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

add oracle/mssql/postgres unit test cases

Browse Source
This commit is contained in:
wenzi1
2019-08-12 16:50:57 +08:00
parent d03180ff4d
commit 296c4b750b
21 changed files with 8263 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
database/gdb/gdb_mssql.go
View File

@ -14,10 +14,12 @@ package gdb
import (
"database/sql"
"fmt"
"github.com/gogf/gf/encoding/gbinary"
"github.com/gogf/gf/os/gtime"
"github.com/gogf/gf/text/gregex"
"github.com/gogf/gf/util/gconv"
"strconv"
"strings"
"github.com/gogf/gf/text/gregex"
)
// 数据库链接对象
@ -151,7 +153,7 @@ func (db *dbMssql) parseSql(sql string) string {
// 获得指定表表的数据结构，构造成map哈希表返回，其中键名为表字段名称，键值暂无用途(默认为字段数据类型).
func (db *dbMssql) getTableFields(table string) (fields map[string]string, err error) {
// 缓存不存在时会查询数据表结构，缓存后不过期，直至程序重启(重新部署)
v := db.cache.GetOrSetFunc("table_fields_"+table, func() interface{} {
v := db.cache.GetOrSetFunc("mssql_table_fields_"+table, func() interface{} {
result := (Result)(nil)
result, err = db.GetAll(fmt.Sprintf(`
SELECT c.name as FIELD, CASE t.name
@ -174,3 +176,64 @@ func (db *dbMssql) getTableFields(table string) (fields map[string]string, err e
}
return
}
// 字段类型转换，将数据库字段类型转换为golang变量类型
//mssql的datetime类型返回的格式为："2018-02-09T20:46:17Z"，所以这里对datetime类型转换为:"2018-02-09 20:46:17"
//@TODO 下面这些类型的处理是从MYSQL拷过来的，需要针对mssql完善
// 字段类型转换，将数据库字段类型转换为golang变量类型
func (db *dbMssql) convertValue(fieldValue []byte, fieldType string) interface{} {
t, _ := gregex.ReplaceString(`\(.+\)`, "", fieldType)
t = strings.ToLower(t)
switch t {
case "binary", "varbinary", "blob", "tinyblob", "mediumblob", "longblob":
return fieldValue
case "int", "tinyint", "small_int", "medium_int":
return gconv.Int(string(fieldValue))
case "big_int":
return gconv.Int64(string(fieldValue))
case "float", "double", "decimal":
return gconv.Float64(string(fieldValue))
case "bit":
s := string(fieldValue)
// 这里的字符串判断是为兼容不同的数据库类型，如: mssql
if strings.EqualFold(s, "true") {
return 1
}
if strings.EqualFold(s, "false") {
return 0
}
return gbinary.BeDecodeToInt64(fieldValue)
case "bool":
return gconv.Bool(fieldValue)
default:
// 自动识别类型, 以便默认支持更多数据库类型
switch {
case strings.Contains(t, "datetime"):
t, _ := gtime.StrToTime(gconv.String(fieldValue))
return t.UTC().String()
case strings.Contains(t, "int"):
return gconv.Int(string(fieldValue))
case strings.Contains(t, "text") || strings.Contains(t, "char"):
return string(fieldValue)
case strings.Contains(t, "float") || strings.Contains(t, "double"):
return gconv.Float64(string(fieldValue))
case strings.Contains(t, "bool"):
return gconv.Bool(string(fieldValue))
case strings.Contains(t, "binary") || strings.Contains(t, "blob"):
return fieldValue
default:
return string(fieldValue)
}
}
}

304
database/gdb/gdb_oracle.go
View File

@ -12,11 +12,12 @@ package gdb
import (
"database/sql"
"errors"
"fmt"
"github.com/gogf/gf/text/gregex"
"reflect"
"strconv"
"strings"
"github.com/gogf/gf/text/gregex"
)
// 数据库链接对象
@ -24,6 +25,11 @@ type dbOracle struct {
*dbBase
}
const (
tableAlias1 = "GFORM1"
tableAlias2 = "GFORM2"
)
// 创建SQL操作对象
func (db *dbOracle) Open(config *ConfigNode) (*sql.DB, error) {
var source string
@ -60,7 +66,7 @@ func (db *dbOracle) handleSqlBeforeExec(query string) string {
//由于ORACLE中对LIMIT和批量插入的语法与MYSQL不一致，所以这里需要对LIMIT和批量插入做语法上的转换
func (db *dbOracle) parseSql(sql string) string {
//下面的正则表达式匹配出SELECT和INSERT的关键字后分别做不同的处理，如有LIMIT则将LIMIT的关键字也匹配出
patten := `^\s*(?i)(SELECT)|(INSERT)|(LIMIT\s*(\d+)\s*,\s*(\d+))`
patten := `^\s*(?i)(SELECT)|(LIMIT\s*(\d+)\s*,\s*(\d+))`
if gregex.IsMatchString(patten, sql) == false {
//fmt.Println("not matched..")
return sql
@ -110,32 +116,6 @@ func (db *dbOracle) parseSql(sql string) string {
//也可以使用between,据说这种写法的性能会比between好点,里层SQL中的ROWNUM_ >= limit可以缩小查询后的数据集规模
sql = fmt.Sprintf("SELECT * FROM (SELECT GFORM.*, ROWNUM ROWNUM_ FROM (%s %s) GFORM WHERE ROWNUM <= %d) WHERE ROWNUM_ >= %d", queryExpr[1], queryExpr[2], limit, first)
case "INSERT":
//获取VALUE的值，匹配所有带括号的值,会将INSERT INTO后的值匹配到，所以下面的判断语句会判断数组长度是否小于3
valueExpr, err := gregex.MatchAllString(`(\s*\(([^\(\)]*)\))`, sql)
if err != nil {
return sql
}
//判断VALUE后的值是否有多个，只有在批量插入的时候才需要做转换，如只有1个VALUE则不需要做转换
if len(valueExpr) < 3 {
break
}
//获取INTO后面的值
tableExpr, err := gregex.MatchString(`(?i)\s*(INTO\s+\w+\(([^\(\)]*)\))`, sql)
if err != nil {
return sql
}
tableExpr[0] = strings.TrimSpace(tableExpr[0])
sql = "INSERT ALL"
for i := 1; i < len(valueExpr); i++ {
sql += fmt.Sprintf(" %s VALUES%s", tableExpr[0], strings.TrimSpace(valueExpr[i][0]))
}
sql += " SELECT 1 FROM DUAL"
default:
}
return sql
}
@ -143,7 +123,7 @@ func (db *dbOracle) parseSql(sql string) string {
// 获得指定表表的数据结构，构造成map哈希表返回，其中键名为表字段名称，键值暂无用途(默认为字段数据类型).
func (db *dbOracle) getTableFields(table string) (fields map[string]string, err error) {
// 缓存不存在时会查询数据表结构，缓存后不过期，直至程序重启(重新部署)
v := db.cache.GetOrSetFunc("table_fields_"+table, func() interface{} {
v := db.cache.GetOrSetFunc("oracle_table_fields_"+table, func() interface{} {
result := (Result)(nil)
result, err = db.GetAll(fmt.Sprintf(`
SELECT COLUMN_NAME AS FIELD, CASE DATA_TYPE
@ -166,3 +146,267 @@ func (db *dbOracle) getTableFields(table string) (fields map[string]string, err
}
return
}
//查询表的主键及唯一索引并存入缓存中
func (db *dbOracle) getTableUniqueIndex(table string) (fields map[string]map[string]string, err error) {
table = strings.ToUpper(table)
v := db.cache.GetOrSetFunc("table_unique_index_"+table, func() interface{} {
res := (Result)(nil)
res, err = db.GetAll(fmt.Sprintf(`
SELECT INDEX_NAME,COLUMN_NAME,CHAR_LENGTH FROM USER_IND_COLUMNS
WHERE TABLE_NAME = '%s'
AND INDEX_NAME IN(SELECT INDEX_NAME FROM USER_INDEXES WHERE TABLE_NAME='%s' AND UNIQUENESS='UNIQUE')
ORDER BY INDEX_NAME,COLUMN_POSITION`, table, table))
if err != nil {
return nil
}
fields := make(map[string]map[string]string)
for _, v := range res {
mm := make(map[string]string)
mm[v["COLUMN_NAME"].String()] = v["CHAR_LENGTH"].String()
fields[v["INDEX_NAME"].String()] = mm
}
return fields
}, 0)
if err == nil {
fields = v.(map[string]map[string]string)
}
return
}
// 支持insert、replace, save， ignore操作。
// 0: insert: 仅仅执行写入操作，如果存在冲突的主键或者唯一索引，那么报错返回;
// 1: replace: 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条;
// 2: save: 如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据;
// 3: ignore: 如果数据存在(主键或者唯一索引)，那么什么也不做,需ORACLE 11G以上版本
//
// 注意：对于replace/save/ignore操作只支持表中存在一个唯一索引或主键的情况，
// 如存在多个唯一索引或主键有可能会执行失败，因为这3种类型的操作需指定唯一索引，没有唯一索引情况下统一执行insert
//
// 参数data支持map/struct/*struct/slice类型，
// 当为slice(例如[]map/[]struct/[]*struct)类型时，batch参数生效，并自动切换为批量操作。
func (db *dbOracle) doInsert(link dbLink, table string, data interface{}, option int, batch ...int) (result sql.Result, err error) {
var fields []string
var values []string
var params []interface{}
var dataMap Map
// 使用反射判断data数据类型，如果为slice类型，那么自动转为批量操作
rv := reflect.ValueOf(data)
kind := rv.Kind()
if kind == reflect.Ptr {
rv = rv.Elem()
kind = rv.Kind()
}
switch kind {
case reflect.Slice:
fallthrough
case reflect.Array:
return db.db.doBatchInsert(link, table, data, option, batch...)
case reflect.Map:
fallthrough
case reflect.Struct:
dataMap = structToMap(data)
default:
return result, errors.New(fmt.Sprint("unsupported data type:", kind))
}
indexs := make([]string, 0)
indexMap := make(map[string]string)
indexExists := false
if option != OPTION_INSERT {
index, err := db.getTableUniqueIndex(table)
if err != nil {
return nil, err
}
if len(index) > 0 {
for _, v := range index {
for k, _ := range v {
indexs = append(indexs, k)
}
indexMap = v
indexExists = true
break
}
}
}
subSqlStr := make([]string, 0)
onStr := make([]string, 0)
updateStr := make([]string, 0)
charL, charR := db.db.getChars()
for k, v := range dataMap {
k = strings.ToUpper(k)
//操作类型为REPLACE/SAVE时且存在唯一索引才使用merge，否则使用insert
if (option == OPTION_REPLACE || option == OPTION_SAVE) && indexExists {
fields = append(fields, tableAlias1+"."+charL+k+charR)
values = append(values, tableAlias2+"."+charL+k+charR)
params = append(params, convertParam(v))
subSqlStr = append(subSqlStr, fmt.Sprintf("%s?%s %s", charL, charR, k))
//merge中的on子句中由唯一索引组成,update子句中不含唯一索引
if _, ok := indexMap[k]; ok {
onStr = append(onStr, fmt.Sprintf("%s.%s = %s.%s ", tableAlias1, k, tableAlias2, k))
} else {
updateStr = append(updateStr, fmt.Sprintf("%s.%s = %s.%s ", tableAlias1, k, tableAlias2, k))
}
} else {
fields = append(fields, charL+k+charR)
values = append(values, "?")
params = append(params, convertParam(v))
}
}
if link == nil {
if link, err = db.db.Master(); err != nil {
return nil, err
}
}
if indexExists && option != OPTION_INSERT {
switch option {
case OPTION_REPLACE:
fallthrough
case OPTION_SAVE:
tmp := fmt.Sprintf("MERGE INTO %s %s USING(SELECT %s FROM DUAL) %s ON(%s) WHEN MATCHED THEN UPDATE SET %s WHEN NOT MATCHED THEN INSERT (%s) VALUES(%s)",
table, tableAlias1, strings.Join(subSqlStr, ","), tableAlias2,
strings.Join(onStr, "AND"), strings.Join(updateStr, ","), strings.Join(fields, ","), strings.Join(values, ","))
return db.db.doExec(link, tmp, params...)
case OPTION_IGNORE:
return db.db.doExec(link,
fmt.Sprintf("INSERT /*+ IGNORE_ROW_ON_DUPKEY_INDEX(%s(%s)) */ INTO %s(%s) VALUES(%s)",
table, strings.Join(indexs, ","), table, strings.Join(fields, ","), strings.Join(values, ",")),
params...)
}
}
return db.db.doExec(link, fmt.Sprintf("INSERT INTO %s(%s) VALUES(%s)",
table, strings.Join(fields, ","), strings.Join(values, ",")), params...)
}
// 批量写入数据, 参数list支持slice类型，例如: []map/[]struct/[]*struct。
func (db *dbOracle) doBatchInsert(link dbLink, table string, list interface{}, option int, batch ...int) (result sql.Result, err error) {
var keys []string
var values []string
var params []interface{}
listMap := (List)(nil)
switch v := list.(type) {
case Result:
listMap = v.ToList()
case Record:
listMap = List{v.ToMap()}
case List:
listMap = v
case Map:
listMap = List{v}
default:
rv := reflect.ValueOf(list)
kind := rv.Kind()
if kind == reflect.Ptr {
rv = rv.Elem()
kind = rv.Kind()
}
switch kind {
// 如果是slice，那么转换为List类型
case reflect.Slice:
fallthrough
case reflect.Array:
listMap = make(List, rv.Len())
for i := 0; i < rv.Len(); i++ {
listMap[i] = structToMap(rv.Index(i).Interface())
}
case reflect.Map:
fallthrough
case reflect.Struct:
listMap = List{Map(structToMap(list))}
default:
return result, errors.New(fmt.Sprint("unsupported list type:", kind))
}
}
// 判断长度
if len(listMap) < 1 {
return result, errors.New("empty data list")
}
if link == nil {
if link, err = db.db.Master(); err != nil {
return
}
}
// 首先获取字段名称及记录长度
holders := []string(nil)
for k, _ := range listMap[0] {
keys = append(keys, k)
holders = append(holders, "?")
}
batchResult := new(batchSqlResult)
charL, charR := db.db.getChars()
keyStr := charL + strings.Join(keys, charL+","+charR) + charR
valueHolderStr := strings.Join(holders, ",")
// 当操作类型非insert时调用单笔的insert功能
if option != OPTION_INSERT {
for _, v := range listMap {
r, err := db.doInsert(link, table, v, option, 1)
if err != nil {
return r, err
}
if n, err := r.RowsAffected(); err != nil {
return r, err
} else {
batchResult.lastResult = r
batchResult.rowsAffected += n
}
}
return batchResult, nil
}
// 构造批量写入数据格式(注意map的遍历是无序的)
batchNum := gDEFAULT_BATCH_NUM
if len(batch) > 0 {
batchNum = batch[0]
}
intoStr := make([]string, 0) //组装into语句
for i := 0; i < len(listMap); i++ {
for _, k := range keys {
params = append(params, convertParam(listMap[i][k]))
}
values = append(values, valueHolderStr)
intoStr = append(intoStr, fmt.Sprintf(" INTO %s(%s) VALUES(%s) ", table, keyStr, valueHolderStr))
if len(intoStr) == batchNum {
r, err := db.db.doExec(link, fmt.Sprintf("INSERT ALL %s SELECT * FROM DUAL", strings.Join(intoStr, " ")), params...)
if err != nil {
return r, err
}
if n, err := r.RowsAffected(); err != nil {
return r, err
} else {
batchResult.lastResult = r
batchResult.rowsAffected += n
}
params = params[:0]
intoStr = intoStr[:0]
}
}
// 处理最后不构成指定批量的数据
if len(intoStr) > 0 {
r, err := db.db.doExec(link, fmt.Sprintf("INSERT ALL %s SELECT * FROM DUAL", strings.Join(intoStr, " ")), params...)
if err != nil {
return r, err
}
if n, err := r.RowsAffected(); err != nil {
return r, err
} else {
batchResult.lastResult = r
batchResult.rowsAffected += n
}
}
return batchResult, nil
}

29
database/gdb/gdb_pgsql.go
View File

@ -9,8 +9,8 @@ package gdb
import (
"database/sql"
"fmt"
"github.com/gogf/gf/text/gregex"
"strings"
)
// PostgreSQL的适配.
@ -32,7 +32,7 @@ func (db *dbPgsql) Open(config *ConfigNode) (*sql.DB, error) {
if config.LinkInfo != "" {
source = config.LinkInfo
} else {
source = fmt.Sprintf("user=%s password=%s host=%s port=%s dbname=%s", 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
@ -63,3 +63,28 @@ func (db *dbPgsql) handleSqlBeforeExec(query string) string {
query, _ = gregex.ReplaceString(` LIMIT (\d+),\s*(\d+)`, ` LIMIT $1 OFFSET $2`, query)
return query
}
func (db *dbPgsql) getTableFields(table string) (fields map[string]string, err error) {
// 缓存不存在时会查询数据表结构，缓存后不过期，直至程序重启(重新部署)
table, _ = gregex.ReplaceString("\"", "", table)
v := db.cache.GetOrSetFunc("pgsql_table_fields_"+table, func() interface{} {
result := (Result)(nil)
result, err = db.GetAll(fmt.Sprintf(`
SELECT a.attname AS field, t.typname AS type FROM pg_class c, pg_attribute a
LEFT OUTER JOIN pg_description b ON a.attrelid=b.objoid AND a.attnum = b.objsubid,pg_type t
WHERE c.relname = '%s' and a.attnum > 0 and a.attrelid = c.oid and a.atttypid = t.oid ORDER BY a.attnum`, strings.ToLower(table)))
if err != nil {
return nil
}
fields = make(map[string]string)
for _, m := range result {
fields[m["field"].String()] = m["type"].String()
}
return fields
}, 0)
if err == nil {
fields = v.(map[string]string)
}
return
}

21
database/gdb/gdb_unit_0_init_test.go Normal file
View File

@ -0,0 +1,21 @@
// 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/denisenkom/go-mssqldb"
_ "github.com/lib/pq"
//_ "github.com/mattn/go-oci8"
_ "github.com/gogf/gf/database/gdb"
)
func init() {
InitPgsql()
//InitOracle()
//InitMssql()
InitMysql()
}

113
database/gdb/gdb_unit_init_mssql_test.go Normal file
View File

@ -0,0 +1,113 @@
// 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)
}
}

111
database/gdb/gdb_unit_init_oracle_test.go Normal file
View File

@ -0,0 +1,111 @@
// 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)
}
}

121
database/gdb/gdb_unit_init_pgsql_test.go Normal file
View File

@ -0,0 +1,121 @@
// 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")
}
// 创建指定名称的user测试表，当table为空时，创建随机的表名。
// 创建的测试表默认没有任何数据。
// 执行完成后返回该表名。
// TODO 支持更多数据库
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)
}
}

29
database/gdb/gdb_unit_init_test.go
View File

@ -32,24 +32,27 @@ var (
// 初始化连接参数。
// 测试前需要修改连接参数。
func init() {
func InitMysql() {
node := gdb.ConfigNode{
Host: "127.0.0.1",
Port: "3306",
User: "root",
Pass: "",
Name: "",
Type: "mysql",
Role: "master",
Charset: "utf8",
Weight: 1,
Host: "140.143.231.161",
Port: "3306",
User: "root",
Pass: "lala1234",
Name: "",
Type: "mysql",
Role: "master",
Charset: "utf8",
Weight: 1,
MaxIdleConnCount: 10,
MaxOpenConnCount: 10,
MaxConnLifetime: 600,
}
// 作者本地测试hack
if hostname, _ := os.Hostname(); hostname == "ijohn" {
node.Pass = "12345678"
}
gdb.AddConfigNode("test", node)
gdb.AddConfigNode(gdb.DEFAULT_GROUP_NAME, node)
gdb.AddDefaultConfigNode(node)
if r, err := gdb.New(); err != nil {
gtest.Error(err)
} else {
@ -68,6 +71,10 @@ func init() {
db.SetSchema(SCHEMA1)
// 创建默认用户表
createTable(TABLE)
gdb.GetConfig("test")
gdb.GetDefaultGroup()
gdb.SetDefaultGroup(gdb.DEFAULT_GROUP_NAME)
}
// 创建指定名称的user测试表，当table为空时，创建随机的表名。

531
database/gdb/gdb_unit_z_method_test.go
View File

@ -8,6 +8,9 @@ package gdb_test
import (
"fmt"
"github.com/gogf/gf/database/gdb"
"github.com/gogf/gf/encoding/gjson"
"github.com/gogf/gf/encoding/gxml"
"testing"
"time"
@ -201,6 +204,9 @@ func Test_DB_BatchInsert(t *testing.T) {
gtest.Assert(err, nil)
n, _ := r.RowsAffected()
gtest.Assert(n, 2)
n, _ = r.LastInsertId()
gtest.Assert(n, 3)
})
gtest.Case(t, func() {
@ -625,3 +631,528 @@ func Test_DB_Time(t *testing.T) {
gtest.Assert(n, 2)
})
}
func Test_DB_ToJson(t *testing.T) {
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
gtest.Assert(err, nil)
gtest.Case(t, func() {
result, err := db.Table(table).Fields("*").Where("id =? ", 1).Select()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime string
}
users := make([]User, 0)
err = result.ToStructs(users)
gtest.AssertNE(err, nil)
err = result.ToStructs(&users)
if err != nil {
gtest.Fatal(err)
}
//ToJson
resultJson, err := gjson.LoadContent(result.ToJson())
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(users[0].Id, resultJson.GetInt("0.id"))
gtest.Assert(users[0].Passport, resultJson.GetString("0.passport"))
gtest.Assert(users[0].Password, resultJson.GetString("0.password"))
gtest.Assert(users[0].NickName, resultJson.GetString("0.nickname"))
gtest.Assert(users[0].CreateTime, resultJson.GetString("0.create_time"))
result = nil
err = result.ToStructs(&users)
gtest.AssertNE(err, nil)
})
gtest.Case(t, func() {
result, err := db.Table(table).Fields("*").Where("id =? ", 1).One()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime string
}
users := User{}
err = result.ToStruct(&users)
if err != nil {
gtest.Fatal(err)
}
result = nil
err = result.ToStruct(&users)
gtest.AssertNE(err, nil)
})
}
func Test_DB_ToXml(t *testing.T) {
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
gtest.Assert(err, nil)
gtest.Case(t, func() {
record, err := db.Table(table).Fields("*").Where("id = ?", 1).One()
if err != nil {
gtest.Fatal(err)
}
type User struct {
Id int
Passport string
Password string
NickName string
CreateTime string
}
user := User{}
err = record.ToStruct(&user)
if err != nil {
gtest.Fatal(err)
}
result, err := gxml.Decode([]byte(record.ToXml("doc")))
if err != nil {
gtest.Fatal(err)
}
resultXml := result["doc"].(map[string]interface{})
if v, ok := resultXml["id"]; ok {
gtest.Assert(user.Id, v)
} else {
gtest.Fatal("FAIL")
}
if v, ok := resultXml["passport"]; ok {
gtest.Assert(user.Passport, v)
} else {
gtest.Fatal("FAIL")
}
if v, ok := resultXml["password"]; ok {
gtest.Assert(user.Password, v)
} else {
gtest.Fatal("FAIL")
}
if v, ok := resultXml["nickname"]; ok {
gtest.Assert(user.NickName, v)
} else {
gtest.Fatal("FAIL")
}
if v, ok := resultXml["create_time"]; ok {
gtest.Assert(user.CreateTime, v)
} else {
gtest.Fatal("FAIL")
}
})
}
func Test_DB_ToStringMap(t *testing.T) {
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
gtest.Assert(err, nil)
gtest.Case(t, func() {
id := "1"
result, err := db.Table(table).Fields("*").Where("id = ?", 1).Select()
if err != nil {
gtest.Fatal(err)
}
type t_user struct {
Id int
Passport string
Password string
NickName string
CreateTime string
}
t_users := make([]t_user, 0)
err = result.ToStructs(&t_users)
if err != nil {
gtest.Fatal(err)
}
resultStringMap := result.ToStringMap("id")
gtest.Assert(t_users[0].Id, resultStringMap[id]["id"])
gtest.Assert(t_users[0].Passport, resultStringMap[id]["passport"])
gtest.Assert(t_users[0].Password, resultStringMap[id]["password"])
gtest.Assert(t_users[0].NickName, resultStringMap[id]["nickname"])
gtest.Assert(t_users[0].CreateTime, resultStringMap[id]["create_time"])
})
}
func Test_DB_ToIntMap(t *testing.T) {
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
gtest.Assert(err, nil)
gtest.Case(t, func() {
id := 1
result, err := db.Table(table).Fields("*").Where("id = ?", id).Select()
if err != nil {
gtest.Fatal(err)
}
type t_user struct {
Id int
Passport string
Password string
NickName string
CreateTime string
}
t_users := make([]t_user, 0)
err = result.ToStructs(&t_users)
if err != nil {
gtest.Fatal(err)
}
resultIntMap := result.ToIntMap("id")
gtest.Assert(t_users[0].Id, resultIntMap[id]["id"])
gtest.Assert(t_users[0].Passport, resultIntMap[id]["passport"])
gtest.Assert(t_users[0].Password, resultIntMap[id]["password"])
gtest.Assert(t_users[0].NickName, resultIntMap[id]["nickname"])
gtest.Assert(t_users[0].CreateTime, resultIntMap[id]["create_time"])
})
}
func Test_DB_ToUintMap(t *testing.T) {
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
gtest.Assert(err, nil)
gtest.Case(t, func() {
id := 1
result, err := db.Table(table).Fields("*").Where("id = ?", id).Select()
if err != nil {
gtest.Fatal(err)
}
type t_user struct {
Id int
Passport string
Password string
NickName string
CreateTime string
}
t_users := make([]t_user, 0)
err = result.ToStructs(&t_users)
if err != nil {
gtest.Fatal(err)
}
resultUintMap := result.ToUintMap("id")
gtest.Assert(t_users[0].Id, resultUintMap[uint(id)]["id"])
gtest.Assert(t_users[0].Passport, resultUintMap[uint(id)]["passport"])
gtest.Assert(t_users[0].Password, resultUintMap[uint(id)]["password"])
gtest.Assert(t_users[0].NickName, resultUintMap[uint(id)]["nickname"])
gtest.Assert(t_users[0].CreateTime, resultUintMap[uint(id)]["create_time"])
})
}
func Test_DB_ToStringRecord(t *testing.T) {
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
gtest.Assert(err, nil)
gtest.Case(t, func() {
id := 1
ids := "1"
result, err := db.Table(table).Fields("*").Where("id = ?", id).Select()
if err != nil {
gtest.Fatal(err)
}
type t_user struct {
Id int
Passport string
Password string
NickName string
CreateTime string
}
t_users := make([]t_user, 0)
err = result.ToStructs(&t_users)
if err != nil {
gtest.Fatal(err)
}
resultStringRecord := result.ToStringRecord("id")
gtest.Assert(t_users[0].Id, resultStringRecord[ids]["id"].Int())
gtest.Assert(t_users[0].Passport, resultStringRecord[ids]["passport"].String())
gtest.Assert(t_users[0].Password, resultStringRecord[ids]["password"].String())
gtest.Assert(t_users[0].NickName, resultStringRecord[ids]["nickname"].String())
gtest.Assert(t_users[0].CreateTime, resultStringRecord[ids]["create_time"].String())
})
}
func Test_DB_ToIntRecord(t *testing.T) {
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
gtest.Assert(err, nil)
gtest.Case(t, func() {
id := 1
result, err := db.Table(table).Fields("*").Where("id = ?", id).Select()
if err != nil {
gtest.Fatal(err)
}
type t_user struct {
Id int
Passport string
Password string
NickName string
CreateTime string
}
t_users := make([]t_user, 0)
err = result.ToStructs(&t_users)
if err != nil {
gtest.Fatal(err)
}
resultIntRecord := result.ToIntRecord("id")
gtest.Assert(t_users[0].Id, resultIntRecord[id]["id"].Int())
gtest.Assert(t_users[0].Passport, resultIntRecord[id]["passport"].String())
gtest.Assert(t_users[0].Password, resultIntRecord[id]["password"].String())
gtest.Assert(t_users[0].NickName, resultIntRecord[id]["nickname"].String())
gtest.Assert(t_users[0].CreateTime, resultIntRecord[id]["create_time"].String())
})
}
func Test_DB_ToUintRecord(t *testing.T) {
table := createInitTable()
defer dropTable(table)
_, err := db.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1)
gtest.Assert(err, nil)
gtest.Case(t, func() {
id := 1
result, err := db.Table(table).Fields("*").Where("id = ?", id).Select()
if err != nil {
gtest.Fatal(err)
}
type t_user struct {
Id int
Passport string
Password string
NickName string
CreateTime string
}
t_users := make([]t_user, 0)
err = result.ToStructs(&t_users)
if err != nil {
gtest.Fatal(err)
}
resultUintRecord := result.ToUintRecord("id")
gtest.Assert(t_users[0].Id, resultUintRecord[uint(id)]["id"].Int())
gtest.Assert(t_users[0].Passport, resultUintRecord[uint(id)]["passport"].String())
gtest.Assert(t_users[0].Password, resultUintRecord[uint(id)]["password"].String())
gtest.Assert(t_users[0].NickName, resultUintRecord[uint(id)]["nickname"].String())
gtest.Assert(t_users[0].CreateTime, resultUintRecord[uint(id)]["create_time"].String())
})
}
func Test_DB_TableField(t *testing.T) {
name := "field_test"
dropTable(name)
defer dropTable(name)
_, err := db.Exec(fmt.Sprintf(`
CREATE TABLE %s (
field_tinyint tinyint(8) NULL ,
field_int int(8) NULL ,
field_integer integer(8) NULL ,
field_bigint bigint(8) NULL ,
field_bit bit(3) NULL ,
field_real real(8,0) NULL ,
field_double double(12,2) NULL ,
field_varchar varchar(10) NULL ,
field_varbinary varbinary(255) NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
`, name))
if err != nil {
gtest.Fatal(err)
}
data := gdb.Map{
"field_tinyint": 1,
"field_int": 2,
"field_integer": 3,
"field_bigint": 4,
"field_bit": 6,
"field_real": 123,
"field_double": 123.25,
"field_varchar": "abc",
"field_varbinary": "aaa",
}
res, err := db.Table(name).Data(data).Insert()
if err != nil {
gtest.Fatal(err)
}
n, err := res.RowsAffected()
if err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(n, 1)
}
result, err := db.Table(name).Fields("*").Where("field_int = ?", 2).Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(result[0], data)
}
func Test_Model_InnerJoin(t *testing.T) {
gtest.Case(t, func() {
table1 := createInitTable("user1")
table2 := createInitTable("user2")
defer dropTable(table1)
defer dropTable(table2)
res, err := db.Table(table1).Where("id > ?", 5).Delete()
if err != nil {
gtest.Fatal(err)
}
n, err := res.RowsAffected()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(n, 5)
result, err := db.Table(table1+" u1").InnerJoin(table2+" u2", "u1.id = u2.id").OrderBy("u1.id").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 5)
result, err = db.Table(table1+" u1").InnerJoin(table2+" u2", "u1.id = u2.id").Where("u1.id > ?", 1).OrderBy("u1.id").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 4)
})
}
func Test_Model_LeftJoin(t *testing.T) {
gtest.Case(t, func() {
table1 := createInitTable("user1")
table2 := createInitTable("user2")
defer dropTable(table1)
defer dropTable(table2)
res, err := db.Table(table2).Where("id > ?", 3).Delete()
if err != nil {
gtest.Fatal(err)
}
n, err := res.RowsAffected()
if err != nil {
gtest.Fatal(err)
} else {
gtest.Assert(n, 7)
}
result, err := db.Table(table1+" u1").LeftJoin(table2+" u2", "u1.id = u2.id").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 10)
result, err = db.Table(table1+" u1").LeftJoin(table2+" u2", "u1.id = u2.id").Where("u1.id > ? ", 2).Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 8)
})
}
func Test_Model_RightJoin(t *testing.T) {
gtest.Case(t, func() {
table1 := createInitTable("user1")
table2 := createInitTable("user2")
defer dropTable(table1)
defer dropTable(table2)
res, err := db.Table(table1).Where("id > ?", 3).Delete()
if err != nil {
gtest.Fatal(err)
}
n, err := res.RowsAffected()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(n, 7)
result, err := db.Table(table1+" u1").RightJoin(table2+" u2", "u1.id = u2.id").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 10)
result, err = db.Table(table1+" u1").RightJoin(table2+" u2", "u1.id = u2.id").Where("u1.id > 2").Select()
if err != nil {
gtest.Fatal(err)
}
gtest.Assert(len(result), 1)
})
}

38
database/gdb/gdb_unit_z_model_test.go
View File

@ -20,7 +20,8 @@ func Test_Model_Insert(t *testing.T) {
table := createTable()
defer dropTable(table)
gtest.Case(t, func() {
result, err := db.Table(table).Filter().Data(g.Map{
user := db.From(table)
result, err := user.Filter().Data(g.Map{
"id": 1,
"uid": 1,
"passport": "t1",
@ -273,6 +274,18 @@ func Test_Model_Safe(t *testing.T) {
gtest.Assert(err, nil)
gtest.Assert(count, 2)
})
gtest.Case(t, func() {
md := db.Table(table).Safe().Where("id IN(?)", g.Slice{1, 3})
count, err := md.Count()
gtest.Assert(err, nil)
gtest.Assert(count, 2)
md.And("id = ?", 1)
count, err = md.Count()
gtest.Assert(err, nil)
gtest.Assert(count, 2)
})
}
func Test_Model_All(t *testing.T) {
@ -816,3 +829,26 @@ func Test_Model_Delete(t *testing.T) {
gtest.Assert(n, INIT_DATA_SIZE-2)
})
}
func Test_Model_Offset(t *testing.T) {
table := createInitTable()
defer dropTable(table)
result, err := db.Table(table).Limit(2).Offset(5).OrderBy("id").Select()
gtest.Assert(err, nil)
gtest.Assert(len(result), 2)
gtest.Assert(result[0]["id"], 6)
gtest.Assert(result[1]["id"], 7)
}
func Test_Model_ForPage(t *testing.T) {
table := createInitTable()
defer dropTable(table)
db.SetDebug(true)
defer db.SetDebug(false)
result, err := db.Table(table).ForPage(3, 3).OrderBy("id").Select()
gtest.Assert(err, nil)
gtest.Assert(len(result), 3)
gtest.Assert(result[0]["id"], 7)
gtest.Assert(result[1]["id"], 8)
}

707
database/gdb/gdb_unit_z_mssql_method_test.go Normal file
View File

@ -0,0 +1,707 @@
// 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_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)
msdb.Exec("delete from t_user")
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)
}
}

916
database/gdb/gdb_unit_z_mssql_model_test.go Normal file
View File

@ -0,0 +1,916 @@
// 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_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)
})
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)
}
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=1").Struct(user)
if err != nil {
gtest.Fatal(err)
}
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=-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 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
}
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)
}
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[0]["CREATE_TIME"].GTime("Y-m-d H:i:s").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 Normal file
View File

@ -0,0 +1,112 @@
// 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 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 := 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.ToJson())
gtest.Assert(one.ToStruct(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)
})
}

700
database/gdb/gdb_unit_z_mssql_transaction_test.go Normal file
View File

@ -0,0 +1,700 @@
// 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) {
tx, err := db.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) {
tx, err := db.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
}
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.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)
}
}

970
database/gdb/gdb_unit_z_oracle_method_test.go Normal file
View File

@ -0,0 +1,970 @@
// 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 Normal file
View File

@ -0,0 +1,872 @@
// 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 Normal file
View File

@ -0,0 +1,111 @@
// 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.ToStruct(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 Normal file
View File

@ -0,0 +1,717 @@
// 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 Normal file
View File

File diff suppressed because it is too large Load Diff

816
database/gdb/gdb_unit_z_pgsql_model_test.go Normal file
View File

@ -0,0 +1,816 @@
// 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")
})
}

26
database/gdb/gdb_unit_z_transaction_test.go
View File

@ -120,23 +120,37 @@ func Test_TX_Insert(t *testing.T) {
if err != nil {
gtest.Error(err)
}
if _, err := tx.Insert(table, g.Map{
user := tx.From(table)
if _, err := user.Data(g.Map{
"id": 1,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
}).Insert(); err != nil {
gtest.Error(err)
}
if _, err := tx.Insert(table, g.Map{
"id": 2,
"passport": "t1",
"password": "25d55ad283aa400af464c76d713c07ad",
"nickname": "T1",
"create_time": gtime.Now().String(),
}); err != nil {
gtest.Error(err)
}
if n, err := tx.Table(table).Count(); err != nil {
gtest.Error(err)
} else {
gtest.Assert(n, 2)
}
if err := tx.Commit(); err != nil {
gtest.Error(err)
}
if n, err := db.Table(table).Count(); err != nil {
gtest.Error(err)
} else {
gtest.Assert(n, 1)
}
})
}