AST struct name rewording

go/cmd/query_analyzer/query_analyzer.go

@@ -113,7 +113,7 @@ func analyze(line []byte) {
 }
 
 func formatWithBind(buf *sqlparser.TrackedBuffer, node sqlparser.SQLNode) {
-	v, ok := node.(*sqlparser.SQLVal)
+	v, ok := node.(*sqlparser.Literal)
 	if !ok {
 		node.Format(buf)
 		return

go/mysql/conn.go

@@ -908,8 +908,8 @@ func (c *Conn) handleNextCommand(handler Handler) error {
 		paramsCount := uint16(0)
 		_ = sqlparser.Walk(func(node sqlparser.SQLNode) (bool, error) {
 			switch node := node.(type) {
-			case *sqlparser.SQLVal:
-				if strings.HasPrefix(string(node.Val), ":v") {
+			case sqlparser.Argument:
+				if strings.HasPrefix(string(node), ":v") {
 					paramsCount++
 				}
 			}

go/vt/sqlparser/analyzer.go

@@ -319,9 +319,11 @@ func IsColName(node Expr) bool {
 // NULL is not considered to be a value.
 func IsValue(node Expr) bool {
 	switch v := node.(type) {
-	case *SQLVal:
+	case Argument:
+		return true
+	case *Literal:
 		switch v.Type {
-		case StrVal, HexVal, IntVal, ValArg:
+		case StrVal, HexVal, IntVal:
 			return true
 		}
 	}
@@ -358,10 +360,10 @@ func IsSimpleTuple(node Expr) bool {
 // NewPlanValue builds a sqltypes.PlanValue from an Expr.
 func NewPlanValue(node Expr) (sqltypes.PlanValue, error) {
 	switch node := node.(type) {
-	case *SQLVal:
+	case Argument:
+		return sqltypes.PlanValue{Key: string(node[1:])}, nil
+	case *Literal:
 		switch node.Type {
-		case ValArg:
-			return sqltypes.PlanValue{Key: string(node.Val[1:])}, nil
 		case IntVal:
 			n, err := sqltypes.NewIntegral(string(node.Val))
 			if err != nil {

go/vt/sqlparser/analyzer_test.go

@@ -241,7 +241,7 @@ func TestIsColName(t *testing.T) {
 		in:  &ColName{},
 		out: true,
 	}, {
-		in: newHexVal(""),
+		in: newHexLiteral(""),
 	}}
 	for _, tc := range testcases {
 		out := IsColName(tc.in)
@@ -256,32 +256,35 @@ func TestIsValue(t *testing.T) {
 		in  Expr
 		out bool
 	}{{
-		in:  newStrVal("aa"),
+		in:  newStrLiteral("aa"),
 		out: true,
 	}, {
-		in:  newHexVal("3131"),
+		in:  newHexLiteral("3131"),
 		out: true,
 	}, {
-		in:  newIntVal("1"),
+		in:  newIntLiteral("1"),
 		out: true,
 	}, {
-		in:  newValArg(":a"),
+		in:  newArgument(":a"),
 		out: true,
 	}, {
 		in:  &NullVal{},
 		out: false,
 	}}
 	for _, tc := range testcases {
-		out := IsValue(tc.in)
-		if out != tc.out {
-			t.Errorf("IsValue(%T): %v, want %v", tc.in, out, tc.out)
-		}
-		if tc.out {
-			// NewPlanValue should not fail for valid values.
-			if _, err := NewPlanValue(tc.in); err != nil {
-				t.Error(err)
+		t.Run(String(tc.in), func(t *testing.T) {
+			out := IsValue(tc.in)
+			if out != tc.out {
+				t.Errorf("IsValue(%T): %v, want %v", tc.in, out, tc.out)
 			}
-		}
+			if tc.out {
+				// NewPlanValue should not fail for valid values.
+				if _, err := NewPlanValue(tc.in); err != nil {
+					t.Error(err)
+				}
+			}
+
+		})
 	}
 }
 
@@ -293,7 +296,7 @@ func TestIsNull(t *testing.T) {
 		in:  &NullVal{},
 		out: true,
 	}, {
-		in: newStrVal(""),
+		in: newStrLiteral(""),
 	}}
 	for _, tc := range testcases {
 		out := IsNull(tc.in)
@@ -308,7 +311,7 @@ func TestIsSimpleTuple(t *testing.T) {
 		in  Expr
 		out bool
 	}{{
-		in:  ValTuple{newStrVal("aa")},
+		in:  ValTuple{newStrLiteral("aa")},
 		out: true,
 	}, {
 		in: ValTuple{&ColName{}},
@@ -338,43 +341,40 @@ func TestNewPlanValue(t *testing.T) {
 		out sqltypes.PlanValue
 		err string
 	}{{
-		in: &SQLVal{
-			Type: ValArg,
-			Val:  []byte(":valarg"),
-		},
+		in:  Argument(":valarg"),
 		out: sqltypes.PlanValue{Key: "valarg"},
 	}, {
-		in: &SQLVal{
+		in: &Literal{
 			Type: IntVal,
 			Val:  []byte("10"),
 		},
 		out: sqltypes.PlanValue{Value: sqltypes.NewInt64(10)},
 	}, {
-		in: &SQLVal{
+		in: &Literal{
 			Type: IntVal,
 			Val:  []byte("1111111111111111111111111111111111111111"),
 		},
 		err: "value out of range",
 	}, {
-		in: &SQLVal{
+		in: &Literal{
 			Type: StrVal,
 			Val:  []byte("strval"),
 		},
 		out: sqltypes.PlanValue{Value: sqltypes.NewVarBinary("strval")},
 	}, {
-		in: &SQLVal{
+		in: &Literal{
 			Type: BitVal,
 			Val:  []byte("01100001"),
 		},
 		err: "expression is too complex",
 	}, {
-		in: &SQLVal{
+		in: &Literal{
 			Type: HexVal,
 			Val:  []byte("3131"),
 		},
 		out: sqltypes.PlanValue{Value: sqltypes.NewVarBinary("11")},
 	}, {
-		in: &SQLVal{
+		in: &Literal{
 			Type: HexVal,
 			Val:  []byte("313"),
 		},
@@ -384,11 +384,8 @@ func TestNewPlanValue(t *testing.T) {
 		out: sqltypes.PlanValue{ListKey: "list"},
 	}, {
 		in: ValTuple{
-			&SQLVal{
-				Type: ValArg,
-				Val:  []byte(":valarg"),
-			},
-			&SQLVal{
+			Argument(":valarg"),
+			&Literal{
 				Type: StrVal,
 				Val:  []byte("strval"),
 			},
@@ -409,15 +406,15 @@ func TestNewPlanValue(t *testing.T) {
 		in:  &NullVal{},
 		out: sqltypes.PlanValue{},
 	}, {
-		in: &SQLVal{
+		in: &Literal{
 			Type: FloatVal,
 			Val:  []byte("2.1"),
 		},
 		out: sqltypes.PlanValue{Value: sqltypes.NewFloat64(2.1)},
 	}, {
 		in: &UnaryExpr{
 			Operator: Latin1Str,
-			Expr: &SQLVal{
+			Expr: &Literal{
 				Type: StrVal,
 				Val:  []byte("strval"),
 			},
@@ -426,7 +423,7 @@ func TestNewPlanValue(t *testing.T) {
 	}, {
 		in: &UnaryExpr{
 			Operator: UBinaryStr,
-			Expr: &SQLVal{
+			Expr: &Literal{
 				Type: StrVal,
 				Val:  []byte("strval"),
 			},
@@ -435,7 +432,7 @@ func TestNewPlanValue(t *testing.T) {
 	}, {
 		in: &UnaryExpr{
 			Operator: Utf8mb4Str,
-			Expr: &SQLVal{
+			Expr: &Literal{
 				Type: StrVal,
 				Val:  []byte("strval"),
 			},
@@ -444,7 +441,7 @@ func TestNewPlanValue(t *testing.T) {
 	}, {
 		in: &UnaryExpr{
 			Operator: Utf8Str,
-			Expr: &SQLVal{
+			Expr: &Literal{
 				Type: StrVal,
 				Val:  []byte("strval"),
 			},
@@ -453,7 +450,7 @@ func TestNewPlanValue(t *testing.T) {
 	}, {
 		in: &UnaryExpr{
 			Operator: MinusStr,
-			Expr: &SQLVal{
+			Expr: &Literal{
 				Type: FloatVal,
 				Val:  []byte("2.1"),
 			},
@@ -482,18 +479,18 @@ var mustMatch = utils.MustMatchFn(
 	[]string{".Conn"}, // ignored fields
 )
 
-func newStrVal(in string) *SQLVal {
-	return NewStrVal([]byte(in))
+func newStrLiteral(in string) *Literal {
+	return NewStrLiteral([]byte(in))
 }
 
-func newIntVal(in string) *SQLVal {
-	return NewIntVal([]byte(in))
+func newIntLiteral(in string) *Literal {
+	return NewIntLiteral([]byte(in))
 }
 
-func newHexVal(in string) *SQLVal {
-	return NewHexVal([]byte(in))
+func newHexLiteral(in string) *Literal {
+	return NewHexLiteral([]byte(in))
 }
 
-func newValArg(in string) *SQLVal {
-	return NewValArg([]byte(in))
+func newArgument(in string) Expr {
+	return NewArgument([]byte(in))
 }

go/vt/sqlparser/ast.go

@@ -353,13 +353,13 @@ type ColumnType struct {
 	Autoincrement BoolVal
 	Default       Expr
 	OnUpdate      Expr
-	Comment       *SQLVal
+	Comment       *Literal
 
 	// Numeric field options
-	Length   *SQLVal
+	Length   *Literal
 	Unsigned BoolVal
 	Zerofill BoolVal
-	Scale    *SQLVal
+	Scale    *Literal
 
 	// Text field options
 	Charset string
@@ -614,12 +614,15 @@ type (
 		Subquery *Subquery
 	}
 
-	// SQLVal represents a single value.
-	SQLVal struct {
+	// Literal represents a fixed value.
+	Literal struct {
 		Type ValType
 		Val  []byte
 	}
 
+	// Argument represents bindvariable expression
+	Argument []byte
+
 	// NullVal represents a NULL value.
 	NullVal struct{}
 
@@ -711,7 +714,7 @@ type (
 	// In this case StrVal will be set instead of Name.
 	SubstrExpr struct {
 		Name   *ColName
-		StrVal *SQLVal
+		StrVal *Literal
 		From   Expr
 		To     Expr
 	}
@@ -771,7 +774,8 @@ func (*ComparisonExpr) iExpr()    {}
 func (*RangeCond) iExpr()         {}
 func (*IsExpr) iExpr()            {}
 func (*ExistsExpr) iExpr()        {}
-func (*SQLVal) iExpr()            {}
+func (*Literal) iExpr()           {}
+func (Argument) iExpr()           {}
 func (*NullVal) iExpr()           {}
 func (BoolVal) iExpr()            {}
 func (*ColName) iExpr()           {}
@@ -805,8 +809,8 @@ func (ListArg) iColTuple()   {}
 // ConvertType represents the type in call to CONVERT(expr, type)
 type ConvertType struct {
 	Type     string
-	Length   *SQLVal
-	Scale    *SQLVal
+	Length   *Literal
+	Scale    *Literal
 	Operator string
 	Charset  string
 }
@@ -1579,7 +1583,7 @@ func (node *ExistsExpr) Format(buf *TrackedBuffer) {
 }
 
 // Format formats the node.
-func (node *SQLVal) Format(buf *TrackedBuffer) {
+func (node *Literal) Format(buf *TrackedBuffer) {
 	switch node.Type {
 	case StrVal:
 		sqltypes.MakeTrusted(sqltypes.VarBinary, node.Val).EncodeSQL(buf)
@@ -1589,13 +1593,16 @@ func (node *SQLVal) Format(buf *TrackedBuffer) {
 		buf.astPrintf(node, "X'%s'", node.Val)
 	case BitVal:
 		buf.astPrintf(node, "B'%s'", node.Val)
-	case ValArg:
-		buf.WriteArg(string(node.Val))
 	default:
 		panic("unexpected")
 	}
 }
 
+// Format formats the node.
+func (node Argument) Format(buf *TrackedBuffer) {
+	buf.WriteArg(string(node))
+}
+
 // Format formats the node.
 func (node *NullVal) Format(buf *TrackedBuffer) {
 	buf.astPrintf(node, "null")
@@ -1864,8 +1871,8 @@ func (node *SetExpr) Format(buf *TrackedBuffer) {
 	case node.Name.EqualString("charset") || node.Name.EqualString("names"):
 		buf.astPrintf(node, "%s %v", node.Name.String(), node.Expr)
 	case node.Name.EqualString(TransactionStr):
-		sqlVal := node.Expr.(*SQLVal)
-		buf.astPrintf(node, "%s %s", node.Name.String(), strings.ToLower(string(sqlVal.Val)))
+		literal := node.Expr.(*Literal)
+		buf.astPrintf(node, "%s %s", node.Name.String(), strings.ToLower(string(literal.Val)))
 	default:
 		buf.astPrintf(node, "%v = %v", node.Name, node.Expr)
 	}