fix ExistsExpr buildScalar to use subquery impl

Author: elianddb

enginetest/memory_engine_test.go

@@ -200,37 +200,23 @@ func TestSingleQueryPrepared(t *testing.T) {
 
 // Convenience test for debugging a single query. Unskip and set to the desired query.
 func TestSingleScript(t *testing.T) {
-	//t.Skip()
+	t.Skip()
 	var scripts = []queries.ScriptTest{
 		{
-			// https://github.com/dolthub/dolt/issues/10113
-			Name: "DELETE with NOT EXISTS subquery",
-			SetUpScript: []string{
-				`CREATE TABLE IF NOT EXISTS student (
-					id BIGINT AUTO_INCREMENT,
-					name VARCHAR(50) NOT NULL,
-					PRIMARY KEY (id)
-				);`,
-				`CREATE TABLE IF NOT EXISTS student_hobby (
-					id BIGINT AUTO_INCREMENT,
-					student_id BIGINT NOT NULL,
-					hobby VARCHAR(50) NOT NULL,
-					PRIMARY KEY (id)
-				);`,
-				"INSERT INTO student (id, name) VALUES (1, 'test1');",
-				"INSERT INTO student (id, name) VALUES (2, 'test2');",
-				"INSERT INTO student_hobby (id, student_id, hobby) VALUES (1, 1, 'test1');",
-				"INSERT INTO student_hobby (id, student_id, hobby) VALUES (2, 2, 'test2');",
-				"INSERT INTO student_hobby (id, student_id, hobby) VALUES (3, 100, 'test3');",
-				"INSERT INTO student_hobby (id, student_id, hobby) VALUES (4, 100, 'test3');",
-			},
+			Name:        "AS OF propagates to nested CALLs",
+			SetUpScript: []string{},
 			Assertions: []queries.ScriptTestAssertion{
 				{
-					Query: "delete from student_hobby where not exists (select 1 from student where student.id = student_hobby.student_id);",
+					Query: "create procedure create_proc() create table t (i int primary key, j int);",
+					Expected: []sql.Row{
+						{types.NewOkResult(0)},
+					},
 				},
 				{
-					Query:    "SELECT * FROM student_hobby ORDER BY id;",
-					Expected: []sql.Row{{1, 1, "test1"}, {2, 2, "test2"}},
+					Query: "call create_proc()",
+					Expected: []sql.Row{
+						{types.NewOkResult(0)},
+					},
 				},
 			},
 		},

enginetest/queries/script_queries.go

@@ -122,6 +122,38 @@ type ScriptTestAssertion struct {
 // Unlike other engine tests, ScriptTests must be self-contained. No other tables are created outside the definition of
 // the tests.
 var ScriptTests = []ScriptTest{
+	{
+		// https://github.com/dolthub/dolt/issues/10113
+		Name: "DELETE with NOT EXISTS subquery",
+		SetUpScript: []string{
+			`CREATE TABLE IF NOT EXISTS student (
+				id BIGINT AUTO_INCREMENT,
+				name VARCHAR(50) NOT NULL,
+				PRIMARY KEY (id)
+			);`,
+			`CREATE TABLE IF NOT EXISTS student_hobby (
+				id BIGINT AUTO_INCREMENT,
+				student_id BIGINT NOT NULL,
+				hobby VARCHAR(50) NOT NULL,
+				PRIMARY KEY (id)
+			);`,
+			"INSERT INTO student (id, name) VALUES (1, 'test1');",
+			"INSERT INTO student (id, name) VALUES (2, 'test2');",
+			"INSERT INTO student_hobby (id, student_id, hobby) VALUES (1, 1, 'test1');",
+			"INSERT INTO student_hobby (id, student_id, hobby) VALUES (2, 2, 'test2');",
+			"INSERT INTO student_hobby (id, student_id, hobby) VALUES (3, 100, 'test3');",
+			"INSERT INTO student_hobby (id, student_id, hobby) VALUES (4, 100, 'test3');",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: "delete from student_hobby where not exists (select 1 from student where student.id = student_hobby.student_id);",
+			},
+			{
+				Query:    "SELECT * FROM student_hobby ORDER BY id;",
+				Expected: []sql.Row{{1, 1, "test1"}, {2, 2, "test2"}},
+			},
+		},
+	},
 	{
 		// https://github.com/dolthub/dolt/issues/9987
 		Name: "GROUP BY nil pointer dereference in Dispose when Next() never called",

sql/analyzer/node_batches.go

@@ -107,10 +107,6 @@ func getBatchesForNode(node sql.Node) ([]*Batch, bool) {
 							Id:    validateReadOnlyTransactionId,
 							Apply: validateReadOnlyTransaction,
 						},
-						{
-							Id:    resolveSubqueriesId,
-							Apply: resolveSubqueries,
-						},
 						{
 							Id:    processTruncateId,
 							Apply: processTruncate,

sql/planbuilder/dml.go

@@ -447,6 +447,13 @@ func (b *Builder) buildDelete(inScope *scope, d *ast.Delete) (outScope *scope) {
 	b.qFlags.Set(sql.QFlagDelete)
 
 	outScope = b.buildFrom(inScope, d.TableExprs)
+
+	// Capture the table node for simple DELETEs before buildWhere wraps it
+	var targets []sql.Node
+	if len(d.Targets) == 0 {
+		targets = []sql.Node{outScope.node}
+	}
+
 	b.buildWhere(outScope, d.Where)
 	orderByScope := b.analyzeOrderBy(outScope, outScope, d.OrderBy)
 	b.buildOrderBy(outScope, orderByScope)
@@ -459,7 +466,6 @@ func (b *Builder) buildDelete(inScope *scope, d *ast.Delete) (outScope *scope) {
 		outScope.node = plan.NewLimit(limit, outScope.node)
 	}
 
-	var targets []sql.Node
 	if len(d.Targets) > 0 {
 		targets = make([]sql.Node, len(d.Targets))
 		for i, tableName := range d.Targets {

sql/planbuilder/scalar.go

@@ -372,14 +372,12 @@ func (b *Builder) buildScalar(inScope *scope, e ast.Expr) (ex sql.Expression) {
 			return values
 		}
 	case *ast.ExistsExpr:
-		sqScope := inScope.push()
-		sqScope.initSubquery()
-		selScope := b.buildSelectStmt(sqScope, v.Subquery.Select)
-		selectString := ast.String(v.Subquery.Select)
-		sq := plan.NewSubquery(selScope.node, selectString)
-		sq = sq.WithCorrelated(sqScope.correlated())
-		b.qFlags.Set(sql.QFlagScalarSubquery)
-		return plan.NewExistsSubquery(sq)
+		sq := b.buildScalar(inScope, v.Subquery)
+		sqPlan, ok := sq.(*plan.Subquery)
+		if !ok {
+			b.handleErr(fmt.Errorf("expected Subquery from ExistsExpr, got %T", sq))
+		}
+		return plan.NewExistsSubquery(sqPlan)
 	case *ast.TimestampFuncExpr:
 		var (
 			unit  sql.Expression