From ea3c48b18bbb6a86906a94115ac7b2952085a0b4 Mon Sep 17 00:00:00 2001 From: Erik Grinaker Date: Thu, 25 Aug 2022 13:49:06 +0000 Subject: [PATCH] sql/logictest: add MVCC range tombstone test configs This patch adds two new test configurations, `fakedist-range-tombstone` and `3node-tenant-range-tombstone`, for the SQL logic tests. These write a single, global MVCC range tombstone across the entire user keyspace during cluster bootstrapping. This should not semantically affect the test data written above it, but will activate MVCC range tombstone code paths in the storage layer for testing. Release justification: non-production code changes Release note: None --- pkg/BUILD.bazel | 12 + .../generated_test.go | 2 +- .../tests/3node-tenant/generated_test.go | 2 +- .../tests/5node/generated_test.go | 2 +- .../fakedist-range-tombstone/BUILD.bazel | 30 + .../generated_test.go | 95 + .../generated_test.go | 2 +- .../generated_test.go | 2 +- .../generated_test.go | 2 +- .../generated_test.go | 2 +- .../generated_test.go | 2 +- .../generated_test.go | 2 +- .../tests/3node-tenant/generated_test.go | 2 +- pkg/kv/kvserver/client_raft_test.go | 33 + pkg/sql/logictest/BUILD.bazel | 2 + pkg/sql/logictest/logic.go | 11 +- .../logictest/logictestbase/logictestbase.go | 23 + .../tests/5node-disk/generated_test.go | 2 +- .../logictest/tests/5node/generated_test.go | 2 +- .../fakedist-range-tombstone/BUILD.bazel | 28 + .../generated_test.go | 2082 +++++++++++++++++ .../local-mixed-22.1-22.2/generated_test.go | 2 +- .../generated_test.go | 2 +- .../generated_test.go | 2 +- .../execbuilder/tests/5node/generated_test.go | 2 +- .../fakedist-range-tombstone/BUILD.bazel | 29 + .../generated_test.go | 89 + .../fakedist-range-tombstone/BUILD.bazel | 29 + .../generated_test.go | 1429 +++++++++++ 29 files changed, 3907 insertions(+), 17 deletions(-) create mode 100644 pkg/ccl/logictestccl/tests/fakedist-range-tombstone/BUILD.bazel create mode 100644 pkg/ccl/logictestccl/tests/fakedist-range-tombstone/generated_test.go create mode 100644 pkg/sql/logictest/tests/fakedist-range-tombstone/BUILD.bazel create mode 100644 pkg/sql/logictest/tests/fakedist-range-tombstone/generated_test.go create mode 100644 pkg/sql/opt/exec/execbuilder/tests/fakedist-range-tombstone/BUILD.bazel create mode 100644 pkg/sql/opt/exec/execbuilder/tests/fakedist-range-tombstone/generated_test.go create mode 100644 pkg/sql/sqlitelogictest/tests/fakedist-range-tombstone/BUILD.bazel create mode 100644 pkg/sql/sqlitelogictest/tests/fakedist-range-tombstone/generated_test.go diff --git a/pkg/BUILD.bazel b/pkg/BUILD.bazel index 2d40d27a41e5..5c42cc5300c4 100644 --- a/pkg/BUILD.bazel +++ b/pkg/BUILD.bazel @@ -41,6 +41,7 @@ ALL_TESTS = [ "//pkg/ccl/logictestccl/tests/3node-tenant:3node-tenant_test", "//pkg/ccl/logictestccl/tests/5node:5node_test", "//pkg/ccl/logictestccl/tests/fakedist-disk:fakedist-disk_test", + "//pkg/ccl/logictestccl/tests/fakedist-range-tombstone:fakedist-range-tombstone_test", "//pkg/ccl/logictestccl/tests/fakedist-vec-off:fakedist-vec-off_test", "//pkg/ccl/logictestccl/tests/fakedist:fakedist_test", "//pkg/ccl/logictestccl/tests/local-vec-off:local-vec-off_test", @@ -357,6 +358,7 @@ ALL_TESTS = [ "//pkg/sql/logictest/tests/5node-disk:5node-disk_test", "//pkg/sql/logictest/tests/5node:5node_test", "//pkg/sql/logictest/tests/fakedist-disk:fakedist-disk_test", + "//pkg/sql/logictest/tests/fakedist-range-tombstone:fakedist-range-tombstone_test", "//pkg/sql/logictest/tests/fakedist-vec-off:fakedist-vec-off_test", "//pkg/sql/logictest/tests/fakedist:fakedist_test", "//pkg/sql/logictest/tests/local-mixed-22.1-22.2:local-mixed-22_1-22_2_test", @@ -374,6 +376,7 @@ ALL_TESTS = [ "//pkg/sql/opt/distribution:distribution_test", "//pkg/sql/opt/exec/execbuilder/tests/5node:5node_test", "//pkg/sql/opt/exec/execbuilder/tests/fakedist-disk:fakedist-disk_test", + "//pkg/sql/opt/exec/execbuilder/tests/fakedist-range-tombstone:fakedist-range-tombstone_test", "//pkg/sql/opt/exec/execbuilder/tests/fakedist-vec-off:fakedist-vec-off_test", "//pkg/sql/opt/exec/execbuilder/tests/fakedist:fakedist_test", "//pkg/sql/opt/exec/execbuilder/tests/local-vec-off:local-vec-off_test", @@ -460,6 +463,7 @@ ALL_TESTS = [ "//pkg/sql/sqlinstance/instanceprovider:instanceprovider_test", "//pkg/sql/sqlinstance/instancestorage:instancestorage_test", "//pkg/sql/sqlitelogictest/tests/fakedist-disk:fakedist-disk_test", + "//pkg/sql/sqlitelogictest/tests/fakedist-range-tombstone:fakedist-range-tombstone_test", "//pkg/sql/sqlitelogictest/tests/fakedist-vec-off:fakedist-vec-off_test", "//pkg/sql/sqlitelogictest/tests/fakedist:fakedist_test", "//pkg/sql/sqlitelogictest/tests/local-vec-off:local-vec-off_test", @@ -685,6 +689,7 @@ GO_TARGETS = [ "//pkg/ccl/logictestccl/tests/3node-tenant:3node-tenant_test", "//pkg/ccl/logictestccl/tests/5node:5node_test", "//pkg/ccl/logictestccl/tests/fakedist-disk:fakedist-disk_test", + "//pkg/ccl/logictestccl/tests/fakedist-range-tombstone:fakedist-range-tombstone_test", "//pkg/ccl/logictestccl/tests/fakedist-vec-off:fakedist-vec-off_test", "//pkg/ccl/logictestccl/tests/fakedist:fakedist_test", "//pkg/ccl/logictestccl/tests/local-vec-off:local-vec-off_test", @@ -1455,6 +1460,7 @@ GO_TARGETS = [ "//pkg/sql/logictest/tests/5node-disk:5node-disk_test", "//pkg/sql/logictest/tests/5node:5node_test", "//pkg/sql/logictest/tests/fakedist-disk:fakedist-disk_test", + "//pkg/sql/logictest/tests/fakedist-range-tombstone:fakedist-range-tombstone_test", "//pkg/sql/logictest/tests/fakedist-vec-off:fakedist-vec-off_test", "//pkg/sql/logictest/tests/fakedist:fakedist_test", "//pkg/sql/logictest/tests/local-mixed-22.1-22.2:local-mixed-22_1-22_2_test", @@ -1481,6 +1487,7 @@ GO_TARGETS = [ "//pkg/sql/opt/distribution:distribution_test", "//pkg/sql/opt/exec/execbuilder/tests/5node:5node_test", "//pkg/sql/opt/exec/execbuilder/tests/fakedist-disk:fakedist-disk_test", + "//pkg/sql/opt/exec/execbuilder/tests/fakedist-range-tombstone:fakedist-range-tombstone_test", "//pkg/sql/opt/exec/execbuilder/tests/fakedist-vec-off:fakedist-vec-off_test", "//pkg/sql/opt/exec/execbuilder/tests/fakedist:fakedist_test", "//pkg/sql/opt/exec/execbuilder/tests/local-vec-off:local-vec-off_test", @@ -1689,6 +1696,7 @@ GO_TARGETS = [ "//pkg/sql/sqlinstance/instancestorage:instancestorage_test", "//pkg/sql/sqlinstance:sqlinstance", "//pkg/sql/sqlitelogictest/tests/fakedist-disk:fakedist-disk_test", + "//pkg/sql/sqlitelogictest/tests/fakedist-range-tombstone:fakedist-range-tombstone_test", "//pkg/sql/sqlitelogictest/tests/fakedist-vec-off:fakedist-vec-off_test", "//pkg/sql/sqlitelogictest/tests/fakedist:fakedist_test", "//pkg/sql/sqlitelogictest/tests/local-vec-off:local-vec-off_test", @@ -2119,6 +2127,7 @@ GET_X_DATA_TARGETS = [ "//pkg/ccl/logictestccl/tests/5node:get_x_data", "//pkg/ccl/logictestccl/tests/fakedist:get_x_data", "//pkg/ccl/logictestccl/tests/fakedist-disk:get_x_data", + "//pkg/ccl/logictestccl/tests/fakedist-range-tombstone:get_x_data", "//pkg/ccl/logictestccl/tests/fakedist-vec-off:get_x_data", "//pkg/ccl/logictestccl/tests/local:get_x_data", "//pkg/ccl/logictestccl/tests/local-vec-off:get_x_data", @@ -2578,6 +2587,7 @@ GET_X_DATA_TARGETS = [ "//pkg/sql/logictest/tests/5node-disk:get_x_data", "//pkg/sql/logictest/tests/fakedist:get_x_data", "//pkg/sql/logictest/tests/fakedist-disk:get_x_data", + "//pkg/sql/logictest/tests/fakedist-range-tombstone:get_x_data", "//pkg/sql/logictest/tests/fakedist-vec-off:get_x_data", "//pkg/sql/logictest/tests/local:get_x_data", "//pkg/sql/logictest/tests/local-mixed-22.1-22.2:get_x_data", @@ -2599,6 +2609,7 @@ GET_X_DATA_TARGETS = [ "//pkg/sql/opt/exec/execbuilder/tests/5node:get_x_data", "//pkg/sql/opt/exec/execbuilder/tests/fakedist:get_x_data", "//pkg/sql/opt/exec/execbuilder/tests/fakedist-disk:get_x_data", + "//pkg/sql/opt/exec/execbuilder/tests/fakedist-range-tombstone:get_x_data", "//pkg/sql/opt/exec/execbuilder/tests/fakedist-vec-off:get_x_data", "//pkg/sql/opt/exec/execbuilder/tests/local:get_x_data", "//pkg/sql/opt/exec/execbuilder/tests/local-vec-off:get_x_data", @@ -2727,6 +2738,7 @@ GET_X_DATA_TARGETS = [ "//pkg/sql/sqlitelogictest:get_x_data", "//pkg/sql/sqlitelogictest/tests/fakedist:get_x_data", "//pkg/sql/sqlitelogictest/tests/fakedist-disk:get_x_data", + "//pkg/sql/sqlitelogictest/tests/fakedist-range-tombstone:get_x_data", "//pkg/sql/sqlitelogictest/tests/fakedist-vec-off:get_x_data", "//pkg/sql/sqlitelogictest/tests/local:get_x_data", "//pkg/sql/sqlitelogictest/tests/local-vec-off:get_x_data", diff --git a/pkg/ccl/logictestccl/tests/3node-tenant-multiregion/generated_test.go b/pkg/ccl/logictestccl/tests/3node-tenant-multiregion/generated_test.go index 18567b8445a1..bbbfa7beadd1 100644 --- a/pkg/ccl/logictestccl/tests/3node-tenant-multiregion/generated_test.go +++ b/pkg/ccl/logictestccl/tests/3node-tenant-multiregion/generated_test.go @@ -30,7 +30,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 10 +const configIdx = 11 var logicTestDir string var execBuildLogicTestDir string diff --git a/pkg/ccl/logictestccl/tests/3node-tenant/generated_test.go b/pkg/ccl/logictestccl/tests/3node-tenant/generated_test.go index eb18c16bbe79..ad31354f47bd 100644 --- a/pkg/ccl/logictestccl/tests/3node-tenant/generated_test.go +++ b/pkg/ccl/logictestccl/tests/3node-tenant/generated_test.go @@ -30,7 +30,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 9 +const configIdx = 10 var logicTestDir string var cclLogicTestDir string diff --git a/pkg/ccl/logictestccl/tests/5node/generated_test.go b/pkg/ccl/logictestccl/tests/5node/generated_test.go index 26596f1ea8a8..f378f2ee1235 100644 --- a/pkg/ccl/logictestccl/tests/5node/generated_test.go +++ b/pkg/ccl/logictestccl/tests/5node/generated_test.go @@ -29,7 +29,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 7 +const configIdx = 8 var cclLogicTestDir string diff --git a/pkg/ccl/logictestccl/tests/fakedist-range-tombstone/BUILD.bazel b/pkg/ccl/logictestccl/tests/fakedist-range-tombstone/BUILD.bazel new file mode 100644 index 000000000000..d892a01ba66d --- /dev/null +++ b/pkg/ccl/logictestccl/tests/fakedist-range-tombstone/BUILD.bazel @@ -0,0 +1,30 @@ +load("//build/bazelutil/unused_checker:unused.bzl", "get_x_data") +load("@io_bazel_rules_go//go:def.bzl", "go_test") + +go_test( + name = "fakedist-range-tombstone_test", + size = "enormous", + srcs = ["generated_test.go"], + data = [ + "//c-deps:libgeos", # keep + "//pkg/ccl/logictestccl:testdata", # keep + ], + shard_count = 3, + tags = ["cpu:2"], + deps = [ + "//pkg/build/bazel", + "//pkg/ccl", + "//pkg/ccl/utilccl", + "//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", + ], +) + +get_x_data(name = "get_x_data") diff --git a/pkg/ccl/logictestccl/tests/fakedist-range-tombstone/generated_test.go b/pkg/ccl/logictestccl/tests/fakedist-range-tombstone/generated_test.go new file mode 100644 index 000000000000..80700d656b9f --- /dev/null +++ b/pkg/ccl/logictestccl/tests/fakedist-range-tombstone/generated_test.go @@ -0,0 +1,95 @@ +// Copyright 2022 The Cockroach Authors. +// +// Licensed as a CockroachDB Enterprise file under the Cockroach Community +// License (the "License"); you may not use this file except in compliance with +// the License. You may obtain a copy of the License at +// +// https://github.com/cockroachdb/cockroach/blob/master/licenses/CCL.txt + +// Code generated by generate-logictest, DO NOT EDIT. + +package testfakedist_range_tombstone + +import ( + "os" + "path/filepath" + "testing" + + "github.com/cockroachdb/cockroach/pkg/build/bazel" + _ "github.com/cockroachdb/cockroach/pkg/ccl" + "github.com/cockroachdb/cockroach/pkg/ccl/utilccl" + "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 = 7 + +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 utilccl.TestingEnableEnterprise()() + securityassets.SetLoader(securitytest.EmbeddedAssets) + randutil.SeedForTests() + serverutils.InitTestServerFactory(server.TestServerFactory) + serverutils.InitTestClusterFactory(testcluster.TestClusterFactory) + 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_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_schema_change_in_txn( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runCCLLogicTest(t, "schema_change_in_txn") +} diff --git a/pkg/ccl/logictestccl/tests/multiregion-15node-5region-3azs/generated_test.go b/pkg/ccl/logictestccl/tests/multiregion-15node-5region-3azs/generated_test.go index 3768a6405ebf..7799d68b9eb9 100644 --- a/pkg/ccl/logictestccl/tests/multiregion-15node-5region-3azs/generated_test.go +++ b/pkg/ccl/logictestccl/tests/multiregion-15node-5region-3azs/generated_test.go @@ -29,7 +29,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 17 +const configIdx = 19 var cclLogicTestDir string diff --git a/pkg/ccl/logictestccl/tests/multiregion-3node-3superlongregions/generated_test.go b/pkg/ccl/logictestccl/tests/multiregion-3node-3superlongregions/generated_test.go index 4aa3c4eb22d5..0bf481da0f87 100644 --- a/pkg/ccl/logictestccl/tests/multiregion-3node-3superlongregions/generated_test.go +++ b/pkg/ccl/logictestccl/tests/multiregion-3node-3superlongregions/generated_test.go @@ -29,7 +29,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 12 +const configIdx = 14 var cclLogicTestDir string diff --git a/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs-no-los/generated_test.go b/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs-no-los/generated_test.go index 8367b3c9b28f..ebd10c213b3c 100644 --- a/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs-no-los/generated_test.go +++ b/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs-no-los/generated_test.go @@ -29,7 +29,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 16 +const configIdx = 18 var cclLogicTestDir string diff --git a/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs-tenant/generated_test.go b/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs-tenant/generated_test.go index 32807c03044b..322aefad35bb 100644 --- a/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs-tenant/generated_test.go +++ b/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs-tenant/generated_test.go @@ -29,7 +29,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 14 +const configIdx = 16 var cclLogicTestDir string diff --git a/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs-vec-off/generated_test.go b/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs-vec-off/generated_test.go index 9dd61bb6dbab..a8689ca02df8 100644 --- a/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs-vec-off/generated_test.go +++ b/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs-vec-off/generated_test.go @@ -29,7 +29,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 15 +const configIdx = 17 var cclLogicTestDir string diff --git a/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs/generated_test.go b/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs/generated_test.go index 565c902c782d..c9e01092f13c 100644 --- a/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs/generated_test.go +++ b/pkg/ccl/logictestccl/tests/multiregion-9node-3region-3azs/generated_test.go @@ -29,7 +29,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 13 +const configIdx = 15 var cclLogicTestDir string diff --git a/pkg/ccl/sqlitelogictestccl/tests/3node-tenant/generated_test.go b/pkg/ccl/sqlitelogictestccl/tests/3node-tenant/generated_test.go index 10eaffc46c61..304dc51b1e0a 100644 --- a/pkg/ccl/sqlitelogictestccl/tests/3node-tenant/generated_test.go +++ b/pkg/ccl/sqlitelogictestccl/tests/3node-tenant/generated_test.go @@ -31,7 +31,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 9 +const configIdx = 10 var sqliteLogicTestDir string diff --git a/pkg/kv/kvserver/client_raft_test.go b/pkg/kv/kvserver/client_raft_test.go index 4a77ab618cdf..cfe460a61fcd 100644 --- a/pkg/kv/kvserver/client_raft_test.go +++ b/pkg/kv/kvserver/client_raft_test.go @@ -80,6 +80,39 @@ func mustGetInt(v *roachpb.Value) int64 { return i } +func TestXXX(t *testing.T) { + defer leaktest.AfterTest(t)() + defer log.Scope(t).Close(t) + + stickyEngineRegistry := server.NewStickyInMemEnginesRegistry() + defer stickyEngineRegistry.CloseAllStickyInMemEngines() + + ctx := context.Background() + tc := testcluster.StartTestCluster(t, 1, + base.TestClusterArgs{ + ReplicationMode: base.ReplicationManual, + ServerArgs: base.TestServerArgs{ + StoreSpecs: []base.StoreSpec{ + { + InMemory: true, + StickyInMemoryEngineID: "1", + }, + }, + Knobs: base.TestingKnobs{ + Server: &server.TestingKnobs{ + StickyEngineRegistry: stickyEngineRegistry, + }, + Store: &kvserver.StoreTestingKnobs{ + GlobalMVCCRangeTombstone: true, + }, + }, + }, + }) + defer tc.Stopper().Stop(ctx) + + time.Sleep(5 * time.Second) +} + // TestStoreRecoverFromEngine verifies that the store recovers all ranges and their contents // after being stopped and recreated. func TestStoreRecoverFromEngine(t *testing.T) { diff --git a/pkg/sql/logictest/BUILD.bazel b/pkg/sql/logictest/BUILD.bazel index aac8d57a4a43..0bcf2d9cae39 100644 --- a/pkg/sql/logictest/BUILD.bazel +++ b/pkg/sql/logictest/BUILD.bazel @@ -29,7 +29,9 @@ go_library( "//pkg/base", "//pkg/cloud/externalconn/providers", "//pkg/clusterversion", + "//pkg/kv/kvclient/rangefeed", "//pkg/kv/kvserver", + "//pkg/kv/kvserver/kvserverbase", "//pkg/roachpb", "//pkg/security/username", "//pkg/server", diff --git a/pkg/sql/logictest/logic.go b/pkg/sql/logictest/logic.go index f97a4c67c93f..a8e68bd2078e 100644 --- a/pkg/sql/logictest/logic.go +++ b/pkg/sql/logictest/logic.go @@ -40,7 +40,9 @@ import ( "github.com/cockroachdb/cockroach/pkg/base" _ "github.com/cockroachdb/cockroach/pkg/cloud/externalconn/providers" // imported to register ExternalConnection providers "github.com/cockroachdb/cockroach/pkg/clusterversion" + "github.com/cockroachdb/cockroach/pkg/kv/kvclient/rangefeed" "github.com/cockroachdb/cockroach/pkg/kv/kvserver" + "github.com/cockroachdb/cockroach/pkg/kv/kvserver/kvserverbase" "github.com/cockroachdb/cockroach/pkg/roachpb" "github.com/cockroachdb/cockroach/pkg/security/username" "github.com/cockroachdb/cockroach/pkg/server" @@ -1197,7 +1199,11 @@ func (t *logicTest) newCluster( Knobs: base.TestingKnobs{ Store: &kvserver.StoreTestingKnobs{ // The consistency queue makes a lot of noisy logs during logic tests. - DisableConsistencyQueue: true, + DisableConsistencyQueue: true, + GlobalMVCCRangeTombstone: t.cfg.GlobalMVCCRangeTombstone, + EvalKnobs: kvserverbase.BatchEvalTestingKnobs{ + DisableInitPutFailOnTombstones: t.cfg.GlobalMVCCRangeTombstone, + }, }, SQLEvalContext: &eval.TestingKnobs{ AssertBinaryExprReturnTypes: true, @@ -1217,6 +1223,9 @@ func (t *logicTest) newCluster( SQLDeclarativeSchemaChanger: &scexec.TestingKnobs{ BeforeStage: corpusCollectionCallback, }, + RangeFeed: rangefeed.TestingKnobs{ + IgnoreOnDeleteRangeError: t.cfg.GlobalMVCCRangeTombstone, + }, }, ClusterName: "testclustername", ExternalIODir: t.sharedIODir, diff --git a/pkg/sql/logictest/logictestbase/logictestbase.go b/pkg/sql/logictest/logictestbase/logictestbase.go index cf8808cfe969..7688edce1051 100644 --- a/pkg/sql/logictest/logictestbase/logictestbase.go +++ b/pkg/sql/logictest/logictestbase/logictestbase.go @@ -85,6 +85,11 @@ type TestClusterConfig struct { // DeclarativeCorpusCollection enables support for collecting corpuses // for the declarative schema changer. DeclarativeCorpusCollection bool + // GlobalMVCCRangeTombstone will write a global MVCC range tombstone across + // the entire user keyspace at the start of the test. Since this is below all + // SQL data, it will not affect results, but it does activate MVCC range + // tombstone code paths in the storage layer for testing. + GlobalMVCCRangeTombstone bool } const threeNodeTenantConfigName = "3node-tenant" @@ -298,6 +303,13 @@ var LogicTestConfigs = []TestClusterConfig{ SQLExecUseDisk: true, SkipShort: true, }, + { + Name: "fakedist-range-tombstone", + NumNodes: 3, + UseFakeSpanResolver: true, + OverrideDistSQLMode: "on", + GlobalMVCCRangeTombstone: true, + }, { Name: "5node", NumNodes: 5, @@ -360,6 +372,15 @@ var LogicTestConfigs = []TestClusterConfig{ }, }, }, + { + Name: "3node-tenant-range-tombstone", + NumNodes: 3, + UseTenant: true, + IsCCLConfig: true, + OverrideDistSQLMode: "on", + DeclarativeCorpusCollection: true, + GlobalMVCCRangeTombstone: true, + }, // Regions and zones below are named deliberately, and contain "-"'s to be reflective // of the naming convention in public clouds. "-"'s are handled differently in SQL // (they're double double quoted) so we explicitly test them here to ensure that @@ -528,6 +549,7 @@ var ( "fakedist", "fakedist-vec-off", "fakedist-disk", + "fakedist-range-tombstone", } // FiveNodeDefaultConfigName is a special alias for all 5 node configs. FiveNodeDefaultConfigName = "5node-default-configs" @@ -543,6 +565,7 @@ var ( ThreeNodeTenantDefaultConfigNames = []string{ "3node-tenant", "3node-tenant-multiregion", + "3node-tenant-range-tombstone", } // DefaultConfig is the default test configuration. DefaultConfig = parseTestConfig(DefaultConfigNames) diff --git a/pkg/sql/logictest/tests/5node-disk/generated_test.go b/pkg/sql/logictest/tests/5node-disk/generated_test.go index 4c3ccfb525ca..45b87f5045c2 100644 --- a/pkg/sql/logictest/tests/5node-disk/generated_test.go +++ b/pkg/sql/logictest/tests/5node-disk/generated_test.go @@ -29,7 +29,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 8 +const configIdx = 9 var logicTestDir string diff --git a/pkg/sql/logictest/tests/5node/generated_test.go b/pkg/sql/logictest/tests/5node/generated_test.go index cce0a684238f..45694646ac19 100644 --- a/pkg/sql/logictest/tests/5node/generated_test.go +++ b/pkg/sql/logictest/tests/5node/generated_test.go @@ -29,7 +29,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 7 +const configIdx = 8 var logicTestDir string diff --git a/pkg/sql/logictest/tests/fakedist-range-tombstone/BUILD.bazel b/pkg/sql/logictest/tests/fakedist-range-tombstone/BUILD.bazel new file mode 100644 index 000000000000..89111f028289 --- /dev/null +++ b/pkg/sql/logictest/tests/fakedist-range-tombstone/BUILD.bazel @@ -0,0 +1,28 @@ +load("//build/bazelutil/unused_checker:unused.bzl", "get_x_data") +load("@io_bazel_rules_go//go:def.bzl", "go_test") + +go_test( + name = "fakedist-range-tombstone_test", + size = "enormous", + srcs = ["generated_test.go"], + data = [ + "//c-deps:libgeos", # keep + "//pkg/sql/logictest:testdata", # keep + ], + shard_count = 16, + tags = ["cpu:2"], + deps = [ + "//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", + ], +) + +get_x_data(name = "get_x_data") diff --git a/pkg/sql/logictest/tests/fakedist-range-tombstone/generated_test.go b/pkg/sql/logictest/tests/fakedist-range-tombstone/generated_test.go new file mode 100644 index 000000000000..9d43dd7ee0cb --- /dev/null +++ b/pkg/sql/logictest/tests/fakedist-range-tombstone/generated_test.go @@ -0,0 +1,2082 @@ +// Copyright 2022 The Cockroach Authors. +// +// Use of this software is governed by the Business Source License +// included in the file licenses/BSL.txt. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0, included in the file +// licenses/APL.txt. + +// Code generated by generate-logictest, DO NOT EDIT. + +package testfakedist_range_tombstone + +import ( + "os" + "path/filepath" + "testing" + + "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 = 7 + +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) + 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_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_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_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_copyfrom( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "copyfrom") +} + +func TestLogic_crdb_internal( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "crdb_internal") +} + +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_as_non_metamorphic( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "create_as_non_metamorphic") +} + +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_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_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_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_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_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_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_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_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_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_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_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_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_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_returning( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "returning") +} + +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_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_retry( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "schema_change_retry") +} + +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_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_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_default_privileges( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_default_privileges") +} + +func TestLogic_show_fingerprints( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_fingerprints") +} + +func TestLogic_show_indexes( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_indexes") +} + +func TestLogic_show_transfer_state( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "show_transfer_state") +} + +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_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_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_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_system_privileges( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "system_privileges") +} + +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_tuple( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "tuple") +} + +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_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_upsert( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "upsert") +} + +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_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_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( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "zone_config") +} + +func TestLogic_zone_config_system_tenant( + t *testing.T, +) { + defer leaktest.AfterTest(t)() + runLogicTest(t, "zone_config_system_tenant") +} diff --git a/pkg/sql/logictest/tests/local-mixed-22.1-22.2/generated_test.go b/pkg/sql/logictest/tests/local-mixed-22.1-22.2/generated_test.go index 56f7418f017d..0bc88247203b 100644 --- a/pkg/sql/logictest/tests/local-mixed-22.1-22.2/generated_test.go +++ b/pkg/sql/logictest/tests/local-mixed-22.1-22.2/generated_test.go @@ -29,7 +29,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 19 +const configIdx = 21 var logicTestDir string diff --git a/pkg/sql/logictest/tests/multiregion-9node-3region-3azs/generated_test.go b/pkg/sql/logictest/tests/multiregion-9node-3region-3azs/generated_test.go index f8913bd27311..84fa6af14c0b 100644 --- a/pkg/sql/logictest/tests/multiregion-9node-3region-3azs/generated_test.go +++ b/pkg/sql/logictest/tests/multiregion-9node-3region-3azs/generated_test.go @@ -29,7 +29,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 13 +const configIdx = 15 var logicTestDir string diff --git a/pkg/sql/logictest/tests/multiregion-invalid-locality/generated_test.go b/pkg/sql/logictest/tests/multiregion-invalid-locality/generated_test.go index 050d7a96050a..cc74847ef0cc 100644 --- a/pkg/sql/logictest/tests/multiregion-invalid-locality/generated_test.go +++ b/pkg/sql/logictest/tests/multiregion-invalid-locality/generated_test.go @@ -29,7 +29,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 11 +const configIdx = 13 var logicTestDir string diff --git a/pkg/sql/opt/exec/execbuilder/tests/5node/generated_test.go b/pkg/sql/opt/exec/execbuilder/tests/5node/generated_test.go index 2dd4eba2d398..65d3ec2d7ed8 100644 --- a/pkg/sql/opt/exec/execbuilder/tests/5node/generated_test.go +++ b/pkg/sql/opt/exec/execbuilder/tests/5node/generated_test.go @@ -30,7 +30,7 @@ import ( "github.com/cockroachdb/cockroach/pkg/util/randutil" ) -const configIdx = 7 +const configIdx = 8 var execBuildLogicTestDir string diff --git a/pkg/sql/opt/exec/execbuilder/tests/fakedist-range-tombstone/BUILD.bazel b/pkg/sql/opt/exec/execbuilder/tests/fakedist-range-tombstone/BUILD.bazel new file mode 100644 index 000000000000..fa6f8deb6d47 --- /dev/null +++ b/pkg/sql/opt/exec/execbuilder/tests/fakedist-range-tombstone/BUILD.bazel @@ -0,0 +1,29 @@ +load("//build/bazelutil/unused_checker:unused.bzl", "get_x_data") +load("@io_bazel_rules_go//go:def.bzl", "go_test") + +go_test( + name = "fakedist-range-tombstone_test", + size = "enormous", + srcs = ["generated_test.go"], + data = [ + "//c-deps:libgeos", # keep + "//pkg/sql/opt/exec/execbuilder:testdata", # keep + ], + shard_count = 1, + tags = ["cpu:2"], + deps = [ + "//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", + ], +) + +get_x_data(name = "get_x_data") diff --git a/pkg/sql/opt/exec/execbuilder/tests/fakedist-range-tombstone/generated_test.go b/pkg/sql/opt/exec/execbuilder/tests/fakedist-range-tombstone/generated_test.go new file mode 100644 index 000000000000..04858acf61e4 --- /dev/null +++ b/pkg/sql/opt/exec/execbuilder/tests/fakedist-range-tombstone/generated_test.go @@ -0,0 +1,89 @@ +// Copyright 2022 The Cockroach Authors. +// +// Use of this software is governed by the Business Source License +// included in the file licenses/BSL.txt. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0, included in the file +// licenses/APL.txt. + +// Code generated by generate-logictest, DO NOT EDIT. + +package testfakedist_range_tombstone + +import ( + "os" + "path/filepath" + "testing" + + "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 = 7 + +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) + 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, + } + 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/fakedist-range-tombstone/BUILD.bazel b/pkg/sql/sqlitelogictest/tests/fakedist-range-tombstone/BUILD.bazel new file mode 100644 index 000000000000..686b33687c4b --- /dev/null +++ b/pkg/sql/sqlitelogictest/tests/fakedist-range-tombstone/BUILD.bazel @@ -0,0 +1,29 @@ +load("//build/bazelutil/unused_checker:unused.bzl", "get_x_data") +load("@io_bazel_rules_go//go:def.bzl", "go_test") + +go_test( + name = "fakedist-range-tombstone_test", + size = "enormous", + srcs = ["generated_test.go"], + data = [ + "//c-deps:libgeos", # keep + "@com_github_cockroachdb_sqllogictest//:testfiles", # keep + ], + shard_count = 16, + tags = ["cpu:2"], + deps = [ + "//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", + ], +) + +get_x_data(name = "get_x_data") diff --git a/pkg/sql/sqlitelogictest/tests/fakedist-range-tombstone/generated_test.go b/pkg/sql/sqlitelogictest/tests/fakedist-range-tombstone/generated_test.go new file mode 100644 index 000000000000..b3f1bfc17fcf --- /dev/null +++ b/pkg/sql/sqlitelogictest/tests/fakedist-range-tombstone/generated_test.go @@ -0,0 +1,1429 @@ +// Copyright 2022 The Cockroach Authors. +// +// Use of this software is governed by the Business Source License +// included in the file licenses/BSL.txt. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0, included in the file +// licenses/APL.txt. + +// Code generated by generate-logictest, DO NOT EDIT. + +package testfakedist_range_tombstone + +import ( + "flag" + "os" + "path/filepath" + "testing" + + "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 = 7 + +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) + 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. + serverArgs := logictest.TestServerArgs{ + MaxSQLMemoryLimit: 512 << 20, // 512 MiB + // TODO(yuzefovich): remove this once the flake in #84022 is fixed. + DisableWorkmemRandomization: true, + } + 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") +}