diff --git a/pkg/BUILD.bazel b/pkg/BUILD.bazel index ea54e0ef43bc..58f3966ebb2b 100644 --- a/pkg/BUILD.bazel +++ b/pkg/BUILD.bazel @@ -61,6 +61,7 @@ ALL_TESTS = [ "//pkg/ccl/logictestccl/tests/fakedist:fakedist_test", "//pkg/ccl/logictestccl/tests/local-legacy-schema-changer:local-legacy-schema-changer_test", "//pkg/ccl/logictestccl/tests/local-mixed-24.2:local-mixed-24_2_test", + "//pkg/ccl/logictestccl/tests/local-mixed-24.3:local-mixed-24_3_test", "//pkg/ccl/logictestccl/tests/local-read-committed:local-read-committed_test", "//pkg/ccl/logictestccl/tests/local-repeatable-read:local-repeatable-read_test", "//pkg/ccl/logictestccl/tests/local-vec-off:local-vec-off_test", @@ -486,6 +487,7 @@ ALL_TESTS = [ "//pkg/sql/logictest/tests/fakedist:fakedist_test", "//pkg/sql/logictest/tests/local-legacy-schema-changer:local-legacy-schema-changer_test", "//pkg/sql/logictest/tests/local-mixed-24.2:local-mixed-24_2_test", + "//pkg/sql/logictest/tests/local-mixed-24.3:local-mixed-24_3_test", "//pkg/sql/logictest/tests/local-vec-off:local-vec-off_test", "//pkg/sql/logictest/tests/local:local_test", "//pkg/sql/logictest/tests/multiregion-9node-3region-3azs:multiregion-9node-3region-3azs_test", @@ -503,6 +505,7 @@ ALL_TESTS = [ "//pkg/sql/opt/exec/execbuilder/tests/fakedist:fakedist_test", "//pkg/sql/opt/exec/execbuilder/tests/local-legacy-schema-changer:local-legacy-schema-changer_test", "//pkg/sql/opt/exec/execbuilder/tests/local-mixed-24.2:local-mixed-24_2_test", + "//pkg/sql/opt/exec/execbuilder/tests/local-mixed-24.3:local-mixed-24_3_test", "//pkg/sql/opt/exec/execbuilder/tests/local-vec-off:local-vec-off_test", "//pkg/sql/opt/exec/execbuilder/tests/local:local_test", "//pkg/sql/opt/exec/execbuilder:execbuilder_test", @@ -605,6 +608,7 @@ ALL_TESTS = [ "//pkg/sql/sqlitelogictest/tests/fakedist:fakedist_test", "//pkg/sql/sqlitelogictest/tests/local-legacy-schema-changer:local-legacy-schema-changer_test", "//pkg/sql/sqlitelogictest/tests/local-mixed-24.2:local-mixed-24_2_test", + "//pkg/sql/sqlitelogictest/tests/local-mixed-24.3:local-mixed-24_3_test", "//pkg/sql/sqlitelogictest/tests/local-read-committed:local-read-committed_test", "//pkg/sql/sqlitelogictest/tests/local-repeatable-read:local-repeatable-read_test", "//pkg/sql/sqlitelogictest/tests/local-vec-off:local-vec-off_test", @@ -931,6 +935,7 @@ GO_TARGETS = [ "//pkg/ccl/logictestccl/tests/fakedist:fakedist_test", "//pkg/ccl/logictestccl/tests/local-legacy-schema-changer:local-legacy-schema-changer_test", "//pkg/ccl/logictestccl/tests/local-mixed-24.2:local-mixed-24_2_test", + "//pkg/ccl/logictestccl/tests/local-mixed-24.3:local-mixed-24_3_test", "//pkg/ccl/logictestccl/tests/local-read-committed:local-read-committed_test", "//pkg/ccl/logictestccl/tests/local-repeatable-read:local-repeatable-read_test", "//pkg/ccl/logictestccl/tests/local-vec-off:local-vec-off_test", @@ -1962,6 +1967,7 @@ GO_TARGETS = [ "//pkg/sql/logictest/tests/fakedist:fakedist_test", "//pkg/sql/logictest/tests/local-legacy-schema-changer:local-legacy-schema-changer_test", "//pkg/sql/logictest/tests/local-mixed-24.2:local-mixed-24_2_test", + "//pkg/sql/logictest/tests/local-mixed-24.3:local-mixed-24_3_test", "//pkg/sql/logictest/tests/local-vec-off:local-vec-off_test", "//pkg/sql/logictest/tests/local:local_test", "//pkg/sql/logictest/tests/multiregion-9node-3region-3azs:multiregion-9node-3region-3azs_test", @@ -1988,6 +1994,7 @@ GO_TARGETS = [ "//pkg/sql/opt/exec/execbuilder/tests/fakedist:fakedist_test", "//pkg/sql/opt/exec/execbuilder/tests/local-legacy-schema-changer:local-legacy-schema-changer_test", "//pkg/sql/opt/exec/execbuilder/tests/local-mixed-24.2:local-mixed-24_2_test", + "//pkg/sql/opt/exec/execbuilder/tests/local-mixed-24.3:local-mixed-24_3_test", "//pkg/sql/opt/exec/execbuilder/tests/local-vec-off:local-vec-off_test", "//pkg/sql/opt/exec/execbuilder/tests/local:local_test", "//pkg/sql/opt/exec/execbuilder:execbuilder", @@ -2237,6 +2244,7 @@ GO_TARGETS = [ "//pkg/sql/sqlitelogictest/tests/fakedist:fakedist_test", "//pkg/sql/sqlitelogictest/tests/local-legacy-schema-changer:local-legacy-schema-changer_test", "//pkg/sql/sqlitelogictest/tests/local-mixed-24.2:local-mixed-24_2_test", + "//pkg/sql/sqlitelogictest/tests/local-mixed-24.3:local-mixed-24_3_test", "//pkg/sql/sqlitelogictest/tests/local-read-committed:local-read-committed_test", "//pkg/sql/sqlitelogictest/tests/local-repeatable-read:local-repeatable-read_test", "//pkg/sql/sqlitelogictest/tests/local-vec-off:local-vec-off_test", diff --git a/pkg/ccl/logictestccl/tests/local-mixed-24.3/BUILD.bazel b/pkg/ccl/logictestccl/tests/local-mixed-24.3/BUILD.bazel new file mode 100644 index 000000000000..1ffe8472c60a --- /dev/null +++ b/pkg/ccl/logictestccl/tests/local-mixed-24.3/BUILD.bazel @@ -0,0 +1,28 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_test") + +go_test( + name = "local-mixed-24_3_test", + size = "enormous", + srcs = ["generated_test.go"], + data = [ + "//c-deps:libgeos", # keep + "//pkg/ccl/logictestccl:testdata", # keep + ], + exec_properties = {"test.Pool": "large"}, + shard_count = 31, + tags = ["cpu:1"], + deps = [ + "//pkg/base", + "//pkg/build/bazel", + "//pkg/ccl", + "//pkg/security/securityassets", + "//pkg/security/securitytest", + "//pkg/server", + "//pkg/sql/logictest", + "//pkg/testutils/serverutils", + "//pkg/testutils/skip", + "//pkg/testutils/testcluster", + "//pkg/util/leaktest", + "//pkg/util/randutil", + ], +) diff --git a/pkg/ccl/logictestccl/tests/local-mixed-24.3/generated_test.go b/pkg/ccl/logictestccl/tests/local-mixed-24.3/generated_test.go new file mode 100644 index 000000000000..1cfb52269633 --- /dev/null +++ b/pkg/ccl/logictestccl/tests/local-mixed-24.3/generated_test.go @@ -0,0 +1,293 @@ +// Copyright 2022 The Cockroach Authors. +// +// Use of this software is governed by the CockroachDB Software License +// included in the /LICENSE file. + +// Code generated by generate-logictest, DO NOT EDIT. + +package testlocal_mixed_243 + +import ( + "os" + "path/filepath" + "testing" + + "github.com/cockroachdb/cockroach/pkg/base" + "github.com/cockroachdb/cockroach/pkg/build/bazel" + "github.com/cockroachdb/cockroach/pkg/ccl" + "github.com/cockroachdb/cockroach/pkg/security/securityassets" + "github.com/cockroachdb/cockroach/pkg/security/securitytest" + "github.com/cockroachdb/cockroach/pkg/server" + "github.com/cockroachdb/cockroach/pkg/sql/logictest" + "github.com/cockroachdb/cockroach/pkg/testutils/serverutils" + "github.com/cockroachdb/cockroach/pkg/testutils/skip" + "github.com/cockroachdb/cockroach/pkg/testutils/testcluster" + "github.com/cockroachdb/cockroach/pkg/util/leaktest" + "github.com/cockroachdb/cockroach/pkg/util/randutil" +) + +const configIdx = 21 + +var cclLogicTestDir string + +func init() { + if bazel.BuiltWithBazel() { + var err error + cclLogicTestDir, err = bazel.Runfile("pkg/ccl/logictestccl/testdata/logic_test") + if err != nil { + panic(err) + } + } else { + cclLogicTestDir = "../../../../ccl/logictestccl/testdata/logic_test" + } +} + +func TestMain(m *testing.M) { + defer ccl.TestingEnableEnterprise()() + securityassets.SetLoader(securitytest.EmbeddedAssets) + randutil.SeedForTests() + serverutils.InitTestServerFactory(server.TestServerFactory) + serverutils.InitTestClusterFactory(testcluster.TestClusterFactory) + + defer serverutils.TestingSetDefaultTenantSelectionOverride( + base.TestIsForStuffThatShouldWorkWithSecondaryTenantsButDoesntYet(76378), + )() + + os.Exit(m.Run()) +} + +func runCCLLogicTest(t *testing.T, file string) { + skip.UnderDeadlock(t, "times out and/or hangs") + logictest.RunLogicTest(t, logictest.TestServerArgs{}, configIdx, filepath.Join(cclLogicTestDir, file)) +} + +// TestLogic_tmp runs any tests that are prefixed with "_", in which a dedicated +// test is not generated for. This allows developers to create and run temporary +// test files that are not checked into the repository, without repeatedly +// regenerating and reverting changes to this file, generated_test.go. +// +// TODO(mgartner): Add file filtering so that individual files can be run, +// instead of all files with the "_" prefix. +func TestLogic_tmp(t *testing.T) { + defer leaktest.AfterTest(t)() + var glob string + glob = filepath.Join(cclLogicTestDir, "_*") + logictest.RunLogicTests(t, logictest.TestServerArgs{}, configIdx, glob) +} + +func TestCCLLogic_fips_ready( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "fips_ready") +} + +func TestCCLLogic_fk_read_committed( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "fk_read_committed") +} + +func TestCCLLogic_hash_sharded_index_read_committed( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "hash_sharded_index_read_committed") +} + +func TestCCLLogic_nested_routines( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "nested_routines") +} + +func TestCCLLogic_new_schema_changer( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "new_schema_changer") +} + +func TestCCLLogic_partitioning_enum( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "partitioning_enum") +} + +func TestCCLLogic_pgcrypto_builtins( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "pgcrypto_builtins") +} + +func TestCCLLogic_plpgsql_assign( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "plpgsql_assign") +} + +func TestCCLLogic_plpgsql_block( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "plpgsql_block") +} + +func TestCCLLogic_plpgsql_call( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "plpgsql_call") +} + +func TestCCLLogic_plpgsql_cursor( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "plpgsql_cursor") +} + +func TestCCLLogic_plpgsql_into( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "plpgsql_into") +} + +func TestCCLLogic_plpgsql_record( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "plpgsql_record") +} + +func TestCCLLogic_plpgsql_txn( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "plpgsql_txn") +} + +func TestCCLLogic_plpgsql_unsupported( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "plpgsql_unsupported") +} + +func TestCCLLogic_procedure_params( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "procedure_params") +} + +func TestCCLLogic_procedure_plpgsql( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "procedure_plpgsql") +} + +func TestCCLLogic_read_committed( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "read_committed") +} + +func TestCCLLogic_redact_descriptor( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "redact_descriptor") +} + +func TestCCLLogic_refcursor( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "refcursor") +} + +func TestCCLLogic_schema_change_in_txn( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "schema_change_in_txn") +} + +func TestCCLLogic_select_for_update_read_committed( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "select_for_update_read_committed") +} + +func TestCCLLogic_show_create( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "show_create") +} + +func TestCCLLogic_subject( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "subject") +} + +func TestCCLLogic_triggers( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "triggers") +} + +func TestCCLLogic_udf_params( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "udf_params") +} + +func TestCCLLogic_udf_plpgsql( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "udf_plpgsql") +} + +func TestCCLLogic_udf_rewrite( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "udf_rewrite") +} + +func TestCCLLogic_udf_volatility_check( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "udf_volatility_check") +} + +func TestCCLLogic_unique_read_committed( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "unique_read_committed") +} + +func TestCCLLogic_vector( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "vector") +} diff --git a/pkg/sql/logictest/logictestbase/logictestbase.go b/pkg/sql/logictest/logictestbase/logictestbase.go index 2cb5685e0031..00705dded375 100644 --- a/pkg/sql/logictest/logictestbase/logictestbase.go +++ b/pkg/sql/logictest/logictestbase/logictestbase.go @@ -589,8 +589,7 @@ var ( "fakedist-vec-off", "fakedist-disk", "local-mixed-24.2", - // TODO(radu): enable this. - //"local-mixed-24.3", + "local-mixed-24.3", } // FiveNodeDefaultConfigName is a special alias for all 5 node configs. FiveNodeDefaultConfigName = "5node-default-configs" diff --git a/pkg/sql/logictest/testdata/logic_test/alter_column_type b/pkg/sql/logictest/testdata/logic_test/alter_column_type index 372e68286637..5d7412524565 100644 --- a/pkg/sql/logictest/testdata/logic_test/alter_column_type +++ b/pkg/sql/logictest/testdata/logic_test/alter_column_type @@ -1448,6 +1448,7 @@ ALTER TABLE stored1 ALTER COLUMN comp1 SET DATA TYPE TEXT; skipif config local-legacy-schema-changer skipif config local-mixed-24.1 skipif config local-mixed-24.2 +skipif config local-mixed-24.3 statement ok ALTER TABLE stored1 ALTER COLUMN comp1 SET DATA TYPE INT2 USING -1; @@ -1457,6 +1458,7 @@ INSERT INTO stored1 VALUES (-1000); skipif config local-legacy-schema-changer skipif config local-mixed-24.1 skipif config local-mixed-24.2 +skipif config local-mixed-24.3 query TT SHOW CREATE TABLE stored1; ---- @@ -1470,6 +1472,7 @@ stored1 CREATE TABLE public.stored1 ( skipif config local-legacy-schema-changer skipif config local-mixed-24.1 skipif config local-mixed-24.2 +skipif config local-mixed-24.3 query II SELECT * FROM stored1 ORDER BY A; ---- @@ -1484,6 +1487,7 @@ SELECT * FROM stored1 ORDER BY A; skipif config local-legacy-schema-changer skipif config local-mixed-24.1 skipif config local-mixed-24.2 +skipif config local-mixed-24.3 statement error pq: unimplemented: ALTER COLUMN TYPE cannot be used in combination with other ALTER TABLE commands ALTER TABLE stored1 ALTER COLUMN comp1 SET DATA TYPE INT4 USING -1, ALTER COLUMN comp1 drop stored; diff --git a/pkg/sql/logictest/testdata/logic_test/tenant_builtins b/pkg/sql/logictest/testdata/logic_test/tenant_builtins index 205c5a78a8a3..dfd4d9c1681b 100644 --- a/pkg/sql/logictest/testdata/logic_test/tenant_builtins +++ b/pkg/sql/logictest/testdata/logic_test/tenant_builtins @@ -1,4 +1,5 @@ -# LogicTest: !enterprise-configs +# LogicTest: !enterprise-configs !local-mixed-24.3 +# TODO(radu): local-mixed-24.3 should not be excluded; tracked in #135358 query IBIT colnames SELECT id, active, length(info), name FROM system.tenants ORDER BY id diff --git a/pkg/sql/logictest/testdata/logic_test/zone_config b/pkg/sql/logictest/testdata/logic_test/zone_config index 85cb3fe37dcb..cccc30e4fe70 100644 --- a/pkg/sql/logictest/testdata/logic_test/zone_config +++ b/pkg/sql/logictest/testdata/logic_test/zone_config @@ -1,3 +1,6 @@ +# LogicTest: !local-mixed-24.3 +# TODO(radu): local-mixed-24.3 should not be excluded; tracked in #135358 + # Check that we can alter the default zone config. statement ok ALTER RANGE default CONFIGURE ZONE USING num_replicas = 1 diff --git a/pkg/sql/logictest/tests/local-mixed-24.3/BUILD.bazel b/pkg/sql/logictest/tests/local-mixed-24.3/BUILD.bazel new file mode 100644 index 000000000000..4d23d538c257 --- /dev/null +++ b/pkg/sql/logictest/tests/local-mixed-24.3/BUILD.bazel @@ -0,0 +1,30 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_test") + +go_test( + name = "local-mixed-24_3_test", + size = "enormous", + srcs = ["generated_test.go"], + data = [ + "//c-deps:libgeos", # keep + "//pkg/sql/logictest:testdata", # keep + ], + exec_properties = select({ + "//build/toolchains:is_heavy": {"test.Pool": "heavy"}, + "//conditions:default": {"test.Pool": "large"}, + }), + shard_count = 48, + tags = ["cpu:1"], + deps = [ + "//pkg/base", + "//pkg/build/bazel", + "//pkg/security/securityassets", + "//pkg/security/securitytest", + "//pkg/server", + "//pkg/sql/logictest", + "//pkg/testutils/serverutils", + "//pkg/testutils/skip", + "//pkg/testutils/testcluster", + "//pkg/util/leaktest", + "//pkg/util/randutil", + ], +) diff --git a/pkg/sql/logictest/tests/local-mixed-24.3/generated_test.go b/pkg/sql/logictest/tests/local-mixed-24.3/generated_test.go new file mode 100644 index 000000000000..e9da95faf799 --- /dev/null +++ b/pkg/sql/logictest/tests/local-mixed-24.3/generated_test.go @@ -0,0 +1,2587 @@ +// Copyright 2022 The Cockroach Authors. +// +// Use of this software is governed by the CockroachDB Software License +// included in the /LICENSE file. + +// Code generated by generate-logictest, DO NOT EDIT. + +package testlocal_mixed_243 + +import ( + "os" + "path/filepath" + "testing" + + "github.com/cockroachdb/cockroach/pkg/base" + "github.com/cockroachdb/cockroach/pkg/build/bazel" + "github.com/cockroachdb/cockroach/pkg/security/securityassets" + "github.com/cockroachdb/cockroach/pkg/security/securitytest" + "github.com/cockroachdb/cockroach/pkg/server" + "github.com/cockroachdb/cockroach/pkg/sql/logictest" + "github.com/cockroachdb/cockroach/pkg/testutils/serverutils" + "github.com/cockroachdb/cockroach/pkg/testutils/skip" + "github.com/cockroachdb/cockroach/pkg/testutils/testcluster" + "github.com/cockroachdb/cockroach/pkg/util/leaktest" + "github.com/cockroachdb/cockroach/pkg/util/randutil" +) + +const configIdx = 21 + +var logicTestDir string + +func init() { + if bazel.BuiltWithBazel() { + var err error + logicTestDir, err = bazel.Runfile("pkg/sql/logictest/testdata/logic_test") + if err != nil { + panic(err) + } + } else { + logicTestDir = "../../../../sql/logictest/testdata/logic_test" + } +} + +func TestMain(m *testing.M) { + securityassets.SetLoader(securitytest.EmbeddedAssets) + randutil.SeedForTests() + serverutils.InitTestServerFactory(server.TestServerFactory) + serverutils.InitTestClusterFactory(testcluster.TestClusterFactory) + + defer serverutils.TestingSetDefaultTenantSelectionOverride( + base.TestIsForStuffThatShouldWorkWithSecondaryTenantsButDoesntYet(76378), + )() + + os.Exit(m.Run()) +} + +func runLogicTest(t *testing.T, file string) { + skip.UnderDeadlock(t, "times out and/or hangs") + logictest.RunLogicTest(t, logictest.TestServerArgs{}, configIdx, filepath.Join(logicTestDir, file)) +} + +// TestLogic_tmp runs any tests that are prefixed with "_", in which a dedicated +// test is not generated for. This allows developers to create and run temporary +// test files that are not checked into the repository, without repeatedly +// regenerating and reverting changes to this file, generated_test.go. +// +// TODO(mgartner): Add file filtering so that individual files can be run, +// instead of all files with the "_" prefix. +func TestLogic_tmp(t *testing.T) { + defer leaktest.AfterTest(t)() + var glob string + glob = filepath.Join(logicTestDir, "_*") + logictest.RunLogicTests(t, logictest.TestServerArgs{}, configIdx, glob) +} + +func TestLogic_aggregate( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "aggregate") +} + +func TestLogic_alias_types( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alias_types") +} + +func TestLogic_alter_column_type( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_column_type") +} + +func TestLogic_alter_database_convert_to_schema( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_database_convert_to_schema") +} + +func TestLogic_alter_database_owner( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_database_owner") +} + +func TestLogic_alter_default_privileges_for_all_roles( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_default_privileges_for_all_roles") +} + +func TestLogic_alter_default_privileges_for_schema( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_default_privileges_for_schema") +} + +func TestLogic_alter_default_privileges_for_sequence( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_default_privileges_for_sequence") +} + +func TestLogic_alter_default_privileges_for_table( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_default_privileges_for_table") +} + +func TestLogic_alter_default_privileges_for_type( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_default_privileges_for_type") +} + +func TestLogic_alter_default_privileges_in_schema( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_default_privileges_in_schema") +} + +func TestLogic_alter_default_privileges_with_grant_option( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_default_privileges_with_grant_option") +} + +func TestLogic_alter_primary_key( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_primary_key") +} + +func TestLogic_alter_role( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_role") +} + +func TestLogic_alter_role_set( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_role_set") +} + +func TestLogic_alter_schema_owner( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_schema_owner") +} + +func TestLogic_alter_sequence( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_sequence") +} + +func TestLogic_alter_sequence_owner( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_sequence_owner") +} + +func TestLogic_alter_table( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_table") +} + +func TestLogic_alter_table_owner( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_table_owner") +} + +func TestLogic_alter_type( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_type") +} + +func TestLogic_alter_type_owner( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_type_owner") +} + +func TestLogic_alter_view_owner( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "alter_view_owner") +} + +func TestLogic_and_or( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "and_or") +} + +func TestLogic_apply_join( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "apply_join") +} + +func TestLogic_array( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "array") +} + +func TestLogic_as_of( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "as_of") +} + +func TestLogic_asyncpg( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "asyncpg") +} + +func TestLogic_auto_span_config_reconciliation_job( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "auto_span_config_reconciliation_job") +} + +func TestLogic_bit( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "bit") +} + +func TestLogic_bpchar( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "bpchar") +} + +func TestLogic_builtin_function( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "builtin_function") +} + +func TestLogic_builtin_function_notenant( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "builtin_function_notenant") +} + +func TestLogic_bytes( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "bytes") +} + +func TestLogic_cascade( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "cascade") +} + +func TestLogic_case_sensitive_names( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "case_sensitive_names") +} + +func TestLogic_cast( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "cast") +} + +func TestLogic_ccl( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "ccl") +} + +func TestLogic_check_constraints( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "check_constraints") +} + +func TestLogic_cluster_settings( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "cluster_settings") +} + +func TestLogic_collatedstring( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "collatedstring") +} + +func TestLogic_collatedstring_constraint( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "collatedstring_constraint") +} + +func TestLogic_collatedstring_index1( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "collatedstring_index1") +} + +func TestLogic_collatedstring_index2( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "collatedstring_index2") +} + +func TestLogic_collatedstring_normalization( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "collatedstring_normalization") +} + +func TestLogic_collatedstring_nullinindex( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "collatedstring_nullinindex") +} + +func TestLogic_collatedstring_uniqueindex1( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "collatedstring_uniqueindex1") +} + +func TestLogic_collatedstring_uniqueindex2( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "collatedstring_uniqueindex2") +} + +func TestLogic_comment_on( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "comment_on") +} + +func TestLogic_composite_types( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "composite_types") +} + +func TestLogic_computed( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "computed") +} + +func TestLogic_conditional( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "conditional") +} + +func TestLogic_connect_privilege( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "connect_privilege") +} + +func TestLogic_crdb_internal( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "crdb_internal") +} + +func TestLogic_crdb_internal_catalog( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "crdb_internal_catalog") +} + +func TestLogic_crdb_internal_default_privileges( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "crdb_internal_default_privileges") +} + +func TestLogic_create_as( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "create_as") +} + +func TestLogic_create_index( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "create_index") +} + +func TestLogic_create_statements( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "create_statements") +} + +func TestLogic_create_table( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "create_table") +} + +func TestLogic_cross_join( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "cross_join") +} + +func TestLogic_cursor( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "cursor") +} + +func TestLogic_custom_escape_character( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "custom_escape_character") +} + +func TestLogic_dangerous_statements( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "dangerous_statements") +} + +func TestLogic_database( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "database") +} + +func TestLogic_datetime( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "datetime") +} + +func TestLogic_decimal( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "decimal") +} + +func TestLogic_default( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "default") +} + +func TestLogic_delete( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "delete") +} + +func TestLogic_delete_batch( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "delete_batch") +} + +func TestLogic_dependencies( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "dependencies") +} + +func TestLogic_discard( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "discard") +} + +func TestLogic_disjunction_in_join( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "disjunction_in_join") +} + +func TestLogic_distinct( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "distinct") +} + +func TestLogic_distinct_on( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "distinct_on") +} + +func TestLogic_distsql_automatic_partial_stats( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "distsql_automatic_partial_stats") +} + +func TestLogic_distsql_automatic_stats( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "distsql_automatic_stats") +} + +func TestLogic_distsql_event_log( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "distsql_event_log") +} + +func TestLogic_distsql_expr( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "distsql_expr") +} + +func TestLogic_distsql_join( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "distsql_join") +} + +func TestLogic_distsql_srfs( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "distsql_srfs") +} + +func TestLogic_drop_database( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_database") +} + +func TestLogic_drop_function( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_function") +} + +func TestLogic_drop_index( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_index") +} + +func TestLogic_drop_owned_by( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_owned_by") +} + +func TestLogic_drop_procedure( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_procedure") +} + +func TestLogic_drop_role_with_default_privileges( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_role_with_default_privileges") +} + +func TestLogic_drop_role_with_default_privileges_in_schema( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_role_with_default_privileges_in_schema") +} + +func TestLogic_drop_schema( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_schema") +} + +func TestLogic_drop_sequence( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_sequence") +} + +func TestLogic_drop_table( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_table") +} + +func TestLogic_drop_temp( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_temp") +} + +func TestLogic_drop_type( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_type") +} + +func TestLogic_drop_user( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_user") +} + +func TestLogic_drop_view( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "drop_view") +} + +func TestLogic_edge( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "edge") +} + +func TestLogic_enums( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "enums") +} + +func TestLogic_errors( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "errors") +} + +func TestLogic_event_log( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "event_log") +} + +func TestLogic_exclude_data_from_backup( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "exclude_data_from_backup") +} + +func TestLogic_experimental_distsql_planning( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "experimental_distsql_planning") +} + +func TestLogic_explain_analyze( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "explain_analyze") +} + +func TestLogic_export( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "export") +} + +func TestLogic_expression_index( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "expression_index") +} + +func TestLogic_external_connection_privileges( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "external_connection_privileges") +} + +func TestLogic_family( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "family") +} + +func TestLogic_fk( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "fk") +} + +func TestLogic_float( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "float") +} + +func TestLogic_format( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "format") +} + +func TestLogic_function_lookup( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "function_lookup") +} + +func TestLogic_fuzzystrmatch( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "fuzzystrmatch") +} + +func TestLogic_geospatial( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "geospatial") +} + +func TestLogic_geospatial_index( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "geospatial_index") +} + +func TestLogic_geospatial_meta( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "geospatial_meta") +} + +func TestLogic_geospatial_regression( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "geospatial_regression") +} + +func TestLogic_geospatial_zm( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "geospatial_zm") +} + +func TestLogic_grant_database( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "grant_database") +} + +func TestLogic_grant_in_txn( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "grant_in_txn") +} + +func TestLogic_grant_on_all_sequences_in_schema( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "grant_on_all_sequences_in_schema") +} + +func TestLogic_grant_on_all_tables_in_schema( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "grant_on_all_tables_in_schema") +} + +func TestLogic_grant_revoke_with_grant_option( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "grant_revoke_with_grant_option") +} + +func TestLogic_grant_role( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "grant_role") +} + +func TestLogic_grant_schema( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "grant_schema") +} + +func TestLogic_group_join( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "group_join") +} + +func TestLogic_hash_join( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "hash_join") +} + +func TestLogic_hash_sharded_index( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "hash_sharded_index") +} + +func TestLogic_hidden_columns( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "hidden_columns") +} + +func TestLogic_impure( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "impure") +} + +func TestLogic_index_join( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "index_join") +} + +func TestLogic_inet( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "inet") +} + +func TestLogic_inflight_trace_spans( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "inflight_trace_spans") +} + +func TestLogic_information_schema( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "information_schema") +} + +func TestLogic_inner_join( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "inner-join") +} + +func TestLogic_insert( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "insert") +} + +func TestLogic_int_size( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "int_size") +} + +func TestLogic_internal_executor( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "internal_executor") +} + +func TestLogic_interval( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "interval") +} + +func TestLogic_inverted_filter_geospatial( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "inverted_filter_geospatial") +} + +func TestLogic_inverted_filter_json_array( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "inverted_filter_json_array") +} + +func TestLogic_inverted_index( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "inverted_index") +} + +func TestLogic_inverted_index_multi_column( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "inverted_index_multi_column") +} + +func TestLogic_inverted_join_geospatial( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "inverted_join_geospatial") +} + +func TestLogic_inverted_join_json_array( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "inverted_join_json_array") +} + +func TestLogic_inverted_join_multi_column( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "inverted_join_multi_column") +} + +func TestLogic_jobs( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "jobs") +} + +func TestLogic_join( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "join") +} + +func TestLogic_json( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "json") +} + +func TestLogic_json_builtins( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "json_builtins") +} + +func TestLogic_json_index( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "json_index") +} + +func TestLogic_kv_builtin_functions( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "kv_builtin_functions") +} + +func TestLogic_limit( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "limit") +} + +func TestLogic_locality( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "locality") +} + +func TestLogic_lock_timeout( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "lock_timeout") +} + +func TestLogic_lookup_join( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "lookup_join") +} + +func TestLogic_lookup_join_spans( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "lookup_join_spans") +} + +func TestLogic_manual_retry( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "manual_retry") +} + +func TestLogic_materialized_view( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "materialized_view") +} + +func TestLogic_merge_join( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "merge_join") +} + +func TestLogic_multi_statement( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "multi_statement") +} + +func TestLogic_name_escapes( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "name_escapes") +} + +func TestLogic_namespace( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "namespace") +} + +func TestLogic_new_schema_changer( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "new_schema_changer") +} + +func TestLogic_no_primary_key( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "no_primary_key") +} + +func TestLogic_notice( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "notice") +} + +func TestLogic_numeric_references( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "numeric_references") +} + +func TestLogic_on_update( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "on_update") +} + +func TestLogic_operator( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "operator") +} + +func TestLogic_optimizer_timeout( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "optimizer_timeout") +} + +func TestLogic_order_by( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "order_by") +} + +func TestLogic_ordinal_references( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "ordinal_references") +} + +func TestLogic_ordinality( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "ordinality") +} + +func TestLogic_overflow( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "overflow") +} + +func TestLogic_overlaps( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "overlaps") +} + +func TestLogic_owner( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "owner") +} + +func TestLogic_parallel_stmts_compat( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "parallel_stmts_compat") +} + +func TestLogic_partial_index( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "partial_index") +} + +func TestLogic_partial_txn_commit( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "partial_txn_commit") +} + +func TestLogic_partitioning( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "partitioning") +} + +func TestLogic_pg_builtins( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "pg_builtins") +} + +func TestLogic_pg_catalog_pg_default_acl( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "pg_catalog_pg_default_acl") +} + +func TestLogic_pg_catalog_pg_default_acl_with_grant_option( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "pg_catalog_pg_default_acl_with_grant_option") +} + +func TestLogic_pg_extension( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "pg_extension") +} + +func TestLogic_pg_lsn( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "pg_lsn") +} + +func TestLogic_pgcrypto_builtins( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "pgcrypto_builtins") +} + +func TestLogic_pgoidtype( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "pgoidtype") +} + +func TestLogic_plpgsql_builtins( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "plpgsql_builtins") +} + +func TestLogic_poison_after_push( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "poison_after_push") +} + +func TestLogic_postgres_jsonb( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "postgres_jsonb") +} + +func TestLogic_postgresjoin( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "postgresjoin") +} + +func TestLogic_privilege_builtins( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "privilege_builtins") +} + +func TestLogic_privileges_comments( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "privileges_comments") +} + +func TestLogic_privileges_table( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "privileges_table") +} + +func TestLogic_proc_invokes_proc( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "proc_invokes_proc") +} + +func TestLogic_procedure( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "procedure") +} + +func TestLogic_procedure_deps( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "procedure_deps") +} + +func TestLogic_procedure_params( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "procedure_params") +} + +func TestLogic_procedure_polymorphic( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "procedure_polymorphic") +} + +func TestLogic_procedure_privileges( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "procedure_privileges") +} + +func TestLogic_procedure_schema_change( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "procedure_schema_change") +} + +func TestLogic_propagate_input_ordering( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "propagate_input_ordering") +} + +func TestLogic_reassign_owned_by( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "reassign_owned_by") +} + +func TestLogic_record( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "record") +} + +func TestLogic_redact_descriptor( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "redact_descriptor") +} + +func TestLogic_rename_atomic( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "rename_atomic") +} + +func TestLogic_rename_column( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "rename_column") +} + +func TestLogic_rename_constraint( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "rename_constraint") +} + +func TestLogic_rename_database( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "rename_database") +} + +func TestLogic_rename_index( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "rename_index") +} + +func TestLogic_rename_sequence( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "rename_sequence") +} + +func TestLogic_rename_table( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "rename_table") +} + +func TestLogic_rename_view( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "rename_view") +} + +func TestLogic_reset( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "reset") +} + +func TestLogic_retry( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "retry") +} + +func TestLogic_returning( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "returning") +} + +func TestLogic_routine_schema_change( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "routine_schema_change") +} + +func TestLogic_row_level_ttl( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "row_level_ttl") +} + +func TestLogic_rows_from( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "rows_from") +} + +func TestLogic_run_control( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "run_control") +} + +func TestLogic_save_table( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "save_table") +} + +func TestLogic_savepoints( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "savepoints") +} + +func TestLogic_scale( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "scale") +} + +func TestLogic_scatter( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "scatter") +} + +func TestLogic_schema( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "schema") +} + +func TestLogic_schema_change_feature_flags( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "schema_change_feature_flags") +} + +func TestLogic_schema_change_in_txn( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "schema_change_in_txn") +} + +func TestLogic_schema_change_logical_replication( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "schema_change_logical_replication") +} + +func TestLogic_schema_change_retry( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "schema_change_retry") +} + +func TestLogic_schema_locked( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "schema_locked") +} + +func TestLogic_schema_repair( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "schema_repair") +} + +func TestLogic_scrub( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "scrub") +} + +func TestLogic_secondary_index_column_families( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "secondary_index_column_families") +} + +func TestLogic_select( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "select") +} + +func TestLogic_select_for_share( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "select_for_share") +} + +func TestLogic_select_for_update( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "select_for_update") +} + +func TestLogic_select_index( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "select_index") +} + +func TestLogic_select_index_flags( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "select_index_flags") +} + +func TestLogic_select_search_path( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "select_search_path") +} + +func TestLogic_select_table_alias( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "select_table_alias") +} + +func TestLogic_sequences( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "sequences") +} + +func TestLogic_sequences_distsql( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "sequences_distsql") +} + +func TestLogic_sequences_regclass( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "sequences_regclass") +} + +func TestLogic_serial( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "serial") +} + +func TestLogic_serializable_eager_restart( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "serializable_eager_restart") +} + +func TestLogic_set_local( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "set_local") +} + +func TestLogic_set_role( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "set_role") +} + +func TestLogic_set_schema( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "set_schema") +} + +func TestLogic_set_time_zone( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "set_time_zone") +} + +func TestLogic_shift( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "shift") +} + +func TestLogic_show_commit_timestamp( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_commit_timestamp") +} + +func TestLogic_show_completions( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_completions") +} + +func TestLogic_show_create( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_create") +} + +func TestLogic_show_create_all_schemas( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_create_all_schemas") +} + +func TestLogic_show_create_all_tables( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_create_all_tables") +} + +func TestLogic_show_create_all_tables_builtin( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_create_all_tables_builtin") +} + +func TestLogic_show_create_all_types( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_create_all_types") +} + +func TestLogic_show_create_redact( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_create_redact") +} + +func TestLogic_show_default_privileges( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_default_privileges") +} + +func TestLogic_show_external_connections( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_external_connections") +} + +func TestLogic_show_fingerprints( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_fingerprints") +} + +func TestLogic_show_grants_on_virtual_table( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_grants_on_virtual_table") +} + +func TestLogic_show_grants_synthetic( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_grants_synthetic") +} + +func TestLogic_show_indexes( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_indexes") +} + +func TestLogic_show_tenant_fingerprints( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_tenant_fingerprints") +} + +func TestLogic_show_transfer_state( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_transfer_state") +} + +func TestLogic_show_var( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_var") +} + +func TestLogic_span_builtins( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "span_builtins") +} + +func TestLogic_split_at( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "split_at") +} + +func TestLogic_sqllite( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "sqllite") +} + +func TestLogic_sqlliveness( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "sqlliveness") +} + +func TestLogic_sqlsmith( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "sqlsmith") +} + +func TestLogic_srfs( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "srfs") +} + +func TestLogic_statement_source( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "statement_source") +} + +func TestLogic_statement_statistics_errors( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "statement_statistics_errors") +} + +func TestLogic_statement_statistics_errors_redacted( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "statement_statistics_errors_redacted") +} + +func TestLogic_stats( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "stats") +} + +func TestLogic_storing( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "storing") +} + +func TestLogic_strict_ddl_atomicity( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "strict_ddl_atomicity") +} + +func TestLogic_suboperators( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "suboperators") +} + +func TestLogic_subquery( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "subquery") +} + +func TestLogic_subquery_correlated( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "subquery_correlated") +} + +func TestLogic_synthetic_privileges( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "synthetic_privileges") +} + +func TestLogic_system( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "system") +} + +func TestLogic_system_columns( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "system_columns") +} + +func TestLogic_system_namespace( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "system_namespace") +} + +func TestLogic_table( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "table") +} + +func TestLogic_target_names( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "target_names") +} + +func TestLogic_temp_table( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "temp_table") +} + +func TestLogic_temp_table_txn( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "temp_table_txn") +} + +func TestLogic_tenant( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "tenant") +} + +func TestLogic_time( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "time") +} + +func TestLogic_timestamp( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "timestamp") +} + +func TestLogic_timetz( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "timetz") +} + +func TestLogic_trigram_builtins( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "trigram_builtins") +} + +func TestLogic_trigram_indexes( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "trigram_indexes") +} + +func TestLogic_truncate( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "truncate") +} + +func TestLogic_truncate_with_concurrent_mutation( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "truncate_with_concurrent_mutation") +} + +func TestLogic_tsvector( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "tsvector") +} + +func TestLogic_tuple( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "tuple") +} + +func TestLogic_tuple_local( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "tuple_local") +} + +func TestLogic_txn( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "txn") +} + +func TestLogic_txn_as_of( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "txn_as_of") +} + +func TestLogic_txn_retry( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "txn_retry") +} + +func TestLogic_txn_stats( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "txn_stats") +} + +func TestLogic_type_privileges( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "type_privileges") +} + +func TestLogic_typing( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "typing") +} + +func TestLogic_udf( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf") +} + +func TestLogic_udf_calling_udf( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_calling_udf") +} + +func TestLogic_udf_delete( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_delete") +} + +func TestLogic_udf_deps( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_deps") +} + +func TestLogic_udf_fk( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_fk") +} + +func TestLogic_udf_in_column_defaults( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_in_column_defaults") +} + +func TestLogic_udf_in_constraints( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_in_constraints") +} + +func TestLogic_udf_insert( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_insert") +} + +func TestLogic_udf_observability( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_observability") +} + +func TestLogic_udf_oid_ref( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_oid_ref") +} + +func TestLogic_udf_options( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_options") +} + +func TestLogic_udf_params( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_params") +} + +func TestLogic_udf_polymorphic( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_polymorphic") +} + +func TestLogic_udf_prepare( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_prepare") +} + +func TestLogic_udf_privileges( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_privileges") +} + +func TestLogic_udf_privileges_mutations( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_privileges_mutations") +} + +func TestLogic_udf_procedure_mix( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_procedure_mix") +} + +func TestLogic_udf_record( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_record") +} + +func TestLogic_udf_regressions( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_regressions") +} + +func TestLogic_udf_rewrite( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_rewrite") +} + +func TestLogic_udf_schema_change( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_schema_change") +} + +func TestLogic_udf_security( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_security") +} + +func TestLogic_udf_setof( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_setof") +} + +func TestLogic_udf_star( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_star") +} + +func TestLogic_udf_subquery( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_subquery") +} + +func TestLogic_udf_unsupported( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_unsupported") +} + +func TestLogic_udf_update( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_update") +} + +func TestLogic_udf_upsert( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "udf_upsert") +} + +func TestLogic_union( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "union") +} + +func TestLogic_unique( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "unique") +} + +func TestLogic_update( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "update") +} + +func TestLogic_update_from( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "update_from") +} + +func TestLogic_upgrade_skip_version( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "upgrade_skip_version") +} + +func TestLogic_upsert( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "upsert") +} + +func TestLogic_upsert_non_metamorphic( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "upsert_non_metamorphic") +} + +func TestLogic_uuid( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "uuid") +} + +func TestLogic_values( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "values") +} + +func TestLogic_vectorize_agg( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "vectorize_agg") +} + +func TestLogic_vectorize_overloads( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "vectorize_overloads") +} + +func TestLogic_vectorize_shutdown( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "vectorize_shutdown") +} + +func TestLogic_vectorize_types( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "vectorize_types") +} + +func TestLogic_vectorize_unsupported( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "vectorize_unsupported") +} + +func TestLogic_vectoross( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "vectoross") +} + +func TestLogic_views( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "views") +} + +func TestLogic_virtual_columns( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "virtual_columns") +} + +func TestLogic_virtual_table_privileges( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "virtual_table_privileges") +} + +func TestLogic_void( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "void") +} + +func TestLogic_where( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "where") +} + +func TestLogic_window( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "window") +} + +func TestLogic_with( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "with") +} + +func TestLogic_workload_indexrecs( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "workload_indexrecs") +} + +func TestLogic_zero( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "zero") +} + +func TestLogic_zigzag_join( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "zigzag_join") +} + +func TestLogic_zone_config_system_tenant( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "zone_config_system_tenant") +} diff --git a/pkg/sql/opt/exec/execbuilder/tests/local-mixed-24.3/BUILD.bazel b/pkg/sql/opt/exec/execbuilder/tests/local-mixed-24.3/BUILD.bazel new file mode 100644 index 000000000000..c2e2f25aa25e --- /dev/null +++ b/pkg/sql/opt/exec/execbuilder/tests/local-mixed-24.3/BUILD.bazel @@ -0,0 +1,31 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_test") + +go_test( + name = "local-mixed-24_3_test", + size = "enormous", + srcs = ["generated_test.go"], + data = [ + "//c-deps:libgeos", # keep + "//pkg/sql/opt/exec/execbuilder:testdata", # keep + ], + exec_properties = select({ + "//build/toolchains:is_heavy": {"test.Pool": "heavy"}, + "//conditions:default": {"test.Pool": "large"}, + }), + shard_count = 1, + tags = ["cpu:1"], + deps = [ + "//pkg/base", + "//pkg/build/bazel", + "//pkg/security/securityassets", + "//pkg/security/securitytest", + "//pkg/server", + "//pkg/sql", + "//pkg/sql/logictest", + "//pkg/testutils/serverutils", + "//pkg/testutils/skip", + "//pkg/testutils/testcluster", + "//pkg/util/leaktest", + "//pkg/util/randutil", + ], +) diff --git a/pkg/sql/opt/exec/execbuilder/tests/local-mixed-24.3/generated_test.go b/pkg/sql/opt/exec/execbuilder/tests/local-mixed-24.3/generated_test.go new file mode 100644 index 000000000000..3fcef1d3e528 --- /dev/null +++ b/pkg/sql/opt/exec/execbuilder/tests/local-mixed-24.3/generated_test.go @@ -0,0 +1,93 @@ +// Copyright 2022 The Cockroach Authors. +// +// Use of this software is governed by the CockroachDB Software License +// included in the /LICENSE file. + +// Code generated by generate-logictest, DO NOT EDIT. + +package testlocal_mixed_243 + +import ( + "os" + "path/filepath" + "testing" + + "github.com/cockroachdb/cockroach/pkg/base" + "github.com/cockroachdb/cockroach/pkg/build/bazel" + "github.com/cockroachdb/cockroach/pkg/security/securityassets" + "github.com/cockroachdb/cockroach/pkg/security/securitytest" + "github.com/cockroachdb/cockroach/pkg/server" + "github.com/cockroachdb/cockroach/pkg/sql" + "github.com/cockroachdb/cockroach/pkg/sql/logictest" + "github.com/cockroachdb/cockroach/pkg/testutils/serverutils" + "github.com/cockroachdb/cockroach/pkg/testutils/skip" + "github.com/cockroachdb/cockroach/pkg/testutils/testcluster" + "github.com/cockroachdb/cockroach/pkg/util/leaktest" + "github.com/cockroachdb/cockroach/pkg/util/randutil" +) + +const configIdx = 21 + +var execBuildLogicTestDir string + +func init() { + if bazel.BuiltWithBazel() { + var err error + execBuildLogicTestDir, err = bazel.Runfile("pkg/sql/opt/exec/execbuilder/testdata") + if err != nil { + panic(err) + } + } else { + execBuildLogicTestDir = "../../../../../../sql/opt/exec/execbuilder/testdata" + } +} + +func TestMain(m *testing.M) { + securityassets.SetLoader(securitytest.EmbeddedAssets) + randutil.SeedForTests() + serverutils.InitTestServerFactory(server.TestServerFactory) + serverutils.InitTestClusterFactory(testcluster.TestClusterFactory) + + defer serverutils.TestingSetDefaultTenantSelectionOverride( + base.TestIsForStuffThatShouldWorkWithSecondaryTenantsButDoesntYet(76378), + )() + + os.Exit(m.Run()) +} + +func runExecBuildLogicTest(t *testing.T, file string) { + defer sql.TestingOverrideExplainEnvVersion("CockroachDB execbuilder test version")() + skip.UnderDeadlock(t, "times out and/or hangs") + serverArgs := logictest.TestServerArgs{ + DisableWorkmemRandomization: true, + ForceProductionValues: true, + // Disable the direct scans in order to keep the output of EXPLAIN (VEC) + // deterministic. + DisableDirectColumnarScans: true, + } + logictest.RunLogicTest(t, serverArgs, configIdx, filepath.Join(execBuildLogicTestDir, file)) +} + +// TestLogic_tmp runs any tests that are prefixed with "_", in which a dedicated +// test is not generated for. This allows developers to create and run temporary +// test files that are not checked into the repository, without repeatedly +// regenerating and reverting changes to this file, generated_test.go. +// +// TODO(mgartner): Add file filtering so that individual files can be run, +// instead of all files with the "_" prefix. +func TestLogic_tmp(t *testing.T) { + defer leaktest.AfterTest(t)() + var glob string + glob = filepath.Join(execBuildLogicTestDir, "_*") + serverArgs := logictest.TestServerArgs{ + DisableWorkmemRandomization: true, + } + logictest.RunLogicTests(t, serverArgs, configIdx, glob) +} + +func TestExecBuild_geospatial( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runExecBuildLogicTest(t, "geospatial") +} diff --git a/pkg/sql/sqlitelogictest/tests/local-mixed-24.3/BUILD.bazel b/pkg/sql/sqlitelogictest/tests/local-mixed-24.3/BUILD.bazel new file mode 100644 index 000000000000..868c4f0420a6 --- /dev/null +++ b/pkg/sql/sqlitelogictest/tests/local-mixed-24.3/BUILD.bazel @@ -0,0 +1,28 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_test") + +go_test( + name = "local-mixed-24_3_test", + size = "enormous", + srcs = ["generated_test.go"], + data = [ + "//c-deps:libgeos", # keep + "@com_github_cockroachdb_sqllogictest//:testfiles", # keep + ], + exec_properties = {"test.Pool": "default"}, + shard_count = 48, + tags = ["cpu:1"], + deps = [ + "//pkg/base", + "//pkg/build/bazel", + "//pkg/security/securityassets", + "//pkg/security/securitytest", + "//pkg/server", + "//pkg/sql/logictest", + "//pkg/sql/sqlitelogictest", + "//pkg/testutils/serverutils", + "//pkg/testutils/skip", + "//pkg/testutils/testcluster", + "//pkg/util/leaktest", + "//pkg/util/randutil", + ], +) diff --git a/pkg/sql/sqlitelogictest/tests/local-mixed-24.3/generated_test.go b/pkg/sql/sqlitelogictest/tests/local-mixed-24.3/generated_test.go new file mode 100644 index 000000000000..674939782812 --- /dev/null +++ b/pkg/sql/sqlitelogictest/tests/local-mixed-24.3/generated_test.go @@ -0,0 +1,1434 @@ +// Copyright 2022 The Cockroach Authors. +// +// Use of this software is governed by the CockroachDB Software License +// included in the /LICENSE file. + +// Code generated by generate-logictest, DO NOT EDIT. + +package testlocal_mixed_243 + +import ( + "flag" + "os" + "path/filepath" + "testing" + + "github.com/cockroachdb/cockroach/pkg/base" + "github.com/cockroachdb/cockroach/pkg/build/bazel" + "github.com/cockroachdb/cockroach/pkg/security/securityassets" + "github.com/cockroachdb/cockroach/pkg/security/securitytest" + "github.com/cockroachdb/cockroach/pkg/server" + "github.com/cockroachdb/cockroach/pkg/sql/logictest" + "github.com/cockroachdb/cockroach/pkg/sql/sqlitelogictest" + "github.com/cockroachdb/cockroach/pkg/testutils/serverutils" + "github.com/cockroachdb/cockroach/pkg/testutils/skip" + "github.com/cockroachdb/cockroach/pkg/testutils/testcluster" + "github.com/cockroachdb/cockroach/pkg/util/leaktest" + "github.com/cockroachdb/cockroach/pkg/util/randutil" +) + +const configIdx = 21 + +var sqliteLogicTestDir string + +func init() { +} + +func TestMain(m *testing.M) { + flag.Parse() + if *logictest.Bigtest { + if bazel.BuiltWithBazel() { + var err error + sqliteLogicTestDir, err = bazel.Runfile("external/com_github_cockroachdb_sqllogictest") + if err != nil { + panic(err) + } + } else { + var err error + sqliteLogicTestDir, err = sqlitelogictest.FindLocalLogicTestClone() + if err != nil { + panic(err) + } + } + } + securityassets.SetLoader(securitytest.EmbeddedAssets) + randutil.SeedForTests() + serverutils.InitTestServerFactory(server.TestServerFactory) + serverutils.InitTestClusterFactory(testcluster.TestClusterFactory) + + defer serverutils.TestingSetDefaultTenantSelectionOverride( + base.TestIsForStuffThatShouldWorkWithSecondaryTenantsButDoesntYet(76378), + )() + + os.Exit(m.Run()) +} + +func runSqliteLogicTest(t *testing.T, file string) { + skip.UnderDeadlock(t, "times out and/or hangs") + if !*logictest.Bigtest { + skip.IgnoreLint(t, "-bigtest flag must be specified to run this test") + } + // SQLLite logic tests can be very memory intensive, so we give them larger + // limit than other logic tests get. Also some of the 'delete' files become + // extremely slow when MVCC range tombstones are enabled for point deletes, + // so we disable that. + serverArgs := logictest.TestServerArgs{ + MaxSQLMemoryLimit: 512 << 20, // 512 MiB + DisableUseMVCCRangeTombstonesForPointDeletes: true, + // Some sqlite tests with very low bytes limit value are too slow, so + // ensure 3 KiB lower bound. + BatchBytesLimitLowerBound: 3 << 10, // 3 KiB + } + logictest.RunLogicTest(t, serverArgs, configIdx, filepath.Join(sqliteLogicTestDir, file)) +} + +func TestSqlLiteLogic_testindexbetween1slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/between/1/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexbetween10slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/between/10/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexbetween10slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/between/10/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexbetween10slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/between/10/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexbetween10slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/between/10/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexbetween10slt_good_4_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/between/10/slt_good_4.test") +} + +func TestSqlLiteLogic_testindexbetween10slt_good_5_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/between/10/slt_good_5.test") +} + +func TestSqlLiteLogic_testindexbetween100slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/between/100/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexbetween100slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/between/100/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexbetween100slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/between/100/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexbetween100slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/between/100/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexbetween100slt_good_4_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/between/100/slt_good_4.test") +} + +func TestSqlLiteLogic_testindexbetween1000slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/between/1000/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_10_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_10.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_11_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_11.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_12_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_12.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_13_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_13.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_14_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_14.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_15_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_15.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_16_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_16.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_17_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_17.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_18_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_18.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_19_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_19.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_20_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_20.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_21_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_21.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_22_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_22.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_23_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_23.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_24_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_24.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_25_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_25.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_26_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_26.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_27_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_27.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_28_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_28.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_29_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_29.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_30_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_30.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_31_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_31.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_32_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_32.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_33_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_33.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_34_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_34.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_4_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_4.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_5_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_5.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_6_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_6.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_7_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_7.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_8_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_8.test") +} + +func TestSqlLiteLogic_testindexcommute10slt_good_9_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/10/slt_good_9.test") +} + +func TestSqlLiteLogic_testindexcommute100slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/100/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexcommute100slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/100/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexcommute100slt_good_10_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/100/slt_good_10.test") +} + +func TestSqlLiteLogic_testindexcommute100slt_good_11_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/100/slt_good_11.test") +} + +func TestSqlLiteLogic_testindexcommute100slt_good_12_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/100/slt_good_12.test") +} + +func TestSqlLiteLogic_testindexcommute100slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/100/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexcommute100slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/100/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexcommute100slt_good_4_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/100/slt_good_4.test") +} + +func TestSqlLiteLogic_testindexcommute100slt_good_5_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/100/slt_good_5.test") +} + +func TestSqlLiteLogic_testindexcommute100slt_good_6_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/100/slt_good_6.test") +} + +func TestSqlLiteLogic_testindexcommute100slt_good_7_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/100/slt_good_7.test") +} + +func TestSqlLiteLogic_testindexcommute100slt_good_8_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/100/slt_good_8.test") +} + +func TestSqlLiteLogic_testindexcommute100slt_good_9_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/100/slt_good_9.test") +} + +func TestSqlLiteLogic_testindexcommute1000slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/1000/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexcommute1000slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/1000/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexcommute1000slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/1000/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexcommute1000slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/commute/1000/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexdelete1slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/1/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexdelete10slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/10/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexdelete10slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/10/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexdelete10slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/10/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexdelete10slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/10/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexdelete10slt_good_4_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/10/slt_good_4.test") +} + +func TestSqlLiteLogic_testindexdelete10slt_good_5_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/10/slt_good_5.test") +} + +func TestSqlLiteLogic_testindexdelete100slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/100/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexdelete100slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/100/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexdelete100slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/100/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexdelete100slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/100/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexdelete1000slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/1000/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexdelete1000slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/1000/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexdelete10000slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/delete/10000/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexin10slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/in/10/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexin10slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/in/10/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexin10slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/in/10/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexin10slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/in/10/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexin10slt_good_4_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/in/10/slt_good_4.test") +} + +func TestSqlLiteLogic_testindexin10slt_good_5_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/in/10/slt_good_5.test") +} + +func TestSqlLiteLogic_testindexin100slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/in/100/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexin100slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/in/100/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexin100slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/in/100/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexin100slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/in/100/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexin100slt_good_4_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/in/100/slt_good_4.test") +} + +func TestSqlLiteLogic_testindexin1000slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/in/1000/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexin1000slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/in/1000/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_10_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_10.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_11_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_11.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_12_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_12.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_13_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_13.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_14_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_14.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_15_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_15.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_16_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_16.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_17_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_17.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_18_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_18.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_19_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_19.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_20_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_20.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_21_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_21.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_22_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_22.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_23_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_23.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_24_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_24.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_25_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_25.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_4_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_4.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_5_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_5.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_6_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_6.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_7_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_7.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_8_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_8.test") +} + +func TestSqlLiteLogic_testindexorderby10slt_good_9_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/10/slt_good_9.test") +} + +func TestSqlLiteLogic_testindexorderby100slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/100/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexorderby100slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/100/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexorderby100slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/100/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexorderby100slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/100/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexorderby1000slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby/1000/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_10_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_10.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_11_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_11.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_12_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_12.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_13_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_13.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_14_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_14.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_15_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_15.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_16_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_16.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_17_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_17.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_18_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_18.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_19_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_19.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_20_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_20.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_21_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_21.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_22_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_22.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_23_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_23.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_24_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_24.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_25_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_25.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_26_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_26.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_27_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_27.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_28_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_28.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_29_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_29.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_30_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_30.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_31_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_31.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_32_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_32.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_33_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_33.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_34_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_34.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_35_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_35.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_36_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_36.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_37_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_37.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_38_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_38.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_39_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_39.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_4_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_4.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_5_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_5.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_6_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_6.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_7_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_7.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_8_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_8.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort10slt_good_9_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/10/slt_good_9.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort100slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/100/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort100slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/100/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort100slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/100/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort100slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/100/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort100slt_good_4_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/100/slt_good_4.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort100slt_good_5_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/100/slt_good_5.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort100slt_good_6_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/100/slt_good_6.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort1000slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/1000/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexorderby_nosort1000slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/orderby_nosort/1000/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexview10slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/10/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexview10slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/10/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexview10slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/10/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexview10slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/10/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexview10slt_good_4_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/10/slt_good_4.test") +} + +func TestSqlLiteLogic_testindexview10slt_good_5_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/10/slt_good_5.test") +} + +func TestSqlLiteLogic_testindexview10slt_good_6_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/10/slt_good_6.test") +} + +func TestSqlLiteLogic_testindexview10slt_good_7_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/10/slt_good_7.test") +} + +func TestSqlLiteLogic_testindexview100slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/100/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexview100slt_good_1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/100/slt_good_1.test") +} + +func TestSqlLiteLogic_testindexview100slt_good_2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/100/slt_good_2.test") +} + +func TestSqlLiteLogic_testindexview100slt_good_3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/100/slt_good_3.test") +} + +func TestSqlLiteLogic_testindexview100slt_good_4_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/100/slt_good_4.test") +} + +func TestSqlLiteLogic_testindexview100slt_good_5_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/100/slt_good_5.test") +} + +func TestSqlLiteLogic_testindexview1000slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/1000/slt_good_0.test") +} + +func TestSqlLiteLogic_testindexview10000slt_good_0_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/index/view/10000/slt_good_0.test") +} + +func TestSqlLiteLogic_testselect1_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/select1.test") +} + +func TestSqlLiteLogic_testselect2_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/select2.test") +} + +func TestSqlLiteLogic_testselect3_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/select3.test") +} + +func TestSqlLiteLogic_testselect4_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/select4.test") +} + +func TestSqlLiteLogic_testselect5_test( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runSqliteLogicTest(t, "/test/select5.test") +}