test(contrib/drivers/mariadb): add softtime, with, scanlist, union and do tests (#4721)

## Summary

- Port 48 soft-time tests: soft create/update/delete with
timestamp/datetime/date types, SoftTime switches
(SoftTimeTypeOff/Delete/Timestamp), Unscoped, ForceDelete, joined
queries with soft-delete
- Port 19 With/ScanList tests: With/WithAll for eager loading of
hasOne/hasMany/belongsTo relations, ScanList for manual relation
mapping, nested With
- Port 12 union tests: Union/UnionAll with various parameter forms
(string/Model/subquery), combined with OrderBy, Limit, Where conditions
- Port 12 gdb.Do tests: DoSelect/DoInsert/DoUpdate/DoDelete raw
operation hooks, batch insert, InsertIgnore/InsertGetId/Replace via
DoInsert option

Includes testdata SQL files for With relation table schemas (with_tpl).
Soft-time tests create tables inline via SQL, no separate testdata files
needed.

All tests are structurally identical to the MySQL driver baseline. SQL
syntax is standard and shared. Package and import references are adapted
for MariaDB.

ref #4689

contrib/drivers/mariadb/mariadb_z_unit_feature_model_do_test.go

@@ -0,0 +1,390 @@
+// Copyright GoFrame Author(https://goframe.org). 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 mariadb_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+func Test_Model_Insert_Data_DO(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			g.Meta     `orm:"do:true"`
+			Id         any
+			Passport   any
+			Password   any
+			Nickname   any
+			CreateTime any
+		}
+		data := User{
+			Id:       1,
+			Passport: "user_1",
+			Password: "pass_1",
+		}
+		result, err := db.Model(table).Data(data).Insert()
+		t.AssertNil(err)
+		n, _ := result.LastInsertId()
+		t.Assert(n, 1)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one[`id`], `1`)
+		t.Assert(one[`passport`], `user_1`)
+		t.Assert(one[`password`], `pass_1`)
+		t.Assert(one[`nickname`], ``)
+		t.Assert(one[`create_time`], ``)
+	})
+}
+
+func Test_Model_Insert_Data_List_DO(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			g.Meta     `orm:"do:true"`
+			Id         any
+			Passport   any
+			Password   any
+			Nickname   any
+			CreateTime any
+		}
+		data := g.Slice{
+			User{
+				Id:       1,
+				Passport: "user_1",
+				Password: "pass_1",
+			},
+			User{
+				Id:       2,
+				Passport: "user_2",
+				Password: "pass_2",
+			},
+		}
+		result, err := db.Model(table).Data(data).Insert()
+		t.AssertNil(err)
+		n, _ := result.LastInsertId()
+		t.Assert(n, 2)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one[`id`], `1`)
+		t.Assert(one[`passport`], `user_1`)
+		t.Assert(one[`password`], `pass_1`)
+		t.Assert(one[`nickname`], ``)
+		t.Assert(one[`create_time`], ``)
+
+		one, err = db.Model(table).WherePri(2).One()
+		t.AssertNil(err)
+		t.Assert(one[`id`], `2`)
+		t.Assert(one[`passport`], `user_2`)
+		t.Assert(one[`password`], `pass_2`)
+		t.Assert(one[`nickname`], ``)
+		t.Assert(one[`create_time`], ``)
+	})
+}
+
+func Test_Model_Update_Data_DO(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			g.Meta     `orm:"do:true"`
+			Id         any
+			Passport   any
+			Password   any
+			Nickname   any
+			CreateTime any
+		}
+		data := User{
+			Id:       1,
+			Passport: "user_100",
+			Password: "pass_100",
+		}
+		_, err := db.Model(table).Data(data).WherePri(1).Update()
+		t.AssertNil(err)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one[`id`], `1`)
+		t.Assert(one[`passport`], `user_100`)
+		t.Assert(one[`password`], `pass_100`)
+		t.Assert(one[`nickname`], `name_1`)
+	})
+}
+
+func Test_Model_Update_Pointer_Data_DO(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type NN string
+		type Req struct {
+			Id       int
+			Passport *string
+			Password *string
+			Nickname *NN
+		}
+		type UserDo struct {
+			g.Meta     `orm:"do:true"`
+			Id         any
+			Passport   any
+			Password   any
+			Nickname   any
+			CreateTime any
+		}
+		var (
+			nickname = NN("nickname_111")
+			req      = Req{
+				Password: gconv.PtrString("12345678"),
+				Nickname: &nickname,
+			}
+			data = UserDo{
+				Passport: req.Passport,
+				Password: req.Password,
+				Nickname: req.Nickname,
+			}
+		)
+
+		_, err := db.Model(table).Data(data).WherePri(1).Update()
+		t.AssertNil(err)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one[`id`], `1`)
+		t.Assert(one[`password`], `12345678`)
+		t.Assert(one[`nickname`], `nickname_111`)
+	})
+}
+
+func Test_Model_Where_DO(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			g.Meta     `orm:"do:true"`
+			Id         any
+			Passport   any
+			Password   any
+			Nickname   any
+			CreateTime any
+		}
+		where := User{
+			Id:       1,
+			Passport: "user_1",
+			Password: "pass_1",
+		}
+		one, err := db.Model(table).Where(where).One()
+		t.AssertNil(err)
+		t.Assert(one[`id`], `1`)
+		t.Assert(one[`passport`], `user_1`)
+		t.Assert(one[`password`], `pass_1`)
+		t.Assert(one[`nickname`], `name_1`)
+	})
+}
+
+func Test_Model_Insert_Data_ForDao(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type UserForDao struct {
+			Id         any
+			Passport   any
+			Password   any
+			Nickname   any
+			CreateTime any
+		}
+		data := UserForDao{
+			Id:       1,
+			Passport: "user_1",
+			Password: "pass_1",
+		}
+		result, err := db.Model(table).Data(data).Insert()
+		t.AssertNil(err)
+		n, _ := result.LastInsertId()
+		t.Assert(n, 1)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one[`id`], `1`)
+		t.Assert(one[`passport`], `user_1`)
+		t.Assert(one[`password`], `pass_1`)
+		t.Assert(one[`nickname`], ``)
+		t.Assert(one[`create_time`], ``)
+	})
+}
+
+func Test_Model_Insert_Data_List_ForDao(t *testing.T) {
+	table := createTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type UserForDao struct {
+			Id         any
+			Passport   any
+			Password   any
+			Nickname   any
+			CreateTime any
+		}
+		data := g.Slice{
+			UserForDao{
+				Id:       1,
+				Passport: "user_1",
+				Password: "pass_1",
+			},
+			UserForDao{
+				Id:       2,
+				Passport: "user_2",
+				Password: "pass_2",
+			},
+		}
+		result, err := db.Model(table).Data(data).Insert()
+		t.AssertNil(err)
+		n, _ := result.LastInsertId()
+		t.Assert(n, 2)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one[`id`], `1`)
+		t.Assert(one[`passport`], `user_1`)
+		t.Assert(one[`password`], `pass_1`)
+		t.Assert(one[`nickname`], ``)
+		t.Assert(one[`create_time`], ``)
+
+		one, err = db.Model(table).WherePri(2).One()
+		t.AssertNil(err)
+		t.Assert(one[`id`], `2`)
+		t.Assert(one[`passport`], `user_2`)
+		t.Assert(one[`password`], `pass_2`)
+		t.Assert(one[`nickname`], ``)
+		t.Assert(one[`create_time`], ``)
+	})
+}
+
+func Test_Model_Update_Data_ForDao(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type UserForDao struct {
+			Id         any
+			Passport   any
+			Password   any
+			Nickname   any
+			CreateTime any
+		}
+		data := UserForDao{
+			Id:       1,
+			Passport: "user_100",
+			Password: "pass_100",
+		}
+		_, err := db.Model(table).Data(data).WherePri(1).Update()
+		t.AssertNil(err)
+
+		one, err := db.Model(table).WherePri(1).One()
+		t.AssertNil(err)
+		t.Assert(one[`id`], `1`)
+		t.Assert(one[`passport`], `user_100`)
+		t.Assert(one[`password`], `pass_100`)
+		t.Assert(one[`nickname`], `name_1`)
+	})
+}
+
+func Test_Model_Where_ForDao(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		type UserForDao struct {
+			Id         any
+			Passport   any
+			Password   any
+			Nickname   any
+			CreateTime any
+		}
+		where := UserForDao{
+			Id:       1,
+			Passport: "user_1",
+			Password: "pass_1",
+		}
+		one, err := db.Model(table).Where(where).One()
+		t.AssertNil(err)
+		t.Assert(one[`id`], `1`)
+		t.Assert(one[`passport`], `user_1`)
+		t.Assert(one[`password`], `pass_1`)
+		t.Assert(one[`nickname`], `name_1`)
+	})
+}
+
+func Test_Model_Where_FieldPrefix(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := gstr.SplitAndTrim(gtest.DataContent(`table_with_prefix.sql`), ";")
+		for _, v := range array {
+			if _, err := db.Exec(ctx, v); err != nil {
+				gtest.Error(err)
+			}
+		}
+		defer dropTable("instance")
+
+		type Instance struct {
+			ID   int `orm:"f_id"`
+			Name string
+		}
+
+		type InstanceDo struct {
+			g.Meta `orm:"table:instance, do:true"`
+			ID     any `orm:"f_id"`
+		}
+		var instance *Instance
+		err := db.Model("instance").Where(InstanceDo{
+			ID: 1,
+		}).Scan(&instance)
+		t.AssertNil(err)
+		t.AssertNE(instance, nil)
+		t.Assert(instance.ID, 1)
+		t.Assert(instance.Name, "john")
+	})
+	// With omitempty.
+	gtest.C(t, func(t *gtest.T) {
+		array := gstr.SplitAndTrim(gtest.DataContent(`table_with_prefix.sql`), ";")
+		for _, v := range array {
+			if _, err := db.Exec(ctx, v); err != nil {
+				gtest.Error(err)
+			}
+		}
+		defer dropTable("instance")
+
+		type Instance struct {
+			ID   int `orm:"f_id,omitempty"`
+			Name string
+		}
+
+		type InstanceDo struct {
+			g.Meta `orm:"table:instance, do:true"`
+			ID     any `orm:"f_id,omitempty"`
+		}
+		var instance *Instance
+		err := db.Model("instance").Where(InstanceDo{
+			ID: 1,
+		}).Scan(&instance)
+		t.AssertNil(err)
+		t.AssertNE(instance, nil)
+		t.Assert(instance.ID, 1)
+		t.Assert(instance.Name, "john")
+	})
+}

contrib/drivers/mariadb/mariadb_z_unit_feature_union_test.go

@@ -0,0 +1,146 @@
+// Copyright GoFrame Author(https://goframe.org). 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 mariadb_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/test/gtest"
+)
+
+func Test_Union(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.Union(
+			db.Model(table).Where("id", 1),
+			db.Model(table).Where("id", 2),
+			db.Model(table).WhereIn("id", g.Slice{1, 2, 3}).OrderDesc("id"),
+		).OrderDesc("id").All()
+
+		t.AssertNil(err)
+
+		t.Assert(len(r), 3)
+		t.Assert(r[0]["id"], 3)
+		t.Assert(r[1]["id"], 2)
+		t.Assert(r[2]["id"], 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.Union(
+			db.Model(table).Where("id", 1),
+			db.Model(table).Where("id", 2),
+			db.Model(table).WhereIn("id", g.Slice{1, 2, 3}).OrderDesc("id"),
+		).OrderDesc("id").One()
+
+		t.AssertNil(err)
+
+		t.Assert(r["id"], 3)
+	})
+}
+
+func Test_UnionAll(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.UnionAll(
+			db.Model(table).Where("id", 1),
+			db.Model(table).Where("id", 2),
+			db.Model(table).WhereIn("id", g.Slice{1, 2, 3}).OrderDesc("id"),
+		).OrderDesc("id").All()
+
+		t.AssertNil(err)
+
+		t.Assert(len(r), 5)
+		t.Assert(r[0]["id"], 3)
+		t.Assert(r[1]["id"], 2)
+		t.Assert(r[2]["id"], 2)
+		t.Assert(r[3]["id"], 1)
+		t.Assert(r[4]["id"], 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.UnionAll(
+			db.Model(table).Where("id", 1),
+			db.Model(table).Where("id", 2),
+			db.Model(table).WhereIn("id", g.Slice{1, 2, 3}).OrderDesc("id"),
+		).OrderDesc("id").One()
+
+		t.AssertNil(err)
+
+		t.Assert(r["id"], 3)
+	})
+}
+
+func Test_Model_Union(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.Model(table).Union(
+			db.Model(table).Where("id", 1),
+			db.Model(table).Where("id", 2),
+			db.Model(table).WhereIn("id", g.Slice{1, 2, 3}).OrderDesc("id"),
+		).OrderDesc("id").All()
+
+		t.AssertNil(err)
+
+		t.Assert(len(r), 3)
+		t.Assert(r[0]["id"], 3)
+		t.Assert(r[1]["id"], 2)
+		t.Assert(r[2]["id"], 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.Model(table).Union(
+			db.Model(table).Where("id", 1),
+			db.Model(table).Where("id", 2),
+			db.Model(table).WhereIn("id", g.Slice{1, 2, 3}).OrderDesc("id"),
+		).OrderDesc("id").One()
+
+		t.AssertNil(err)
+
+		t.Assert(r["id"], 3)
+	})
+}
+
+func Test_Model_UnionAll(t *testing.T) {
+	table := createInitTable()
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.Model(table).UnionAll(
+			db.Model(table).Where("id", 1),
+			db.Model(table).Where("id", 2),
+			db.Model(table).WhereIn("id", g.Slice{1, 2, 3}).OrderDesc("id"),
+		).OrderDesc("id").All()
+
+		t.AssertNil(err)
+
+		t.Assert(len(r), 5)
+		t.Assert(r[0]["id"], 3)
+		t.Assert(r[1]["id"], 2)
+		t.Assert(r[2]["id"], 2)
+		t.Assert(r[3]["id"], 1)
+		t.Assert(r[4]["id"], 1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		r, err := db.Model(table).UnionAll(
+			db.Model(table).Where("id", 1),
+			db.Model(table).Where("id", 2),
+			db.Model(table).WhereIn("id", g.Slice{1, 2, 3}).OrderDesc("id"),
+		).OrderDesc("id").One()
+
+		t.AssertNil(err)
+
+		t.Assert(r["id"], 3)
+	})
+}

contrib/drivers/mariadb/testdata/table_with_prefix.sql

@@ -0,0 +1,7 @@
+CREATE TABLE `instance`  (
+    `f_id` int(11) NOT NULL AUTO_INCREMENT,
+    `name` varchar(255) NULL DEFAULT '',
+    PRIMARY KEY (`f_id`) USING BTREE
+) ENGINE = InnoDB;
+
+INSERT INTO `instance` VALUES (1, 'john');

contrib/drivers/mariadb/testdata/with_multiple_depends.sql

@@ -0,0 +1,33 @@
+
+CREATE TABLE `table_a`  (
+    `id` int(11) NOT NULL AUTO_INCREMENT,
+    `alias` varchar(255) NULL DEFAULT '',
+    PRIMARY KEY (`id`) USING BTREE
+) ENGINE = InnoDB;
+
+INSERT INTO `table_a` VALUES (1, 'table_a_test1');
+INSERT INTO `table_a` VALUES (2, 'table_a_test2');
+
+CREATE TABLE `table_b`  (
+    `id` int(11) NOT NULL AUTO_INCREMENT,
+    `table_a_id` int(11) NOT NULL,
+    `alias` varchar(255) NULL DEFAULT '',
+    PRIMARY KEY (`id`) USING BTREE
+) ENGINE = InnoDB;
+
+INSERT INTO `table_b` VALUES (10, 1, 'table_b_test1');
+INSERT INTO `table_b` VALUES (20, 2, 'table_b_test2');
+INSERT INTO `table_b` VALUES (30, 1, 'table_b_test3');
+INSERT INTO `table_b` VALUES (40, 2, 'table_b_test4');
+
+CREATE TABLE `table_c`  (
+    `id` int(11) NOT NULL AUTO_INCREMENT,
+    `table_b_id` int(11) NOT NULL,
+    `alias` varchar(255) NULL DEFAULT '',
+    PRIMARY KEY (`id`) USING BTREE
+) ENGINE = InnoDB;
+
+INSERT INTO `table_c` VALUES (100, 10, 'table_c_test1');
+INSERT INTO `table_c` VALUES (200, 10, 'table_c_test2');
+INSERT INTO `table_c` VALUES (300, 20, 'table_c_test3');
+INSERT INTO `table_c` VALUES (400, 30, 'table_c_test4');

contrib/drivers/mariadb/testdata/with_tpl_user.sql

@@ -0,0 +1,5 @@
+CREATE TABLE IF NOT EXISTS %s (
+    id int(10) unsigned NOT NULL AUTO_INCREMENT,
+    name varchar(45) NOT NULL,
+    PRIMARY KEY (id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;

contrib/drivers/mariadb/testdata/with_tpl_user_detail.sql

@@ -0,0 +1,5 @@
+CREATE TABLE IF NOT EXISTS %s (
+    uid int(10) unsigned NOT NULL AUTO_INCREMENT,
+    address varchar(45) NOT NULL,
+    PRIMARY KEY (uid)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;

contrib/drivers/mariadb/testdata/with_tpl_user_scores.sql

@@ -0,0 +1,6 @@
+CREATE TABLE IF NOT EXISTS %s (
+    id int(10) unsigned NOT NULL AUTO_INCREMENT,
+    uid int(10) unsigned NOT NULL,
+    score int(10) unsigned NOT NULL,
+    PRIMARY KEY (id)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8;