mirror of
https://gitee.com/johng/gf.git
synced 2024-12-01 03:38:35 +08:00
371 lines
10 KiB
Go
371 lines
10 KiB
Go
// 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/os/gtime"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/gogf/gf/frame/g"
|
|
|
|
"github.com/gogf/gf/test/gtest"
|
|
)
|
|
|
|
func Test_CreateUpdateDeleteTime(t *testing.T) {
|
|
table := "time_test_table"
|
|
if _, err := db.Exec(fmt.Sprintf(`
|
|
CREATE TABLE %s (
|
|
id int(11) NOT NULL,
|
|
name varchar(45) DEFAULT NULL,
|
|
create_at datetime DEFAULT NULL,
|
|
update_at datetime DEFAULT NULL,
|
|
delete_at datetime DEFAULT NULL,
|
|
PRIMARY KEY (id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
|
|
`, table)); err != nil {
|
|
gtest.Error(err)
|
|
}
|
|
defer dropTable(table)
|
|
|
|
gtest.C(t, func(t *gtest.T) {
|
|
// Insert
|
|
dataInsert := g.Map{
|
|
"id": 1,
|
|
"name": "name_1",
|
|
}
|
|
r, err := db.Table(table).Data(dataInsert).Insert()
|
|
t.Assert(err, nil)
|
|
n, _ := r.RowsAffected()
|
|
t.Assert(n, 1)
|
|
|
|
oneInsert, err := db.Table(table).FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(oneInsert["id"].Int(), 1)
|
|
t.Assert(oneInsert["name"].String(), "name_1")
|
|
t.Assert(oneInsert["delete_at"].String(), "")
|
|
t.AssertGE(oneInsert["create_at"].GTime().Timestamp(), gtime.Timestamp()-2)
|
|
t.AssertGE(oneInsert["update_at"].GTime().Timestamp(), gtime.Timestamp())
|
|
|
|
time.Sleep(2 * time.Second)
|
|
|
|
// Save
|
|
dataSave := g.Map{
|
|
"id": 1,
|
|
"name": "name_10",
|
|
}
|
|
r, err = db.Table(table).Data(dataSave).Save()
|
|
t.Assert(err, nil)
|
|
n, _ = r.RowsAffected()
|
|
t.Assert(n, 2)
|
|
|
|
oneSave, err := db.Table(table).FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(oneSave["id"].Int(), 1)
|
|
t.Assert(oneSave["name"].String(), "name_10")
|
|
t.Assert(oneSave["delete_at"].String(), "")
|
|
t.Assert(oneSave["create_at"].GTime().Timestamp(), oneInsert["create_at"].GTime().Timestamp())
|
|
t.AssertNE(oneSave["update_at"].GTime().Timestamp(), oneInsert["update_at"].GTime().Timestamp())
|
|
t.AssertGE(oneSave["update_at"].GTime().Timestamp(), gtime.Now().Timestamp()-2)
|
|
|
|
time.Sleep(2 * time.Second)
|
|
|
|
// Update
|
|
dataUpdate := g.Map{
|
|
"id": 1,
|
|
"name": "name_1000",
|
|
}
|
|
r, err = db.Table(table).Data(dataUpdate).WherePri(1).Update()
|
|
t.Assert(err, nil)
|
|
n, _ = r.RowsAffected()
|
|
t.Assert(n, 1)
|
|
|
|
oneUpdate, err := db.Table(table).FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(oneUpdate["id"].Int(), 1)
|
|
t.Assert(oneUpdate["name"].String(), "name_1000")
|
|
t.Assert(oneUpdate["delete_at"].String(), "")
|
|
t.Assert(oneUpdate["create_at"].GTime().Timestamp(), oneInsert["create_at"].GTime().Timestamp())
|
|
t.AssertGE(oneUpdate["update_at"].GTime().Timestamp(), gtime.Now().Timestamp()-2)
|
|
|
|
// Replace
|
|
dataReplace := g.Map{
|
|
"id": 1,
|
|
"name": "name_100",
|
|
}
|
|
r, err = db.Table(table).Data(dataReplace).Replace()
|
|
t.Assert(err, nil)
|
|
n, _ = r.RowsAffected()
|
|
t.Assert(n, 2)
|
|
|
|
oneReplace, err := db.Table(table).FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(oneReplace["id"].Int(), 1)
|
|
t.Assert(oneReplace["name"].String(), "name_100")
|
|
t.Assert(oneReplace["delete_at"].String(), "")
|
|
t.AssertGE(oneReplace["create_at"].GTime().Timestamp(), oneInsert["create_at"].GTime().Timestamp())
|
|
t.AssertGE(oneReplace["update_at"].GTime().Timestamp(), oneInsert["update_at"].GTime().Timestamp())
|
|
|
|
time.Sleep(2 * time.Second)
|
|
|
|
// Delete
|
|
r, err = db.Table(table).Delete("id", 1)
|
|
t.Assert(err, nil)
|
|
n, _ = r.RowsAffected()
|
|
t.Assert(n, 1)
|
|
// Delete Select
|
|
one4, err := db.Table(table).FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(len(one4), 0)
|
|
one5, err := db.Table(table).Unscoped().FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(one5["id"].Int(), 1)
|
|
t.AssertGE(one5["delete_at"].GTime().Timestamp(), gtime.Now().Timestamp()-2)
|
|
// Delete Count
|
|
i, err := db.Table(table).FindCount()
|
|
t.Assert(err, nil)
|
|
t.Assert(i, 0)
|
|
i, err = db.Table(table).Unscoped().FindCount()
|
|
t.Assert(err, nil)
|
|
t.Assert(i, 1)
|
|
|
|
// Delete Unscoped
|
|
r, err = db.Table(table).Unscoped().Delete("id", 1)
|
|
t.Assert(err, nil)
|
|
n, _ = r.RowsAffected()
|
|
t.Assert(n, 1)
|
|
one6, err := db.Table(table).Unscoped().FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(len(one6), 0)
|
|
i, err = db.Table(table).Unscoped().FindCount()
|
|
t.Assert(err, nil)
|
|
t.Assert(i, 0)
|
|
})
|
|
}
|
|
|
|
func Test_SoftDelete_Join(t *testing.T) {
|
|
table1 := "time_test_table1"
|
|
if _, err := db.Exec(fmt.Sprintf(`
|
|
CREATE TABLE %s (
|
|
id int(11) NOT NULL,
|
|
name varchar(45) DEFAULT NULL,
|
|
create_at datetime DEFAULT NULL,
|
|
update_at datetime DEFAULT NULL,
|
|
delete_at datetime DEFAULT NULL,
|
|
PRIMARY KEY (id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
|
|
`, table1)); err != nil {
|
|
gtest.Error(err)
|
|
}
|
|
defer dropTable(table1)
|
|
|
|
table2 := "time_test_table2"
|
|
if _, err := db.Exec(fmt.Sprintf(`
|
|
CREATE TABLE %s (
|
|
id int(11) NOT NULL,
|
|
name varchar(45) DEFAULT NULL,
|
|
createat datetime DEFAULT NULL,
|
|
updateat datetime DEFAULT NULL,
|
|
deleteat datetime DEFAULT NULL,
|
|
PRIMARY KEY (id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
|
|
`, table2)); err != nil {
|
|
gtest.Error(err)
|
|
}
|
|
defer dropTable(table2)
|
|
|
|
gtest.C(t, func(t *gtest.T) {
|
|
//db.SetDebug(true)
|
|
dataInsert1 := g.Map{
|
|
"id": 1,
|
|
"name": "name_1",
|
|
}
|
|
r, err := db.Table(table1).Data(dataInsert1).Insert()
|
|
t.Assert(err, nil)
|
|
n, _ := r.RowsAffected()
|
|
t.Assert(n, 1)
|
|
|
|
dataInsert2 := g.Map{
|
|
"id": 1,
|
|
"name": "name_2",
|
|
}
|
|
r, err = db.Table(table2).Data(dataInsert2).Insert()
|
|
t.Assert(err, nil)
|
|
n, _ = r.RowsAffected()
|
|
t.Assert(n, 1)
|
|
|
|
one, err := db.Table(table1, "t1").LeftJoin(table2, "t2", "t2.id=t1.id").Fields("t1.name").FindOne()
|
|
t.Assert(err, nil)
|
|
t.Assert(one["name"], "name_1")
|
|
|
|
// Soft deleting.
|
|
r, err = db.Table(table1).Delete()
|
|
t.Assert(err, nil)
|
|
n, _ = r.RowsAffected()
|
|
t.Assert(n, 1)
|
|
|
|
one, err = db.Table(table1, "t1").LeftJoin(table2, "t2", "t2.id=t1.id").Fields("t1.name").FindOne()
|
|
t.Assert(err, nil)
|
|
t.Assert(one.IsEmpty(), true)
|
|
|
|
one, err = db.Table(table2, "t2").LeftJoin(table1, "t1", "t2.id=t1.id").Fields("t2.name").FindOne()
|
|
t.Assert(err, nil)
|
|
t.Assert(one.IsEmpty(), true)
|
|
})
|
|
}
|
|
|
|
func Test_CreateUpdateTime_Struct(t *testing.T) {
|
|
table := "time_test_table"
|
|
if _, err := db.Exec(fmt.Sprintf(`
|
|
CREATE TABLE %s (
|
|
id int(11) NOT NULL,
|
|
name varchar(45) DEFAULT NULL,
|
|
create_at datetime DEFAULT NULL,
|
|
update_at datetime DEFAULT NULL,
|
|
delete_at datetime DEFAULT NULL,
|
|
PRIMARY KEY (id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
|
|
`, table)); err != nil {
|
|
gtest.Error(err)
|
|
}
|
|
defer dropTable(table)
|
|
|
|
type Entity struct {
|
|
Id uint64 `orm:"id,primary" json:"id"`
|
|
Name string `orm:"name" json:"name"`
|
|
CreateAt *gtime.Time `orm:"create_at" json:"create_at"`
|
|
UpdateAt *gtime.Time `orm:"update_at" json:"update_at"`
|
|
DeleteAt *gtime.Time `orm:"delete_at" json:"delete_at"`
|
|
}
|
|
gtest.C(t, func(t *gtest.T) {
|
|
// Insert
|
|
dataInsert := &Entity{
|
|
Id: 1,
|
|
Name: "name_1",
|
|
CreateAt: nil,
|
|
UpdateAt: nil,
|
|
DeleteAt: nil,
|
|
}
|
|
r, err := db.Table(table).Data(dataInsert).Insert()
|
|
t.Assert(err, nil)
|
|
n, _ := r.RowsAffected()
|
|
t.Assert(n, 1)
|
|
|
|
oneInsert, err := db.Table(table).FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(oneInsert["id"].Int(), 1)
|
|
t.Assert(oneInsert["name"].String(), "name_1")
|
|
t.Assert(oneInsert["delete_at"].String(), "")
|
|
t.AssertGE(oneInsert["create_at"].GTime().Timestamp(), gtime.Timestamp()-2)
|
|
t.AssertGE(oneInsert["update_at"].GTime().Timestamp(), gtime.Timestamp())
|
|
|
|
time.Sleep(2 * time.Second)
|
|
|
|
// Save
|
|
dataSave := &Entity{
|
|
Id: 1,
|
|
Name: "name_10",
|
|
CreateAt: nil,
|
|
UpdateAt: nil,
|
|
DeleteAt: nil,
|
|
}
|
|
r, err = db.Table(table).Data(dataSave).Save()
|
|
t.Assert(err, nil)
|
|
n, _ = r.RowsAffected()
|
|
t.Assert(n, 2)
|
|
|
|
oneSave, err := db.Table(table).FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(oneSave["id"].Int(), 1)
|
|
t.Assert(oneSave["name"].String(), "name_10")
|
|
t.Assert(oneSave["delete_at"].String(), "")
|
|
t.Assert(oneSave["create_at"].GTime().Timestamp(), oneInsert["create_at"].GTime().Timestamp())
|
|
t.AssertNE(oneSave["update_at"].GTime().Timestamp(), oneInsert["update_at"].GTime().Timestamp())
|
|
t.AssertGE(oneSave["update_at"].GTime().Timestamp(), gtime.Now().Timestamp()-2)
|
|
|
|
time.Sleep(2 * time.Second)
|
|
|
|
// Update
|
|
dataUpdate := &Entity{
|
|
Id: 1,
|
|
Name: "name_1000",
|
|
CreateAt: nil,
|
|
UpdateAt: nil,
|
|
DeleteAt: nil,
|
|
}
|
|
r, err = db.Table(table).Data(dataUpdate).WherePri(1).Update()
|
|
t.Assert(err, nil)
|
|
n, _ = r.RowsAffected()
|
|
t.Assert(n, 1)
|
|
|
|
oneUpdate, err := db.Table(table).FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(oneUpdate["id"].Int(), 1)
|
|
t.Assert(oneUpdate["name"].String(), "name_1000")
|
|
t.Assert(oneUpdate["delete_at"].String(), "")
|
|
t.Assert(oneUpdate["create_at"].GTime().Timestamp(), oneInsert["create_at"].GTime().Timestamp())
|
|
t.AssertGE(oneUpdate["update_at"].GTime().Timestamp(), gtime.Now().Timestamp()-2)
|
|
|
|
// Replace
|
|
dataReplace := &Entity{
|
|
Id: 1,
|
|
Name: "name_100",
|
|
CreateAt: nil,
|
|
UpdateAt: nil,
|
|
DeleteAt: nil,
|
|
}
|
|
r, err = db.Table(table).Data(dataReplace).Replace()
|
|
t.Assert(err, nil)
|
|
n, _ = r.RowsAffected()
|
|
t.Assert(n, 2)
|
|
|
|
oneReplace, err := db.Table(table).FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(oneReplace["id"].Int(), 1)
|
|
t.Assert(oneReplace["name"].String(), "name_100")
|
|
t.Assert(oneReplace["delete_at"].String(), "")
|
|
t.AssertGE(oneReplace["create_at"].GTime().Timestamp(), oneInsert["create_at"].GTime().Timestamp())
|
|
t.AssertGE(oneReplace["update_at"].GTime().Timestamp(), oneInsert["update_at"].GTime().Timestamp())
|
|
|
|
time.Sleep(2 * time.Second)
|
|
|
|
// Delete
|
|
r, err = db.Table(table).Delete("id", 1)
|
|
t.Assert(err, nil)
|
|
n, _ = r.RowsAffected()
|
|
t.Assert(n, 1)
|
|
// Delete Select
|
|
one4, err := db.Table(table).FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(len(one4), 0)
|
|
one5, err := db.Table(table).Unscoped().FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(one5["id"].Int(), 1)
|
|
t.AssertGE(one5["delete_at"].GTime().Timestamp(), gtime.Now().Timestamp()-2)
|
|
// Delete Count
|
|
i, err := db.Table(table).FindCount()
|
|
t.Assert(err, nil)
|
|
t.Assert(i, 0)
|
|
i, err = db.Table(table).Unscoped().FindCount()
|
|
t.Assert(err, nil)
|
|
t.Assert(i, 1)
|
|
|
|
// Delete Unscoped
|
|
r, err = db.Table(table).Unscoped().Delete("id", 1)
|
|
t.Assert(err, nil)
|
|
n, _ = r.RowsAffected()
|
|
t.Assert(n, 1)
|
|
one6, err := db.Table(table).Unscoped().FindOne(1)
|
|
t.Assert(err, nil)
|
|
t.Assert(len(one6), 0)
|
|
i, err = db.Table(table).Unscoped().FindCount()
|
|
t.Assert(err, nil)
|
|
t.Assert(i, 0)
|
|
})
|
|
}
|