From 296c4b750b2333ec73d67bf837a8bc461155f2af Mon Sep 17 00:00:00 2001 From: wenzi1 Date: Mon, 12 Aug 2019 16:50:57 +0800 Subject: [PATCH 1/6] add oracle/mssql/postgres unit test cases --- database/gdb/gdb_mssql.go | 69 +- database/gdb/gdb_oracle.go | 304 ++++- database/gdb/gdb_pgsql.go | 29 +- database/gdb/gdb_unit_0_init_test.go | 21 + database/gdb/gdb_unit_init_mssql_test.go | 113 ++ database/gdb/gdb_unit_init_oracle_test.go | 111 ++ database/gdb/gdb_unit_init_pgsql_test.go | 121 ++ database/gdb/gdb_unit_init_test.go | 29 +- database/gdb/gdb_unit_z_method_test.go | 531 +++++++++ database/gdb/gdb_unit_z_model_test.go | 38 +- database/gdb/gdb_unit_z_mssql_method_test.go | 707 ++++++++++++ database/gdb/gdb_unit_z_mssql_model_test.go | 916 +++++++++++++++ database/gdb/gdb_unit_z_mssql_struct_test.go | 112 ++ .../gdb/gdb_unit_z_mssql_transaction_test.go | 700 ++++++++++++ database/gdb/gdb_unit_z_oracle_method_test.go | 970 ++++++++++++++++ database/gdb/gdb_unit_z_oracle_model_test.go | 872 ++++++++++++++ database/gdb/gdb_unit_z_oracle_struct_test.go | 111 ++ .../gdb/gdb_unit_z_oracle_transaction_test.go | 717 ++++++++++++ database/gdb/gdb_unit_z_pgsql_method_test.go | 1003 +++++++++++++++++ database/gdb/gdb_unit_z_pgsql_model_test.go | 816 ++++++++++++++ database/gdb/gdb_unit_z_transaction_test.go | 26 +- 21 files changed, 8263 insertions(+), 53 deletions(-) create mode 100644 database/gdb/gdb_unit_0_init_test.go create mode 100644 database/gdb/gdb_unit_init_mssql_test.go create mode 100644 database/gdb/gdb_unit_init_oracle_test.go create mode 100644 database/gdb/gdb_unit_init_pgsql_test.go create mode 100644 database/gdb/gdb_unit_z_mssql_method_test.go create mode 100644 database/gdb/gdb_unit_z_mssql_model_test.go create mode 100644 database/gdb/gdb_unit_z_mssql_struct_test.go create mode 100644 database/gdb/gdb_unit_z_mssql_transaction_test.go create mode 100644 database/gdb/gdb_unit_z_oracle_method_test.go create mode 100644 database/gdb/gdb_unit_z_oracle_model_test.go create mode 100644 database/gdb/gdb_unit_z_oracle_struct_test.go create mode 100644 database/gdb/gdb_unit_z_oracle_transaction_test.go create mode 100644 database/gdb/gdb_unit_z_pgsql_method_test.go create mode 100644 database/gdb/gdb_unit_z_pgsql_model_test.go diff --git a/database/gdb/gdb_mssql.go b/database/gdb/gdb_mssql.go index 9af5ef5e3..47e54c069 100644 --- a/database/gdb/gdb_mssql.go +++ b/database/gdb/gdb_mssql.go @@ -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) + } + } +} diff --git a/database/gdb/gdb_oracle.go b/database/gdb/gdb_oracle.go index 456085cfe..e86df6aab 100644 --- a/database/gdb/gdb_oracle.go +++ b/database/gdb/gdb_oracle.go @@ -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 +} diff --git a/database/gdb/gdb_pgsql.go b/database/gdb/gdb_pgsql.go index 2dac99783..281102d29 100644 --- a/database/gdb/gdb_pgsql.go +++ b/database/gdb/gdb_pgsql.go @@ -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 +} diff --git a/database/gdb/gdb_unit_0_init_test.go b/database/gdb/gdb_unit_0_init_test.go new file mode 100644 index 000000000..4542015b9 --- /dev/null +++ b/database/gdb/gdb_unit_0_init_test.go @@ -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() +} diff --git a/database/gdb/gdb_unit_init_mssql_test.go b/database/gdb/gdb_unit_init_mssql_test.go new file mode 100644 index 000000000..de1d44801 --- /dev/null +++ b/database/gdb/gdb_unit_init_mssql_test.go @@ -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) + } +} diff --git a/database/gdb/gdb_unit_init_oracle_test.go b/database/gdb/gdb_unit_init_oracle_test.go new file mode 100644 index 000000000..e110c819e --- /dev/null +++ b/database/gdb/gdb_unit_init_oracle_test.go @@ -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) + } +} diff --git a/database/gdb/gdb_unit_init_pgsql_test.go b/database/gdb/gdb_unit_init_pgsql_test.go new file mode 100644 index 000000000..5ba629a3b --- /dev/null +++ b/database/gdb/gdb_unit_init_pgsql_test.go @@ -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) + } +} diff --git a/database/gdb/gdb_unit_init_test.go b/database/gdb/gdb_unit_init_test.go index 359ebf47b..47179511b 100644 --- a/database/gdb/gdb_unit_init_test.go +++ b/database/gdb/gdb_unit_init_test.go @@ -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为空时，创建随机的表名。 diff --git a/database/gdb/gdb_unit_z_method_test.go b/database/gdb/gdb_unit_z_method_test.go index ddaf4f388..fbd507b38 100644 --- a/database/gdb/gdb_unit_z_method_test.go +++ b/database/gdb/gdb_unit_z_method_test.go @@ -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) + }) +} diff --git a/database/gdb/gdb_unit_z_model_test.go b/database/gdb/gdb_unit_z_model_test.go index f331f8f02..84377e0ff 100644 --- a/database/gdb/gdb_unit_z_model_test.go +++ b/database/gdb/gdb_unit_z_model_test.go @@ -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) +} diff --git a/database/gdb/gdb_unit_z_mssql_method_test.go b/database/gdb/gdb_unit_z_mssql_method_test.go new file mode 100644 index 000000000..14a3d5610 --- /dev/null +++ b/database/gdb/gdb_unit_z_mssql_method_test.go @@ -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) + } +} diff --git a/database/gdb/gdb_unit_z_mssql_model_test.go b/database/gdb/gdb_unit_z_mssql_model_test.go new file mode 100644 index 000000000..90621bd9a --- /dev/null +++ b/database/gdb/gdb_unit_z_mssql_model_test.go @@ -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) + }) +} diff --git a/database/gdb/gdb_unit_z_mssql_struct_test.go b/database/gdb/gdb_unit_z_mssql_struct_test.go new file mode 100644 index 000000000..9bd4b7241 --- /dev/null +++ b/database/gdb/gdb_unit_z_mssql_struct_test.go @@ -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) + }) + +} diff --git a/database/gdb/gdb_unit_z_mssql_transaction_test.go b/database/gdb/gdb_unit_z_mssql_transaction_test.go new file mode 100644 index 000000000..697a3e8ef --- /dev/null +++ b/database/gdb/gdb_unit_z_mssql_transaction_test.go @@ -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) + } +} diff --git a/database/gdb/gdb_unit_z_oracle_method_test.go b/database/gdb/gdb_unit_z_oracle_method_test.go new file mode 100644 index 000000000..ed72ca754 --- /dev/null +++ b/database/gdb/gdb_unit_z_oracle_method_test.go @@ -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") + }) + +} diff --git a/database/gdb/gdb_unit_z_oracle_model_test.go b/database/gdb/gdb_unit_z_oracle_model_test.go new file mode 100644 index 000000000..47cd88c3f --- /dev/null +++ b/database/gdb/gdb_unit_z_oracle_model_test.go @@ -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") + + }) +} diff --git a/database/gdb/gdb_unit_z_oracle_struct_test.go b/database/gdb/gdb_unit_z_oracle_struct_test.go new file mode 100644 index 000000000..cd25c76a0 --- /dev/null +++ b/database/gdb/gdb_unit_z_oracle_struct_test.go @@ -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) + }) + +} diff --git a/database/gdb/gdb_unit_z_oracle_transaction_test.go b/database/gdb/gdb_unit_z_oracle_transaction_test.go new file mode 100644 index 000000000..a7b8b4f3f --- /dev/null +++ b/database/gdb/gdb_unit_z_oracle_transaction_test.go @@ -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) + } +} diff --git a/database/gdb/gdb_unit_z_pgsql_method_test.go b/database/gdb/gdb_unit_z_pgsql_method_test.go new file mode 100644 index 000000000..6c1b1e42c --- /dev/null +++ b/database/gdb/gdb_unit_z_pgsql_method_test.go @@ -0,0 +1,1003 @@ +// 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/encoding/gjson" + "github.com/gogf/gf/encoding/gxml" + "github.com/gogf/gf/frame/g" + "github.com/gogf/gf/os/gtime" + "github.com/gogf/gf/test/gtest" + "strings" + "testing" + "time" +) + +func Test_DB_Ping_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + gtest.Case(t, func() { + err1 := pgdb.PingMaster() + + err2 := pgdb.PingSlave() + gtest.Assert(err1, nil) + gtest.Assert(err2, nil) + }) +} + +func Test_DB_SetParm_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + + gtest.Case(t, func() { + pgdb.SetMaxConnLifetime(600) + pgdb.SetMaxIdleConnCount(20) + pgdb.SetMaxOpenConnCount(20) + + }) +} + +func Test_DB_Insert_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createTablePgsql() + defer dropTablePgsql(table) + pgdb.SetDebug(true) + defer pgdb.SetDebug(false) + if _, err := pgdb.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 := pgdb.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 t_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 = pgdb.Insert(table, t_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 := pgdb.GetValue(fmt.Sprintf("select passport from %s where id=?", table), 3) + gtest.Assert(err, nil) + gtest.Assert(value.String(), "t3") + + // *struct + result, err = pgdb.Insert(table, &t_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 = pgdb.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 := pgdb.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 = pgdb.Delete(table, "id>?", 1) + if err != nil { + gtest.Fatal(err) + } + n, _ = result.RowsAffected() + gtest.Assert(n, 5) +} + +func Test_DB_BatchInsert_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createTablePgsql() + defer dropTablePgsql(table) + + gtest.Case(t, func() { + if r, err := pgdb.BatchInsert(table, g.List{ + { + "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(), + }, + }, 1); err != nil { + gtest.Fatal(err) + } else { + n, _ := r.RowsAffected() + gtest.Assert(n, 2) + + } + + result, err := pgdb.Delete(table, "id>?", 1) + if err != nil { + gtest.Fatal(err) + } + n, _ := result.RowsAffected() + gtest.Assert(n, 2) + + // []interface{} + if r, err := pgdb.BatchInsert(table, []interface{}{ + map[interface{}]interface{}{ + "id": 2, + "passport": "t2", + "password": "25d55ad283aa400af464c76d713c07ad", + "nickname": "T2", + "create_time": gtime.Now().String(), + }, + map[interface{}]interface{}{ + "id": 3, + "passport": "t3", + "password": "25d55ad283aa400af464c76d713c07ad", + "nickname": "T3", + "create_time": gtime.Now().String(), + }, + }, 1); err != nil { + gtest.Fatal(err) + } else { + n, _ := r.RowsAffected() + gtest.Assert(n, 2) + } + }) + // batch insert map + gtest.Case(t, func() { + result, err := pgdb.BatchInsert(table, g.Map{ + "id": 1, + "passport": "t1", + "password": "p1", + "nickname": "T1", + "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: 4, + Passport: "t1", + Password: "p1", + NickName: "T1", + CreateTime: gtime.Now(), + } + result, err := pgdb.BatchInsert(table, user) + if err != nil { + gtest.Fatal(err) + } + n, _ := result.RowsAffected() + gtest.Assert(n, 1) + }) +} + +/* +func Test_DB_Save_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + if _, err := pgdb.Save(table, g.Map{ + "id": 1, + "passport": "t1", + "password": "25d55ad283aa400af464c76d713c07ad", + "nickname": "T11", + "create_time": gtime.Now().String(), + }); err != nil { + gtest.Fatal(err) + } +} + +func Test_DB_Replace_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + if _, err := pgdb.Save(table, g.Map{ + "id": 1, + "passport": "t1", + "password": "25d55ad283aa400af464c76d713c07ad", + "nickname": "T111", + "create_time": gtime.Now().String(), + }); err != nil { + gtest.Fatal(err) + } +} +*/ + +func Test_DB_Update_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createInitTablePgsql() + defer dropTablePgsql(table) + + if result, err := pgdb.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) + } +} + +func Test_DB_GetAll_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createInitTablePgsql() + defer dropTablePgsql(table) + + gtest.Case(t, func() { + result, err := pgdb.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 := pgdb.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 := pgdb.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 := pgdb.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 := pgdb.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 := pgdb.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_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + + table := createInitTablePgsql() + defer dropTablePgsql(table) + + if record, err := pgdb.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_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + + table := createInitTablePgsql() + defer dropTablePgsql(table) + if value, err := pgdb.GetValue(fmt.Sprintf("SELECT id FROM %s WHERE passport=?", table), "t3"); err != nil { + gtest.Fatal(err) + } else { + gtest.Assert(value.Int(), 3) + } +} + +func Test_DB_GetCount_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createInitTablePgsql() + defer dropTablePgsql(table) + + if count, err := pgdb.GetCount(fmt.Sprintf("SELECT * FROM %s", table)); err != nil { + gtest.Fatal(err) + } else { + gtest.Assert(count, INIT_DATA_SIZE) + } +} + +func Test_DB_GetStruct_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createInitTablePgsql() + defer dropTablePgsql(table) + + _, err := pgdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 3) + 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 := pgdb.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); 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 := pgdb.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil { + gtest.Fatal(err) + } else { + gtest.Assert(user.CreateTime.String(), "2010-10-10 00:00:01") + } + }) +} + +func Test_DB_GetStructs_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createInitTablePgsql() + defer dropTablePgsql(table) + + _, err := pgdb.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 + } + var users []User + if err := pgdb.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? and id <= ? order by 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[1].CreateTime.String(), "2010-10-10 00:00:01") + }) +} + +func Test_DB_GetScan_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createInitTablePgsql() + defer dropTablePgsql(table) + + _, err := pgdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 3) + 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 := pgdb.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=? ", table), 3); 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 := pgdb.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=? ", table), 3); 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 := pgdb.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? and id <= ? order by id", table), 1, 3); err != nil { + gtest.Fatal(err) + } + gtest.Assert(len(users), 3) + 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") + }) + + gtest.Case(t, func() { + type User struct { + Id int + Passport string + Password string + NickName string + CreateTime *gtime.Time + } + var users []User + if err := pgdb.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=? and id <= ? order by id", table), 1, 3); err != nil { + gtest.Fatal(err) + } + gtest.Assert(len(users), 3) + 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") + }) +} + +func Test_DB_Delete_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createInitTablePgsql() + defer dropTablePgsql(table) + + if result, err := pgdb.Delete(table, nil); err != nil { + gtest.Fatal(err) + } else { + n, _ := result.RowsAffected() + gtest.Assert(n, INIT_DATA_SIZE) + } +} + +func Test_DB_Time_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createInitTablePgsql() + defer dropTablePgsql(table) + + gtest.Case(t, func() { + result, err := pgdb.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 := pgdb.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 := pgdb.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 := pgdb.GetValue(fmt.Sprintf("select passport from %s where id=?", table), 300) + gtest.Assert(err, nil) + gtest.Assert(value.String(), "t300") + }) + +} + +func Test_DB_ToJson_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createInitTablePgsql() + defer dropTablePgsql(table) + _, err := pgdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1) + gtest.Assert(err, nil) + + gtest.Case(t, func() { + result, err := pgdb.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 := pgdb.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_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + + table := createInitTablePgsql() + defer dropTablePgsql(table) + _, err := pgdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1) + gtest.Assert(err, nil) + + gtest.Case(t, func() { + record, err := pgdb.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(strings.TrimSpace(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_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + + table := createInitTablePgsql() + defer dropTablePgsql(table) + _, err := pgdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1) + gtest.Assert(err, nil) + gtest.Case(t, func() { + id := "1" + result, err := pgdb.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_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createInitTablePgsql() + defer dropTablePgsql(table) + _, err := pgdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1) + gtest.Assert(err, nil) + + gtest.Case(t, func() { + id := 1 + result, err := pgdb.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_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createInitTablePgsql() + defer dropTablePgsql(table) + _, err := pgdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1) + gtest.Assert(err, nil) + + gtest.Case(t, func() { + id := 1 + result, err := pgdb.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_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + + table := createInitTablePgsql() + defer dropTablePgsql(table) + _, err := pgdb.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 := pgdb.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_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createInitTablePgsql() + defer dropTablePgsql(table) + _, err := pgdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1) + gtest.Assert(err, nil) + + gtest.Case(t, func() { + id := 1 + result, err := pgdb.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_Pgsql(t *testing.T) { + if pgdb == nil { + return + } + table := createInitTablePgsql() + defer dropTablePgsql(table) + _, err := pgdb.Update(table, "create_time='2010-10-10 00:00:01'", "id=?", 1) + gtest.Assert(err, nil) + + gtest.Case(t, func() { + id := 1 + result, err := pgdb.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()) + }) +} diff --git a/database/gdb/gdb_unit_z_pgsql_model_test.go b/database/gdb/gdb_unit_z_pgsql_model_test.go new file mode 100644 index 000000000..7096103d5 --- /dev/null +++ b/database/gdb/gdb_unit_z_pgsql_model_test.go @@ -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") + }) + +} diff --git a/database/gdb/gdb_unit_z_transaction_test.go b/database/gdb/gdb_unit_z_transaction_test.go index f532819d3..832697943 100644 --- a/database/gdb/gdb_unit_z_transaction_test.go +++ b/database/gdb/gdb_unit_z_transaction_test.go @@ -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) - } + }) } From 9a057b757d273279ed8a0ae9b642255b61debc66 Mon Sep 17 00:00:00 2001 From: wenzi1 Date: Mon, 12 Aug 2019 16:53:07 +0800 Subject: [PATCH 2/6] add package gini --- encoding/gini/gini.go | 113 +++++++++++++++++++++++ encoding/gini/gini_test.go | 97 +++++++++++++++++++ encoding/gjson/gjson_api_encoding.go | 13 ++- encoding/gjson/gjson_api_new_load.go | 18 +++- encoding/gjson/gjson_z_unit_load_test.go | 38 ++++++++ encoding/gparser/gparser_api_encoding.go | 4 + encoding/gparser/gparser_api_new_load.go | 4 + 7 files changed, 281 insertions(+), 6 deletions(-) create mode 100644 encoding/gini/gini.go create mode 100644 encoding/gini/gini_test.go diff --git a/encoding/gini/gini.go b/encoding/gini/gini.go new file mode 100644 index 000000000..35740c453 --- /dev/null +++ b/encoding/gini/gini.go @@ -0,0 +1,113 @@ +// Copyright 2017 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 gini provides accessing and converting for INI content. +package gini + +import ( + "bufio" + "bytes" + "encoding/json" + "fmt" + "io" + "strings" +) + +//Decode converts INI format to map +func Decode(data []byte) (res map[string]interface{}, err error) { + res = make(map[string]interface{}) + fieldMap := make(map[string]interface{}) + + a := bytes.NewReader(data) + + r := bufio.NewReader(a) + + var section string + var lastSection string + var haveSection bool + for { + line, err := r.ReadString('\n') + if err != nil { + if err == io.EOF { + break + } + return nil, err + } + + lineStr := strings.TrimSpace(string(line)) + if len(lineStr) == 0 { + continue + } + + if lineStr[0] == ';' || lineStr[0] == '#' { + continue + } + + sectionBeginPos := strings.Index(lineStr, "[") + sectionEndPos := strings.Index(lineStr, "]") + + if sectionBeginPos >= 0 && sectionEndPos >= 2 { + section = lineStr[sectionBeginPos+1 : sectionEndPos] + + if lastSection == "" { + lastSection = section + } else if lastSection != section { + lastSection = section + fieldMap = make(map[string]interface{}) + } + haveSection = true + } else if haveSection == false { + continue + } + + if strings.Contains(lineStr, "=") && haveSection { + values := strings.Split(lineStr, "=") + + fieldMap[strings.TrimSpace(values[0])] = strings.TrimSpace(strings.Join(values[1:], "")) + res[section] = fieldMap + } + + } + + return res, nil +} + +//Encode converts map to INI format +func Encode(data map[string]interface{}) (res []byte, err error) { + w := new(bytes.Buffer) + + w.WriteString(";gini\n") + for k, v := range data { + n, err := w.WriteString(fmt.Sprintf("[%s]\n", k)) + if err != nil || n == 0 { + return nil, fmt.Errorf("write data failed. %v", err) + } + + for kk, vv := range v.(map[string]interface{}) { + n, err := w.WriteString(fmt.Sprintf("%s=%s\n", kk, vv.(string))) + if err != nil || n == 0 { + return nil, fmt.Errorf("write data failed. %v", err) + } + } + } + res = make([]byte, w.Len()) + n, err := w.Read(res) + if err != nil || n == 0 { + return nil, fmt.Errorf("write data failed. %v", err) + } + + return res, nil +} + +//ToJson convert INI format to JSON +func ToJson(data []byte) (res []byte, err error) { + iniMap, err := Decode(data) + if err != nil { + return nil, err + } + + return json.Marshal(iniMap) +} diff --git a/encoding/gini/gini_test.go b/encoding/gini/gini_test.go new file mode 100644 index 000000000..da75c22a3 --- /dev/null +++ b/encoding/gini/gini_test.go @@ -0,0 +1,97 @@ +// Copyright 2017 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 gini_test + +import ( + "fmt" + "github.com/gogf/gf/encoding/gini" + "github.com/gogf/gf/encoding/gjson" + "github.com/gogf/gf/test/gtest" + "testing" +) + +var iniContent = ` + +;注释 +aa=bb +[addr] +#注释 +ip = 127.0.0.1 +port=9001 +enable=true + + [DBINFO] + type=mysql + user=root + password=password +[键] +呵呵=值 + +` + +func TestDecode(t *testing.T) { + gtest.Case(t, func() { + res, err := gini.Decode([]byte(iniContent)) + if err != nil { + gtest.Fatal(err) + } + fmt.Println(res) + gtest.Assert(res["addr"].(map[string]interface{})["ip"], "127.0.0.1") + gtest.Assert(res["addr"].(map[string]interface{})["port"], "9001") + gtest.Assert(res["DBINFO"].(map[string]interface{})["user"], "root") + gtest.Assert(res["DBINFO"].(map[string]interface{})["type"], "mysql") + gtest.Assert(res["键"].(map[string]interface{})["呵呵"], "值") + }) + +} + +func TestEncode(t *testing.T) { + gtest.Case(t, func() { + iniMap, err := gini.Decode([]byte(iniContent)) + if err != nil { + gtest.Fatal(err) + } + + iniStr, err := gini.Encode(iniMap) + if err != nil { + gtest.Fatal(err) + } + + res, err := gini.Decode(iniStr) + if err != nil { + gtest.Fatal(err) + } + + gtest.Assert(res["addr"].(map[string]interface{})["ip"], "127.0.0.1") + gtest.Assert(res["addr"].(map[string]interface{})["port"], "9001") + gtest.Assert(res["DBINFO"].(map[string]interface{})["user"], "root") + gtest.Assert(res["DBINFO"].(map[string]interface{})["type"], "mysql") + + }) +} + +func TestToJson(t *testing.T) { + gtest.Case(t, func() { + jsonStr, err := gini.ToJson([]byte(iniContent)) + if err != nil { + gtest.Fatal(err) + } + + json, err := gjson.LoadContent(jsonStr) + if err != nil { + gtest.Fatal(err) + } + + iniMap, err := gini.Decode([]byte(iniContent)) + gtest.Assert(err, nil) + + gtest.Assert(iniMap["addr"].(map[string]interface{})["ip"], json.GetString("addr.ip")) + gtest.Assert(iniMap["addr"].(map[string]interface{})["port"], json.GetString("addr.port")) + gtest.Assert(iniMap["DBINFO"].(map[string]interface{})["user"], json.GetString("DBINFO.user")) + gtest.Assert(iniMap["DBINFO"].(map[string]interface{})["type"], json.GetString("DBINFO.type")) + }) +} diff --git a/encoding/gjson/gjson_api_encoding.go b/encoding/gjson/gjson_api_encoding.go index bbce2cf8f..1b49183fd 100644 --- a/encoding/gjson/gjson_api_encoding.go +++ b/encoding/gjson/gjson_api_encoding.go @@ -8,7 +8,7 @@ package gjson import ( "encoding/json" - + "github.com/gogf/gf/encoding/gini" "github.com/gogf/gf/encoding/gtoml" "github.com/gogf/gf/encoding/gxml" "github.com/gogf/gf/encoding/gyaml" @@ -75,3 +75,14 @@ func (j *Json) ToTomlString() (string, error) { b, e := j.ToToml() return string(b), e } + +func (j *Json) ToIni() ([]byte, error) { + j.mu.RLock() + defer j.mu.RUnlock() + return gini.Encode((*(j.p)).(map[string]interface{})) +} + +func (j *Json) ToIniString() (string, error) { + b, e := j.ToToml() + return string(b), e +} diff --git a/encoding/gjson/gjson_api_new_load.go b/encoding/gjson/gjson_api_new_load.go index 0746cc34d..12a95cc46 100644 --- a/encoding/gjson/gjson_api_new_load.go +++ b/encoding/gjson/gjson_api_new_load.go @@ -12,17 +12,16 @@ import ( "encoding/json" "errors" "fmt" - "reflect" - - "github.com/gogf/gf/os/gfile" - + "github.com/gogf/gf/encoding/gini" "github.com/gogf/gf/encoding/gtoml" "github.com/gogf/gf/encoding/gxml" "github.com/gogf/gf/encoding/gyaml" "github.com/gogf/gf/internal/rwmutex" "github.com/gogf/gf/os/gfcache" + "github.com/gogf/gf/os/gfile" "github.com/gogf/gf/text/gregex" "github.com/gogf/gf/util/gconv" + "reflect" ) // New creates a Json object with any variable type of , @@ -147,6 +146,10 @@ func LoadToml(data interface{}, safe ...bool) (*Json, error) { return doLoadContent("toml", gconv.Bytes(data), safe...) } +func LoadIni(data interface{}, safe ...bool) (*Json, error) { + return doLoadContent("ini", gconv.Bytes(data), safe...) +} + func doLoadContent(dataType string, data []byte, safe ...bool) (*Json, error) { var err error var result interface{} @@ -173,7 +176,10 @@ func doLoadContent(dataType string, data []byte, safe ...bool) (*Json, error) { if data, err = gtoml.ToJson(data); err != nil { return nil, err } - + case "ini", ".ini": + if data, err = gini.ToJson(data); err != nil { + return nil, err + } default: err = errors.New("unsupported type for loading") } @@ -211,6 +217,8 @@ func checkDataType(content []byte) string { return "xml" } else if gregex.IsMatch(`^[\s\t]*[\w\-]+\s*:\s*.+`, content) || gregex.IsMatch(`\n[\s\t]*[\w\-]+\s*:\s*.+`, content) { return "yml" + } else if (gregex.IsMatch(`^[\s\t\[*\]].?*[\w\-]+\s*=\s*.+`, content) || gregex.IsMatch(`\n[\s\t\[*\]]*[\w\-]+\s*=\s*.+`, content)) && gregex.IsMatch(`\n[\s\t]*[\w\-]+\s*=*\"*.+\"`, content) == false && gregex.IsMatch(`^[\s\t]*[\w\-]+\s*=*\"*.+\"`, content) == false { + return "ini" } else if gregex.IsMatch(`^[\s\t]*[\w\-]+\s*=\s*.+`, content) || gregex.IsMatch(`\n[\s\t]*[\w\-]+\s*=\s*.+`, content) { return "toml" } else { diff --git a/encoding/gjson/gjson_z_unit_load_test.go b/encoding/gjson/gjson_z_unit_load_test.go index 7271da4f2..a729e5fa8 100644 --- a/encoding/gjson/gjson_z_unit_load_test.go +++ b/encoding/gjson/gjson_z_unit_load_test.go @@ -196,3 +196,41 @@ func Test_Load_Basic(t *testing.T) { }) } + +func Test_Load_Ini(t *testing.T) { + var data = ` + +;注释 + +[addr] +#注释 +ip = 127.0.0.1 +port=9001 +enable=true + + [DBINFO] + type=mysql + user=root + password=password + +` + + gtest.Case(t, func() { + json, err := gjson.LoadContent(data) + if err != nil { + gtest.Fatal(err) + } + + gtest.Assert(json.GetString("addr.ip"), "127.0.0.1") + gtest.Assert(json.GetString("addr.port"), "9001") + gtest.Assert(json.GetString("addr.enable"), "true") + gtest.Assert(json.GetString("DBINFO.type"), "mysql") + gtest.Assert(json.GetString("DBINFO.user"), "root") + gtest.Assert(json.GetString("DBINFO.password"), "password") + + _, err = json.ToIni() + if err != nil { + gtest.Fatal(err) + } + }) +} diff --git a/encoding/gparser/gparser_api_encoding.go b/encoding/gparser/gparser_api_encoding.go index 04a8f53c4..2047c16e8 100644 --- a/encoding/gparser/gparser_api_encoding.go +++ b/encoding/gparser/gparser_api_encoding.go @@ -37,3 +37,7 @@ func VarToYaml(value interface{}) ([]byte, error) { func VarToToml(value interface{}) ([]byte, error) { return New(value).ToToml() } + +func VarToIni(value interface{}) ([]byte, error) { + return New(value).ToIni() +} diff --git a/encoding/gparser/gparser_api_new_load.go b/encoding/gparser/gparser_api_new_load.go index b582c2c8a..59224e798 100644 --- a/encoding/gparser/gparser_api_new_load.go +++ b/encoding/gparser/gparser_api_new_load.go @@ -47,3 +47,7 @@ func LoadYaml(data interface{}, safe ...bool) (*Parser, error) { func LoadToml(data interface{}, safe ...bool) (*Parser, error) { return gjson.LoadToml(data, safe...) } + +func LoadIni(data interface{}, safe ...bool) (*Parser, error) { + return gjson.LoadIni(data, safe...) +} From b960faec459ec18374cce5b7db8e755f6e90258f Mon Sep 17 00:00:00 2001 From: wenzi1 Date: Mon, 12 Aug 2019 16:57:08 +0800 Subject: [PATCH 3/6] to support automated testing of postgres --- .travis.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.travis.yml b/.travis.yml index 5bb814298..aa25ec53a 100644 --- a/.travis.yml +++ b/.travis.yml @@ -16,8 +16,10 @@ env: services: - mysql - redis-server +- postgresql addons: + postgresql: "9.4" hosts: - local @@ -30,6 +32,7 @@ install: before_script: - find . -name "*.go" | xargs gofmt -w - git diff --name-only --exit-code || exit 1 +- psql -c 'create database travis_ci_test;' -U postgres script: - GOARCH=386 go test -v ./... || exit 1 From 5d7d8abbdea89757c594b15e0eb03a4e303bd4f0 Mon Sep 17 00:00:00 2001 From: wenzi1 Date: Mon, 12 Aug 2019 17:12:16 +0800 Subject: [PATCH 4/6] add oracle/mssql/postgres unit test cases --- database/gdb/gdb_unit_init_test.go | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/database/gdb/gdb_unit_init_test.go b/database/gdb/gdb_unit_init_test.go index 47179511b..979f62e0b 100644 --- a/database/gdb/gdb_unit_init_test.go +++ b/database/gdb/gdb_unit_init_test.go @@ -34,10 +34,10 @@ var ( // 测试前需要修改连接参数。 func InitMysql() { node := gdb.ConfigNode{ - Host: "140.143.231.161", + Host: "127.0.0.1", Port: "3306", User: "root", - Pass: "lala1234", + Pass: "", Name: "", Type: "mysql", Role: "master", @@ -52,7 +52,7 @@ func InitMysql() { node.Pass = "12345678" } gdb.AddConfigNode("test", node) - gdb.AddDefaultConfigNode(node) + gdb.AddConfigNode(gdb.DEFAULT_GROUP_NAME, node) if r, err := gdb.New(); err != nil { gtest.Error(err) } else { @@ -71,10 +71,6 @@ func InitMysql() { db.SetSchema(SCHEMA1) // 创建默认用户表 createTable(TABLE) - - gdb.GetConfig("test") - gdb.GetDefaultGroup() - gdb.SetDefaultGroup(gdb.DEFAULT_GROUP_NAME) } // 创建指定名称的user测试表，当table为空时，创建随机的表名。 From 8f7363df418e09184b25b1750904fa8b1cb29f2a Mon Sep 17 00:00:00 2001 From: wenzi1 Date: Wed, 14 Aug 2019 19:16:45 +0800 Subject: [PATCH 5/6] =?UTF-8?q?=E5=88=A0=E9=99=A4mssql=E4=B8=AD=E7=9A=84co?= =?UTF-8?q?nvertValue=E6=96=B9=E6=B3=95=E3=80=82=20=E4=BF=AE=E6=94=B9?= =?UTF-8?q?=E6=B5=8B=E8=AF=95=E6=A1=88=E4=BE=8B=E4=B8=AD=E7=9A=84datetime?= =?UTF-8?q?=E7=B1=BB=E5=9E=8B=E7=9A=84=E5=AD=97=E6=AE=B5=E5=9C=A8=E6=9F=A5?= =?UTF-8?q?=E5=88=B0=E6=95=B0=E6=8D=AE=E5=90=8E=E5=81=9A=E8=BD=AC=E6=8D=A2?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- database/gdb/gdb_mssql.go | 64 ------------------- database/gdb/gdb_unit_z_mssql_model_test.go | 19 ++++-- database/gdb/gdb_unit_z_mssql_struct_test.go | 2 +- .../gdb/gdb_unit_z_mssql_transaction_test.go | 18 +++++- 4 files changed, 31 insertions(+), 72 deletions(-) diff --git a/database/gdb/gdb_mssql.go b/database/gdb/gdb_mssql.go index 47e54c069..e16297fa2 100644 --- a/database/gdb/gdb_mssql.go +++ b/database/gdb/gdb_mssql.go @@ -14,10 +14,7 @@ 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" ) @@ -176,64 +173,3 @@ 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) - } - } -} diff --git a/database/gdb/gdb_unit_z_mssql_model_test.go b/database/gdb/gdb_unit_z_mssql_model_test.go index 90621bd9a..748bcf0ca 100644 --- a/database/gdb/gdb_unit_z_mssql_model_test.go +++ b/database/gdb/gdb_unit_z_mssql_model_test.go @@ -8,6 +8,7 @@ package gdb_test import ( "database/sql" + "fmt" "testing" "github.com/gogf/gf/frame/g" @@ -406,6 +407,14 @@ func Test_Model_Struct_Mssql(t *testing.T) { n, _ := res.RowsAffected() gtest.Assert(n, 1) + + res, err = msdb.Table(table).Data("create_time", "2018-10-10 00:01:10").Where("id = ?", 2).Update() + if err != nil { + gtest.Fatal(err) + } + + n, _ = res.RowsAffected() + gtest.Assert(n, 1) }) gtest.Case(t, func() { @@ -432,6 +441,7 @@ func Test_Model_Struct_Mssql(t *testing.T) { if err != nil { gtest.Fatal(err) } + fmt.Println("id=1 ", user.CreateTime.String()) gtest.Assert(user.NickName, "T111") gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10") }) @@ -444,11 +454,12 @@ func Test_Model_Struct_Mssql(t *testing.T) { CreateTime *gtime.Time } user := new(User) - err := msdb.Table(table).Where("id=1").Struct(user) + err := msdb.Table(table).Where("id=2").Struct(user) if err != nil { gtest.Fatal(err) } - gtest.Assert(user.NickName, "T111") + fmt.Println("id=2 ", user.CreateTime.String()) + gtest.Assert(user.NickName, "T2") gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10") }) @@ -875,11 +886,11 @@ func Test_Model_Limit_Mssql(t *testing.T) { if err != nil { gtest.Fatal(err) } - + fmt.Println(result[0]["CREATE_TIME"].String(), result[0]["CREATE_TIME"].GTime().String(), result[0]["CREATE_TIME"].Time().String()) gtest.Assert(len(result), 3) gtest.Assert(result[0]["ID"].Int(), 1) gtest.Assert(result[0]["NICKNAME"].String(), "T1") - gtest.Assert(result[0]["CREATE_TIME"].String(), "2018-10-10 00:01:10") + gtest.Assert(result[0]["CREATE_TIME"].GTime().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) diff --git a/database/gdb/gdb_unit_z_mssql_struct_test.go b/database/gdb/gdb_unit_z_mssql_struct_test.go index 9bd4b7241..3e15a5651 100644 --- a/database/gdb/gdb_unit_z_mssql_struct_test.go +++ b/database/gdb/gdb_unit_z_mssql_struct_test.go @@ -71,7 +71,7 @@ func Test_Model_Inherit_MapToStruct_Mssql(t *testing.T) { } type Base struct { Ids - CreateTime string `json:"create_time"` + CreateTime *gtime.Time `json:"create_time"` } type User struct { Base diff --git a/database/gdb/gdb_unit_z_mssql_transaction_test.go b/database/gdb/gdb_unit_z_mssql_transaction_test.go index 697a3e8ef..00f101c20 100644 --- a/database/gdb/gdb_unit_z_mssql_transaction_test.go +++ b/database/gdb/gdb_unit_z_mssql_transaction_test.go @@ -15,7 +15,11 @@ import ( ) func Test_TX_Query_Mssql(t *testing.T) { - tx, err := db.Begin() + if msdb == nil { + return + } + + tx, err := msdb.Begin() if err != nil { gtest.Fatal(err) } @@ -43,7 +47,11 @@ func Test_TX_Query_Mssql(t *testing.T) { } func Test_TX_Exec_Mssql(t *testing.T) { - tx, err := db.Begin() + if msdb == nil { + return + } + + tx, err := msdb.Begin() if err != nil { gtest.Fatal(err) } @@ -65,6 +73,10 @@ func Test_TX_Exec_Mssql(t *testing.T) { } func Test_TX_Commit_Mssql(t *testing.T) { + if msdb == nil { + return + } + if msdb == nil { return } @@ -347,7 +359,7 @@ func Test_TX_Update_Mssql(t *testing.T) { 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") + gtest.Assert(value.GTime().String(), "2010-10-10 00:00:01") } }) } From c402e176051b9d6df32f3a8cb78cb7e97ac819fd Mon Sep 17 00:00:00 2001 From: wenzi1 Date: Wed, 14 Aug 2019 22:44:57 +0800 Subject: [PATCH 6/6] =?UTF-8?q?=E4=BF=AE=E6=94=B9mssql=E4=B8=AD=E7=9A=84da?= =?UTF-8?q?tetime=E7=B1=BB=E5=9E=8B=E7=9A=84=E5=A4=84=E7=90=86?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- database/gdb/gdb_structure.go | 5 +++++ database/gdb/gdb_unit_z_mssql_model_test.go | 7 +++---- 2 files changed, 8 insertions(+), 4 deletions(-) diff --git a/database/gdb/gdb_structure.go b/database/gdb/gdb_structure.go index 3c3bffc85..d09d94412 100644 --- a/database/gdb/gdb_structure.go +++ b/database/gdb/gdb_structure.go @@ -8,6 +8,7 @@ package gdb import ( "fmt" + "github.com/gogf/gf/os/gtime" "strings" "github.com/gogf/gf/encoding/gbinary" @@ -55,6 +56,10 @@ func (bs *dbBase) convertValue(fieldValue []byte, fieldType string) interface{} case "bool": return gconv.Bool(fieldValue) + case "datetime": + t, _ := gtime.StrToTime(string(fieldValue)) + return t.String() + default: // 自动识别类型, 以便默认支持更多数据库类型 switch { diff --git a/database/gdb/gdb_unit_z_mssql_model_test.go b/database/gdb/gdb_unit_z_mssql_model_test.go index 748bcf0ca..efb1387cf 100644 --- a/database/gdb/gdb_unit_z_mssql_model_test.go +++ b/database/gdb/gdb_unit_z_mssql_model_test.go @@ -565,7 +565,7 @@ func Test_Model_Scan_Mssql(t *testing.T) { Passport string Password string NickName string - CreateTime gtime.Time + CreateTime string } user := new(User) err := msdb.Table(table).Where("id=1").Scan(user) @@ -573,7 +573,7 @@ func Test_Model_Scan_Mssql(t *testing.T) { gtest.Fatal(err) } gtest.Assert(user.NickName, "T1") - gtest.Assert(user.CreateTime.String(), "2018-10-10 00:01:10") + gtest.Assert(user.CreateTime, "2018-10-10 00:01:10") }) gtest.Case(t, func() { type User struct { @@ -890,8 +890,7 @@ func Test_Model_Limit_Mssql(t *testing.T) { 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"].GTime().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[0]["CREATE_TIME"].String(), "2018-10-10 00:01:10") gtest.Assert(result[1]["ID"].Int(), 2) gtest.Assert(result[1]["NICKNAME"].String(), "T2")