95a8a61d2b
* fix 5500: querySet should not be changed when constructing SQL * fix 5530: use orm.DebugLog
1460 lines
39 KiB
Go
1460 lines
39 KiB
Go
// Copyright 2020 beego
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package orm
|
|
|
|
import (
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"github.com/beego/beego/v2/client/orm/clauses/order_clause"
|
|
"github.com/beego/beego/v2/client/orm/internal/buffers"
|
|
|
|
"github.com/beego/beego/v2/client/orm/internal/models"
|
|
)
|
|
|
|
func TestDbBase_InsertValueSQL(t *testing.T) {
|
|
|
|
mi := &models.ModelInfo{
|
|
Table: "test_table",
|
|
}
|
|
|
|
testCases := []struct {
|
|
name string
|
|
db *dbBase
|
|
isMulti bool
|
|
names []string
|
|
values []interface{}
|
|
|
|
wantRes string
|
|
}{
|
|
{
|
|
name: "single insert by dbBase",
|
|
db: &dbBase{
|
|
ins: &dbBase{},
|
|
},
|
|
isMulti: false,
|
|
names: []string{"name", "age"},
|
|
values: []interface{}{"test", 18},
|
|
wantRes: "INSERT INTO `test_table` (`name`, `age`) VALUES (?, ?)",
|
|
},
|
|
{
|
|
name: "single insert by dbBasePostgres",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
isMulti: false,
|
|
names: []string{"name", "age"},
|
|
values: []interface{}{"test", 18},
|
|
wantRes: "INSERT INTO \"test_table\" (\"name\", \"age\") VALUES ($1, $2)",
|
|
},
|
|
{
|
|
name: "multi insert by dbBase",
|
|
db: &dbBase{
|
|
ins: &dbBase{},
|
|
},
|
|
isMulti: true,
|
|
names: []string{"name", "age"},
|
|
values: []interface{}{"test", 18, "test2", 19},
|
|
wantRes: "INSERT INTO `test_table` (`name`, `age`) VALUES (?, ?), (?, ?)",
|
|
},
|
|
{
|
|
name: "multi insert by dbBasePostgres",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
isMulti: true,
|
|
names: []string{"name", "age"},
|
|
values: []interface{}{"test", 18, "test2", 19},
|
|
wantRes: "INSERT INTO \"test_table\" (\"name\", \"age\") VALUES ($1, $2), ($3, $4)",
|
|
},
|
|
{
|
|
name: "multi insert by dbBase but values is not enough",
|
|
db: &dbBase{
|
|
ins: &dbBase{},
|
|
},
|
|
isMulti: true,
|
|
names: []string{"name", "age"},
|
|
values: []interface{}{"test", 18, "test2"},
|
|
wantRes: "INSERT INTO `test_table` (`name`, `age`) VALUES (?, ?)",
|
|
},
|
|
{
|
|
name: "multi insert by dbBasePostgres but values is not enough",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
isMulti: true,
|
|
names: []string{"name", "age"},
|
|
values: []interface{}{"test", 18, "test2"},
|
|
wantRes: "INSERT INTO \"test_table\" (\"name\", \"age\") VALUES ($1, $2)",
|
|
},
|
|
{
|
|
name: "single insert by dbBase but values is double to names",
|
|
db: &dbBase{
|
|
ins: &dbBase{},
|
|
},
|
|
isMulti: false,
|
|
names: []string{"name", "age"},
|
|
values: []interface{}{"test", 18, "test2", 19},
|
|
wantRes: "INSERT INTO `test_table` (`name`, `age`) VALUES (?, ?)",
|
|
},
|
|
{
|
|
name: "single insert by dbBasePostgres but values is double to names",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
isMulti: false,
|
|
names: []string{"name", "age"},
|
|
values: []interface{}{"test", 18, "test2", 19},
|
|
wantRes: "INSERT INTO \"test_table\" (\"name\", \"age\") VALUES ($1, $2)",
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
res := tc.db.InsertValueSQL(tc.names, tc.values, tc.isMulti, mi)
|
|
|
|
assert.Equal(t, tc.wantRes, res)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDbBase_UpdateSQL(t *testing.T) {
|
|
mi := &models.ModelInfo{
|
|
Table: "test_table",
|
|
}
|
|
|
|
testCases := []struct {
|
|
name string
|
|
db *dbBase
|
|
|
|
setNames []string
|
|
pkName string
|
|
|
|
wantRes string
|
|
}{
|
|
{
|
|
name: "update by dbBase",
|
|
db: &dbBase{
|
|
ins: &dbBase{},
|
|
},
|
|
setNames: []string{"name", "age", "sender"},
|
|
pkName: "id",
|
|
wantRes: "UPDATE `test_table` SET `name` = ?, `age` = ?, `sender` = ? WHERE `id` = ?",
|
|
},
|
|
{
|
|
name: "update by dbBasePostgres",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
setNames: []string{"name", "age", "sender"},
|
|
pkName: "id",
|
|
wantRes: "UPDATE \"test_table\" SET \"name\" = $1, \"age\" = $2, \"sender\" = $3 WHERE \"id\" = $4",
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
res := tc.db.UpdateSQL(tc.setNames, tc.pkName, mi)
|
|
|
|
assert.Equal(t, tc.wantRes, res)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDbBase_DeleteSQL(t *testing.T) {
|
|
mi := &models.ModelInfo{
|
|
Table: "test_table",
|
|
}
|
|
|
|
testCases := []struct {
|
|
name string
|
|
db *dbBase
|
|
|
|
whereCols []string
|
|
|
|
wantRes string
|
|
}{
|
|
{
|
|
name: "delete by dbBase with id",
|
|
db: &dbBase{
|
|
ins: &dbBase{},
|
|
},
|
|
whereCols: []string{"id"},
|
|
wantRes: "DELETE FROM `test_table` WHERE `id` = ?",
|
|
},
|
|
{
|
|
name: "delete by dbBase not id",
|
|
db: &dbBase{
|
|
ins: &dbBase{},
|
|
},
|
|
whereCols: []string{"name", "age"},
|
|
wantRes: "DELETE FROM `test_table` WHERE `name` = ? AND `age` = ?",
|
|
},
|
|
{
|
|
name: "delete by dbBasePostgres with id",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
whereCols: []string{"id"},
|
|
wantRes: "DELETE FROM \"test_table\" WHERE \"id\" = $1",
|
|
},
|
|
{
|
|
name: "delete by dbBasePostgres not id",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
whereCols: []string{"name", "age"},
|
|
wantRes: "DELETE FROM \"test_table\" WHERE \"name\" = $1 AND \"age\" = $2",
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
res := tc.db.DeleteSQL(tc.whereCols, mi)
|
|
|
|
assert.Equal(t, tc.wantRes, res)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDbBase_buildSetSQL(t *testing.T) {
|
|
|
|
testCases := []struct {
|
|
name string
|
|
|
|
db *dbBase
|
|
|
|
columns []string
|
|
values []interface{}
|
|
|
|
wantRes string
|
|
wantValues []interface{}
|
|
}{
|
|
{
|
|
name: "Set add/mul operator by dbBase",
|
|
db: &dbBase{
|
|
ins: &dbBase{},
|
|
},
|
|
columns: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
colValue{
|
|
opt: ColAdd,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColMultiply,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
wantRes: "SET T0.`name` = ?, T0.`age` = T0.`age` + ?, T0.`score` = T0.`score` * ?",
|
|
wantValues: []interface{}{"test_name", int64(12), int64(2), "test_origin_name", 18},
|
|
},
|
|
{
|
|
name: "Set min/except operator by dbBase",
|
|
db: &dbBase{
|
|
ins: &dbBase{},
|
|
},
|
|
columns: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
colValue{
|
|
opt: ColMinus,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColExcept,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
wantRes: "SET T0.`name` = ?, T0.`age` = T0.`age` - ?, T0.`score` = T0.`score` / ?",
|
|
wantValues: []interface{}{"test_name", int64(12), int64(2), "test_origin_name", 18},
|
|
},
|
|
{
|
|
name: "Set bitRShift/bitLShift operator by dbBase",
|
|
db: &dbBase{
|
|
ins: &dbBase{},
|
|
},
|
|
columns: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
colValue{
|
|
opt: ColBitRShift,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColBitLShift,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
wantRes: "SET T0.`name` = ?, T0.`age` = T0.`age` >> ?, T0.`score` = T0.`score` << ?",
|
|
wantValues: []interface{}{"test_name", int64(12), int64(2), "test_origin_name", 18},
|
|
},
|
|
{
|
|
name: "Set bitAnd/bitOr/bitXOR operator by dbBase",
|
|
db: &dbBase{
|
|
ins: &dbBase{},
|
|
},
|
|
columns: []string{"count", "age", "score"},
|
|
values: []interface{}{
|
|
colValue{
|
|
opt: ColBitAnd,
|
|
value: 28,
|
|
},
|
|
colValue{
|
|
opt: ColBitOr,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColBitXOR,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
wantRes: "SET T0.`count` = T0.`count` & ?, T0.`age` = T0.`age` | ?, T0.`score` = T0.`score` ^ ?",
|
|
wantValues: []interface{}{int64(28), int64(12), int64(2), "test_origin_name", 18},
|
|
},
|
|
{
|
|
name: "Set add/mul operator by dbBasePostgres",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
columns: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
colValue{
|
|
opt: ColAdd,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColMultiply,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
wantRes: `SET "name" = ?, "age" = "age" + ?, "score" = "score" * ?`,
|
|
wantValues: []interface{}{"test_name", int64(12), int64(2), "test_origin_name", 18},
|
|
},
|
|
{
|
|
name: "Set min/except operator by dbBasePostgres",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
columns: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
colValue{
|
|
opt: ColMinus,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColExcept,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
wantRes: `SET "name" = ?, "age" = "age" - ?, "score" = "score" / ?`,
|
|
wantValues: []interface{}{"test_name", int64(12), int64(2), "test_origin_name", 18},
|
|
},
|
|
{
|
|
name: "Set bitRShift/bitLShift operator by dbBasePostgres",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
columns: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
colValue{
|
|
opt: ColBitRShift,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColBitLShift,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
wantRes: `SET "name" = ?, "age" = "age" >> ?, "score" = "score" << ?`,
|
|
wantValues: []interface{}{"test_name", int64(12), int64(2), "test_origin_name", 18},
|
|
},
|
|
{
|
|
name: "Set bitAnd/bitOr/bitXOR operator by dbBasePostgres",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
columns: []string{"count", "age", "score"},
|
|
values: []interface{}{
|
|
colValue{
|
|
opt: ColBitAnd,
|
|
value: 28,
|
|
},
|
|
colValue{
|
|
opt: ColBitOr,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColBitXOR,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
wantRes: `SET "count" = "count" & ?, "age" = "age" | ?, "score" = "score" ^ ?`,
|
|
wantValues: []interface{}{int64(28), int64(12), int64(2), "test_origin_name", 18},
|
|
},
|
|
{
|
|
name: "Set add/mul operator by dbBaseSqlite",
|
|
db: &dbBase{
|
|
ins: newdbBaseSqlite(),
|
|
},
|
|
columns: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
colValue{
|
|
opt: ColAdd,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColMultiply,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
wantRes: "SET `name` = ?, `age` = `age` + ?, `score` = `score` * ?",
|
|
wantValues: []interface{}{"test_name", int64(12), int64(2), "test_origin_name", 18},
|
|
},
|
|
{
|
|
name: "Set min/except operator by dbBaseSqlite",
|
|
db: &dbBase{
|
|
ins: newdbBaseSqlite(),
|
|
},
|
|
columns: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
colValue{
|
|
opt: ColMinus,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColExcept,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
wantRes: "SET `name` = ?, `age` = `age` - ?, `score` = `score` / ?",
|
|
wantValues: []interface{}{"test_name", int64(12), int64(2), "test_origin_name", 18},
|
|
},
|
|
{
|
|
name: "Set bitRShift/bitLShift operator by dbBaseSqlite",
|
|
db: &dbBase{
|
|
ins: newdbBaseSqlite(),
|
|
},
|
|
columns: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
colValue{
|
|
opt: ColBitRShift,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColBitLShift,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
wantRes: "SET `name` = ?, `age` = `age` >> ?, `score` = `score` << ?",
|
|
wantValues: []interface{}{"test_name", int64(12), int64(2), "test_origin_name", 18},
|
|
},
|
|
{
|
|
name: "Set bitAnd/bitOr/bitXOR operator by dbBaseSqlite",
|
|
db: &dbBase{
|
|
ins: newdbBaseSqlite(),
|
|
},
|
|
columns: []string{"count", "age", "score"},
|
|
values: []interface{}{
|
|
colValue{
|
|
opt: ColBitAnd,
|
|
value: 28,
|
|
},
|
|
colValue{
|
|
opt: ColBitOr,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColBitXOR,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
wantRes: "SET `count` = `count` & ?, `age` = `age` | ?, `score` = `score` ^ ?",
|
|
wantValues: []interface{}{int64(28), int64(12), int64(2), "test_origin_name", 18},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
buf := buffers.Get()
|
|
defer buffers.Put(buf)
|
|
|
|
tc.db.buildSetSQL(buf, tc.columns, tc.values)
|
|
|
|
assert.Equal(t, tc.wantRes, buf.String())
|
|
assert.Equal(t, tc.wantValues, tc.values)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDbBase_UpdateBatchSQL(t *testing.T) {
|
|
mi := &models.ModelInfo{
|
|
Table: "test_tab",
|
|
Fields: &models.Fields{
|
|
Pk: &models.FieldInfo{
|
|
Column: "test_id",
|
|
},
|
|
},
|
|
}
|
|
|
|
testCases := []struct {
|
|
name string
|
|
db *dbBase
|
|
|
|
columns []string
|
|
values []interface{}
|
|
|
|
specifyIndexes string
|
|
join string
|
|
where string
|
|
|
|
wantRes string
|
|
}{
|
|
{
|
|
name: "update batch by dbBase",
|
|
db: &dbBase{
|
|
ins: &dbBase{},
|
|
},
|
|
|
|
columns: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
colValue{
|
|
opt: ColAdd,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColMultiply,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
|
|
specifyIndexes: " USE INDEX(`name`) ",
|
|
join: "LEFT OUTER JOIN `test_tab_2` T1 ON T1.`id` = T0.`test_id` ",
|
|
where: "WHERE T0.`name` = ? AND T1.`age` = ?",
|
|
|
|
wantRes: "UPDATE `test_tab` T0 USE INDEX(`name`) LEFT OUTER JOIN `test_tab_2` T1 ON T1.`id` = T0.`test_id` SET T0.`name` = ?, T0.`age` = T0.`age` + ?, T0.`score` = T0.`score` * ? WHERE T0.`name` = ? AND T1.`age` = ?",
|
|
},
|
|
{
|
|
name: "update batch by dbBasePostgres",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
|
|
columns: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
colValue{
|
|
opt: ColAdd,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColMultiply,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
|
|
specifyIndexes: ` USE INDEX("name") `,
|
|
join: `LEFT OUTER JOIN "test_tab_2" T1 ON T1."id" = T0."test_id" `,
|
|
where: `WHERE T0."name" = ? AND T1."age" = ?`,
|
|
|
|
wantRes: `UPDATE "test_tab" SET "name" = $1, "age" = "age" + $2, "score" = "score" * $3 WHERE "test_id" IN ( SELECT T0."test_id" FROM "test_tab" T0 USE INDEX("name") LEFT OUTER JOIN "test_tab_2" T1 ON T1."id" = T0."test_id" WHERE T0."name" = $4 AND T1."age" = $5 )`,
|
|
},
|
|
{
|
|
name: "update batch by dbBaseSqlite",
|
|
db: &dbBase{
|
|
ins: newdbBaseSqlite(),
|
|
},
|
|
|
|
columns: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
colValue{
|
|
opt: ColAdd,
|
|
value: 12,
|
|
},
|
|
colValue{
|
|
opt: ColMultiply,
|
|
value: 2,
|
|
},
|
|
"test_origin_name",
|
|
18,
|
|
},
|
|
|
|
specifyIndexes: " USE INDEX(`name`) ",
|
|
join: "LEFT OUTER JOIN `test_tab_2` T1 ON T1.`id` = T0.`test_id` ",
|
|
where: "WHERE T0.`name` = ? AND T1.`age` = ?",
|
|
|
|
wantRes: "UPDATE `test_tab` SET `name` = ?, `age` = `age` + ?, `score` = `score` * ? WHERE `test_id` IN ( SELECT T0.`test_id` FROM `test_tab` T0 USE INDEX(`name`) LEFT OUTER JOIN `test_tab_2` T1 ON T1.`id` = T0.`test_id` WHERE T0.`name` = ? AND T1.`age` = ? )",
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
res := tc.db.UpdateBatchSQL(mi, tc.columns, tc.values, tc.specifyIndexes, tc.join, tc.where)
|
|
|
|
assert.Equal(t, tc.wantRes, res)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDbBase_InsertOrUpdateSQL(t *testing.T) {
|
|
|
|
mi := &models.ModelInfo{
|
|
Table: "test_tab",
|
|
}
|
|
|
|
testCases := []struct {
|
|
name string
|
|
db *dbBase
|
|
|
|
names []string
|
|
values []interface{}
|
|
a *alias
|
|
args []string
|
|
|
|
wantRes string
|
|
wantErr error
|
|
wantValues []interface{}
|
|
}{
|
|
{
|
|
name: "test nonsupport driver",
|
|
db: &dbBase{
|
|
ins: newdbBaseSqlite(),
|
|
},
|
|
|
|
names: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
18,
|
|
12,
|
|
},
|
|
a: &alias{
|
|
Driver: DRSqlite,
|
|
DriverName: "sqlite3",
|
|
},
|
|
args: []string{
|
|
"`age`=20",
|
|
"`score`=`score`+1",
|
|
},
|
|
|
|
wantErr: errors.New("`sqlite3` nonsupport InsertOrUpdate in beego"),
|
|
wantValues: []interface{}{
|
|
"test_name",
|
|
18,
|
|
12,
|
|
},
|
|
},
|
|
{
|
|
name: "insert or update with MySQL",
|
|
db: &dbBase{
|
|
ins: newdbBaseMysql(),
|
|
},
|
|
|
|
names: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
18,
|
|
12,
|
|
},
|
|
a: &alias{
|
|
Driver: DRMySQL,
|
|
DriverName: "mysql",
|
|
},
|
|
args: []string{
|
|
"`age`=20",
|
|
"`score`=`score`+1",
|
|
},
|
|
|
|
wantRes: "INSERT INTO `test_tab` (`name`, `age`, `score`) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE `name`=?, `age`=20, `score`=`score`+1",
|
|
wantValues: []interface{}{
|
|
"test_name",
|
|
18,
|
|
12,
|
|
"test_name",
|
|
},
|
|
},
|
|
{
|
|
name: "insert or update with MySQL with no args",
|
|
db: &dbBase{
|
|
ins: newdbBaseMysql(),
|
|
},
|
|
|
|
names: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
18,
|
|
12,
|
|
},
|
|
a: &alias{
|
|
Driver: DRMySQL,
|
|
DriverName: "mysql",
|
|
},
|
|
|
|
wantRes: "INSERT INTO `test_tab` (`name`, `age`, `score`) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE `name`=?, `age`=?, `score`=?",
|
|
wantValues: []interface{}{
|
|
"test_name",
|
|
18,
|
|
12,
|
|
"test_name",
|
|
18,
|
|
12,
|
|
},
|
|
},
|
|
{
|
|
name: "insert or update with PostgreSQL normal",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
|
|
names: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
18,
|
|
12,
|
|
},
|
|
a: &alias{
|
|
Driver: DRPostgres,
|
|
DriverName: "postgres",
|
|
},
|
|
args: []string{
|
|
`"name"`,
|
|
`"score"="score_1"`,
|
|
},
|
|
|
|
wantRes: `INSERT INTO "test_tab" ("name", "age", "score") VALUES ($1, $2, $3) ON CONFLICT ("name") DO UPDATE SET "name"=$4, "age"=$5, "score"=(select "score_1" from test_tab where "name" = $6 )`,
|
|
wantValues: []interface{}{
|
|
"test_name",
|
|
18,
|
|
12,
|
|
"test_name",
|
|
18,
|
|
"test_name",
|
|
},
|
|
},
|
|
{
|
|
name: "insert or update with PostgreSQL without conflict column",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
|
|
names: []string{"name", "age", "score"},
|
|
values: []interface{}{
|
|
"test_name",
|
|
18,
|
|
12,
|
|
},
|
|
a: &alias{
|
|
Driver: DRPostgres,
|
|
DriverName: "postgres",
|
|
},
|
|
|
|
wantErr: errors.New("`postgres` use InsertOrUpdate must have a conflict column"),
|
|
wantValues: []interface{}{
|
|
"test_name",
|
|
18,
|
|
12,
|
|
},
|
|
},
|
|
{
|
|
name: "insert or update with PostgreSQL the conflict column is not in front of the specified column",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
|
|
names: []string{"score", "name", "age"},
|
|
values: []interface{}{
|
|
12,
|
|
"test_name",
|
|
18,
|
|
},
|
|
a: &alias{
|
|
Driver: DRPostgres,
|
|
DriverName: "postgres",
|
|
},
|
|
args: []string{
|
|
`"name"`,
|
|
`"score"="score_1"`,
|
|
},
|
|
|
|
wantErr: errors.New("`\"name\"` must be in front of `\"score\"` in your struct"),
|
|
wantValues: []interface{}{
|
|
12,
|
|
"test_name",
|
|
18,
|
|
},
|
|
},
|
|
{
|
|
name: "insert or update with PostgreSQL the conflict column is in front of the specified column",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
|
|
names: []string{"age", "name", "score"},
|
|
values: []interface{}{
|
|
18,
|
|
"test_name",
|
|
12,
|
|
},
|
|
a: &alias{
|
|
Driver: DRPostgres,
|
|
DriverName: "postgres",
|
|
},
|
|
args: []string{
|
|
`"name"`,
|
|
`"score"="score_1"`,
|
|
},
|
|
|
|
wantRes: `INSERT INTO "test_tab" ("age", "name", "score") VALUES ($1, $2, $3) ON CONFLICT ("name") DO UPDATE SET "age"=$4, "name"=$5, "score"=(select "score_1" from test_tab where "name" = $6 )`,
|
|
wantValues: []interface{}{
|
|
18,
|
|
"test_name",
|
|
12,
|
|
18,
|
|
"test_name",
|
|
"test_name",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
|
|
res, err := tc.db.InsertOrUpdateSQL(tc.names, &tc.values, mi, tc.a, tc.args...)
|
|
|
|
assert.Equal(t, tc.wantValues, tc.values)
|
|
|
|
assert.Equal(t, tc.wantErr, err)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
assert.Equal(t, tc.wantRes, res)
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestDbBase_readBatchSQL(t *testing.T) {
|
|
|
|
mc := models.NewModelCacheHandler()
|
|
|
|
err := mc.Register("", false, new(testTab), new(testTab1), new(testTab2))
|
|
|
|
assert.Nil(t, err)
|
|
|
|
mc.Bootstrap()
|
|
|
|
mi, ok := mc.GetByMd(new(testTab))
|
|
|
|
assert.True(t, ok)
|
|
|
|
cond := NewCondition().And("name", "test_name").
|
|
OrCond(NewCondition().And("age__gt", 18).And("score__lt", 60))
|
|
|
|
tz := time.Local
|
|
|
|
testCases := []struct {
|
|
name string
|
|
db *dbBase
|
|
|
|
tCols []string
|
|
qs querySet
|
|
|
|
wantRes string
|
|
wantArgs []interface{}
|
|
}{
|
|
{
|
|
name: "read batch with MySQL",
|
|
db: &dbBase{
|
|
ins: newdbBaseMysql(),
|
|
},
|
|
tCols: []string{"name", "score"},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
useIndex: 1,
|
|
indexes: []string{"name", "score"},
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
},
|
|
wantRes: "SELECT T0.`name`, T0.`score`, T1.`id`, T1.`name_1`, T1.`age_1`, T1.`score_1`, T1.`test_tab_2_id`, T2.`id`, T2.`name_2`, T2.`age_2`, T2.`score_2` FROM `test_tab` T0 USE INDEX(`name`,`score`) INNER JOIN `test_tab1` T1 ON T1.`id` = T0.`test_tab_1_id` INNER JOIN `test_tab2` T2 ON T2.`id` = T1.`test_tab_2_id` WHERE T0.`name` = ? OR ( T0.`age` > ? AND T0.`score` < ? ) GROUP BY T0.`name`, T0.`age` ORDER BY T0.`score` DESC, T0.`age` ASC LIMIT 10 OFFSET 100",
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "read batch with MySQL and distinct",
|
|
db: &dbBase{
|
|
ins: newdbBaseMysql(),
|
|
},
|
|
tCols: []string{"name", "score"},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
useIndex: 1,
|
|
indexes: []string{"name", "score"},
|
|
distinct: true,
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
},
|
|
wantRes: "SELECT DISTINCT T0.`name`, T0.`score`, T1.`id`, T1.`name_1`, T1.`age_1`, T1.`score_1`, T1.`test_tab_2_id`, T2.`id`, T2.`name_2`, T2.`age_2`, T2.`score_2` FROM `test_tab` T0 USE INDEX(`name`,`score`) INNER JOIN `test_tab1` T1 ON T1.`id` = T0.`test_tab_1_id` INNER JOIN `test_tab2` T2 ON T2.`id` = T1.`test_tab_2_id` WHERE T0.`name` = ? OR ( T0.`age` > ? AND T0.`score` < ? ) GROUP BY T0.`name`, T0.`age` ORDER BY T0.`score` DESC, T0.`age` ASC LIMIT 10 OFFSET 100",
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "read batch with MySQL and aggregate",
|
|
db: &dbBase{
|
|
ins: newdbBaseMysql(),
|
|
},
|
|
tCols: []string{"name", "score"},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
useIndex: 1,
|
|
indexes: []string{"name", "score"},
|
|
aggregate: "sum(`T0`.`score`), count(`T1`.`name_1`)",
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
},
|
|
wantRes: "SELECT sum(`T0`.`score`), count(`T1`.`name_1`) FROM `test_tab` T0 USE INDEX(`name`,`score`) INNER JOIN `test_tab1` T1 ON T1.`id` = T0.`test_tab_1_id` INNER JOIN `test_tab2` T2 ON T2.`id` = T1.`test_tab_2_id` WHERE T0.`name` = ? OR ( T0.`age` > ? AND T0.`score` < ? ) GROUP BY T0.`name`, T0.`age` ORDER BY T0.`score` DESC, T0.`age` ASC LIMIT 10 OFFSET 100",
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "read batch with MySQL and distinct and aggregate",
|
|
db: &dbBase{
|
|
ins: newdbBaseMysql(),
|
|
},
|
|
tCols: []string{"name", "score"},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
useIndex: 1,
|
|
indexes: []string{"name", "score"},
|
|
distinct: true,
|
|
aggregate: "sum(`T0`.`score`), count(`T1`.`name_1`)",
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
},
|
|
wantRes: "SELECT DISTINCT sum(`T0`.`score`), count(`T1`.`name_1`) FROM `test_tab` T0 USE INDEX(`name`,`score`) INNER JOIN `test_tab1` T1 ON T1.`id` = T0.`test_tab_1_id` INNER JOIN `test_tab2` T2 ON T2.`id` = T1.`test_tab_2_id` WHERE T0.`name` = ? OR ( T0.`age` > ? AND T0.`score` < ? ) GROUP BY T0.`name`, T0.`age` ORDER BY T0.`score` DESC, T0.`age` ASC LIMIT 10 OFFSET 100",
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "read batch with MySQL and for update",
|
|
db: &dbBase{
|
|
ins: newdbBaseMysql(),
|
|
},
|
|
tCols: []string{"name", "score"},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
useIndex: 1,
|
|
indexes: []string{"name", "score"},
|
|
forUpdate: true,
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
},
|
|
wantRes: "SELECT T0.`name`, T0.`score`, T1.`id`, T1.`name_1`, T1.`age_1`, T1.`score_1`, T1.`test_tab_2_id`, T2.`id`, T2.`name_2`, T2.`age_2`, T2.`score_2` FROM `test_tab` T0 USE INDEX(`name`,`score`) INNER JOIN `test_tab1` T1 ON T1.`id` = T0.`test_tab_1_id` INNER JOIN `test_tab2` T2 ON T2.`id` = T1.`test_tab_2_id` WHERE T0.`name` = ? OR ( T0.`age` > ? AND T0.`score` < ? ) GROUP BY T0.`name`, T0.`age` ORDER BY T0.`score` DESC, T0.`age` ASC LIMIT 10 OFFSET 100 FOR UPDATE",
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "read batch with PostgreSQL",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
tCols: []string{"name", "score"},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
},
|
|
wantRes: `SELECT T0."name", T0."score", T1."id", T1."name_1", T1."age_1", T1."score_1", T1."test_tab_2_id", T2."id", T2."name_2", T2."age_2", T2."score_2" FROM "test_tab" T0 INNER JOIN "test_tab1" T1 ON T1."id" = T0."test_tab_1_id" INNER JOIN "test_tab2" T2 ON T2."id" = T1."test_tab_2_id" WHERE T0."name" = $1 OR ( T0."age" > $2 AND T0."score" < $3 ) GROUP BY T0."name", T0."age" ORDER BY T0."score" DESC, T0."age" ASC LIMIT 10 OFFSET 100`,
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "read batch with PostgreSQL and distinct",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
tCols: []string{"name", "score"},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
distinct: true,
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
},
|
|
wantRes: `SELECT DISTINCT T0."name", T0."score", T1."id", T1."name_1", T1."age_1", T1."score_1", T1."test_tab_2_id", T2."id", T2."name_2", T2."age_2", T2."score_2" FROM "test_tab" T0 INNER JOIN "test_tab1" T1 ON T1."id" = T0."test_tab_1_id" INNER JOIN "test_tab2" T2 ON T2."id" = T1."test_tab_2_id" WHERE T0."name" = $1 OR ( T0."age" > $2 AND T0."score" < $3 ) GROUP BY T0."name", T0."age" ORDER BY T0."score" DESC, T0."age" ASC LIMIT 10 OFFSET 100`,
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "read batch with PostgreSQL and aggregate",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
tCols: []string{"name", "score"},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
aggregate: `sum("T0"."score"), count("T1"."name_1")`,
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
},
|
|
wantRes: `SELECT sum("T0"."score"), count("T1"."name_1") FROM "test_tab" T0 INNER JOIN "test_tab1" T1 ON T1."id" = T0."test_tab_1_id" INNER JOIN "test_tab2" T2 ON T2."id" = T1."test_tab_2_id" WHERE T0."name" = $1 OR ( T0."age" > $2 AND T0."score" < $3 ) GROUP BY T0."name", T0."age" ORDER BY T0."score" DESC, T0."age" ASC LIMIT 10 OFFSET 100`,
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "read batch with PostgreSQL and distinct and aggregate",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
tCols: []string{"name", "score"},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
distinct: true,
|
|
aggregate: `sum("T0"."score"), count("T1"."name_1")`,
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
},
|
|
wantRes: `SELECT DISTINCT sum("T0"."score"), count("T1"."name_1") FROM "test_tab" T0 INNER JOIN "test_tab1" T1 ON T1."id" = T0."test_tab_1_id" INNER JOIN "test_tab2" T2 ON T2."id" = T1."test_tab_2_id" WHERE T0."name" = $1 OR ( T0."age" > $2 AND T0."score" < $3 ) GROUP BY T0."name", T0."age" ORDER BY T0."score" DESC, T0."age" ASC LIMIT 10 OFFSET 100`,
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "read batch with PostgreSQL and for update",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
tCols: []string{"name", "score"},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
forUpdate: true,
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
},
|
|
wantRes: `SELECT T0."name", T0."score", T1."id", T1."name_1", T1."age_1", T1."score_1", T1."test_tab_2_id", T2."id", T2."name_2", T2."age_2", T2."score_2" FROM "test_tab" T0 INNER JOIN "test_tab1" T1 ON T1."id" = T0."test_tab_1_id" INNER JOIN "test_tab2" T2 ON T2."id" = T1."test_tab_2_id" WHERE T0."name" = $1 OR ( T0."age" > $2 AND T0."score" < $3 ) GROUP BY T0."name", T0."age" ORDER BY T0."score" DESC, T0."age" ASC LIMIT 10 OFFSET 100 FOR UPDATE`,
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
tables := newDbTables(mi, tc.db.ins)
|
|
tables.parseRelated(tc.qs.related, tc.qs.relDepth)
|
|
|
|
res, args := tc.db.readBatchSQL(tables, tc.tCols, cond, tc.qs, mi, tz)
|
|
|
|
assert.Equal(t, tc.wantRes, res)
|
|
assert.Equal(t, tc.wantArgs, args)
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestDbBase_readValuesSQL(t *testing.T) {
|
|
|
|
mc := models.NewModelCacheHandler()
|
|
|
|
err := mc.Register("", false, new(testTab), new(testTab1), new(testTab2))
|
|
|
|
assert.Nil(t, err)
|
|
|
|
mc.Bootstrap()
|
|
|
|
mi, ok := mc.GetByMd(new(testTab))
|
|
|
|
assert.True(t, ok)
|
|
|
|
cond := NewCondition().And("name", "test_name").
|
|
OrCond(NewCondition().And("age__gt", 18).And("score__lt", 60))
|
|
|
|
tz := time.Local
|
|
|
|
testCases := []struct {
|
|
name string
|
|
db *dbBase
|
|
|
|
cols []string
|
|
qs querySet
|
|
|
|
wantRes string
|
|
wantArgs []interface{}
|
|
}{
|
|
{
|
|
name: "read values with MySQL",
|
|
db: &dbBase{
|
|
ins: newdbBaseMysql(),
|
|
},
|
|
cols: []string{"T0.`name` name", "T0.`age` age", "T0.`score` score"},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
useIndex: 1,
|
|
indexes: []string{"name", "score"},
|
|
},
|
|
wantRes: "SELECT T0.`name` name, T0.`age` age, T0.`score` score FROM `test_tab` T0 USE INDEX(`name`,`score`) WHERE T0.`name` = ? OR ( T0.`age` > ? AND T0.`score` < ? ) GROUP BY T0.`name`, T0.`age` ORDER BY T0.`score` DESC, T0.`age` ASC LIMIT 10 OFFSET 100",
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "read values with MySQL and distinct",
|
|
db: &dbBase{
|
|
ins: newdbBaseMysql(),
|
|
},
|
|
cols: []string{"T0.`name` name", "T0.`age` age", "T0.`score` score"},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
useIndex: 1,
|
|
indexes: []string{"name", "score"},
|
|
distinct: true,
|
|
},
|
|
wantRes: "SELECT DISTINCT T0.`name` name, T0.`age` age, T0.`score` score FROM `test_tab` T0 USE INDEX(`name`,`score`) WHERE T0.`name` = ? OR ( T0.`age` > ? AND T0.`score` < ? ) GROUP BY T0.`name`, T0.`age` ORDER BY T0.`score` DESC, T0.`age` ASC LIMIT 10 OFFSET 100",
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "read values with PostgreSQL",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
cols: []string{`T0."name" name`, `T0."age" age`, `T0."score" score`},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
},
|
|
wantRes: `SELECT T0."name" name, T0."age" age, T0."score" score FROM "test_tab" T0 WHERE T0."name" = $1 OR ( T0."age" > $2 AND T0."score" < $3 ) GROUP BY T0."name", T0."age" ORDER BY T0."score" DESC, T0."age" ASC LIMIT 10 OFFSET 100`,
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "read values with PostgreSQL and distinct",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
cols: []string{`T0."name" name`, `T0."age" age`, `T0."score" score`},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
limit: 10,
|
|
offset: 100,
|
|
groups: []string{"name", "age"},
|
|
orders: []*order_clause.Order{
|
|
order_clause.Clause(order_clause.Column("score"),
|
|
order_clause.SortDescending()),
|
|
order_clause.Clause(order_clause.Column("age"),
|
|
order_clause.SortAscending()),
|
|
},
|
|
distinct: true,
|
|
},
|
|
wantRes: `SELECT DISTINCT T0."name" name, T0."age" age, T0."score" score FROM "test_tab" T0 WHERE T0."name" = $1 OR ( T0."age" > $2 AND T0."score" < $3 ) GROUP BY T0."name", T0."age" ORDER BY T0."score" DESC, T0."age" ASC LIMIT 10 OFFSET 100`,
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
tables := newDbTables(mi, tc.db.ins)
|
|
|
|
res, args := tc.db.readValuesSQL(tables, tc.cols, tc.qs, mi, cond, tz)
|
|
|
|
assert.Equal(t, tc.wantRes, res)
|
|
assert.Equal(t, tc.wantArgs, args)
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestDbBase_countSQL(t *testing.T) {
|
|
|
|
mc := models.NewModelCacheHandler()
|
|
|
|
err := mc.Register("", false, new(testTab), new(testTab1), new(testTab2))
|
|
|
|
assert.Nil(t, err)
|
|
|
|
mc.Bootstrap()
|
|
|
|
mi, ok := mc.GetByMd(new(testTab))
|
|
|
|
assert.True(t, ok)
|
|
|
|
cond := NewCondition().And("name", "test_name").
|
|
OrCond(NewCondition().And("age__gt", 18).And("score__lt", 60))
|
|
|
|
tz := time.Local
|
|
|
|
testCases := []struct {
|
|
name string
|
|
db *dbBase
|
|
|
|
qs querySet
|
|
|
|
wantRes string
|
|
wantArgs []interface{}
|
|
}{
|
|
{
|
|
name: "count with MySQL has no group by",
|
|
db: &dbBase{
|
|
ins: newdbBaseMysql(),
|
|
},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
useIndex: 1,
|
|
indexes: []string{"name", "score"},
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
},
|
|
wantRes: "SELECT COUNT(*) FROM `test_tab` T0 USE INDEX(`name`,`score`) INNER JOIN `test_tab1` T1 ON T1.`id` = T0.`test_tab_1_id` INNER JOIN `test_tab2` T2 ON T2.`id` = T1.`test_tab_2_id` WHERE T0.`name` = ? OR ( T0.`age` > ? AND T0.`score` < ? ) ",
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "count with MySQL has group by",
|
|
db: &dbBase{
|
|
ins: newdbBaseMysql(),
|
|
},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
useIndex: 1,
|
|
indexes: []string{"name", "score"},
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
groups: []string{"name", "age"},
|
|
},
|
|
wantRes: "SELECT COUNT(*) FROM (SELECT COUNT(*) FROM `test_tab` T0 USE INDEX(`name`,`score`) INNER JOIN `test_tab1` T1 ON T1.`id` = T0.`test_tab_1_id` INNER JOIN `test_tab2` T2 ON T2.`id` = T1.`test_tab_2_id` WHERE T0.`name` = ? OR ( T0.`age` > ? AND T0.`score` < ? ) GROUP BY T0.`name`, T0.`age` ) AS T",
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "count with PostgreSQL has no group by",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
},
|
|
wantRes: `SELECT COUNT(*) FROM "test_tab" T0 INNER JOIN "test_tab1" T1 ON T1."id" = T0."test_tab_1_id" INNER JOIN "test_tab2" T2 ON T2."id" = T1."test_tab_2_id" WHERE T0."name" = $1 OR ( T0."age" > $2 AND T0."score" < $3 ) `,
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
{
|
|
name: "count with PostgreSQL has group by",
|
|
db: &dbBase{
|
|
ins: newdbBasePostgres(),
|
|
},
|
|
qs: querySet{
|
|
mi: mi,
|
|
cond: cond,
|
|
related: make([]string, 0),
|
|
relDepth: 2,
|
|
groups: []string{"name", "age"},
|
|
},
|
|
wantRes: `SELECT COUNT(*) FROM (SELECT COUNT(*) FROM "test_tab" T0 INNER JOIN "test_tab1" T1 ON T1."id" = T0."test_tab_1_id" INNER JOIN "test_tab2" T2 ON T2."id" = T1."test_tab_2_id" WHERE T0."name" = $1 OR ( T0."age" > $2 AND T0."score" < $3 ) GROUP BY T0."name", T0."age" ) AS T`,
|
|
wantArgs: []interface{}{"test_name", int64(18), int64(60)},
|
|
},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
res, args := tc.db.countSQL(tc.qs, mi, cond, tz)
|
|
|
|
assert.Equal(t, tc.wantRes, res)
|
|
assert.Equal(t, tc.wantArgs, args)
|
|
})
|
|
}
|
|
}
|
|
|
|
type testTab struct {
|
|
ID int64 `orm:"auto;pk;column(id)"`
|
|
Name string `orm:"column(name)"`
|
|
Age int64 `orm:"column(age)"`
|
|
Score int64 `orm:"column(score)"`
|
|
TestTab1 *testTab1 `orm:"rel(fk);column(test_tab_1_id)"`
|
|
}
|
|
|
|
type testTab1 struct {
|
|
ID int64 `orm:"auto;pk;column(id)"`
|
|
Name1 string `orm:"column(name_1)"`
|
|
Age1 int64 `orm:"column(age_1)"`
|
|
Score1 int64 `orm:"column(score_1)"`
|
|
TestTab2 *testTab2 `orm:"rel(fk);column(test_tab_2_id)"`
|
|
}
|
|
|
|
type testTab2 struct {
|
|
ID int64 `orm:"auto;pk;column(id)"`
|
|
Name2 int64 `orm:"column(name_2)"`
|
|
Age2 int64 `orm:"column(age_2)"`
|
|
Score2 int64 `orm:"column(score_2)"`
|
|
}
|