merge main

Author: zachmu

enginetest/queries/generated_columns.go

@@ -65,6 +65,14 @@ var GeneratedColumnTests = []ScriptTest{
 				Query:    "select * from t1 where b = 5 order by a",
 				Expected: []sql.Row{{4, 5}},
 			},
+			{
+				Query:    "insert into t1 values (5, DEFAULT)",
+				Expected: []sql.Row{{types.NewOkResult(1)}},
+			},
+			{
+				Query:    "select * from t1 where a = 5",
+				Expected: []sql.Row{{5, 6}},
+			},
 			{
 				Query:       "update t1 set b = b + 1",
 				ExpectedErr: sql.ErrGeneratedColumnValue,
@@ -75,15 +83,43 @@ var GeneratedColumnTests = []ScriptTest{
 			},
 			{
 				Query:    "select * from t1 order by a",
-				Expected: []sql.Row{{2, 3}, {3, 4}, {4, 5}, {10, 11}},
+				Expected: []sql.Row{{2, 3}, {3, 4}, {4, 5}, {5, 6}, {10, 11}},
 			},
 			{
 				Query:    "delete from t1 where b = 11",
 				Expected: []sql.Row{{types.NewOkResult(1)}},
 			},
 			{
 				Query:    "select * from t1 order by a",
-				Expected: []sql.Row{{2, 3}, {3, 4}, {4, 5}},
+				Expected: []sql.Row{{2, 3}, {3, 4}, {4, 5}, {5, 6}},
+			},
+		},
+	},
+	{
+		Name: "generated column with DEFAULT in VALUES clause (issue #9428)",
+		SetUpScript: []string{
+			"create table t (i int generated always as (1 + 1))",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query:    "insert into t values (default)",
+				Expected: []sql.Row{{types.NewOkResult(1)}},
+			},
+			{
+				Query:    "select * from t",
+				Expected: []sql.Row{{2}},
+			},
+			{
+				Query:    "insert into t values (default), (default)",
+				Expected: []sql.Row{{types.NewOkResult(2)}},
+			},
+			{
+				Query:    "select * from t order by i",
+				Expected: []sql.Row{{2}, {2}, {2}},
+			},
+			{
+				Query:       "insert into t values (5)",
+				ExpectedErr: sql.ErrGeneratedColumnValue,
 			},
 		},
 	},

enginetest/queries/integration_plans.go

@@ -8728,6 +8728,27 @@ where
 			},
 		},
 	},
+	{
+		// https://github.com/dolthub/dolt/issues/9024
+		Name:    "subqueries should coerce union types",
+		Dialect: "mysql",
+		SetUpScript: []string{
+			"create table enum_table (i int primary key, e enum('a','b') not null)",
+			"insert into enum_table values (1,'a'),(2,'b')",
+			"create table uv (u int primary key, v varchar(10))",
+			"insert into uv values (0, 'bug'),(1,'ant'),(3, null)",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query:    "select * from (select e from enum_table union select v from uv) sq",
+				Expected: []sql.Row{{"a"}, {"b"}, {"bug"}, {"ant"}, {nil}},
+			},
+			{
+				Query:    "with a as (select e from enum_table union select v from uv) select * from a",
+				Expected: []sql.Row{{"a"}, {"b"}, {"bug"}, {"ant"}, {nil}},
+			},
+		},
+	},
 
 	// Enum tests
 	{

enginetest/queries/script_queries.go

@@ -76,10 +76,6 @@ func (b *Builder) buildInsert(inScope *scope, i *ast.Insert) (outScope *scope) {
 			schema := rt.Schema()
 			columns = make([]string, len(schema))
 			for i, col := range schema {
-				// Tables with any generated column must always supply a column list, so this is always an error
-				if col.Generated != nil {
-					b.handleErr(sql.ErrGeneratedColumnValue.New(col.Name, rt.Name()))
-				}
 				columns[i] = col.Name
 			}
 		}

sql/planbuilder/dml.go

@@ -165,7 +165,12 @@ func validGeneratedColumnValue(idx int, source sql.Node) bool {
 				if _, ok := val.Unwrap().(*sql.ColumnDefaultValue); ok {
 					return true
 				}
+				if _, ok := val.Unwrap().(*expression.DefaultColumn); ok {
+					return true
+				}
 				return false
+			case *expression.DefaultColumn: // handle unwrapped DefaultColumn
+				return true
 			default:
 				return false
 			}

sql/planbuilder/dml_validate.go

@@ -24,6 +24,7 @@ import (
 	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/plan"
 	"github.com/dolthub/go-mysql-server/sql/transform"
+	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
 func hasRecursiveCte(node sql.Node) bool {
@@ -144,10 +145,28 @@ func (b *Builder) buildSetOp(inScope *scope, u *ast.SetOp) (outScope *scope) {
 	tabId := b.tabId
 	ret := plan.NewSetOp(setOpType, leftScope.node, rightScope.node, distinct, limit, offset, sortFields).WithId(tabId).WithColumns(cols)
 	outScope = leftScope
+	outScope.cols = b.mergeSetOpScopeColumns(leftScope.cols, rightScope.cols, tabId)
 	outScope.node = b.mergeSetOpSchemas(ret.(*plan.SetOp))
 	return
 }
 
+func (b *Builder) mergeSetOpScopeColumns(left, right []scopeColumn, tabId sql.TableId) []scopeColumn {
+	merged := make([]scopeColumn, len(left))
+	for i := range left {
+		merged[i] = scopeColumn{
+			tableId:     tabId,
+			db:          left[i].db,
+			table:       left[i].table,
+			col:         left[i].col,
+			originalCol: left[i].originalCol,
+			id:          left[i].id,
+			typ:         types.GeneralizeTypes(left[i].typ, right[i].typ),
+			nullable:    left[i].nullable || right[i].nullable,
+		}
+	}
+	return merged
+}
+
 func (b *Builder) mergeSetOpSchemas(u *plan.SetOp) sql.Node {
 	ls, rs := u.Left().Schema(), u.Right().Schema()
 	if len(ls) != len(rs) {

sql/planbuilder/set_op.go

@@ -16,6 +16,7 @@ package types
 
 import (
 	"fmt"
+	"reflect"
 	"strconv"
 	"strings"
 	"time"
@@ -635,7 +636,12 @@ func generalizeNumberTypes(a, b sql.Type) sql.Type {
 // GeneralizeTypes returns the more "general" of two types as defined by
 // https://dev.mysql.com/doc/refman/8.4/en/flow-control-functions.html
 // TODO: Create and handle "Illegal mix of collations" error
+// TODO: Handle extended types, like DoltgresType
 func GeneralizeTypes(a, b sql.Type) sql.Type {
+	if reflect.DeepEqual(a, b) {
+		return a
+	}
+
 	if a == Null {
 		return b
 	}

sql/types/conversion.go

@@ -207,7 +207,7 @@ func TestGeneralizeTypes(t *testing.T) {
 		{Time, Date, DatetimeMaxPrecision},
 		{Date, Date, Date},
 		{Date, Timestamp, DatetimeMaxPrecision},
-		{Timestamp, Timestamp, TimestampMaxPrecision},
+		{Timestamp, Timestamp, Timestamp},
 		{Timestamp, TimestampMaxPrecision, TimestampMaxPrecision},
 		{Timestamp, Datetime, DatetimeMaxPrecision},
 		{Null, Int64, Int64},