enginetest

package
v0.14.7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 21, 2023 License: Apache-2.0 Imports: 35 Imported by: 0

Documentation

Overview

Example 
package main

import (
	"context"
	"fmt"
	"io"

	sqle "github.com/gabereiser/go-mysql-server"
	"github.com/gabereiser/go-mysql-server/memory"
	"github.com/gabereiser/go-mysql-server/sql"
	"github.com/gabereiser/go-mysql-server/sql/types"
)

func main() {
	// Create a test memory database and register it to the default engine.
	db := createTestDatabase()
	e := sqle.NewDefault(sql.NewDatabaseProvider(db))

	ctx := sql.NewContext(context.Background())
	ctx.SetCurrentDatabase("test")

	_, r, err := e.Query(ctx, `SELECT name, count(*) FROM mytable
	WHERE name = 'John Doe'
	GROUP BY name`)
	checkIfError(err)

	// Iterate results and print them.
	for {
		row, err := r.Next(ctx)
		if err == io.EOF {
			break
		}
		checkIfError(err)

		name := row[0]
		count := row[1]

		fmt.Println(name, count)
	}

}

func checkIfError(err error) {
	if err != nil {
		panic(err)
	}
}

func createTestDatabase() sql.Database {
	db := memory.NewDatabase("test")
	table := memory.NewTable("mytable", sql.NewPrimaryKeySchema(sql.Schema{
		{Name: "name", Type: types.Text, Source: "mytable"},
		{Name: "email", Type: types.Text, Source: "mytable"},
	}), db.GetForeignKeyCollection())
	db.AddTable("mytable", table)
	ctx := sql.NewEmptyContext()

	rows := []sql.Row{
		sql.NewRow("John Doe", "john@doe.com"),
		sql.NewRow("John Doe", "johnalt@doe.com"),
		sql.NewRow("Jane Doe", "jane@doe.com"),
		sql.NewRow("Evil Bob", "evilbob@gmail.com"),
	}

	for _, row := range rows {
		table.Insert(ctx, row)
	}

	return db
}

Output:

John Doe 2

Index

Examples

Constants

This section is empty.

Variables

View Source 
var JoinPlanningTests = []struct {
	name  string
	setup []string
	tests []JoinPlanTest
}{
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
}
View Source 
var SpatialIndexTests = []SpatialIndexPlanTest{
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
	{
		// contains filtered or unexported fields
	},
}

Functions

func AddColumn 

func AddColumn(t *testing.T, ctx *sql.Context, table sql.AlterableTable, column *sql.Column)

AddColumn adds a column to the specified table

func AssertErr 

func AssertErr(t *testing.T, e *sqle.Engine, harness Harness, query string, expectedErrKind *errors.Kind, errStrs ...string)

AssertErr asserts that the given query returns an error during its execution, optionally specifying a type of error.

func AssertErrPrepared 

func AssertErrPrepared(t *testing.T, e *sqle.Engine, harness Harness, query string, expectedErrKind *errors.Kind, errStrs ...string)

AssertErrPrepared asserts that the given query returns an error during its execution, optionally specifying a type of error.

func AssertErrPreparedWithCtx 

func AssertErrPreparedWithCtx(t *testing.T, e *sqle.Engine, harness Harness, ctx *sql.Context, query string, expectedErrKind *errors.Kind, errStrs ...string)

AssertErrPreparedWithCtx is the same as AssertErr, but uses the context given instead of creating one from a harness

func AssertErrWithBindings 

func AssertErrWithBindings(t *testing.T, e *sqle.Engine, harness Harness, query string, bindings map[string]sql.Expression, expectedErrKind *errors.Kind, errStrs ...string)

AssertErrWithBindings asserts that the given query returns an error during its execution, optionally specifying a type of error.

func AssertErrWithCtx 

func AssertErrWithCtx(t *testing.T, e *sqle.Engine, harness Harness, ctx *sql.Context, query string, expectedErrKind *errors.Kind, errStrs ...string)

AssertErrWithCtx is the same as AssertErr, but uses the context given instead of creating one from a harness

func AssertWarningAndTestQuery 

func AssertWarningAndTestQuery(
	t *testing.T,
	e *sqle.Engine,
	ctx *sql.Context,
	harness Harness,
	query string,
	expected []sql.Row,
	expectedCols []*sql.Column,
	expectedCode int,
	expectedWarningsCount int,
	expectedWarningMessageSubstring string,
	skipResultsCheck bool,
)

AssertWarningAndTestQuery tests the query and asserts an expected warning code. If |ctx| is provided, it will be used. Otherwise the harness will be used to create a fresh context.

func CreateVersionedTestData 

func CreateVersionedTestData(t *testing.T, harness VersionedDBHarness) []sql.Database

CreateVersionedTestData uses the provided harness to create test tables and data for many of the other tests.

func DeleteRows 

func DeleteRows(t *testing.T, ctx *sql.Context, table sql.DeletableTable, rows ...sql.Row)

func ExtractQueryNode 

func ExtractQueryNode(node sql.Node) sql.Node

func InsertRows 

func InsertRows(t *testing.T, ctx *sql.Context, table sql.InsertableTable, rows ...sql.Row)

func MustQuery 

func MustQuery(ctx *sql.Context, e *sqle.Engine, q string) (sql.Schema, []sql.Row)

func MustQueryWithBindings 

func MustQueryWithBindings(ctx *sql.Context, e *sqle.Engine, q string, bindings map[string]sql.Expression) (sql.Schema, []sql.Row)

func MustQueryWithPreBindings 

func MustQueryWithPreBindings(ctx *sql.Context, e *sqle.Engine, q string, bindings map[string]sql.Expression) (sql.Node, sql.Schema, []sql.Row)

func NewBaseSession 

func NewBaseSession() *sql.BaseSession

NewBaseSession returns a new BaseSession compatible with these tests. Most tests will work with any session implementation, but for full compatibility use a session based on this one.

func NewColumnDefaultValue 

func NewColumnDefaultValue(expr sql.Expression, outType sql.Type, representsLiteral, isParenthesized, mayReturnNil bool) *sql.ColumnDefaultValue

func NewContext 

func NewContext(harness Harness) *sql.Context

func NewContextWithClient 

func NewContextWithClient(harness ClientHarness, client sql.Client) *sql.Context

func NewContextWithEngine 

func NewContextWithEngine(harness Harness, engine *sqle.Engine) *sql.Context

TODO: remove

func NewEngine 

func NewEngine(t *testing.T, harness Harness, provider sql.DatabaseProvider, setupData []setup.SetupScript) (*sqle.Engine, error)

NewEngine creates an engine and sets it up for testing using harness, provider, and setup data given.

func NewEngineWithProvider 

func NewEngineWithProvider(_ *testing.T, harness Harness, provider sql.DatabaseProvider) *sqle.Engine

NewEngineWithProvider returns a new engine with the specified provider

func NewSession 

func NewSession(harness Harness) *sql.Context

func RunQuery 

func RunQuery(t *testing.T, e *sqle.Engine, harness Harness, query string)

RunQuery runs the query given and asserts that it doesn't result in an error.

func RunQueryTests 

func RunQueryTests(t *testing.T, harness Harness, queries []queries.QueryTest)

RunQueryTests runs the query tests given after setting up the engine. Useful for testing out a smaller subset of queries during debugging.

func RunQueryWithContext 

func RunQueryWithContext(t *testing.T, e *sqle.Engine, harness Harness, ctx *sql.Context, query string)

RunQueryWithContext runs the query given and asserts that it doesn't result in an error.

func RunSetupScripts 

func RunSetupScripts(ctx *sql.Context, e *sqle.Engine, scripts []setup.SetupScript, createIndexes bool) (*sqle.Engine, error)

RunSetupScripts runs the given setup scripts on the given engine, returning any error

func RunWriteQueryTest 

func RunWriteQueryTest(t *testing.T, harness Harness, tt queries.WriteQueryTest)

RunWriteQueryTest runs the specified |tt| WriteQueryTest using the specified harness.

func RunWriteQueryTestWithEngine 

func RunWriteQueryTestWithEngine(t *testing.T, harness Harness, e *sqle.Engine, tt queries.WriteQueryTest)

RunWriteQueryTestWithEngine runs the specified |tt| WriteQueryTest, using the specified harness and engine. Callers are still responsible for closing the engine.

func TestAddAutoIncrementColumn 

func TestAddAutoIncrementColumn(t *testing.T, harness Harness)

func TestAddColumn 

func TestAddColumn(t *testing.T, harness Harness)

todo(max): convert to WriteQueryTest

func TestAddDropPks 

func TestAddDropPks(t *testing.T, harness Harness)

func TestAlterTable 

func TestAlterTable(t *testing.T, harness Harness)

func TestAmbiguousColumnResolution 

func TestAmbiguousColumnResolution(t *testing.T, harness Harness)

func TestBlobs 

func TestBlobs(t *testing.T, h Harness)

func TestBrokenInsertScripts 

func TestBrokenInsertScripts(t *testing.T, harness Harness)

func TestBrokenJSONTableScripts 

func TestBrokenJSONTableScripts(t *testing.T, harness Harness)

func TestBrokenQueries 

func TestBrokenQueries(t *testing.T, harness Harness)

func TestCharsetCollationEngine 

func TestCharsetCollationEngine(t *testing.T, harness Harness)

func TestCharsetCollationWire 

func TestCharsetCollationWire(t *testing.T, h Harness, sessionBuilder server.SessionBuilder)

func TestChecksOnInsert 

func TestChecksOnInsert(t *testing.T, harness Harness)

todo(max): rewrite into []ScriptTest

func TestChecksOnUpdate 

func TestChecksOnUpdate(t *testing.T, harness Harness)

func TestClearWarnings 

func TestClearWarnings(t *testing.T, harness Harness)

func TestColumnAliases 

func TestColumnAliases(t *testing.T, harness Harness)

TestColumnAliases exercises the logic for naming and referring to column aliases, and unlike other tests in this file checks that the name of the columns in the result schema is correct.

func TestColumnDefaults 

func TestColumnDefaults(t *testing.T, harness Harness)

func TestComplexIndexQueries 

func TestComplexIndexQueries(t *testing.T, harness Harness)

func TestComplexIndexQueriesPrepared 

func TestComplexIndexQueriesPrepared(t *testing.T, harness Harness)

func TestConcurrentTransactions 

func TestConcurrentTransactions(t *testing.T, harness Harness)

TestConcurrentTransactions tests that two concurrent processes/transactions can successfully execute without early cancellation.

func TestCreateCheckConstraints 

func TestCreateCheckConstraints(t *testing.T, harness Harness)

todo(max): rewrite this using info schema and []QueryTest

func TestCreateCheckConstraintsScriptsPrepared 

func TestCreateCheckConstraintsScriptsPrepared(t *testing.T, harness Harness)

func TestCreateDatabase 

func TestCreateDatabase(t *testing.T, harness Harness)

func TestCreateForeignKeys 

func TestCreateForeignKeys(t *testing.T, harness Harness)

func TestCreateTable 

func TestCreateTable(t *testing.T, harness Harness)

func TestCurrentTimestamp 

func TestCurrentTimestamp(t *testing.T, harness Harness)

func TestDatabaseCollationWire 

func TestDatabaseCollationWire(t *testing.T, h Harness, sessionBuilder server.SessionBuilder)

func TestDateParse 

func TestDateParse(t *testing.T, harness Harness)

func TestDelete 

func TestDelete(t *testing.T, harness Harness)

func TestDeleteErrors 

func TestDeleteErrors(t *testing.T, harness Harness)

func TestDeleteQueriesPrepared 

func TestDeleteQueriesPrepared(t *testing.T, harness Harness)

func TestDerivedTableOuterScopeVisibility 

func TestDerivedTableOuterScopeVisibility(t *testing.T, harness Harness)

func TestDisallowedCheckConstraints 

func TestDisallowedCheckConstraints(t *testing.T, harness Harness)

func TestDropCheckConstraints 

func TestDropCheckConstraints(t *testing.T, harness Harness)

todo(max): rewrite with []ScriptTest

func TestDropColumn 

func TestDropColumn(t *testing.T, harness Harness)

todo(max): convert to WriteQueryTest

func TestDropColumnKeylessTables 

func TestDropColumnKeylessTables(t *testing.T, harness Harness)

func TestDropConstraints 

func TestDropConstraints(t *testing.T, harness Harness)

func TestDropDatabase 

func TestDropDatabase(t *testing.T, harness Harness)

func TestDropForeignKeys 

func TestDropForeignKeys(t *testing.T, harness Harness)

func TestDropTable 

func TestDropTable(t *testing.T, harness Harness)

func TestForeignKeys 

func TestForeignKeys(t *testing.T, harness Harness)

func TestIgnoreIntoWithDuplicateUniqueKeyKeyless 

func TestIgnoreIntoWithDuplicateUniqueKeyKeyless(t *testing.T, harness Harness)

func TestIgnoreIntoWithDuplicateUniqueKeyKeylessPrepared 

func TestIgnoreIntoWithDuplicateUniqueKeyKeylessPrepared(t *testing.T, harness Harness)

func TestIndexPrefix 

func TestIndexPrefix(t *testing.T, h Harness)

func TestIndexQueryPlans 

func TestIndexQueryPlans(t *testing.T, harness Harness)

func TestIndexes 

func TestIndexes(t *testing.T, h Harness)

func TestInfoSchema 

func TestInfoSchema(t *testing.T, h Harness)

TestInfoSchema runs tests of the information_schema database

func TestInfoSchemaPrepared 

func TestInfoSchemaPrepared(t *testing.T, harness Harness)

TestInfoSchemaPrepared runs tests of the information_schema database

func TestInnerNestedInNaturalJoins 

func TestInnerNestedInNaturalJoins(t *testing.T, harness Harness)

func TestInsertDuplicateKeyKeyless 

func TestInsertDuplicateKeyKeyless(t *testing.T, harness Harness)

func TestInsertDuplicateKeyKeylessPrepared 

func TestInsertDuplicateKeyKeylessPrepared(t *testing.T, harness Harness)

func TestInsertErrorScriptsPrepared 

func TestInsertErrorScriptsPrepared(t *testing.T, harness Harness)

func TestInsertIgnoreInto 

func TestInsertIgnoreInto(t *testing.T, harness Harness)

func TestInsertIgnoreScriptsPrepared 

func TestInsertIgnoreScriptsPrepared(t *testing.T, harness Harness)

func TestInsertInto 

func TestInsertInto(t *testing.T, harness Harness)

func TestInsertIntoErrors 

func TestInsertIntoErrors(t *testing.T, harness Harness)

func TestInsertQueriesPrepared 

func TestInsertQueriesPrepared(t *testing.T, harness Harness)

func TestInsertScriptsPrepared 

func TestInsertScriptsPrepared(t *testing.T, harness Harness)

func TestIntegrationPlans 

func TestIntegrationPlans(t *testing.T, harness Harness)

func TestJSONTableQueries 

func TestJSONTableQueries(t *testing.T, harness Harness)

func TestJSONTableScripts 

func TestJSONTableScripts(t *testing.T, harness Harness)

func TestJoinOps 

func TestJoinOps(t *testing.T, harness Harness)

func TestJoinOpsPrepared 

func TestJoinOpsPrepared(t *testing.T, harness Harness)

func TestJoinPlanning 

func TestJoinPlanning(t *testing.T, harness Harness)

func TestJoinPlanningPrepared 

func TestJoinPlanningPrepared(t *testing.T, harness Harness)

func TestJoinQueries 

func TestJoinQueries(t *testing.T, harness Harness)

TestJoinQueries tests join queries against a provided harness.

func TestJoinQueriesPrepared 

func TestJoinQueriesPrepared(t *testing.T, harness Harness)

TestJoinQueriesPrepared tests join queries as prepared statements against a provided harness.

func TestJsonScripts 

func TestJsonScripts(t *testing.T, harness Harness)

func TestJsonScriptsPrepared 

func TestJsonScriptsPrepared(t *testing.T, harness Harness)

func TestLoadData 

func TestLoadData(t *testing.T, harness Harness)

func TestLoadDataErrors 

func TestLoadDataErrors(t *testing.T, harness Harness)

func TestLoadDataFailing 

func TestLoadDataFailing(t *testing.T, harness Harness)

func TestLoadDataPrepared 

func TestLoadDataPrepared(t *testing.T, harness Harness)

func TestModifyColumn 

func TestModifyColumn(t *testing.T, harness Harness)

todo(max): convert to WriteQueryTest

func TestNamedWindows 

func TestNamedWindows(t *testing.T, harness Harness)

func TestNaturalJoin 

func TestNaturalJoin(t *testing.T, harness Harness)

func TestNaturalJoinDisjoint 

func TestNaturalJoinDisjoint(t *testing.T, harness Harness)

func TestNaturalJoinEqual 

func TestNaturalJoinEqual(t *testing.T, harness Harness)

func TestNoDatabaseSelected 

func TestNoDatabaseSelected(t *testing.T, harness Harness)

func TestNullRanges 

func TestNullRanges(t *testing.T, harness Harness)

func TestOrderByGroupBy 

func TestOrderByGroupBy(t *testing.T, harness Harness)

func TestPersist 

func TestPersist(t *testing.T, harness Harness, newPersistableSess func(ctx *sql.Context) sql.PersistableSession)

func TestPkOrdinalsDDL 

func TestPkOrdinalsDDL(t *testing.T, harness Harness)

func TestPkOrdinalsDML 

func TestPkOrdinalsDML(t *testing.T, harness Harness)

func TestPrepared 

func TestPrepared(t *testing.T, harness Harness)

func TestPreparedInsert 

func TestPreparedInsert(t *testing.T, harness Harness)

func TestPreparedQuery 

func TestPreparedQuery(t *testing.T, harness Harness, q string, expected []sql.Row, expectedCols []*sql.Column)

TestPreparedQuery runs a prepared query on the engine given and asserts that results are as expected.

func TestPreparedQueryWithContext 

func TestPreparedQueryWithContext(
	t *testing.T,
	ctx *sql.Context,
	e *sqle.Engine,
	h Harness,
	q string,
	expected []sql.Row,
	expectedCols []*sql.Column,
)

func TestPreparedQueryWithEngine 

func TestPreparedQueryWithEngine(t *testing.T, harness Harness, e *sqle.Engine, tt queries.QueryTest)

func TestPreparedStatements 

func TestPreparedStatements(t *testing.T, harness Harness)

func TestPreparedStaticIndexQuery 

func TestPreparedStaticIndexQuery(t *testing.T, harness Harness)

func TestPrivilegePersistence 

func TestPrivilegePersistence(t *testing.T, h Harness)

func TestQueries 

func TestQueries(t *testing.T, harness Harness)

TestQueries tests a variety of queries against databases and tables provided by the given harness.

func TestQueriesPrepared 

func TestQueriesPrepared(t *testing.T, harness Harness)

func TestQuery 

func TestQuery(t *testing.T, harness Harness, q string, expected []sql.Row, expectedCols []*sql.Column, bindings map[string]sql.Expression)

TestQuery runs a query on the engine given and asserts that results are as expected. TODO: this should take en engine

func TestQuery2 

func TestQuery2(t *testing.T, harness Harness, e *sqle.Engine, q string, expected []sql.Row, expectedCols []*sql.Column, bindings map[string]sql.Expression)

TestQuery runs a query on the engine given and asserts that results are as expected.

func TestQueryErrors 

func TestQueryErrors(t *testing.T, harness Harness)

func TestQueryPlan 

func TestQueryPlan(t *testing.T, harness Harness, e *sqle.Engine, query, expectedPlan string, verbose bool)

TestQueryPlan analyzes the query given and asserts that its printed plan matches the expected one.

func TestQueryPlanWithEngine 

func TestQueryPlanWithEngine(t *testing.T, harness Harness, e *sqle.Engine, tt queries.QueryPlanTest, verbose bool)

func TestQueryPlans 

func TestQueryPlans(t *testing.T, harness Harness, planTests []queries.QueryPlanTest)

TestQueryPlans tests generating the correct query plans for various queries using databases and tables provided by the given harness.

func TestQueryWithContext 

func TestQueryWithContext(t *testing.T, ctx *sql.Context, e *sqle.Engine, harness Harness, q string, expected []sql.Row, expectedCols []*sql.Column, bindings map[string]sql.Expression)

func TestQueryWithEngine 

func TestQueryWithEngine(t *testing.T, harness Harness, e *sqle.Engine, tt queries.QueryTest)

TODO: collapse into TestQuery

func TestReadOnly 

func TestReadOnly(t *testing.T, harness Harness)

func TestReadOnlyDatabases 

func TestReadOnlyDatabases(t *testing.T, harness ReadOnlyDatabaseHarness)

func TestReadOnlyVersionedQueries 

func TestReadOnlyVersionedQueries(t *testing.T, harness Harness)

func TestRecursiveViewDefinition 

func TestRecursiveViewDefinition(t *testing.T, harness Harness)

func TestRenameColumn 

func TestRenameColumn(t *testing.T, harness Harness)

func TestRenameTable 

func TestRenameTable(t *testing.T, harness Harness)

func TestReplaceInto 

func TestReplaceInto(t *testing.T, harness Harness)

func TestReplaceIntoErrors 

func TestReplaceIntoErrors(t *testing.T, harness Harness)

func TestReplaceQueriesPrepared 

func TestReplaceQueriesPrepared(t *testing.T, harness Harness)

func TestRollbackTriggers 

func TestRollbackTriggers(t *testing.T, harness Harness)

func TestScript 

func TestScript(t *testing.T, harness Harness, script queries.ScriptTest)

TestScript runs the test script given, making any assertions given

func TestScriptPrepared 

func TestScriptPrepared(t *testing.T, harness Harness, script queries.ScriptTest) bool

TestScriptPrepared substitutes literals for bindvars, runs the test script given, and makes any assertions given

func TestScriptWithEngine 

func TestScriptWithEngine(t *testing.T, e *sqle.Engine, harness Harness, script queries.ScriptTest)

TestScriptWithEngine runs the test script given with the engine provided.

func TestScriptWithEnginePrepared 

func TestScriptWithEnginePrepared(t *testing.T, e *sqle.Engine, harness Harness, script queries.ScriptTest)

TestScriptWithEnginePrepared runs the test script with bindvars substituted for literals using the engine provided.

func TestScripts 

func TestScripts(t *testing.T, harness Harness)

func TestScriptsPrepared 

func TestScriptsPrepared(t *testing.T, harness Harness)

func TestSessionSelectLimit 

func TestSessionSelectLimit(t *testing.T, harness Harness)

func TestShowTableStatus 

func TestShowTableStatus(t *testing.T, harness Harness)

Runs tests on SHOW TABLE STATUS queries.

func TestShowTableStatusPrepared 

func TestShowTableStatusPrepared(t *testing.T, harness Harness)

func TestShowTriggers 

func TestShowTriggers(t *testing.T, harness Harness)

func TestSpatialDelete 

func TestSpatialDelete(t *testing.T, harness Harness)

func TestSpatialIndexPlans 

func TestSpatialIndexPlans(t *testing.T, harness Harness)

func TestSpatialIndexPlansPrepared 

func TestSpatialIndexPlansPrepared(t *testing.T, harness Harness)

func TestSpatialIndexScripts 

func TestSpatialIndexScripts(t *testing.T, harness Harness)

func TestSpatialIndexScriptsPrepared 

func TestSpatialIndexScriptsPrepared(t *testing.T, harness Harness)

func TestSpatialInsertInto 

func TestSpatialInsertInto(t *testing.T, harness Harness)

func TestSpatialQueries 

func TestSpatialQueries(t *testing.T, harness Harness)

TestSpatialQueries tests a variety of geometry queries against databases and tables provided by the given harness.

func TestSpatialQueriesPrepared 

func TestSpatialQueriesPrepared(t *testing.T, harness Harness)

TestSpatialQueriesPrepared tests a variety of geometry queries against databases and tables provided by the given harness.

func TestSpatialScripts 

func TestSpatialScripts(t *testing.T, harness Harness)

func TestSpatialScriptsPrepared 

func TestSpatialScriptsPrepared(t *testing.T, harness Harness)

func TestSpatialUpdate 

func TestSpatialUpdate(t *testing.T, harness Harness)

func TestStatistics 

func TestStatistics(t *testing.T, harness Harness)

TestStatistics tests the statistics from ANALYZE TABLE

func TestStatisticsPrepared 

func TestStatisticsPrepared(t *testing.T, harness Harness)

TestStatisticsPrepared tests the statistics from ANALYZE TABLE

func TestStoredProcedures 

func TestStoredProcedures(t *testing.T, harness Harness)

func TestTracing 

func TestTracing(t *testing.T, harness Harness)

func TestTransactionScript 

func TestTransactionScript(t *testing.T, harness Harness, script queries.TransactionTest) bool

TestTransactionScript runs the test script given, making any assertions given

func TestTransactionScriptWithEngine 

func TestTransactionScriptWithEngine(t *testing.T, e *sqle.Engine, harness Harness, script queries.TransactionTest)

TestTransactionScriptWithEngine runs the transaction test script given with the engine provided.

func TestTransactionScripts 

func TestTransactionScripts(t *testing.T, harness Harness)

func TestTriggerErrors 

func TestTriggerErrors(t *testing.T, harness Harness)

func TestTriggers 

func TestTriggers(t *testing.T, harness Harness)

func TestTruncate 

func TestTruncate(t *testing.T, harness Harness)

func TestTypesOverWire 

func TestTypesOverWire(t *testing.T, harness ClientHarness, sessionBuilder server.SessionBuilder)

func TestUpdate 

func TestUpdate(t *testing.T, harness Harness)

func TestUpdateErrors 

func TestUpdateErrors(t *testing.T, harness Harness)

func TestUpdateIgnore 

func TestUpdateIgnore(t *testing.T, harness Harness)

func TestUpdateQueriesPrepared 

func TestUpdateQueriesPrepared(t *testing.T, harness Harness)

func TestUse 

func TestUse(t *testing.T, harness Harness)

func TestUserAuthentication 

func TestUserAuthentication(t *testing.T, h Harness)

func TestUserPrivileges 

func TestUserPrivileges(t *testing.T, harness ClientHarness)

func TestValidateSession 

func TestValidateSession(t *testing.T, harness Harness, newSessFunc func(ctx *sql.Context) sql.PersistableSession, count *int)

func TestVariableErrors 

func TestVariableErrors(t *testing.T, harness Harness)

func TestVariables 

func TestVariables(t *testing.T, harness Harness)

func TestVersionedQueries 

func TestVersionedQueries(t *testing.T, harness VersionedDBHarness)

TestVersionedQueries tests a variety of versioned queries

func TestVersionedQueriesPrepared 

func TestVersionedQueriesPrepared(t *testing.T, harness VersionedDBHarness)

Tests a variety of queries against databases and tables provided by the given harness.

func TestVersionedViews 

func TestVersionedViews(t *testing.T, harness VersionedDBHarness)

func TestVersionedViewsPrepared 

func TestVersionedViewsPrepared(t *testing.T, harness VersionedDBHarness)

func TestViews 

func TestViews(t *testing.T, harness Harness)

func TestViewsPrepared 

func TestViewsPrepared(t *testing.T, harness Harness)

func TestWarnings 

func TestWarnings(t *testing.T, harness Harness)

func TestWindowFunctions 

func TestWindowFunctions(t *testing.T, harness Harness)

func TestWindowRangeFrames 

func TestWindowRangeFrames(t *testing.T, harness Harness)

func TestWindowRowFrames 

func TestWindowRowFrames(t *testing.T, harness Harness)

func WidenRow 

func WidenRow(sch sql.Schema, row sql.Row) sql.Row

See WidenRows

func WidenRows 

func WidenRows(sch sql.Schema, rows []sql.Row) []sql.Row

For a variety of reasons, the widths of various primitive types can vary when passed through different SQL queries (and different database implementations). We may eventually decide that this undefined behavior is a problem, but for now it's mostly just an issue when comparing results in tests. To get around this, we widen every type to its widest value in actual and expected results.

Types

type ClientHarness 

type ClientHarness interface {
	Harness

	// NewContextWithClient returns a context that will return the given client when requested from the session.
	NewContextWithClient(client sql.Client) *sql.Context
}

ClientHarness allows for integrators to test user privileges, as mock clients are used to test functionality.

type ForeignKeyHarness 

type ForeignKeyHarness interface {
	Harness

	// SupportsForeignKeys returns whether this harness should accept CREATE FOREIGN KEY statements as part of test
	// setup.
	SupportsForeignKeys() bool
}

ForeignKeyHarness is an extension to Harness that lets an integrator test their implementation with foreign keys. Integrator tables must implement sql.ForeignKeyTable.

type Harness 

type Harness interface {
	// Parallelism returns how many parallel go routines to use when constructing an engine for test.
	Parallelism() int
	// NewContext allows a harness to specify any sessions or context variables necessary for the proper functioning of
	// their engine implementation. Every harnessed engine test uses the context created by this method, with some
	// additional information (e.g. current DB) set uniformly. To replicated the behavior of tests during setup,
	// harnesses should generally dispatch to enginetest.NewContext(harness), rather than calling this method themselves.
	NewContext() *sql.Context
	// Setup supplies a test suite's setup scripts, which must be stored and used to create a new Engine on demand via
	// calls to the NewEngine method.
	Setup(...[]setup.SetupScript)
	// NewEngine creates a new sqle.Engine. The state of the engine returned must match what was previous specified
	// by Setup, with no other data. See enginetest.NewEngine for help creating an engine suitable in tests.
	NewEngine(*testing.T) (*sqle.Engine, error)
}

Harness provides a way for database integrators to validate their implementation against the standard set of queries used to develop and test the engine itself. See memory_engine_test.go for an example. The typical harness lifecycle during test setup looks like this: 1) Harness is instantiated, which should create a sql.MutableDatabaseProvider to use for the rest of setup 2) Harness.NewDatabase or Harness.NewTable is called to create the database and tables that will be used for the test 3) For some tests, harness.Setup() is called instead of Harness.NewDatabase and Harness.NewTable 4) Harness.NewEngine() is called to create an engine with the setup data provided prior. It can be called multiple times during a single test run, and must return a "fresh" engine instance each time, i.e. an instance that contains exactly the test data provided via other setup methods.

type IndexDriverHarness 

type IndexDriverHarness interface {
	Harness

	// InitializeIndexDriver initializes the index driver for this test run with the databases given
	InitializeIndexDriver(dbs []sql.Database)
}

IndexDriverHarness is an extension to Harness that lets an integrator test their implementation alongside an index driver they provide.

type IndexDriverInitializer 

type IndexDriverInitializer func([]sql.Database) sql.IndexDriver

type IndexHarness 

type IndexHarness interface {
	Harness

	// SupportsNativeIndexCreation returns whether this harness should accept CREATE INDEX statements as part of test
	// setup.
	SupportsNativeIndexCreation() bool
}

IndexHarness is an extension to Harness that lets an integrator test their implementation with native (table-supplied) indexes. Integrator tables must implement sql.IndexAlterableTable.

type JoinOpTests 

type JoinOpTests struct {
	Query    string
	Expected []sql.Row
	Skip     bool
}

type JoinPlanTest 

type JoinPlanTest struct {
	// contains filtered or unexported fields
}

type KeylessTableHarness 

type KeylessTableHarness interface {
	Harness

	// SupportsKeylessTables indicates integrator support for keyless tables.
	SupportsKeylessTables() bool
}

KeylessTableHarness is an extension to Harness that lets an integrator test their implementation with keyless tables.

type MemoryHarness 

type MemoryHarness struct {
	// contains filtered or unexported fields
}

func NewDefaultMemoryHarness 

func NewDefaultMemoryHarness() *MemoryHarness

func NewMemoryHarness 

func NewMemoryHarness(name string, parallelism int, numTablePartitions int, useNativeIndexes bool, driverInitalizer IndexDriverInitializer) *MemoryHarness

func NewReadOnlyMemoryHarness 

func NewReadOnlyMemoryHarness() *MemoryHarness

func (*MemoryHarness) ExternalStoredProcedure 

func (m *MemoryHarness) ExternalStoredProcedure(_ *sql.Context, name string, numOfParams int) (*sql.ExternalStoredProcedureDetails, error)

ExternalStoredProcedure implements the sql.ExternalStoredProcedureProvider interface

func (*MemoryHarness) ExternalStoredProcedures 

func (m *MemoryHarness) ExternalStoredProcedures(_ *sql.Context, name string) ([]sql.ExternalStoredProcedureDetails, error)

ExternalStoredProcedures implements the sql.ExternalStoredProcedureProvider interface

func (*MemoryHarness) IndexDriver 

func (m *MemoryHarness) IndexDriver(dbs []sql.Database) sql.IndexDriver

func (*MemoryHarness) InitializeIndexDriver 

func (m *MemoryHarness) InitializeIndexDriver(dbs []sql.Database)

func (*MemoryHarness) NewContext 

func (m *MemoryHarness) NewContext() *sql.Context

func (*MemoryHarness) NewContextWithClient 

func (m *MemoryHarness) NewContextWithClient(client sql.Client) *sql.Context

func (*MemoryHarness) NewDatabaseProvider 

func (m *MemoryHarness) NewDatabaseProvider() sql.MutableDatabaseProvider

func (*MemoryHarness) NewDatabases 

func (m *MemoryHarness) NewDatabases(names ...string) []sql.Database

func (*MemoryHarness) NewEngine 

func (m *MemoryHarness) NewEngine(t *testing.T) (*sqle.Engine, error)

func (*MemoryHarness) NewReadOnlyEngine 

func (m *MemoryHarness) NewReadOnlyEngine(provider sql.DatabaseProvider) (*sqle.Engine, error)

func (*MemoryHarness) NewSession 

func (m *MemoryHarness) NewSession() *sql.Context

func (*MemoryHarness) NewTable 

func (m *MemoryHarness) NewTable(db sql.Database, name string, schema sql.PrimaryKeySchema) (sql.Table, error)

func (*MemoryHarness) NewTableAsOf 

func (m *MemoryHarness) NewTableAsOf(db sql.VersionedDatabase, name string, schema sql.PrimaryKeySchema, asOf interface{}) sql.Table

func (*MemoryHarness) Parallelism 

func (m *MemoryHarness) Parallelism() int

func (*MemoryHarness) QueriesToSkip 

func (m *MemoryHarness) QueriesToSkip(queries ...string)

func (*MemoryHarness) Setup 

func (m *MemoryHarness) Setup(setupData ...[]setup.SetupScript)

func (*MemoryHarness) SkipQueryTest 

func (m *MemoryHarness) SkipQueryTest(query string) bool

func (*MemoryHarness) SnapshotTable 

func (m *MemoryHarness) SnapshotTable(db sql.VersionedDatabase, name string, asOf interface{}) error

func (*MemoryHarness) SupportsForeignKeys 

func (m *MemoryHarness) SupportsForeignKeys() bool

func (*MemoryHarness) SupportsKeylessTables 

func (m *MemoryHarness) SupportsKeylessTables() bool

func (*MemoryHarness) SupportsNativeIndexCreation 

func (m *MemoryHarness) SupportsNativeIndexCreation() bool

func (*MemoryHarness) ValidateEngine 

func (m *MemoryHarness) ValidateEngine(ctx *sql.Context, e *sqle.Engine) error

type ReadOnlyDatabaseHarness 

type ReadOnlyDatabaseHarness interface {
	Harness

	// NewReadOnlyEngine returns a new engine with read-only versions of the databases supplied by the provider.
	// TODO: should this and NewEngine actually just be NewProvider?
	NewReadOnlyEngine(provider sql.DatabaseProvider) (*sqle.Engine, error)
}

type SkippingHarness 

type SkippingHarness interface {
	// SkipQueryTest returns whether to skip a test of the provided query string.
	SkipQueryTest(query string) bool
}

SkippingHarness provides a way for integrators to skip tests that are known to be broken. E.g., integrators that can't handle every possible SQL type.

type SkippingMemoryHarness 

type SkippingMemoryHarness struct {
	MemoryHarness
}

func NewSkippingMemoryHarness 

func NewSkippingMemoryHarness() *SkippingMemoryHarness

func (SkippingMemoryHarness) SkipQueryTest 

func (s SkippingMemoryHarness) SkipQueryTest(query string) bool

type SpatialIndexPlanTest 

type SpatialIndexPlanTest struct {
	// contains filtered or unexported fields
}

type SpatialIndexPlanTestAssertion 

type SpatialIndexPlanTestAssertion struct {
	// contains filtered or unexported fields
}

type TransactionHarness 

type TransactionHarness interface {
	Harness

	// NewSession returns a context with a new Session, rather than reusing an existing session from previous calls to
	// NewContext()
	NewSession() *sql.Context
}

type ValidatingHarness 

type ValidatingHarness interface {
	Harness

	// ValidateEngine runs post-test assertions against an engine.
	ValidateEngine(ctx *sql.Context, e *sqle.Engine) error
}

type VersionedDBHarness 

type VersionedDBHarness interface {
	Harness

	// NewDatabases returns a set of new databases used for the duration of a versioned test
	NewDatabases(names ...string) []sql.Database

	// NewTableAsOf creates a new table with the given name and schema, optionally handling snapshotting with the asOf
	// identifier. NewTableAsOf must ignore tables that already exist in the database. Tables returned by this method do
	// not need to have any previously created data in them, but they can. This behavior is implementation specific, and
	// the harness works either way.
	NewTableAsOf(db sql.VersionedDatabase, name string, schema sql.PrimaryKeySchema, asOf interface{}) sql.Table
	// SnapshotTable creates a snapshot of the table named with the given asOf label. Depending on the implementation,
	// NewTableAsOf might do all the necessary work to create such snapshots, so this could be a no-op.
	SnapshotTable(db sql.VersionedDatabase, name string, asOf interface{}) error
}

VersionedDBHarness is an extension to Harness that lets an integrator test their implementation of versioned (AS OF) queries. Integrators must implement sql.VersionedDatabase. For each table version being created, there will be a call to NewTableAsOf, some number of Delete and Insert operations, and then a call to SnapshotTable.

Source Files

View all Source files

Directories

Path Synopsis
scriptgen
cmd/scriptgen
setup
harness

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.