User defined and sys variables

go/mysql/binlog_event_make_test.go

@@ -292,7 +292,7 @@ func TestTableMapEvent(t *testing.T) {
 
 	tableID := event.TableID(f)
 	if tableID != 0x102030405060 {
-		t.Fatalf("NewTableMapEvent().TableID returned %x", tableID)
+		t.Fatalf("NewTableMapEvent().ID returned %x", tableID)
 	}
 	gotTm, err := event.TableMap(f)
 	if err != nil {
@@ -310,9 +310,9 @@ func TestRowsEvent(t *testing.T) {
 	/*
 		    Reason for nolint
 		    Used in line 384 to 387
-		    tableID = event.TableID(f)
+		    tableID = event.ID(f)
 				if tableID != 0x102030405060 {
-					t.Fatalf("NewRowsEvent().TableID returned %x", tableID)
+					t.Fatalf("NewRowsEvent().ID returned %x", tableID)
 				}
 	*/
 	tableID := uint64(0x102030405060) //nolint
@@ -388,7 +388,7 @@ func TestRowsEvent(t *testing.T) {
 
 	tableID = event.TableID(f)
 	if tableID != 0x102030405060 {
-		t.Fatalf("NewRowsEvent().TableID returned %x", tableID)
+		t.Fatalf("NewRowsEvent().ID returned %x", tableID)
 	}
 	gotRows, err := event.Rows(f, tm)
 	if err != nil {

go/test/utils/diff.go

@@ -17,9 +17,12 @@ limitations under the License.
 package utils
 
 import (
+	"os"
 	"reflect"
 	"testing"
 
+	"github.com/stretchr/testify/require"
+
 	"google.golang.org/protobuf/encoding/prototext"
 
 	"google.golang.org/protobuf/proto"
@@ -102,3 +105,18 @@ func MustMatchPB(t *testing.T, expected string, pb proto.Message) {
 
 	MustMatch(t, expectedPb, pb)
 }
+
+func MakeTestOutput(t *testing.T, dir, pattern string) string {
+	testOutputTempDir, err := os.MkdirTemp(dir, pattern)
+	require.NoError(t, err)
+
+	t.Cleanup(func() {
+		if !t.Failed() {
+			_ = os.RemoveAll(testOutputTempDir)
+		} else {
+			t.Logf("Errors found in plantests. If the output is correct, run `cp %s/* testdata/` to update test expectations", testOutputTempDir)
+		}
+	})
+
+	return testOutputTempDir
+}

go/vt/binlog/binlog_streamer.go

@@ -479,7 +479,7 @@ func (bls *Streamer) parseEvents(ctx context.Context, events <-chan mysql.Binlog
 			}
 
 			// Find and fill in the table schema.
-			tce.ti = bls.se.GetTable(sqlparser.NewTableIdent(tm.Name))
+			tce.ti = bls.se.GetTable(sqlparser.NewIdentifierCS(tm.Name))
 			if tce.ti == nil {
 				return pos, fmt.Errorf("unknown table %v in schema", tm.Name)
 			}
@@ -604,7 +604,7 @@ func (bls *Streamer) parseEvents(ctx context.Context, events <-chan mysql.Binlog
 func (bls *Streamer) appendInserts(statements []FullBinlogStatement, tce *tableCacheEntry, rows *mysql.Rows) []FullBinlogStatement {
 	for i := range rows.Rows {
 		sql := sqlparser.NewTrackedBuffer(nil)
-		sql.Myprintf("INSERT INTO %v SET ", sqlparser.NewTableIdent(tce.tm.Name))
+		sql.Myprintf("INSERT INTO %v SET ", sqlparser.NewIdentifierCS(tce.tm.Name))
 
 		keyspaceIDCell, pkValues, err := writeValuesAsSQL(sql, tce, rows, i, tce.pkNames != nil)
 		if err != nil {
@@ -640,7 +640,7 @@ func (bls *Streamer) appendInserts(statements []FullBinlogStatement, tce *tableC
 func (bls *Streamer) appendUpdates(statements []FullBinlogStatement, tce *tableCacheEntry, rows *mysql.Rows) []FullBinlogStatement {
 	for i := range rows.Rows {
 		sql := sqlparser.NewTrackedBuffer(nil)
-		sql.Myprintf("UPDATE %v SET ", sqlparser.NewTableIdent(tce.tm.Name))
+		sql.Myprintf("UPDATE %v SET ", sqlparser.NewIdentifierCS(tce.tm.Name))
 
 		keyspaceIDCell, pkValues, err := writeValuesAsSQL(sql, tce, rows, i, tce.pkNames != nil)
 		if err != nil {
@@ -683,7 +683,7 @@ func (bls *Streamer) appendUpdates(statements []FullBinlogStatement, tce *tableC
 func (bls *Streamer) appendDeletes(statements []FullBinlogStatement, tce *tableCacheEntry, rows *mysql.Rows) []FullBinlogStatement {
 	for i := range rows.Rows {
 		sql := sqlparser.NewTrackedBuffer(nil)
-		sql.Myprintf("DELETE FROM %v WHERE ", sqlparser.NewTableIdent(tce.tm.Name))
+		sql.Myprintf("DELETE FROM %v WHERE ", sqlparser.NewIdentifierCS(tce.tm.Name))
 
 		keyspaceIDCell, pkValues, err := writeIdentifiersAsSQL(sql, tce, rows, i, tce.pkNames != nil)
 		if err != nil {
@@ -743,7 +743,7 @@ func writeValuesAsSQL(sql *sqlparser.TrackedBuffer, tce *tableCacheEntry, rs *my
 		if valueIndex > 0 {
 			sql.WriteString(", ")
 		}
-		sql.Myprintf("%v", sqlparser.NewColIdent(tce.ti.Fields[c].Name))
+		sql.Myprintf("%v", sqlparser.NewIdentifierCI(tce.ti.Fields[c].Name))
 		sql.WriteByte('=')
 
 		if rs.Rows[rowIndex].NullColumns.Bit(valueIndex) {
@@ -808,7 +808,7 @@ func writeIdentifiersAsSQL(sql *sqlparser.TrackedBuffer, tce *tableCacheEntry, r
 		if valueIndex > 0 {
 			sql.WriteString(" AND ")
 		}
-		sql.Myprintf("%v", sqlparser.NewColIdent(tce.ti.Fields[c].Name))
+		sql.Myprintf("%v", sqlparser.NewIdentifierCI(tce.ti.Fields[c].Name))
 
 		if rs.Rows[rowIndex].NullIdentifyColumns.Bit(valueIndex) {
 			// This column is represented, but its value is NULL.

go/vt/binlog/binlog_streamer_rbr_test.go

@@ -42,7 +42,7 @@ func TestStreamerParseRBREvents(t *testing.T) {
 	// We only use the Columns.
 	se := schema.NewEngineForTests()
 	se.SetTableForTests(&schema.Table{
-		Name: sqlparser.NewTableIdent("vt_a"),
+		Name: sqlparser.NewIdentifierCS("vt_a"),
 		Fields: []*querypb.Field{{
 			Name: "id",
 			Type: querypb.Type_INT64,
@@ -287,7 +287,7 @@ func TestStreamerParseRBRNameEscapes(t *testing.T) {
 	// Create a schema.Engine for this test using keyword names.
 	se := schema.NewEngineForTests()
 	se.SetTableForTests(&schema.Table{
-		Name: sqlparser.NewTableIdent("insert"),
+		Name: sqlparser.NewIdentifierCS("insert"),
 		Fields: []*querypb.Field{{
 			Name: "update",
 			Type: querypb.Type_INT64,

go/vt/schemadiff/column.go

@@ -24,7 +24,7 @@ import (
 
 func colWithMaskedName(col *sqlparser.ColumnDefinition) string {
 	col = sqlparser.CloneRefOfColumnDefinition(col)
-	col.Name = sqlparser.NewColIdent("mask")
+	col.Name = sqlparser.NewIdentifierCI("mask")
 	return sqlparser.CanonicalString(col)
 
 }
@@ -57,8 +57,8 @@ func (c *columnDetails) nextColName() string {
 	return c.nextCol.col.Name.String()
 }
 
-func getColName(colIdent *sqlparser.ColIdent) *sqlparser.ColName {
-	return &sqlparser.ColName{Name: *colIdent}
+func getColName(id *sqlparser.IdentifierCI) *sqlparser.ColName {
+	return &sqlparser.ColName{Name: *id}
 }
 
 type ModifyColumnDiff struct {

go/vt/schemadiff/table.go

@@ -521,7 +521,7 @@ func (c *CreateTableEntity) normalizeKeys() {
 				suggestedKeyName = fmt.Sprintf("%s_%d", colName, enumerate)
 			}
 			// OK we found a free slot!
-			key.Info.Name = sqlparser.NewColIdent(suggestedKeyName)
+			key.Info.Name = sqlparser.NewIdentifierCI(suggestedKeyName)
 			keyNameExists[strings.ToLower(suggestedKeyName)] = true
 		}
 
@@ -565,7 +565,7 @@ func (c *CreateTableEntity) normalizeUnnamedConstraints() {
 				suggestedCheckName = fmt.Sprintf(nameFormat, c.CreateTable.Table.Name.String(), enumerate)
 			}
 			// OK we found a free slot!
-			constraint.Name = sqlparser.NewColIdent(suggestedCheckName)
+			constraint.Name = sqlparser.NewIdentifierCI(suggestedCheckName)
 			constraintNameExists[strings.ToLower(suggestedCheckName)] = true
 		}
 	}
@@ -948,7 +948,7 @@ func (c *CreateTableEntity) isRangePartitionsRotation(
 	for _, p := range droppedPartitions1 {
 		partitionSpec := &sqlparser.PartitionSpec{
 			Action: sqlparser.DropAction,
-			Names:  []sqlparser.ColIdent{p.Name},
+			Names:  []sqlparser.IdentifierCI{p.Name},
 		}
 		partitionSpecs = append(partitionSpecs, partitionSpec)
 	}
@@ -1113,7 +1113,7 @@ func (c *CreateTableEntity) diffKeys(alterTable *sqlparser.AlterTable,
 		t2KeysMap[key.Info.Name.String()] = key
 	}
 
-	dropKeyStatement := func(name sqlparser.ColIdent) *sqlparser.DropKey {
+	dropKeyStatement := func(name sqlparser.IdentifierCI) *sqlparser.DropKey {
 		dropKey := &sqlparser.DropKey{}
 		if strings.EqualFold(dropKey.Name.String(), "PRIMARY") {
 			dropKey.Type = sqlparser.PrimaryKeyType
@@ -2086,6 +2086,6 @@ func (c *CreateTableEntity) identicalOtherThanName(other *CreateTableEntity) boo
 // tableWithMaskedName returns the CREATE TABLE statement but with table's name replaced with a constant arbitrary name
 func tableWithMaskedName(createTable *sqlparser.CreateTable) string {
 	createTable = sqlparser.CloneRefOfCreateTable(createTable)
-	createTable.Table.Name = sqlparser.NewTableIdent("mask")
+	createTable.Table.Name = sqlparser.NewIdentifierCS("mask")
 	return sqlparser.CanonicalString(createTable)
 }

go/vt/sqlparser/analyzer.go

@@ -391,12 +391,12 @@ func TableFromStatement(sql string) (TableName, error) {
 
 // GetTableName returns the table name from the SimpleTableExpr
 // only if it's a simple expression. Otherwise, it returns "".
-func GetTableName(node SimpleTableExpr) TableIdent {
+func GetTableName(node SimpleTableExpr) IdentifierCS {
 	if n, ok := node.(TableName); ok && n.Qualifier.IsEmpty() {
 		return n.Name
 	}
 	// sub-select or '.' expression
-	return NewTableIdent("")
+	return NewIdentifierCS("")
 }
 
 // IsColName returns true if the Expr is a *ColName.

go/vt/sqlparser/analyzer_test.go

@@ -165,30 +165,30 @@ func TestAndExpressions(t *testing.T) {
 	greaterThanExpr := &ComparisonExpr{
 		Operator: GreaterThanOp,
 		Left: &ColName{
-			Name: NewColIdent("val"),
+			Name: NewIdentifierCI("val"),
 			Qualifier: TableName{
-				Name: NewTableIdent("a"),
+				Name: NewIdentifierCS("a"),
 			},
 		},
 		Right: &ColName{
-			Name: NewColIdent("val"),
+			Name: NewIdentifierCI("val"),
 			Qualifier: TableName{
-				Name: NewTableIdent("b"),
+				Name: NewIdentifierCS("b"),
 			},
 		},
 	}
 	equalExpr := &ComparisonExpr{
 		Operator: EqualOp,
 		Left: &ColName{
-			Name: NewColIdent("id"),
+			Name: NewIdentifierCI("id"),
 			Qualifier: TableName{
-				Name: NewTableIdent("a"),
+				Name: NewIdentifierCS("a"),
 			},
 		},
 		Right: &ColName{
-			Name: NewColIdent("id"),
+			Name: NewIdentifierCI("id"),
 			Qualifier: TableName{
-				Name: NewTableIdent("b"),
+				Name: NewIdentifierCS("b"),
 			},
 		},
 	}