mirror of
https://github.com/neilotoole/sq.git
synced 2024-12-22 07:31:39 +03:00
962 lines
27 KiB
Go
962 lines
27 KiB
Go
package driver_test
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"slices"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"golang.org/x/sync/errgroup"
|
|
|
|
"github.com/neilotoole/sq/libsq/core/errz"
|
|
"github.com/neilotoole/sq/libsq/core/kind"
|
|
"github.com/neilotoole/sq/libsq/core/options"
|
|
"github.com/neilotoole/sq/libsq/core/schema"
|
|
"github.com/neilotoole/sq/libsq/core/stringz"
|
|
"github.com/neilotoole/sq/libsq/core/tablefq"
|
|
"github.com/neilotoole/sq/libsq/driver"
|
|
"github.com/neilotoole/sq/libsq/source/drivertype"
|
|
"github.com/neilotoole/sq/testh"
|
|
"github.com/neilotoole/sq/testh/fixt"
|
|
"github.com/neilotoole/sq/testh/sakila"
|
|
"github.com/neilotoole/sq/testh/tu"
|
|
)
|
|
|
|
func TestDriver_DropTable(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, handle := range sakila.SQLAll() {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
th, src, drvr, _, db := testh.NewWith(t, handle)
|
|
|
|
tblName := stringz.UniqTableName(sakila.TblActor)
|
|
|
|
// Copy a table that we can play with
|
|
tblName = th.CopyTable(false, src, tablefq.From(sakila.TblActor), tablefq.From(tblName), false)
|
|
require.NoError(t, drvr.DropTable(th.Context, db, tablefq.From(tblName), true))
|
|
|
|
// Copy the table again so we can drop it again
|
|
tblName = th.CopyTable(false, src, tablefq.From(sakila.TblActor), tablefq.From(tblName), false)
|
|
|
|
// test with ifExists = false
|
|
require.NoError(t, drvr.DropTable(th.Context, db, tablefq.From(tblName), false))
|
|
|
|
// Check that we get the expected behavior when the table doesn't exist
|
|
notTable := tablefq.New(stringz.UniqSuffix("not_a_table"))
|
|
require.NoError(t, drvr.DropTable(th.Context, db, notTable, true),
|
|
"should be no error when ifExists is true")
|
|
require.Error(t, drvr.DropTable(th.Context, db, notTable, false),
|
|
"error expected when ifExists is false")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDriver_TableExists(t *testing.T) {
|
|
for _, handle := range sakila.SQLAll() {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
th, _, drvr, _, db := testh.NewWith(t, handle)
|
|
|
|
tblName := sakila.TblActor
|
|
exists, err := drvr.TableExists(th.Context, db, tblName)
|
|
require.NoError(t, err)
|
|
require.True(t, exists)
|
|
|
|
tblName = stringz.UniqTableName("no_exist")
|
|
exists, err = drvr.TableExists(th.Context, db, tblName)
|
|
require.NoError(t, err)
|
|
require.False(t, exists)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDriver_CopyTable(t *testing.T) {
|
|
t.Parallel()
|
|
for _, handle := range sakila.SQLAll() {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
th, src, drvr, _, db := testh.NewWith(t, handle)
|
|
require.Equal(t, int64(sakila.TblActorCount), th.RowCount(src, sakila.TblActor),
|
|
"fromTable should have ActorCount rows beforehand")
|
|
|
|
toTable := stringz.UniqTableName(sakila.TblActor)
|
|
// First, test with copyData = true
|
|
copied, err := drvr.CopyTable(th.Context, db, tablefq.From(sakila.TblActor), tablefq.From(toTable), true)
|
|
require.NoError(t, err)
|
|
require.Equal(t, int64(sakila.TblActorCount), copied)
|
|
require.Equal(t, int64(sakila.TblActorCount), th.RowCount(src, toTable))
|
|
defer th.DropTable(src, tablefq.From(toTable))
|
|
|
|
toTable = stringz.UniqTableName(sakila.TblActor)
|
|
// Then, with copyData = false
|
|
copied, err = drvr.CopyTable(th.Context, db, tablefq.From(sakila.TblActor), tablefq.From(toTable), false)
|
|
require.NoError(t, err)
|
|
require.Equal(t, int64(0), copied)
|
|
require.Equal(t, int64(0), th.RowCount(src, toTable))
|
|
defer th.DropTable(src, tablefq.From(toTable))
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestDriver_CreateTable_Minimal tests the minimal functionality
|
|
// of SQLDriver.CreateTable impls.
|
|
func TestDriver_CreateTable_Minimal(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
testCases := sakila.SQLAll()
|
|
for _, handle := range testCases {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
th, src, drvr, _, db := testh.NewWith(t, handle)
|
|
|
|
tblName := stringz.UniqTableName(t.Name())
|
|
colNames, colKinds := fixt.ColNamePerKind(drvr.Dialect().IntBool, false, false)
|
|
tblDef := schema.NewTable(tblName, colNames, colKinds)
|
|
|
|
err := drvr.CreateTable(th.Context, db, tblDef)
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() { th.DropTable(src, tablefq.From(tblName)) })
|
|
|
|
colTypes, err := drvr.TableColumnTypes(th.Context, db, tblName, colNames)
|
|
require.NoError(t, err)
|
|
require.Equal(t, len(colNames), len(colTypes))
|
|
|
|
recMeta, _, err := drvr.RecordMeta(th.Context, colTypes)
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, colNames, recMeta.Names())
|
|
require.Equal(t, colKinds, recMeta.Kinds())
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDriver_TableColumnTypes(t *testing.T) { //nolint:tparallel
|
|
testCases := sakila.SQLAll()
|
|
for _, handle := range testCases {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
tu.SkipShort(t, handle == sakila.XLSX)
|
|
t.Parallel()
|
|
|
|
th, src, drvr, _, db := testh.NewWith(t, handle)
|
|
|
|
// Run the test both with and without data in the target table.
|
|
// Some driver implementations of rows.ColumnTypes behave
|
|
// differently depending upon whether the query returns rows
|
|
// or not.
|
|
for _, copyData := range []bool{false, true} {
|
|
tblName := th.CopyTable(true, src, tablefq.From(sakila.TblActor), tablefq.T{}, copyData)
|
|
|
|
// Note nil colNames, should still get all columns
|
|
// as if the query was (SELECT * FROM actualTblName)
|
|
colTypes, err := drvr.TableColumnTypes(th.Context, db, tblName, nil)
|
|
require.NoError(t, err)
|
|
require.Equal(t, len(sakila.TblActorCols()), len(colTypes))
|
|
for i := range colTypes {
|
|
require.Equal(t, sakila.TblActorCols()[i], colTypes[i].Name())
|
|
}
|
|
|
|
// Try again, but requesting specific col names
|
|
wantColNames := []string{sakila.TblActorCols()[0], sakila.TblActorCols()[2]}
|
|
colTypes, err = drvr.TableColumnTypes(th.Context, db, tblName, wantColNames)
|
|
require.NoError(t, err)
|
|
require.Equal(t, len(wantColNames), len(colTypes))
|
|
for i := range colTypes {
|
|
require.Equal(t, wantColNames[i], colTypes[i].Name())
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSQLDriver_PrepareUpdateStmt(t *testing.T) { //nolint:tparallel
|
|
testCases := sakila.SQLAll()
|
|
for _, handle := range testCases {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
tu.SkipShort(t, handle == sakila.XLSX)
|
|
t.Parallel()
|
|
|
|
th, src, drvr, _, db := testh.NewWith(t, handle)
|
|
|
|
tblName := th.CopyTable(true, src, tablefq.From(sakila.TblActor), tablefq.T{}, true)
|
|
|
|
const (
|
|
actorID int64 = 1
|
|
whereClause string = "actor_id = ?"
|
|
)
|
|
var (
|
|
destCols = []string{"first_name", "last_name"}
|
|
wantVals = []any{"Kubla", "Khan"}
|
|
args = append(wantVals, actorID)
|
|
)
|
|
|
|
stmtExecer, err := drvr.PrepareUpdateStmt(th.Context, db, tblName, destCols, whereClause)
|
|
require.NoError(t, err)
|
|
require.Equal(t, destCols, stmtExecer.DestMeta().Names())
|
|
require.NoError(t, stmtExecer.Munge(wantVals))
|
|
|
|
affected, err := stmtExecer.Exec(th.Context, args...)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, int64(1), affected)
|
|
|
|
sink, err := th.QuerySQL(src, nil, "SELECT * FROM "+tblName+" WHERE actor_id = 1")
|
|
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(sink.Recs))
|
|
require.Equal(t, actorID, stringz.Val(sink.Recs[0][0]))
|
|
require.Equal(t, wantVals[0], stringz.Val(sink.Recs[0][1]))
|
|
require.Equal(t, wantVals[1], stringz.Val(sink.Recs[0][2]))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDriver_Ping(t *testing.T) {
|
|
testCases := sakila.AllHandles()
|
|
testCases = append(testCases, sakila.CSVActor, sakila.CSVActorHTTP)
|
|
|
|
for _, handle := range testCases {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
tu.SkipShort(t, handle == sakila.XLSX)
|
|
|
|
th := testh.New(t)
|
|
src := th.Source(handle)
|
|
drvr := th.DriverFor(src)
|
|
err := drvr.Ping(th.Context, src)
|
|
require.NoError(t, err)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDriver_Open(t *testing.T) {
|
|
t.Parallel()
|
|
testCases := sakila.AllHandles()
|
|
testCases = append(testCases, sakila.CSVActor, sakila.CSVActorHTTP)
|
|
|
|
for _, handle := range testCases {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
tu.SkipShort(t, handle == sakila.XLSX)
|
|
t.Parallel()
|
|
|
|
th := testh.New(t)
|
|
src := th.Source(handle)
|
|
drvr := th.DriverFor(src)
|
|
grip, err := drvr.Open(th.Context, src)
|
|
require.NoError(t, err)
|
|
db, err := grip.DB(th.Context)
|
|
require.NoError(t, err)
|
|
require.NoError(t, db.PingContext(th.Context))
|
|
require.NoError(t, grip.Close())
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestNewBatchInsert(t *testing.T) {
|
|
// This value is chosen as it's not a neat divisor of 200 (sakila.TblActorSize).
|
|
const batchSize = 70
|
|
|
|
for _, handle := range sakila.SQLAll() {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
th, src, drvr, _, db := testh.NewWith(t, handle)
|
|
tblName := th.CopyTable(true, src, tablefq.From(sakila.TblActor), tablefq.T{}, false)
|
|
conn, err := db.Conn(th.Context)
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() {
|
|
_ = conn.Close()
|
|
})
|
|
|
|
// Get records from TblActor that we'll write to the new tbl
|
|
recMeta, recs := testh.RecordsFromTbl(t, handle, sakila.TblActor)
|
|
bi, err := driver.NewBatchInsert(
|
|
th.Context,
|
|
"Insert records",
|
|
drvr,
|
|
conn,
|
|
tblName,
|
|
recMeta.Names(),
|
|
batchSize,
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
for _, rec := range recs {
|
|
err = bi.Munge(rec)
|
|
require.NoError(t, err)
|
|
|
|
select {
|
|
case <-th.Context.Done():
|
|
close(bi.RecordCh)
|
|
// Should never happen
|
|
t.Fatal(th.Context.Err())
|
|
case err = <-bi.ErrCh:
|
|
close(bi.RecordCh)
|
|
// Should not happen
|
|
t.Fatal(err)
|
|
case bi.RecordCh <- rec:
|
|
}
|
|
}
|
|
close(bi.RecordCh) // Indicates end of records
|
|
|
|
err = <-bi.ErrCh
|
|
require.Nil(t, err)
|
|
|
|
require.NoError(t, conn.Close())
|
|
|
|
sink, err := th.QuerySQL(src, nil, "SELECT * FROM "+tblName)
|
|
require.NoError(t, err)
|
|
require.Equal(t, sakila.TblActorCount, len(sink.Recs))
|
|
th.TruncateTable(src, tblName) // cleanup
|
|
})
|
|
}
|
|
}
|
|
|
|
// coreDrivers is a slice of the core driver types.
|
|
var coreDrivers = []drivertype.Type{
|
|
drivertype.Pg,
|
|
drivertype.MSSQL,
|
|
drivertype.SQLite,
|
|
drivertype.MySQL,
|
|
drivertype.CSV,
|
|
drivertype.TSV,
|
|
drivertype.XLSX,
|
|
}
|
|
|
|
// sqlDrivers is a slice of the SQL driver types.
|
|
var sqlDrivers = []drivertype.Type{
|
|
drivertype.Pg,
|
|
drivertype.MSSQL,
|
|
drivertype.SQLite,
|
|
drivertype.MySQL,
|
|
}
|
|
|
|
// docDrivers is a slice of the doc driver types.
|
|
var docDrivers = []drivertype.Type{
|
|
drivertype.CSV,
|
|
drivertype.TSV,
|
|
drivertype.XLSX,
|
|
}
|
|
|
|
func TestRegistry_DriversMetadata_All(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
reg := testh.New(t).Registry()
|
|
metas := reg.DriversMetadata()
|
|
require.Equal(t, len(metas), len(reg.Drivers()))
|
|
|
|
m := map[drivertype.Type]driver.Metadata{}
|
|
for i := range metas {
|
|
m[metas[i].Type] = metas[i]
|
|
}
|
|
|
|
for _, typ := range coreDrivers {
|
|
md, ok := m[typ]
|
|
require.True(t, ok)
|
|
require.Equal(t, typ, md.Type)
|
|
}
|
|
}
|
|
|
|
func TestRegistry_DriversMetadata_SQL(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, typ := range sqlDrivers {
|
|
typ := typ
|
|
|
|
t.Run(typ.String(), func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
th := testh.New(t)
|
|
reg := th.Registry()
|
|
|
|
drvr, err := reg.DriverFor(typ)
|
|
require.NoError(t, err)
|
|
|
|
meta := drvr.DriverMetadata()
|
|
require.Equal(t, typ, meta.Type)
|
|
require.True(t, meta.IsSQL)
|
|
require.False(t, meta.Monotable, "can't be monotable and SQL")
|
|
|
|
sqlDrvr, ok := drvr.(driver.SQLDriver)
|
|
require.True(t, ok)
|
|
|
|
dialect := sqlDrvr.Dialect()
|
|
require.Equal(t, typ, dialect.Type)
|
|
require.NotNil(t, dialect.Placeholders)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRegistry_DriversMetadata_Doc(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, typ := range docDrivers {
|
|
typ := typ
|
|
|
|
t.Run(typ.String(), func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
th := testh.New(t)
|
|
reg := th.Registry()
|
|
|
|
drvr, err := reg.DriverFor(typ)
|
|
require.NoError(t, err)
|
|
|
|
_, ok := drvr.(driver.SQLDriver)
|
|
require.False(t, ok)
|
|
|
|
meta := drvr.DriverMetadata()
|
|
require.Equal(t, typ, meta.Type)
|
|
require.False(t, meta.IsSQL)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGrip_TableMetadata(t *testing.T) { //nolint:tparallel
|
|
for _, handle := range sakila.SQLAll() {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
th, _, _, grip, _ := testh.NewWith(t, handle)
|
|
|
|
tblMeta, err := grip.TableMetadata(th.Context, sakila.TblActor)
|
|
require.NoError(t, err)
|
|
require.Equal(t, sakila.TblActor, tblMeta.Name)
|
|
require.Equal(t, int64(sakila.TblActorCount), tblMeta.RowCount)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGrip_SourceMetadata(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
for _, handle := range sakila.SQLAll() {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
th, _, _, grip, _ := testh.NewWith(t, handle)
|
|
|
|
md, err := grip.SourceMetadata(th.Context, false)
|
|
require.NoError(t, err)
|
|
require.Equal(t, sakila.TblActor, md.Tables[0].Name)
|
|
require.Equal(t, int64(sakila.TblActorCount), md.Tables[0].RowCount)
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestSQLDriver_ListTableNames_ArgSchemaEmpty tests [driver.SQLDriver.ListTableNames]
|
|
// with an empty schema arg.
|
|
func TestSQLDriver_ListTableNames_ArgSchemaEmpty(t *testing.T) { //nolint:tparallel
|
|
for _, handle := range sakila.SQLLatest() {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
th, _, drvr, _, db := testh.NewWith(t, handle)
|
|
|
|
got, err := drvr.ListTableNames(th.Context, db, "", false, false)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, got)
|
|
require.True(t, len(got) == 0)
|
|
|
|
got, err = drvr.ListTableNames(th.Context, db, "", true, false)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, got)
|
|
require.Contains(t, got, sakila.TblActor)
|
|
require.NotContains(t, got, sakila.ViewFilmList)
|
|
|
|
got, err = drvr.ListTableNames(th.Context, db, "", false, true)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, got)
|
|
require.NotContains(t, got, sakila.TblActor)
|
|
require.Contains(t, got, sakila.ViewFilmList)
|
|
|
|
got, err = drvr.ListTableNames(th.Context, db, "", true, true)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, got)
|
|
require.Contains(t, got, sakila.TblActor)
|
|
require.Contains(t, got, sakila.ViewFilmList)
|
|
|
|
gotCopy := append([]string(nil), got...)
|
|
slices.Sort(gotCopy)
|
|
require.Equal(t, got, gotCopy, "expected results to be sorted")
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestSQLDriver_ListTableNames_ArgSchemaNotEmpty tests
|
|
// [driver.SQLDriver.ListTableNames] with a non-empty schema arg.
|
|
func TestSQLDriver_ListTableNames_ArgSchemaNotEmpty(t *testing.T) { //nolint:tparallel
|
|
testCases := []struct {
|
|
handle string
|
|
schema string
|
|
wantTables int
|
|
wantViews int
|
|
}{
|
|
{handle: sakila.Pg12, schema: "public", wantTables: 25, wantViews: 5},
|
|
{handle: sakila.MS19, schema: "dbo", wantTables: 17, wantViews: 5},
|
|
{handle: sakila.SL3, schema: "main", wantTables: 16, wantViews: 5},
|
|
{handle: sakila.My8, schema: "sakila", wantTables: 16, wantViews: 7},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
t.Run(tc.handle, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
th, _, drvr, _, db := testh.NewWith(t, tc.handle)
|
|
|
|
got, err := drvr.ListTableNames(th.Context, db, tc.schema, false, false)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, got)
|
|
require.True(t, len(got) == 0)
|
|
|
|
got, err = drvr.ListTableNames(th.Context, db, tc.schema, true, false)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, got)
|
|
require.Len(t, got, tc.wantTables)
|
|
|
|
got, err = drvr.ListTableNames(th.Context, db, tc.schema, false, true)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, got)
|
|
require.Len(t, got, tc.wantViews)
|
|
|
|
got, err = drvr.ListTableNames(th.Context, db, tc.schema, true, true)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, got)
|
|
require.Len(t, got, tc.wantTables+tc.wantViews)
|
|
|
|
gotCopy := append([]string(nil), got...)
|
|
slices.Sort(gotCopy)
|
|
require.Equal(t, got, gotCopy, "expected results to be sorted")
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestGrip_SourceMetadata_concurrent tests the behavior of the
|
|
// drivers when SourceMetadata is invoked concurrently.
|
|
func TestGrip_SourceMetadata_concurrent(t *testing.T) { //nolint:tparallel
|
|
const concurrency = 5
|
|
|
|
handles := sakila.SQLLatest()
|
|
for _, handle := range handles {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
th, _, _, grip, _ := testh.NewWith(t, handle)
|
|
g, gCtx := errgroup.WithContext(th.Context)
|
|
for i := 0; i < concurrency; i++ {
|
|
g.Go(func() error {
|
|
md, err := grip.SourceMetadata(gCtx, false)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, md)
|
|
gotTbl := md.Table(sakila.TblActor)
|
|
require.NotNil(t, gotTbl)
|
|
require.Equal(t, int64(sakila.TblActorCount), gotTbl.RowCount)
|
|
return nil
|
|
})
|
|
}
|
|
|
|
require.NoError(t, g.Wait())
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSQLDriver_AlterTableAddColumn(t *testing.T) {
|
|
testCases := sakila.SQLLatest()
|
|
|
|
for _, handle := range testCases {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
th, src, drvr, _, db := testh.NewWith(t, handle)
|
|
|
|
// Make a copy of the table to play with
|
|
tbl := th.CopyTable(true, src, tablefq.From(sakila.TblActor), tablefq.T{}, true)
|
|
|
|
const wantCol, wantKind = "col_int", kind.Int
|
|
wantCols := append(sakila.TblActorCols(), wantCol)
|
|
wantKinds := append(sakila.TblActorColKinds(), wantKind)
|
|
|
|
err := drvr.AlterTableAddColumn(th.Context, db, tbl, wantCol, wantKind)
|
|
require.NoError(t, err)
|
|
|
|
sink, err := th.QuerySQL(src, nil, "SELECT * FROM "+tbl)
|
|
require.NoError(t, err)
|
|
|
|
gotCols := sink.RecMeta.Names()
|
|
require.Equal(t, wantCols, gotCols)
|
|
|
|
gotKinds := sink.RecMeta.Kinds()
|
|
require.Equal(t, wantKinds, gotKinds)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSQLDriver_AlterTableRename(t *testing.T) {
|
|
testCases := sakila.SQLLatest()
|
|
|
|
for _, handle := range testCases {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
th, src, drvr, grip, db := testh.NewWith(t, handle)
|
|
|
|
// Make a copy of the table to play with
|
|
tbl := th.CopyTable(true, src, tablefq.From(sakila.TblActor), tablefq.T{}, true)
|
|
defer th.DropTable(src, tablefq.From(tbl))
|
|
|
|
newName := stringz.UniqSuffix("actor_copy_")
|
|
err := drvr.AlterTableRename(th.Context, db, tbl, newName)
|
|
require.NoError(t, err)
|
|
defer th.DropTable(src, tablefq.From(newName))
|
|
|
|
md, err := grip.TableMetadata(th.Context, newName)
|
|
require.NoError(t, err)
|
|
require.Equal(t, newName, md.Name)
|
|
sink, err := th.QuerySQL(src, nil, "SELECT * FROM "+newName)
|
|
require.NoError(t, err)
|
|
require.Equal(t, sakila.TblActorCount, len(sink.Recs))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSQLDriver_AlterTableRenameColumn(t *testing.T) {
|
|
testCases := sakila.SQLLatest()
|
|
|
|
for _, handle := range testCases {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
th, src, drvr, grip, db := testh.NewWith(t, handle)
|
|
|
|
// Make a copy of the table to play with
|
|
tbl := th.CopyTable(true, src, tablefq.From(sakila.TblActor), tablefq.T{}, true)
|
|
|
|
newName := "given_name"
|
|
err := drvr.AlterTableRenameColumn(th.Context, db, tbl, "first_name", newName)
|
|
require.NoError(t, err)
|
|
|
|
md, err := grip.TableMetadata(th.Context, tbl)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, md.Column(newName))
|
|
sink, err := th.QuerySQL(src, nil, fmt.Sprintf("SELECT %s FROM %s", newName, tbl))
|
|
require.NoError(t, err)
|
|
require.Equal(t, sakila.TblActorCount, len(sink.Recs))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSQLDriver_CurrentCatalog(t *testing.T) {
|
|
for _, handle := range sakila.SQLAll() {
|
|
handle := handle
|
|
|
|
t.Run(handle, func(t *testing.T) {
|
|
th, _, drvr, _, db := testh.NewWith(t, handle)
|
|
if !drvr.Dialect().Catalog {
|
|
t.Skipf("driver {%s} does not support catalogs", drvr.DriverMetadata().Type)
|
|
return
|
|
}
|
|
|
|
currentCatalog, err := drvr.CurrentCatalog(th.Context, db)
|
|
require.NoError(t, err)
|
|
require.NotEmpty(t, currentCatalog)
|
|
|
|
gotCatalogs, err := drvr.ListCatalogs(th.Context, db)
|
|
require.NoError(t, err)
|
|
require.Equal(t, currentCatalog, gotCatalogs[0])
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSQLDriver_CurrentSchemaCatalog(t *testing.T) {
|
|
testCases := []struct {
|
|
handle string
|
|
wantSchema string
|
|
wantCatalog string
|
|
}{
|
|
{sakila.SL3, "main", "default"},
|
|
{sakila.Pg, "public", "sakila"},
|
|
{sakila.My, "sakila", "def"},
|
|
{sakila.MS, "dbo", "sakila"},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
|
|
t.Run(tc.handle, func(t *testing.T) {
|
|
th, _, drvr, grip, db := testh.NewWith(t, tc.handle)
|
|
|
|
gotSchema, err := drvr.CurrentSchema(th.Context, db)
|
|
require.NoError(t, err)
|
|
require.Equal(t, tc.wantSchema, gotSchema)
|
|
|
|
md, err := grip.SourceMetadata(th.Context, false)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, md)
|
|
require.Equal(t, md.Schema, tc.wantSchema)
|
|
require.Equal(t, md.Catalog, tc.wantCatalog)
|
|
|
|
gotSchemas, err := drvr.ListSchemas(th.Context, db)
|
|
require.NoError(t, err)
|
|
require.Contains(t, gotSchemas, gotSchema)
|
|
|
|
if drvr.Dialect().Catalog {
|
|
gotCatalog, err := drvr.CurrentCatalog(th.Context, db)
|
|
require.NoError(t, err)
|
|
require.Equal(t, tc.wantCatalog, gotCatalog)
|
|
gotCatalogs, err := drvr.ListCatalogs(th.Context, db)
|
|
require.NoError(t, err)
|
|
require.Contains(t, gotCatalogs, gotCatalog)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSQLDriver_SchemaExists(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
testCases := []struct {
|
|
handle string
|
|
schema string
|
|
wantOK bool
|
|
}{
|
|
{handle: sakila.SL3, schema: "main", wantOK: true},
|
|
{handle: sakila.SL3, schema: "", wantOK: false},
|
|
{handle: sakila.SL3, schema: "not_exist", wantOK: false},
|
|
{handle: sakila.Pg, schema: "public", wantOK: true},
|
|
{handle: sakila.Pg, schema: "information_schema", wantOK: true},
|
|
{handle: sakila.Pg, schema: "not_exist", wantOK: false},
|
|
{handle: sakila.Pg, schema: "", wantOK: false},
|
|
{handle: sakila.My, schema: "sakila", wantOK: true},
|
|
{handle: sakila.My, schema: "", wantOK: false},
|
|
{handle: sakila.My, schema: "not_exist", wantOK: false},
|
|
{handle: sakila.MS, schema: "dbo", wantOK: true},
|
|
{handle: sakila.MS, schema: "sys", wantOK: true},
|
|
{handle: sakila.MS, schema: "INFORMATION_SCHEMA", wantOK: true},
|
|
{handle: sakila.MS, schema: "", wantOK: false},
|
|
{handle: sakila.MS, schema: "not_exist", wantOK: false},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
|
|
t.Run(tu.Name(tc.handle, tc.schema, tc.wantOK), func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
th, _, drvr, _, db := testh.NewWith(t, tc.handle)
|
|
ok, err := drvr.SchemaExists(th.Context, db, tc.schema)
|
|
require.NoError(t, err)
|
|
require.Equal(t, tc.wantOK, ok)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSQLDriver_CatalogExists(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
testCases := []struct {
|
|
handle string
|
|
catalog string
|
|
wantOK bool
|
|
wantErr bool
|
|
}{
|
|
{handle: sakila.SL3, catalog: "default", wantErr: true},
|
|
{handle: sakila.SL3, catalog: "not_exist", wantErr: true},
|
|
{handle: sakila.SL3, catalog: "", wantErr: true},
|
|
{handle: sakila.Pg, catalog: "sakila", wantOK: true},
|
|
{handle: sakila.Pg, catalog: "postgres", wantOK: true},
|
|
{handle: sakila.Pg, catalog: "not_exist", wantOK: false},
|
|
{handle: sakila.Pg, catalog: "", wantOK: false},
|
|
{handle: sakila.My, catalog: "def", wantOK: true},
|
|
{handle: sakila.My, catalog: "not_exist", wantOK: false},
|
|
{handle: sakila.My, catalog: "", wantOK: false},
|
|
{handle: sakila.MS, catalog: "sakila", wantOK: true},
|
|
{handle: sakila.MS, catalog: "model", wantOK: true},
|
|
{handle: sakila.MS, catalog: "not_exist", wantOK: false},
|
|
{handle: sakila.MS, catalog: "", wantOK: false},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
|
|
t.Run(tu.Name(tc.handle, tc.catalog, tc.wantOK), func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
th, _, drvr, _, db := testh.NewWith(t, tc.handle)
|
|
|
|
ok, err := drvr.CatalogExists(th.Context, db, tc.catalog)
|
|
require.Equal(t, tc.wantOK, ok)
|
|
if tc.wantErr {
|
|
require.Error(t, err)
|
|
} else {
|
|
require.NoError(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestDriverCreateDropSchema(t *testing.T) {
|
|
testCases := []struct {
|
|
handle string
|
|
defaultSchema string
|
|
}{
|
|
{sakila.SL3, "main"},
|
|
{sakila.Pg, "public"},
|
|
{sakila.My, "sakila"},
|
|
{sakila.MS, "dbo"},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
tc := tc
|
|
t.Run(tc.handle, func(t *testing.T) {
|
|
th, src, drvr, _, db := testh.NewWith(t, tc.handle)
|
|
ctx := th.Context
|
|
|
|
conn, err := db.Conn(th.Context)
|
|
require.NoError(t, err)
|
|
t.Cleanup(func() {
|
|
assert.NoError(t, conn.Close())
|
|
})
|
|
|
|
gotSchema1, err := drvr.CurrentSchema(ctx, conn)
|
|
require.NoError(t, err)
|
|
require.Equal(t, tc.defaultSchema, gotSchema1)
|
|
|
|
newSchema := "test_schema_" + stringz.Uniq8()
|
|
|
|
err = drvr.CreateSchema(ctx, conn, newSchema)
|
|
require.NoError(t, err)
|
|
|
|
t.Cleanup(func() {
|
|
err = drvr.DropSchema(ctx, conn, newSchema)
|
|
assert.NoError(t, err)
|
|
})
|
|
|
|
schemaNames, err := drvr.ListSchemas(ctx, conn)
|
|
require.NoError(t, err)
|
|
require.Contains(t, schemaNames, tc.defaultSchema)
|
|
require.Contains(t, schemaNames, newSchema)
|
|
|
|
destTblFQ := tablefq.T{Schema: newSchema, Table: stringz.UniqTableName("actor2")}
|
|
srcTblFQ := tablefq.From(sakila.TblActor)
|
|
copied, err := drvr.CopyTable(ctx, conn, srcTblFQ, destTblFQ, true)
|
|
require.NoError(t, err)
|
|
require.Equal(t, int64(sakila.TblActorCount), copied)
|
|
|
|
q := fmt.Sprintf("SELECT * FROM %s.%s", destTblFQ.Schema, destTblFQ.Table)
|
|
sink, err := th.QuerySQL(src, conn, q)
|
|
require.NoError(t, err)
|
|
require.Equal(t, int64(sakila.TblActorCount), int64(len(sink.Recs)))
|
|
|
|
// Do a second copy for good measure. We want to verify that CopyTable works
|
|
// even on the non-default schema (this could probably be its own test).
|
|
destTblFQ2 := tablefq.T{Schema: newSchema, Table: stringz.UniqSuffix("actor3_")}
|
|
copied, err = drvr.CopyTable(ctx, conn, destTblFQ, destTblFQ2, true)
|
|
require.NoError(t, err)
|
|
require.Equal(t, int64(sakila.TblActorCount), copied)
|
|
|
|
q = fmt.Sprintf("SELECT * FROM %s.%s", destTblFQ2.Schema, destTblFQ2.Table)
|
|
sink, err = th.QuerySQL(src, conn, q)
|
|
require.NoError(t, err)
|
|
require.Equal(t, int64(sakila.TblActorCount), int64(len(sink.Recs)))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestSQLDriver_ErrWrap_IsErrNotExist(t *testing.T) {
|
|
for _, h := range sakila.SQLLatest() {
|
|
h := h
|
|
t.Run(h, func(t *testing.T) {
|
|
th, _, _, _, _ := testh.NewWith(t, h)
|
|
_, err := th.QuerySLQ(h+".does_not_exist", nil)
|
|
require.Error(t, err)
|
|
require.True(t, errz.Has[*driver.NotExistError](err))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestMungeColNames(t *testing.T) {
|
|
testCases := []struct {
|
|
in []string
|
|
want []string
|
|
}{
|
|
{[]string{"a", "b", "c"}, []string{"a", "b", "c"}},
|
|
{[]string{"a", "b", "a", "d"}, []string{"a", "b", "a_1", "d"}},
|
|
{[]string{"a", "b", "a", "b", "d", "a"}, []string{"a", "b", "a_1", "b_1", "d", "a_2"}},
|
|
}
|
|
|
|
for i, tc := range testCases {
|
|
tc := tc
|
|
t.Run(tu.Name(i, tc.in), func(t *testing.T) {
|
|
ctx := options.NewContext(context.Background(), options.Options{})
|
|
got, err := driver.MungeResultColNames(ctx, tc.in)
|
|
require.NoError(t, err)
|
|
require.Equal(t, tc.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEmptyDataError(t *testing.T) {
|
|
var err error
|
|
require.False(t, errz.Has[driver.EmptyDataError](err))
|
|
require.False(t, errz.Has[driver.EmptyDataError](errz.New("huzzah")))
|
|
|
|
var ede1 driver.EmptyDataError
|
|
require.True(t, errz.Has[driver.EmptyDataError](ede1))
|
|
|
|
var ede2 driver.EmptyDataError
|
|
require.True(t, errors.As(ede1, &ede2))
|
|
|
|
err = driver.NewEmptyDataError("huzzah")
|
|
require.True(t, errz.Has[driver.EmptyDataError](err))
|
|
err = fmt.Errorf("wrap me: %w", err)
|
|
require.True(t, errz.Has[driver.EmptyDataError](err))
|
|
|
|
err = driver.NewEmptyDataError("%s doesn't exist", "me")
|
|
require.True(t, errz.Has[driver.EmptyDataError](err))
|
|
require.Equal(t, "me doesn't exist", err.Error())
|
|
}
|
|
|
|
func TestNotExistError(t *testing.T) {
|
|
var err error
|
|
require.False(t, errz.Has[*driver.NotExistError](err))
|
|
|
|
var nee1 *driver.NotExistError
|
|
require.True(t, errz.Has[*driver.NotExistError](nee1))
|
|
|
|
var nee2 *driver.NotExistError
|
|
require.True(t, errors.As(nee1, &nee2))
|
|
|
|
err = driver.NewNotExistError(errz.New("huzzah"))
|
|
require.True(t, errz.Has[*driver.NotExistError](err))
|
|
err = fmt.Errorf("wrap me: %w", err)
|
|
require.True(t, errz.Has[*driver.NotExistError](err))
|
|
}
|