Experimenting with switching on MySQL/PostgreSQL behavior

Author: fulghum

sql/analyzer/analyzer.go

@@ -274,6 +274,7 @@ func (ab *Builder) Build() *Analyzer {
 		Parallelism:  ab.parallelism,
 		Coster:       memo.NewDefaultCoster(),
 		ExecBuilder:  rowexec.DefaultBuilder,
+		DatabaseType: sql.EngineType_MySql,
 	}
 }
 
@@ -298,6 +299,9 @@ type Analyzer struct {
 	// EventScheduler is used to communiate with the event scheduler
 	// for any EVENT related statements. It can be nil if EventScheduler is not defined.
 	EventScheduler sql.EventScheduler
+	// DatabaseType indicates whether the analyzer's behavior is compatible with a MySQL
+	// database or a PostgreSQL database.
+	DatabaseType sql.EngineType
 }
 
 // NewDefault creates a default Analyzer instance with all default Rules and configuration.

sql/analyzer/validate_create_table.go

@@ -44,7 +44,8 @@ func validateCreateTable(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.
 	if err != nil {
 		return nil, transform.SameTree, err
 	}
-	err = validateIndexes(ctx, sch, idxs, strictMySQLCompat)
+	validatePrefixLengths := a.DatabaseType == sql.EngineType_MySql
+	err = validateIndexes(ctx, sch, idxs, strictMySQLCompat, validatePrefixLengths)
 	if err != nil {
 		return nil, transform.SameTree, err
 	}
@@ -226,6 +227,7 @@ func resolveAlterColumn(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.S
 	initialSch := sch
 
 	addedColumn := false
+	validatePrefixLengths := a.DatabaseType == sql.EngineType_MySql
 
 	// Need a TransformUp here because multiple of these statement types can be nested under a Block node.
 	// It doesn't look it, but this is actually an iterative loop over all the independent clauses in an ALTER statement
@@ -237,7 +239,7 @@ func resolveAlterColumn(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.S
 				return nil, transform.SameTree, err
 			}
 
-			sch, err = validateModifyColumn(ctx, initialSch, sch, n.(*plan.ModifyColumn), keyedColumns)
+			sch, err = validateModifyColumn(ctx, initialSch, sch, n.(*plan.ModifyColumn), keyedColumns, validatePrefixLengths)
 			if err != nil {
 				return nil, transform.SameTree, err
 			}
@@ -282,7 +284,7 @@ func resolveAlterColumn(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.S
 			if err != nil {
 				return nil, transform.SameTree, err
 			}
-			indexes, err = validateAlterIndex(ctx, initialSch, sch, n.(*plan.AlterIndex), indexes)
+			indexes, err = validateAlterIndex(ctx, sch, n.(*plan.AlterIndex), indexes, validatePrefixLengths)
 			if err != nil {
 				return nil, transform.SameTree, err
 			}
@@ -294,7 +296,7 @@ func resolveAlterColumn(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.S
 			if err != nil {
 				return nil, transform.SameTree, err
 			}
-			sch, err = validatePrimaryKey(ctx, initialSch, sch, n.(*plan.AlterPK))
+			sch, err = validatePrimaryKey(ctx, sch, n.(*plan.AlterPK), validatePrefixLengths)
 			if err != nil {
 				return nil, transform.SameTree, err
 			}
@@ -446,7 +448,9 @@ func isStrictMysqlCompatibilityEnabled(ctx *sql.Context) (bool, error) {
 	return i == 1, nil
 }
 
-func validateModifyColumn(ctx *sql.Context, initialSch sql.Schema, schema sql.Schema, mc *plan.ModifyColumn, keyedColumns map[string]bool) (sql.Schema, error) {
+// validateModifyColumn validates the |mc| ModifyColumn node and returns the updated schema. If
+// |validatePrefixLengths| is true, then prefix lengths on TEXT/BLOB columns will also be validated.
+func validateModifyColumn(ctx *sql.Context, initialSch sql.Schema, schema sql.Schema, mc *plan.ModifyColumn, keyedColumns map[string]bool, validatePrefixLengths bool) (sql.Schema, error) {
 	table := mc.Table
 	tableName := table.(sql.Nameable).Name()
 
@@ -496,7 +500,6 @@ func validateModifyColumn(ctx *sql.Context, initialSch sql.Schema, schema sql.Sc
 		if index.IsFullText() {
 			continue
 		}
-		prefixLengths := index.PrefixLengths()
 		for i, expr := range index.Expressions() {
 			col := plan.GetColumnFromIndexExpr(expr, tbl)
 			if !strings.EqualFold(col.Name, oldColName) {
@@ -505,13 +508,16 @@ func validateModifyColumn(ctx *sql.Context, initialSch sql.Schema, schema sql.Sc
 			if types.IsJSON(newCol.Type) {
 				return nil, sql.ErrJSONIndex.New(col.Name)
 			}
-			var prefixLen int64
-			if i < len(prefixLengths) {
-				prefixLen = int64(prefixLengths[i])
-			}
-			err = validatePrefixLength(ctx, oldColName, prefixLen, newCol.Type, strictMySQLCompat, index.IsUnique())
-			if err != nil {
-				return nil, err
+
+			if validatePrefixLengths {
+				var prefixLen int64
+				if i < len(index.PrefixLengths()) {
+					prefixLen = int64(index.PrefixLengths()[i])
+				}
+				err = validatePrefixLength(ctx, oldColName, prefixLen, newCol.Type, strictMySQLCompat, index.IsUnique())
+				if err != nil {
+					return nil, err
+				}
 			}
 		}
 	}
@@ -619,8 +625,9 @@ func validateColumnSafeToDropWithCheckConstraint(columnName string, checks sql.C
 }
 
 // validateAlterIndex validates the specified column can have an index added, dropped, or renamed. Returns an updated
-// list of index name given the add, drop, or rename operations.
-func validateAlterIndex(ctx *sql.Context, initialSch, sch sql.Schema, ai *plan.AlterIndex, indexes []string) ([]string, error) {
+// list of index name given the add, drop, or rename operations. If |validatePrefixLengths| is true, then index prefix
+// lengths on TEXT and BLOB columns will also be validated.
+func validateAlterIndex(ctx *sql.Context, sch sql.Schema, ai *plan.AlterIndex, indexes []string, validatePrefixLengths bool) ([]string, error) {
 	switch ai.Action {
 	case plan.IndexAction_Create:
 		err := validateIdentifier(ai.IndexName)
@@ -640,7 +647,7 @@ func validateAlterIndex(ctx *sql.Context, initialSch, sch sql.Schema, ai *plan.A
 			Storage:    ai.Using,
 			Comment:    ai.Comment,
 		}
-		err = validateIndex(ctx, colMap, indexDef, strictMySQLCompat)
+		err = validateIndex(ctx, colMap, indexDef, strictMySQLCompat, validatePrefixLengths)
 		if err != nil {
 			return nil, err
 		}
@@ -839,14 +846,14 @@ func schToColMap(sch sql.Schema) map[string]*sql.Column {
 }
 
 // validateIndexes prevents creating tables with blob/text primary keys and indexes without a specified length
-func validateIndexes(ctx *sql.Context, sch sql.Schema, idxDefs sql.IndexDefs, strictMySQLCompat bool) error {
+func validateIndexes(ctx *sql.Context, sch sql.Schema, idxDefs sql.IndexDefs, strictMySQLCompat bool, validatePrefixLengths bool) error {
 	colMap := schToColMap(sch)
 	var hasPkIndexDef bool
 	for _, idxDef := range idxDefs {
 		if idxDef.IsPrimary() {
 			hasPkIndexDef = true
 		}
-		if err := validateIndex(ctx, colMap, idxDef, strictMySQLCompat); err != nil {
+		if err := validateIndex(ctx, colMap, idxDef, strictMySQLCompat, validatePrefixLengths); err != nil {
 			return err
 		}
 	}
@@ -865,13 +872,14 @@ func validateIndexes(ctx *sql.Context, sch sql.Schema, idxDefs sql.IndexDefs, st
 }
 
 // validateIndex ensures that the Index Definition is valid for the table schema.
-// This function will throw errors and warnings as needed.
-// All columns in the index must be:
+// This function will throw errors and warnings as needed. If |validatePrefixLengths| is
+// true, then TEXT and BLOB columns included in the index will also be checked to ensure
+// they include a valid prefix length. All columns in the index must be:
 //   - in the schema
 //   - not duplicated
 //   - not JSON Type
 //   - have the proper prefix length
-func validateIndex(ctx *sql.Context, colMap map[string]*sql.Column, idxDef *sql.IndexDef, strictMySQLCompat bool) error {
+func validateIndex(ctx *sql.Context, colMap map[string]*sql.Column, idxDef *sql.IndexDef, strictMySQLCompat, validatePrefixLengths bool) error {
 	seenCols := make(map[string]struct{})
 	for _, idxCol := range idxDef.Columns {
 		schCol, exists := colMap[strings.ToLower(idxCol.Name)]
@@ -890,9 +898,11 @@ func validateIndex(ctx *sql.Context, colMap map[string]*sql.Column, idxDef *sql.
 			continue
 		}
 
-		err := validatePrefixLength(ctx, idxCol.Name, idxCol.Length, schCol.Type, strictMySQLCompat, idxDef.IsUnique())
-		if err != nil {
-			return err
+		if validatePrefixLengths {
+			err := validatePrefixLength(ctx, idxCol.Name, idxCol.Length, schCol.Type, strictMySQLCompat, idxDef.IsUnique())
+			if err != nil {
+				return err
+			}
 		}
 	}
 
@@ -957,8 +967,9 @@ func getTableIndexNames(ctx *sql.Context, _ *Analyzer, table sql.Node) ([]string
 	return names, nil
 }
 
-// validatePrimaryKey validates a primary key add or drop operation.
-func validatePrimaryKey(ctx *sql.Context, initialSch, sch sql.Schema, ai *plan.AlterPK) (sql.Schema, error) {
+// validatePrimaryKey validates a primary key add or drop operation. If |validatePrefixLengths| is true, then
+// TEXT and BLOB columns will be checked for a valid prefix length.
+func validatePrimaryKey(ctx *sql.Context, sch sql.Schema, ai *plan.AlterPK, validatePrefixLengths bool) (sql.Schema, error) {
 	tableName := getTableName(ai.Table)
 	switch ai.Action {
 	case plan.PrimaryKeyAction_Create:
@@ -976,7 +987,7 @@ func validatePrimaryKey(ctx *sql.Context, initialSch, sch sql.Schema, ai *plan.A
 		if err != nil {
 			return nil, err
 		}
-		err = validateIndex(ctx, colMap, idxDef, strictMySQLCompat)
+		err = validateIndex(ctx, colMap, idxDef, strictMySQLCompat, validatePrefixLengths)
 		if err != nil {
 			return nil, err
 		}

sql/engines.go

@@ -16,6 +16,15 @@ package sql
 
 import "fmt"
 
+// EngineType indicates which type of database is being emulated. This is used to switch
+// between MySQL behavior and PostgreSQL behavior.
+type EngineType byte
+
+const (
+	EngineType_MySql EngineType = iota
+	EngineType_Postgres
+)
+
 // Engine represents a sql engine.
 type Engine struct {
 	Name        string