Merge main

Author: zachmu

driver/conn.go

@@ -23,13 +23,13 @@ import (
 
 // Conn is a connection to a database.
 type Conn struct {
-	dsn      string
-	options  *Options
-	dbConn   *dbConn
 	session  sql.Session
 	contexts ContextBuilder
+	options  *Options
+	dbConn   *dbConn
 	indexes  *sql.IndexRegistry
 	views    *sql.ViewRegistry
+	dsn      string
 }
 
 // DSN returns the driver connection string.

driver/driver.go

@@ -82,12 +82,11 @@ type ProviderWithSessionBuilder interface {
 // A Driver exposes an engine as a stdlib SQL driver.
 type Driver struct {
 	provider Provider
-	options  *Options
 	sessions SessionBuilder
 	contexts ContextBuilder
-
-	mu  sync.Mutex
-	dbs map[string]*dbConn
+	options  *Options
+	dbs      map[string]*dbConn
+	mu       sync.Mutex
 }
 
 // New returns a driver using the specified provider.
@@ -223,9 +222,9 @@ func (c *dbConn) close() error {
 type Connector struct {
 	driver     *Driver
 	options    *Options
+	dbConn     *dbConn
 	serverName string
 	dsn        string
-	dbConn     *dbConn
 }
 
 // Driver returns the driver.

driver/rows.go

@@ -26,10 +26,10 @@ import (
 
 // Rows is an iterator over an executed query's results.
 type Rows struct {
+	rows    sql.RowIter
 	options *Options
 	ctx     *sql.Context
 	cols    sql.Schema
-	rows    sql.RowIter
 }
 
 // Columns returns the names of the columns. The number of

driver/stmt.go

@@ -117,5 +117,10 @@ func (s *Stmt) query(ctx context.Context, bindings map[string]sqlparser.Expr) (d
 		return nil, err
 	}
 
-	return &Rows{s.conn.options, qctx, cols, rows}, nil
+	return &Rows{
+		options: s.conn.options,
+		ctx:     qctx,
+		cols:    cols,
+		rows:    rows,
+	}, nil
 }

engine.go

@@ -53,16 +53,16 @@ func init() {
 type Config struct {
 	// VersionPostfix to display with the `VERSION()` UDF.
 	VersionPostfix string
+	// TemporaryUsers adds any users that should be included when the engine is created. By default, authentication is
+	// disabled, and including any users here will enable authentication. All users in this list will have full access.
+	// This field is only temporary, and will be removed as development on users and authentication continues.
+	TemporaryUsers []TemporaryUser
 	// IsReadOnly sets the engine to disallow modification queries.
 	IsReadOnly     bool
 	IsServerLocked bool
 	// IncludeRootAccount adds the root account (with no password) to the list of accounts, and also enables
 	// authentication.
 	IncludeRootAccount bool
-	// TemporaryUsers adds any users that should be included when the engine is created. By default, authentication is
-	// disabled, and including any users here will enable authentication. All users in this list will have full access.
-	// This field is only temporary, and will be removed as development on users and authentication continues.
-	TemporaryUsers []TemporaryUser
 }
 
 // TemporaryUser is a user that will be added to the engine. This is for temporary use while the remaining features
@@ -136,18 +136,18 @@ func (p *PreparedDataCache) UncacheStmt(sessId uint32, query string) {
 
 // Engine is a SQL engine.
 type Engine struct {
+	Parser            sql.Parser
+	ProcessList       sql.ProcessList
 	Analyzer          *analyzer.Analyzer
 	LS                *sql.LockSubsystem
-	ProcessList       sql.ProcessList
 	MemoryManager     *sql.MemoryManager
 	BackgroundThreads *sql.BackgroundThreads
-	ReadOnly          atomic.Bool
-	IsServerLocked    bool
 	PreparedDataCache *PreparedDataCache
 	mu                *sync.Mutex
-	Version           sql.AnalyzerVersion
 	EventScheduler    *eventscheduler.EventScheduler
-	Parser            sql.Parser
+	ReadOnly          atomic.Bool
+	IsServerLocked    bool
+	Version           sql.AnalyzerVersion
 }
 
 var _ sql.StatementRunner = (*Engine)(nil)

enginetest/enginetests.go

@@ -6089,6 +6089,15 @@ func TestVectorFunctions(t *testing.T, h Harness) {
 	for _, tt := range queries.VectorFunctionQueries {
 		TestScript(t, h, tt)
 	}
+	for _, testCase := range queries.VectorFunctionTestCases {
+		TestScript(t, h, queries.MakeVectorFunctionTest(testCase))
+	}
+}
+
+func TestVectorType(t *testing.T, h Harness) {
+	for _, tt := range queries.VectorDDLQueries {
+		TestScript(t, h, tt)
+	}
 }
 
 func TestIndexPrefix(t *testing.T, h Harness) {

enginetest/join_op_tests.go

@@ -2046,6 +2046,72 @@ WHERE
 			},
 		},
 	},
+	{
+		name: "joining on decimals",
+		setup: [][]string{
+			{
+				"create table t1(c0 decimal(6,3))",
+				"create table t2(c0 decimal(5,2))",
+				"insert into t1 values (10.000),(20.505),(30.000)",
+				"insert into t2 values (20.5), (25.0), (30.0)",
+			},
+		},
+		tests: []JoinOpTests{
+			{
+				Query:    "select * from t1 join t2 on t1.c0 = t2.c0",
+				Expected: []sql.Row{{"30.000", "30.00"}},
+			},
+		},
+	},
+	{
+		// https://github.com/dolthub/dolt/issues/9777
+		name: "join with % condition",
+		setup: [][]string{
+			{
+				"create table t1(c0 int)",
+				"create table t2(c0 int)",
+				"insert into t1 values (1),(2)",
+				"insert into t2 values (3),(4)",
+			},
+		},
+		tests: []JoinOpTests{
+			{
+				Query: "select * from t1 join t2 on (t1.c0 % 2) = (t2.c0 % 2)",
+				Expected: []sql.Row{
+					{1, 3},
+					{2, 4},
+				},
+			},
+		},
+	},
+	{
+		// https://github.com/dolthub/dolt/issues/9782
+		name: "joining with subquery on empty table",
+		setup: [][]string{
+			{
+				"CREATE TABLE t(c INT);",
+				"INSERT INTO t VALUES (1);",
+			},
+		},
+		tests: []JoinOpTests{
+			{
+				Query:    "SELECT t.c FROM t LEFT JOIN (SELECT t.c FROM t WHERE FALSE) AS subq ON TRUE;",
+				Expected: []sql.Row{{1}},
+			},
+			{
+				Query:    "SELECT t.c FROM t NATURAL LEFT JOIN (SELECT t.c FROM t WHERE FALSE) AS subq;",
+				Expected: []sql.Row{{1}},
+			},
+			{
+				Query:    "SELECT t.c FROM (SELECT t.c FROM t WHERE FALSE) AS subq RIGHT JOIN t ON TRUE;",
+				Expected: []sql.Row{{1}},
+			},
+			{
+				Query:    "SELECT t.c FROM (SELECT t.c FROM t WHERE FALSE) AS subq NATURAL RIGHT JOIN t;",
+				Expected: []sql.Row{{1}},
+			},
+		},
+	},
 }
 
 var rangeJoinOpTests = []JoinOpTests{

enginetest/memory_engine_test.go

@@ -922,6 +922,10 @@ func TestVectorFunctions(t *testing.T) {
 	enginetest.TestVectorFunctions(t, enginetest.NewDefaultMemoryHarness())
 }
 
+func TestVectorType(t *testing.T) {
+	enginetest.TestVectorType(t, enginetest.NewDefaultMemoryHarness())
+}
+
 func TestIndexPrefix(t *testing.T) {
 	enginetest.TestIndexPrefix(t, enginetest.NewDefaultMemoryHarness())
 }
@@ -997,9 +1001,6 @@ func TestDatabaseCollationWire(t *testing.T) {
 }
 
 func TestTypesOverWire(t *testing.T) {
-	if _, ok := os.LookupEnv("CI_TEST"); !ok {
-		t.Skip("Skipping test that requires CI_TEST=true")
-	}
 	harness := enginetest.NewDefaultMemoryHarness()
 	enginetest.TestTypesOverWire(t, harness, harness.SessionBuilder())
 }

enginetest/queries/check_scripts.go

@@ -540,16 +540,36 @@ var ChecksOnUpdateScriptTests = []ScriptTest{
 		},
 		Assertions: []ScriptTestAssertion{
 			{
-				Query:    "UPDATE sales JOIN (SELECT year_built FROM sales) AS t ON sales.year_built = t.year_built SET sales.year_built = 1901;",
-				Expected: []sql.Row{{types.OkResult{1, 0, plan.UpdateInfo{1, 1, 0}}}},
+				Query: "UPDATE sales JOIN (SELECT year_built FROM sales) AS t ON sales.year_built = t.year_built SET sales.year_built = 1901;",
+				Expected: []sql.Row{
+					{
+						types.OkResult{
+							RowsAffected: 1,
+							Info: plan.UpdateInfo{
+								Matched: 1,
+								Updated: 1,
+							},
+						},
+					},
+				},
 			},
 			{
 				Query:    "select * from sales;",
 				Expected: []sql.Row{{1901}},
 			},
 			{
-				Query:    "UPDATE sales as s1 JOIN (SELECT year_built FROM sales) AS t SET S1.year_built = 1902;",
-				Expected: []sql.Row{{types.OkResult{1, 0, plan.UpdateInfo{1, 1, 0}}}},
+				Query: "UPDATE sales as s1 JOIN (SELECT year_built FROM sales) AS t SET S1.year_built = 1902;",
+				Expected: []sql.Row{
+					{
+						types.OkResult{
+							RowsAffected: 1,
+							Info: plan.UpdateInfo{
+								Matched: 1,
+								Updated: 1,
+							},
+						},
+					},
+				},
 			},
 			{
 				Query:    "select * from sales;",
@@ -599,8 +619,18 @@ var ChecksOnUpdateScriptTests = []ScriptTest{
 				Expected: []sql.Row{{"WA"}},
 			},
 			{
-				Query:    "UPDATE sales JOIN locations SET sales.year_built = 2000, locations.state = 'CA';",
-				Expected: []sql.Row{{types.OkResult{2, 0, plan.UpdateInfo{2, 2, 0}}}},
+				Query: "UPDATE sales JOIN locations SET sales.year_built = 2000, locations.state = 'CA';",
+				Expected: []sql.Row{
+					{
+						types.OkResult{
+							RowsAffected: 2,
+							Info: plan.UpdateInfo{
+								Matched: 2,
+								Updated: 2,
+							},
+						},
+					},
+				},
 			},
 			{
 				Query:    "select * from sales;",

enginetest/queries/column_alias_queries.go

@@ -269,11 +269,17 @@ var ColumnAliasQueries = []ScriptTest{
 		Assertions: []ScriptTestAssertion{
 			{
 				// GMS returns "expression 'dt.two' doesn't appear in the group by expressions", but MySQL will execute
-				// this query.
+				// this query. https://github.com/dolthub/dolt/issues/9717
 				Query: "select 1 as a, one + 1 as mod1, dt.* from mytable as t1, (select 1, 2 from mytable) as dt (one, two) where dt.one > 0 group by one;",
 				// column names:  a, mod1, one, two
 				Expected: []sql.Row{{1, 2, 1, 2}},
 			},
+			{
+				// MySQL will execute this query but group by validation isn't able to recognize that exprAlias is a
+				// literal https://github.com/dolthub/dolt/issues/9717
+				Query:    "select 1 as exprAlias, 2, 3, (select exprAlias + count(*) from one_pk_three_idx a cross join one_pk_three_idx b);",
+				Expected: []sql.Row{{1, 2, 3, 65}},
+			},
 		},
 	},
 }