Merge remote-tracking branch 'upstream/master' into stmt-cache2

# Conflicts:
#	tests/postgres/alltypes_test.go
#	tests/postgres/northwind_test.go
#	tests/postgres/sample_test.go
#	tests/postgres/update_test.go
#	tests/sqlite/insert_test.go
#	tests/sqlite/main_test.go
#	tests/sqlite/sample_test.go
#	tests/sqlite/update_test.go

mysql/cast.go

@@ -6,23 +6,27 @@ import (
 )
 
 type cast interface {
-	// Cast expressions as castType type
+	// AS casts expressions as castType type
 	AS(castType string) Expression
-	// Cast expression as char with optional length
+	// AS_CHAR casts expression as char with optional length
 	AS_CHAR(length ...int) StringExpression
-	// Cast expression AS date type
+	// AS_DATE casts expression AS date type
 	AS_DATE() DateExpression
-	// Cast expression AS numeric type, using precision and optionally scale
+	// AS_FLOAT casts expressions as float type
+	AS_FLOAT() FloatExpression
+	// AS_DOUBLE casts expressions as double type
+	AS_DOUBLE() FloatExpression
+	// AS_DECIMAL casts expression AS numeric type
 	AS_DECIMAL() FloatExpression
-	// Cast expression AS time type
+	// AS_TIME casts expression AS time type
 	AS_TIME() TimeExpression
-	// Cast expression as datetime type
+	// AS_DATETIME casts expression as datetime type
 	AS_DATETIME() DateTimeExpression
-	// Cast expressions as signed integer type
+	// AS_SIGNED casts expressions as signed integer type
 	AS_SIGNED() IntegerExpression
-	// Cast expression as unsigned integer type
+	// AS_UNSIGNED casts expression as unsigned integer type
 	AS_UNSIGNED() IntegerExpression
-	// Cast expression as binary type
+	// AS_BINARY casts expression as binary type
 	AS_BINARY() StringExpression
 }
 
@@ -73,6 +77,14 @@ func (c *castImpl) AS_DATE() DateExpression {
 	return DateExp(c.AS("DATE"))
 }
 
+func (c *castImpl) AS_FLOAT() FloatExpression {
+	return FloatExp(c.AS("FLOAT"))
+}
+
+func (c *castImpl) AS_DOUBLE() FloatExpression {
+	return FloatExp(c.AS("DOUBLE"))
+}
+
 // AS_DECIMAL casts expression AS DECIMAL type
 func (c *castImpl) AS_DECIMAL() FloatExpression {
 	return FloatExp(c.AS("DECIMAL"))

mysql/dialect.go

@@ -1,6 +1,7 @@
 package mysql
 
 import (
+	"fmt"
 	"github.com/go-jet/jet/v2/internal/jet"
 )
 
@@ -28,6 +29,9 @@ func newDialect() jet.Dialect {
 		},
 		ReservedWords:    reservedWords,
 		SerializeOrderBy: serializeOrderBy,
+		ValuesDefaultColumnName: func(index int) string {
+			return fmt.Sprintf("column_%d", index)
+		},
 	}
 
 	return jet.NewDialect(mySQLDialectParams)

mysql/expressions.go

@@ -30,6 +30,9 @@ type DateTimeExpression = jet.TimestampExpression
 // TimestampExpression interface
 type TimestampExpression = jet.TimestampExpression
 
+// RowExpression interface
+type RowExpression = jet.RowExpression
+
 // BoolExp is bool expression wrapper around arbitrary expression.
 // Allows go compiler to see any expression as bool expression.
 // Does not add sql cast to generated sql builder output.
@@ -70,6 +73,11 @@ var DateTimeExp = jet.TimestampExp
 // Does not add sql cast to generated sql builder output.
 var TimestampExp = jet.TimestampExp
 
+// RowExp serves as a wrapper for an arbitrary expression, treating it as a row expression.
+// This enables the Go compiler to interpret any expression as a row expression
+// Note: This does not modify the generated SQL builder output by adding a SQL CAST operation.
+var RowExp = jet.RowExp
+
 // CustomExpression is used to define custom expressions.
 var CustomExpression = jet.CustomExpression
 

mysql/functions.go

@@ -12,7 +12,9 @@ var (
 )
 
 // ROW function is used to create a tuple value that consists of a set of expressions or column values.
-var ROW = jet.ROW
+func ROW(expressions ...Expression) RowExpression {
+	return jet.ROW(Dialect, expressions...)
+}
 
 // ------------------ Mathematical functions ---------------//
 

mysql/interval.go

@@ -14,25 +14,25 @@ type unitType string
 // List of interval unit types for MySQL
 const (
 	MICROSECOND        unitType = "MICROSECOND"
-	SECOND                      = "SECOND"
-	MINUTE                      = "MINUTE"
-	HOUR                        = "HOUR"
-	DAY                         = "DAY"
-	WEEK                        = "WEEK"
-	MONTH                       = "MONTH"
-	QUARTER                     = "QUARTER"
-	YEAR                        = "YEAR"
-	SECOND_MICROSECOND          = "SECOND_MICROSECOND"
-	MINUTE_MICROSECOND          = "MINUTE_MICROSECOND"
-	MINUTE_SECOND               = "MINUTE_SECOND"
-	HOUR_MICROSECOND            = "HOUR_MICROSECOND"
-	HOUR_SECOND                 = "HOUR_SECOND"
-	HOUR_MINUTE                 = "HOUR_MINUTE"
-	DAY_MICROSECOND             = "DAY_MICROSECOND"
-	DAY_SECOND                  = "DAY_SECOND"
-	DAY_MINUTE                  = "DAY_MINUTE"
-	DAY_HOUR                    = "DAY_HOUR"
-	YEAR_MONTH                  = "YEAR_MONTH"
+	SECOND             unitType = "SECOND"
+	MINUTE             unitType = "MINUTE"
+	HOUR               unitType = "HOUR"
+	DAY                unitType = "DAY"
+	WEEK               unitType = "WEEK"
+	MONTH              unitType = "MONTH"
+	QUARTER            unitType = "QUARTER"
+	YEAR               unitType = "YEAR"
+	SECOND_MICROSECOND unitType = "SECOND_MICROSECOND"
+	MINUTE_MICROSECOND unitType = "MINUTE_MICROSECOND"
+	MINUTE_SECOND      unitType = "MINUTE_SECOND"
+	HOUR_MICROSECOND   unitType = "HOUR_MICROSECOND"
+	HOUR_SECOND        unitType = "HOUR_SECOND"
+	HOUR_MINUTE        unitType = "HOUR_MINUTE"
+	DAY_MICROSECOND    unitType = "DAY_MICROSECOND"
+	DAY_SECOND         unitType = "DAY_SECOND"
+	DAY_MINUTE         unitType = "DAY_MINUTE"
+	DAY_HOUR           unitType = "DAY_HOUR"
+	YEAR_MONTH         unitType = "YEAR_MONTH"
 )
 
 // Interval is representation of MySQL interval

mysql/select_statement.go

@@ -172,7 +172,7 @@ func (s *selectStatementImpl) LOCK_IN_SHARE_MODE() SelectStatement {
 }
 
 func (s *selectStatementImpl) AsTable(alias string) SelectTable {
-	return newSelectTable(s, alias)
+	return newSelectTable(s, alias, nil)
 }
 
 //-----------------------------------------------------

mysql/select_table.go

@@ -13,9 +13,9 @@ type selectTableImpl struct {
 	readableTableInterfaceImpl
 }
 
-func newSelectTable(selectStmt jet.SerializerHasProjections, alias string) SelectTable {
+func newSelectTable(selectStmt jet.SerializerHasProjections, alias string, columnAliases []jet.ColumnExpression) SelectTable {
 	subQuery := &selectTableImpl{
-		SelectTable: jet.NewSelectTable(selectStmt, alias),
+		SelectTable: jet.NewSelectTable(selectStmt, alias, columnAliases),
 	}
 
 	subQuery.readableTableInterfaceImpl.parent = subQuery

mysql/set_statement.go

@@ -85,7 +85,7 @@ func (s *setStatementImpl) OFFSET(offset int64) setStatement {
 }
 
 func (s *setStatementImpl) AsTable(alias string) SelectTable {
-	return newSelectTable(s, alias)
+	return newSelectTable(s, alias, nil)
 }
 
 const (

mysql/statement.go

@@ -6,7 +6,7 @@ import (
 )
 
 // RawStatement creates new sql statements from raw query and optional map of named arguments
-func RawStatement(rawQuery string, namedArguments ...RawArgs) Statement {
+func RawStatement(rawQuery string, namedArguments ...RawArgs) jet.SerializerStatement {
 	return jet.RawStatement(Dialect, rawQuery, namedArguments...)
 }
 

mysql/values.go

@@ -0,0 +1,32 @@
+package mysql
+
+import "github.com/go-jet/jet/v2/internal/jet"
+
+type values struct {
+	jet.Values
+}
+
+// VALUES is a table value constructor that computes a set of one or more rows as a temporary constant table.
+// Each row is defined by the ROW constructor, which takes one or more expressions.
+//
+// Example usage:
+//
+//	VALUES(
+//		ROW(Int32(204), Float32(1.21)),
+//		ROW(Int32(207), Float32(1.02)),
+//	)
+func VALUES(rows ...RowExpression) values {
+	return values{Values: jet.Values(rows)}
+}
+
+// AS assigns an alias to the temporary VALUES table, allowing it to be referenced
+// within SQL FROM clauses, just like a regular table.
+// By default, VALUES columns are named `column1`, `column2`, etc... Default column aliasing can be
+// overwritten by passing new list of columns.
+//
+// Example usage:
+//
+//	VALUES(...).AS("film_values", IntegerColumn("length"), TimestampColumn("update_date"))
+func (v values) AS(alias string, columns ...Column) SelectTable {
+	return newSelectTable(v, alias, columns)
+}

mysql/with_statement.go

@@ -6,7 +6,7 @@ import "github.com/go-jet/jet/v2/internal/jet"
 type CommonTableExpression interface {
 	SelectTable
 
-	AS(statement jet.SerializerStatement) CommonTableExpression
+	AS(statement jet.SerializerHasProjections) CommonTableExpression
 	// ALIAS is used to create another alias of the CTE, if a CTE needs to appear multiple times in the main query.
 	ALIAS(alias string) SelectTable
 
@@ -41,7 +41,7 @@ func CTE(name string, columns ...jet.ColumnExpression) CommonTableExpression {
 }
 
 // AS is used to define a CTE query
-func (c *commonTableExpression) AS(statement jet.SerializerStatement) CommonTableExpression {
+func (c *commonTableExpression) AS(statement jet.SerializerHasProjections) CommonTableExpression {
 	c.CommonTableExpression.Statement = statement
 	return c
 }
@@ -52,7 +52,7 @@ func (c *commonTableExpression) internalCTE() *jet.CommonTableExpression {
 
 // ALIAS is used to create another alias of the CTE, if a CTE needs to appear multiple times in the main query.
 func (c *commonTableExpression) ALIAS(name string) SelectTable {
-	return newSelectTable(c, name)
+	return newSelectTable(c, name, nil)
 }
 
 func toInternalCTE(ctes []CommonTableExpression) []*jet.CommonTableExpression {