bingyi/gf
1
0
Fork 0
mirror of https://gitee.com/johng/gf synced 2026-06-07 02:12:11 +08:00
Code Issues Packages Projects Releases Wiki Activity

improve unit testing for gdb

Browse Source
This commit is contained in:
John
2020-01-06 20:43:59 +08:00
parent c4537b4753
commit f2190e50b2
25 changed files with 318 additions and 7547 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
database/gdb/gdb_mssql.go
View File

@ -3,11 +3,11 @@
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
// 说明：
// 1.需要导入sqlserver驱动： github.com/denisenkom/go-mssqldb
// 2.不支持save/replace方法
// 3.不支持LastInsertId方法
//
// Note:
// 1. It needs manually import: _ "github.com/lib/pq"
// 2. It does not support Save/Replace features.
// 3. It does not support LastInsertId.
package gdb
@ -20,19 +20,19 @@ import (
"github.com/gogf/gf/text/gregex"
)
// 数据库链接对象
type dbMssql struct {
*dbBase
}
// 创建SQL操作对象
func (db *dbMssql) Open(config *ConfigNode) (*sql.DB, error) {
source := ""
if config.LinkInfo != "" {
source = config.LinkInfo
} else {
source = fmt.Sprintf("user id=%s;password=%s;server=%s;port=%s;database=%s;encrypt=disable",
config.User, config.Pass, config.Host, config.Port, config.Name)
source = fmt.Sprintf(
"user id=%s;password=%s;server=%s;port=%s;database=%s;encrypt=disable",
config.User, config.Pass, config.Host, config.Port, config.Name,
)
}
if db, err := sql.Open("sqlserver", source); err == nil {
return db, nil
@ -41,12 +41,10 @@ func (db *dbMssql) Open(config *ConfigNode) (*sql.DB, error) {
}
}
// 获得关键字操作符
func (db *dbMssql) getChars() (charLeft string, charRight string) {
return "\"", "\""
}
// 在执行sql之前对sql进行进一步处理
func (db *dbMssql) handleSqlBeforeExec(query string) string {
index := 0
str, _ := gregex.ReplaceStringFunc("\\?", query, func(s string) string {
@ -59,58 +57,49 @@ func (db *dbMssql) handleSqlBeforeExec(query string) string {
return db.parseSql(str)
}
//将MYSQL的SQL语法转换为MSSQL的语法
//1.由于mssql不支持limit写法所以需要对mysql中的limit用法做转换
func (db *dbMssql) parseSql(sql string) string {
//下面的正则表达式匹配出SELECT和INSERT的关键字后分别做不同的处理，如有LIMIT则将LIMIT的关键字也匹配出
patten := `^\s*(?i)(SELECT)|(LIMIT\s*(\d+)\s*,\s*(\d+))`
if gregex.IsMatchString(patten, sql) == false {
//fmt.Println("not matched..")
return sql
}
res, err := gregex.MatchAllString(patten, sql)
if err != nil {
//fmt.Println("MatchString error.", err)
return ""
}
index := 0
keyword := strings.TrimSpace(res[index][0])
keyword = strings.ToUpper(keyword)
index++
switch keyword {
case "SELECT":
//不含LIMIT关键字则不处理
if len(res) < 2 || (strings.HasPrefix(res[index][0], "LIMIT") == false && strings.HasPrefix(res[index][0], "limit") == false) {
// 不含LIMIT关键字则不处理
if len(res) < 2 ||
(strings.HasPrefix(res[index][0], "LIMIT") == false &&
strings.HasPrefix(res[index][0], "limit") == false) {
break
}
//不含LIMIT则不处理
// 不含LIMIT则不处理
if gregex.IsMatchString("((?i)SELECT)(.+)((?i)LIMIT)", sql) == false {
break
}
//判断SQL中是否含有order by
// 判断SQL中是否含有order by
selectStr := ""
orderbyStr := ""
orderStr := ""
haveOrderby := gregex.IsMatchString("((?i)SELECT)(.+)((?i)ORDER BY)", sql)
if haveOrderby {
//取order by 前面的字符串
// 取order by 前面的字符串
queryExpr, _ := gregex.MatchString("((?i)SELECT)(.+)((?i)ORDER BY)", sql)
if len(queryExpr) != 4 || strings.EqualFold(queryExpr[1], "SELECT") == false || strings.EqualFold(queryExpr[3], "ORDER BY") == false {
break
}
selectStr = queryExpr[2]
//取order by表达式的值
orderbyExpr, _ := gregex.MatchString("((?i)ORDER BY)(.+)((?i)LIMIT)", sql)
if len(orderbyExpr) != 4 || strings.EqualFold(orderbyExpr[1], "ORDER BY") == false || strings.EqualFold(orderbyExpr[3], "LIMIT") == false {
// 取order by表达式的值
orderExpr, _ := gregex.MatchString("((?i)ORDER BY)(.+)((?i)LIMIT)", sql)
if len(orderExpr) != 4 || strings.EqualFold(orderExpr[1], "ORDER BY") == false || strings.EqualFold(orderExpr[3], "LIMIT") == false {
break
}
orderbyStr = orderbyExpr[2]
orderStr = orderExpr[2]
} else {
queryExpr, _ := gregex.MatchString("((?i)SELECT)(.+)((?i)LIMIT)", sql)
if len(queryExpr) != 4 || strings.EqualFold(queryExpr[1], "SELECT") == false || strings.EqualFold(queryExpr[3], "LIMIT") == false {
@ -119,7 +108,7 @@ func (db *dbMssql) parseSql(sql string) string {
selectStr = queryExpr[2]
}
//取limit后面的取值范围
// 取limit后面的取值范围
first, limit := 0, 0
for i := 1; i < len(res[index]); i++ {
if len(strings.TrimSpace(res[index][i])) == 0 {
@ -134,14 +123,22 @@ func (db *dbMssql) parseSql(sql string) string {
}
if haveOrderby {
sql = fmt.Sprintf("SELECT * FROM (SELECT ROW_NUMBER() OVER (ORDER BY %s) as ROWNUMBER_, %s ) as TMP_ WHERE TMP_.ROWNUMBER_ > %d AND TMP_.ROWNUMBER_ <= %d", orderbyStr, selectStr, first, limit)
sql = fmt.Sprintf(
"SELECT * FROM "+
"(SELECT ROW_NUMBER() OVER (ORDER BY %s) as ROWNUMBER_, %s ) as TMP_ "+
"WHERE TMP_.ROWNUMBER_ > %d AND TMP_.ROWNUMBER_ <= %d",
orderStr, selectStr, first, limit,
)
} else {
if first == 0 {
first = limit
} else {
first = limit - first
}
sql = fmt.Sprintf("SELECT * FROM (SELECT TOP %d * FROM (SELECT TOP %d %s) as TMP1_ ) as TMP2_ ", first, limit, selectStr)
sql = fmt.Sprintf(
"SELECT * FROM (SELECT TOP %d * FROM (SELECT TOP %d %s) as TMP1_ ) as TMP2_ ",
first, limit, selectStr,
)
}
default:
}
@ -150,15 +147,14 @@ func (db *dbMssql) parseSql(sql string) string {
// 返回当前数据库所有的数据表名称
// TODO
func (bs *dbMssql) Tables() (tables []string, err error) {
func (db *dbMssql) Tables() (tables []string, err error) {
return
}
// 获得指定表表的数据结构，构造成map哈希表返回，其中键名为表字段名称，键值暂无用途(默认为字段数据类型).
func (db *dbMssql) TableFields(table string) (fields map[string]*TableField, err error) {
// 缓存不存在时会查询数据表结构，缓存后不过期，直至程序重启(重新部署)
v := db.cache.GetOrSetFunc("mssql_table_fields_"+table, func() interface{} {
result := (Result)(nil)
var result Result
result, err = db.GetAll(fmt.Sprintf(`
SELECT c.name as FIELD, CASE t.name
WHEN 'numeric' THEN t.name + '(' + convert(varchar(20),c.xprec) + ',' + convert(varchar(20),c.xscale) + ')'

4
database/gdb/gdb_mysql.go
View File

@ -34,12 +34,12 @@ func (db *dbMysql) Open(config *ConfigNode) (*sql.DB, error) {
}
}
// 获得关键字操作符
// getChars returns the quote chars for field.
func (db *dbMysql) getChars() (charLeft string, charRight string) {
return "`", "`"
}
// 在执行sql之前对sql进行进一步处理
// handleSqlBeforeExec handles the sql before posts it to database.
func (db *dbMysql) handleSqlBeforeExec(query string) string {
return query
}

11
database/gdb/gdb_oracle.go
View File

@ -3,10 +3,11 @@
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
// 说明：
// 1.需要导入oracle驱动： github.com/mattn/go-oci8
// 2.不支持save/replace方法，可以调用这2个方法估计会报错，还没测试过,(应该是可以通过oracle的merge来实现这2个功能的，还没仔细研究)
// 3.不支持LastInsertId方法
//
// Note:
// 1. It needs manually import: _ "github.com/mattn/go-oci8"
// 2. It does not support Save/Replace features.
// 3. It does not support LastInsertId.
package gdb
@ -123,7 +124,7 @@ func (db *dbOracle) parseSql(sql string) string {
// 返回当前数据库所有的数据表名称
// TODO
func (bs *dbOracle) Tables() (tables []string, err error) {
func (db *dbOracle) Tables() (tables []string, err error) {
return
}

27
database/gdb/gdb_pgsql.go
View File

@ -3,6 +3,11 @@
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
//
// Note:
// 1. It needs manually import: _ "github.com/lib/pq"
// 2. It does not support Save/Replace features.
// 3. It does not support LastInsertId.
package gdb
@ -14,26 +19,19 @@ import (
"github.com/gogf/gf/text/gregex"
)
// PostgreSQL的适配.
//
// 使用时需要import:
//
// _ "github.com/lib/pq"
//
// @todo 需要完善replace和save的操作覆盖
// 数据库链接对象
type dbPgsql struct {
*dbBase
}
// 创建SQL操作对象，内部采用了lazy link处理
func (db *dbPgsql) Open(config *ConfigNode) (*sql.DB, error) {
var source string
if config.LinkInfo != "" {
source = config.LinkInfo
} else {
source = fmt.Sprintf("user=%s password=%s host=%s port=%s dbname=%s sslmode=disable", config.User, config.Pass, config.Host, config.Port, config.Name)
source = fmt.Sprintf(
"user=%s password=%s host=%s port=%s dbname=%s sslmode=disable",
config.User, config.Pass, config.Host, config.Port, config.Name,
)
}
if db, err := sql.Open("postgres", source); err == nil {
return db, nil
@ -42,38 +40,33 @@ func (db *dbPgsql) Open(config *ConfigNode) (*sql.DB, error) {
}
}
// 动态切换数据库
func (db *dbPgsql) setSchema(sqlDb *sql.DB, schema string) error {
_, err := sqlDb.Exec("SET search_path TO " + schema)
return err
}
// 获得关键字操作符
func (db *dbPgsql) getChars() (charLeft string, charRight string) {
return "\"", "\""
}
// 在执行sql之前对sql进行进一步处理
func (db *dbPgsql) handleSqlBeforeExec(query string) string {
index := 0
query, _ = gregex.ReplaceStringFunc("\\?", query, func(s string) string {
index++
return fmt.Sprintf("$%d", index)
})
// 分页语法替换
query, _ = gregex.ReplaceString(` LIMIT (\d+),\s*(\d+)`, ` LIMIT $1 OFFSET $2`, query)
return query
}
// 返回当前数据库所有的数据表名称
// TODO
func (bs *dbPgsql) Tables() (tables []string, err error) {
func (db *dbPgsql) Tables() (tables []string, err error) {
return
}
// 获得指定表表的数据结构，构造成map哈希表返回，其中键名为表字段名称，键值为字段数据结构.
func (db *dbPgsql) TableFields(table string) (fields map[string]*TableField, err error) {
// 缓存不存在时会查询数据表结构，缓存后不过期，直至程序重启(重新部署)
table, _ = gregex.ReplaceString("\"", "", table)
v := db.cache.GetOrSetFunc("pgsql_table_fields_"+table, func() interface{} {
result := (Result)(nil)

14
database/gdb/gdb_sqlite.go
View File

@ -3,6 +3,10 @@
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
//
// Note:
// 1. It needs manually import: _ "github.com/mattn/go-sqlite3"
// 2. It does not support Save/Replace features.
package gdb
@ -10,13 +14,6 @@ import (
"database/sql"
)
// 使用时需要import:
// _ "github.com/mattn/go-sqlite3"
// Sqlite接口对象
// @author wxkj<wxscz@qq.com>
// 数据库链接对象
type dbSqlite struct {
*dbBase
}
@ -35,14 +32,13 @@ func (db *dbSqlite) Open(config *ConfigNode) (*sql.DB, error) {
}
}
// 获得关键字操作符
func (db *dbSqlite) getChars() (charLeft string, charRight string) {
return "`", "`"
}
// 返回当前数据库所有的数据表名称
// TODO
func (bs *dbSqlite) Tables() (tables []string, err error) {
func (db *dbSqlite) Tables() (tables []string, err error) {
return
}

109
database/gdb/gdb_unit_init_mssql_test.go
View File

@ -1,109 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb_test
import (
"fmt"
"github.com/gogf/gf/container/garray"
"github.com/gogf/gf/database/gdb"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
)
var (
msdb gdb.DB
)
func InitMssql() {
node := gdb.ConfigNode{
Host: "127.0.0.1",
Port: "1433",
User: "sa",
Pass: "123456",
Name: "test",
Type: "mssql",
Role: "master",
Charset: "utf8",
Weight: 1,
MaxIdleConnCount: 10,
MaxOpenConnCount: 10,
MaxConnLifetime: 600,
}
gdb.AddConfigNode("mssqlGroup", node)
gdb.AddConfigNode("mssqlGroup", node)
if r, err := gdb.New("mssqlGroup"); err != nil {
gtest.Fatal(err)
} else {
msdb = r
}
createTableMssql("t_user")
//msdb.SetDebug(true)
}
func createTableMssql(table ...string) (name string) {
if len(table) > 0 {
name = table[0]
} else {
name = fmt.Sprintf("user_%d", gtime.Nanosecond())
}
dropTableMssql(name)
if _, err := msdb.Exec(fmt.Sprintf(`
IF NOT EXISTS (SELECT * FROM sysobjects WHERE name='%s' and xtype='U')
CREATE TABLE %s (
ID numeric(10,0) NOT NULL,
PASSPORT VARCHAR(45) NOT NULL,
PASSWORD CHAR(32) NOT NULL,
NICKNAME VARCHAR(45) NOT NULL,
CREATE_TIME datetime NOT NULL,
PRIMARY KEY (ID))
`, name, name)); err != nil {
gtest.Fatal(err)
}
//msdb.Exec("DROP DATABASE test")
//msdb.Exec("CREATE DATABASE test")
msdb.SetSchema("test")
//msdb.SetDebug(true)
return
}
func createInitTableMssql(table ...string) (name string) {
name = createTableMssql(table...)
array := garray.New(true)
for i := 1; i <= INIT_DATA_SIZE; i++ {
array.Append(g.Map{
"id": i,
"passport": fmt.Sprintf(`t%d`, i),
"password": fmt.Sprintf(`p%d`, i),
"nickname": fmt.Sprintf(`T%d`, i),
"create_time": gtime.Now().String(),
})
}
result, err := msdb.Table(name).Data(array.Slice()).Insert()
gtest.Assert(err, nil)
n, e := result.RowsAffected()
gtest.Assert(e, nil)
gtest.Assert(n, INIT_DATA_SIZE)
return
}
func dropTableMssql(table string) {
if _, err := msdb.Exec(fmt.Sprintf(`
IF EXISTS (SELECT * FROM sysobjects WHERE name='%s' and xtype='U')
DROP TABLE %s
`, table, table)); err != nil {
gtest.Fatal(err)
}
}

144
database/gdb/gdb_unit_init_mysql_test.go
View File

@ -1,144 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb_test
import (
"fmt"
"github.com/gogf/gf/container/garray"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/database/gdb"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
)
const (
INIT_DATA_SIZE = 10
TABLE = "user"
SCHEMA1 = "test1"
SCHEMA2 = "test2"
PREFIX1 = "gf_"
)
var (
db gdb.DB
dbPrefix gdb.DB
)
func InitMysql() {
nodeDefault := gdb.ConfigNode{
Host: "127.0.0.1",
Port: "3306",
User: "root",
Pass: "12345678",
Name: "",
Type: "mysql",
Role: "master",
Charset: "utf8",
Weight: 1,
MaxIdleConnCount: 10,
MaxOpenConnCount: 10,
MaxConnLifetime: 600,
}
nodePrefix := nodeDefault
nodePrefix.Prefix = PREFIX1
gdb.AddConfigNode("test", nodeDefault)
gdb.AddConfigNode("prefix", nodePrefix)
gdb.AddConfigNode(gdb.DEFAULT_GROUP_NAME, nodeDefault)
// Default db.
if r, err := gdb.New(); err != nil {
gtest.Error(err)
} else {
db = r
}
schemaTemplate := "CREATE DATABASE IF NOT EXISTS `%s` CHARACTER SET UTF8"
if _, err := db.Exec(fmt.Sprintf(schemaTemplate, SCHEMA1)); err != nil {
gtest.Error(err)
}
if _, err := db.Exec(fmt.Sprintf(schemaTemplate, SCHEMA2)); err != nil {
gtest.Error(err)
}
db.SetSchema(SCHEMA1)
createTable(TABLE)
// Prefix db.
if r, err := gdb.New("prefix"); err != nil {
gtest.Error(err)
} else {
dbPrefix = r
}
if _, err := dbPrefix.Exec(fmt.Sprintf(schemaTemplate, SCHEMA1)); err != nil {
gtest.Error(err)
}
if _, err := dbPrefix.Exec(fmt.Sprintf(schemaTemplate, SCHEMA2)); err != nil {
gtest.Error(err)
}
dbPrefix.SetSchema(SCHEMA1)
createTable(TABLE)
}
func createTable(table ...string) string {
return createTableWithDb(db, table...)
}
func createInitTable(table ...string) string {
return createInitTableWithDb(db, table...)
}
func dropTable(table string) {
dropTableWithDb(db, table)
}
func createTableWithDb(db gdb.DB, table ...string) (name string) {
if len(table) > 0 {
name = table[0]
} else {
name = fmt.Sprintf(`%s_%d`, TABLE, gtime.Nanosecond())
}
dropTableWithDb(db, name)
if _, err := db.Exec(fmt.Sprintf(`
CREATE TABLE %s (
id int(10) unsigned NOT NULL AUTO_INCREMENT,
passport varchar(45) NULL,
password char(32) NULL,
nickname varchar(45) NULL,
create_time timestamp NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
`, name)); err != nil {
gtest.Error(err)
}
return
}
func createInitTableWithDb(db gdb.DB, table ...string) (name string) {
name = createTableWithDb(db, table...)
array := garray.New(true)
for i := 1; i <= INIT_DATA_SIZE; i++ {
array.Append(g.Map{
"id": i,
"passport": fmt.Sprintf(`user_%d`, i),
"password": fmt.Sprintf(`pass_%d`, i),
"nickname": fmt.Sprintf(`name_%d`, i),
"create_time": gtime.NewFromStr("2018-10-24 10:00:00").String(),
})
}
result, err := db.BatchInsert(name, array.Slice())
gtest.Assert(err, nil)
n, e := result.RowsAffected()
gtest.Assert(e, nil)
gtest.Assert(n, INIT_DATA_SIZE)
return
}
func dropTableWithDb(db gdb.DB, table string) {
if _, err := db.Exec(fmt.Sprintf("DROP TABLE IF EXISTS `%s`", table)); err != nil {
gtest.Error(err)
}
}

108
database/gdb/gdb_unit_init_oracle_test.go
View File

@ -1,108 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb_test
import (
"fmt"
"github.com/gogf/gf/container/garray"
"github.com/gogf/gf/database/gdb"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
"strings"
)
var (
oradb gdb.DB
)
func InitOracle() {
node := gdb.ConfigNode{
Host: "192.168.146.0",
Port: "1521",
User: "scott",
Pass: "tiger",
Name: "orcl",
Type: "oracle",
Role: "master",
MaxIdleConnCount: 10,
MaxOpenConnCount: 10,
MaxConnLifetime: 600,
}
node1 := node
node1.LinkInfo = fmt.Sprintf("%s/%s@%s", node.User, node.Pass, node.Name)
gdb.AddConfigNode("oracleNode", node)
gdb.AddConfigNode("oracleNode", node)
if r, err := gdb.New("oracleNode"); err != nil {
gtest.Fatal(err)
} else {
oradb = r
}
createTableOracle("t_user")
}
func createTableOracle(table ...string) (name string) {
if len(table) > 0 {
name = table[0]
} else {
name = fmt.Sprintf("t_user_%d", gtime.Nanosecond())
}
dropTableOracle(name)
if _, err := oradb.Exec(fmt.Sprintf(`
CREATE TABLE %s (
ID NUMBER(10) NOT NULL,
PASSPORT VARCHAR(45) NOT NULL,
PASSWORD CHAR(32) NOT NULL,
NICKNAME VARCHAR(45) NOT NULL,
CREATE_TIME varchar(45) NOT NULL,
PRIMARY KEY (ID))
`, name)); err != nil {
gtest.Fatal(err)
}
return
}
func createInitTableOracle(table ...string) (name string) {
name = createTableOracle(table...)
array := garray.New(true)
for i := 1; i <= INIT_DATA_SIZE; i++ {
array.Append(g.Map{
"id": i,
"passport": fmt.Sprintf(`t%d`, i),
"password": fmt.Sprintf(`p%d`, i),
"nickname": fmt.Sprintf(`T%d`, i),
"create_time": gtime.Now().String(),
})
}
result, err := oradb.Table(name).Data(array.Slice()).Insert()
gtest.Assert(err, nil)
n, e := result.RowsAffected()
gtest.Assert(e, nil)
gtest.Assert(n, INIT_DATA_SIZE)
return
}
func dropTableOracle(table string) {
count, err := oradb.GetCount("SELECT COUNT(*) FROM USER_TABLES WHERE TABLE_NAME = ?", strings.ToUpper(table))
if err != nil {
gtest.Fatal(err)
}
if count == 0 {
return
}
if _, err := oradb.Exec(fmt.Sprintf("DROP TABLE %s", table)); err != nil {
gtest.Fatal(err)
}
}

112
database/gdb/gdb_unit_init_pgsql_test.go
View File

@ -1,112 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb_test
import (
"fmt"
"github.com/gogf/gf/container/garray"
"github.com/gogf/gf/database/gdb"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
)
var (
pgdb gdb.DB
)
func InitPgsql() {
node := gdb.ConfigNode{
Host: "127.0.0.1",
Port: "5432",
User: "postgres",
Pass: "password",
Name: "travis_ci_test",
Type: "pgsql",
Role: "master",
Charset: "utf8",
Weight: 1,
MaxIdleConnCount: 10,
MaxOpenConnCount: 10,
MaxConnLifetime: 600,
}
gdb.AddConfigNode("pgsqlNode", node)
gdb.AddConfigNode("pgsqlNode", node)
if r, err := gdb.New("pgsqlNode"); err != nil {
gtest.Fatal(err)
} else {
pgdb = r
}
/*if _, err := pgdb.Exec(fmt.Sprintf("drop database if exists %s", SCHEMA1)); err != nil {
gtest.Error(err)
}
schemaTemplate := "CREATE DATABASE %s"
if _, err := pgdb.Exec(fmt.Sprintf(schemaTemplate, SCHEMA1)); err != nil {
gtest.Error(err)
}
if _, err := pgdb.Exec(fmt.Sprintf("SET search_path TO %s", SCHEMA1)); err != nil {
gtest.Error(err)
}
pgdb.SetSchema(SCHEMA1)
*/
// 创建默认用户表
createTablePgsql("t_user")
}
func createTablePgsql(table ...string) (name string) {
if len(table) > 0 {
name = table[0]
} else {
name = fmt.Sprintf(`user_%d`, gtime.Nanosecond())
}
dropTablePgsql(name)
if _, err := pgdb.Exec(fmt.Sprintf(`
CREATE TABLE %s (
id bigint NOT NULL,
passport varchar(45),
password char(32) NOT NULL,
nickname varchar(45) NOT NULL,
create_time timestamp NOT NULL,
PRIMARY KEY (id)
) ;
`, name)); err != nil {
gtest.Fatal(err)
}
return
}
func createInitTablePgsql(table ...string) (name string) {
name = createTablePgsql(table...)
array := garray.New(true)
for i := 1; i <= INIT_DATA_SIZE; i++ {
array.Append(g.Map{
"id": i,
"passport": fmt.Sprintf(`t%d`, i),
"password": fmt.Sprintf(`p%d`, i),
"nickname": fmt.Sprintf(`T%d`, i),
"create_time": gtime.Now().String(),
})
}
result, err := pgdb.Table(name).Data(array.Slice()).Insert()
gtest.Assert(err, nil)
n, e := result.RowsAffected()
gtest.Assert(e, nil)
gtest.Assert(n, INIT_DATA_SIZE)
return
}
func dropTablePgsql(table string) {
if _, err := pgdb.Exec(fmt.Sprintf("DROP TABLE IF EXISTS %s", table)); err != nil {
gtest.Fatal(err)
}
}

205
database/gdb/gdb_unit_init_test.go
View File

@ -7,15 +7,204 @@
package gdb_test
import (
// _ "github.com/denisenkom/go-mssqldb"
// _ "github.com/lib/pq"
// _ "github.com/mattn/go-oci8"
_ "github.com/gogf/gf/database/gdb"
"fmt"
"github.com/gogf/gf/container/garray"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/os/gcmd"
"github.com/gogf/gf/database/gdb"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
)
const (
SIZE = 10
TABLE = "user"
SCHEMA1 = "test1"
SCHEMA2 = "test2"
PREFIX1 = "gf_"
)
var (
db gdb.DB
dbPrefix gdb.DB
configNode gdb.ConfigNode
)
func init() {
//InitPgsql()
//InitOracle()
//InitMssql()
InitMysql()
parser, err := gcmd.Parse(g.MapStrBool{
"name": true,
"type": true,
}, false)
gtest.Assert(err, nil)
configNode = gdb.ConfigNode{
Host: "127.0.0.1",
Port: "3306",
User: "root",
Pass: "12345678",
Name: parser.GetOpt("name", ""),
Type: parser.GetOpt("type", "mysql"),
Role: "master",
Charset: "utf8",
Weight: 1,
MaxIdleConnCount: 10,
MaxOpenConnCount: 10,
MaxConnLifetime: 600,
}
nodePrefix := configNode
nodePrefix.Prefix = PREFIX1
gdb.AddConfigNode("test", configNode)
gdb.AddConfigNode("prefix", nodePrefix)
gdb.AddConfigNode(gdb.DEFAULT_GROUP_NAME, configNode)
// Default db.
if r, err := gdb.New(); err != nil {
gtest.Error(err)
} else {
db = r
}
schemaTemplate := "CREATE DATABASE IF NOT EXISTS `%s` CHARACTER SET UTF8"
if _, err := db.Exec(fmt.Sprintf(schemaTemplate, SCHEMA1)); err != nil {
gtest.Error(err)
}
if _, err := db.Exec(fmt.Sprintf(schemaTemplate, SCHEMA2)); err != nil {
gtest.Error(err)
}
db.SetSchema(SCHEMA1)
createTable(TABLE)
// Prefix db.
if r, err := gdb.New("prefix"); err != nil {
gtest.Error(err)
} else {
dbPrefix = r
}
if _, err := dbPrefix.Exec(fmt.Sprintf(schemaTemplate, SCHEMA1)); err != nil {
gtest.Error(err)
}
if _, err := dbPrefix.Exec(fmt.Sprintf(schemaTemplate, SCHEMA2)); err != nil {
gtest.Error(err)
}
dbPrefix.SetSchema(SCHEMA1)
createTable(TABLE)
}
func createTable(table ...string) string {
return createTableWithDb(db, table...)
}
func createInitTable(table ...string) string {
return createInitTableWithDb(db, table...)
}
func dropTable(table string) {
dropTableWithDb(db, table)
}
func createTableWithDb(db gdb.DB, table ...string) (name string) {
if len(table) > 0 {
name = table[0]
} else {
name = fmt.Sprintf(`%s_%d`, TABLE, gtime.TimestampNano())
}
dropTableWithDb(db, name)
switch configNode.Type {
case "sqlite":
if _, err := db.Exec(fmt.Sprintf(`
CREATE TABLE %s (
id bigint NOT NULL,
passport varchar(45),
password char(32) NOT NULL,
nickname varchar(45) NOT NULL,
create_time timestamp NOT NULL,
PRIMARY KEY (id)
) ;`, name,
)); err != nil {
gtest.Fatal(err)
}
case "pgsql":
if _, err := db.Exec(fmt.Sprintf(`
CREATE TABLE %s (
id bigint NOT NULL,
passport varchar(45),
password char(32) NOT NULL,
nickname varchar(45) NOT NULL,
create_time timestamp NOT NULL,
PRIMARY KEY (id)
) ;`, name,
)); err != nil {
gtest.Fatal(err)
}
case "mssql":
if _, err := db.Exec(fmt.Sprintf(`
IF NOT EXISTS (SELECT * FROM sysobjects WHERE name='%s' and xtype='U')
CREATE TABLE %s (
ID numeric(10,0) NOT NULL,
PASSPORT VARCHAR(45) NOT NULL,
PASSWORD CHAR(32) NOT NULL,
NICKNAME VARCHAR(45) NOT NULL,
CREATE_TIME datetime NOT NULL,
PRIMARY KEY (ID))`,
name, name,
)); err != nil {
gtest.Fatal(err)
}
case "oracle":
if _, err := db.Exec(fmt.Sprintf(`
CREATE TABLE %s (
ID NUMBER(10) NOT NULL,
PASSPORT VARCHAR(45) NOT NULL,
PASSWORD CHAR(32) NOT NULL,
NICKNAME VARCHAR(45) NOT NULL,
CREATE_TIME varchar(45) NOT NULL,
PRIMARY KEY (ID))
`, name,
)); err != nil {
gtest.Fatal(err)
}
case "mysql":
if _, err := db.Exec(fmt.Sprintf(`
CREATE TABLE %s (
id int(10) unsigned NOT NULL AUTO_INCREMENT,
passport varchar(45) NULL,
password char(32) NULL,
nickname varchar(45) NULL,
create_time timestamp NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
`, name,
)); err != nil {
gtest.Fatal(err)
}
}
return
}
func createInitTableWithDb(db gdb.DB, table ...string) (name string) {
name = createTableWithDb(db, table...)
array := garray.New(true)
for i := 1; i <= SIZE; i++ {
array.Append(g.Map{
"id": i,
"passport": fmt.Sprintf(`user_%d`, i),
"password": fmt.Sprintf(`pass_%d`, i),
"nickname": fmt.Sprintf(`name_%d`, i),
"create_time": gtime.NewFromStr("2018-10-24 10:00:00").String(),
})
}
result, err := db.BatchInsert(name, array.Slice())
gtest.Assert(err, nil)
n, e := result.RowsAffected()
gtest.Assert(e, nil)
gtest.Assert(n, SIZE)
return
}
func dropTableWithDb(db gdb.DB, table string) {
if _, err := db.Exec(fmt.Sprintf("DROP TABLE IF EXISTS `%s`", table)); err != nil {
gtest.Error(err)
}
}

708
database/gdb/gdb_unit_z_mssql_method_test.go
View File

@ -1,708 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb_test
import (
"fmt"
"testing"
"time"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
)
func Test_DB_Ping_Mssql(t *testing.T) {
if msdb == nil {
return
}
gtest.Case(t, func() {
err1 := msdb.PingMaster()
err2 := msdb.PingSlave()
gtest.Assert(err1, nil)
gtest.Assert(err2, nil)
})
}
func Test_DB_Query_Mssql(t *testing.T) {
if msdb == nil {
return
}
if _, err := msdb.Query("SELECT 1"); err != nil {
gtest.Fatal(err)
}
if _, err := msdb.Query("ERROR"); err == nil {
gtest.Fatal("FAIL")
}
}
func Test_DB_Exec_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
if _, err := msdb.Exec(fmt.Sprintf("UPDATE %s SET NICKNAME=? WHERE ID IN(1,2,3)", table), "LYZ"); err != nil {
gtest.Fatal(err)
}
if _, err := msdb.Exec("ERROR"); err == nil {
gtest.Fatal("FAIL")
}
}
func Test_DB_Prepare_Mssql(t *testing.T) {
if msdb == nil {
return
}
gtest.Case(t, func() {
st, err := msdb.Prepare("SELECT 100 as aa")
if err != nil {
gtest.Fatal(err)
}
rows, err := st.Query()
if err != nil {
gtest.Fatal(err)
}
array, err := rows.Columns()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(array[0], "aa")
if err := rows.Close(); err != nil {
gtest.Fatal(err)
}
})
}
func Test_DB_Insert_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createTableMssql()
defer dropTableMssql(table)
if _, err := msdb.Insert(table, g.Map{
"id": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
}); err != nil {
gtest.Fatal(err)
}
// normal map
result, err := msdb.Insert(table, map[interface{}]interface{}{
"id": "2",
"passport": "t2",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
})
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
// struct
type User struct {
Id int `gconv:"id"`
Passport string `json:"passport"`
Password string `gconv:"password"`
Nickname string `gconv:"nickname"`
CreateTime string `json:"create_time"`
}
result, err = msdb.Insert(table, User{
Id: 3,
Passport: "t3",
Password: "25d55ad283aa400af464c76d713c07ad",
Nickname: "T3",
CreateTime: gtime.Now().String(),
})
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
value, err := msdb.GetValue(fmt.Sprintf(`select passport from %s where id=?`, table), 3)
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t3")
// *struct
result, err = msdb.Insert(table, &User{
Id: 4,
Passport: "t4",
Password: "25d55ad283aa400af464c76d713c07ad",
Nickname: "T4",
CreateTime: gtime.Now().String(),
})
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
value, err = msdb.GetValue(fmt.Sprintf("select passport from %s where id=?", table), 4)
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t4")
// batch with Insert
if r, err := msdb.Insert(table, []interface{}{
map[interface{}]interface{}{
"id": 200,
"passport": "t200",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T200",
"create_time": gtime.Now().String(),
},
map[interface{}]interface{}{
"id": 300,
"passport": "t300",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T300",
"create_time": gtime.Now().String(),
},
}); err != nil {
gtest.Fatal(err)
} else {
n, _ := r.RowsAffected()
gtest.Assert(n, 2)
}
// clear unnecessary data
result, err = msdb.Delete(table, "id>?", 1)
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 5)
}
func Test_DB_BatchInsert_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createTableMssql()
defer dropTableMssql(table)
gtest.Case(t, func() {
if r, err := msdb.BatchInsert(table, g.List{
{
"id": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
},
{
"id": 2,
"passport": "t2",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
},
{
"id": 3,
"passport": "t3",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T3",
"create_time": gtime.Now().String(),
},
{
"id": 4,
"passport": "t4",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T4",
"create_time": gtime.Now().String(),
},
{
"id": 5,
"passport": "t5",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T5",
"create_time": gtime.Now().String(),
},
{
"id": 6,
"passport": "t6",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T6",
"create_time": gtime.Now().String(),
},
{
"id": 7,
"passport": "t7",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T7",
"create_time": gtime.Now().String(),
},
{
"id": 8,
"passport": "t8",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T8",
"create_time": gtime.Now().String(),
},
}, 3); err != nil {
gtest.Fatal(err)
} else {
n, _ := r.RowsAffected()
gtest.Assert(n, 8)
}
result, err := msdb.Delete(table, "id>=?", 1)
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 8)
// []interface{}
if r, err := msdb.BatchInsert(table, []interface{}{
map[interface{}]interface{}{
"id": 11,
"passport": "t11",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T11",
"create_time": gtime.Now().String(),
},
map[interface{}]interface{}{
"id": 12,
"passport": "t12",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T12",
"create_time": gtime.Now().String(),
},
map[interface{}]interface{}{
"id": 13,
"passport": "t13",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T13",
"create_time": gtime.Now().String(),
},
map[interface{}]interface{}{
"id": 14,
"passport": "t14",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T14",
"create_time": gtime.Now().String(),
},
map[interface{}]interface{}{
"id": 15,
"passport": "t15",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T15",
"create_time": gtime.Now().String(),
},
}, 2); err != nil {
gtest.Fatal(err)
} else {
n, _ := r.RowsAffected()
gtest.Assert(n, 5)
}
})
// batch insert map
gtest.Case(t, func() {
result, err := msdb.BatchInsert(table, g.Map{
"id": 20,
"passport": "t20",
"password": "p20",
"nickname": "T20",
"create_time": gtime.Now().String(),
})
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
})
// batch insert struct
gtest.Case(t, func() {
type User struct {
Id int `gconv:"id"`
Passport string `gconv:"passport"`
Password string `gconv:"password"`
NickName string `gconv:"nickname"`
CreateTime *gtime.Time `gconv:"create_time"`
}
user := &User{
Id: 30,
Passport: "t30",
Password: "p30",
NickName: "T30",
CreateTime: gtime.Now(),
}
result, err := msdb.BatchInsert(table, user)
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
})
}
func Test_DB_Update_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
if result, err := msdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=1"); err != nil {
gtest.Fatal(err)
} else {
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
if result, err := msdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=10"); err != nil {
gtest.Fatal(err)
} else {
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
}
func Test_DB_GetAll_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
gtest.Case(t, func() {
result, err := msdb.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1)
gtest.Assert(err, nil)
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["ID"].Int(), 1)
})
gtest.Case(t, func() {
result, err := msdb.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), g.Slice{1})
gtest.Assert(err, nil)
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["ID"].Int(), 1)
})
gtest.Case(t, func() {
result, err := msdb.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id in(?) order by id ", table), g.Slice{1, 2, 3})
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[1]["ID"].Int(), 2)
gtest.Assert(result[2]["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := msdb.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id in(?,?,?) order by id ", table), g.Slice{1, 2, 3})
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[1]["ID"].Int(), 2)
gtest.Assert(result[2]["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := msdb.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id in(?,?,?) order by id ", table), g.Slice{1, 2, 3}...)
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[1]["ID"].Int(), 2)
gtest.Assert(result[2]["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := msdb.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id>=? AND id <=? order by id ", table), g.Slice{1, 3})
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[1]["ID"].Int(), 2)
gtest.Assert(result[2]["ID"].Int(), 3)
})
}
func Test_DB_GetOne_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
if record, err := msdb.GetOne(fmt.Sprintf("SELECT * FROM %s WHERE passport=?", table), "t1"); err != nil {
gtest.Fatal(err)
} else {
if record == nil {
gtest.Fatal("FAIL")
}
gtest.Assert(record["NICKNAME"].String(), "T1")
}
}
func Test_DB_GetValue_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
if value, err := msdb.GetValue(fmt.Sprintf("SELECT id FROM %s WHERE passport=?", table), "t2"); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(value.Int(), 2)
}
}
func Test_DB_GetCount_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
if count, err := msdb.GetCount(fmt.Sprintf("SELECT * FROM %s", table)); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(count, 10)
}
}
func Test_DB_GetStruct_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
if result, err := msdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=1"); err != nil {
gtest.Fatal(err)
} else {
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
user := new(User)
if err := msdb.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
}
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
if err := msdb.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
}
})
}
func Test_DB_GetStructs_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
if err := msdb.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? and id <=? order by id", table), 2, 3); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), 2)
gtest.Assert(users[0].Id, 2)
gtest.Assert(users[1].Id, 3)
gtest.Assert(users[0].NickName, "T2")
gtest.Assert(users[1].NickName, "T3")
})
}
func Test_DB_GetScan_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
if result, err := msdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=1"); err != nil {
gtest.Fatal(err)
} else {
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
user := new(User)
if err := msdb.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
}
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
if err := msdb.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
}
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
if err := msdb.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? and id <=?", table), 1, 2); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), 2)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[0].CreateTime.String(), "2010-10-10 00:00:01")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []User
if err := msdb.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? and id <=?", table), 1, 2); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), 2)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[0].CreateTime.String(), "2010-10-10 00:00:01")
})
}
func Test_DB_Delete_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
if result, err := msdb.Delete(table, nil); err != nil {
gtest.Fatal(err)
} else {
n, _ := result.RowsAffected()
gtest.Assert(n, 10)
}
}
func Test_DB_Time_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createTableMssql()
defer dropTableMssql(table)
gtest.Case(t, func() {
result, err := msdb.Insert(table, g.Map{
"id": 200,
"passport": "t200",
"password": "123456",
"nickname": "T200",
"create_time": time.Now(),
})
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
value, err := msdb.GetValue(fmt.Sprintf("select passport from %s where id=?", table), 200)
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t200")
})
gtest.Case(t, func() {
t := time.Now()
result, err := msdb.Insert(table, g.Map{
"id": 300,
"passport": "t300",
"password": "123456",
"nickname": "T300",
"create_time": &t,
})
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
value, err := msdb.GetValue(fmt.Sprintf("select passport from %s where id=?", table), 300)
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t300")
})
if result, err := msdb.Delete(table, nil); err != nil {
gtest.Fatal(err)
} else {
n, _ := result.RowsAffected()
gtest.Assert(n, 2)
}
}

926
database/gdb/gdb_unit_z_mssql_model_test.go
View File

@ -1,926 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb_test
import (
"database/sql"
"fmt"
"testing"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
)
// 基本测试
func Test_Model_Insert_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createTableMssql()
defer dropTableMssql(table)
result, err := msdb.Table(table).Filter().Data(g.Map{
"id": 1,
"uid": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
}).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
result, err = msdb.Table(table).Filter().Data(map[interface{}]interface{}{
"id": "2",
"uid": "2",
"passport": "t2",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
}).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
type t_user struct {
Id int `gconv:"id"`
Uid int `gconv:"uid"`
Passport string `json:"passport"`
Password string `gconv:"password"`
Nickname string `gconv:"nickname"`
CreateTime string `json:"create_time"`
}
result, err = msdb.Table(table).Filter().Data(t_user{
Id: 3,
Uid: 3,
Passport: "t3",
Password: "25d55ad283aa400af464c76d713c07ad",
Nickname: "T3",
CreateTime: gtime.Now().String(),
}).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
value, err := msdb.Table(table).Fields("passport").Where("id=3").Value()
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t3")
result, err = msdb.Table(table).Filter().Data(&t_user{
Id: 4,
Uid: 4,
Passport: "t4",
Password: "25d55ad283aa400af464c76d713c07ad",
Nickname: "T4",
CreateTime: gtime.Now().String(),
}).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
value, err = msdb.Table(table).Fields("passport").Where("id=4").Value()
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t4")
result, err = msdb.Table(table).Where("id>?", 1).Delete()
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 3)
}
func Test_Model_Batch_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createTableMssql()
defer dropTableMssql(table)
// batch insert
gtest.Case(t, func() {
result, err := msdb.Table(table).Filter().Data(g.List{
{
"id": 2,
"uid": 2,
"passport": "t2",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
},
{
"id": 3,
"uid": 3,
"passport": "t3",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T3",
"create_time": gtime.Now().String(),
},
}).Batch(1).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 2)
})
// batch save
/*gtest.Case(t, func() {
table := createInitTableMssql()
defer dropTableMssql(table)
result, err := msdb.Table(table).All()
gtest.Assert(err, nil)
gtest.Assert(len(result), INIT_DATA_SIZE)
for _, v := range result {
v["NICKNAME"].Set(v["NICKNAME"].String() + v["ID"].String())
}
r, e := msdb.Table(table).Data(result).Save()
gtest.Assert(e, nil)
n, e := r.RowsAffected()
gtest.Assert(e, nil)
gtest.Assert(n, INIT_DATA_SIZE)
})
// batch replace
gtest.Case(t, func() {
table := createInitTableMssql()
defer dropTableMssql(table)
result, err := msdb.Table(table).All()
gtest.Assert(err, nil)
gtest.Assert(len(result), INIT_DATA_SIZE)
for _, v := range result {
v["NICKNAME"].Set(v["NICKNAME"].String() + v["ID"].String())
}
r, e := msdb.Table(table).Data(result).Replace()
gtest.Assert(e, nil)
n, e := r.RowsAffected()
gtest.Assert(e, nil)
gtest.Assert(n, INIT_DATA_SIZE)
})*/
}
/*
func Test_Model_Replace_Mssql(t *testing.T) {
if msdb == nil {
return
}
result, err := msdb.Table(table).Data(g.Map{
"id": 1,
"passport": "t11",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T11",
"create_time": "2018-10-10 00:01:10",
}).Replace()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
func Test_Model_Save_Mssql(t *testing.T) {
if msdb == nil {
return
}
result, err := msdb.Table(table).Data(g.Map{
"id": 1,
"passport": "t111",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T111",
"create_time": "2018-10-10 00:01:10",
}).Save()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
*/
func Test_Model_Update_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
gtest.Case(t, func() {
result, err := msdb.Table(table).Data("nickname", "T100").Where("id", 10).Update()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
v1, err := msdb.Table(table).Fields("nickname").Where("id", 10).Value()
gtest.Assert(err, nil)
gtest.Assert(v1.String(), "T100")
v2, err := msdb.Table(table).Fields("nickname").Where("id", 8).Value()
gtest.Assert(err, nil)
gtest.Assert(v2.String(), "T8")
})
gtest.Case(t, func() {
result, err := msdb.Table(table).Data("passport", "t22").Where("passport=?", "t2").Update()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
})
gtest.Case(t, func() {
result, err := msdb.Table(table).Data("passport", "t2").Where("passport='t22'").Update()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
})
}
func Test_Model_Clone_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
md := msdb.Table(table).Where("id IN(?)", g.Slice{1, 3})
count, err := md.Count()
if err != nil {
gtest.Fatal(err)
}
record, err := md.OrderBy("id DESC").One()
if err != nil {
gtest.Fatal(err)
}
result, err := md.OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 2)
gtest.Assert(record["ID"].Int(), 3)
gtest.Assert(len(result), 2)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[1]["ID"].Int(), 3)
}
func Test_Model_Safe_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
gtest.Case(t, func() {
md := msdb.Table(table).Safe(false).Where("id IN(?)", g.Slice{1, 3})
count, err := md.Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 2)
md.And("id = ?", 1)
count, err = md.Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 1)
})
gtest.Case(t, func() {
md := msdb.Table(table).Safe(true).Where("id IN(?)", g.Slice{1, 3})
count, err := md.Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 2)
md.And("id = ?", 1)
count, err = md.Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 2)
})
}
func Test_Model_All_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
result, err := msdb.Table(table).All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), INIT_DATA_SIZE)
}
func Test_Model_One_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
record, err := msdb.Table(table).Where("id", 1).One()
if err != nil {
gtest.Fatal(err)
}
if record == nil {
gtest.Fatal("FAIL")
}
gtest.Assert(record["NICKNAME"].String(), "T1")
}
func Test_Model_Value_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
value, err := msdb.Table(table).Fields("nickname").Where("id", 1).Value()
if err != nil {
gtest.Fatal(err)
}
if value == nil {
gtest.Fatal("FAIL")
}
gtest.Assert(value.String(), "T1")
}
func Test_Model_Count_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
count, err := msdb.Table(table).Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, INIT_DATA_SIZE)
}
func Test_Model_Select_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
result, err := msdb.Table(table).Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), INIT_DATA_SIZE)
}
func Test_Model_Struct_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
gtest.Case(t, func() {
res, err := msdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
if err != nil {
gtest.Fatal(err)
}
n, _ := res.RowsAffected()
gtest.Assert(n, 1)
res, err = msdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 2).Update()
if err != nil {
gtest.Fatal(err)
}
n, _ = res.RowsAffected()
gtest.Assert(n, 1)
})
gtest.Case(t, func() {
res, err := msdb.Table(table).Data(g.Map{
"nickname": "T111",
}).Where("id = ?", 1).Update()
if err != nil {
gtest.Fatal(err)
}
n, _ := res.RowsAffected()
gtest.Assert(n, 1)
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
user := new(User)
err := msdb.Table(table).Where("id=1").Struct(user)
if err != nil {
gtest.Fatal(err)
}
fmt.Println("id=1 ", user.CreateTime.String())
gtest.Assert(user.NickName, "T111")
gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
err := msdb.Table(table).Where("id=2").Struct(user)
if err != nil {
gtest.Fatal(err)
}
fmt.Println("id=2 ", user.CreateTime.String())
gtest.Assert(user.NickName, "T2")
gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
err := msdb.Table(table).Where("id=-1").Struct(user)
gtest.Assert(err, sql.ErrNoRows)
})
}
func Test_Model_Structs_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
_, err := msdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
if err != nil {
gtest.Fatal(err)
}
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
err := msdb.Table(table).OrderBy("id asc").Structs(&users)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []*User
err := msdb.Table(table).OrderBy("id asc").Structs(&users)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []*User
err := msdb.Table(table).Where("id<0").Structs(&users)
gtest.Assert(err, sql.ErrNoRows)
})
}
func Test_Model_Scan_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
_, err := msdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime string
}
user := new(User)
err := msdb.Table(table).Where("id=1").Scan(user)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T1")
gtest.Assert(user.CreateTime, "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
err := msdb.Table(table).Where("id=1").Scan(user)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T1")
gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
err := msdb.Table(table).OrderBy("id asc").Scan(&users)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []*User
err := msdb.Table(table).OrderBy("id asc").Scan(&users)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
users := new([]*User)
err1 := msdb.Table(table).Where("id < 0").Scan(user)
err2 := msdb.Table(table).Where("id < 0").Scan(users)
gtest.Assert(err1, sql.ErrNoRows)
gtest.Assert(err2, sql.ErrNoRows)
})
}
func Test_Model_OrderBy_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
_, err := msdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
result, err := msdb.Table(table).OrderBy("id").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), INIT_DATA_SIZE)
gtest.Assert(result[0]["NICKNAME"].String(), "T1")
}
func Test_Model_GroupBy_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
_, err := msdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
result, err := msdb.Table(table).Fields("NICKNAME,count(*)").OrderBy("nickname").GroupBy("nickname").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), INIT_DATA_SIZE)
gtest.Assert(result[0]["NICKNAME"].String(), "T1")
}
func Test_Model_Where_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
_, err := msdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
// string
gtest.Case(t, func() {
result, err := msdb.Table(table).Where("id=? and nickname=?", 3, "T3").One()
if err != nil {
gtest.Fatal(err)
}
gtest.AssertGT(len(result), 0)
gtest.Assert(result["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := msdb.Table(table).Where("id", 3).One()
if err != nil {
gtest.Fatal(err)
}
gtest.AssertGT(len(result), 0)
gtest.Assert(result["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := msdb.Table(table).Where("id", 3).Where("nickname", "T3").One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := msdb.Table(table).Where("id", 3).And("nickname", "T3").One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := msdb.Table(table).Where("id", 30).Or("nickname", "T3").One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := msdb.Table(table).Where("id", 30).Or("nickname", "T3").And("id>?", 1).One()
gtest.Assert(err, nil)
gtest.Assert(result["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := msdb.Table(table).Where("id", 30).Or("nickname", "T3").And("id>", 1).One()
gtest.Assert(err, nil)
gtest.Assert(result["ID"].Int(), 3)
})
// map
gtest.Case(t, func() {
result, err := msdb.Table(table).Where(g.Map{"id": 3, "nickname": "T3"}).One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["ID"].Int(), 3)
})
// map key operator
gtest.Case(t, func() {
result, err := msdb.Table(table).Where(g.Map{"id>": 1, "id<": 3}).One()
gtest.Assert(err, nil)
gtest.Assert(result["ID"].Int(), 2)
})
// complicated where 1
gtest.Case(t, func() {
conditions := g.Map{
"nickname like ?": "%T%",
"id between ? and ?": g.Slice{1, 3},
"id > 0": nil,
"id": g.Slice{1, 2, 3},
}
result, err := msdb.Table(table).Where(conditions).OrderBy("id asc").All()
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
})
// complicated where 2
gtest.Case(t, func() {
conditions := g.Map{
"nickname like ?": "%T%",
"id between ? and ?": g.Slice{1, 3},
"id >= ?": 1,
"create_time > ?": " ",
"id in(?)": g.Slice{1, 2, 3},
}
result, err := msdb.Table(table).Where(conditions).OrderBy("id asc").All()
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
})
// struct
gtest.Case(t, func() {
type User struct {
Id int `json:"id"`
Nickname string `gconv:"nickname"`
}
result, err := msdb.Table(table).Where(User{3, "T3"}).One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["ID"].Int(), 3)
result, err = msdb.Table(table).Where(&User{3, "T3"}).One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["ID"].Int(), 3)
})
// slice single
gtest.Case(t, func() {
result, err := msdb.Table(table).Where("id IN(?)", g.Slice{1, 3}).OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 2)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[1]["ID"].Int(), 3)
})
// slice + string
gtest.Case(t, func() {
result, err := msdb.Table(table).Where("nickname=? AND id IN(?)", "T3", g.Slice{1, 3}).OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["ID"].Int(), 3)
})
// slice + map
gtest.Case(t, func() {
result, err := msdb.Table(table).Where(g.Map{
"id": g.Slice{1, 3},
"nickname": "T3",
}).OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["ID"].Int(), 3)
})
// slice + struct
gtest.Case(t, func() {
type t_user struct {
Ids []int `json:"id"`
Nickname string `gconv:"nickname"`
}
result, err := msdb.Table(table).Where(t_user{
Ids: []int{1, 3},
Nickname: "T3",
}).OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["ID"].Int(), 3)
})
}
func Test_Model_Limit_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
_, err := msdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
msdb.SetDebug(true)
defer msdb.SetDebug(false)
gtest.Case(t, func() {
result, err := msdb.Table(table).Fields("*").Where("id>?", 0).Limit(1, 2).OrderBy("id").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["ID"].Int(), 2)
gtest.Assert(result[0]["NICKNAME"].String(), "T2")
})
gtest.Case(t, func() {
result, err := msdb.Table(table).Fields("*").Where("id>?", 0).Limit(0, 3).OrderBy("id").Select()
if err != nil {
gtest.Fatal(err)
}
fmt.Println(result[0]["CREATE_TIME"].String(), result[0]["CREATE_TIME"].GTime().String(), result[0]["CREATE_TIME"].Time().String())
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[0]["NICKNAME"].String(), "T1")
gtest.Assert(result[0]["CREATE_TIME"].String(), "2018-10-10 00:01:10")
gtest.Assert(result[1]["ID"].Int(), 2)
gtest.Assert(result[1]["NICKNAME"].String(), "T2")
})
gtest.Case(t, func() {
result, err := msdb.Table(table).Fields("*").Where("id>?", 0).Limit(1, 2).Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 1)
})
}
func Test_Model_Delete_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
gtest.Case(t, func() {
result, err := msdb.Table(table).Delete()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, INIT_DATA_SIZE)
})
}

112
database/gdb/gdb_unit_z_mssql_struct_test.go
View File

@ -1,112 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb_test
import (
"fmt"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
"strings"
"testing"
)
func Test_Model_Inherit_Insert_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
gtest.Case(t, func() {
type Base struct {
Id int `json:"id"`
Uid int `json:"uid"`
CreateTime string `json:"create_time"`
}
type User struct {
Base
Passport string `json:"passport"`
Password string `json:"password"`
Nickname string `json:"nickname"`
}
result, err := msdb.Table(table).Filter().Data(User{
Passport: "john-test",
Password: "123456",
Nickname: "John",
Base: Base{
Id: 100,
Uid: 100,
CreateTime: gtime.Now().String(),
},
}).Insert()
gtest.Assert(err, nil)
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
value, err := msdb.Table(table).Fields("passport").Where("id=100").Value()
gtest.Assert(err, nil)
gtest.Assert(value.String(), "john-test")
// Delete this test data.
_, err = msdb.Table(table).Where("id", 100).Delete()
gtest.Assert(err, nil)
})
}
func Test_Model_Inherit_MapToStruct_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
gtest.Case(t, func() {
type Ids struct {
Id int `json:"id"`
Uid int `json:"uid"`
}
type Base struct {
Ids
CreateTime *gtime.Time `json:"create_time"`
}
type User struct {
Base
Passport string `json:"passport"`
Password string `json:"password"`
Nickname string `json:"nickname"`
}
data := g.Map{
"id": 100,
"uid": 101,
"passport": "t1",
"password": "123456",
"nickname": "T1",
"create_time": gtime.Now().String(),
}
result, err := msdb.Table(table).Filter().Data(data).Insert()
gtest.Assert(err, nil)
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
one, err := msdb.Table(table).Where("id=100").One()
gtest.Assert(err, nil)
user := new(User)
fmt.Println(one.Json())
gtest.Assert(one.Struct(user), nil)
gtest.Assert(user.Id, data["id"])
gtest.Assert(user.Passport, data["passport"])
gtest.Assert(strings.TrimSpace(user.Password), data["password"])
gtest.Assert(user.Nickname, data["nickname"])
gtest.Assert(user.CreateTime, data["create_time"])
// Delete this test data.
_, err = msdb.Table(table).Where("id", 100).Delete()
gtest.Assert(err, nil)
})
}

712
database/gdb/gdb_unit_z_mssql_transaction_test.go
View File

@ -1,712 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb_test
import (
"fmt"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
"testing"
)
func Test_TX_Query_Mssql(t *testing.T) {
if msdb == nil {
return
}
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if rows, err := tx.Query("SELECT ?", 1); err != nil {
gtest.Fatal(err)
} else {
rows.Close()
}
if rows, err := tx.Query("SELECT ?+?", 1, 2); err != nil {
gtest.Fatal(err)
} else {
rows.Close()
}
if rows, err := tx.Query("SELECT ?+?", g.Slice{1, 2}); err != nil {
gtest.Fatal(err)
} else {
rows.Close()
}
if _, err := tx.Query("ERROR"); err == nil {
gtest.Fatal("FAIL")
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_Exec_Mssql(t *testing.T) {
if msdb == nil {
return
}
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.Exec("SELECT ?", 1); err != nil {
gtest.Fatal(err)
}
if _, err := tx.Exec("SELECT ?+?", 1, 2); err != nil {
gtest.Fatal(err)
}
if _, err := tx.Exec("SELECT ?+?", g.Slice{1, 2}); err != nil {
gtest.Fatal(err)
}
if _, err := tx.Exec("ERROR"); err == nil {
gtest.Fatal("FAIL")
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_Commit_Mssql(t *testing.T) {
if msdb == nil {
return
}
if msdb == nil {
return
}
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_Rollback_Mssql(t *testing.T) {
if msdb == nil {
return
}
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if err := tx.Rollback(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_Prepare_Mssql(t *testing.T) {
if msdb == nil {
return
}
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
st, err := tx.Prepare("SELECT 100 as aa")
if err != nil {
gtest.Fatal(err)
}
rows, err := st.Query()
if err != nil {
gtest.Fatal(err)
}
array, err := rows.Columns()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(array[0], "aa")
if err := rows.Close(); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_Insert_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createTableMssql()
defer dropTableMssql(table)
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.Insert(table, g.Map{
"id": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
}); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
if n, err := msdb.Table(table).Count(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(n, 1)
}
}
func Test_TX_BatchInsert_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createTableMssql()
defer dropTableMssql(table)
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.BatchInsert(table, g.List{
{
"id": 2,
"passport": "t",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
},
{
"id": 3,
"passport": "t3",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T3",
"create_time": gtime.Now().String(),
},
}, 10); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
if n, err := msdb.Table(table).Count(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(n, 2)
}
}
/*
func Test_TX_BatchReplace_Mssql(t *testing.T) {
if msdb == nil {
return
}
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.BatchReplace(table, g.List{
{
"id": 2,
"passport": "t2",
"password": "p2",
"nickname": "T2",
"create_time": gtime.Now().String(),
},
{
"id": 4,
"passport": "t4",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T4",
"create_time": gtime.Now().String(),
},
}, 10); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
// 数据数量
if n, err := msdb.Table(table).Count(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(n, 4)
}
// 检查replace后的数值
if value, err := msdb.Table(table).Fields("password").Where("id", 2).Value(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(strings.TrimSpace(value.String()), "p2")
}
}
func Test_TX_BatchSave_Mssql(t *testing.T) {
if msdb == nil {
return
}
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.BatchSave(table, g.List{
{
"id": 4,
"passport": "t4",
"password": "p4",
"nickname": "T4",
"create_time": gtime.Now().String(),
},
}, 10); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
// 数据数量
if n, err := msdb.Table(table).Count(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(n, 4)
}
// 检查replace后的数值
if value, err := msdb.Table(table).Fields("password").Where("id", 4).Value(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(strings.TrimSpace(value.String()), "p4")
}
}
func Test_TX_Replace_Mssql(t *testing.T) {
if msdb == nil {
return
}
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.Replace(table, g.Map{
"id": 1,
"passport": "t11",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T11",
"create_time": gtime.Now().String(),
}); err != nil {
gtest.Fatal(err)
}
if err := tx.Rollback(); err != nil {
gtest.Fatal(err)
}
if value, err := msdb.Table(table).Fields("nickname").Where("id", 1).Value(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(value.String(), "T1")
}
}
func Test_TX_Save_Mssql(t *testing.T) {
if msdb == nil {
return
}
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.Save(table, g.Map{
"id": 1,
"passport": "t11",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T11",
"create_time": gtime.Now().String(),
}); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
if value, err := msdb.Table(table).Fields("nickname").Where("id", 1).Value(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(value.String(), "T11")
}
}
**/
func Test_TX_Update_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
gtest.Case(t, func() {
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if result, err := msdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=3"); err != nil {
gtest.Fatal(err)
} else {
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
if value, err := msdb.Table(table).Fields("create_time").Where("id", 3).Value(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(value.GTime().String(), "2010-10-10 00:00:01")
}
})
}
func Test_TX_GetAll_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if result, err := tx.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(len(result), 1)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_GetOne_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if record, err := tx.GetOne(fmt.Sprintf("SELECT * FROM %s WHERE passport=?", table), "t3"); err != nil {
gtest.Fatal(err)
} else {
if record == nil {
gtest.Fatal("FAIL")
}
gtest.Assert(record["NICKNAME"].String(), "T3")
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_GetValue_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if value, err := tx.GetValue(fmt.Sprintf("SELECT id FROM %s WHERE passport=?", table), "t3"); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(value.Int(), 3)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_GetCount_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if count, err := tx.GetCount(fmt.Sprintf("SELECT * FROM %s", table)); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(count, INIT_DATA_SIZE)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_GetStruct_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
_, err := msdb.Table(table).Data("create_time", "2010-10-10 00:00:01").Where("id = ?", 3).Update()
gtest.Assert(err, nil)
gtest.Case(t, func() {
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
user := new(User)
if err := tx.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T3")
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
gtest.Case(t, func() {
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
if err := tx.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T3")
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
}
func Test_TX_GetStructs_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
_, err := msdb.Table(table).Data("create_time", "2010-10-10 00:00:01").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
gtest.Case(t, func() {
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
if err := tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? order by id", table), 1); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
gtest.Case(t, func() {
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []User
if err := tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? order by id", table), 1); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
}
func Test_TX_GetScan_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
_, err := msdb.Table(table).Data("create_time", "2010-10-10 00:00:01").Where("id = ?", 3).Update()
gtest.Assert(err, nil)
gtest.Case(t, func() {
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
user := new(User)
if err := tx.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T3")
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
gtest.Case(t, func() {
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
if err := tx.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T3")
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
gtest.Case(t, func() {
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
if err := tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? order by id", table), 1); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
gtest.Case(t, func() {
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []User
if err := tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? order by id", table), 1); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
}
func Test_TX_Delete_Mssql(t *testing.T) {
if msdb == nil {
return
}
table := createInitTableMssql()
defer dropTableMssql(table)
tx, err := msdb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.Delete(table, nil); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
if n, err := msdb.Table(table).Count(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(n, 0)
}
}

16
database/gdb/gdb_unit_z_mysql_method_test.go
View File

@ -426,7 +426,7 @@ func Test_DB_GetCount(t *testing.T) {
gtest.Case(t, func() {
count, err := db.GetCount(fmt.Sprintf("SELECT * FROM %s", table))
gtest.Assert(err, nil)
gtest.Assert(count, INIT_DATA_SIZE)
gtest.Assert(count, SIZE)
})
}
@ -475,7 +475,7 @@ func Test_DB_GetStructs(t *testing.T) {
var users []User
err := db.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>?", table), 1)
gtest.Assert(err, nil)
gtest.Assert(len(users), INIT_DATA_SIZE-1)
gtest.Assert(len(users), SIZE-1)
gtest.Assert(users[0].Id, 2)
gtest.Assert(users[1].Id, 3)
gtest.Assert(users[2].Id, 4)
@ -495,7 +495,7 @@ func Test_DB_GetStructs(t *testing.T) {
var users []User
err := db.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>?", table), 1)
gtest.Assert(err, nil)
gtest.Assert(len(users), INIT_DATA_SIZE-1)
gtest.Assert(len(users), SIZE-1)
gtest.Assert(users[0].Id, 2)
gtest.Assert(users[1].Id, 3)
gtest.Assert(users[2].Id, 4)
@ -546,7 +546,7 @@ func Test_DB_GetScan(t *testing.T) {
var users []User
err := db.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>?", table), 1)
gtest.Assert(err, nil)
gtest.Assert(len(users), INIT_DATA_SIZE-1)
gtest.Assert(len(users), SIZE-1)
gtest.Assert(users[0].Id, 2)
gtest.Assert(users[1].Id, 3)
gtest.Assert(users[2].Id, 4)
@ -566,7 +566,7 @@ func Test_DB_GetScan(t *testing.T) {
var users []User
err := db.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>?", table), 1)
gtest.Assert(err, nil)
gtest.Assert(len(users), INIT_DATA_SIZE-1)
gtest.Assert(len(users), SIZE-1)
gtest.Assert(users[0].Id, 2)
gtest.Assert(users[1].Id, 3)
gtest.Assert(users[2].Id, 4)
@ -583,7 +583,7 @@ func Test_DB_Delete(t *testing.T) {
result, err := db.Delete(table, nil)
gtest.Assert(err, nil)
n, _ := result.RowsAffected()
gtest.Assert(n, INIT_DATA_SIZE)
gtest.Assert(n, SIZE)
})
}
@ -1138,7 +1138,7 @@ func Test_DB_Prefix(t *testing.T) {
gtest.Case(t, func() {
array := garray.New(true)
for i := 1; i <= INIT_DATA_SIZE; i++ {
for i := 1; i <= SIZE; i++ {
array.Append(g.Map{
"id": i,
"passport": fmt.Sprintf(`user_%d`, i),
@ -1153,7 +1153,7 @@ func Test_DB_Prefix(t *testing.T) {
n, e := result.RowsAffected()
gtest.Assert(e, nil)
gtest.Assert(n, INIT_DATA_SIZE)
gtest.Assert(n, SIZE)
})
}

51
database/gdb/gdb_unit_z_mysql_model_test.go
View File

@ -131,7 +131,7 @@ func Test_Model_Batch(t *testing.T) {
defer dropTable(table)
result, err := db.Table(table).All()
gtest.Assert(err, nil)
gtest.Assert(len(result), INIT_DATA_SIZE)
gtest.Assert(len(result), SIZE)
for _, v := range result {
v["nickname"].Set(v["nickname"].String() + v["id"].String())
}
@ -139,7 +139,7 @@ func Test_Model_Batch(t *testing.T) {
gtest.Assert(e, nil)
n, e := r.RowsAffected()
gtest.Assert(e, nil)
gtest.Assert(n, INIT_DATA_SIZE*2)
gtest.Assert(n, SIZE*2)
})
// batch replace
@ -148,7 +148,7 @@ func Test_Model_Batch(t *testing.T) {
defer dropTable(table)
result, err := db.Table(table).All()
gtest.Assert(err, nil)
gtest.Assert(len(result), INIT_DATA_SIZE)
gtest.Assert(len(result), SIZE)
for _, v := range result {
v["nickname"].Set(v["nickname"].String() + v["id"].String())
}
@ -156,7 +156,7 @@ func Test_Model_Batch(t *testing.T) {
gtest.Assert(e, nil)
n, e := r.RowsAffected()
gtest.Assert(e, nil)
gtest.Assert(n, INIT_DATA_SIZE*2)
gtest.Assert(n, SIZE*2)
})
}
@ -362,7 +362,7 @@ func Test_Model_All(t *testing.T) {
gtest.Case(t, func() {
result, err := db.Table(table).All()
gtest.Assert(err, nil)
gtest.Assert(len(result), INIT_DATA_SIZE)
gtest.Assert(len(result), SIZE)
})
gtest.Case(t, func() {
result, err := db.Table(table).Where("id<0").All()
@ -400,7 +400,7 @@ func Test_Model_FindAll(t *testing.T) {
gtest.Case(t, func() {
result, err := db.Table(table).FindAll()
gtest.Assert(err, nil)
gtest.Assert(len(result), INIT_DATA_SIZE)
gtest.Assert(len(result), SIZE)
})
gtest.Case(t, func() {
result, err := db.Table(table).Where("id<0").FindAll()
@ -512,7 +512,7 @@ func Test_Model_Count(t *testing.T) {
gtest.Case(t, func() {
count, err := db.Table(table).Count()
gtest.Assert(err, nil)
gtest.Assert(count, INIT_DATA_SIZE)
gtest.Assert(count, SIZE)
})
}
@ -532,7 +532,7 @@ func Test_Model_FindCount(t *testing.T) {
gtest.Case(t, func() {
count, err := db.Table(table).FindCount()
gtest.Assert(err, nil)
gtest.Assert(count, INIT_DATA_SIZE)
gtest.Assert(count, SIZE)
})
}
@ -542,7 +542,7 @@ func Test_Model_Select(t *testing.T) {
gtest.Case(t, func() {
result, err := db.Table(table).Select()
gtest.Assert(err, nil)
gtest.Assert(len(result), INIT_DATA_SIZE)
gtest.Assert(len(result), SIZE)
})
}
@ -641,7 +641,7 @@ func Test_Model_Structs(t *testing.T) {
if err != nil {
gtest.Error(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(len(users), SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
@ -664,7 +664,7 @@ func Test_Model_Structs(t *testing.T) {
if err != nil {
gtest.Error(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(len(users), SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
@ -687,7 +687,7 @@ func Test_Model_Structs(t *testing.T) {
if err != nil {
gtest.Error(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(len(users), SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
@ -754,7 +754,7 @@ func Test_Model_Scan(t *testing.T) {
var users []User
err := db.Table(table).Order("id asc").Scan(&users)
gtest.Assert(err, nil)
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(len(users), SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
@ -774,7 +774,7 @@ func Test_Model_Scan(t *testing.T) {
var users []*User
err := db.Table(table).Order("id asc").Scan(&users)
gtest.Assert(err, nil)
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(len(users), SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
@ -808,8 +808,8 @@ func Test_Model_OrderBy(t *testing.T) {
gtest.Case(t, func() {
result, err := db.Table(table).Order("id DESC").Select()
gtest.Assert(err, nil)
gtest.Assert(len(result), INIT_DATA_SIZE)
gtest.Assert(result[0]["nickname"].String(), fmt.Sprintf("name_%d", INIT_DATA_SIZE))
gtest.Assert(len(result), SIZE)
gtest.Assert(result[0]["nickname"].String(), fmt.Sprintf("name_%d", SIZE))
})
}
@ -820,7 +820,7 @@ func Test_Model_GroupBy(t *testing.T) {
gtest.Case(t, func() {
result, err := db.Table(table).GroupBy("id").Select()
gtest.Assert(err, nil)
gtest.Assert(len(result), INIT_DATA_SIZE)
gtest.Assert(len(result), SIZE)
gtest.Assert(result[0]["nickname"].String(), "name_1")
})
}
@ -1342,7 +1342,7 @@ func Test_Model_Delete(t *testing.T) {
result, err := db.Table(table).Delete()
gtest.Assert(err, nil)
n, _ := result.RowsAffected()
gtest.Assert(n, INIT_DATA_SIZE-2)
gtest.Assert(n, SIZE-2)
})
}
@ -1487,15 +1487,15 @@ func Test_Model_Option_Map(t *testing.T) {
_, err = db.Table(table).Option(gdb.OPTION_OMITEMPTY).Data(g.Map{"nickname": ""}).Where("id", 2).Update()
gtest.AssertNE(err, nil)
r, err = db.Table(table).OptionOmitEmpty().Data(g.Map{"nickname": "", "password": "123"}).Where("id", 3).Update()
r, err = db.Table(table).OmitEmpty().Data(g.Map{"nickname": "", "password": "123"}).Where("id", 3).Update()
gtest.Assert(err, nil)
n, _ = r.RowsAffected()
gtest.Assert(n, 1)
_, err = db.Table(table).OptionOmitEmpty().Fields("nickname").Data(g.Map{"nickname": "", "password": "123"}).Where("id", 4).Update()
_, err = db.Table(table).OmitEmpty().Fields("nickname").Data(g.Map{"nickname": "", "password": "123"}).Where("id", 4).Update()
gtest.AssertNE(err, nil)
r, err = db.Table(table).OptionOmitEmpty().
r, err = db.Table(table).OmitEmpty().
Fields("password").Data(g.Map{
"nickname": "",
"passport": "123",
@ -1551,7 +1551,7 @@ func Test_Model_Option_List(t *testing.T) {
gtest.Case(t, func() {
table := createTable()
defer dropTable(table)
r, err := db.Table(table).OptionOmitEmpty().Fields("id, password").Data(g.List{
r, err := db.Table(table).OmitEmpty().Fields("id, password").Data(g.List{
g.Map{
"id": 1,
"passport": "1",
@ -1569,7 +1569,6 @@ func Test_Model_Option_List(t *testing.T) {
n, _ := r.RowsAffected()
gtest.Assert(n, 2)
list, err := db.Table(table).Order("id asc").All()
g.Dump(list)
gtest.Assert(err, nil)
gtest.Assert(len(list), 2)
gtest.Assert(list[0]["id"].String(), "1")
@ -1589,15 +1588,15 @@ func Test_Model_Option_Where(t *testing.T) {
gtest.Case(t, func() {
table := createInitTable()
defer dropTable(table)
r, err := db.Table(table).OptionOmitEmpty().Data("nickname", 1).Where(g.Map{"id": 0, "passport": ""}).Update()
r, err := db.Table(table).OmitEmpty().Data("nickname", 1).Where(g.Map{"id": 0, "passport": ""}).Update()
gtest.Assert(err, nil)
n, _ := r.RowsAffected()
gtest.Assert(n, INIT_DATA_SIZE)
gtest.Assert(n, SIZE)
})
gtest.Case(t, func() {
table := createInitTable()
defer dropTable(table)
r, err := db.Table(table).OptionOmitEmpty().Data("nickname", 1).Where(g.Map{"id": 1, "passport": ""}).Update()
r, err := db.Table(table).OmitEmpty().Data("nickname", 1).Where(g.Map{"id": 1, "passport": ""}).Update()
gtest.Assert(err, nil)
n, _ := r.RowsAffected()
gtest.Assert(n, 1)

16
database/gdb/gdb_unit_z_mysql_transaction_test.go
View File

@ -225,7 +225,7 @@ func Test_TX_BatchReplace(t *testing.T) {
if n, err := db.Table(table).Count(); err != nil {
gtest.Error(err)
} else {
gtest.Assert(n, INIT_DATA_SIZE)
gtest.Assert(n, SIZE)
}
if value, err := db.Table(table).Fields("password").Where("id", 2).Value(); err != nil {
gtest.Error(err)
@ -262,7 +262,7 @@ func Test_TX_BatchSave(t *testing.T) {
if n, err := db.Table(table).Count(); err != nil {
gtest.Error(err)
} else {
gtest.Assert(n, INIT_DATA_SIZE)
gtest.Assert(n, SIZE)
}
if value, err := db.Table(table).Fields("password").Where("id", 4).Value(); err != nil {
@ -437,7 +437,7 @@ func Test_TX_GetCount(t *testing.T) {
if count, err := tx.GetCount("SELECT * FROM " + table); err != nil {
gtest.Error(err)
} else {
gtest.Assert(count, INIT_DATA_SIZE)
gtest.Assert(count, SIZE)
}
if err := tx.Commit(); err != nil {
gtest.Error(err)
@ -515,7 +515,7 @@ func Test_TX_GetStructs(t *testing.T) {
if err := tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil {
gtest.Error(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(len(users), SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
@ -544,7 +544,7 @@ func Test_TX_GetStructs(t *testing.T) {
if err := tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil {
gtest.Error(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(len(users), SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
@ -623,7 +623,7 @@ func Test_TX_GetScan(t *testing.T) {
if err := tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil {
gtest.Error(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(len(users), SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
@ -652,7 +652,7 @@ func Test_TX_GetScan(t *testing.T) {
if err := tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil {
gtest.Error(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(len(users), SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
@ -709,7 +709,7 @@ func Test_TX_Delete(t *testing.T) {
if n, err := db.Table(table).Count(); err != nil {
gtest.Error(err)
} else {
gtest.Assert(n, INIT_DATA_SIZE)
gtest.Assert(n, SIZE)
gtest.AssertNE(n, 0)
}
})

970
database/gdb/gdb_unit_z_oracle_method_test.go
View File

@ -1,970 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb_test
import (
"fmt"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
"testing"
"time"
)
func Test_DB_Ping_Oracle(t *testing.T) {
if oradb == nil {
return
}
gtest.Case(t, func() {
err1 := oradb.PingMaster()
err2 := oradb.PingSlave()
gtest.Assert(err1, nil)
gtest.Assert(err2, nil)
})
}
func Test_DB_Query_Oracle(t *testing.T) {
if oradb == nil {
return
}
if _, err := oradb.Query("SELECT SYSDATE FROM DUAL"); err != nil {
gtest.Fatal(err)
}
if _, err := oradb.Query("ERROR"); err == nil {
gtest.Fatal("FAIL")
}
}
func Test_DB_Exec_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
if _, err := oradb.Exec(fmt.Sprintf("UPDATE %s SET NICKNAME=?", table), "LYZ"); err != nil {
gtest.Fatal(err)
}
if _, err := oradb.Exec("ERROR"); err == nil {
gtest.Fatal("FAIL")
}
}
func Test_DB_Prepare_Oracle(t *testing.T) {
if oradb == nil {
return
}
st, err := oradb.Prepare("SELECT 100 FROM DUAL")
if err != nil {
gtest.Fatal(err)
}
rows, err := st.Query()
if err != nil {
gtest.Fatal(err)
}
array, err := rows.Columns()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(array[0], "100")
if err := rows.Close(); err != nil {
gtest.Fatal(err)
}
}
func Test_DB_Insert_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createTableOracle()
defer dropTableOracle(table)
if _, err := oradb.Insert(table, g.Map{
"id": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
}); err != nil {
gtest.Fatal(err)
}
// normal map
result, err := oradb.Insert(table, map[interface{}]interface{}{
"id": "2",
"passport": "t2",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
})
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
// struct
type User struct {
Id int `gconv:"id"`
Passport string `json:"passport"`
Password string `gconv:"password"`
Nickname string `gconv:"nickname"`
CreateTime string `json:"create_time"`
}
result, err = oradb.Insert(table, User{
Id: 3,
Passport: "t3",
Password: "25d55ad283aa400af464c76d713c07ad",
Nickname: "T3",
CreateTime: gtime.Now().String(),
})
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
value, err := oradb.GetValue(fmt.Sprintf(`select passport from %s where id=?`, table), 3)
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t3")
// *struct
result, err = oradb.Insert(table, &User{
Id: 4,
Passport: "t4",
Password: "25d55ad283aa400af464c76d713c07ad",
Nickname: "T4",
CreateTime: gtime.Now().String(),
})
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
value, err = oradb.GetValue(fmt.Sprintf("select passport from %s where id=?", table), 4)
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t4")
// batch with Insert
if r, err := oradb.Insert(table, []interface{}{
map[interface{}]interface{}{
"id": 200,
"passport": "t200",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T200",
"create_time": gtime.Now().String(),
},
map[interface{}]interface{}{
"id": 300,
"passport": "t300",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T300",
"create_time": gtime.Now().String(),
},
}); err != nil {
gtest.Fatal(err)
} else {
n, _ := r.RowsAffected()
gtest.Assert(n, 2)
}
// clear unnecessary data
result, err = oradb.Delete(table, "id>?", 1)
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 5)
}
func Test_DB_BatchInsert_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createTableOracle()
defer dropTableOracle(table)
gtest.Case(t, func() {
if r, err := oradb.BatchInsert(table, g.List{
{
"id": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
},
{
"id": 2,
"passport": "t2",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
},
{
"id": 3,
"passport": "t3",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T3",
"create_time": gtime.Now().String(),
},
{
"id": 4,
"passport": "t4",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T4",
"create_time": gtime.Now().String(),
},
{
"id": 5,
"passport": "t5",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T5",
"create_time": gtime.Now().String(),
},
{
"id": 6,
"passport": "t6",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T6",
"create_time": gtime.Now().String(),
},
{
"id": 7,
"passport": "t7",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T7",
"create_time": gtime.Now().String(),
},
{
"id": 8,
"passport": "t8",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T8",
"create_time": gtime.Now().String(),
},
}, 3); err != nil {
gtest.Fatal(err)
} else {
n, _ := r.RowsAffected()
gtest.Assert(n, 8)
}
result, err := oradb.Delete(table, "id>=?", 1)
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 8)
// []interface{}
if r, err := oradb.BatchInsert(table, []interface{}{
map[interface{}]interface{}{
"id": 11,
"passport": "t11",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T11",
"create_time": gtime.Now().String(),
},
map[interface{}]interface{}{
"id": 12,
"passport": "t12",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T12",
"create_time": gtime.Now().String(),
},
map[interface{}]interface{}{
"id": 13,
"passport": "t13",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T13",
"create_time": gtime.Now().String(),
},
map[interface{}]interface{}{
"id": 14,
"passport": "t14",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T14",
"create_time": gtime.Now().String(),
},
map[interface{}]interface{}{
"id": 15,
"passport": "t15",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T15",
"create_time": gtime.Now().String(),
},
}, 2); err != nil {
gtest.Fatal(err)
} else {
n, _ := r.RowsAffected()
gtest.Assert(n, 5)
}
})
// batch insert map
gtest.Case(t, func() {
result, err := oradb.BatchInsert(table, g.Map{
"id": 20,
"passport": "t20",
"password": "p20",
"nickname": "T20",
"create_time": gtime.Now().String(),
})
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
})
// batch insert struct
gtest.Case(t, func() {
type User struct {
Id int `gconv:"id"`
Passport string `gconv:"passport"`
Password string `gconv:"password"`
NickName string `gconv:"nickname"`
CreateTime *gtime.Time `gconv:"create_time"`
}
user := &User{
Id: 30,
Passport: "t30",
Password: "p30",
NickName: "T30",
CreateTime: gtime.Now(),
}
result, err := oradb.BatchInsert(table, user)
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
})
}
func Test_DB_BatchSave_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createTableOracle()
defer dropTableOracle(table)
gtest.Case(t, func() {
if r, err := oradb.BatchInsert(table, g.List{
{
"id": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
},
{
"id": 2,
"passport": "t2",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
},
}, 3); err != nil {
gtest.Fatal(err)
} else {
n, _ := r.RowsAffected()
gtest.Assert(n, 2)
}
if r, err := oradb.BatchSave(table, g.List{
{
"id": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
},
{
"id": 2,
"passport": "t2",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
},
}, 3); err != nil {
gtest.Fatal(err)
} else {
n, _ := r.RowsAffected()
gtest.Assert(n, 2)
}
if r, err := oradb.BatchReplace(table, g.List{
{
"id": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
},
{
"id": 2,
"passport": "t2",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
},
}, 3); err != nil {
gtest.Fatal(err)
} else {
n, _ := r.RowsAffected()
gtest.Assert(n, 2)
}
// []interface{}
if r, err := oradb.BatchInsert(table, []interface{}{
map[interface{}]interface{}{
"id": 11,
"passport": "t11",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T11",
"create_time": gtime.Now().String(),
},
map[interface{}]interface{}{
"id": 12,
"passport": "t12",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T12",
"create_time": gtime.Now().String(),
},
}, 2); err != nil {
gtest.Fatal(err)
} else {
n, _ := r.RowsAffected()
gtest.Assert(n, 2)
}
if r, err := oradb.BatchReplace(table, []interface{}{
map[interface{}]interface{}{
"id": 11,
"passport": "t11",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T11",
"create_time": gtime.Now().String(),
},
map[interface{}]interface{}{
"id": 12,
"passport": "t12",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T12",
"create_time": gtime.Now().String(),
},
}, 2); err != nil {
gtest.Fatal(err)
} else {
n, _ := r.RowsAffected()
gtest.Assert(n, 2)
}
if r, err := oradb.BatchSave(table, []interface{}{
map[interface{}]interface{}{
"id": 11,
"passport": "t11",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T11",
"create_time": gtime.Now().String(),
},
map[interface{}]interface{}{
"id": 12,
"passport": "t12",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T12",
"create_time": gtime.Now().String(),
},
}, 2); err != nil {
gtest.Fatal(err)
} else {
n, _ := r.RowsAffected()
gtest.Assert(n, 2)
}
})
// batch insert map
gtest.Case(t, func() {
result, err := oradb.BatchInsert(table, g.Map{
"id": 20,
"passport": "t20",
"password": "p20",
"nickname": "T20",
"create_time": gtime.Now().String(),
})
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
result, err = oradb.BatchSave(table, g.Map{
"id": 20,
"passport": "t20",
"password": "p20",
"nickname": "T20",
"create_time": gtime.Now().String(),
})
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
result, err = oradb.BatchReplace(table, g.Map{
"id": 20,
"passport": "t20",
"password": "p20",
"nickname": "T20",
"create_time": gtime.Now().String(),
})
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
})
// batch insert struct
gtest.Case(t, func() {
type User struct {
Id int `gconv:"id"`
Passport string `gconv:"passport"`
Password string `gconv:"password"`
NickName string `gconv:"nickname"`
CreateTime *gtime.Time `gconv:"create_time"`
}
user := &User{
Id: 30,
Passport: "t30",
Password: "p30",
NickName: "T30",
CreateTime: gtime.Now(),
}
result, err := oradb.BatchInsert(table, user)
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
result, err = oradb.BatchSave(table, user)
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
result, err = oradb.BatchReplace(table, user)
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
})
}
func Test_DB_Save_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
if _, err := oradb.Save(table, g.Map{
"id": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T11",
"create_time": gtime.Now().String(),
}); err != nil {
gtest.Fatal(err)
}
result, err := oradb.Table(table).Fields("*").Where("id = ?", 1).One()
gtest.Assert(err, nil)
gtest.Assert(result["NICKNAME"], "T11")
}
func Test_DB_Replace_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
if _, err := oradb.Replace(table, g.Map{
"id": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T111",
"create_time": gtime.Now().String(),
}); err != nil {
gtest.Fatal(err)
}
result, err := oradb.Table(table).Fields("*").Where("id = ?", 1).One()
gtest.Assert(err, nil)
gtest.Assert(result["NICKNAME"], "T111")
}
func Test_DB_Update_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
if result, err := oradb.Update(table, "create_time='2010-10-10 00:00:01'", "id=1"); err != nil {
gtest.Fatal(err)
} else {
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
if result, err := oradb.Update(table, "create_time='2010-10-10 00:00:02'", "id=2"); err != nil {
gtest.Fatal(err)
} else {
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
result, err := oradb.Table(table).Fields("*").Where("id in(?)", g.Slice{1, 2}).OrderBy("id ").Select()
gtest.Assert(err, nil)
gtest.Assert(result[0]["CREATE_TIME"], "2010-10-10 00:00:01")
gtest.Assert(result[1]["CREATE_TIME"], "2010-10-10 00:00:02")
}
func Test_DB_GetAll_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
gtest.Case(t, func() {
result, err := oradb.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1)
gtest.Assert(err, nil)
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["ID"].Int(), 1)
})
gtest.Case(t, func() {
result, err := oradb.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), g.Slice{1})
gtest.Assert(err, nil)
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["ID"].Int(), 1)
})
gtest.Case(t, func() {
result, err := oradb.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id in(?) order by id ", table), g.Slice{1, 2, 3})
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[1]["ID"].Int(), 2)
gtest.Assert(result[2]["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := oradb.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id in(?,?,?) order by id ", table), g.Slice{1, 2, 3})
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[1]["ID"].Int(), 2)
gtest.Assert(result[2]["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := oradb.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id in(?,?,?) order by id ", table), g.Slice{1, 2, 3}...)
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[1]["ID"].Int(), 2)
gtest.Assert(result[2]["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := oradb.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id>=? AND id <=? order by id ", table), g.Slice{1, 3})
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[1]["ID"].Int(), 2)
gtest.Assert(result[2]["ID"].Int(), 3)
})
}
func Test_DB_GetOne_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
if record, err := oradb.GetOne(fmt.Sprintf("SELECT * FROM %s WHERE passport=?", table), "t1"); err != nil {
gtest.Fatal(err)
} else {
if record == nil {
gtest.Fatal("FAIL")
}
gtest.Assert(record["NICKNAME"].String(), "T1")
}
}
func Test_DB_GetValue_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
if value, err := oradb.GetValue(fmt.Sprintf("SELECT id FROM %s WHERE passport=?", table), "t2"); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(value.Int(), 2)
}
}
func Test_DB_GetCount_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
if count, err := oradb.GetCount(fmt.Sprintf("SELECT * FROM %s", table)); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(count, INIT_DATA_SIZE)
}
}
func Test_DB_GetStruct_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
gtest.Case(t, func() {
_, err := oradb.Update(table, "create_time = '2010-10-10 00:00:01'", "id = ?", 1)
gtest.Assert(err, nil)
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
user := new(User)
if err := oradb.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
}
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
if err := oradb.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
}
})
}
func Test_DB_GetStructs_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
gtest.Case(t, func() {
_, err := oradb.Update(table, "create_time = '2010-10-10 00:00:01'", "id = ?", 2)
gtest.Assert(err, nil)
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
if err := oradb.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? and id <=? order by id ", table), 2, 3); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), 2)
gtest.Assert(users[0].Id, 2)
gtest.Assert(users[1].Id, 3)
gtest.Assert(users[0].NickName, "T2")
gtest.Assert(users[1].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2010-10-10 00:00:01")
})
}
func Test_DB_GetScan_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
_, err := oradb.Update(table, "create_time = '2010-10-10 00:00:01'", "id = ?", 2)
gtest.Assert(err, nil)
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
user := new(User)
if err := oradb.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 2); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
}
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
if err := oradb.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 2); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
}
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
if err := oradb.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? and id <=? order by id ", table), 2, 3); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), 2)
gtest.Assert(users[0].Id, 2)
gtest.Assert(users[1].Id, 3)
gtest.Assert(users[0].NickName, "T2")
gtest.Assert(users[1].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2010-10-10 00:00:01")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []User
if err := oradb.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? and id <=? order by id ", table), 2, 3); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), 2)
gtest.Assert(users[0].Id, 2)
gtest.Assert(users[1].Id, 3)
gtest.Assert(users[0].NickName, "T2")
gtest.Assert(users[1].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2010-10-10 00:00:01")
})
}
func Test_DB_Delete_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
if result, err := oradb.Delete(table, nil); err != nil {
gtest.Fatal(err)
} else {
n, _ := result.RowsAffected()
gtest.Assert(n, INIT_DATA_SIZE)
}
}
func Test_DB_Time_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
gtest.Case(t, func() {
result, err := oradb.Insert(table, g.Map{
"id": 200,
"passport": "t200",
"password": "123456",
"nickname": "T200",
"create_time": time.Now(),
})
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
value, err := oradb.GetValue(fmt.Sprintf("select passport from %s where id=?", table), 200)
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t200")
})
gtest.Case(t, func() {
t := time.Now()
result, err := oradb.Insert(table, g.Map{
"id": 300,
"passport": "t300",
"password": "123456",
"nickname": "T300",
"create_time": &t,
})
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
value, err := oradb.GetValue(fmt.Sprintf("select passport from %s where id=?", table), 300)
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t300")
})
}

872
database/gdb/gdb_unit_z_oracle_model_test.go
View File

@ -1,872 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb_test
import (
"database/sql"
"testing"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
)
// 基本测试
func Test_Model_Insert_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createTableOracle()
defer dropTableOracle(table)
oradb.SetDebug(true)
result, err := oradb.Table(table).Filter().Data(g.Map{
"id": 1,
"uid": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
}).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
result, err = oradb.Table(table).Filter().Data(map[interface{}]interface{}{
"id": "2",
"uid": "2",
"passport": "t2",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
}).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
type t_user struct {
Id int `gconv:"id"`
Uid int `gconv:"uid"`
Passport string `json:"passport"`
Password string `gconv:"password"`
Nickname string `gconv:"nickname"`
CreateTime string `json:"create_time"`
}
result, err = oradb.Table(table).Filter().Data(t_user{
Id: 3,
Uid: 3,
Passport: "t3",
Password: "25d55ad283aa400af464c76d713c07ad",
Nickname: "T3",
CreateTime: gtime.Now().String(),
}).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
value, err := oradb.Table(table).Fields("passport").Where("id=3").Value()
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t3")
result, err = oradb.Table(table).Filter().Data(&t_user{
Id: 4,
Uid: 4,
Passport: "t4",
Password: "25d55ad283aa400af464c76d713c07ad",
Nickname: "T4",
CreateTime: gtime.Now().String(),
}).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
value, err = oradb.Table(table).Fields("passport").Where("id=4").Value()
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t4")
}
func Test_Model_Batch_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createTableOracle()
defer dropTableOracle(table)
// batch insert
gtest.Case(t, func() {
result, err := oradb.Table(table).Filter().Data(g.List{
{
"id": 2,
"uid": 2,
"passport": "t2",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
},
{
"id": 3,
"uid": 3,
"passport": "t3",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T3",
"create_time": gtime.Now().String(),
},
}).Batch(1).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 2)
})
// batch save
gtest.Case(t, func() {
table := createInitTableOracle()
defer dropTableOracle(table)
result, err := oradb.Table(table).All()
gtest.Assert(err, nil)
gtest.Assert(len(result), INIT_DATA_SIZE)
for _, v := range result {
v["NICKNAME"].Set(v["NICKNAME"].String() + v["ID"].String())
}
r, e := oradb.Table(table).Data(result).Save()
gtest.Assert(e, nil)
n, e := r.RowsAffected()
gtest.Assert(e, nil)
gtest.Assert(n, INIT_DATA_SIZE)
})
// batch replace
gtest.Case(t, func() {
table := createInitTableOracle()
defer dropTableOracle(table)
result, err := oradb.Table(table).All()
gtest.Assert(err, nil)
gtest.Assert(len(result), INIT_DATA_SIZE)
for _, v := range result {
v["NICKNAME"].Set(v["NICKNAME"].String() + v["ID"].String())
}
r, e := oradb.Table(table).Data(result).Replace()
gtest.Assert(e, nil)
n, e := r.RowsAffected()
gtest.Assert(e, nil)
gtest.Assert(n, INIT_DATA_SIZE)
})
}
func Test_Model_Replace_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
result, err := oradb.Table(table).Data(g.Map{
"id": 1,
"passport": "t11",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T11",
"create_time": "2018-10-10 00:01:10",
}).Replace()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
func Test_Model_Save_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
result, err := oradb.Table(table).Data(g.Map{
"id": 1,
"passport": "t111",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T111",
"create_time": "2018-10-10 00:01:10",
}).Save()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
func Test_Model_Update_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
gtest.Case(t, func() {
result, err := oradb.Table(table).Data("nickname", "T100").Where("id", 10).Update()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
v1, err := oradb.Table(table).Fields("nickname").Where("id", 10).Value()
gtest.Assert(err, nil)
gtest.Assert(v1.String(), "T100")
v2, err := oradb.Table(table).Fields("nickname").Where("id", 8).Value()
gtest.Assert(err, nil)
gtest.Assert(v2.String(), "T8")
})
gtest.Case(t, func() {
result, err := oradb.Table(table).Data("passport", "t22").Where("passport=?", "t2").Update()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
})
gtest.Case(t, func() {
result, err := oradb.Table(table).Data("passport", "t2").Where("passport='t22'").Update()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
})
}
func Test_Model_Clone_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
md := oradb.Table(table).Where("id IN(?)", g.Slice{1, 3})
count, err := md.Count()
if err != nil {
gtest.Fatal(err)
}
record, err := md.OrderBy("id DESC").One()
if err != nil {
gtest.Fatal(err)
}
result, err := md.OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 2)
gtest.Assert(record["ID"].Int(), 3)
gtest.Assert(len(result), 2)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[1]["ID"].Int(), 3)
}
func Test_Model_Safe_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
gtest.Case(t, func() {
md := oradb.Table(table).Safe(false).Where("id IN(?)", g.Slice{1, 3})
count, err := md.Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 2)
md.And("id = ?", 1)
count, err = md.Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 1)
})
gtest.Case(t, func() {
md := oradb.Table(table).Safe(true).Where("id IN(?)", g.Slice{1, 3})
count, err := md.Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 2)
md.And("id = ?", 1)
count, err = md.Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 2)
})
}
func Test_Model_All_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
result, err := oradb.Table(table).All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), INIT_DATA_SIZE)
}
func Test_Model_One_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
record, err := oradb.Table(table).Where("id", 1).One()
if err != nil {
gtest.Fatal(err)
}
if record == nil {
gtest.Fatal("FAIL")
}
gtest.Assert(record["NICKNAME"].String(), "T1")
}
func Test_Model_Value_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
value, err := oradb.Table(table).Fields("nickname").Where("id", 1).Value()
if err != nil {
gtest.Fatal(err)
}
if value == nil {
gtest.Fatal("FAIL")
}
gtest.Assert(value.String(), "T1")
}
func Test_Model_Count_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
count, err := oradb.Table(table).Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, INIT_DATA_SIZE)
}
func Test_Model_Select_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
result, err := oradb.Table(table).Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), INIT_DATA_SIZE)
}
func Test_Model_Struct_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
_, err := oradb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
user := new(User)
err := oradb.Table(table).Where("id=1").Struct(user)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T1")
gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
err := oradb.Table(table).Where("id=1").Struct(user)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T1")
gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
err := oradb.Table(table).Where("id=-1").Struct(user)
gtest.Assert(err, sql.ErrNoRows)
})
}
func Test_Model_Structs_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
_, err := oradb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
err := oradb.Table(table).OrderBy("id").Structs(&users)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []*User
err := oradb.Table(table).OrderBy("id asc").Structs(&users)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []*User
err := oradb.Table(table).Where("id<0").Structs(&users)
gtest.Assert(err, sql.ErrNoRows)
})
}
func Test_Model_Scan_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
_, err := oradb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
user := new(User)
err := oradb.Table(table).Where("id=1").Scan(user)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T1")
gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
err := oradb.Table(table).Where("id=1").Scan(user)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T1")
gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
err := oradb.Table(table).OrderBy("id asc").Scan(&users)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []*User
err := oradb.Table(table).OrderBy("id asc").Scan(&users)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
users := new([]*User)
err1 := oradb.Table(table).Where("id < 0").Scan(user)
err2 := oradb.Table(table).Where("id < 0").Scan(users)
gtest.Assert(err1, sql.ErrNoRows)
gtest.Assert(err2, sql.ErrNoRows)
})
}
func Test_Model_OrderBy_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
_, err := oradb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
result, err := oradb.Table(table).OrderBy("id").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), INIT_DATA_SIZE)
gtest.Assert(result[0]["NICKNAME"].String(), "T1")
}
func Test_Model_GroupBy_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
_, err := oradb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
result, err := oradb.Table(table).Fields("nickname,count(*)").OrderBy("nickname").GroupBy("nickname").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), INIT_DATA_SIZE)
gtest.Assert(result[0]["NICKNAME"].String(), "T1")
}
func Test_Model_Where_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
_, err := oradb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
// string
gtest.Case(t, func() {
result, err := oradb.Table(table).Where("id=? and nickname=?", 3, "T3").One()
if err != nil {
gtest.Fatal(err)
}
gtest.AssertGT(len(result), 0)
gtest.Assert(result["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := oradb.Table(table).Where("id", 3).One()
if err != nil {
gtest.Fatal(err)
}
gtest.AssertGT(len(result), 0)
gtest.Assert(result["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := oradb.Table(table).Where("id", 3).Where("nickname", "T3").One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := oradb.Table(table).Where("id", 3).And("nickname", "T3").One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := oradb.Table(table).Where("id", 30).Or("nickname", "T3").One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := oradb.Table(table).Where("id", 30).Or("nickname", "T3").And("id>?", 1).One()
gtest.Assert(err, nil)
gtest.Assert(result["ID"].Int(), 3)
})
gtest.Case(t, func() {
result, err := oradb.Table(table).Where("id", 30).Or("nickname", "T3").And("id>", 1).One()
gtest.Assert(err, nil)
gtest.Assert(result["ID"].Int(), 3)
})
// map
gtest.Case(t, func() {
result, err := oradb.Table(table).Where(g.Map{"id": 3, "nickname": "T3"}).One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["ID"].Int(), 3)
})
// map key operator
gtest.Case(t, func() {
result, err := oradb.Table(table).Where(g.Map{"id>": 1, "id<": 3}).One()
gtest.Assert(err, nil)
gtest.Assert(result["ID"].Int(), 2)
})
// complicated where 1
gtest.Case(t, func() {
//oradb.SetDebug(true)
conditions := g.Map{
"nickname like ?": "%T%",
"id between ? and ?": g.Slice{1, 3},
"id > 0": nil,
"id": g.Slice{1, 2, 3},
}
result, err := oradb.Table(table).Where(conditions).OrderBy("id asc").All()
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
})
// complicated where 2
gtest.Case(t, func() {
//oradb.SetDebug(true)
conditions := g.Map{
"nickname like ?": "%T%",
"id between ? and ?": g.Slice{1, 3},
"id >= ?": 1,
"create_time > ?": " ",
"id in(?)": g.Slice{1, 2, 3},
}
result, err := oradb.Table(table).Where(conditions).OrderBy("id asc").All()
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
})
// struct
gtest.Case(t, func() {
type t_user struct {
Id int `json:"id"`
Nickname string `gconv:"nickname"`
}
result, err := oradb.Table(table).Where(t_user{3, "T3"}).One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["ID"].Int(), 3)
result, err = oradb.Table(table).Where(&t_user{3, "T3"}).One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["ID"].Int(), 3)
})
// slice single
gtest.Case(t, func() {
result, err := oradb.Table(table).Where("id IN(?)", g.Slice{1, 3}).OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 2)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[1]["ID"].Int(), 3)
})
// slice + string
gtest.Case(t, func() {
result, err := oradb.Table(table).Where("nickname=? AND id IN(?)", "T3", g.Slice{1, 3}).OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["ID"].Int(), 3)
})
// slice + map
gtest.Case(t, func() {
result, err := oradb.Table(table).Where(g.Map{
"id": g.Slice{1, 3},
"nickname": "T3",
}).OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["ID"].Int(), 3)
})
// slice + struct
gtest.Case(t, func() {
type t_user struct {
Ids []int `json:"id"`
Nickname string `gconv:"nickname"`
}
result, err := oradb.Table(table).Where(t_user{
Ids: []int{1, 3},
Nickname: "T3",
}).OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["ID"].Int(), 3)
})
}
func Test_Model_Limit_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
_, err := oradb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
oradb.SetDebug(true)
defer oradb.SetDebug(false)
gtest.Case(t, func() {
result, err := oradb.Table(table).Fields("*").Where("id>?", 0).Limit(1, 2).OrderBy("id").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 2)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[0]["NICKNAME"].String(), "T1")
gtest.Assert(result[0]["CREATE_TIME"].String(), "2018-10-10 00:01:10")
gtest.Assert(result[1]["ID"].Int(), 2)
gtest.Assert(result[1]["NICKNAME"].String(), "T2")
})
gtest.Case(t, func() {
result, err := oradb.Table(table).Fields("*").Where("id>?", 0).Limit(0, 3).OrderBy("id").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["ID"].Int(), 1)
gtest.Assert(result[0]["NICKNAME"].String(), "T1")
gtest.Assert(result[0]["CREATE_TIME"].String(), "2018-10-10 00:01:10")
gtest.Assert(result[1]["ID"].Int(), 2)
gtest.Assert(result[1]["NICKNAME"].String(), "T2")
})
}

111
database/gdb/gdb_unit_z_oracle_struct_test.go
View File

@ -1,111 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb_test
import (
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
"strings"
"testing"
)
func Test_Model_Inherit_Insert_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
gtest.Case(t, func() {
type Base struct {
Id int `json:"id"`
Uid int `json:"uid"`
CreateTime string `json:"create_time"`
}
type User struct {
Base
Passport string `json:"passport"`
Password string `json:"password"`
Nickname string `json:"nickname"`
}
result, err := oradb.Table(table).Filter().Data(User{
Passport: "john-test",
Password: "123456",
Nickname: "John",
Base: Base{
Id: 100,
Uid: 100,
CreateTime: gtime.Now().String(),
},
}).Insert()
gtest.Assert(err, nil)
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
value, err := oradb.Table(table).Fields("passport").Where("id=100").Value()
gtest.Assert(err, nil)
gtest.Assert(value.String(), "john-test")
// Delete this test data.
_, err = oradb.Table(table).Where("id", 100).Delete()
gtest.Assert(err, nil)
})
}
func Test_Model_Inherit_MapToStruct_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
gtest.Case(t, func() {
type Ids struct {
Id int `json:"id"`
Uid int `json:"uid"`
}
type Base struct {
Ids
CreateTime string `json:"create_time"`
}
type User struct {
Base
Passport string `json:"passport"`
Password string `json:"password"`
Nickname string `json:"nickname"`
}
data := g.Map{
"id": 100,
"uid": 101,
"passport": "t1",
"password": "123456",
"nickname": "T1",
"create_time": gtime.Now().String(),
}
result, err := oradb.Table(table).Filter().Data(data).Insert()
gtest.Assert(err, nil)
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
one, err := oradb.Table(table).Where("id=100").One()
gtest.Assert(err, nil)
user := new(User)
gtest.Assert(one.Struct(user), nil)
gtest.Assert(user.Id, data["id"])
gtest.Assert(user.Passport, data["passport"])
gtest.Assert(strings.TrimSpace(user.Password), data["password"])
gtest.Assert(user.Nickname, data["nickname"])
gtest.Assert(user.CreateTime, data["create_time"])
// Delete this test data.
_, err = oradb.Table(table).Where("id", 100).Delete()
gtest.Assert(err, nil)
})
}

717
database/gdb/gdb_unit_z_oracle_transaction_test.go
View File

@ -1,717 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb_test
import (
"fmt"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
"strings"
"testing"
)
func Test_TX_Query_Oracle(t *testing.T) {
tx, err := db.Begin()
if err != nil {
gtest.Fatal(err)
}
if rows, err := tx.Query("SELECT ? FROM DUAL", 1); err != nil {
gtest.Fatal(err)
} else {
rows.Close()
}
if rows, err := tx.Query("SELECT ?+? FROM DUAL", 1, 2); err != nil {
gtest.Fatal(err)
} else {
rows.Close()
}
if rows, err := tx.Query("SELECT ?+? FROM DUAL", g.Slice{1, 2}); err != nil {
gtest.Fatal(err)
} else {
rows.Close()
}
if _, err := tx.Query("ERROR"); err == nil {
gtest.Fatal("FAIL")
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_Exec_Oracle(t *testing.T) {
tx, err := db.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.Exec("SELECT ? FROM DUAL", 1); err != nil {
gtest.Fatal(err)
}
if _, err := tx.Exec("SELECT ?+? FROM DUAL", 1, 2); err != nil {
gtest.Fatal(err)
}
if _, err := tx.Exec("SELECT ?+? FROM DUAL", g.Slice{1, 2}); err != nil {
gtest.Fatal(err)
}
if _, err := tx.Exec("ERROR"); err == nil {
gtest.Fatal("FAIL")
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_Commit_Oracle(t *testing.T) {
if oradb == nil {
return
}
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_Rollback_Oracle(t *testing.T) {
if oradb == nil {
return
}
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if err := tx.Rollback(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_Prepare_Oracle(t *testing.T) {
if oradb == nil {
return
}
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
st, err := tx.Prepare("SELECT 100 FROM DUAL")
if err != nil {
gtest.Fatal(err)
}
rows, err := st.Query()
if err != nil {
gtest.Fatal(err)
}
array, err := rows.Columns()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(array[0], "100")
if err := rows.Close(); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_Insert_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createTableOracle()
defer dropTableOracle(table)
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.Insert(table, g.Map{
"id": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
}); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
if n, err := oradb.Table(table).Count(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(n, 1)
}
}
func Test_TX_BatchInsert_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createTableOracle()
defer dropTableOracle(table)
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.BatchInsert(table, g.List{
{
"id": 2,
"passport": "t",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
},
{
"id": 3,
"passport": "t3",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T3",
"create_time": gtime.Now().String(),
},
}, 10); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
if n, err := oradb.Table(table).Count(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(n, 2)
}
}
func Test_TX_BatchReplace_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createTableOracle()
defer dropTableOracle(table)
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.BatchReplace(table, g.List{
{
"id": 2,
"passport": "t2",
"password": "p2",
"nickname": "T2",
"create_time": gtime.Now().String(),
},
{
"id": 4,
"passport": "t4",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T4",
"create_time": gtime.Now().String(),
},
}, 10); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
// 数据数量
if n, err := oradb.Table(table).Count(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(n, 2)
}
// 检查replace后的数值
if value, err := oradb.Table(table).Fields("password").Where("id", 2).Value(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(strings.TrimSpace(value.String()), "p2")
}
}
func Test_TX_BatchSave_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createTableOracle()
defer dropTableOracle(table)
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.BatchSave(table, g.List{
{
"id": 4,
"passport": "t4",
"password": "p4",
"nickname": "T4",
"create_time": gtime.Now().String(),
},
}, 10); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
// 数据数量
if n, err := oradb.Table(table).Count(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(n, 1)
}
// 检查replace后的数值
if value, err := oradb.Table(table).Fields("password").Where("id", 4).Value(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(strings.TrimSpace(value.String()), "p4")
}
}
func Test_TX_Replace_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.Replace(table, g.Map{
"id": 1,
"passport": "t11",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T11",
"create_time": gtime.Now().String(),
}); err != nil {
gtest.Fatal(err)
}
if err := tx.Rollback(); err != nil {
gtest.Fatal(err)
}
if value, err := oradb.Table(table).Fields("nickname").Where("id", 1).Value(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(value.String(), "T1")
}
}
func Test_TX_Save_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createTableOracle()
defer dropTableOracle(table)
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.Save(table, g.Map{
"id": 1,
"passport": "t11",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T11",
"create_time": gtime.Now().String(),
}); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
if value, err := oradb.Table(table).Fields("nickname").Where("id", 1).Value(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(value.String(), "T11")
}
}
func Test_TX_Update_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
gtest.Case(t, func() {
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if result, err := oradb.Update(table, "create_time='2010-10-10 00:00:01'", "id=3"); err != nil {
gtest.Fatal(err)
} else {
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
if value, err := oradb.Table(table).Fields("create_time").Where("id", 3).Value(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(value.String(), "2010-10-10 00:00:01")
}
})
}
func Test_TX_GetAll_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if result, err := tx.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(len(result), 1)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_GetOne_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if record, err := tx.GetOne(fmt.Sprintf("SELECT * FROM %s WHERE passport=?", table), "t2"); err != nil {
gtest.Fatal(err)
} else {
if record == nil {
gtest.Fatal("FAIL")
}
gtest.Assert(record["NICKNAME"].String(), "T2")
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_GetValue_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if value, err := tx.GetValue(fmt.Sprintf("SELECT id FROM %s WHERE passport=?", table), "t3"); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(value.Int(), 3)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_GetCount_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if count, err := tx.GetCount(fmt.Sprintf("SELECT * FROM %s", table)); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(count, INIT_DATA_SIZE)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
}
func Test_TX_GetStruct_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
_, err := oradb.Table(table).Data("create_time", "2010-10-10 00:00:01").Where("id = ?", 3).Update()
gtest.Assert(err, nil)
gtest.Case(t, func() {
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
user := new(User)
if err := tx.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T3")
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
gtest.Case(t, func() {
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
if err := tx.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T3")
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
}
func Test_TX_GetStructs_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
_, err := oradb.Table(table).Data("create_time", "2010-10-10 00:00:01").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
gtest.Case(t, func() {
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
if err := tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? order by id", table), 1); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
gtest.Case(t, func() {
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []User
if err := tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? order by id", table), 1); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
}
func Test_TX_GetScan_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
_, err := oradb.Table(table).Data("create_time", "2010-10-10 00:00:01").Where("id = ?", 3).Update()
gtest.Assert(err, nil)
gtest.Case(t, func() {
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
user := new(User)
if err := tx.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T3")
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
gtest.Case(t, func() {
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
if err := tx.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T3")
gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
gtest.Case(t, func() {
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
if err := tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? order by id", table), 1); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
gtest.Case(t, func() {
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []User
if err := tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? order by id", table), 1); err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[2].CreateTime.String(), "2010-10-10 00:00:01")
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
})
}
func Test_TX_Delete_Oracle(t *testing.T) {
if oradb == nil {
return
}
table := createInitTableOracle()
defer dropTableOracle(table)
tx, err := oradb.Begin()
if err != nil {
gtest.Fatal(err)
}
if _, err := tx.Delete(table, nil); err != nil {
gtest.Fatal(err)
}
if err := tx.Commit(); err != nil {
gtest.Fatal(err)
}
if n, err := oradb.Table(table).Count(); err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(n, 0)
}
}

1003
database/gdb/gdb_unit_z_pgsql_method_test.go
View File

File diff suppressed because it is too large Load Diff

816
database/gdb/gdb_unit_z_pgsql_model_test.go
View File

@ -1,816 +0,0 @@
// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
//
// This Source Code Form is subject to the terms of the MIT License.
// If a copy of the MIT was not distributed with this file,
// You can obtain one at https://github.com/gogf/gf.
package gdb_test
import (
"database/sql"
"testing"
"github.com/gogf/gf/frame/g"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/test/gtest"
)
// 基本测试
func Test_Model_Insert_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createTablePgsql()
defer dropTablePgsql(table)
result, err := pgdb.Table(table).Filter().Data(g.Map{
"id": 1,
"uid": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
}).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
result, err = pgdb.Table(table).Filter().Data(map[interface{}]interface{}{
"id": "2",
"uid": "2",
"passport": "t2",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
}).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
type t_user struct {
Id int `gconv:"id"`
Uid int `gconv:"uid"`
Passport string `json:"passport"`
Password string `gconv:"password"`
Nickname string `gconv:"nickname"`
CreateTime string `json:"create_time"`
}
result, err = pgdb.Table(table).Filter().Data(t_user{
Id: 3,
Uid: 3,
Passport: "t3",
Password: "25d55ad283aa400af464c76d713c07ad",
Nickname: "T3",
CreateTime: gtime.Now().String(),
}).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
value, err := pgdb.Table(table).Fields("passport").Where("id=3").Value()
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t3")
result, err = pgdb.Table(table).Filter().Data(&t_user{
Id: 4,
Uid: 4,
Passport: "t4",
Password: "25d55ad283aa400af464c76d713c07ad",
Nickname: "T4",
CreateTime: gtime.Now().String(),
}).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ = result.RowsAffected()
gtest.Assert(n, 1)
value, err = pgdb.Table(table).Fields("passport").Where("id=4").Value()
gtest.Assert(err, nil)
gtest.Assert(value.String(), "t4")
}
func Test_Model_Batch_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createTablePgsql()
defer dropTablePgsql(table)
// batch insert
gtest.Case(t, func() {
result, err := pgdb.Table(table).Filter().Data(g.List{
{
"id": 2,
"uid": 2,
"passport": "t2",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T2",
"create_time": gtime.Now().String(),
},
{
"id": 3,
"uid": 3,
"passport": "t3",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T3",
"create_time": gtime.Now().String(),
},
}).Batch(1).Insert()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 2)
})
}
/*
func Test_Model_Replace_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
result, err := pgdb.Table(table).Data(g.Map{
"id": 1,
"passport": "t11",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T11",
"create_time": "2018-10-10 00:01:10",
}).Replace()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
func Test_Model_Save_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
result, err := pgdb.Table(table).Data(g.Map{
"id": 1,
"passport": "t111",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T111",
"create_time": "2018-10-10 00:01:10",
}).Save()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
}
*/
func Test_Model_Update_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
gtest.Case(t, func() {
pgdb.SetDebug(true)
defer pgdb.SetDebug(false)
result, err := pgdb.Table(table).Data("nickname", "T100").Where("id", 10).Update()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
v1, err := pgdb.Table(table).Fields("nickname").Where("id", 10).Value()
gtest.Assert(err, nil)
gtest.Assert(v1.String(), "T100")
v2, err := pgdb.Table(table).Fields("nickname").Where("id", 8).Value()
gtest.Assert(err, nil)
gtest.Assert(v2.String(), "T8")
})
gtest.Case(t, func() {
result, err := pgdb.Table(table).Data("passport", "t22").Where("passport=?", "t2").Update()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
})
gtest.Case(t, func() {
result, err := pgdb.Table(table).Data("passport", "t2").Where("passport='t22'").Update()
if err != nil {
gtest.Fatal(err)
}
n, _ := result.RowsAffected()
gtest.Assert(n, 1)
})
}
func Test_Model_Clone_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
md := pgdb.Table(table).Where("id IN(?)", g.Slice{1, 3})
count, err := md.Count()
if err != nil {
gtest.Fatal(err)
}
record, err := md.OrderBy("id DESC").One()
if err != nil {
gtest.Fatal(err)
}
result, err := md.OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 2)
gtest.Assert(record["id"].Int(), 3)
gtest.Assert(len(result), 2)
gtest.Assert(result[0]["id"].Int(), 1)
gtest.Assert(result[1]["id"].Int(), 3)
}
func Test_Model_Safe_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
gtest.Case(t, func() {
md := pgdb.Table(table).Safe(false).Where("id IN(?)", g.Slice{1, 3})
count, err := md.Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 2)
md.And("id = ?", 1)
count, err = md.Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 1)
})
gtest.Case(t, func() {
md := pgdb.Table(table).Safe(true).Where("id IN(?)", g.Slice{1, 3})
count, err := md.Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 2)
md.And("id = ?", 1)
count, err = md.Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, 2)
})
}
func Test_Model_All_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
result, err := pgdb.Table(table).All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), INIT_DATA_SIZE)
}
func Test_Model_One_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
record, err := pgdb.Table(table).Where("id", 1).One()
if err != nil {
gtest.Fatal(err)
}
if record == nil {
gtest.Fatal("FAIL")
}
gtest.Assert(record["nickname"].String(), "T1")
}
func Test_Model_Value_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
value, err := pgdb.Table(table).Fields("nickname").Where("id", 1).Value()
if err != nil {
gtest.Fatal(err)
}
if value == nil {
gtest.Fatal("FAIL")
}
gtest.Assert(value.String(), "T1")
}
func Test_Model_Count_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
count, err := pgdb.Table(table).Count()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(count, INIT_DATA_SIZE)
}
func Test_Model_Select_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
result, err := pgdb.Table(table).Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), INIT_DATA_SIZE)
}
func Test_Model_Struct_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
_, err := pgdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
user := new(User)
err := pgdb.Table(table).Where("id=1").Struct(user)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T1")
gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
err := pgdb.Table(table).Where("id=1").Struct(user)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T1")
gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
err := pgdb.Table(table).Where("id=-1").Struct(user)
gtest.Assert(err, sql.ErrNoRows)
})
}
func Test_Model_Structs_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
_, err := pgdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
err := pgdb.Table(table).OrderBy("id").Structs(&users)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []*User
err := pgdb.Table(table).OrderBy("id asc").Structs(&users)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []*User
err := pgdb.Table(table).Where("id<0").Structs(&users)
gtest.Assert(err, sql.ErrNoRows)
})
}
func Test_Model_Scan_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
_, err := pgdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
user := new(User)
err := pgdb.Table(table).Where("id=1").Scan(user)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T1")
gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
err := pgdb.Table(table).Where("id=1").Scan(user)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(user.NickName, "T1")
gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime gtime.Time
}
var users []User
err := pgdb.Table(table).OrderBy("id asc").Scan(&users)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
var users []*User
err := pgdb.Table(table).OrderBy("id asc").Scan(&users)
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(users), INIT_DATA_SIZE)
gtest.Assert(users[0].Id, 1)
gtest.Assert(users[1].Id, 2)
gtest.Assert(users[2].Id, 3)
gtest.Assert(users[0].NickName, "T1")
gtest.Assert(users[1].NickName, "T2")
gtest.Assert(users[2].NickName, "T3")
gtest.Assert(users[0].CreateTime.String(), "2018-10-10 00:01:10")
})
gtest.Case(t, func() {
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime *gtime.Time
}
user := new(User)
users := new([]*User)
err1 := pgdb.Table(table).Where("id < 0").Scan(user)
err2 := pgdb.Table(table).Where("id < 0").Scan(users)
gtest.Assert(err1, sql.ErrNoRows)
gtest.Assert(err2, sql.ErrNoRows)
})
}
func Test_Model_OrderBy_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
_, err := pgdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
result, err := pgdb.Table(table).OrderBy("id").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), INIT_DATA_SIZE)
gtest.Assert(result[0]["nickname"].String(), "T1")
}
func Test_Model_GroupBy_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
_, err := pgdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
result, err := pgdb.Table(table).Fields("nickname,count(*)").OrderBy("nickname").GroupBy("nickname").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), INIT_DATA_SIZE)
gtest.Assert(result[0]["nickname"].String(), "T1")
}
func Test_Model_Where_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
_, err := pgdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 1).Update()
gtest.Assert(err, nil)
// string
gtest.Case(t, func() {
result, err := pgdb.Table(table).Where("id=? and nickname=?", 3, "T3").One()
if err != nil {
gtest.Fatal(err)
}
gtest.AssertGT(len(result), 0)
gtest.Assert(result["id"].Int(), 3)
})
gtest.Case(t, func() {
result, err := pgdb.Table(table).Where("id", 3).One()
if err != nil {
gtest.Fatal(err)
}
gtest.AssertGT(len(result), 0)
gtest.Assert(result["id"].Int(), 3)
})
gtest.Case(t, func() {
result, err := pgdb.Table(table).Where("id", 3).Where("nickname", "T3").One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["id"].Int(), 3)
})
gtest.Case(t, func() {
result, err := pgdb.Table(table).Where("id", 3).And("nickname", "T3").One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["id"].Int(), 3)
})
gtest.Case(t, func() {
result, err := pgdb.Table(table).Where("id", 30).Or("nickname", "T3").One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["id"].Int(), 3)
})
gtest.Case(t, func() {
result, err := pgdb.Table(table).Where("id", 30).Or("nickname", "T3").And("id>?", 1).One()
gtest.Assert(err, nil)
gtest.Assert(result["id"].Int(), 3)
})
gtest.Case(t, func() {
result, err := pgdb.Table(table).Where("id", 30).Or("nickname", "T3").And("id>", 1).One()
gtest.Assert(err, nil)
gtest.Assert(result["id"].Int(), 3)
})
// map
gtest.Case(t, func() {
result, err := pgdb.Table(table).Where(g.Map{"id": 3, "nickname": "T3"}).One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["id"].Int(), 3)
})
// map key operator
gtest.Case(t, func() {
result, err := pgdb.Table(table).Where(g.Map{"id>": 1, "id<": 3}).One()
gtest.Assert(err, nil)
gtest.Assert(result["id"].Int(), 2)
})
// complicated where 1
gtest.Case(t, func() {
//pgdb.SetDebug(true)
conditions := g.Map{
"nickname like ?": "%T%",
"id between ? and ?": g.Slice{1, 3},
"id > 0": nil,
"id": g.Slice{1, 2, 3},
}
result, err := pgdb.Table(table).Where(conditions).OrderBy("id asc").All()
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["id"].Int(), 1)
})
// complicated where 2
gtest.Case(t, func() {
//pgdb.SetDebug(true)
conditions := g.Map{
"nickname like ?": "%T%",
"id between ? and ?": g.Slice{1, 3},
"id >= ?": 1,
"id in(?)": g.Slice{1, 2, 3},
}
result, err := pgdb.Table(table).Where(conditions).OrderBy("id asc").All()
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["id"].Int(), 1)
})
// struct
gtest.Case(t, func() {
type t_user struct {
Id int `json:"id"`
Nickname string `gconv:"nickname"`
}
result, err := pgdb.Table(table).Where(t_user{3, "T3"}).One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["id"].Int(), 3)
result, err = pgdb.Table(table).Where(&t_user{3, "T3"}).One()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result["id"].Int(), 3)
})
// slice single
gtest.Case(t, func() {
result, err := pgdb.Table(table).Where("id IN(?)", g.Slice{1, 3}).OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 2)
gtest.Assert(result[0]["id"].Int(), 1)
gtest.Assert(result[1]["id"].Int(), 3)
})
// slice + string
gtest.Case(t, func() {
result, err := pgdb.Table(table).Where("nickname=? AND id IN(?)", "T3", g.Slice{1, 3}).OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["id"].Int(), 3)
})
// slice + map
gtest.Case(t, func() {
result, err := pgdb.Table(table).Where(g.Map{
"id": g.Slice{1, 3},
"nickname": "T3",
}).OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["id"].Int(), 3)
})
// slice + struct
gtest.Case(t, func() {
type t_user struct {
Ids []int `json:"id"`
Nickname string `gconv:"nickname"`
}
result, err := pgdb.Table(table).Where(t_user{
Ids: []int{1, 3},
Nickname: "T3",
}).OrderBy("id ASC").All()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["id"].Int(), 3)
})
}
func Test_Model_Limit_Pgsql(t *testing.T) {
if pgdb == nil {
return
}
table := createInitTablePgsql()
defer dropTablePgsql(table)
gtest.Case(t, func() {
result, err := pgdb.Table(table).Fields("*").Where("id>?", 0).Limit(1, 2).OrderBy("id").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 1)
gtest.Assert(result[0]["id"].Int(), 3)
gtest.Assert(result[0]["nickname"].String(), "T3")
})
}