diff --git a/.github/workflows/ci-check-repo.yaml b/.github/workflows/ci-check-repo.yaml
index 370c7a435b..34e62a0329 100644
--- a/.github/workflows/ci-check-repo.yaml
+++ b/.github/workflows/ci-check-repo.yaml
@@ -32,8 +32,7 @@ jobs:
           go run -mod=readonly ./utils/copyrightshdrs/
           ./Godeps/verify.sh
           ./utils/repofmt/check_bats_fmt.sh
-          ./utils/repofmt/check_prepared_tests.sh
-          
+
           if ./utils/repofmt/check_fmt.sh ; then
             echo "code is formatted"
           else
diff --git a/go/cmd/dolt/commands/diff.go b/go/cmd/dolt/commands/diff.go
index 8c82dea4c9..902b81ca12 100644
--- a/go/cmd/dolt/commands/diff.go
+++ b/go/cmd/dolt/commands/diff.go
@@ -22,9 +22,8 @@ import (
 	"strings"
 
 	"github.com/dolthub/go-mysql-server/sql"
-	"github.com/dolthub/go-mysql-server/sql/parse"
 	"github.com/dolthub/go-mysql-server/sql/types"
-	"github.com/dolthub/vitess/go/vt/sqlparser"
+	ast "github.com/dolthub/vitess/go/vt/sqlparser"
 	"github.com/go-sql-driver/mysql"
 	"github.com/gocraft/dbr/v2"
 	"github.com/gocraft/dbr/v2/dialect"
@@ -857,7 +856,7 @@ func getTableSchemaAtRef(queryist cli.Queryist, sqlCtx *sql.Context, tableName s
 		createStmt += ";"
 	}
 
-	sch, err = schemaFromCreateTableStmt(sqlCtx, createStmt)
+	sch, err = schemaFromCreateTableStmt(createStmt)
 	if err != nil {
 		return sch, createStmt, err
 	}
@@ -865,33 +864,50 @@ func getTableSchemaAtRef(queryist cli.Queryist, sqlCtx *sql.Context, tableName s
 	return sch, createStmt, nil
 }
 
-func schemaFromCreateTableStmt(sqlCtx *sql.Context, createTableStmt string) (schema.Schema, error) {
-	p, err := sqlparser.Parse(createTableStmt)
+func schemaFromCreateTableStmt(createTableStmt string) (schema.Schema, error) {
+	parsed, err := ast.Parse(createTableStmt)
 	if err != nil {
 		return nil, err
 	}
-	ddl := p.(*sqlparser.DDL)
+	create, ok := parsed.(*ast.DDL)
+	if !ok {
+		return nil, fmt.Errorf("expected create table, found %T", parsed)
+	}
 
-	s, _, err := parse.TableSpecToSchema(sqlCtx, ddl.TableSpec, false)
-	if err != nil {
-		return nil, err
+	primaryCols := make(map[string]bool)
+	for _, index := range create.TableSpec.Indexes {
+		if index.Info.Primary {
+			for _, indexCol := range index.Columns {
+				primaryCols[indexCol.Column.Lowered()] = true
+			}
+			break
+		}
 	}
 
 	cols := []schema.Column{}
-	for _, col := range s.Schema {
-		typeInfo, err := typeinfo.FromSqlType(col.Type)
+	for _, col := range create.TableSpec.Columns {
+		internalTyp, err := types.ColumnTypeToType(&col.Type)
+		typeInfo, err := typeinfo.FromSqlType(internalTyp)
 		if err != nil {
 			return nil, err
 		}
 
+		defBuf := ast.NewTrackedBuffer(nil)
+		if col.Type.Default != nil {
+			col.Type.Default.Format(defBuf)
+		}
+		var comment string
+		if col.Type.Comment != nil {
+			comment = col.Type.Comment.String()
+		}
 		sCol, err := schema.NewColumnWithTypeInfo(
-			col.Name,
+			col.Name.String(),
 			0,
 			typeInfo,
-			col.PrimaryKey,
-			col.Default.String(),
-			col.AutoIncrement,
-			col.Comment,
+			primaryCols[col.Name.Lowered()],
+			defBuf.String(),
+			col.Type.Autoincrement == true,
+			comment,
 		)
 		cols = append(cols, sCol)
 	}
diff --git a/go/cmd/dolt/commands/dump.go b/go/cmd/dolt/commands/dump.go
index 5dcded8c59..adb137ab01 100644
--- a/go/cmd/dolt/commands/dump.go
+++ b/go/cmd/dolt/commands/dump.go
@@ -23,8 +23,8 @@ import (
 	"strings"
 
 	"github.com/dolthub/go-mysql-server/sql"
-	"github.com/dolthub/go-mysql-server/sql/parse"
 	"github.com/dolthub/go-mysql-server/sql/plan"
+	"github.com/dolthub/go-mysql-server/sql/planbuilder"
 	"github.com/fatih/color"
 
 	"github.com/dolthub/dolt/go/cmd/dolt/cli"
@@ -430,12 +430,12 @@ func dumpViews(ctx *sql.Context, engine *engine.SqlEngine, root *doltdb.RootValu
 			sqlMode = s
 		}
 
+		opts := sql.NewSqlModeFromString(sqlMode).ParserOptions()
 		// We used to store just the SELECT part of a view, but now we store the entire CREATE VIEW statement
-		cv, err := parse.ParseWithOptions(ctx, row[fragColIdx].(string), sql.NewSqlModeFromString(sqlMode).ParserOptions())
+		cv, err := planbuilder.ParseWithOptions(ctx, engine.GetUnderlyingEngine().Analyzer.Catalog, row[fragColIdx].(string), opts)
 		if err != nil {
 			return err
 		}
-
 		modeChanged, err := changeSqlMode(ctx, writer, sqlMode)
 		if err != nil {
 			return err
diff --git a/go/cmd/dolt/commands/tblcmds/import.go b/go/cmd/dolt/commands/tblcmds/import.go
index 540ac09030..0799429199 100644
--- a/go/cmd/dolt/commands/tblcmds/import.go
+++ b/go/cmd/dolt/commands/tblcmds/import.go
@@ -470,7 +470,7 @@ func newImportDataReader(ctx context.Context, root *doltdb.RootValue, dEnv *env.
 		return nil, &mvdata.DataMoverCreationError{ErrType: mvdata.CreateReaderErr, Cause: fmt.Errorf("%s already exists. Use -f to overwrite.", impOpts.DestName())}
 	}
 
-	rd, _, err := impOpts.src.NewReader(ctx, root, dEnv.FS, impOpts.srcOptions)
+	rd, _, err := impOpts.src.NewReader(ctx, dEnv, impOpts.srcOptions)
 	if err != nil {
 		return nil, &mvdata.DataMoverCreationError{ErrType: mvdata.CreateReaderErr, Cause: err}
 	}
@@ -646,14 +646,11 @@ func moveRows(
 }
 
 func getImportSchema(ctx context.Context, dEnv *env.DoltEnv, impOpts *importOptions) (schema.Schema, *mvdata.DataMoverCreationError) {
-	root, err := dEnv.WorkingRoot(ctx)
-	if err != nil {
-		return nil, &mvdata.DataMoverCreationError{ErrType: mvdata.SchemaErr, Cause: err}
-	}
-
 	if impOpts.schFile != "" {
-		tn, out, err := mvdata.SchAndTableNameFromFile(ctx, impOpts.schFile, dEnv.FS, root)
-
+		tn, out, err := mvdata.SchAndTableNameFromFile(ctx, impOpts.schFile, dEnv)
+		if err != nil {
+			return nil, &mvdata.DataMoverCreationError{ErrType: mvdata.SchemaErr, Cause: err}
+		}
 		if err == nil && tn != impOpts.destTableName {
 			err = fmt.Errorf("table name '%s' from schema file %s does not match table arg '%s'", tn, impOpts.schFile, impOpts.destTableName)
 		}
@@ -671,7 +668,7 @@ func getImportSchema(ctx context.Context, dEnv *env.DoltEnv, impOpts *importOpti
 			return nil, nil
 		}
 
-		rd, _, err := impOpts.src.NewReader(ctx, root, dEnv.FS, impOpts.srcOptions)
+		rd, _, err := impOpts.src.NewReader(ctx, dEnv, impOpts.srcOptions)
 		if err != nil {
 			return nil, &mvdata.DataMoverCreationError{ErrType: mvdata.CreateReaderErr, Cause: err}
 		}
@@ -681,6 +678,11 @@ func getImportSchema(ctx context.Context, dEnv *env.DoltEnv, impOpts *importOpti
 			return rd.GetSchema(), nil
 		}
 
+		root, err := dEnv.WorkingRoot(ctx)
+		if err != nil {
+			return nil, &mvdata.DataMoverCreationError{ErrType: mvdata.SchemaErr, Cause: err}
+		}
+
 		outSch, err := mvdata.InferSchema(ctx, root, rd, impOpts.destTableName, impOpts.primaryKeys, impOpts)
 		if err != nil {
 			return nil, &mvdata.DataMoverCreationError{ErrType: mvdata.SchemaErr, Cause: err}
diff --git a/go/go.mod b/go/go.mod
index 4d35661b07..5fc8bcc69b 100644
--- a/go/go.mod
+++ b/go/go.mod
@@ -15,7 +15,7 @@ require (
 	github.com/dolthub/fslock v0.0.3
 	github.com/dolthub/ishell v0.0.0-20221214210346-d7db0b066488
 	github.com/dolthub/sqllogictest/go v0.0.0-20201107003712-816f3ae12d81
-	github.com/dolthub/vitess v0.0.0-20230815183531-5f606d83f408
+	github.com/dolthub/vitess v0.0.0-20230815195949-02f159e126f9
 	github.com/dustin/go-humanize v1.0.0
 	github.com/fatih/color v1.13.0
 	github.com/flynn-archive/go-shlex v0.0.0-20150515145356-3f9db97f8568
@@ -45,8 +45,8 @@ require (
 	golang.org/x/sync v0.2.0
 	golang.org/x/sys v0.10.0
 	google.golang.org/api v0.126.0
-	google.golang.org/grpc v1.55.0
-	google.golang.org/protobuf v1.30.0
+	google.golang.org/grpc v1.57.0
+	google.golang.org/protobuf v1.31.0
 	gopkg.in/square/go-jose.v2 v2.5.1
 	gopkg.in/src-d/go-errors.v1 v1.0.0
 	gopkg.in/yaml.v2 v2.4.0
@@ -59,7 +59,7 @@ require (
 	github.com/cespare/xxhash v1.1.0
 	github.com/creasty/defaults v1.6.0
 	github.com/dolthub/flatbuffers/v23 v23.3.3-dh.2
-	github.com/dolthub/go-mysql-server v0.16.1-0.20230815232241-704a2c0709d3
+	github.com/dolthub/go-mysql-server v0.16.1-0.20230817011537-fac838d6f846
 	github.com/dolthub/swiss v0.1.0
 	github.com/goccy/go-json v0.10.2
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
@@ -90,10 +90,10 @@ require (
 )
 
 require (
-	cloud.google.com/go v0.110.2 // indirect
-	cloud.google.com/go/compute v1.19.3 // indirect
+	cloud.google.com/go v0.110.7 // indirect
+	cloud.google.com/go/compute v1.23.0 // indirect
 	cloud.google.com/go/compute/metadata v0.2.3 // indirect
-	cloud.google.com/go/iam v1.1.0 // indirect
+	cloud.google.com/go/iam v1.1.1 // indirect
 	git.sr.ht/~sbinet/gg v0.3.1 // indirect
 	github.com/ajstarks/svgo v0.0.0-20211024235047-1546f124cd8b // indirect
 	github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751 // indirect
@@ -151,9 +151,9 @@ require (
 	golang.org/x/tools v0.6.0 // indirect
 	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect
 	google.golang.org/appengine v1.6.7 // indirect
-	google.golang.org/genproto v0.0.0-20230530153820-e85fd2cbaebc // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20230530153820-e85fd2cbaebc // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20230530153820-e85fd2cbaebc // indirect
+	google.golang.org/genproto v0.0.0-20230807174057-1744710a1577 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20230803162519-f966b187b2e5 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20230803162519-f966b187b2e5 // indirect
 	gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect
 )
 
diff --git a/go/go.sum b/go/go.sum
index 22b2cddd0a..410161f500 100644
--- a/go/go.sum
+++ b/go/go.sum
@@ -13,22 +13,22 @@ cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKV
 cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
 cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
 cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
-cloud.google.com/go v0.110.2 h1:sdFPBr6xG9/wkBbfhmUz/JmZC7X6LavQgcrVINrKiVA=
-cloud.google.com/go v0.110.2/go.mod h1:k04UEeEtb6ZBRTv3dZz4CeJC3jKGxyhl0sAiVVquxiw=
+cloud.google.com/go v0.110.7 h1:rJyC7nWRg2jWGZ4wSJ5nY65GTdYJkg0cd/uXb+ACI6o=
+cloud.google.com/go v0.110.7/go.mod h1:+EYjdK8e5RME/VY/qLCAtuyALQ9q67dvuum8i+H5xsI=
 cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
 cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
 cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
 cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
 cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
 cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
-cloud.google.com/go/compute v1.19.3 h1:DcTwsFgGev/wV5+q8o2fzgcHOaac+DKGC91ZlvpsQds=
-cloud.google.com/go/compute v1.19.3/go.mod h1:qxvISKp/gYnXkSAD1ppcSOveRAmzxicEv/JlizULFrI=
+cloud.google.com/go/compute v1.23.0 h1:tP41Zoavr8ptEqaW6j+LQOnyBBhO7OkOMAGrgLopTwY=
+cloud.google.com/go/compute v1.23.0/go.mod h1:4tCnrn48xsqlwSAiLf1HXMQk8CONslYbdiEZc9FEIbM=
 cloud.google.com/go/compute/metadata v0.2.3 h1:mg4jlk7mCAj6xXp9UJ4fjI9VUI5rubuGBW5aJ7UnBMY=
 cloud.google.com/go/compute/metadata v0.2.3/go.mod h1:VAV5nSsACxMJvgaAuX6Pk2AawlZn8kiOGuCv6gTkwuA=
 cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
 cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
-cloud.google.com/go/iam v1.1.0 h1:67gSqaPukx7O8WLLHMa0PNs3EBGd2eE4d+psbO/CO94=
-cloud.google.com/go/iam v1.1.0/go.mod h1:nxdHjaKfCr7fNYx/HJMM8LgiMugmveWlkatear5gVyk=
+cloud.google.com/go/iam v1.1.1 h1:lW7fzj15aVIXYHREOqjRBV9PsH0Z6u8Y46a1YGvQP4Y=
+cloud.google.com/go/iam v1.1.1/go.mod h1:A5avdyVL2tCppe4unb0951eI9jreack+RJ0/d+KUZOU=
 cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
 cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
 cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
@@ -180,10 +180,8 @@ github.com/dolthub/fslock v0.0.3 h1:iLMpUIvJKMKm92+N1fmHVdxJP5NdyDK5bK7z7Ba2s2U=
 github.com/dolthub/fslock v0.0.3/go.mod h1:QWql+P17oAAMLnL4HGB5tiovtDuAjdDTPbuqx7bYfa0=
 github.com/dolthub/go-icu-regex v0.0.0-20230524105445-af7e7991c97e h1:kPsT4a47cw1+y/N5SSCkma7FhAPw7KeGmD6c9PBZW9Y=
 github.com/dolthub/go-icu-regex v0.0.0-20230524105445-af7e7991c97e/go.mod h1:KPUcpx070QOfJK1gNe0zx4pA5sicIK1GMikIGLKC168=
-github.com/dolthub/go-mysql-server v0.16.1-0.20230807211358-5b6031f113ba h1:ImvGNMKqAA+KPH5rXTR1xmOVQYv9XC7p6AjX8RhkWMU=
-github.com/dolthub/go-mysql-server v0.16.1-0.20230807211358-5b6031f113ba/go.mod h1:nY1J1sV2kuGJbAZ6bcZARw4dF8TD3KpEfYVVs/HK/JY=
-github.com/dolthub/go-mysql-server v0.16.1-0.20230815232241-704a2c0709d3 h1:2puC5sgRHTdWapYMn4WrSH06/qq8Qfw1wW84eWHvC1Q=
-github.com/dolthub/go-mysql-server v0.16.1-0.20230815232241-704a2c0709d3/go.mod h1:wK9co8FTJEstDv35ITVgCjYVqqBoN5MlDyVMsNCoWaw=
+github.com/dolthub/go-mysql-server v0.16.1-0.20230817011537-fac838d6f846 h1:GcbYtLRUeR0/ckyPu7emb+vYyzR5+lfNgNx4u//w4PI=
+github.com/dolthub/go-mysql-server v0.16.1-0.20230817011537-fac838d6f846/go.mod h1:G05kv0oaccoUORzpk7B45EpL2fwhO1WETObKslLmra8=
 github.com/dolthub/ishell v0.0.0-20221214210346-d7db0b066488 h1:0HHu0GWJH0N6a6keStrHhUAK5/o9LVfkh44pvsV4514=
 github.com/dolthub/ishell v0.0.0-20221214210346-d7db0b066488/go.mod h1:ehexgi1mPxRTk0Mok/pADALuHbvATulTh6gzr7NzZto=
 github.com/dolthub/jsonpath v0.0.2-0.20230525180605-8dc13778fd72 h1:NfWmngMi1CYUWU4Ix8wM+USEhjc+mhPlT9JUR/anvbQ=
@@ -194,8 +192,8 @@ github.com/dolthub/sqllogictest/go v0.0.0-20201107003712-816f3ae12d81 h1:7/v8q9X
 github.com/dolthub/sqllogictest/go v0.0.0-20201107003712-816f3ae12d81/go.mod h1:siLfyv2c92W1eN/R4QqG/+RjjX5W2+gCTRjZxBjI3TY=
 github.com/dolthub/swiss v0.1.0 h1:EaGQct3AqeP/MjASHLiH6i4TAmgbG/c4rA6a1bzCOPc=
 github.com/dolthub/swiss v0.1.0/go.mod h1:BeucyB08Vb1G9tumVN3Vp/pyY4AMUnr9p7Rz7wJ7kAQ=
-github.com/dolthub/vitess v0.0.0-20230815183531-5f606d83f408 h1:0MhiNzFzHybo3FR3kJBGadx+Z9u30R30YfUOKQ3fyJQ=
-github.com/dolthub/vitess v0.0.0-20230815183531-5f606d83f408/go.mod h1:IyoysiiOzrIs7QsEHC+yVF0yRQ6W70GXyCXqtI2vVTs=
+github.com/dolthub/vitess v0.0.0-20230815195949-02f159e126f9 h1:5KCy4uBtYu/A5Zgb97gBL5TFnIZwvT77QK4r6EPTk9Y=
+github.com/dolthub/vitess v0.0.0-20230815195949-02f159e126f9/go.mod h1:IyoysiiOzrIs7QsEHC+yVF0yRQ6W70GXyCXqtI2vVTs=
 github.com/dustin/go-humanize v0.0.0-20171111073723-bb3d318650d4/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
 github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
 github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
@@ -1082,12 +1080,12 @@ google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7Fc
 google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
 google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
-google.golang.org/genproto v0.0.0-20230530153820-e85fd2cbaebc h1:8DyZCyvI8mE1IdLy/60bS+52xfymkE72wv1asokgtao=
-google.golang.org/genproto v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:xZnkP7mREFX5MORlOPEzLMr+90PPZQ2QWzrVTWfAq64=
-google.golang.org/genproto/googleapis/api v0.0.0-20230530153820-e85fd2cbaebc h1:kVKPf/IiYSBWEWtkIn6wZXwWGCnLKcC8oWfZvXjsGnM=
-google.golang.org/genproto/googleapis/api v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:vHYtlOoi6TsQ3Uk2yxR7NI5z8uoV+3pZtR4jmHIkRig=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230530153820-e85fd2cbaebc h1:XSJ8Vk1SWuNr8S18z1NZSziL0CPIXLCCMDOEFtHBOFc=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20230530153820-e85fd2cbaebc/go.mod h1:66JfowdXAEgad5O9NnYcsNPLCPZJD++2L9X0PCMODrA=
+google.golang.org/genproto v0.0.0-20230807174057-1744710a1577 h1:Tyk/35yqszRCvaragTn5NnkY6IiKk/XvHzEWepo71N0=
+google.golang.org/genproto v0.0.0-20230807174057-1744710a1577/go.mod h1:yZTlhN0tQnXo3h00fuXNCxJdLdIdnVFVBaRJ5LWBbw4=
+google.golang.org/genproto/googleapis/api v0.0.0-20230803162519-f966b187b2e5 h1:nIgk/EEq3/YlnmVVXVnm14rC2oxgs1o0ong4sD/rd44=
+google.golang.org/genproto/googleapis/api v0.0.0-20230803162519-f966b187b2e5/go.mod h1:5DZzOUPCLYL3mNkQ0ms0F3EuUNZ7py1Bqeq6sxzI7/Q=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20230803162519-f966b187b2e5 h1:eSaPbMR4T7WfH9FvABk36NBMacoTUKdWCvV0dx+KfOg=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20230803162519-f966b187b2e5/go.mod h1:zBEcrKX2ZOcEkHWxBPAIvYUWOKKMIhYcmNiUIu2ji3I=
 google.golang.org/grpc v1.17.0/go.mod h1:6QZJwpn2B+Zp71q/5VxRsJ6NXXVCE5NRUHRo+f3cWCs=
 google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
 google.golang.org/grpc v1.20.0/go.mod h1:chYK+tFQF0nDUGJgXMSgLCQk3phJEuONr2DCgLDdAQM=
@@ -1109,8 +1107,8 @@ google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTp
 google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
 google.golang.org/grpc v1.36.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
 google.golang.org/grpc v1.45.0/go.mod h1:lN7owxKUQEqMfSyQikvvk5tf/6zMPsrK+ONuO11+0rQ=
-google.golang.org/grpc v1.55.0 h1:3Oj82/tFSCeUrRTg/5E/7d/W5A1tj6Ky1ABAuZuv5ag=
-google.golang.org/grpc v1.55.0/go.mod h1:iYEXKGkEBhg1PjZQvoYEVPTDkHo1/bjTnfwTeGONTY8=
+google.golang.org/grpc v1.57.0 h1:kfzNeI/klCGD2YPMUlaGNT3pxvYfga7smW3Vth8Zsiw=
+google.golang.org/grpc v1.57.0/go.mod h1:Sd+9RMTACXwmub0zcNY2c4arhtrbBYD1AUHI/dt16Mo=
 google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
 google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
 google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
@@ -1123,8 +1121,8 @@ google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGj
 google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
-google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+google.golang.org/protobuf v1.31.0 h1:g0LDEJHgrBl9N9r17Ru3sqWhkIx2NB67okBHPwC7hs8=
+google.golang.org/protobuf v1.31.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
 gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
diff --git a/go/libraries/doltcore/merge/merge_schema.go b/go/libraries/doltcore/merge/merge_schema.go
index 1bffe49271..95c64db66a 100644
--- a/go/libraries/doltcore/merge/merge_schema.go
+++ b/go/libraries/doltcore/merge/merge_schema.go
@@ -21,8 +21,8 @@ import (
 	"sort"
 	"strings"
 
-	sqle "github.com/dolthub/go-mysql-server"
 	"github.com/dolthub/go-mysql-server/sql"
+	ast "github.com/dolthub/vitess/go/vt/sqlparser"
 	errorkinds "gopkg.in/src-d/go-errors.v1"
 
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
@@ -1154,7 +1154,7 @@ func mergeChecks(ctx context.Context, ourChks, theirChks, ancChks schema.CheckCo
 			CheckExpression: chk.Expression(),
 			Enforced:        chk.Enforced(),
 		}
-		colNames, err := sqle.ColumnsFromCheckDefinition(sql.NewContext(ctx), &chkDef)
+		colNames, err := ColumnsFromCheckDefinition(sql.NewContext(ctx), &chkDef)
 		if err != nil {
 			return nil, nil, err
 		}
@@ -1176,7 +1176,7 @@ func mergeChecks(ctx context.Context, ourChks, theirChks, ancChks schema.CheckCo
 			CheckExpression: ourChk.Expression(),
 			Enforced:        ourChk.Enforced(),
 		}
-		colNames, err := sqle.ColumnsFromCheckDefinition(sql.NewContext(ctx), &chkDef)
+		colNames, err := ColumnsFromCheckDefinition(sql.NewContext(ctx), &chkDef)
 		if err != nil {
 			return nil, nil, err
 		}
@@ -1267,7 +1267,7 @@ func isCheckReferenced(sch schema.Schema, chk schema.Check) (bool, error) {
 		CheckExpression: chk.Expression(),
 		Enforced:        chk.Enforced(),
 	}
-	colNames, err := sqle.ColumnsFromCheckDefinition(sql.NewEmptyContext(), &chkDef)
+	colNames, err := ColumnsFromCheckDefinition(sql.NewEmptyContext(), &chkDef)
 	if err != nil {
 		return false, err
 	}
@@ -1281,3 +1281,39 @@ func isCheckReferenced(sch schema.Schema, chk schema.Check) (bool, error) {
 
 	return true, nil
 }
+
+// ColumnsFromCheckDefinition retrieves the Column Names referenced by a CheckDefinition
+func ColumnsFromCheckDefinition(ctx *sql.Context, def *sql.CheckDefinition) ([]string, error) {
+	// Evaluate the CheckDefinition to get evaluated Expression
+	parseStr := fmt.Sprintf("select %s", def.CheckExpression)
+	parsed, err := ast.Parse(parseStr)
+	if err != nil {
+		return nil, err
+	}
+
+	selectStmt, ok := parsed.(*ast.Select)
+	if !ok || len(selectStmt.SelectExprs) != 1 {
+		err := sql.ErrInvalidCheckConstraint.New(def.CheckExpression)
+		return nil, err
+	}
+
+	expr := selectStmt.SelectExprs[0]
+	ae, ok := expr.(*ast.AliasedExpr)
+	if !ok {
+		err := sql.ErrInvalidCheckConstraint.New(def.CheckExpression)
+		return nil, err
+	}
+
+	// Look for any column references in the evaluated Expression
+	var cols []string
+	ast.Walk(func(n ast.SQLNode) (kontinue bool, err error) {
+		switch n := n.(type) {
+		case *ast.ColName:
+			colName := n.Name.Lowered()
+			cols = append(cols, colName)
+		default:
+		}
+		return true, nil
+	}, ae.Expr)
+	return cols, nil
+}
diff --git a/go/libraries/doltcore/merge/schema_merge_test.go b/go/libraries/doltcore/merge/schema_merge_test.go
index afb1b6b2bf..28aebfea0d 100644
--- a/go/libraries/doltcore/merge/schema_merge_test.go
+++ b/go/libraries/doltcore/merge/schema_merge_test.go
@@ -22,6 +22,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/dolthub/dolt/go/cmd/dolt/commands/engine"
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
 	"github.com/dolthub/dolt/go/libraries/doltcore/dtestutils"
 	"github.com/dolthub/dolt/go/libraries/doltcore/merge"
@@ -599,8 +600,11 @@ func sch(definition string) namedSchema {
 	ns := denv.DoltDB.NodeStore()
 	ctx := context.Background()
 	root, _ := doltdb.EmptyRootValue(ctx, vrw, ns)
+	eng, dbName, _ := engine.NewSqlEngineForEnv(ctx, denv)
+	sqlCtx, _ := eng.NewDefaultContext(ctx)
+	sqlCtx.SetCurrentDatabase(dbName)
 	// TODO: ParseCreateTableStatement silently drops any indexes or check constraints in the definition
-	name, s, err := sqlutil.ParseCreateTableStatement(ctx, root, definition)
+	name, s, err := sqlutil.ParseCreateTableStatement(sqlCtx, root, eng.GetUnderlyingEngine(), definition)
 	if err != nil {
 		panic(err)
 	}
diff --git a/go/libraries/doltcore/mvdata/data_loc.go b/go/libraries/doltcore/mvdata/data_loc.go
index 9e1ce37169..235cf85725 100644
--- a/go/libraries/doltcore/mvdata/data_loc.go
+++ b/go/libraries/doltcore/mvdata/data_loc.go
@@ -21,12 +21,12 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/dolthub/dolt/go/libraries/doltcore/table/editor"
-
 	"github.com/dolthub/dolt/go/cmd/dolt/cli"
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+	"github.com/dolthub/dolt/go/libraries/doltcore/env"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
 	"github.com/dolthub/dolt/go/libraries/doltcore/table"
+	"github.com/dolthub/dolt/go/libraries/doltcore/table/editor"
 	"github.com/dolthub/dolt/go/libraries/utils/filesys"
 )
 
@@ -89,7 +89,7 @@ type DataLocation interface {
 	Exists(ctx context.Context, root *doltdb.RootValue, fs filesys.ReadableFS) (bool, error)
 
 	// NewReader creates a TableReadCloser for the DataLocation
-	NewReader(ctx context.Context, root *doltdb.RootValue, fs filesys.ReadableFS, opts interface{}) (rdCl table.SqlRowReader, sorted bool, err error)
+	NewReader(ctx context.Context, dEnv *env.DoltEnv, opts interface{}) (rdCl table.SqlRowReader, sorted bool, err error)
 
 	// NewCreatingWriter will create a TableWriteCloser for a DataLocation that will create a new table, or overwrite
 	// an existing table.
diff --git a/go/libraries/doltcore/mvdata/data_loc_test.go b/go/libraries/doltcore/mvdata/data_loc_test.go
index 4d48548086..c12fe0bed0 100644
--- a/go/libraries/doltcore/mvdata/data_loc_test.go
+++ b/go/libraries/doltcore/mvdata/data_loc_test.go
@@ -240,7 +240,7 @@ func TestCreateRdWr(t *testing.T) {
 			t.Fatal("Failed to write data. bad:", numBad, err)
 		}
 
-		rd, _, err := loc.NewReader(context.Background(), root, dEnv.FS, JSONOptions{TableName: testTableName, SchFile: testSchemaFileName})
+		rd, _, err := loc.NewReader(context.Background(), dEnv, JSONOptions{TableName: testTableName, SchFile: testSchemaFileName})
 
 		if err != nil {
 			t.Fatal("Unexpected error creating reader", err)
diff --git a/go/libraries/doltcore/mvdata/data_mover.go b/go/libraries/doltcore/mvdata/data_mover.go
index f102de0b31..a317bdae6a 100644
--- a/go/libraries/doltcore/mvdata/data_mover.go
+++ b/go/libraries/doltcore/mvdata/data_mover.go
@@ -19,13 +19,14 @@ import (
 	"errors"
 	"fmt"
 
+	"github.com/dolthub/dolt/go/cmd/dolt/commands/engine"
 	"github.com/dolthub/dolt/go/cmd/dolt/errhand"
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+	"github.com/dolthub/dolt/go/libraries/doltcore/env"
 	"github.com/dolthub/dolt/go/libraries/doltcore/env/actions"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/sqlutil"
 	"github.com/dolthub/dolt/go/libraries/doltcore/table"
-	"github.com/dolthub/dolt/go/libraries/utils/filesys"
 	"github.com/dolthub/dolt/go/libraries/utils/set"
 )
 
@@ -88,15 +89,30 @@ func (dmce *DataMoverCreationError) String() string {
 }
 
 // SchAndTableNameFromFile reads a SQL schema file and creates a Dolt schema from it.
-func SchAndTableNameFromFile(ctx context.Context, path string, fs filesys.ReadableFS, root *doltdb.RootValue) (string, schema.Schema, error) {
+func SchAndTableNameFromFile(ctx context.Context, path string, dEnv *env.DoltEnv) (string, schema.Schema, error) {
+	root, err := dEnv.WorkingRoot(ctx)
+	if err != nil {
+		return "", nil, err
+	}
+	fs := dEnv.FS
+
 	if path != "" {
 		data, err := fs.ReadFile(path)
-
 		if err != nil {
 			return "", nil, err
 		}
 
-		tn, sch, err := sqlutil.ParseCreateTableStatement(ctx, root, string(data))
+		eng, dbName, err := engine.NewSqlEngineForEnv(ctx, dEnv)
+		if err != nil {
+			return "", nil, err
+		}
+
+		sqlCtx, err := eng.NewDefaultContext(ctx)
+		if err != nil {
+			return "", nil, err
+		}
+		sqlCtx.SetCurrentDatabase(dbName)
+		tn, sch, err := sqlutil.ParseCreateTableStatement(sqlCtx, root, eng.GetUnderlyingEngine(), string(data))
 
 		if err != nil {
 			return "", nil, fmt.Errorf("%s in schema file %s", err.Error(), path)
diff --git a/go/libraries/doltcore/mvdata/engine_table_reader.go b/go/libraries/doltcore/mvdata/engine_table_reader.go
index 925d4e68f2..fe3573df08 100644
--- a/go/libraries/doltcore/mvdata/engine_table_reader.go
+++ b/go/libraries/doltcore/mvdata/engine_table_reader.go
@@ -20,6 +20,8 @@ import (
 
 	sqle "github.com/dolthub/go-mysql-server"
 	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/plan"
+	"github.com/dolthub/go-mysql-server/sql/planbuilder"
 
 	"github.com/dolthub/dolt/go/cmd/dolt/commands/engine"
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
@@ -64,7 +66,17 @@ func NewSqlEngineReader(ctx context.Context, dEnv *env.DoltEnv, tableName string
 	}
 	sqlCtx.SetCurrentDatabase(mrEnv.GetFirstDatabase())
 
-	sch, iter, err := se.Query(sqlCtx, fmt.Sprintf("SELECT * FROM `%s`", tableName))
+	ret, err := planbuilder.Parse(sqlCtx, se.GetUnderlyingEngine().Analyzer.Catalog, fmt.Sprintf("show create table `%s`", tableName))
+	if err != nil {
+		return nil, err
+	}
+
+	create, ok := ret.(*plan.ShowCreateTable)
+	if !ok {
+		return nil, fmt.Errorf("expected *plan.ShowCreate table, found %T", ret)
+	}
+
+	_, iter, err := se.Query(sqlCtx, fmt.Sprintf("SELECT * FROM `%s`", tableName))
 	if err != nil {
 		return nil, err
 	}
@@ -74,7 +86,7 @@ func NewSqlEngineReader(ctx context.Context, dEnv *env.DoltEnv, tableName string
 		return nil, err
 	}
 
-	doltSchema, err := sqlutil.ToDoltSchema(ctx, root, tableName, sql.NewPrimaryKeySchema(sch), nil, sql.Collation_Default)
+	doltSchema, err := sqlutil.ToDoltSchema(ctx, root, tableName, create.PrimaryKeySchema, nil, sql.Collation_Default)
 	if err != nil {
 		return nil, err
 	}
diff --git a/go/libraries/doltcore/mvdata/engine_table_writer.go b/go/libraries/doltcore/mvdata/engine_table_writer.go
index a31c6f02be..7a9edef13b 100644
--- a/go/libraries/doltcore/mvdata/engine_table_writer.go
+++ b/go/libraries/doltcore/mvdata/engine_table_writer.go
@@ -23,8 +23,8 @@ import (
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/analyzer"
 	"github.com/dolthub/go-mysql-server/sql/analyzer/analyzererrors"
-	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/plan"
+	"github.com/dolthub/go-mysql-server/sql/planbuilder"
 	"github.com/dolthub/go-mysql-server/sql/rowexec"
 	"github.com/dolthub/go-mysql-server/sql/transform"
 
@@ -173,7 +173,7 @@ func (s *SqlEngineTableWriter) WriteRows(ctx context.Context, inputChannel chan
 		}
 	}
 
-	insertOrUpdateOperation, err := s.getInsertNode(inputChannel)
+	insertOrUpdateOperation, err := s.getInsertNode(inputChannel, false)
 	if err != nil {
 		return err
 	}
@@ -265,52 +265,70 @@ func (s *SqlEngineTableWriter) createOrEmptyTableIfNeeded() error {
 
 // createTable creates a table.
 func (s *SqlEngineTableWriter) createTable() error {
-	cr := plan.NewCreateTable(sql.UnresolvedDatabase(s.database), s.tableName, false, false, &plan.TableSpec{Schema: s.tableSchema})
-	analyzed, err := s.se.Analyze(s.sqlCtx, cr)
+	// TODO don't use internal interfaces to do this, we had to have a sql.Schema somewhere
+	// upstream to make the dolt schema
+	sqlCols := make([]string, len(s.tableSchema.Schema))
+	for i, c := range s.tableSchema.Schema {
+		sqlCols[i] = sql.GenerateCreateTableColumnDefinition(c, c.Default.String())
+	}
+	var pks string
+	var sep string
+	for _, i := range s.tableSchema.PkOrdinals {
+		pks += sep + s.tableSchema.Schema[i].Name
+		sep = ", "
+	}
+	if len(sep) > 0 {
+		sqlCols = append(sqlCols, fmt.Sprintf("PRIMARY KEY (%s)", pks))
+	}
+
+	createTable := sql.GenerateCreateTableStatement(s.tableName, sqlCols, sql.CharacterSet_utf8.String(), sql.Collation_Default.String())
+	sch, iter, err := s.se.Query(s.sqlCtx, createTable)
 	if err != nil {
 		return err
 	}
-
-	analyzedQueryProcess := analyzer.StripPassthroughNodes(analyzed.(*plan.QueryProcess))
-
-	ri, err := rowexec.DefaultBuilder.Build(s.sqlCtx, analyzedQueryProcess, nil)
-	if err != nil {
-		return err
-	}
-
-	for {
-		_, err = ri.Next(s.sqlCtx)
-		if err != nil {
-			return ri.Close(s.sqlCtx)
-		}
-	}
-}
-
-// getInsertNode returns the sql.Node to be iterated on given the import option.
-func (s *SqlEngineTableWriter) getInsertNode(inputChannel chan sql.Row) (sql.Node, error) {
-	switch s.importOption {
-	case CreateOp, ReplaceOp, AppendOp:
-		return s.createInsertImportNode(inputChannel, s.contOnErr, false, nil) // contonerr translates to ignore
-	case UpdateOp:
-		return s.createInsertImportNode(inputChannel, s.contOnErr, false, generateOnDuplicateKeyExpressions(s.rowOperationSchema.Schema)) // contonerr translates to ignore
-	default:
-		return nil, fmt.Errorf("unsupported import type")
-	}
+	_, err = sql.RowIterToRows(s.sqlCtx, sch, iter)
+	return err
 }
 
 // createInsertImportNode creates the relevant/analyzed insert node given the import option. This insert node is wrapped
 // with an error handler.
-func (s *SqlEngineTableWriter) createInsertImportNode(source chan sql.Row, ignore bool, replace bool, onDuplicateExpression []sql.Expression) (sql.Node, error) {
-	src := NewChannelRowSource(s.rowOperationSchema.Schema, source)
-	dest := plan.NewUnresolvedTable(s.tableName, s.database)
-
-	colNames := make([]string, 0)
+func (s *SqlEngineTableWriter) getInsertNode(inputChannel chan sql.Row, replace bool) (sql.Node, error) {
+	update := s.importOption == UpdateOp
+	colNames := ""
+	values := ""
+	duplicate := ""
+	if update {
+		duplicate += " ON DUPLICATE KEY UPDATE "
+	}
+	sep := ""
 	for _, col := range s.rowOperationSchema.Schema {
-		colNames = append(colNames, col.Name)
+		colNames += fmt.Sprintf("%s`%s`", sep, col.Name)
+		values += fmt.Sprintf("%s1", sep)
+		if update {
+			duplicate += fmt.Sprintf("%s`%s` = VALUES(`%s`)", sep, col.Name, col.Name)
+		}
+		sep = ", "
 	}
 
-	insert := plan.NewInsertInto(sql.UnresolvedDatabase(s.database), dest, src, replace, colNames, onDuplicateExpression, ignore)
-	analyzed, err := s.se.Analyze(s.sqlCtx, insert)
+	insert := fmt.Sprintf("insert into `%s` (%s) VALUES (%s)%s", s.tableName, colNames, values, duplicate)
+	parsed, err := planbuilder.Parse(s.sqlCtx, s.se.GetUnderlyingEngine().Analyzer.Catalog, insert)
+	if err != nil {
+		return nil, fmt.Errorf("error constructing import query '%s': %w", insert, err)
+	}
+	parsedIns, ok := parsed.(*plan.InsertInto)
+	if !ok {
+		return nil, fmt.Errorf("import setup expected *plan.InsertInto root, found %T", parsed)
+	}
+	schema := make(sql.Schema, len(s.rowOperationSchema.Schema))
+	for i, c := range s.rowOperationSchema.Schema {
+		newC := c.Copy()
+		newC.Source = planbuilder.OnDupValuesPrefix
+		schema[i] = newC
+	}
+	parsedIns.Source = NewChannelRowSource(schema, inputChannel)
+	parsedIns.Ignore = s.contOnErr
+	parsedIns.IsReplace = replace
+	analyzed, err := s.se.Analyze(s.sqlCtx, parsedIns)
 	if err != nil {
 		return nil, err
 	}
@@ -330,15 +348,3 @@ func (s *SqlEngineTableWriter) createInsertImportNode(source chan sql.Row, ignor
 
 	return analyzed, nil
 }
-
-// generateOnDuplicateKeyExpressions generates the duplicate key expressions needed for the update import option.
-func generateOnDuplicateKeyExpressions(sch sql.Schema) []sql.Expression {
-	ret := make([]sql.Expression, len(sch))
-	for i, col := range sch {
-		columnExpression := expression.NewUnresolvedColumn(col.Name)
-		functionExpression := expression.NewUnresolvedFunction("values", false, nil, expression.NewUnresolvedColumn(col.Name))
-		ret[i] = expression.NewSetField(columnExpression, functionExpression)
-	}
-
-	return ret
-}
diff --git a/go/libraries/doltcore/mvdata/file_data_loc.go b/go/libraries/doltcore/mvdata/file_data_loc.go
index 69d66523c5..60fbd97d76 100644
--- a/go/libraries/doltcore/mvdata/file_data_loc.go
+++ b/go/libraries/doltcore/mvdata/file_data_loc.go
@@ -22,6 +22,8 @@ import (
 	"os"
 	"strings"
 
+	"github.com/dolthub/dolt/go/libraries/doltcore/env"
+
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
 	"github.com/dolthub/dolt/go/libraries/doltcore/table"
@@ -75,7 +77,13 @@ func (dl FileDataLocation) Exists(ctx context.Context, root *doltdb.RootValue, f
 }
 
 // NewReader creates a TableReadCloser for the DataLocation
-func (dl FileDataLocation) NewReader(ctx context.Context, root *doltdb.RootValue, fs filesys.ReadableFS, opts interface{}) (rdCl table.SqlRowReader, sorted bool, err error) {
+func (dl FileDataLocation) NewReader(ctx context.Context, dEnv *env.DoltEnv, opts interface{}) (rdCl table.SqlRowReader, sorted bool, err error) {
+	fs := dEnv.FS
+	root, err := dEnv.WorkingRoot(ctx)
+	if err != nil {
+		return nil, false, err
+	}
+
 	exists, isDir := fs.Exists(dl.Path)
 
 	if !exists {
@@ -113,7 +121,7 @@ func (dl FileDataLocation) NewReader(ctx context.Context, root *doltdb.RootValue
 		var sch schema.Schema
 		jsonOpts, _ := opts.(JSONOptions)
 		if jsonOpts.SchFile != "" {
-			tn, s, err := SchAndTableNameFromFile(ctx, jsonOpts.SchFile, fs, root)
+			tn, s, err := SchAndTableNameFromFile(ctx, jsonOpts.SchFile, dEnv)
 			if err != nil {
 				return nil, false, err
 			}
@@ -145,7 +153,7 @@ func (dl FileDataLocation) NewReader(ctx context.Context, root *doltdb.RootValue
 		var tableSch schema.Schema
 		parquetOpts, _ := opts.(ParquetOptions)
 		if parquetOpts.SchFile != "" {
-			tn, s, tnErr := SchAndTableNameFromFile(ctx, parquetOpts.SchFile, fs, root)
+			tn, s, tnErr := SchAndTableNameFromFile(ctx, parquetOpts.SchFile, dEnv)
 			if tnErr != nil {
 				return nil, false, tnErr
 			}
diff --git a/go/libraries/doltcore/mvdata/stream_data_loc.go b/go/libraries/doltcore/mvdata/stream_data_loc.go
index 86ac6def4a..9da3f78711 100644
--- a/go/libraries/doltcore/mvdata/stream_data_loc.go
+++ b/go/libraries/doltcore/mvdata/stream_data_loc.go
@@ -19,6 +19,8 @@ import (
 	"errors"
 	"io"
 
+	"github.com/dolthub/dolt/go/libraries/doltcore/env"
+
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
 	"github.com/dolthub/dolt/go/libraries/doltcore/table"
@@ -46,7 +48,12 @@ func (dl StreamDataLocation) Exists(ctx context.Context, root *doltdb.RootValue,
 }
 
 // NewReader creates a TableReadCloser for the DataLocation
-func (dl StreamDataLocation) NewReader(ctx context.Context, root *doltdb.RootValue, fs filesys.ReadableFS, opts interface{}) (rdCl table.SqlRowReader, sorted bool, err error) {
+func (dl StreamDataLocation) NewReader(ctx context.Context, dEnv *env.DoltEnv, opts interface{}) (rdCl table.SqlRowReader, sorted bool, err error) {
+	root, err := dEnv.WorkingRoot(ctx)
+	if err != nil {
+		return nil, false, err
+	}
+
 	switch dl.Format {
 	case CsvFile:
 		delim := ","
diff --git a/go/libraries/doltcore/schema/encoding/integration_test.go b/go/libraries/doltcore/schema/encoding/integration_test.go
index cd0e735919..1e3a2d0867 100644
--- a/go/libraries/doltcore/schema/encoding/integration_test.go
+++ b/go/libraries/doltcore/schema/encoding/integration_test.go
@@ -22,6 +22,7 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
+	"github.com/dolthub/dolt/go/cmd/dolt/commands/engine"
 	"github.com/dolthub/dolt/go/libraries/doltcore/dtestutils"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema/encoding"
@@ -57,7 +58,12 @@ func parseSchemaString(t *testing.T, s string) schema.Schema {
 	defer dEnv.DoltDB.Close()
 	root, err := dEnv.WorkingRoot(ctx)
 	require.NoError(t, err)
-	_, sch, err := sqlutil.ParseCreateTableStatement(ctx, root, s)
+	eng, db, err := engine.NewSqlEngineForEnv(ctx, dEnv)
+	require.NoError(t, err)
+	sqlCtx, err := eng.NewDefaultContext(ctx)
+	require.NoError(t, err)
+	sqlCtx.SetCurrentDatabase(db)
+	_, sch, err := sqlutil.ParseCreateTableStatement(sqlCtx, root, eng.GetUnderlyingEngine(), s)
 	require.NoError(t, err)
 	return sch
 }
diff --git a/go/libraries/doltcore/schema/encoding/serialization.go b/go/libraries/doltcore/schema/encoding/serialization.go
index c824b852bc..2f66edd56d 100644
--- a/go/libraries/doltcore/schema/encoding/serialization.go
+++ b/go/libraries/doltcore/schema/encoding/serialization.go
@@ -20,7 +20,7 @@ import (
 
 	fb "github.com/dolthub/flatbuffers/v23/go"
 	"github.com/dolthub/go-mysql-server/sql"
-	"github.com/dolthub/go-mysql-server/sql/parse"
+	"github.com/dolthub/go-mysql-server/sql/planbuilder"
 
 	"github.com/dolthub/dolt/go/gen/fb/serial"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
@@ -287,7 +287,7 @@ func deserializeColumns(ctx context.Context, s *serial.TableSchema) ([]schema.Co
 	c := serial.Column{}
 	for i := range cols {
 		s.Columns(&c, i)
-		sqlType, err := typeinfoFromSqlType(ctx, string(c.SqlType()))
+		sqlType, err := typeinfoFromSqlType(string(c.SqlType()))
 		if err != nil {
 			return nil, err
 		}
@@ -538,12 +538,12 @@ func sqlTypeString(t typeinfo.TypeInfo) string {
 	return typ.String()
 }
 
-func typeinfoFromSqlType(ctx context.Context, s string) (typeinfo.TypeInfo, error) {
-	t, err := parse.ParseColumnTypeString(sql.NewContext(ctx), s)
+func typeinfoFromSqlType(s string) (typeinfo.TypeInfo, error) {
+	sqlType, err := planbuilder.ParseColumnTypeString(s)
 	if err != nil {
 		return nil, err
 	}
-	return typeinfo.FromSqlType(t)
+	return typeinfo.FromSqlType(sqlType)
 }
 
 func encodingFromTypeinfo(t typeinfo.TypeInfo) serial.Encoding {
diff --git a/go/libraries/doltcore/sqle/alterschema_test.go b/go/libraries/doltcore/sqle/alterschema_test.go
index b37afbeb40..8169859878 100644
--- a/go/libraries/doltcore/sqle/alterschema_test.go
+++ b/go/libraries/doltcore/sqle/alterschema_test.go
@@ -21,7 +21,7 @@ import (
 	"testing"
 
 	"github.com/dolthub/go-mysql-server/sql"
-	"github.com/dolthub/go-mysql-server/sql/parse"
+	"github.com/dolthub/go-mysql-server/sql/planbuilder"
 	gmstypes "github.com/dolthub/go-mysql-server/sql/types"
 	"github.com/dolthub/vitess/go/sqltypes"
 	"github.com/stretchr/testify/assert"
@@ -292,7 +292,7 @@ func makePeopleTable(ctx context.Context, dEnv *env.DoltEnv) (*env.DoltEnv, erro
 }
 
 func mustStringToColumnDefault(defaultString string) *sql.ColumnDefaultValue {
-	def, err := parse.StringToColumnDefaultValue(sql.NewEmptyContext(), defaultString)
+	def, err := planbuilder.StringToColumnDefaultValue(sql.NewEmptyContext(), defaultString)
 	if err != nil {
 		panic(err)
 	}
diff --git a/go/libraries/doltcore/sqle/binlogreplication/binlog_replica_applier.go b/go/libraries/doltcore/sqle/binlogreplication/binlog_replica_applier.go
index 50285cea46..954845b5fd 100644
--- a/go/libraries/doltcore/sqle/binlogreplication/binlog_replica_applier.go
+++ b/go/libraries/doltcore/sqle/binlogreplication/binlog_replica_applier.go
@@ -26,7 +26,7 @@ import (
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/binlogreplication"
 	"github.com/dolthub/go-mysql-server/sql/mysql_db"
-	"github.com/dolthub/go-mysql-server/sql/parse"
+	"github.com/dolthub/go-mysql-server/sql/planbuilder"
 	"github.com/dolthub/go-mysql-server/sql/rowexec"
 	"github.com/dolthub/go-mysql-server/sql/types"
 	"github.com/dolthub/vitess/go/mysql"
@@ -870,16 +870,16 @@ func convertVitessJsonExpressionString(ctx *sql.Context, value sqltypes.Value) (
 		strValue = strValue[len("EXPRESSION(") : len(strValue)-1]
 	}
 
-	node, err := parse.Parse(ctx, "SELECT "+strValue)
-	if err != nil {
-		return nil, err
-	}
-
 	server, _ := sqlserver.GetRunningServer()
 	if server == nil {
 		return nil, fmt.Errorf("unable to access running SQL server")
 	}
 
+	node, err := planbuilder.Parse(ctx, server.Engine.Analyzer.Catalog, "SELECT "+strValue)
+	if err != nil {
+		return nil, err
+	}
+
 	analyze, err := server.Engine.Analyzer.Analyze(ctx, node, nil)
 	if err != nil {
 		return nil, err
diff --git a/go/libraries/doltcore/sqle/common_test.go b/go/libraries/doltcore/sqle/common_test.go
index 5a03270e44..81d23ebb47 100644
--- a/go/libraries/doltcore/sqle/common_test.go
+++ b/go/libraries/doltcore/sqle/common_test.go
@@ -50,6 +50,8 @@ func executeSelect(t *testing.T, ctx context.Context, dEnv *env.DoltEnv, root *d
 		return nil, nil, err
 	}
 
+	engine.Analyzer.Verbose = true
+	engine.Analyzer.Debug = true
 	sch, iter, err := engine.Query(sqlCtx, query)
 	if err != nil {
 		return nil, nil, err
diff --git a/go/libraries/doltcore/sqle/database.go b/go/libraries/doltcore/sqle/database.go
index 635d468e26..07bbb5e5b2 100644
--- a/go/libraries/doltcore/sqle/database.go
+++ b/go/libraries/doltcore/sqle/database.go
@@ -24,9 +24,8 @@ import (
 
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/fulltext"
-	"github.com/dolthub/go-mysql-server/sql/parse"
-	"github.com/dolthub/go-mysql-server/sql/plan"
 	"github.com/dolthub/go-mysql-server/sql/types"
+	"github.com/dolthub/vitess/go/vt/sqlparser"
 	"gopkg.in/src-d/go-errors.v1"
 
 	"github.com/dolthub/dolt/go/libraries/doltcore/branch_control"
@@ -246,6 +245,9 @@ func (db Database) GetTableInsensitive(ctx *sql.Context, tblName string) (sql.Ta
 
 // GetTableInsensitiveAsOf implements sql.VersionedDatabase
 func (db Database) GetTableInsensitiveAsOf(ctx *sql.Context, tableName string, asOf interface{}) (sql.Table, bool, error) {
+	if asOf == nil {
+		return db.GetTableInsensitive(ctx, tableName)
+	}
 	head, root, err := resolveAsOf(ctx, db, asOf)
 	if err != nil {
 		return nil, false, err
@@ -1152,15 +1154,16 @@ func getViewDefinitionFromSchemaFragmentsOfView(ctx *sql.Context, tbl *WritableD
 	var viewDef sql.ViewDefinition
 	var views = make([]sql.ViewDefinition, len(fragments))
 	for i, fragment := range fragments {
-		cv, err := parse.ParseWithOptions(ctx, fragments[i].fragment,
+		cv, err := sqlparser.ParseWithOptions(fragments[i].fragment,
 			sql.NewSqlModeFromString(fragment.sqlMode).ParserOptions())
 		if err != nil {
 			return nil, sql.ViewDefinition{}, false, err
 		}
 
-		createView, ok := cv.(*plan.CreateView)
+		createView, ok := cv.(*sqlparser.DDL)
 		if ok {
-			views[i] = sql.ViewDefinition{Name: fragments[i].name, TextDefinition: createView.Definition.TextDefinition,
+			selectStr := fragments[i].fragment[createView.SubStatementPositionStart:createView.SubStatementPositionEnd]
+			views[i] = sql.ViewDefinition{Name: fragments[i].name, TextDefinition: selectStr,
 				CreateViewStatement: fragments[i].fragment, SqlMode: fragment.sqlMode}
 		} else {
 			views[i] = sql.ViewDefinition{Name: fragments[i].name, TextDefinition: fragments[i].fragment, CreateViewStatement: fmt.Sprintf("CREATE VIEW %s AS %s", fragments[i].name, fragments[i].fragment)}
diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go b/go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go
index 9154234a57..66363d2b2f 100644
--- a/go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go
+++ b/go/libraries/doltcore/sqle/enginetest/dolt_engine_test.go
@@ -576,11 +576,6 @@ func TestSpatialIndexPlans(t *testing.T) {
 	enginetest.TestSpatialIndexPlans(t, newDoltHarness(t))
 }
 
-func TestSpatialIndexPlansPrepared(t *testing.T) {
-	skipOldFormat(t)
-	enginetest.TestSpatialIndexPlansPrepared(t, newDoltHarness(t))
-}
-
 func TestTruncate(t *testing.T) {
 	h := newDoltHarness(t)
 	defer h.Close()
@@ -690,15 +685,6 @@ func TestJoinOps(t *testing.T) {
 	enginetest.TestJoinOps(t, h)
 }
 
-func TestJoinPlanningPrepared(t *testing.T) {
-	if types.IsFormat_LD(types.Format_Default) {
-		t.Skip("DOLT_LD keyless indexes are not sorted")
-	}
-	h := newDoltHarness(t).WithParallelism(1)
-	defer h.Close()
-	enginetest.TestJoinPlanningPrepared(t, h)
-}
-
 func TestJoinPlanning(t *testing.T) {
 	if types.IsFormat_LD(types.Format_Default) {
 		t.Skip("DOLT_LD keyless indexes are not sorted")
@@ -708,16 +694,6 @@ func TestJoinPlanning(t *testing.T) {
 	enginetest.TestJoinPlanning(t, h)
 }
 
-func TestJoinOpsPrepared(t *testing.T) {
-	if types.IsFormat_LD(types.Format_Default) {
-		t.Skip("DOLT_LD keyless indexes are not sorted")
-	}
-
-	h := newDoltHarness(t)
-	defer h.Close()
-	enginetest.TestJoinOpsPrepared(t, h)
-}
-
 func TestJoinQueries(t *testing.T) {
 	h := newDoltHarness(t)
 	defer h.Close()
@@ -1557,6 +1533,7 @@ func TestDoltMerge(t *testing.T) {
 		func() {
 			h := newDoltHarness(t).WithParallelism(1)
 			defer h.Close()
+			h.Setup(setup.MydbData)
 			enginetest.TestScript(t, h, script)
 		}()
 	}
@@ -2337,12 +2314,6 @@ func TestQueriesPrepared(t *testing.T) {
 	enginetest.TestQueriesPrepared(t, h)
 }
 
-func TestPreparedStaticIndexQuery(t *testing.T) {
-	h := newDoltHarness(t)
-	defer h.Close()
-	enginetest.TestPreparedStaticIndexQuery(t, h)
-}
-
 func TestStatistics(t *testing.T) {
 	h := newDoltHarness(t)
 	defer h.Close()
diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_harness.go b/go/libraries/doltcore/sqle/enginetest/dolt_harness.go
index 1499852ba1..1aef342dac 100644
--- a/go/libraries/doltcore/sqle/enginetest/dolt_harness.go
+++ b/go/libraries/doltcore/sqle/enginetest/dolt_harness.go
@@ -278,6 +278,7 @@ func (d *DoltHarness) newSessionWithClient(client sql.Client) *dsess.DoltSession
 	pro := d.session.Provider()
 
 	dSession, err := dsess.NewDoltSession(sql.NewBaseSessionWithClientServer("address", client, 1), pro.(dsess.DoltDatabaseProvider), localConfig, d.branchControl)
+	dSession.SetCurrentDatabase("mydb")
 	require.NoError(d.t, err)
 	return dSession
 }
diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_queries.go b/go/libraries/doltcore/sqle/enginetest/dolt_queries.go
index 9a2d23e682..1a6d392fab 100644
--- a/go/libraries/doltcore/sqle/enginetest/dolt_queries.go
+++ b/go/libraries/doltcore/sqle/enginetest/dolt_queries.go
@@ -20,9 +20,10 @@ import (
 
 	"github.com/dolthub/go-mysql-server/enginetest/queries"
 	"github.com/dolthub/go-mysql-server/sql"
-	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/plan"
 	"github.com/dolthub/go-mysql-server/sql/types"
+	"github.com/dolthub/vitess/go/sqltypes"
+	"github.com/dolthub/vitess/go/vt/proto/query"
 
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle"
 )
@@ -895,29 +896,29 @@ var DoltScripts = []queries.ScriptTest{
 			{
 				Query:    "select * from test as of 'HEAD~' where pk=?;",
 				Expected: []sql.Row{{0, 0}},
-				Bindings: map[string]sql.Expression{
-					"v1": expression.NewLiteral(0, types.Int8),
+				Bindings: map[string]*query.BindVariable{
+					"v1": sqltypes.Int8BindVariable(int8(0)),
 				},
 			},
 			{
 				Query:    "select * from test as of hashof('HEAD') where pk=?;",
 				Expected: []sql.Row{{1, 1, nil}},
-				Bindings: map[string]sql.Expression{
-					"v1": expression.NewLiteral(1, types.Int8),
+				Bindings: map[string]*query.BindVariable{
+					"v1": sqltypes.Int8BindVariable(int8(1)),
 				},
 			},
 			{
 				Query:    "select * from test as of @Commit1 where pk=?;",
 				Expected: []sql.Row{{0, 0}},
-				Bindings: map[string]sql.Expression{
-					"v1": expression.NewLiteral(0, types.Int8),
+				Bindings: map[string]*query.BindVariable{
+					"v1": sqltypes.Int8BindVariable(int8(0)),
 				},
 			},
 			{
 				Query:    "select * from test as of @Commit2 where pk=?;",
 				Expected: []sql.Row{{0, 0, nil}},
-				Bindings: map[string]sql.Expression{
-					"v1": expression.NewLiteral(0, types.Int8),
+				Bindings: map[string]*query.BindVariable{
+					"v1": sqltypes.Int8BindVariable(int8(0)),
 				},
 			},
 		},
@@ -2123,7 +2124,7 @@ WHERE z IN (
   FROM dolt_history_xyz
   LEFT JOIN dolt_commits
   ON dolt_history_xyz.commit_hash = dolt_commits.commit_hash
-);;`,
+);`,
 				Expected: []sql.Row{
 					{100},
 					{200},
diff --git a/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go b/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
index 914d0576ed..4eea7641e1 100644
--- a/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
+++ b/go/libraries/doltcore/sqle/enginetest/dolt_queries_diff.go
@@ -521,7 +521,7 @@ var DiffSystemTableScriptTests = []queries.ScriptTest{
 				SkipResultsCheck:                true,
 			},
 			{
-				Query:    "SELECT COUNT(*) FROM DOLT_DIFF_t;;",
+				Query:    "SELECT COUNT(*) FROM DOLT_DIFF_t;",
 				Expected: []sql.Row{{1}},
 			},
 			{
diff --git a/go/libraries/doltcore/sqle/enginetest/testgen_test.go b/go/libraries/doltcore/sqle/enginetest/testgen_test.go
index 721e18468d..fc7dba2597 100644
--- a/go/libraries/doltcore/sqle/enginetest/testgen_test.go
+++ b/go/libraries/doltcore/sqle/enginetest/testgen_test.go
@@ -22,7 +22,7 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/dolthub/go-mysql-server/sql/parse"
+	"github.com/dolthub/go-mysql-server/sql/planbuilder"
 
 	"github.com/dolthub/go-mysql-server/enginetest"
 	"github.com/dolthub/go-mysql-server/enginetest/queries"
@@ -47,7 +47,7 @@ func TestGenNewFormatQueryPlans(t *testing.T) {
 	for _, tt := range queries.PlanTests {
 		_, _ = w.WriteString("\t{\n")
 		ctx := enginetest.NewContextWithEngine(harness, engine)
-		parsed, err := parse.Parse(ctx, tt.Query)
+		parsed, err := planbuilder.Parse(ctx, engine.Analyzer.Catalog, tt.Query)
 		require.NoError(t, err)
 
 		node, err := engine.Analyzer.Analyze(ctx, parsed, nil)
diff --git a/go/libraries/doltcore/sqle/index/mergeable_indexes_test.go b/go/libraries/doltcore/sqle/index/mergeable_indexes_test.go
index 8fb72d3bfb..ebd8c75357 100644
--- a/go/libraries/doltcore/sqle/index/mergeable_indexes_test.go
+++ b/go/libraries/doltcore/sqle/index/mergeable_indexes_test.go
@@ -20,8 +20,8 @@ import (
 
 	sqle "github.com/dolthub/go-mysql-server"
 	"github.com/dolthub/go-mysql-server/sql"
-	"github.com/dolthub/go-mysql-server/sql/parse"
 	"github.com/dolthub/go-mysql-server/sql/plan"
+	"github.com/dolthub/go-mysql-server/sql/planbuilder"
 	"github.com/dolthub/go-mysql-server/sql/transform"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -1564,7 +1564,7 @@ func TestMergeableIndexesNulls(t *testing.T) {
 }
 
 func ReadRangesFromQuery(ctx *sql.Context, eng *sqle.Engine, query string) ([]*noms.ReadRange, error) {
-	parsed, err := parse.Parse(ctx, query)
+	parsed, err := planbuilder.Parse(ctx, eng.Analyzer.Catalog, query)
 	if err != nil {
 		return nil, err
 	}
diff --git a/go/libraries/doltcore/sqle/sqlddl_test.go b/go/libraries/doltcore/sqle/sqlddl_test.go
index 9fb79b84ea..4a83ba5e92 100644
--- a/go/libraries/doltcore/sqle/sqlddl_test.go
+++ b/go/libraries/doltcore/sqle/sqlddl_test.go
@@ -20,7 +20,9 @@ import (
 	"strings"
 	"testing"
 
+	gms "github.com/dolthub/go-mysql-server"
 	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/analyzer"
 	gmstypes "github.com/dolthub/go-mysql-server/sql/types"
 	"github.com/dolthub/vitess/go/sqltypes"
 	"github.com/stretchr/testify/assert"
@@ -31,6 +33,7 @@ import (
 	"github.com/dolthub/dolt/go/libraries/doltcore/env"
 	"github.com/dolthub/dolt/go/libraries/doltcore/row"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
+	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dsess"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/dtables"
 	"github.com/dolthub/dolt/go/libraries/doltcore/sqle/sqlutil"
 	"github.com/dolthub/dolt/go/store/types"
@@ -892,7 +895,7 @@ func TestParseCreateTableStatement(t *testing.T) {
 		{
 			name:          "Test create table starting with number",
 			query:         "create table 123table (id int primary key)",
-			expectedTable: "`123table`",
+			expectedTable: "123table",
 			expectedSchema: dtestutils.CreateSchema(
 				schemaNewColumn(t, "id", 4817, gmstypes.Int32, true, schema.NotNullConstraint{})),
 		},
@@ -1076,8 +1079,17 @@ func TestParseCreateTableStatement(t *testing.T) {
 			defer dEnv.DoltDB.Close()
 			ctx := context.Background()
 			root, _ := dEnv.WorkingRoot(ctx)
+			//eng, dbName, _ := engine.NewSqlEngineForEnv(ctx, dEnv)
+			eng, sqlCtx := newTestEngine(ctx, dEnv)
 
-			tblName, sch, err := sqlutil.ParseCreateTableStatement(ctx, root, tt.query)
+			testSch, iter, err := eng.Query(sqlCtx, "create database test")
+			if err != nil {
+				panic(err)
+			}
+			_, _ = sql.RowIterToRows(sqlCtx, testSch, iter)
+			sqlCtx.SetCurrentDatabase("test")
+
+			tblName, sch, err := sqlutil.ParseCreateTableStatement(sqlCtx, root, eng, tt.query)
 
 			if tt.expectedErr != "" {
 				require.Error(t, err)
@@ -1091,6 +1103,30 @@ func TestParseCreateTableStatement(t *testing.T) {
 	}
 }
 
+func newTestEngine(ctx context.Context, dEnv *env.DoltEnv) (*gms.Engine, *sql.Context) {
+	pro, err := NewDoltDatabaseProviderWithDatabases("main", dEnv.FS, nil, nil)
+	if err != nil {
+		panic(err)
+	}
+
+	mrEnv, err := env.MultiEnvForDirectory(ctx, dEnv.Config.WriteableConfig(), dEnv.FS, dEnv.Version, dEnv.IgnoreLockFile, dEnv)
+	if err != nil {
+		panic(err)
+	}
+
+	doltSession, err := dsess.NewDoltSession(sql.NewBaseSession(), pro, dEnv.Config.WriteableConfig(), nil)
+	if err != nil {
+		panic(err)
+	}
+
+	sqlCtx := sql.NewContext(ctx, sql.WithSession(doltSession))
+	sqlCtx.SetCurrentDatabase(mrEnv.GetFirstDatabase())
+
+	return gms.New(analyzer.NewBuilder(pro).WithParallelism(1).Build(), &gms.Config{
+		IsReadOnly:     false,
+		IsServerLocked: false,
+	}), sqlCtx
+}
 func TestIndexOverwrite(t *testing.T) {
 	ctx := context.Background()
 	dEnv := dtestutils.CreateTestEnv()
diff --git a/go/libraries/doltcore/sqle/sqlutil/schema.go b/go/libraries/doltcore/sqle/sqlutil/schema.go
index 2ad6f63463..60f39f4112 100644
--- a/go/libraries/doltcore/sqle/sqlutil/schema.go
+++ b/go/libraries/doltcore/sqle/sqlutil/schema.go
@@ -15,13 +15,13 @@
 package sqlutil
 
 import (
-	"context"
+	"fmt"
 	"strings"
 
+	sqle "github.com/dolthub/go-mysql-server"
 	"github.com/dolthub/go-mysql-server/sql"
-	"github.com/dolthub/go-mysql-server/sql/parse"
 	"github.com/dolthub/go-mysql-server/sql/plan"
-	"github.com/dolthub/vitess/go/vt/sqlparser"
+	"github.com/dolthub/go-mysql-server/sql/planbuilder"
 
 	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
 	"github.com/dolthub/dolt/go/libraries/doltcore/schema"
@@ -29,43 +29,22 @@ import (
 
 // ParseCreateTableStatement will parse a CREATE TABLE ddl statement and use it to create a Dolt Schema. A RootValue
 // is used to generate unique tags for the Schema
-func ParseCreateTableStatement(ctx context.Context, root *doltdb.RootValue, query string) (string, schema.Schema, error) {
-	// todo: verify create table statement
-	p, err := sqlparser.Parse(query)
+func ParseCreateTableStatement(ctx *sql.Context, root *doltdb.RootValue, engine *sqle.Engine, query string) (string, schema.Schema, error) {
+	parsed, err := planbuilder.Parse(ctx, engine.Analyzer.Catalog, query)
 	if err != nil {
 		return "", nil, err
 	}
-	ddl := p.(*sqlparser.DDL)
+	create, ok := parsed.(*plan.CreateTable)
+	if !ok {
+		return "", nil, fmt.Errorf("expected create table, found %T", create)
+	}
 
-	sctx := sql.NewContext(ctx)
-	s, collation, err := parse.TableSpecToSchema(sctx, ddl.TableSpec, false)
+	sch, err := ToDoltSchema(ctx, root, create.Name(), create.CreateSchema, nil, create.Collation)
 	if err != nil {
 		return "", nil, err
 	}
 
-	for _, col := range s.Schema {
-		if collatedType, ok := col.Type.(sql.TypeWithCollation); ok {
-			col.Type, err = collatedType.WithNewCollation(sql.Collation_Default)
-			if err != nil {
-				return "", nil, err
-			}
-		}
-	}
-
-	buf := sqlparser.NewTrackedBuffer(nil)
-	ddl.Table.Format(buf)
-	tableName := buf.String()
-	sch, err := ToDoltSchema(ctx, root, tableName, s, nil, collation)
-	if err != nil {
-		return "", nil, err
-	}
-
-	indexes, err := parse.ConvertIndexDefs(sctx, ddl.TableSpec)
-	if err != nil {
-		return "", nil, err
-	}
-
-	for _, idx := range indexes {
+	for _, idx := range create.IdxDefs {
 		var prefixes []uint16
 		for _, c := range idx.Columns {
 			prefixes = append(prefixes, uint16(c.Length))
@@ -84,18 +63,14 @@ func ParseCreateTableStatement(ctx context.Context, root *doltdb.RootValue, quer
 	}
 
 	// foreign keys are stored on the *doltdb.Table object, ignore them here
-	_, checks, err := parse.ConvertConstraintsDefs(sctx, ddl.Table, ddl.TableSpec)
-	if err != nil {
-		return "", nil, err
-	}
-	for _, chk := range checks {
+	for _, chk := range create.ChDefs {
 		name := getCheckConstraintName(chk)
 		_, err = sch.Checks().AddCheck(name, chk.Expr.String(), chk.Enforced)
 		if err != nil {
 			return "", nil, err
 		}
 	}
-	return tableName, sch, err
+	return create.Name(), sch, err
 }
 
 func getIndexName(def *plan.IndexDefinition) string {
diff --git a/go/utils/repofmt/check_prepared_tests.sh b/go/utils/repofmt/check_prepared_tests.sh
deleted file mode 100755
index 2939cae2c5..0000000000
--- a/go/utils/repofmt/check_prepared_tests.sh
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/bash
-
-set -eo pipefail
-
-script_dir=$(dirname "$0")
-cd $script_dir/../..
-
-enginetest_path=libraries/doltcore/sqle/enginetest/dolt_engine_test.go
-all_cnt=$(grep "func Test.*" "$enginetest_path" | wc -l |  tr -dc '0-9')
-prep_cnt=$(grep "func Test.*Prepared" "$enginetest_path" | wc -l | tr -dc '0-9')
-test_cnt=$((all_cnt-prep_cnt))
-skip_cnt=$(grep "SkipPreparedsCount" "$enginetest_path" | awk '{print $4}' | tr -dc '0-9')
-
-expected="$((test_cnt-skip_cnt))"
-if [[ "$expected" != "$prep_cnt" ]]; then
-    echo "Expected '$expected' enginetests with name 'Test.*Prepared' in dolt_engine_test.go, found: '$prep_cnt'"
-    echo "Either increment SkipPreparedsCount or add a prepared test for the new test suite"
-    exit 1
-fi
-
diff --git a/integration-tests/bats/blame.bats b/integration-tests/bats/blame.bats
index 70320875be..0a2a755e18 100644
--- a/integration-tests/bats/blame.bats
+++ b/integration-tests/bats/blame.bats
@@ -139,8 +139,8 @@ SQL
 
 @test "blame: returns an error when the table is not found in the given revision" {
     run dolt blame HEAD~4 blame_test
-    [ "$status" -eq 0 ]
-    [[ "$output" = "" ]] || false
+    [ "$status" -eq 1 ]
+    [[ "$output" = "table not found: dolt_diff_blame_test" ]] || false
 }
 
 @test "blame: pk ordered output" {
diff --git a/integration-tests/bats/case-sensitivity.bats b/integration-tests/bats/case-sensitivity.bats
index dace3bcfac..4e9d4c2336 100644
--- a/integration-tests/bats/case-sensitivity.bats
+++ b/integration-tests/bats/case-sensitivity.bats
@@ -131,5 +131,5 @@ teardown() {
     run dolt sql -q "select AaA from Test order by 1 limit 1"
     [ "$status" -eq 0 ]
     [[ "$output" =~ "1" ]] || false
-    [[ "$output" =~ "Aaa" ]] || false
+    [[ "$output" =~ "AaA" ]] || false
 }
diff --git a/integration-tests/bats/sql-config.bats b/integration-tests/bats/sql-config.bats
index b4f8fd3f7a..885d4506e2 100644
--- a/integration-tests/bats/sql-config.bats
+++ b/integration-tests/bats/sql-config.bats
@@ -97,7 +97,7 @@ teardown() {
     run dolt sql -q "SELECT @@GLOBAL.unknown" -r csv
     [ "$status" -eq 1 ]
     [[ ! "$output" =~ "panic" ]] || false
-    [[ "$output" =~ "Unknown system variable 'unknown'" ]] || false
+    [[ "$output" =~ "Unknown system variable '@@global.unknown'" ]] || false
 }
 
 @test "sql-config: invalid persisted system variable type errors on cli sql command" {
diff --git a/integration-tests/bats/sql-create-tables.bats b/integration-tests/bats/sql-create-tables.bats
index e607201c6f..9084788c5d 100644
--- a/integration-tests/bats/sql-create-tables.bats
+++ b/integration-tests/bats/sql-create-tables.bats
@@ -765,7 +765,7 @@ DROP TABLE myTempTABLE;
 SELECT * FROM myTempTable;
 SQL
     [ "$status" -eq 1 ]
-    [[ "$output" =~ "table not found: myTempTable" ]] || false
+    [[ "$output" =~ "table not found: mytemptable" ]] || false
 }
 
 @test "sql-create-tables: BINARY attributes" {
@@ -790,4 +790,4 @@ SQL
     [ "$status" -eq 0 ]
     [[ "$output" =~ "2,2" ]] || false
 
-}
\ No newline at end of file
+}
diff --git a/integration-tests/bats/sql.bats b/integration-tests/bats/sql.bats
index ac306c9609..8c7e66460c 100755
--- a/integration-tests/bats/sql.bats
+++ b/integration-tests/bats/sql.bats
@@ -1085,7 +1085,7 @@ SQL
 @test "sql: ambiguous column name" {
     run dolt sql -q "select pk,pk1,pk2 from one_pk,two_pk where c1=0"
     [ "$status" -eq 1 ]
-    [[ "$output" =~ "ambiguous column name \"c1\", it's present in all these tables: one_pk, two_pk" ]] || false
+    [[ "$output" =~ "ambiguous column name \"c1\", it's present in all these tables: [two_pk one_pk]" ]] || false
 }
 
 @test "sql: select with and and or clauses" {