Use the parser to quote identifiers

Author: zachmu

memory/table.go

@@ -134,7 +134,7 @@ func stripTblNames(e sql.Expression) (sql.Expression, transform.TreeIdentity, er
 	case *expression.GetField:
 		// strip table names
 		ne := expression.NewGetField(e.Index(), e.Type(), e.Name(), e.IsNullable())
-		ne = ne.WithBackTickNames(e.IsBackTickNames())
+		ne = ne.WithQuotedNames(sql.GlobalParser, e.IsQuotedIdentifier())
 		return ne, transform.NewTree, nil
 	default:
 	}

sql/analyzer/resolve_column_defaults.go

@@ -307,15 +307,15 @@ func stripTableNamesFromDefault(e *expression.Wrapper) (sql.Expression, transfor
 	return expression.WrapExpression(&nd), transform.NewTree, nil
 }
 
-func backtickDefaultColumnValueNames(ctx *sql.Context, _ *Analyzer, n sql.Node, _ *plan.Scope, _ RuleSelector, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
+func backtickDefaultColumnValueNames(ctx *sql.Context, a *Analyzer, n sql.Node, _ *plan.Scope, _ RuleSelector, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
 	span, ctx := ctx.Span("backtickDefaultColumnValueNames")
 	defer span.End()
 
 	return transform.Node(n, func(n sql.Node) (sql.Node, transform.TreeIdentity, error) {
 		switch node := n.(type) {
 		case *plan.AlterDefaultSet:
 			eWrapper := expression.WrapExpression(node.Default)
-			newExpr, same, err := backtickDefault(eWrapper)
+			newExpr, same, err := quoteIdentifiers(a.Parser, eWrapper)
 			if err != nil {
 				return node, transform.SameTree, err
 			}
@@ -335,7 +335,7 @@ func backtickDefaultColumnValueNames(ctx *sql.Context, _ *Analyzer, n sql.Node,
 					return e, transform.SameTree, nil
 				}
 
-				return backtickDefault(eWrapper)
+				return quoteIdentifiers(a.Parser, eWrapper)
 			})
 		case *plan.ResolvedTable:
 			ct, ok := node.Table.(*information_schema.ColumnsTable)
@@ -354,7 +354,7 @@ func backtickDefaultColumnValueNames(ctx *sql.Context, _ *Analyzer, n sql.Node,
 					return e, transform.SameTree, nil
 				}
 
-				return backtickDefault(eWrapper)
+				return quoteIdentifiers(a.Parser, eWrapper)
 			})
 
 			if err != nil {
@@ -376,7 +376,7 @@ func backtickDefaultColumnValueNames(ctx *sql.Context, _ *Analyzer, n sql.Node,
 	})
 }
 
-func backtickDefault(wrap *expression.Wrapper) (sql.Expression, transform.TreeIdentity, error) {
+func quoteIdentifiers(parser sql.Parser, wrap *expression.Wrapper) (sql.Expression, transform.TreeIdentity, error) {
 	newDefault, ok := wrap.Unwrap().(*sql.ColumnDefaultValue)
 	if !ok {
 		return wrap, transform.SameTree, nil
@@ -388,7 +388,7 @@ func backtickDefault(wrap *expression.Wrapper) (sql.Expression, transform.TreeId
 
 	newExpr, same, err := transform.Expr(newDefault.Expr, func(expr sql.Expression) (sql.Expression, transform.TreeIdentity, error) {
 		if e, isGf := expr.(*expression.GetField); isGf {
-			return e.WithBackTickNames(true), transform.NewTree, nil
+			return e.WithQuotedNames(parser,true), transform.NewTree, nil
 		}
 		return expr, transform.SameTree, nil
 	})

sql/expression/get_field.go

@@ -38,7 +38,11 @@ type GetField struct {
 	fieldType2 sql.Type2
 	nullable   bool
 
-	backTickNames bool
+	// parser is the parser used to parse the expression and print it
+	parser sql.Parser
+
+	// quoteName indicates whether the field name should be quoted when printed with String()
+	quoteName bool
 }
 
 var _ sql.Expression = (*GetField)(nil)
@@ -161,10 +165,14 @@ func (p *GetField) WithChildren(children ...sql.Expression) (sql.Expression, err
 }
 
 func (p *GetField) String() string {
-	if p.table == "" {
-		if p.backTickNames {
-			return "`" + p.name + "`"
+	if p.quoteName {
+		if p.table == "" {
+			return p.parser.QuoteIdentifier(p.name)
 		}
+		return p.parser.QuoteIdentifier(p.table) + "." + p.parser.QuoteIdentifier(p.name)
+	}
+
+	if p.table == "" {
 		return p.name
 	}
 	return p.table + "." + p.name
@@ -188,16 +196,17 @@ func (p *GetField) WithIndex(n int) sql.Expression {
 	return &p2
 }
 
-// WithBackTickNames returns a copy of this expression with the backtick names flag set to the given value.
-func (p *GetField) WithBackTickNames(backtick bool) *GetField {
+// WithQuotedNames returns a copy of this expression with the backtick names flag set to the given value.
+func (p *GetField) WithQuotedNames(parser sql.Parser, quoteNames bool) *GetField {
 	p2 := *p
-	p2.backTickNames = backtick
+	p2.quoteName = quoteNames
+	p2.parser = parser
 	return &p2
 }
 
-// IsBackTickNames returns whether the field name should be quoted with backticks.
-func (p *GetField) IsBackTickNames() bool {
-	return p.backTickNames
+// IsQuotedIdentifier returns whether the field name should be quoted.
+func (p *GetField) IsQuotedIdentifier() bool {
+	return p.quoteName
 }
 
 // CollationCoercibility implements the interface sql.CollationCoercible.

sql/parser.go

@@ -16,6 +16,7 @@ package sql
 
 import (
 	"context"
+	"fmt"
 	trace2 "runtime/trace"
 	"strings"
 	"unicode"
@@ -44,6 +45,10 @@ type Parser interface {
 	// the index of the start of the next query. If |query| represents a no-op statement, such as ";" or "-- comment",
 	// then implementations must return Vitess' ErrEmpty error.
 	ParseOneWithOptions(context.Context, string, ast.ParserOptions) (ast.Statement, int, error)
+	// QuoteIdentifier returns the identifier given quoted according to this parser's dialect. This is used to 
+	// standardize identifiers that cannot be parsed without quoting, because they break the normal identifier naming 
+	// rules (such as containing spaces)
+	QuoteIdentifier(identifier string) string
 }
 
 var _ Parser = &MysqlParser{}
@@ -99,3 +104,7 @@ func RemoveSpaceAndDelimiter(query string, d rune) string {
 		return r == d || unicode.IsSpace(r)
 	})
 }
+
+func (m *MysqlParser) QuoteIdentifier(identifier string) string {
+	return fmt.Sprintf("`%s`", strings.ReplaceAll(identifier, "`", "``"))
+}