github.com/gogf/gf@v1.16.9/database/gdb/gdb_z_mysql_transaction_test.go (about)

     1  // Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
     2  //
     3  // This Source Code Form is subject to the terms of the MIT License.
     4  // If a copy of the MIT was not distributed with this file,
     5  // You can obtain one at https://github.com/gogf/gf.
     6  
     7  package gdb_test
     8  
     9  import (
    10  	"context"
    11  	"fmt"
    12  	"github.com/gogf/gf/os/gctx"
    13  	"testing"
    14  
    15  	"github.com/gogf/gf/database/gdb"
    16  	"github.com/gogf/gf/errors/gerror"
    17  
    18  	"github.com/gogf/gf/frame/g"
    19  	"github.com/gogf/gf/os/gtime"
    20  	"github.com/gogf/gf/test/gtest"
    21  )
    22  
    23  func Test_TX_Query(t *testing.T) {
    24  	tx, err := db.Begin()
    25  	if err != nil {
    26  		gtest.Error(err)
    27  	}
    28  	if rows, err := tx.Query("SELECT ?", 1); err != nil {
    29  		gtest.Error(err)
    30  	} else {
    31  		rows.Close()
    32  	}
    33  	if rows, err := tx.Query("SELECT ?+?", 1, 2); err != nil {
    34  		gtest.Error(err)
    35  	} else {
    36  		rows.Close()
    37  	}
    38  	if rows, err := tx.Query("SELECT ?+?", g.Slice{1, 2}); err != nil {
    39  		gtest.Error(err)
    40  	} else {
    41  		rows.Close()
    42  	}
    43  	if _, err := tx.Query("ERROR"); err == nil {
    44  		gtest.Error("FAIL")
    45  	}
    46  	if err := tx.Commit(); err != nil {
    47  		gtest.Error(err)
    48  	}
    49  }
    50  
    51  func Test_TX_Exec(t *testing.T) {
    52  	tx, err := db.Begin()
    53  	if err != nil {
    54  		gtest.Error(err)
    55  	}
    56  	if _, err := tx.Exec("SELECT ?", 1); err != nil {
    57  		gtest.Error(err)
    58  	}
    59  	if _, err := tx.Exec("SELECT ?+?", 1, 2); err != nil {
    60  		gtest.Error(err)
    61  	}
    62  	if _, err := tx.Exec("SELECT ?+?", g.Slice{1, 2}); err != nil {
    63  		gtest.Error(err)
    64  	}
    65  	if _, err := tx.Exec("ERROR"); err == nil {
    66  		gtest.Error("FAIL")
    67  	}
    68  	if err := tx.Commit(); err != nil {
    69  		gtest.Error(err)
    70  	}
    71  }
    72  
    73  func Test_TX_Commit(t *testing.T) {
    74  	tx, err := db.Begin()
    75  	if err != nil {
    76  		gtest.Error(err)
    77  	}
    78  	if err := tx.Commit(); err != nil {
    79  		gtest.Error(err)
    80  	}
    81  }
    82  
    83  func Test_TX_Rollback(t *testing.T) {
    84  	tx, err := db.Begin()
    85  	if err != nil {
    86  		gtest.Error(err)
    87  	}
    88  	if err := tx.Rollback(); err != nil {
    89  		gtest.Error(err)
    90  	}
    91  }
    92  
    93  func Test_TX_Prepare(t *testing.T) {
    94  	gtest.C(t, func(t *gtest.T) {
    95  		tx, err := db.Begin()
    96  		t.AssertNil(err)
    97  
    98  		st, err := tx.Prepare("SELECT 100")
    99  		t.AssertNil(err)
   100  
   101  		rows, err := st.Query()
   102  		t.AssertNil(err)
   103  
   104  		array, err := rows.Columns()
   105  		t.AssertNil(err)
   106  		t.Assert(array[0], "100")
   107  
   108  		rows.Close()
   109  		t.AssertNil(err)
   110  
   111  		tx.Commit()
   112  		t.AssertNil(err)
   113  	})
   114  }
   115  
   116  func Test_TX_Insert(t *testing.T) {
   117  	table := createTable()
   118  	defer dropTable(table)
   119  
   120  	gtest.C(t, func(t *gtest.T) {
   121  		tx, err := db.Begin()
   122  		if err != nil {
   123  			gtest.Error(err)
   124  		}
   125  		user := tx.Model(table)
   126  		if _, err := user.Data(g.Map{
   127  			"id":          1,
   128  			"passport":    "t1",
   129  			"password":    "25d55ad283aa400af464c76d713c07ad",
   130  			"nickname":    "T1",
   131  			"create_time": gtime.Now().String(),
   132  		}).Insert(); err != nil {
   133  			gtest.Error(err)
   134  		}
   135  		if _, err := tx.Insert(table, g.Map{
   136  			"id":          2,
   137  			"passport":    "t1",
   138  			"password":    "25d55ad283aa400af464c76d713c07ad",
   139  			"nickname":    "T1",
   140  			"create_time": gtime.Now().String(),
   141  		}); err != nil {
   142  			gtest.Error(err)
   143  		}
   144  
   145  		if n, err := tx.Model(table).Count(); err != nil {
   146  			gtest.Error(err)
   147  		} else {
   148  			t.Assert(n, 2)
   149  		}
   150  
   151  		if err := tx.Commit(); err != nil {
   152  			gtest.Error(err)
   153  		}
   154  
   155  	})
   156  }
   157  
   158  func Test_TX_BatchInsert(t *testing.T) {
   159  	table := createTable()
   160  	defer dropTable(table)
   161  
   162  	gtest.C(t, func(t *gtest.T) {
   163  		tx, err := db.Begin()
   164  		if err != nil {
   165  			gtest.Error(err)
   166  		}
   167  		if _, err := tx.Insert(table, g.List{
   168  			{
   169  				"id":          2,
   170  				"passport":    "t",
   171  				"password":    "25d55ad283aa400af464c76d713c07ad",
   172  				"nickname":    "T2",
   173  				"create_time": gtime.Now().String(),
   174  			},
   175  			{
   176  				"id":          3,
   177  				"passport":    "t3",
   178  				"password":    "25d55ad283aa400af464c76d713c07ad",
   179  				"nickname":    "T3",
   180  				"create_time": gtime.Now().String(),
   181  			},
   182  		}, 10); err != nil {
   183  			gtest.Error(err)
   184  		}
   185  		if err := tx.Commit(); err != nil {
   186  			gtest.Error(err)
   187  		}
   188  		if n, err := db.Model(table).Count(); err != nil {
   189  			gtest.Error(err)
   190  		} else {
   191  			t.Assert(n, 2)
   192  		}
   193  	})
   194  }
   195  
   196  func Test_TX_BatchReplace(t *testing.T) {
   197  	table := createInitTable()
   198  	defer dropTable(table)
   199  
   200  	gtest.C(t, func(t *gtest.T) {
   201  		tx, err := db.Begin()
   202  		if err != nil {
   203  			gtest.Error(err)
   204  		}
   205  		if _, err := tx.Replace(table, g.List{
   206  			{
   207  				"id":          2,
   208  				"passport":    "USER_2",
   209  				"password":    "PASS_2",
   210  				"nickname":    "NAME_2",
   211  				"create_time": gtime.Now().String(),
   212  			},
   213  			{
   214  				"id":          4,
   215  				"passport":    "USER_4",
   216  				"password":    "PASS_4",
   217  				"nickname":    "NAME_4",
   218  				"create_time": gtime.Now().String(),
   219  			},
   220  		}, 10); err != nil {
   221  			gtest.Error(err)
   222  		}
   223  		if err := tx.Commit(); err != nil {
   224  			gtest.Error(err)
   225  		}
   226  		if n, err := db.Model(table).Count(); err != nil {
   227  			gtest.Error(err)
   228  		} else {
   229  			t.Assert(n, TableSize)
   230  		}
   231  		if value, err := db.Model(table).Fields("password").Where("id", 2).Value(); err != nil {
   232  			gtest.Error(err)
   233  		} else {
   234  			t.Assert(value.String(), "PASS_2")
   235  		}
   236  	})
   237  }
   238  
   239  func Test_TX_BatchSave(t *testing.T) {
   240  	table := createInitTable()
   241  	defer dropTable(table)
   242  
   243  	gtest.C(t, func(t *gtest.T) {
   244  		tx, err := db.Begin()
   245  		if err != nil {
   246  			gtest.Error(err)
   247  		}
   248  		if _, err := tx.Save(table, g.List{
   249  			{
   250  				"id":          4,
   251  				"passport":    "USER_4",
   252  				"password":    "PASS_4",
   253  				"nickname":    "NAME_4",
   254  				"create_time": gtime.Now().String(),
   255  			},
   256  		}, 10); err != nil {
   257  			gtest.Error(err)
   258  		}
   259  		if err := tx.Commit(); err != nil {
   260  			gtest.Error(err)
   261  		}
   262  
   263  		if n, err := db.Model(table).Count(); err != nil {
   264  			gtest.Error(err)
   265  		} else {
   266  			t.Assert(n, TableSize)
   267  		}
   268  
   269  		if value, err := db.Model(table).Fields("password").Where("id", 4).Value(); err != nil {
   270  			gtest.Error(err)
   271  		} else {
   272  			t.Assert(value.String(), "PASS_4")
   273  		}
   274  	})
   275  }
   276  
   277  func Test_TX_Replace(t *testing.T) {
   278  	table := createInitTable()
   279  	defer dropTable(table)
   280  
   281  	gtest.C(t, func(t *gtest.T) {
   282  		tx, err := db.Begin()
   283  		if err != nil {
   284  			gtest.Error(err)
   285  		}
   286  		if _, err := tx.Replace(table, g.Map{
   287  			"id":          1,
   288  			"passport":    "USER_1",
   289  			"password":    "PASS_1",
   290  			"nickname":    "NAME_1",
   291  			"create_time": gtime.Now().String(),
   292  		}); err != nil {
   293  			gtest.Error(err)
   294  		}
   295  		if err := tx.Rollback(); err != nil {
   296  			gtest.Error(err)
   297  		}
   298  		if value, err := db.Model(table).Fields("nickname").Where("id", 1).Value(); err != nil {
   299  			gtest.Error(err)
   300  		} else {
   301  			t.Assert(value.String(), "name_1")
   302  		}
   303  	})
   304  }
   305  
   306  func Test_TX_Save(t *testing.T) {
   307  	table := createInitTable()
   308  	defer dropTable(table)
   309  
   310  	gtest.C(t, func(t *gtest.T) {
   311  		tx, err := db.Begin()
   312  		if err != nil {
   313  			gtest.Error(err)
   314  		}
   315  		if _, err := tx.Save(table, g.Map{
   316  			"id":          1,
   317  			"passport":    "USER_1",
   318  			"password":    "PASS_1",
   319  			"nickname":    "NAME_1",
   320  			"create_time": gtime.Now().String(),
   321  		}); err != nil {
   322  			gtest.Error(err)
   323  		}
   324  		if err := tx.Commit(); err != nil {
   325  			gtest.Error(err)
   326  		}
   327  		if value, err := db.Model(table).Fields("nickname").Where("id", 1).Value(); err != nil {
   328  			gtest.Error(err)
   329  		} else {
   330  			t.Assert(value.String(), "NAME_1")
   331  		}
   332  	})
   333  }
   334  
   335  func Test_TX_Update(t *testing.T) {
   336  	table := createInitTable()
   337  	defer dropTable(table)
   338  
   339  	gtest.C(t, func(t *gtest.T) {
   340  		tx, err := db.Begin()
   341  		if err != nil {
   342  			gtest.Error(err)
   343  		}
   344  		if result, err := tx.Update(table, "create_time='2019-10-24 10:00:00'", "id=3"); err != nil {
   345  			gtest.Error(err)
   346  		} else {
   347  			n, _ := result.RowsAffected()
   348  			t.Assert(n, 1)
   349  		}
   350  		if err := tx.Commit(); err != nil {
   351  			gtest.Error(err)
   352  		}
   353  		_, err = tx.Model(table).Fields("create_time").Where("id", 3).Value()
   354  		t.AssertNE(err, nil)
   355  
   356  		if value, err := db.Model(table).Fields("create_time").Where("id", 3).Value(); err != nil {
   357  			gtest.Error(err)
   358  		} else {
   359  			t.Assert(value.String(), "2019-10-24 10:00:00")
   360  		}
   361  	})
   362  }
   363  
   364  func Test_TX_GetAll(t *testing.T) {
   365  	table := createInitTable()
   366  	defer dropTable(table)
   367  
   368  	gtest.C(t, func(t *gtest.T) {
   369  		tx, err := db.Begin()
   370  		if err != nil {
   371  			gtest.Error(err)
   372  		}
   373  		if result, err := tx.GetAll(fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 1); err != nil {
   374  			gtest.Error(err)
   375  		} else {
   376  			t.Assert(len(result), 1)
   377  		}
   378  		if err := tx.Commit(); err != nil {
   379  			gtest.Error(err)
   380  		}
   381  	})
   382  }
   383  
   384  func Test_TX_GetOne(t *testing.T) {
   385  	table := createInitTable()
   386  	defer dropTable(table)
   387  
   388  	gtest.C(t, func(t *gtest.T) {
   389  		tx, err := db.Begin()
   390  		if err != nil {
   391  			gtest.Error(err)
   392  		}
   393  		if record, err := tx.GetOne(fmt.Sprintf("SELECT * FROM %s WHERE passport=?", table), "user_2"); err != nil {
   394  			gtest.Error(err)
   395  		} else {
   396  			if record == nil {
   397  				gtest.Error("FAIL")
   398  			}
   399  			t.Assert(record["nickname"].String(), "name_2")
   400  		}
   401  		if err := tx.Commit(); err != nil {
   402  			gtest.Error(err)
   403  		}
   404  	})
   405  }
   406  
   407  func Test_TX_GetValue(t *testing.T) {
   408  	table := createInitTable()
   409  	defer dropTable(table)
   410  
   411  	gtest.C(t, func(t *gtest.T) {
   412  		tx, err := db.Begin()
   413  		if err != nil {
   414  			gtest.Error(err)
   415  		}
   416  		if value, err := tx.GetValue(fmt.Sprintf("SELECT id FROM %s WHERE passport=?", table), "user_3"); err != nil {
   417  			gtest.Error(err)
   418  		} else {
   419  			t.Assert(value.Int(), 3)
   420  		}
   421  		if err := tx.Commit(); err != nil {
   422  			gtest.Error(err)
   423  		}
   424  	})
   425  
   426  }
   427  
   428  func Test_TX_GetCount(t *testing.T) {
   429  	table := createInitTable()
   430  	defer dropTable(table)
   431  
   432  	gtest.C(t, func(t *gtest.T) {
   433  		tx, err := db.Begin()
   434  		if err != nil {
   435  			gtest.Error(err)
   436  		}
   437  		if count, err := tx.GetCount("SELECT * FROM " + table); err != nil {
   438  			gtest.Error(err)
   439  		} else {
   440  			t.Assert(count, TableSize)
   441  		}
   442  		if err := tx.Commit(); err != nil {
   443  			gtest.Error(err)
   444  		}
   445  	})
   446  }
   447  
   448  func Test_TX_GetStruct(t *testing.T) {
   449  	table := createInitTable()
   450  	defer dropTable(table)
   451  
   452  	gtest.C(t, func(t *gtest.T) {
   453  		tx, err := db.Begin()
   454  		if err != nil {
   455  			gtest.Error(err)
   456  		}
   457  		type User struct {
   458  			Id         int
   459  			Passport   string
   460  			Password   string
   461  			NickName   string
   462  			CreateTime gtime.Time
   463  		}
   464  		user := new(User)
   465  		if err := tx.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil {
   466  			gtest.Error(err)
   467  		}
   468  		t.Assert(user.NickName, "name_3")
   469  		t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00")
   470  		if err := tx.Commit(); err != nil {
   471  			gtest.Error(err)
   472  		}
   473  	})
   474  	gtest.C(t, func(t *gtest.T) {
   475  		tx, err := db.Begin()
   476  		if err != nil {
   477  			gtest.Error(err)
   478  		}
   479  		type User struct {
   480  			Id         int
   481  			Passport   string
   482  			Password   string
   483  			NickName   string
   484  			CreateTime *gtime.Time
   485  		}
   486  		user := new(User)
   487  		if err := tx.GetStruct(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil {
   488  			gtest.Error(err)
   489  		}
   490  		t.Assert(user.NickName, "name_3")
   491  		t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00")
   492  		if err := tx.Commit(); err != nil {
   493  			gtest.Error(err)
   494  		}
   495  	})
   496  }
   497  
   498  func Test_TX_GetStructs(t *testing.T) {
   499  	table := createInitTable()
   500  	defer dropTable(table)
   501  
   502  	gtest.C(t, func(t *gtest.T) {
   503  		tx, err := db.Begin()
   504  		if err != nil {
   505  			gtest.Error(err)
   506  		}
   507  		type User struct {
   508  			Id         int
   509  			Passport   string
   510  			Password   string
   511  			NickName   string
   512  			CreateTime gtime.Time
   513  		}
   514  		var users []User
   515  		if err := tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil {
   516  			gtest.Error(err)
   517  		}
   518  		t.Assert(len(users), TableSize)
   519  		t.Assert(users[0].Id, 1)
   520  		t.Assert(users[1].Id, 2)
   521  		t.Assert(users[2].Id, 3)
   522  		t.Assert(users[0].NickName, "name_1")
   523  		t.Assert(users[1].NickName, "name_2")
   524  		t.Assert(users[2].NickName, "name_3")
   525  		t.Assert(users[2].CreateTime.String(), "2018-10-24 10:00:00")
   526  		if err := tx.Commit(); err != nil {
   527  			gtest.Error(err)
   528  		}
   529  	})
   530  
   531  	gtest.C(t, func(t *gtest.T) {
   532  		tx, err := db.Begin()
   533  		if err != nil {
   534  			gtest.Error(err)
   535  		}
   536  		type User struct {
   537  			Id         int
   538  			Passport   string
   539  			Password   string
   540  			NickName   string
   541  			CreateTime *gtime.Time
   542  		}
   543  		var users []User
   544  		if err := tx.GetStructs(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil {
   545  			gtest.Error(err)
   546  		}
   547  		t.Assert(len(users), TableSize)
   548  		t.Assert(users[0].Id, 1)
   549  		t.Assert(users[1].Id, 2)
   550  		t.Assert(users[2].Id, 3)
   551  		t.Assert(users[0].NickName, "name_1")
   552  		t.Assert(users[1].NickName, "name_2")
   553  		t.Assert(users[2].NickName, "name_3")
   554  		t.Assert(users[2].CreateTime.String(), "2018-10-24 10:00:00")
   555  		if err := tx.Commit(); err != nil {
   556  			gtest.Error(err)
   557  		}
   558  	})
   559  }
   560  
   561  func Test_TX_GetScan(t *testing.T) {
   562  	table := createInitTable()
   563  	defer dropTable(table)
   564  
   565  	gtest.C(t, func(t *gtest.T) {
   566  		tx, err := db.Begin()
   567  		if err != nil {
   568  			gtest.Error(err)
   569  		}
   570  		type User struct {
   571  			Id         int
   572  			Passport   string
   573  			Password   string
   574  			NickName   string
   575  			CreateTime gtime.Time
   576  		}
   577  		user := new(User)
   578  		if err := tx.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil {
   579  			gtest.Error(err)
   580  		}
   581  		t.Assert(user.NickName, "name_3")
   582  		t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00")
   583  		if err := tx.Commit(); err != nil {
   584  			gtest.Error(err)
   585  		}
   586  	})
   587  	gtest.C(t, func(t *gtest.T) {
   588  		tx, err := db.Begin()
   589  		if err != nil {
   590  			gtest.Error(err)
   591  		}
   592  		type User struct {
   593  			Id         int
   594  			Passport   string
   595  			Password   string
   596  			NickName   string
   597  			CreateTime *gtime.Time
   598  		}
   599  		user := new(User)
   600  		if err := tx.GetScan(user, fmt.Sprintf("SELECT * FROM %s WHERE id=?", table), 3); err != nil {
   601  			gtest.Error(err)
   602  		}
   603  		t.Assert(user.NickName, "name_3")
   604  		t.Assert(user.CreateTime.String(), "2018-10-24 10:00:00")
   605  		if err := tx.Commit(); err != nil {
   606  			gtest.Error(err)
   607  		}
   608  	})
   609  
   610  	gtest.C(t, func(t *gtest.T) {
   611  		tx, err := db.Begin()
   612  		if err != nil {
   613  			gtest.Error(err)
   614  		}
   615  		type User struct {
   616  			Id         int
   617  			Passport   string
   618  			Password   string
   619  			NickName   string
   620  			CreateTime gtime.Time
   621  		}
   622  		var users []User
   623  		if err := tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil {
   624  			gtest.Error(err)
   625  		}
   626  		t.Assert(len(users), TableSize)
   627  		t.Assert(users[0].Id, 1)
   628  		t.Assert(users[1].Id, 2)
   629  		t.Assert(users[2].Id, 3)
   630  		t.Assert(users[0].NickName, "name_1")
   631  		t.Assert(users[1].NickName, "name_2")
   632  		t.Assert(users[2].NickName, "name_3")
   633  		t.Assert(users[2].CreateTime.String(), "2018-10-24 10:00:00")
   634  		if err := tx.Commit(); err != nil {
   635  			gtest.Error(err)
   636  		}
   637  	})
   638  
   639  	gtest.C(t, func(t *gtest.T) {
   640  		tx, err := db.Begin()
   641  		if err != nil {
   642  			gtest.Error(err)
   643  		}
   644  		type User struct {
   645  			Id         int
   646  			Passport   string
   647  			Password   string
   648  			NickName   string
   649  			CreateTime *gtime.Time
   650  		}
   651  		var users []User
   652  		if err := tx.GetScan(&users, fmt.Sprintf("SELECT * FROM %s WHERE id>=?", table), 1); err != nil {
   653  			gtest.Error(err)
   654  		}
   655  		t.Assert(len(users), TableSize)
   656  		t.Assert(users[0].Id, 1)
   657  		t.Assert(users[1].Id, 2)
   658  		t.Assert(users[2].Id, 3)
   659  		t.Assert(users[0].NickName, "name_1")
   660  		t.Assert(users[1].NickName, "name_2")
   661  		t.Assert(users[2].NickName, "name_3")
   662  		t.Assert(users[2].CreateTime.String(), "2018-10-24 10:00:00")
   663  		if err := tx.Commit(); err != nil {
   664  			gtest.Error(err)
   665  		}
   666  	})
   667  }
   668  
   669  func Test_TX_Delete(t *testing.T) {
   670  	gtest.C(t, func(t *gtest.T) {
   671  		table := createInitTable()
   672  		defer dropTable(table)
   673  		tx, err := db.Begin()
   674  		if err != nil {
   675  			gtest.Error(err)
   676  		}
   677  		if _, err := tx.Delete(table, 1); err != nil {
   678  			gtest.Error(err)
   679  		}
   680  		if err := tx.Commit(); err != nil {
   681  			gtest.Error(err)
   682  		}
   683  		if n, err := db.Model(table).Count(); err != nil {
   684  			gtest.Error(err)
   685  		} else {
   686  			t.Assert(n, 0)
   687  		}
   688  
   689  		t.Assert(tx.IsClosed(), true)
   690  	})
   691  
   692  	gtest.C(t, func(t *gtest.T) {
   693  		table := createInitTable()
   694  		defer dropTable(table)
   695  		tx, err := db.Begin()
   696  		if err != nil {
   697  			gtest.Error(err)
   698  		}
   699  		if _, err := tx.Delete(table, 1); err != nil {
   700  			gtest.Error(err)
   701  		}
   702  		if n, err := tx.Model(table).Count(); err != nil {
   703  			gtest.Error(err)
   704  		} else {
   705  			t.Assert(n, 0)
   706  		}
   707  		if err := tx.Rollback(); err != nil {
   708  			gtest.Error(err)
   709  		}
   710  		if n, err := db.Model(table).Count(); err != nil {
   711  			gtest.Error(err)
   712  		} else {
   713  			t.Assert(n, TableSize)
   714  			t.AssertNE(n, 0)
   715  		}
   716  
   717  		t.Assert(tx.IsClosed(), true)
   718  	})
   719  }
   720  
   721  func Test_Transaction(t *testing.T) {
   722  	table := createInitTable()
   723  	defer dropTable(table)
   724  
   725  	gtest.C(t, func(t *gtest.T) {
   726  		ctx := context.TODO()
   727  		err := db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   728  			if _, err := tx.Ctx(ctx).Replace(table, g.Map{
   729  				"id":          1,
   730  				"passport":    "USER_1",
   731  				"password":    "PASS_1",
   732  				"nickname":    "NAME_1",
   733  				"create_time": gtime.Now().String(),
   734  			}); err != nil {
   735  				t.Error(err)
   736  			}
   737  			t.Assert(tx.IsClosed(), false)
   738  			return gerror.New("error")
   739  		})
   740  		t.AssertNE(err, nil)
   741  
   742  		if value, err := db.Model(table).Ctx(ctx).Fields("nickname").Where("id", 1).Value(); err != nil {
   743  			gtest.Error(err)
   744  		} else {
   745  			t.Assert(value.String(), "name_1")
   746  		}
   747  	})
   748  
   749  	gtest.C(t, func(t *gtest.T) {
   750  		ctx := context.TODO()
   751  		err := db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   752  			if _, err := tx.Replace(table, g.Map{
   753  				"id":          1,
   754  				"passport":    "USER_1",
   755  				"password":    "PASS_1",
   756  				"nickname":    "NAME_1",
   757  				"create_time": gtime.Now().String(),
   758  			}); err != nil {
   759  				t.Error(err)
   760  			}
   761  			return nil
   762  		})
   763  		t.AssertNil(err)
   764  
   765  		if value, err := db.Model(table).Fields("nickname").Where("id", 1).Value(); err != nil {
   766  			gtest.Error(err)
   767  		} else {
   768  			t.Assert(value.String(), "NAME_1")
   769  		}
   770  	})
   771  }
   772  
   773  func Test_Transaction_Panic(t *testing.T) {
   774  	table := createInitTable()
   775  	defer dropTable(table)
   776  
   777  	gtest.C(t, func(t *gtest.T) {
   778  		ctx := context.TODO()
   779  		err := db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   780  			if _, err := tx.Replace(table, g.Map{
   781  				"id":          1,
   782  				"passport":    "USER_1",
   783  				"password":    "PASS_1",
   784  				"nickname":    "NAME_1",
   785  				"create_time": gtime.Now().String(),
   786  			}); err != nil {
   787  				t.Error(err)
   788  			}
   789  			panic("error")
   790  			return nil
   791  		})
   792  		t.AssertNE(err, nil)
   793  
   794  		if value, err := db.Model(table).Fields("nickname").Where("id", 1).Value(); err != nil {
   795  			gtest.Error(err)
   796  		} else {
   797  			t.Assert(value.String(), "name_1")
   798  		}
   799  	})
   800  }
   801  
   802  func Test_Transaction_Nested_Begin_Rollback_Commit(t *testing.T) {
   803  	table := createTable()
   804  	defer dropTable(table)
   805  
   806  	gtest.C(t, func(t *gtest.T) {
   807  		tx, err := db.Begin()
   808  		t.AssertNil(err)
   809  		// tx begin.
   810  		err = tx.Begin()
   811  		t.AssertNil(err)
   812  		// tx rollback.
   813  		_, err = tx.Model(table).Data(g.Map{
   814  			"id":       1,
   815  			"passport": "user_1",
   816  			"password": "pass_1",
   817  			"nickname": "name_1",
   818  		}).Insert()
   819  		err = tx.Rollback()
   820  		t.AssertNil(err)
   821  		// tx commit.
   822  		_, err = tx.Model(table).Data(g.Map{
   823  			"id":       2,
   824  			"passport": "user_2",
   825  			"password": "pass_2",
   826  			"nickname": "name_2",
   827  		}).Insert()
   828  		err = tx.Commit()
   829  		t.AssertNil(err)
   830  		// check data.
   831  		all, err := db.Model(table).All()
   832  		t.AssertNil(err)
   833  		t.Assert(len(all), 1)
   834  		t.Assert(all[0]["id"], 2)
   835  	})
   836  }
   837  
   838  func Test_Transaction_Nested_TX_Transaction_UseTX(t *testing.T) {
   839  	table := createTable()
   840  	defer dropTable(table)
   841  
   842  	db.SetDebug(true)
   843  	defer db.SetDebug(false)
   844  
   845  	gtest.C(t, func(t *gtest.T) {
   846  		var (
   847  			err error
   848  			ctx = context.TODO()
   849  		)
   850  		err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   851  			// commit
   852  			err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   853  				err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   854  					err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   855  						err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   856  							err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   857  								_, err = tx.Model(table).Data(g.Map{
   858  									"id":          1,
   859  									"passport":    "USER_1",
   860  									"password":    "PASS_1",
   861  									"nickname":    "NAME_1",
   862  									"create_time": gtime.Now().String(),
   863  								}).Insert()
   864  								t.AssertNil(err)
   865  								return err
   866  							})
   867  							t.AssertNil(err)
   868  							return err
   869  						})
   870  						t.AssertNil(err)
   871  						return err
   872  					})
   873  					t.AssertNil(err)
   874  					return err
   875  				})
   876  				t.AssertNil(err)
   877  				return err
   878  			})
   879  			t.AssertNil(err)
   880  			// rollback
   881  			err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   882  				_, err = tx.Model(table).Data(g.Map{
   883  					"id":          2,
   884  					"passport":    "USER_2",
   885  					"password":    "PASS_2",
   886  					"nickname":    "NAME_2",
   887  					"create_time": gtime.Now().String(),
   888  				}).Insert()
   889  				t.AssertNil(err)
   890  				panic("error")
   891  				return err
   892  			})
   893  			t.AssertNE(err, nil)
   894  			return nil
   895  		})
   896  		t.AssertNil(err)
   897  
   898  		all, err := db.Ctx(ctx).Model(table).All()
   899  		t.AssertNil(err)
   900  		t.Assert(len(all), 1)
   901  		t.Assert(all[0]["id"], 1)
   902  
   903  		// another record.
   904  		err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   905  			// commit
   906  			err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   907  				err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   908  					err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   909  						err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   910  							err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   911  								_, err = tx.Model(table).Data(g.Map{
   912  									"id":          3,
   913  									"passport":    "USER_1",
   914  									"password":    "PASS_1",
   915  									"nickname":    "NAME_1",
   916  									"create_time": gtime.Now().String(),
   917  								}).Insert()
   918  								t.AssertNil(err)
   919  								return err
   920  							})
   921  							t.AssertNil(err)
   922  							return err
   923  						})
   924  						t.AssertNil(err)
   925  						return err
   926  					})
   927  					t.AssertNil(err)
   928  					return err
   929  				})
   930  				t.AssertNil(err)
   931  				return err
   932  			})
   933  			t.AssertNil(err)
   934  			// rollback
   935  			err = tx.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   936  				_, err = tx.Model(table).Data(g.Map{
   937  					"id":          4,
   938  					"passport":    "USER_2",
   939  					"password":    "PASS_2",
   940  					"nickname":    "NAME_2",
   941  					"create_time": gtime.Now().String(),
   942  				}).Insert()
   943  				t.AssertNil(err)
   944  				panic("error")
   945  				return err
   946  			})
   947  			t.AssertNE(err, nil)
   948  			return nil
   949  		})
   950  		t.AssertNil(err)
   951  
   952  		all, err = db.Ctx(ctx).Model(table).All()
   953  		t.AssertNil(err)
   954  		t.Assert(len(all), 2)
   955  		t.Assert(all[0]["id"], 1)
   956  		t.Assert(all[1]["id"], 3)
   957  	})
   958  }
   959  
   960  func Test_Transaction_Nested_TX_Transaction_UseDB(t *testing.T) {
   961  	table := createTable()
   962  	defer dropTable(table)
   963  
   964  	//db.SetDebug(true)
   965  	//defer db.SetDebug(false)
   966  
   967  	gtest.C(t, func(t *gtest.T) {
   968  		var (
   969  			err error
   970  			ctx = context.TODO()
   971  		)
   972  		err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   973  			// commit
   974  			err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   975  				err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   976  					err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   977  						err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   978  							err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
   979  								_, err = db.Model(table).Ctx(ctx).Data(g.Map{
   980  									"id":          1,
   981  									"passport":    "USER_1",
   982  									"password":    "PASS_1",
   983  									"nickname":    "NAME_1",
   984  									"create_time": gtime.Now().String(),
   985  								}).Insert()
   986  								t.AssertNil(err)
   987  								return err
   988  							})
   989  							t.AssertNil(err)
   990  							return err
   991  						})
   992  						t.AssertNil(err)
   993  						return err
   994  					})
   995  					t.AssertNil(err)
   996  					return err
   997  				})
   998  				t.AssertNil(err)
   999  				return err
  1000  			})
  1001  			t.AssertNil(err)
  1002  
  1003  			// rollback
  1004  			err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  1005  				_, err = tx.Model(table).Ctx(ctx).Data(g.Map{
  1006  					"id":          2,
  1007  					"passport":    "USER_2",
  1008  					"password":    "PASS_2",
  1009  					"nickname":    "NAME_2",
  1010  					"create_time": gtime.Now().String(),
  1011  				}).Insert()
  1012  				t.AssertNil(err)
  1013  				// panic makes this transaction rollback.
  1014  				panic("error")
  1015  				return err
  1016  			})
  1017  			t.AssertNE(err, nil)
  1018  			return nil
  1019  		})
  1020  		t.AssertNil(err)
  1021  		all, err := db.Model(table).All()
  1022  		t.AssertNil(err)
  1023  		t.Assert(len(all), 1)
  1024  		t.Assert(all[0]["id"], 1)
  1025  
  1026  		err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  1027  			// commit
  1028  			err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  1029  				err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  1030  					err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  1031  						err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  1032  							err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  1033  								_, err = db.Model(table).Ctx(ctx).Data(g.Map{
  1034  									"id":          3,
  1035  									"passport":    "USER_1",
  1036  									"password":    "PASS_1",
  1037  									"nickname":    "NAME_1",
  1038  									"create_time": gtime.Now().String(),
  1039  								}).Insert()
  1040  								t.AssertNil(err)
  1041  								return err
  1042  							})
  1043  							t.AssertNil(err)
  1044  							return err
  1045  						})
  1046  						t.AssertNil(err)
  1047  						return err
  1048  					})
  1049  					t.AssertNil(err)
  1050  					return err
  1051  				})
  1052  				t.AssertNil(err)
  1053  				return err
  1054  			})
  1055  			t.AssertNil(err)
  1056  
  1057  			// rollback
  1058  			err = db.Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
  1059  				_, err = tx.Model(table).Ctx(ctx).Data(g.Map{
  1060  					"id":          4,
  1061  					"passport":    "USER_2",
  1062  					"password":    "PASS_2",
  1063  					"nickname":    "NAME_2",
  1064  					"create_time": gtime.Now().String(),
  1065  				}).Insert()
  1066  				t.AssertNil(err)
  1067  				// panic makes this transaction rollback.
  1068  				panic("error")
  1069  				return err
  1070  			})
  1071  			t.AssertNE(err, nil)
  1072  			return nil
  1073  		})
  1074  		t.AssertNil(err)
  1075  
  1076  		all, err = db.Model(table).All()
  1077  		t.AssertNil(err)
  1078  		t.Assert(len(all), 2)
  1079  		t.Assert(all[0]["id"], 1)
  1080  		t.Assert(all[1]["id"], 3)
  1081  	})
  1082  }
  1083  
  1084  func Test_Transaction_Nested_SavePoint_RollbackTo(t *testing.T) {
  1085  	table := createTable()
  1086  	defer dropTable(table)
  1087  
  1088  	gtest.C(t, func(t *gtest.T) {
  1089  		tx, err := db.Begin()
  1090  		t.AssertNil(err)
  1091  		// tx save point.
  1092  		_, err = tx.Model(table).Data(g.Map{
  1093  			"id":       1,
  1094  			"passport": "user_1",
  1095  			"password": "pass_1",
  1096  			"nickname": "name_1",
  1097  		}).Insert()
  1098  		err = tx.SavePoint("MyPoint")
  1099  		t.AssertNil(err)
  1100  		_, err = tx.Model(table).Data(g.Map{
  1101  			"id":       2,
  1102  			"passport": "user_2",
  1103  			"password": "pass_2",
  1104  			"nickname": "name_2",
  1105  		}).Insert()
  1106  		// tx rollback to.
  1107  		err = tx.RollbackTo("MyPoint")
  1108  		t.AssertNil(err)
  1109  		// tx commit.
  1110  		err = tx.Commit()
  1111  		t.AssertNil(err)
  1112  
  1113  		// check data.
  1114  		all, err := db.Model(table).All()
  1115  		t.AssertNil(err)
  1116  		t.Assert(len(all), 1)
  1117  		t.Assert(all[0]["id"], 1)
  1118  	})
  1119  }
  1120  
  1121  func Test_Transaction_Method(t *testing.T) {
  1122  	table := createTable()
  1123  	defer dropTable(table)
  1124  
  1125  	gtest.C(t, func(t *gtest.T) {
  1126  		var err error
  1127  		err = db.Transaction(gctx.New(), func(ctx context.Context, tx *gdb.TX) error {
  1128  			_, err = db.Model(table).Ctx(ctx).Data(g.Map{
  1129  				"id":          1,
  1130  				"passport":    "t1",
  1131  				"password":    "25d55ad283aa400af464c76d713c07ad",
  1132  				"nickname":    "T1",
  1133  				"create_time": gtime.Now().String(),
  1134  			}).Insert()
  1135  			t.AssertNil(err)
  1136  
  1137  			_, err = db.Ctx(ctx).Exec(fmt.Sprintf(
  1138  				"insert into %s(`passport`,`password`,`nickname`,`create_time`,`id`) "+
  1139  					"VALUES('t2','25d55ad283aa400af464c76d713c07ad','T2','2021-08-25 21:53:00',2) ",
  1140  				table))
  1141  			t.AssertNil(err)
  1142  			return gerror.New("rollback")
  1143  		})
  1144  		t.AssertNE(err, nil)
  1145  
  1146  		count, err := db.Model(table).Count()
  1147  		t.AssertNil(err)
  1148  		t.Assert(count, 0)
  1149  	})
  1150  }