First step to generalizing literal expression

zachmu · zachmu · commit ef5a371b0e67 · 2025-04-17T15:41:34.000-07:00
diff --git a/enginetest/server_engine.go b/enginetest/server_engine.go
@@ -650,7 +650,7 @@ func prepareBindingArgs(ctx *sql.Context, bindings map[string]sqlparser.Expr) ([
 		if !ok {
 			return nil, fmt.Errorf("cannot get binding value")
 		}
-		args[i] = lit.Value()
+		args[i] = lit.LiteralValue()
 	}
 	return args, nil
 }
diff --git a/memory/exponential_dist_table.go b/memory/exponential_dist_table.go
@@ -36,23 +36,23 @@ func (s ExponentialDistTable) NewInstance(ctx *sql.Context, db sql.Database, arg
 	if !ok {
 		return nil, fmt.Errorf("normal_dist table expects arguments to be literal expressions")
 	}
-	colCnt, inBounds, _ := types.Int64.Convert(ctx, colCntLit.Value())
+	colCnt, inBounds, _ := types.Int64.Convert(ctx, colCntLit.LiteralValue())
 	if !inBounds {
 		return nil, fmt.Errorf("normal_dist table expects 1st argument to be column count")
 	}
 	rowCntLit, ok := args[1].(*expression.Literal)
 	if !ok {
 		return nil, fmt.Errorf("normal_dist table expects arguments to be literal expressions")
 	}
-	rowCnt, inBounds, _ := types.Int64.Convert(ctx, rowCntLit.Value())
+	rowCnt, inBounds, _ := types.Int64.Convert(ctx, rowCntLit.LiteralValue())
 	if !inBounds {
 		return nil, fmt.Errorf("normal_dist table expects 2nd argument to be row count")
 	}
 	lambdaLit, ok := args[2].(*expression.Literal)
 	if !ok {
 		return nil, fmt.Errorf("exponential_dist table expects arguments to be literal expressions")
 	}
-	lambda, inBounds, _ := types.Float64.Convert(ctx, lambdaLit.Value())
+	lambda, inBounds, _ := types.Float64.Convert(ctx, lambdaLit.LiteralValue())
 	if !inBounds {
 		return nil, fmt.Errorf("exponential_dist table expects 3rd argument to be row count")
 	}
diff --git a/memory/normal_dist_table.go b/memory/normal_dist_table.go
@@ -37,31 +37,31 @@ func (s NormalDistTable) NewInstance(ctx *sql.Context, db sql.Database, args []s
 	if !ok {
 		return nil, fmt.Errorf("normal_dist table expects arguments to be literal expressions")
 	}
-	colCnt, inBounds, _ := types.Int64.Convert(ctx, colCntLit.Value())
+	colCnt, inBounds, _ := types.Int64.Convert(ctx, colCntLit.LiteralValue())
 	if !inBounds {
 		return nil, fmt.Errorf("normal_dist table expects 1st argument to be column count")
 	}
 	rowCntLit, ok := args[1].(*expression.Literal)
 	if !ok {
 		return nil, fmt.Errorf("normal_dist table expects arguments to be literal expressions")
 	}
-	rowCnt, inBounds, _ := types.Int64.Convert(ctx, rowCntLit.Value())
+	rowCnt, inBounds, _ := types.Int64.Convert(ctx, rowCntLit.LiteralValue())
 	if !inBounds {
 		return nil, fmt.Errorf("normal_dist table expects 2nd argument to be row count")
 	}
 	meanLit, ok := args[2].(*expression.Literal)
 	if !ok {
 		return nil, fmt.Errorf("normal_dist table expects arguments to be literal expressions")
 	}
-	mean, inBounds, _ := types.Float64.Convert(ctx, meanLit.Value())
+	mean, inBounds, _ := types.Float64.Convert(ctx, meanLit.LiteralValue())
 	if !inBounds {
 		return nil, fmt.Errorf("normal_dist table expects 3rd argument to be row count")
 	}
 	stdLit, ok := args[3].(*expression.Literal)
 	if !ok {
 		return nil, fmt.Errorf("normal_dist table expects arguments to be literal expressions")
 	}
-	std, inBounds, _ := types.Float64.Convert(ctx, stdLit.Value())
+	std, inBounds, _ := types.Float64.Convert(ctx, stdLit.LiteralValue())
 	if !inBounds {
 		return nil, fmt.Errorf("normal_dist table expects 4th argument to be row count")
 	}
diff --git a/memory/sequence_table.go b/memory/sequence_table.go
@@ -37,15 +37,15 @@ func (s IntSequenceTable) NewInstance(ctx *sql.Context, db sql.Database, args []
 	if !ok {
 		return nil, fmt.Errorf("sequence table expects arguments to be literal expressions")
 	}
-	name, ok := nameExp.Value().(string)
+	name, ok := nameExp.LiteralValue().(string)
 	if !ok {
 		return nil, fmt.Errorf("sequence table expects 1st argument to be column name")
 	}
 	lenExp, ok := args[1].(*expression.Literal)
 	if !ok {
 		return nil, fmt.Errorf("sequence table expects arguments to be literal expressions")
 	}
-	length, _, err := types.Int64.Convert(ctx, lenExp.Value())
+	length, _, err := types.Int64.Convert(ctx, lenExp.LiteralValue())
 	if !ok {
 		return nil, fmt.Errorf("%w; sequence table expects 2nd argument to be a sequence length integer", err)
 	}
diff --git a/memory/table_function.go b/memory/table_function.go
@@ -27,15 +27,15 @@ func (s TableFunc) NewInstance(ctx *sql.Context, db sql.Database, args []sql.Exp
 	if !ok {
 		return nil, fmt.Errorf("table_func table expects arguments to be literal expressions")
 	}
-	name, ok := nameExp.Value().(string)
+	name, ok := nameExp.LiteralValue().(string)
 	if !ok {
 		return nil, fmt.Errorf("table_func table expects 1st argument to be column name")
 	}
 	valueExpr, ok := args[1].(*expression.Literal)
 	if !ok {
 		return nil, fmt.Errorf("table_func table expects arguments to be literal expressions")
 	}
-	value, _, err := types.Int64.Convert(ctx, valueExpr.Value())
+	value, _, err := types.Int64.Convert(ctx, valueExpr.LiteralValue())
 	if !ok {
 		return nil, fmt.Errorf("%w; table_func table expects 2nd argument to be a table_func length integer", err)
 	}
diff --git a/sql/analyzer/costed_index_scan_test.go b/sql/analyzer/costed_index_scan_test.go
@@ -913,7 +913,7 @@ func (i *indexSearchableTable) LookupForExpressions(ctx *sql.Context, exprs ...s
 	if eq, ok := exprs[0].(*expression.Equals); ok {
 		if gf, ok := eq.Left().(*expression.GetField); ok && strings.EqualFold(gf.Name(), "x") {
 			if lit, ok := eq.Right().(*expression.Literal); ok {
-				ranges := sql.MySQLRangeCollection{{sql.ClosedRangeColumnExpr(lit.Value(), lit.Value(), lit.Type())}}
+				ranges := sql.MySQLRangeCollection{{sql.ClosedRangeColumnExpr(lit.LiteralValue(), lit.LiteralValue(), lit.Type())}}
 				return sql.IndexLookup{Index: xIdx, Ranges: ranges}, nil, nil, true, nil
 			}
 		}
diff --git a/sql/analyzer/indexed_joins.go b/sql/analyzer/indexed_joins.go
@@ -1311,7 +1311,7 @@ func makeIndexScan(ctx *sql.Context, statsProv sql.StatsProvider, tab plan.Table
 		if found && lit == nil {
 			break
 		}
-		rang[j] = sql.ClosedRangeColumnExpr(lit.Value(), lit.Value(), idx.SqlIdx().ColumnExpressionTypes()[j].Type)
+		rang[j] = sql.ClosedRangeColumnExpr(lit.LiteralValue(), lit.LiteralValue(), idx.SqlIdx().ColumnExpressionTypes()[j].Type)
 		j++
 		if found {
 			break
diff --git a/sql/analyzer/inserts.go b/sql/analyzer/inserts.go
@@ -243,7 +243,7 @@ func isZero(ctx *sql.Context, lit *expression.Literal) bool {
 		return false
 	}
 
-	convert, inRange, err := types.Int8.Convert(ctx, lit.Value())
+	convert, inRange, err := types.Int8.Convert(ctx, lit.LiteralValue())
 	if err != nil {
 		// Ignore any conversion errors, since that means the value isn't 0
 		// and the values are validated in other parts of the analyzer anyway.
diff --git a/sql/analyzer/optimization_rules.go b/sql/analyzer/optimization_rules.go
@@ -178,10 +178,10 @@ func expressionSources(expr sql.Expression) (sql.FastIntSet, bool) {
 		case *expression.NullSafeEquals:
 			nullRejecting = false
 		case *expression.Equals:
-			if lit, ok := e.Left().(*expression.Literal); ok && lit.Value() == nil {
+			if lit, ok := e.Left().(*expression.Literal); ok && lit.LiteralValue() == nil {
 				nullRejecting = false
 			}
-			if lit, ok := e.Right().(*expression.Literal); ok && lit.Value() == nil {
+			if lit, ok := e.Right().(*expression.Literal); ok && lit.LiteralValue() == nil {
 				nullRejecting = false
 			}
 		case *plan.Subquery:
@@ -194,10 +194,10 @@ func expressionSources(expr sql.Expression) (sql.FastIntSet, bool) {
 				case *expression.NullSafeEquals:
 					nullRejecting = false
 				case *expression.Equals:
-					if lit, ok := e.Left().(*expression.Literal); ok && lit.Value() == nil {
+					if lit, ok := e.Left().(*expression.Literal); ok && lit.LiteralValue() == nil {
 						nullRejecting = false
 					}
-					if lit, ok := e.Right().(*expression.Literal); ok && lit.Value() == nil {
+					if lit, ok := e.Right().(*expression.Literal); ok && lit.LiteralValue() == nil {
 						nullRejecting = false
 					}
 				}
@@ -289,7 +289,7 @@ func simplifyFilters(ctx *sql.Context, a *Analyzer, node sql.Node, scope *plan.S
 				if e.Escape != nil {
 					return e, transform.SameTree, nil
 				}
-				val := r.Value()
+				val := r.LiteralValue()
 				valStr, ok := val.(string)
 				if !ok {
 					return e, transform.SameTree, nil
@@ -369,8 +369,8 @@ func simplifyFilters(ctx *sql.Context, a *Analyzer, node sql.Node, scope *plan.S
 
 func isFalse(e sql.Expression) bool {
 	lit, ok := e.(*expression.Literal)
-	if ok && lit != nil && lit.Type() == types.Boolean && lit.Value() != nil {
-		switch v := lit.Value().(type) {
+	if ok && lit != nil && lit.Type() == types.Boolean && lit.LiteralValue() != nil {
+		switch v := lit.LiteralValue().(type) {
 		case bool:
 			return !v
 		case int8:
@@ -382,8 +382,8 @@ func isFalse(e sql.Expression) bool {
 
 func isTrue(e sql.Expression) bool {
 	lit, ok := e.(*expression.Literal)
-	if ok && lit != nil && lit.Type() == types.Boolean && lit.Value() != nil {
-		switch v := lit.Value().(type) {
+	if ok && lit != nil && lit.Type() == types.Boolean && lit.LiteralValue() != nil {
+		switch v := lit.LiteralValue().(type) {
 		case bool:
 			return v
 		case int8:
diff --git a/sql/core.go b/sql/core.go
@@ -45,6 +45,13 @@ type Expression interface {
 	WithChildren(children ...Expression) (Expression, error)
 }
 
+// LiteralExpression is a marker interface to indicate that an expression is a literal expression
+type LiteralExpression interface {
+	Expression
+	// LiteralValue returns the literal value of the expression.
+	LiteralValue() interface{}
+}
+
 // ExpressionWithNodes is an expression that contains nodes as children.
 type ExpressionWithNodes interface {
 	Expression
diff --git a/sql/expression/common.go b/sql/expression/common.go
@@ -141,7 +141,7 @@ func LiteralToInt(e sql.Expression) (int, error) {
 	if !ok {
 		return 0, ErrInvalidOffset.New(e)
 	}
-	val := lit.Value()
+	val := lit.LiteralValue()
 	var offset int
 	switch e := val.(type) {
 	case int:
diff --git a/sql/expression/literal.go b/sql/expression/literal.go
@@ -35,6 +35,7 @@ type Literal struct {
 var _ sql.Expression = &Literal{}
 var _ sql.Expression2 = &Literal{}
 var _ sql.CollationCoercible = &Literal{}
+var _ sql.LiteralExpression = &Literal{}
 
 // NewLiteral creates a new Literal expression.
 func NewLiteral(value interface{}, fieldType sql.Type) *Literal {
@@ -146,7 +147,7 @@ func (lit *Literal) Type2() sql.Type2 {
 	return t2
 }
 
-// Value returns the literal value.
-func (p *Literal) Value() interface{} {
-	return p.value
+// LiteralValue returns the literal value.
+func (lit *Literal) LiteralValue() interface{} {
+	return lit.value
 }
diff --git a/sql/memo/join_order_builder_test.go b/sql/memo/join_order_builder_test.go
@@ -769,7 +769,7 @@ func assertScalarEq(t *testing.T, exp, cmp sql.Expression) {
 	case *expression.Literal:
 		exp, ok := exp.(*expression.Literal)
 		require.True(t, ok)
-		require.Equal(t, exp.Value(), cmp.Value())
+		require.Equal(t, exp.LiteralValue(), cmp.LiteralValue())
 	case *expression.GetField:
 		exp, ok := exp.(*expression.GetField)
 		require.True(t, ok)
diff --git a/sql/memo/rel_props.go b/sql/memo/rel_props.go
@@ -268,7 +268,7 @@ func (p *relProps) populateFds() {
 						equiv = append(equiv, [2]sql.ColumnId{l.Id(), r.Id()})
 					case *expression.Literal:
 						constant.Add(l.Id())
-						if r.Value() != nil {
+						if r.LiteralValue() != nil {
 							notNull.Add(l.Id())
 						}
 					}
@@ -279,7 +279,7 @@ func (p *relProps) populateFds() {
 						equiv = append(equiv, [2]sql.ColumnId{l.Id(), r.Id()})
 					case *expression.Literal:
 						constant.Add(r.Id())
-						if l.Value() != nil {
+						if l.LiteralValue() != nil {
 							notNull.Add(r.Id())
 						}
 					}
diff --git a/sql/plan/join.go b/sql/plan/join.go
@@ -435,7 +435,7 @@ func (j *JoinNode) Describe(options sql.DescribeOptions) string {
 	if j.Filter != nil {
 		// Don't print a filter that's always true, it's just noise.
 		literal, isLiteral := j.Filter.(*expression.Literal)
-		if !isLiteral || literal.Value() != true {
+		if !isLiteral || literal.LiteralValue() != true {
 			if j.Op.IsMerge() {
 				filters := expression.SplitConjunction(j.Filter)
 				children = append(children, fmt.Sprintf("cmp: %s", sql.Describe(filters[0], options)))
diff --git a/sql/plan/str_expr.go b/sql/plan/str_expr.go
@@ -25,7 +25,7 @@ func AliasSubqueryString(e sql.Expression) string {
 	// String literal values are quoted when their String() method is called, so to avoid that, we
 	// check if we're dealing with a string literal and use it's raw value if so.
 	if literal, ok := e.(*expression.Literal); ok {
-		if s, ok := literal.Value().(string); ok {
+		if s, ok := literal.LiteralValue().(string); ok {
 			return s
 		}
 	}
diff --git a/sql/planbuilder/analyze.go b/sql/planbuilder/analyze.go
@@ -130,7 +130,7 @@ func (b *Builder) buildAnalyzeUpdate(inScope *scope, n *ast.Analyze, dbName, sch
 	using := b.buildScalar(inScope, n.Using)
 	if l, ok := using.(*expression.Literal); ok {
 		if typ, ok := l.Type().(sql.StringType); ok {
-			val, _, err := typ.Convert(b.ctx, l.Value())
+			val, _, err := typ.Convert(b.ctx, l.LiteralValue())
 			if err != nil {
 				b.handleErr(err)
 			}
diff --git a/sql/planbuilder/ddl.go b/sql/planbuilder/ddl.go
@@ -1712,7 +1712,7 @@ func (b *Builder) convertDefaultExpression(inScope *scope, defaultExpr ast.Expr,
 	// TODO: fix the vitess parser so that it parses negative numbers as numbers and not negation of an expression
 	if unaryMinusExpr, ok := resExpr.(*expression.UnaryMinus); ok {
 		if literalExpr, ok := unaryMinusExpr.Child.(*expression.Literal); ok {
-			switch val := literalExpr.Value().(type) {
+			switch val := literalExpr.LiteralValue().(type) {
 			case float32:
 				resExpr = expression.NewLiteral(-val, types.Float32)
 				isLiteral = true
diff --git a/sql/planbuilder/orderby.go b/sql/planbuilder/orderby.go
@@ -188,10 +188,10 @@ func (b *Builder) normalizeValArg(e *ast.SQLVal) (sql.Expression, bool) {
 func (b *Builder) normalizeIntVal(e *ast.SQLVal) (any, bool) {
 	if e.Type == ast.IntVal {
 		lit := b.convertInt(string(e.Val), 10)
-		return lit.Value(), true
+		return lit.LiteralValue(), true
 	} else if replace, ok := b.normalizeValArg(e); ok {
 		if lit, ok := replace.(*expression.Literal); ok && types.IsNumber(lit.Type()) {
-			return lit.Value(), true
+			return lit.LiteralValue(), true
 		}
 	}
 	return nil, false
diff --git a/sql/planbuilder/process.go b/sql/planbuilder/process.go
@@ -72,7 +72,7 @@ func (b *Builder) getInt64Literal(inScope *scope, expr ast.Expr, errStr string)
 		err := sql.ErrUnsupportedFeature.New(errStr)
 		b.handleErr(err)
 	} else {
-		i64, _, err := types.Int64.Convert(b.ctx, nl.Value())
+		i64, _, err := types.Int64.Convert(b.ctx, nl.LiteralValue())
 		if err != nil {
 			err := sql.ErrUnsupportedFeature.New(errStr)
 			b.handleErr(err)
diff --git a/sql/planbuilder/scalar.go b/sql/planbuilder/scalar.go
@@ -433,9 +433,9 @@ func (b *Builder) getJsonValueTypeLiteral(e sql.Expression) sql.Expression {
 		err := fmt.Errorf("invalid json_value coercion type: %s", e)
 		b.handleErr(err)
 	}
-	convStr, _, err := types.LongText.Convert(b.ctx, typLit.Value())
+	convStr, _, err := types.LongText.Convert(b.ctx, typLit.LiteralValue())
 	if err != nil {
-		err := fmt.Errorf("invalid json_value coercion type: %s; %s", typLit.Value(), err.Error())
+		err := fmt.Errorf("invalid json_value coercion type: %s; %s", typLit.LiteralValue(), err.Error())
 		b.handleErr(err)
 	}
 	var typ sql.Type
@@ -591,7 +591,7 @@ func (b *Builder) typeExpandComparisonLiteral(left, right sql.Expression) (sql.E
 				// information casting to the column type. The conditions
 				// should preclude out of range, casting errors, or
 				// correctness missteps.
-				val, _, err := leftGf.Type().Convert(b.ctx, rightLit.Value())
+				val, _, err := leftGf.Type().Convert(b.ctx, rightLit.LiteralValue())
 				if err != nil && !expression.ErrNilOperand.Is(err) {
 					b.handleErr(err)
 				}
diff --git a/sql/planbuilder/select.go b/sql/planbuilder/select.go
@@ -180,7 +180,7 @@ func (b *Builder) typeCoerceLiteral(e sql.Expression) sql.Expression {
 	// todo this should be in a module that can generically coerce to a type or type class
 	switch e := e.(type) {
 	case *expression.Literal:
-		val, _, err := types.Int64.Convert(b.ctx, e.Value())
+		val, _, err := types.Int64.Convert(b.ctx, e.LiteralValue())
 		if err != nil {
 			err = fmt.Errorf("%s: %w", err.Error(), sql.ErrInvalidTypeForLimit.New(types.Int64, e.Type()))
 		}
diff --git a/sql/planbuilder/show.go b/sql/planbuilder/show.go
@@ -845,7 +845,7 @@ func (b *Builder) buildShowCollation(inScope *scope, s *ast.Show) (outScope *sco
 		filterExpr, _, _ = transform.Expr(filterExpr, func(expr sql.Expression) (sql.Expression, transform.TreeIdentity, error) {
 			if exprLiteral, ok := expr.(*expression.Literal); ok {
 				const utf8Prefix = "utf8_"
-				if strLiteral, ok := exprLiteral.Value().(string); ok && strings.HasPrefix(strLiteral, utf8Prefix) {
+				if strLiteral, ok := exprLiteral.LiteralValue().(string); ok && strings.HasPrefix(strLiteral, utf8Prefix) {
 					return expression.NewLiteral("utf8mb3_"+strLiteral[len(utf8Prefix):], exprLiteral.Type()), transform.NewTree, nil
 				}
 			}
diff --git a/sql/rowexec/join_iters.go b/sql/rowexec/join_iters.go
@@ -359,7 +359,7 @@ func (i *existsIter) Next(ctx *sql.Context) (sql.Row, error) {
 
 func isTrueLit(e sql.Expression) bool {
 	if lit, ok := e.(*expression.Literal); ok {
-		return lit.Value() == true
+		return lit.LiteralValue() == true
 	}
 	return false
 }

Original file line number	Diff line number	Diff line change
`@@ -650,7 +650,7 @@ func prepareBindingArgs(ctx *sql.Context, bindings map[string]sqlparser.Expr) ([`
`650`	`650`	`if !ok {`
`651`	`651`	`return nil, fmt.Errorf("cannot get binding value")`
`652`	`652`	`}`
`653`		`- args[i] = lit.Value()`
	`653`	`+ args[i] = lit.LiteralValue()`
`654`	`654`	`}`
`655`	`655`	`return args, nil`
`656`	`656`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,23 +36,23 @@ func (s ExponentialDistTable) NewInstance(ctx *sql.Context, db sql.Database, arg`
`36`	`36`	`if !ok {`
`37`	`37`	`return nil, fmt.Errorf("normal_dist table expects arguments to be literal expressions")`
`38`	`38`	`}`
`39`		`- colCnt, inBounds, _ := types.Int64.Convert(ctx, colCntLit.Value())`
	`39`	`+ colCnt, inBounds, _ := types.Int64.Convert(ctx, colCntLit.LiteralValue())`
`40`	`40`	`if !inBounds {`
`41`	`41`	`return nil, fmt.Errorf("normal_dist table expects 1st argument to be column count")`
`42`	`42`	`}`
`43`	`43`	`rowCntLit, ok := args[1].(*expression.Literal)`
`44`	`44`	`if !ok {`
`45`	`45`	`return nil, fmt.Errorf("normal_dist table expects arguments to be literal expressions")`
`46`	`46`	`}`
`47`		`- rowCnt, inBounds, _ := types.Int64.Convert(ctx, rowCntLit.Value())`
	`47`	`+ rowCnt, inBounds, _ := types.Int64.Convert(ctx, rowCntLit.LiteralValue())`
`48`	`48`	`if !inBounds {`
`49`	`49`	`return nil, fmt.Errorf("normal_dist table expects 2nd argument to be row count")`
`50`	`50`	`}`
`51`	`51`	`lambdaLit, ok := args[2].(*expression.Literal)`
`52`	`52`	`if !ok {`
`53`	`53`	`return nil, fmt.Errorf("exponential_dist table expects arguments to be literal expressions")`
`54`	`54`	`}`
`55`		`- lambda, inBounds, _ := types.Float64.Convert(ctx, lambdaLit.Value())`
	`55`	`+ lambda, inBounds, _ := types.Float64.Convert(ctx, lambdaLit.LiteralValue())`
`56`	`56`	`if !inBounds {`
`57`	`57`	`return nil, fmt.Errorf("exponential_dist table expects 3rd argument to be row count")`
`58`	`58`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,31 +37,31 @@ func (s NormalDistTable) NewInstance(ctx *sql.Context, db sql.Database, args []s`
`37`	`37`	`if !ok {`
`38`	`38`	`return nil, fmt.Errorf("normal_dist table expects arguments to be literal expressions")`
`39`	`39`	`}`
`40`		`- colCnt, inBounds, _ := types.Int64.Convert(ctx, colCntLit.Value())`
	`40`	`+ colCnt, inBounds, _ := types.Int64.Convert(ctx, colCntLit.LiteralValue())`
`41`	`41`	`if !inBounds {`
`42`	`42`	`return nil, fmt.Errorf("normal_dist table expects 1st argument to be column count")`
`43`	`43`	`}`
`44`	`44`	`rowCntLit, ok := args[1].(*expression.Literal)`
`45`	`45`	`if !ok {`
`46`	`46`	`return nil, fmt.Errorf("normal_dist table expects arguments to be literal expressions")`
`47`	`47`	`}`
`48`		`- rowCnt, inBounds, _ := types.Int64.Convert(ctx, rowCntLit.Value())`
	`48`	`+ rowCnt, inBounds, _ := types.Int64.Convert(ctx, rowCntLit.LiteralValue())`
`49`	`49`	`if !inBounds {`
`50`	`50`	`return nil, fmt.Errorf("normal_dist table expects 2nd argument to be row count")`
`51`	`51`	`}`
`52`	`52`	`meanLit, ok := args[2].(*expression.Literal)`
`53`	`53`	`if !ok {`
`54`	`54`	`return nil, fmt.Errorf("normal_dist table expects arguments to be literal expressions")`
`55`	`55`	`}`
`56`		`- mean, inBounds, _ := types.Float64.Convert(ctx, meanLit.Value())`
	`56`	`+ mean, inBounds, _ := types.Float64.Convert(ctx, meanLit.LiteralValue())`
`57`	`57`	`if !inBounds {`
`58`	`58`	`return nil, fmt.Errorf("normal_dist table expects 3rd argument to be row count")`
`59`	`59`	`}`
`60`	`60`	`stdLit, ok := args[3].(*expression.Literal)`
`61`	`61`	`if !ok {`
`62`	`62`	`return nil, fmt.Errorf("normal_dist table expects arguments to be literal expressions")`
`63`	`63`	`}`
`64`		`- std, inBounds, _ := types.Float64.Convert(ctx, stdLit.Value())`
	`64`	`+ std, inBounds, _ := types.Float64.Convert(ctx, stdLit.LiteralValue())`
`65`	`65`	`if !inBounds {`
`66`	`66`	`return nil, fmt.Errorf("normal_dist table expects 4th argument to be row count")`
`67`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -37,15 +37,15 @@ func (s IntSequenceTable) NewInstance(ctx *sql.Context, db sql.Database, args []`
`37`	`37`	`if !ok {`
`38`	`38`	`return nil, fmt.Errorf("sequence table expects arguments to be literal expressions")`
`39`	`39`	`}`
`40`		`- name, ok := nameExp.Value().(string)`
	`40`	`+ name, ok := nameExp.LiteralValue().(string)`
`41`	`41`	`if !ok {`
`42`	`42`	`return nil, fmt.Errorf("sequence table expects 1st argument to be column name")`
`43`	`43`	`}`
`44`	`44`	`lenExp, ok := args[1].(*expression.Literal)`
`45`	`45`	`if !ok {`
`46`	`46`	`return nil, fmt.Errorf("sequence table expects arguments to be literal expressions")`
`47`	`47`	`}`
`48`		`- length, _, err := types.Int64.Convert(ctx, lenExp.Value())`
	`48`	`+ length, _, err := types.Int64.Convert(ctx, lenExp.LiteralValue())`
`49`	`49`	`if !ok {`
`50`	`50`	`return nil, fmt.Errorf("%w; sequence table expects 2nd argument to be a sequence length integer", err)`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,15 +27,15 @@ func (s TableFunc) NewInstance(ctx *sql.Context, db sql.Database, args []sql.Exp`
`27`	`27`	`if !ok {`
`28`	`28`	`return nil, fmt.Errorf("table_func table expects arguments to be literal expressions")`
`29`	`29`	`}`
`30`		`- name, ok := nameExp.Value().(string)`
	`30`	`+ name, ok := nameExp.LiteralValue().(string)`
`31`	`31`	`if !ok {`
`32`	`32`	`return nil, fmt.Errorf("table_func table expects 1st argument to be column name")`
`33`	`33`	`}`
`34`	`34`	`valueExpr, ok := args[1].(*expression.Literal)`
`35`	`35`	`if !ok {`
`36`	`36`	`return nil, fmt.Errorf("table_func table expects arguments to be literal expressions")`
`37`	`37`	`}`
`38`		`- value, _, err := types.Int64.Convert(ctx, valueExpr.Value())`
	`38`	`+ value, _, err := types.Int64.Convert(ctx, valueExpr.LiteralValue())`
`39`	`39`	`if !ok {`
`40`	`40`	`return nil, fmt.Errorf("%w; table_func table expects 2nd argument to be a table_func length integer", err)`
`41`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -913,7 +913,7 @@ func (i indexSearchableTable) LookupForExpressions(ctx sql.Context, exprs ...s`
`913`	`913`	`if eq, ok := exprs[0].(*expression.Equals); ok {`
`914`	`914`	`if gf, ok := eq.Left().(*expression.GetField); ok && strings.EqualFold(gf.Name(), "x") {`
`915`	`915`	`if lit, ok := eq.Right().(*expression.Literal); ok {`
`916`		`- ranges := sql.MySQLRangeCollection{{sql.ClosedRangeColumnExpr(lit.Value(), lit.Value(), lit.Type())}}`
	`916`	`+ ranges := sql.MySQLRangeCollection{{sql.ClosedRangeColumnExpr(lit.LiteralValue(), lit.LiteralValue(), lit.Type())}}`
`917`	`917`	`return sql.IndexLookup{Index: xIdx, Ranges: ranges}, nil, nil, true, nil`
`918`	`918`	`}`
`919`	`919`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1311,7 +1311,7 @@ func makeIndexScan(ctx *sql.Context, statsProv sql.StatsProvider, tab plan.Table`
`1311`	`1311`	`if found && lit == nil {`
`1312`	`1312`	`break`
`1313`	`1313`	`}`
`1314`		`- rang[j] = sql.ClosedRangeColumnExpr(lit.Value(), lit.Value(), idx.SqlIdx().ColumnExpressionTypes()[j].Type)`
	`1314`	`+ rang[j] = sql.ClosedRangeColumnExpr(lit.LiteralValue(), lit.LiteralValue(), idx.SqlIdx().ColumnExpressionTypes()[j].Type)`
`1315`	`1315`	`j++`
`1316`	`1316`	`if found {`
`1317`	`1317`	`break`
Original file line number	Diff line number	Diff line change
`@@ -243,7 +243,7 @@ func isZero(ctx sql.Context, lit expression.Literal) bool {`
`243`	`243`	`return false`
`244`	`244`	`}`
`245`	`245`
`246`		`- convert, inRange, err := types.Int8.Convert(ctx, lit.Value())`
	`246`	`+ convert, inRange, err := types.Int8.Convert(ctx, lit.LiteralValue())`
`247`	`247`	`if err != nil {`
`248`	`248`	`// Ignore any conversion errors, since that means the value isn't 0`
`249`	`249`	`// and the values are validated in other parts of the analyzer anyway.`