// Copyright 2020 Dolthub, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package enginetest

import (
	"context"
	"os"
	"regexp"
	"runtime"
	"testing"

	denginetest "github.com/dolthub/dolt/go/libraries/doltcore/sqle/enginetest"
	"github.com/dolthub/go-mysql-server/enginetest"
	"github.com/dolthub/go-mysql-server/enginetest/queries"
	"github.com/dolthub/go-mysql-server/enginetest/scriptgen/setup"
	"github.com/dolthub/go-mysql-server/sql"
	"github.com/dolthub/go-mysql-server/sql/types"
	"github.com/stretchr/testify/require"

	"github.com/dolthub/dolt/go/libraries/doltcore/dtestutils"
	"github.com/dolthub/dolt/go/libraries/doltcore/env"
	"github.com/dolthub/dolt/go/libraries/doltcore/schema/typeinfo"
	"github.com/dolthub/dolt/go/libraries/doltcore/sqle"
	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess"
	"github.com/dolthub/dolt/go/libraries/utils/config"
)

func init() {
	sqle.MinRowsPerPartition = 8
	sqle.MaxRowsPerPartition = 1024
}

func TestQueries(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestQueries(t, h)
}

func TestSingleWriteQuery(t *testing.T) {
	// t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()

	h.Setup(setup.MydbData, setup.AutoincrementData)

	test := queries.WriteQueryTest{
		WriteQuery:          "INSERT INTO auto_increment_tbl (c0) values (44)",
		ExpectedWriteResult: []sql.Row{{types.OkResult{RowsAffected: 1, InsertID: 4}}},
		SelectQuery:         "SELECT * FROM auto_increment_tbl ORDER BY pk",
		ExpectedSelect: []sql.Row{
			{1, 11},
			{2, 22},
			{3, 33},
			{4, 44},
		},
	}

	enginetest.RunWriteQueryTest(t, h, test)
}

func TestSingleQuery(t *testing.T) {
	t.Skip()

	harness := newDoltgresServerHarness(t)
	harness.Setup(setup.SimpleSetup...)
	engine, err := harness.NewEngine(t)
	if err != nil {
		panic(err)
	}

	setupQueries := []string{
		// "create table t1 (pk int primary key, c int);",
		// "insert into t1 values (1,2), (3,4)",
		// "call dolt_add('.')",
		// "set @Commit1 = dolt_commit('-am', 'initial table');",
		// "insert into t1 values (5,6), (7,8)",
		// "set @Commit2 = dolt_commit('-am', 'two more rows');",
	}

	for _, q := range setupQueries {
		enginetest.RunQueryWithContext(t, engine, harness, nil, q)
	}

	// engine.EngineAnalyzer().Debug = true
	// engine.EngineAnalyzer().Verbose = true

	test := queries.QueryTest{
		Query: `show create table mytable`,
		Expected: []sql.Row{
			{"mytable",
				"CREATE TABLE `mytable` (\n" +
					"  `i` bigint NOT NULL,\n" +
					"  `s` varchar(20) NOT NULL COMMENT 'column s',\n" +
					"  PRIMARY KEY (`i`),\n" +
					"  KEY `idx_si` (`s`,`i`),\n" +
					"  KEY `mytable_i_s` (`i`,`s`),\n" +
					"  UNIQUE KEY `mytable_s` (`s`)\n" +
					") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_bin"},
		},
	}

	enginetest.TestQueryWithEngine(t, harness, engine, test)
}

func TestSchemaOverrides(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunSchemaOverridesTest(t, harness)
}

type doltCommitValidator struct{}

var _ enginetest.CustomValueValidator = &doltCommitValidator{}

// TODO: this custom validator is supposed to match only a commit hash, but we extend it to match the formatting
//
//	characters present in the Doltgres response for some calls. We can remove this when we support the syntax
//	`select * from dolt_commit(...)`
var hashRegex = regexp.MustCompile(`^\{?([0-9a-v]{32}).*$`)

// Validate returns true if the value is a valid commit hash.
func (dcv *doltCommitValidator) Validate(val interface{}) (bool, error) {
	hash, ok := val.(string)
	if !ok {
		return false, nil
	}
	return hashRegex.MatchString(hash), nil
}

// CommitHash returns the commit hash from the value, if it is a valid commit hash.
func (dcv *doltCommitValidator) CommitHash(val interface{}) (bool, string) {
	hash, ok := val.(string)
	if !ok {
		return false, ""
	}

	matches := hashRegex.FindStringSubmatch(hash)
	if len(matches) == 0 {
		return false, ""
	}
	return true, matches[1]
}

// Convenience test for debugging a single query. Unskip and set to the desired query.
func TestSingleScript(t *testing.T) {
	t.Skip()

	var scripts = []queries.ScriptTest{}

	for _, script := range scripts {
		func() {
			harness := newDoltgresServerHarness(t)
			defer harness.Close()
			// harness.Setup(setup.MydbData, setup.MytableData)

			engine, err := harness.NewEngine(t)
			if err != nil {
				panic(err)
			}
			engine.EngineAnalyzer().Debug = true
			engine.EngineAnalyzer().Verbose = true

			enginetest.TestScriptWithEngine(t, engine, harness, script)
		}()
	}
}

func TestAutoIncrementTrackerLockMode(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunAutoIncrementTrackerLockModeTest(t, harness)
}

func TestVersionedQueries(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		// MySQL-only `cast(... as signed)` syntax — postgres uses `cast(... as integer)`.
		// These views aren't referenced by the assertions, so dropping them from
		// setup is harmless.
		"cast(RIGHT(s, 1) as signed)",
		// AS OF tests on these complex views; they depend on views we can't create.
		"myview4", "myview5",
		// SHOW CREATE TABLE AS OF — doltgres doesn't yet expose the AS OF clause
		// to SHOW CREATE TABLE (it errors with "at or near 'as'").
		"SHOW CREATE TABLE myhistorytable as of",
		// SHOW TABLES AS OF and DESCRIBE AS OF likewise unsupported.
		"SHOW TABLES AS OF",
		"SHOW TABLES FROM mydb AS OF",
		"DESCRIBE myhistorytable AS OF",
	})
	defer h.Close()

	denginetest.RunVersionedQueriesTest(t, h)
}

func TestAnsiQuotesSqlMode(t *testing.T) {
	t.Skip()
	enginetest.TestAnsiQuotesSqlMode(t, newDoltgresServerHarness(t))
}

// Tests of choosing the correct execution plan independent of result correctness. Mostly useful for confirming that
// the right indexes are being used for joining tables.
func TestQueryPlans(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunQueryTestPlans(t, harness)
}

func TestIntegrationQueryPlans(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t).WithConfigureStats(true)
	defer harness.Close()
	enginetest.TestIntegrationPlans(t, harness)
}

func TestDoltDiffQueryPlans(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t).WithParallelism(2) // want Exchange nodes
	denginetest.RunDoltDiffQueryPlansTest(t, harness)
}

func TestBranchPlans(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunBranchPlanTests(t, harness)
}

func TestQueryErrors(t *testing.T) {
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestQueryErrors(t, h)
}

func TestInfoSchema(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunInfoSchemaTests(t, h)
}

func TestColumnAliases(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"SELECT s as Date, SUM(i) TimeStamp FROM mytable group by 1 order by 2", // ERROR: at or near "timestamp": syntax error
		"SELECT 1 as a, (select a) as b from dual",                              // table not found: dual
	})
	defer h.Close()
	enginetest.TestColumnAliases(t, h)
}

func TestOrderByGroupBy(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"Group by with decimal columns", // syntax error
		"Validation for use of non-aggregated columns with implicit grouping of all rows", // bad error matching
		"group by with any_value()",   // @@ vars not supported
		"group by with strict errors", // @@ vars not supported
	})
	defer h.Close()
	enginetest.TestOrderByGroupBy(t, h)
}

func TestAmbiguousColumnResolution(t *testing.T) {
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestAmbiguousColumnResolution(t, h)
}

func TestInsertInto(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"with t (i,f) as (select 4,'fourth row' from dual) insert into mytable select i,f from t",                                                 // WITH unsupported syntax
		"with recursive t (i,f) as (select 4,4 from dual union all select i + 1, i + 1 from t where i < 5) insert into mytable select i,f from t", // WITH unsupported syntax
		"issue 6675: on duplicate rearranged getfield indexes from select source",                                                                 // panic
		"Insert on duplicate key references table in subquery",                                                                                    // bad translation?
		"Insert on duplicate key references table in aliased subquery",                                                                            // bad translation?
		"Insert on duplicate key references table in cte",                                                                                         // CTE not supported
		"insert on duplicate key with incorrect row alias",                                                                                        // column "c" could not be found in any table in scope
		"insert on duplicate key update errors",                                                                                                   // failing
		"INSERT INTO ... SELECT with TEXT types",                                                                                                  // typecasts needed
	})
	defer h.Close()
	enginetest.TestInsertInto(t, h)
}

func TestInsertIgnoreInto(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"Test that INSERT IGNORE properly addresses data conversion", // postgres strict typing rejects MySQL coercions
		"Insert Ignore works correctly with ON DUPLICATE UPDATE",     // postgres strict typing rejects MySQL coercions
		"issue 8611: insert ignore on enum type column",              // enums not supported
	})
	defer h.Close()
	enginetest.TestInsertIgnoreInto(t, h)
}

func TestInsertDuplicateKeyKeyless(t *testing.T) {
	enginetest.TestInsertDuplicateKeyKeyless(t, newDoltgresServerHarness(t))
}

func TestIgnoreIntoWithDuplicateUniqueKeyKeyless(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"UPDATE IGNORE keyless tables and secondary indexes", // UPDATE IGNORE rewrite doesn't perform the actual update
	})
	defer h.Close()
	enginetest.TestIgnoreIntoWithDuplicateUniqueKeyKeyless(t, h)
}

func TestInsertIntoErrors(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunInsertIntoErrorsTest(t, h)
}

func TestGeneratedColumns(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunGeneratedColumnTests(t, harness)
}

func TestGeneratedColumnPlans(t *testing.T) {
	t.Skip()
	enginetest.TestGeneratedColumnPlans(t, newDoltgresServerHarness(t))
}

func TestSpatialQueries(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestSpatialQueries(t, h)
}

func TestReplaceInto(t *testing.T) {
	// REPLACE INTO is rewritten to INSERT ... ON CONFLICT DO UPDATE in the
	// converter. Two classes of test still fail:
	//   - VALUES form with no column list (e.g. `REPLACE INTO t VALUES (...)`):
	//     the converter needs the column list to build the SET clause and bails.
	//   - Replacing a row with identical values: postgres/MySQL ON DUPLICATE KEY
	//     UPDATE reports 0 rows affected when the update is a no-op, but MySQL
	//     REPLACE INTO reports 2 (DELETE + INSERT). These are real semantic
	//     differences; we'd need to override the rowcount to make them match.
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"REPLACE INTO mytable VALUES (1, 'first row')",      // no-column REPLACE; bails to raw syntax
		"REPLACE INTO mytable VALUES (1, 'new row same i')", // no-column REPLACE; bails to raw syntax
		"REPLACE INTO mytable VALUES (999, 'x')",            // no-column REPLACE; bails to raw syntax
		"REPLACE INTO mytable SET i = 1, s = 'first row'",   // no-op update reports 0 rows, expected 2
	})
	defer h.Close()
	enginetest.TestReplaceInto(t, h)
}

func TestReplaceIntoErrors(t *testing.T) {
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestReplaceIntoErrors(t, h)
}

func TestUpdate(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"UPDATE mytable SET s = _binary 'updated' WHERE i = 3;",         // _binary not supported
		"UPDATE mytable SET s = 'updated' ORDER BY i LIMIT 1 OFFSET 1;", // offset not supported (limit isn't selected in vanilla postgres but is in the cockroach grammar)
		// TODO: Postgres supports update joins but with a very different syntax, and some join types are not supported
		`UPDATE one_pk INNER JOIN two_pk on one_pk.pk = two_pk.pk1 SET two_pk.c1 = two_pk.c1 + 1`,
		"UPDATE mytable INNER JOIN one_pk ON mytable.i = one_pk.c5 SET mytable.i = mytable.i * 10",
		`UPDATE one_pk INNER JOIN two_pk on one_pk.pk = two_pk.pk1 INNER JOIN othertable on othertable.i2 = two_pk.pk2 SET one_pk.c1 = one_pk.c1 + 1`,
		`UPDATE one_pk INNER JOIN (SELECT * FROM two_pk order by pk1, pk2) as t2 on one_pk.pk = t2.pk1 SET one_pk.c1 = t2.c1 + 1 where one_pk.pk < 1`,
		`UPDATE one_pk INNER JOIN two_pk on one_pk.pk = two_pk.pk1 SET one_pk.c1 = one_pk.c1 + 1`,
		`update mytable h join mytable on h.i = mytable.i and h.s <> mytable.s set h.i = mytable.i+1;`,
		`UPDATE othertable CROSS JOIN tabletest set othertable.i2 = othertable.i2 * 10`,                                                                                              // cross join
		`UPDATE tabletest cross join tabletest as t2 set tabletest.i = tabletest.i * 10`,                                                                                             // cross join
		`UPDATE othertable cross join tabletest set tabletest.i = tabletest.i * 10`,                                                                                                  // cross join
		`UPDATE one_pk INNER JOIN two_pk on one_pk.pk = two_pk.pk1 INNER JOIN two_pk a1 on one_pk.pk = two_pk.pk2 SET two_pk.c1 = two_pk.c1 + 1`,                                     // cross join
		`UPDATE othertable INNER JOIN tabletest on othertable.i2=3 and tabletest.i=3 SET othertable.s2 = 'fourth'`,                                                                   // cross join
		`UPDATE tabletest cross join tabletest as t2 set t2.i = t2.i * 10`,                                                                                                           // cross join
		`UPDATE othertable LEFT JOIN tabletest on othertable.i2=3 and tabletest.i=3 SET othertable.s2 = 'fourth'`,                                                                    // left join
		`UPDATE othertable LEFT JOIN tabletest on othertable.i2=3 and tabletest.i=3 SET tabletest.s = 'fourth row', tabletest.i = tabletest.i + 1`,                                   // left join
		`UPDATE othertable LEFT JOIN tabletest t3 on othertable.i2=3 and t3.i=3 SET t3.s = 'fourth row', t3.i = t3.i + 1`,                                                            // left join
		`UPDATE othertable LEFT JOIN tabletest on othertable.i2=3 and tabletest.i=3 LEFT JOIN one_pk on othertable.i2 = one_pk.pk SET one_pk.c1 = one_pk.c1 + 1`,                     // left join
		`UPDATE othertable LEFT JOIN tabletest on othertable.i2=3 and tabletest.i=3 LEFT JOIN one_pk on othertable.i2 = one_pk.pk SET one_pk.c1 = one_pk.c1 + 1 where one_pk.pk > 4`, // left join
		`UPDATE othertable LEFT JOIN tabletest on othertable.i2=3 and tabletest.i=3 LEFT JOIN one_pk on othertable.i2 = 1 and one_pk.pk = 1 SET one_pk.c1 = one_pk.c1 + 1`,           // left join
		`UPDATE othertable RIGHT JOIN tabletest on othertable.i2=3 and tabletest.i=3 SET othertable.s2 = 'fourth'`,                                                                   // right join
		`UPDATE othertable RIGHT JOIN tabletest on othertable.i2=3 and tabletest.i=3 SET othertable.i2 = othertable.i2 + 1`,                                                          // right join
		`UPDATE othertable LEFT JOIN tabletest on othertable.i2=tabletest.i RIGHT JOIN one_pk on othertable.i2 = 1 and one_pk.pk = 1 SET tabletest.s = 'updated';`,                   // right join
		`UPDATE IGNORE one_pk INNER JOIN two_pk on one_pk.pk = two_pk.pk1 SET two_pk.c1 = two_pk.c1 + 1`,
		`UPDATE IGNORE one_pk JOIN one_pk one_pk2 on one_pk.pk = one_pk2.pk SET one_pk.pk = 10`,
		`with t (n) as (select (1) from dual) UPDATE mytable set s = concat('updated ', i) where i in (select n from t)`, // with not supported
		`with recursive t (n) as (select (1) from dual union all select n + 1 from t where n < 2) UPDATE mytable set s = concat('updated ', i) where i in (select n from t)`,
	})
	defer h.Close()
	enginetest.TestUpdate(t, h)
}

func TestUpdateErrors(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"try updating string that is too long",  // works but error message doesn't match
		"UPDATE mytable SET s = 'hi' LIMIT -1;", // unsupported syntax
	})
	defer h.Close()
	enginetest.TestUpdateErrors(t, h)
}

func TestDeleteFrom(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"DELETE FROM mytable ORDER BY i DESC LIMIT 1 OFFSET 1;", // offset is unsupported syntax
		"with t (n) as (select (1) from dual) delete from mytable where i in (select n from t)",
		"with recursive t (n) as (select (1) from dual union all select n + 1 from t where n < 2) delete from mytable where i in (select n from t)",
	})
	defer h.Close()

	// We've inlined part of engineTest.TestDeleteFrom here because that method tests many queries for join deletions
	// that would be tedious to write out as skips
	h.Setup(setup.MydbData, setup.MytableData, setup.TabletestData)
	t.Run("Delete from single table", func(t *testing.T) {
		for _, tt := range queries.DeleteTests {
			enginetest.RunWriteQueryTest(t, h, tt)
		}
	})
}

func TestDeleteFromErrors(t *testing.T) {
	h := newDoltgresServerHarness(t)
	defer h.Close()

	// These tests are overspecified to mysql-specific errors and include some syntax we don't support, so we redefine
	// the subset we're interested in checking here
	h.Setup(setup.MydbData, setup.MytableData, setup.TabletestData)
	deleteScripts := []queries.ScriptTest{
		{
			Name: "DELETE FROM error cases",
			Assertions: []queries.ScriptTestAssertion{
				{
					Query:          "DELETE FROM invalidtable WHERE x < 1;",
					ExpectedErrStr: "table not found: invalidtable",
				},
				{
					Query:          "DELETE FROM mytable WHERE z = 'dne';",
					ExpectedErrStr: "column \"z\" could not be found in any table in scope",
				},
				{
					Query:          "DELETE FROM mytable LIMIT -1;",
					ExpectedErrStr: "LIMIT must be greater than or equal to 0",
				},
				{
					Query:          "DELETE mytable WHERE i = 1;",
					ExpectedErrStr: "syntax error",
				},
				{
					Query:          "DELETE FROM (SELECT * FROM mytable) mytable WHERE i = 1;",
					ExpectedErrStr: "syntax error",
				},
			},
		},
	}
	for _, tt := range deleteScripts {
		enginetest.TestScript(t, h, tt)
	}
}

func TestSpatialDelete(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestSpatialDelete(t, h)
}

func TestSpatialScripts(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestSpatialScripts(t, h)
}

func TestSpatialIndexScripts(t *testing.T) {
	t.Skip()
	enginetest.TestSpatialIndexScripts(t, newDoltgresServerHarness(t))
}

func TestSpatialIndexPlans(t *testing.T) {
	t.Skip()
	enginetest.TestSpatialIndexPlans(t, newDoltgresServerHarness(t))
}

func TestTruncate(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestTruncate(t, h)
}

func TestConvert(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestConvertPrepared(t, h)
}

func TestScripts(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"can't create table with same name as existing view",      // Doltgres needs to return a different error message
		"filter pushdown through join uppercase name",             // syntax error (join without on)
		"issue 7958, update join uppercase table name validation", // update join syntax not supported
		"Dolt issue 7957, update join matched rows",               // update join syntax not supported
		"update join with update trigger",                         // update join syntax not supported (also catches with-trigger variants by substring)
		"WITH RECURSIVE\n" +
			"    rt (foo) AS (\n" +
			"        SELECT 1 as foo\n" +
			"        UNION ALL\n" +
			"        SELECT foo + 1 as foo FROM rt WHERE foo < 5\n" +
			"    ),\n" +
			"        ladder (depth, foo) AS (\n" +
			"        SELECT 1 as depth, NULL as foo from rt\n" +
			"        UNION ALL\n" +
			"        SELECT ladder.depth + 1 as depth, rt.foo\n" +
			"        FROM ladder JOIN rt WHERE ladder.foo = rt.foo\n" +
			"    )\n" +
			"SELECT * FROM ladder;", // syntax error
		"CREATE TABLE SELECT Queries", // ERROR: TableCopier only accepts CreateTable or TableNode as the destination
		"db1.``.i > 0",                // Multi-db Aliasing: MySQL-only empty-backtick ref
		"join db2.t2 order by",        // Multi-db Aliasing: MySQL implicit-cross-join (no ON)
		"join db2.t2 group by",        // Multi-db Aliasing: MySQL implicit-cross-join (no ON)
		"join db2.t1 b order by a.i",  // Multi-db Aliasing: MySQL implicit-cross-join (no ON)
		// "Simple Update Join test that manipulates two tables",
		// "Partial indexes are used and return the expected result",
		// "Multiple indexes on the same columns in a different order",
		"Ensure proper DECIMAL support (found by fuzzer)", // unsupported type: SET
		// "Ensure scale is not rounded when inserting to DECIMAL type through float64",
		"Show create table with various keys and constraints",                                                     // FK adds explicit ON DELETE/UPDATE RESTRICT; CHECK constraints leak backticks; timestamp(6) loses precision
		"show create table with duplicate primary key",                                                            // auto-generated constraint names differ
		"recreate primary key rebuilds secondary indexes",                                                         // currently no way to drop primary key in doltgres
		"Handle hex number to binary conversion",                                                                  // ERROR: can't convert 0x7ED0599B to decimal: exponent is not numeric
		"join index lookups do not handle filters",                                                                // need a different join syntax (no ON clause not supported in postgres)
		"arithmetic bit operations on int, float and decimal types",                                               // the power operator is not yet supported
		"INSERT IGNORE throws an error when json is badly formatted",                                              // error messages don't match
		"identical expressions over different windows should produce different results",                           // ERROR: integer: unhandled type: float64
		"windows without ORDER BY should be treated as RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING", // ERROR: integer: unhandled type: float64
		"division and int division operation on negative, small and big value for decimal type column of table",   // numeric keys broken
		"update columns with default",                                                                             // broken, see repro in update_test.go
		"select count(*) from t where (f in (null, cast(0.8 as float)));",                                         // incorrect result, needs a fix
		"update with left join with some missing rows",                                                            // need to translate update joins
		"preserve now()",          // harness error
		"binary type primary key", // ERROR: blob/text column 'b' used in key specification without a key length
		"varbinary primary key",   // ERROR: blob/text column 'b' used in key specification without a key length
		"insert into t1 (a, b) values ('1234567890', '12345')",                // different error message
		"insert into t2 (a, b) values ('1234567890', '12345')",                // different error message
		"invalid utf8 encoding strings",                                       // need to investigate why some strings aren't giving errors, might be a harness error
		"mismatched collation using hash in tuples",                           // ERROR: plan is not resolved because of node '*plan.Project'
		"validate_password_strength and validate_password.length",             // unsupported
		"validate_password_strength and validate_password.number_count",       // unsupported
		"validate_password_strength and validate_password.mixed_case_count",   // unsupported
		"validate_password_strength and validate_password.special_char_count", // unsupported
		"coalesce with system types",                                          // unsupported
		"histogram bucket merging error for implementor buckets",              // unsupported "with recursive" syntax
		"varchar primary key",                                                 // literal values longer than the key length returns incorrect results for some queries
		"can't create view with same name as existing table",                  // different error message
	})
	defer h.Close()
	enginetest.TestScripts(t, h)
}

func TestJoinOps(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestJoinOps(t, h, enginetest.DefaultJoinOpTests)
}

func TestJoinPlanning(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t).WithConfigureStats(true)
	defer h.Close()
	enginetest.TestJoinPlanning(t, h)
}

func TestJoinQueries(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestJoinQueries(t, h)
}

// TestJSONTableQueries runs the canonical test queries against a single threaded index enabled harness.
func TestJSONTableQueries(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestJSONTableQueries(t, h)
}

// TestJSONTableScripts runs the canonical test queries against a single threaded index enabled harness.
func TestJSONTableScripts(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestJSONTableScripts(t, h)
}

func TestUserAuthentication(t *testing.T) {
	t.Skip("Unexpected panic, need to fix")
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestUserAuthentication(t, h)
}

func TestComplexIndexQueries(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestComplexIndexQueries(t, h)
}

func TestCreateTable(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestCreateTable(t, h)
}

func TestRowLimit(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestRowLimit(t, h)
}

func TestBranchDdl(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunBranchDdlTest(t, h)
}

func TestPkOrdinalsDDL(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestPkOrdinalsDDL(t, h)
}

func TestPkOrdinalsDML(t *testing.T) {
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestPkOrdinalsDML(t, h)
}

func TestDropTable(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestDropTable(t, h)
}

func TestRenameTable(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestRenameTable(t, h)
}

func TestRenameColumn(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestRenameColumn(t, h)
}

func TestAddColumn(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestAddColumn(t, h)
}

func TestModifyColumn(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestModifyColumn(t, h)
}

func TestDropColumn(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestDropColumn(t, h)
}

func TestCreateDatabase(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestCreateDatabase(t, h)
}

func TestBlobs(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestBlobs(t, h)
}

func TestIndexes(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	defer harness.Close()
	enginetest.TestIndexes(t, harness)
}

func TestIndexedExpressions(t *testing.T) {
	harness := newDoltgresServerHarness(t)
	defer harness.Close()
	enginetest.TestIndexedExpressions(t, harness)
}

func TestIndexPrefix(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunIndexPrefixTest(t, harness)
}

func TestBigBlobs(t *testing.T) {
	t.Skip()

	h := newDoltgresServerHarness(t)
	denginetest.RunBigBlobsTest(t, h)
}

func TestDropDatabase(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunDropEngineTest(t, h)
}

func TestCreateForeignKeys(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestCreateForeignKeys(t, h)
}

func TestDropForeignKeys(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestDropForeignKeys(t, h)
}

func TestForeignKeys(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestForeignKeys(t, h)
}

func TestForeignKeyBranches(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunForeignKeyBranchesTest(t, h)
}

func TestFulltextIndexes(t *testing.T) {
	t.Skip()
	if runtime.GOOS == "windows" && os.Getenv("CI") != "" {
		t.Skip("For some reason, this is flaky only on Windows CI.")
	}
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestFulltextIndexes(t, h)
}

func TestCreateCheckConstraints(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestCreateCheckConstraints(t, h)
}

func TestChecksOnInsert(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestChecksOnInsert(t, h)
}

func TestChecksOnUpdate(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestChecksOnUpdate(t, h)
}

func TestDisallowedCheckConstraints(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestDisallowedCheckConstraints(t, h)
}

func TestDropCheckConstraints(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestDropCheckConstraints(t, h)
}

func TestReadOnly(t *testing.T) {
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestReadOnly(t, h, false /* testStoredProcedures */)
}

func TestViews(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestViews(t, h)
}

func TestBranchViews(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunBranchViewsTest(t, h)
}

func TestVersionedViews(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunVersionedViewsTest(t, h)
}

func TestWindowFunctions(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestWindowFunctions(t, h)
}

func TestWindowRowFrames(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestWindowRowFrames(t, h)
}

func TestWindowRangeFrames(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestWindowRangeFrames(t, h)
}

func TestNamedWindows(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestNamedWindows(t, h)
}

func TestNaturalJoin(t *testing.T) {
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestNaturalJoin(t, h)
}

func TestNaturalJoinEqual(t *testing.T) {
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestNaturalJoinEqual(t, h)
}

func TestNaturalJoinDisjoint(t *testing.T) {
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestNaturalJoinEqual(t, h)
}

func TestInnerNestedInNaturalJoins(t *testing.T) {
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestInnerNestedInNaturalJoins(t, h)
}

func TestColumnDefaults(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestColumnDefaults(t, h)
}

func TestOnUpdateExprScripts(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestOnUpdateExprScripts(t, h)
}

func TestAlterTable(t *testing.T) {
	t.Skip()
	// This is a newly added test in GMS that dolt doesn't support yet
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{"ALTER TABLE t42 ADD COLUMN s varchar(20), drop check check1"})
	defer h.Close()
	enginetest.TestAlterTable(t, h)
}

func TestVariables(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunVariableTest(t, h)
}

func TestVariableErrors(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestVariableErrors(t, h)
}

func TestLoadData(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestLoadData(t, h)
}

func TestLoadDataErrors(t *testing.T) {
	t.Skip()
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestLoadDataErrors(t, h)
}

func TestSelectIntoFile(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestSelectIntoFile(t, h)
}

func TestJsonScripts(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	skippedTests := []string{
		"round-trip into table", // The current Dolt JSON format does not preserve decimals and unsigneds in JSON.
	}
	// TODO: fix this, use a skipping harness
	enginetest.TestJsonScripts(t, h, skippedTests)
}

func TestTriggers(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestTriggers(t, h)
}

func TestRollbackTriggers(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestRollbackTriggers(t, h)
}

func TestStoredProcedures(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunStoredProceduresTest(t, h)
}

func TestDoltStoredProcedures(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunDoltStoredProceduresTest(t, h)
}

func TestEvents(t *testing.T) {
	t.Skip()
	doltHarness := newDoltgresServerHarness(t)
	defer doltHarness.Close()
	enginetest.TestEvents(t, doltHarness)
}

func TestCallAsOf(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunCallAsOfTest(t, h)
}

func TestLargeJsonObjects(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunLargeJsonObjectsTest(t, harness)
}

func TestTransactions(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunTransactionTests(t, h, false)
}

func TestBranchTransactions(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunBranchTransactionTest(t, h)
}

func TestMultiDbTransactions(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunMultiDbTransactionsTest(t, h)
}

func TestConcurrentTransactions(t *testing.T) {
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestConcurrentTransactions(t, h)
}

func TestDoltScripts(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunDoltScriptsTest(t, harness)
}

func TestDoltTempTableScripts(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunDoltTempTableScripts(t, harness)
}

func TestDoltRevisionDbScripts(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunDoltRevisionDbScriptsTest(t, h)
}

func TestDoltDdlScripts(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunDoltDdlScripts(t, harness)
}

func TestBrokenDdlScripts(t *testing.T) {
	t.Skip()
	for _, script := range denginetest.BrokenDDLScripts {
		t.Skip(script.Name)
	}
}

func TestDescribeTableAsOf(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestScript(t, h, denginetest.DescribeTableAsOfScriptTest)
}

func TestShowCreateTable(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		// These scripts call dolt_commit_hash_out(@Commit1, ...). Passing a
		// user variable to dolt_commit_hash_out via the converter's
		// current_setting() shim hits an unrelated unsupported-operator
		// path. Unskip once that lands.
		"Show create table as of",
		"Show create table as of with FKs",
	})
	denginetest.RunShowCreateTableTests(t, h)
}

func TestViewsWithAsOf(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestScript(t, h, denginetest.ViewsWithAsOfScriptTest)
}

func TestDoltMerge(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"dolt_preview_merge_conflicts_summary(", // returns schema qualified table names
		"CALL DOLT_MERGE with schema conflicts can be correctly resolved using dolt_conflicts_resolve when autocommit is off", // alter table
		"merge conflicts prevent new branch creation",                       // different error message
		"Drop and add primary key on two branches converges to same schema", // alter table
		"insert two tables with the same name and different schema",
		"dropping constraint from one branch drops from both",                                                            // alter table (also catches the no-checkout variant)
		"merge with new triggers defined",                                                                                // triggers
		"try to merge a nullable field into a non-null column",                                                           // alter table
		"merge fulltext with renamed table",                                                                              // alter table
		"select * from dolt_status",                                                                                      // table_name column includes schema name,
		"dolt_merge() (3way) works with no auto increment overlap",                                                       // sequencing doesn't work globally after merge, need to decide product behavior
		"dolt_merge() (3way) with a gap in an auto increment key",                                                        // sequencing doesn't work globally after merge, need to decide product behavior
		"dolt_merge() with a gap in an auto increment key",                                                               // unsupported insert statements (need to call next_val, not insert NULL)
		"Merge does not panic when FK is dropped and re-added on one branch and child has composite PK with mixed types", // different foreign key syntax
		"three-way merge of table with vector index",                                                                     // MySQL VECTOR type has no Postgres equivalent
		"dolt_conflicts_resolve keeps vector index consistent with resolved rows",                                        // MySQL VECTOR type has no Postgres equivalent
	})
	denginetest.RunDoltMergeTests(t, h)
}

func TestDoltRebase(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunDoltRebaseTests(t, h)
}

func TestDoltRevert(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"dolt_revert() respects dolt_ignore",                     // ERROR: INSERT: non-Doltgres type found in destination: text
		"dolt_revert() automatically resolves some conflicts",    // panic: interface conversion: sql.Type is types.VarCharType, not types.StringType
		"select count(*) from dolt_log;",                         // Doltgres creates an additional commit that Dolt doesn't have
		"dolt_revert() --continue: ignored table in working set", // ERROR: ASSIGNMENT_CAST: target is of type boolean but expression is of type integer: 1
	})
	denginetest.RunDoltRevertTests(t, h)
}

func TestDoltAutoIncrement(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunDoltAutoIncrementTests(t, h)
}

func TestDoltConflictsTableNameTable(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"dolt_preview_merge_conflicts_summary(", // returns schema qualified table names
		"Provides a dolt_conflicts_id",          // relies on user vars
		"Updating our cols after schema change", // alter table
	})
	denginetest.RunDoltConflictsTableNameTableTests(t, h)
}

// tests new format behavior for keyless merges that create CVs and conflicts
func TestKeylessDoltMergeCVsAndConflicts(t *testing.T) {
	h := newDoltgresServerHarness(t)
	denginetest.RunKeylessDoltMergeCVsAndConflictsTests(t, h)
}

// eventually this will be part of TestDoltMerge
func TestDoltMergeArtifacts(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"conflicts of different schemas can't coexist",                                  // alter table
		"violations with an older commit hash are overwritten if the value is the same", // nothing to commit?
		"regression test for bad column ordering in schema",                             // enum not supported in test harness
		"schema conflicts return an error when autocommit is enabled",                   // problems detecting autocommit for business logic
		"merge error lists all constraint violations when table has multiple violations",
	})
	denginetest.RunDoltMergeArtifacts(t, h)
}

func TestDoltReset(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"select * from dolt_status",                    // table_name column includes schema name
		"SELECT pk, v FROM t AS OF STAGED ORDER BY pk", // AS OF STAGED requires quoting in Postgres
		"SELECT pk FROM t AS OF STAGED ORDER BY pk",    // AS OF STAGED requires quoting in Postgres
	})
	denginetest.RunDoltResetTest(t, h)
}

func TestDoltGC(t *testing.T) {
	t.Skip()
	for _, script := range denginetest.DoltGC {
		func() {
			h := newDoltgresServerHarness(t)
			defer h.Close()
			enginetest.TestScript(t, h, script)
		}()
	}
}

func TestDoltCheckout(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"branch last checked out is deleted",
		"Using non-existent refs",
		"read-only databases", // read-only not yet implemented in harness
		"Checkout tables from commit",
		"dolt_checkout with tracking branch and table with same name", // UseLocalFileSystem did not create remote dir
	})
	denginetest.RunDoltCheckoutTests(t, h)
}

func TestDoltBranch(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"Create branch from startpoint",  // missing SET @var syntax
		"Join same table at two commits", // implicit cross-joins (no ON clause) unsupported in postgres
	})

	denginetest.RunDoltBranchTests(t, h)
}

func TestDoltTag(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		// dolt's initialization is different which results in a different user name for the tagger,
		// should fix the harness to match
		"SELECT tag_name, IF(CHAR_LENGTH(tag_hash) < 0, NULL, 'not null'), tagger, email, IF(date IS NULL, NULL, 'not null'), message from dolt_tags",
	})
	denginetest.RunDoltTagTests(t, h)
}

func TestDoltRemote(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunDoltRemoteTests(t, h)
}

func TestDoltUndrop(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunDoltUndropTests(t, h)
}

func TestBrokenSystemTableQueries(t *testing.T) {
	t.Skip()

	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.RunQueryTests(t, h, denginetest.BrokenSystemTableQueries)
}

func TestHistorySystemTable(t *testing.T) {
	harness := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"explain",                       // not supported
		"select message from dolt_log",  // doltgres setup has extra commits
		"dolt_history table with enums", // enums
		"can sort by dolt_log.commit",   // more commits
	}).WithParallelism(2)
	denginetest.RunHistorySystemTableTests(t, harness)
}

func TestUnscopedDiffSystemTable(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunUnscopedDiffSystemTableTests(t, h)
}

func TestColumnDiffSystemTable(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunColumnDiffSystemTableTests(t, h)
}

func TestStatBranchTests(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunStatBranchTests(t, harness)
}

func TestDiffTableFunction(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunDiffTableFunctionTests(t, harness)
}

func TestDiffStatTableFunction(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunDiffStatTableFunctionTests(t, harness)
}

func TestDiffSummaryTableFunction(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunDiffSummaryTableFunctionTests(t, harness)
}

func TestPatchTableFunction(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunDoltPatchTableFunctionTests(t, harness)
}

func TestLogTableFunction(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunLogTableFunctionTests(t, harness)
}

func TestDoltReflog(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunDoltReflogTests(t, harness)
}

func TestCommitDiffSystemTable(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunCommitDiffSystemTableTests(t, harness)
}

func TestDiffSystemTable(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunDoltDiffSystemTableTests(t, h)
}

func TestSchemaDiffTableFunction(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunSchemaDiffTableFunctionTests(t, harness)
}

func TestDoltDatabaseCollationDiffs(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunDoltDatabaseCollationDiffsTests(t, harness)
}

func TestQueryDiff(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunQueryDiffTests(t, harness)
}

func TestSystemTableIndexes(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunSystemTableIndexesTests(t, harness)
}

func TestSystemTableFunctionIndexes(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunSystemTableFunctionIndexesTests(t, harness)
}

func TestReadOnlyDatabases(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestReadOnlyDatabases(t, h)
}

func TestAddDropPks(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestAddDropPks(t, h)
}

func TestAddAutoIncrementColumn(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunAddAutoIncrementColumnTests(t, h)
}

func TestNullRanges(t *testing.T) {
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestNullRanges(t, h)
}

func TestPersist(t *testing.T) {
	t.Skip()
	ctx := context.Background()
	harness := newDoltgresServerHarness(t)
	defer harness.Close()
	dEnv := dtestutils.CreateTestEnv()
	defer dEnv.DoltDB(ctx).Close()
	localConf, ok := dEnv.Config.GetConfig(env.LocalConfig)
	require.True(t, ok)
	globals := config.NewPrefixConfig(localConf, env.SqlServerGlobalsPrefix)
	newPersistableSession := func(ctx *sql.Context) sql.PersistableSession {
		session := ctx.Session.(*dsess.DoltSession).WithGlobals(globals)
		err := session.RemoveAllPersistedGlobals()
		require.NoError(t, err)
		return session
	}

	enginetest.TestPersist(t, harness, newPersistableSession)
}

func TestTypesOverWire(t *testing.T) {
	t.Skip("Port equivalent test from Dolt")
}

func TestDoltCherryPick(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunDoltCherryPickTests(t, harness)
}

func TestDoltCommit(t *testing.T) {
	harness := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		// These tests set @@autocommit, which we can't translate accurately yet
		"CALL DOLT_COMMIT('-amend') works to update commit message",
		"CALL DOLT_COMMIT('-amend') works to add changes to a commit",
		"CALL DOLT_COMMIT('-amend') works to remove changes from a commit",
		"CALL DOLT_COMMIT('-amend') works to update a merge commit",
		"CALL DOLT_COMMIT('--amend') works on initial commit",
		"DOLT_COMMIT respects foreign_key_checks=0",
	})
	denginetest.RunDoltCommitTests(t, harness)
}

func TestStatsHistograms(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunStatsHistogramTests(t, h)
}

// TestStatsStorage force a provider reload in-between setup and assertions that
// forces a round trip of the statistics table before inspecting values.
func TestStatsStorage(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	denginetest.RunStatsStorageTests(t, h)
}

func TestJoinStats(t *testing.T) {
	h := newDoltgresServerHarness(t)
	denginetest.RunJoinStatsTests(t, h)
}

func TestStatisticIndexes(t *testing.T) {
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestStatisticIndexFilters(t, h)
}

func TestCharsetCollationEngine(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestCharsetCollationEngine(t, h)
}

func TestCharsetCollationWire(t *testing.T) {
	t.Skip("port test from Dolt")
}

func TestDatabaseCollationWire(t *testing.T) {
	t.Skip("port test from Dolt")
}

func TestAddDropPrimaryKeys(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunAddDropPrimaryKeysTests(t, harness)
}

func TestDoltVerifyConstraints(t *testing.T) {
	t.Skip()
	harness := newDoltgresServerHarness(t)
	denginetest.RunDoltVerifyConstraintsTests(t, harness)
}

func TestDoltStorageFormat(t *testing.T) {
	h := newDoltgresServerHarness(t)
	denginetest.RunDoltStorageFormatTests(t, h)
}

func TestThreeWayMergeWithSchemaChangeScripts(t *testing.T) {
	t.Skip()
	h := newDoltgresServerHarness(t)

	denginetest.RunThreeWayMergeWithSchemaChangeScripts(t, h)
}

// If CREATE DATABASE has an error within the DatabaseProvider, it should not
// leave behind intermediate filesystem state.
func TestCreateDatabaseErrorCleansUp(t *testing.T) {
	t.Skip("port test from Dolt")
}

// TestStatsAutoRefreshConcurrency tests some common concurrent patterns that stats
// refresh is subject to -- namely reading/writing the stats objects in (1) DML statements
// (2) auto refresh threads, and (3) manual ANALYZE statements.
// todo: the dolt_stat functions should be concurrency tested
func TestStatsAutoRefreshConcurrency(t *testing.T) {
	t.Skip("port test from Dolt")
}

func TestAdaptiveEncoding(t *testing.T) {
	// The test runs end-to-end, but most subtests currently fail because:
	//  - bytea/text round-trips through the harness lose data for BLOB columns
	//  - the converter does not yet translate MySQL prefix indexes (`col(N)`),
	//    LOAD_FILE(), or INSERT of text literals into bytea columns
	// Unskip once those gaps are filled.
	t.Skip("AdaptiveEncoding runs but fails on bytea round-trip / MySQL-only queries; see comment")

	adaptiveEncoding := typeinfo.UseAdaptiveEncoding
	defer func() { typeinfo.UseAdaptiveEncoding = adaptiveEncoding }()
	typeinfo.UseAdaptiveEncoding = true

	denginetest.RunTestAdaptiveEncoding(t, newDoltgresServerHarness(t), denginetest.AdaptiveEncodingTestType_Blob, denginetest.AdaptiveEncodingTestPurpose_Representation)
	denginetest.RunTestAdaptiveEncoding(t, newDoltgresServerHarness(t), denginetest.AdaptiveEncodingTestType_Blob, denginetest.AdaptiveEncodingTestPurpose_Correctness)
	denginetest.RunTestAdaptiveEncoding(t, newDoltgresServerHarness(t), denginetest.AdaptiveEncodingTestType_Text, denginetest.AdaptiveEncodingTestPurpose_Representation)
	denginetest.RunTestAdaptiveEncoding(t, newDoltgresServerHarness(t), denginetest.AdaptiveEncodingTestType_Text, denginetest.AdaptiveEncodingTestPurpose_Correctness)

	denginetest.RunAdaptiveEncodingScripts(t, newDoltgresServerHarness(t))
}

func TestSchemaOverridesWithAdaptiveEncoding(t *testing.T) {
	// Runs end-to-end but fails on @@dolt_override_schema (user-variable scope)
	// and the MySQL DESCRIBE statement. Unskip once those land.
	t.Skip("SchemaOverrides runs but fails on @@dolt_override_schema / DESCRIBE; see comment")

	adaptiveEncoding := typeinfo.UseAdaptiveEncoding
	defer func() { typeinfo.UseAdaptiveEncoding = adaptiveEncoding }()
	typeinfo.UseAdaptiveEncoding = true
	harness := newDoltgresServerHarness(t)
	denginetest.RunSchemaOverridesTest(t, harness)
}

func TestJsonAdaptiveEncoding(t *testing.T) {
	adaptiveEncoding := typeinfo.UseAdaptiveEncoding
	defer func() { typeinfo.UseAdaptiveEncoding = adaptiveEncoding }()
	typeinfo.UseAdaptiveEncoding = true

	harness := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"json_extract(", // MySQL-specific; postgres uses -> / jsonb_extract_path_text
	})
	denginetest.RunJsonAdaptiveEncodingTests(t, harness)
}

func TestBackupsSystemTable(t *testing.T) {
	t.Skip("port test from Dolt")
}

func TestBranchActivity(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunBranchActivityTests(t, harness)
}

func TestBranchStatusTableFunction(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunBranchStatusTableFunctionTests(t, harness)
}

func TestConcurrentCreateDatabaseIfNotExists(t *testing.T) {
	t.Skip("port test from Dolt")
}

func TestDoltBranchesSystemTable(t *testing.T) {
	t.Skip("port test from Dolt")
	h := newDoltgresServerHarness(t)
	denginetest.RunDoltBranchesSystemTableTests(t, h)
}

func TestDoltCommitVerificationScripts(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunDoltCommitVerificationScripts(t, harness)
}

func TestDoltDTableScripts(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunDoltDTableScriptsTest(t, harness)
}

func TestDoltForeignKeyTests(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunDoltForeignKeyTests(t, harness)
}

func TestDoltHelpSystemTable(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	defer harness.Close()
	denginetest.RunDoltHelpSystemTableTests(t, harness)
}

func TestDoltPreviewMergeConflicts(t *testing.T) {
	t.Skip("port test from Dolt")
	h := newDoltgresServerHarness(t)
	denginetest.RunDoltPreviewMergeConflictsTests(t, h)
}

func TestDoltQueryCatalogSystemTable(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	defer harness.Close()
	denginetest.RunDoltQueryCatalogTests(t, harness)
}

func TestDoltRm(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	defer harness.Close()
	denginetest.RunDoltRmTests(t, harness)
}

func TestDoltStash(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	defer harness.Close()
	denginetest.RunDoltStashSystemTableTests(t, harness)
}

func TestDoltTestsSystemTable(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	defer harness.Close()
	denginetest.RunDoltTestsTableTests(t, harness)
}

func TestDoltUserPrivileges(t *testing.T) {
	t.Skip("MySQL-specific user privilege tests, not applicable to doltgresql")
}

func TestDoltWorkspace(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunDoltWorkspaceTests(t, harness)
}

func TestDriverExecution(t *testing.T) {
	t.Skip("port test from Dolt - uses dolt_backup which is not yet supported")
}

func TestJsonDiffTableFunction(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunJsonDiffTableFunctionTests(t, harness)
}

func TestJsonValueScripts(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunJsonValueScriptsTest(t, harness)
}

func TestLargeGeometryScripts(t *testing.T) {
	t.Skip("doltgresql does not support spatial types")
}

func TestLegacyCreateTableScripts(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunLegacyCreateTableScripts(t, harness)
}

func TestLegacyDeleteScripts(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunLegacyDeleteScripts(t, harness)
}

func TestLegacyDropTableScripts(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunLegacyDropTableScripts(t, harness)
}

func TestLegacyIndexScripts(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunLegacyIndexScripts(t, harness)
}

func TestLegacyInsertScripts(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunLegacyInsertScripts(t, harness)
}

func TestLegacyJoinScripts(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunLegacyJoinScripts(t, harness)
}

func TestLegacyReplaceScripts(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunLegacyReplaceScripts(t, harness)
}

func TestLegacySelectScripts(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunLegacySelectScripts(t, harness)
}

func TestLegacyUpdateScripts(t *testing.T) {
	t.Skip("port test from Dolt")
	harness := newDoltgresServerHarness(t)
	denginetest.RunLegacyUpdateScripts(t, harness)
}

func TestNonlocalTable(t *testing.T) {
	t.Skip("port test from Dolt")
	h := newDoltgresServerHarness(t)
	denginetest.RunNonlocalTableTests(t, h)
}

func TestNumericErrorScripts(t *testing.T) {
	t.Skip("port test from Dolt")
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestNumericErrorScripts(t, h)
}

func TestSingleMergeScript(t *testing.T) {
	t.Skip("debug harness for a single merge script")
}

func TestSingleTransactionScript(t *testing.T) {
	t.Skip("debug harness for a single transaction script")
}

func TestTimeQueries(t *testing.T) {
	t.Skip("port test from Dolt")
	h := newDoltgresServerHarness(t)
	defer h.Close()
	enginetest.TestTimeQueries(t, h)
}

func TestUpdateIgnore(t *testing.T) {
	h := newDoltgresServerHarness(t).WithSkippedQueries([]string{
		"UPDATE IGNORE with primary keys and indexes", // ignore semantics are different
		"UPDATE IGNORE with type conversions",         // postgres strict typing rejects MySQL coercions
	})
	defer h.Close()
	enginetest.TestUpdateIgnore(t, h)
}

func TestUserPrivileges(t *testing.T) {
	t.Skip("MySQL-specific user privilege tests, not applicable to doltgresql")
}

func TestVectorFunctions(t *testing.T) {
	t.Skip("doltgresql does not yet support vector types")
}

func TestVectorIndexes(t *testing.T) {
	t.Skip("doltgresql does not yet support vector types")
}

func TestVectorType(t *testing.T) {
	t.Skip("doltgresql does not yet support vector types")
}