sql: Allow DEFAULT/ON UPDATE types that can be assignment-cast

pkg/ccl/changefeedccl/avro_test.go

@@ -116,7 +116,7 @@ func parseValues(tableDesc catalog.TableDescriptor, values string) ([]rowenc.Enc
 		for colIdx, expr := range rowTuple {
 			col := tableDesc.PublicColumns()[colIdx]
 			typedExpr, err := schemaexpr.SanitizeVarFreeExpr(
-				ctx, expr, col.GetType(), "avro", &semaCtx, volatility.Stable)
+				ctx, expr, col.GetType(), "avro", &semaCtx, volatility.Stable, false /*allowAssignmentCast*/)
 			if err != nil {
 				return nil, err
 			}

pkg/ccl/changefeedccl/cdceval/expr_eval.go

@@ -374,7 +374,7 @@ func (e *exprEval) typeCheck(
 ) (tree.TypedExpr, error) {
 	// If we have variable free immutable expressions, then we can just evaluate it right away.
 	typedExpr, err := schemaexpr.SanitizeVarFreeExpr(
-		ctx, expr, targetType, "cdc", &e.semaCtx, volatility.Immutable)
+		ctx, expr, targetType, "cdc", &e.semaCtx, volatility.Immutable, false)
 	if err == nil {
 		d, err := eval.Expr(e.evalCtx, typedExpr)
 		if err != nil {

pkg/ccl/partitionccl/partition.go

@@ -105,6 +105,7 @@ func valueEncodePartitionTuple(
 		typedExpr, err := schemaexpr.SanitizeVarFreeExpr(evalCtx.Context, expr, cols[i].GetType(), "partition",
 			&semaCtx,
 			volatility.Immutable,
+			false, /*allowAssignmentCast*/
 		)
 		if err != nil {
 			return nil, err

pkg/sql/alter_table.go

@@ -1138,7 +1138,7 @@ func sanitizeColumnExpression(
 ) (tree.TypedExpr, string, error) {
 	colDatumType := col.GetType()
 	typedExpr, err := schemaexpr.SanitizeVarFreeExpr(
-		p.ctx, expr, colDatumType, opName, &p.p.semaCtx, volatility.Volatile,
+		p.ctx, expr, colDatumType, opName, &p.p.semaCtx, volatility.Volatile, false, /*allowAssignmentCast*/
 	)
 	if err != nil {
 		return nil, "", pgerror.WithCandidateCode(err, pgcode.DatatypeMismatch)

pkg/sql/alter_table_locality.go

@@ -373,6 +373,7 @@ func (n *alterTableSetLocalityNode) alterTableLocalityToRegionalByRow(
 			"REGIONAL BY ROW DEFAULT",
 			params.p.SemaCtx(),
 			volatility.Volatile,
+			false, /*allowAssignmentCast*/
 		)
 		if err != nil {
 			return err

pkg/sql/analyze_expr.go

@@ -50,8 +50,7 @@ func (p *planner) analyzeExpr(
 	var err error
 	p.semaCtx.IVarContainer = iVarHelper.Container()
 	if requireType {
-		typedExpr, err = tree.TypeCheckAndRequire(ctx, resolved, &p.semaCtx,
-			expectedType, typingContext)
+		typedExpr, err = tree.TypeCheckAndRequire(ctx, resolved, &p.semaCtx, expectedType, typingContext)
 	} else {
 		typedExpr, err = tree.TypeCheck(ctx, resolved, &p.semaCtx, expectedType)
 	}

pkg/sql/catalog/schemaexpr/BUILD.bazel

@@ -25,6 +25,7 @@ go_library(
         "//pkg/sql/parser",
         "//pkg/sql/pgwire/pgcode",
         "//pkg/sql/pgwire/pgerror",
+        "//pkg/sql/sem/cast",
         "//pkg/sql/sem/catid",
         "//pkg/sql/sem/eval",
         "//pkg/sql/sem/transform",

pkg/sql/catalog/schemaexpr/expr.go

@@ -20,6 +20,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/sql/parser"
 	"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgcode"
 	"github.com/cockroachdb/cockroach/pkg/sql/pgwire/pgerror"
+	"github.com/cockroachdb/cockroach/pkg/sql/sem/cast"
 	"github.com/cockroachdb/cockroach/pkg/sql/sem/eval"
 	"github.com/cockroachdb/cockroach/pkg/sql/sem/tree"
 	"github.com/cockroachdb/cockroach/pkg/sql/sem/volatility"
@@ -105,6 +106,7 @@ func DequalifyAndValidateExpr(
 		context,
 		semaCtx,
 		maxVolatility,
+		false, /*allowAssignmentCast*/
 	)
 
 	if err != nil {
@@ -295,7 +297,7 @@ func deserializeExprForFormatting(
 	// typedExpr.
 	if fmtFlags == tree.FmtPGCatalog {
 		sanitizedExpr, err := SanitizeVarFreeExpr(ctx, expr, typedExpr.ResolvedType(), "FORMAT", semaCtx,
-			volatility.Immutable)
+			volatility.Immutable, false /*allowAssignmentCast*/)
 		// If the expr has no variables and has Immutable, we can evaluate
 		// it and turn it into a constant.
 		if err == nil {
@@ -398,6 +400,7 @@ func SanitizeVarFreeExpr(
 	context string,
 	semaCtx *tree.SemaContext,
 	maxVolatility volatility.V,
+	allowAssignmentCast bool,
 ) (tree.TypedExpr, error) {
 	if tree.ContainsVars(expr) {
 		return nil, pgerror.Newf(pgcode.Syntax,
@@ -436,7 +439,12 @@ func SanitizeVarFreeExpr(
 	actualType := typedExpr.ResolvedType()
 	if !expectedType.Equivalent(actualType) && typedExpr != tree.DNull {
 		// The expression must match the column type exactly unless it is a constant
-		// NULL value.
+		// NULL value or assignment casts are allowed.
+		if allowAssignmentCast {
+			if ok := cast.ValidCast(actualType, expectedType, cast.ContextAssignment); ok {
+				return typedExpr, nil
+			}
+		}
 		return nil, fmt.Errorf("expected %s expression to have type %s, but '%s' has type %s",
 			context, expectedType, expr, actualType)
 	}

pkg/sql/catalog/tabledesc/table.go

@@ -161,7 +161,7 @@ func MakeColumnDefDescs(
 		// Verify the default expression type is compatible with the column type
 		// and does not contain invalid functions.
 		ret.DefaultExpr, err = schemaexpr.SanitizeVarFreeExpr(
-			ctx, d.DefaultExpr.Expr, resType, "DEFAULT", semaCtx, volatility.Volatile,
+			ctx, d.DefaultExpr.Expr, resType, "DEFAULT", semaCtx, volatility.Volatile, true, /*allowAssignmentCast*/
 		)
 		if err != nil {
 			return nil, err
@@ -181,7 +181,7 @@ func MakeColumnDefDescs(
 		// Verify the on update expression type is compatible with the column type
 		// and does not contain invalid functions.
 		ret.OnUpdateExpr, err = schemaexpr.SanitizeVarFreeExpr(
-			ctx, d.OnUpdateExpr.Expr, resType, "ON UPDATE", semaCtx, volatility.Volatile,
+			ctx, d.OnUpdateExpr.Expr, resType, "ON UPDATE", semaCtx, volatility.Volatile, true, /*allowAssignmentCast*/
 		)
 		if err != nil {
 			return nil, err
@@ -266,7 +266,7 @@ func EvalShardBucketCount(
 			shardBuckets = paramVal
 		}
 		typedExpr, err := schemaexpr.SanitizeVarFreeExpr(
-			ctx, shardBuckets, types.Int, "BUCKET_COUNT", semaCtx, volatility.Volatile,
+			ctx, shardBuckets, types.Int, "BUCKET_COUNT", semaCtx, volatility.Volatile, false, /*allowAssignmentCast*/
 		)
 		if err != nil {
 			return 0, err

pkg/sql/execute.go

@@ -54,7 +54,7 @@ func (p *planner) fillInPlaceholders(
 			}
 		}
 		typedExpr, err := schemaexpr.SanitizeVarFreeExpr(
-			ctx, e, typ, "EXECUTE parameter" /* context */, &semaCtx, volatility.Volatile,
+			ctx, e, typ, "EXECUTE parameter" /* context */, &semaCtx, volatility.Volatile, false, /*allowAssignmentCast*/
 		)
 		if err != nil {
 			return nil, pgerror.WithCandidateCode(err, pgcode.WrongObjectType)

pkg/sql/logictest/testdata/logic_test/cast

@@ -1418,3 +1418,71 @@ query TT
 SELECT (-1/3.0)::float4::text, (1/3.0)::float8::text
 ----
 -0.3  0.3
+
+# Test that default/on update expression is allowed to differ from column type
+statement ok
+CREATE TABLE def_assn_cast (
+  id INT4,
+  a INT4 DEFAULT 1.0::FLOAT4,
+  b VARCHAR DEFAULT 'true'::BOOL,
+  c NAME DEFAULT 'foo'::BPCHAR
+)
+
+statement ok
+CREATE TABLE upd_assn_cast (
+  id INT4,
+  a TEXT ON UPDATE 'POINT(2.0 2.0)'::GEOMETRY,
+  b FLOAT8 ON UPDATE 6::INT4,
+  c VARCHAR ON UPDATE '{ "customer": "John Doe"}'::JSONB
+)
+
+# Ensure insertions are allowed
+statement ok
+INSERT INTO def_assn_cast(id) VALUES (1)
+
+statement ok
+INSERT INTO upd_assn_cast(id) VALUES (1)
+
+statement ok
+UPDATE upd_assn_cast SET id = 2
+
+query IITT
+SELECT * from def_assn_cast
+----
+1  1  true  f
+
+query ITFT
+SELECT * from upd_assn_cast
+----
+2  010100000000000000000000400000000000000040  6  {"customer": "John Doe"}
+
+
+statement error pq: could not parse .* as type .*: invalid .* value
+CREATE TABLE fail_assn_cast (
+  a BOOL DEFAULT 'foo'
+)
+
+statement error pq: expected DEFAULT expression to have type .*, but .* has type .*
+CREATE TABLE fail_assn_cast (
+  a DATE DEFAULT 1.0::FLOAT4
+)
+
+statement error pq: expected DEFAULT expression to have type .*, but .* has type .*
+CREATE TABLE fail_assn_cast (
+  b JSONB DEFAULT 'null'::CHAR
+)
+
+statement error pq: expected ON UPDATE expression to have type .*, but .* has type .*
+CREATE TABLE fail_assn_cast (
+  a INT4 ON UPDATE 1.0::BOOL
+)
+
+statement error pq: expected ON UPDATE expression to have type .*, but .* has type .*
+CREATE TABLE fail_assn_cast (
+  a FLOAT4 ON UPDATE '01/02/03'::DATE
+)
+
+statement error pq: expected ON UPDATE expression to have type .*, but .* has type .*
+CREATE TABLE fail_assn_cast (
+  a NUMERIC ON UPDATE '1-2'::INTERVAL
+)

pkg/sql/opt/bench/bench_test.go

@@ -429,6 +429,7 @@ func newHarness(tb testing.TB, query benchQuery) *harness {
 			"", /* context */
 			&h.semaCtx,
 			volatility.Volatile,
+			false, /*allowAssignmentCast*/
 		)
 		if err != nil {
 			tb.Fatalf("%v", err)

pkg/sql/opt/testutils/opttester/opt_tester.go

@@ -1219,6 +1219,7 @@ func (ot *OptTester) AssignPlaceholders(
 			"", /* context */
 			&ot.semaCtx,
 			volatility.Volatile,
+			false, /*allowAssignmentCast*/
 		)
 		if err != nil {
 			return nil, err

pkg/sql/opt/testutils/testcat/alter_table.go

@@ -60,9 +60,7 @@ func injectTableStats(tt *Table, statsExpr tree.Expr) {
 	ctx := context.Background()
 	semaCtx := tree.MakeSemaContext()
 	evalCtx := eval.MakeTestingEvalContext(cluster.MakeTestingClusterSettings())
-	typedExpr, err := tree.TypeCheckAndRequire(
-		ctx, statsExpr, &semaCtx, types.Jsonb, "INJECT STATISTICS",
-	)
+	typedExpr, err := tree.TypeCheckAndRequire(ctx, statsExpr, &semaCtx, types.Jsonb, "INJECT STATISTICS")
 	if err != nil {
 		panic(err)
 	}

pkg/sql/row/expr_walker.go

@@ -784,7 +784,7 @@ func sanitizeExprsForImport(
 
 	// If we have immutable expressions, then we can just return it right away.
 	typedExpr, err := schemaexpr.SanitizeVarFreeExpr(
-		ctx, expr, targetType, "import_default", &semaCtx, volatility.Immutable)
+		ctx, expr, targetType, "import_default", &semaCtx, volatility.Immutable, false /*allowAssignmentCast*/)
 	if err == nil {
 		return typedExpr, overrideImmutable, nil
 	}