Partially reorder indexing rules; use unique ids rather than execution ids

enginetest/evaluation.go

@@ -308,7 +308,8 @@ func TestQueryWithContext(t *testing.T, ctx *sql.Context, e QueryEngine, harness
 		checkResults(t, expected, expectedCols, sch, rows, q)
 	}
 
-	require.Equal(0, ctx.Memory.NumCaches())
+	require.Equal(
+		0, ctx.Memory.NumCaches())
 	validateEngine(t, ctx, harness, e)
 }
 

enginetest/join_planning_tests.go

@@ -651,12 +651,12 @@ FROM xy
 			},
 			{
 				q:     "select * from xy where x in (select 1 where 1 in (select 1 where 1 in (select 1 where x != 2)) and x = 1);",
-				types: []plan.JoinType{plan.JoinTypeHash, plan.JoinTypeHash, plan.JoinTypeHash},
+				types: []plan.JoinType{plan.JoinTypeSemi, plan.JoinTypeSemi, plan.JoinTypeHash},
 				exp:   []sql.Row{{1, 0}},
 			},
 			{
 				q:     "select * from xy where x in (select * from (select 1 where 1 in (select 1 where x != 2)) r where x = 1);",
-				types: []plan.JoinType{plan.JoinTypeHash, plan.JoinTypeHash},
+				types: []plan.JoinType{plan.JoinTypeSemi, plan.JoinTypeHash},
 				exp:   []sql.Row{{1, 0}},
 			},
 			{

enginetest/memory_engine_test.go

@@ -134,8 +134,8 @@ func TestSingleQuery(t *testing.T) {
 	t.Skip()
 	var test queries.QueryTest
 	test = queries.QueryTest{
-		Query:    `SELECT DISTINCT val FROM (values row(1), row(1.00), row(2), row(2)) a (val);`,
-		Expected: []sql.Row{{1.0}, {2.0}},
+		Query:    `select count((select * from (select pk from one_pk limit 1) as sq)) from one_pk;`,
+		Expected: []sql.Row{{0}, {1}},
 	}
 
 	fmt.Sprintf("%v", test)

optgen/cmd/source/memo.yaml

@@ -37,7 +37,7 @@ exprs:
 - name: "LateralJoin"
   join: true
 - name: "TableScan"
-  sourceType: "plan.TableNode"
+  sourceType: "sql.TableNode"
 - name: "Values"
   sourceType: "*plan.ValueDerivedTable"
 - name: "TableAlias"
@@ -52,6 +52,8 @@ exprs:
   sourceType: "sql.NameableNode"
 - name: "TableFunc"
   sourceType: "sql.TableFunction"
+- name: "JSONTable"
+  sourceType: "*plan.JSONTable"
 - name: "EmptyTable"
   sourceType: "*plan.EmptyTable"
 - name: "Project"

sql/analyzer/analyzer.go

@@ -399,8 +399,7 @@ func DefaultRuleSelector(id RuleId) bool {
 func NewProcRuleSelector(sel RuleSelector) RuleSelector {
 	return func(id RuleId) bool {
 		switch id {
-		case optimizeJoinsId,
-			pruneTablesId,
+		case pruneTablesId,
 			transformJoinApplyId,
 
 			// once after default rules should only be run once

sql/analyzer/apply_join.go

@@ -17,8 +17,6 @@ package analyzer
 import (
 	"fmt"
 
-	"github.com/dolthub/go-mysql-server/sql/fixidx"
-
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/plan"
@@ -65,7 +63,6 @@ func transformJoinApply(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.S
 				return n, transform.SameTree, nil
 			}
 
-			subScope := scope.NewScopeFromSubqueryExpression(n)
 			var matches []applyJoin
 			var newFilters []sql.Expression
 
@@ -106,13 +103,7 @@ func transformJoinApply(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.S
 					max1 = true
 				default:
 				}
-				if sq != nil {
-					sq.Query, _, err = fixidx.FixFieldIndexesForNode(ctx, a.LogFn(), scope.NewScopeFromSubqueryExpression(n), sq.Query)
-					if err != nil {
-						return nil, transform.SameTree, err
-					}
-				}
-				if sq != nil && nodeIsCacheable(sq.Query, len(subScope.Schema())) {
+				if sq != nil && sq.CanCacheResults() {
 					matches = append(matches, applyJoin{l: l, r: sq, op: op, filter: joinF, max1: max1})
 				} else {
 					newFilters = append(newFilters, e)
@@ -147,12 +138,8 @@ func transformJoinApply(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.S
 					rightF = tup
 				}
 
-				q, _, err := fixidx.FixFieldIndexesForNode(ctx, a.LogFn(), scope, subq.Query)
-				if err != nil {
-					return nil, transform.SameTree, err
-				}
+				var newSubq sql.Node = plan.NewSubqueryAlias(name, subq.QueryString, subq.Query)
 
-				var newSubq sql.Node = plan.NewSubqueryAlias(name, subq.QueryString, q)
 				newSubq, err = simplifySubqExpr(newSubq)
 				if err != nil {
 					return nil, transform.SameTree, err
@@ -161,15 +148,10 @@ func transformJoinApply(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.S
 					newSubq = plan.NewMax1Row(newSubq, name)
 				}
 
-				condSch := append(ret.Schema(), newSubq.Schema()...)
 				filter, err := m.filter.WithChildren(m.l, rightF)
 				if err != nil {
 					return n, transform.SameTree, err
 				}
-				filter, _, err = fixidx.FixFieldIndexes(scope, a.LogFn(), condSch, filter)
-				if err != nil {
-					return n, transform.SameTree, err
-				}
 				var comment string
 				if c, ok := ret.(sql.CommentedNode); ok {
 					comment = c.Comment()

sql/analyzer/experimental_rules.go

@@ -16,9 +16,16 @@ import (
 // to compensate for the new name resolution expression overloading GetField
 // indexes.
 func fixupAuxiliaryExprs(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scope, sel RuleSelector) (sql.Node, transform.TreeIdentity, error) {
+	return fixupAuxiliaryExprsHelper(ctx, a, n, scope, false)
+}
+
+func fixupAuxiliaryExprsHelper(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scope, trigger bool) (sql.Node, transform.TreeIdentity, error) {
 	return transform.NodeWithOpaque(n, func(n sql.Node) (sql.Node, transform.TreeIdentity, error) {
 		switch n := n.(type) {
 		default:
+			if _, ok := n.(*plan.Set); ok && trigger {
+				return n, transform.SameTree, nil
+			}
 			ret, same1, err := fixidx.FixFieldIndexesForExpressions(ctx, a.LogFn(), n, scope)
 			if err != nil {
 				return n, transform.SameTree, err
@@ -27,11 +34,12 @@ func fixupAuxiliaryExprs(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.
 			ret, same2, err := transform.OneNodeExpressions(ret, func(e sql.Expression) (sql.Expression, transform.TreeIdentity, error) {
 				switch e := e.(type) {
 				case *plan.Subquery:
-					newQ, same, err := fixupAuxiliaryExprs(ctx, a, e.Query, scope.NewScopeFromSubqueryExpression(ret), sel)
+					newQ, same, err := fixupAuxiliaryExprsHelper(ctx, a, e.Query, scope.NewScopeFromSubqueryExpression(ret), trigger)
 					if same || err != nil {
 						return e, transform.SameTree, err
 					}
-					return plan.NewSubquery(newQ, e.QueryString), transform.NewTree, nil
+					e.WithQuery(newQ)
+					return e.WithQuery(newQ), transform.NewTree, nil
 				default:
 				}
 				return e, transform.SameTree, nil
@@ -40,6 +48,10 @@ func fixupAuxiliaryExprs(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.
 				return n, transform.SameTree, nil
 			}
 			return ret, transform.NewTree, nil
+		case *plan.JoinNode, *plan.Filter:
+			return n, transform.SameTree, nil
+		case *plan.IndexedTableAccess:
+			return n, transform.SameTree, nil
 		case *plan.Fetch:
 			return n, transform.SameTree, nil
 		case *plan.JSONTable:
@@ -94,7 +106,7 @@ func fixupAuxiliaryExprs(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.
 				return n, transform.SameTree, err
 			}
 			ins := newN.(*plan.InsertInto)
-			newSource, same2, err := fixupAuxiliaryExprs(ctx, a, ins.Source, scope, sel)
+			newSource, same2, err := fixupAuxiliaryExprsHelper(ctx, a, ins.Source, scope, trigger)
 			if err != nil || (same1 && same2) {
 				return n, transform.SameTree, err
 			}
@@ -145,17 +157,6 @@ func fixupAuxiliaryExprs(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.
 	})
 }
 
-func hoistSort(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scope, sel RuleSelector) (sql.Node, transform.TreeIdentity, error) {
-	return transform.Node(n, func(n sql.Node) (sql.Node, transform.TreeIdentity, error) {
-		// match [node] -> Sort
-		// move sort above [node]
-		// exclusion conditions:
-		// - parent does not have input cols for sort
-		// -
-		return n, transform.SameTree, nil
-	})
-}
-
 type aliasScope struct {
 	aliases map[string]sql.Expression
 	parent  *aliasScope

sql/analyzer/generate_index_scans.go

@@ -147,18 +147,6 @@ func convertFiltersToIndexedAccess(
 			handled = append(handled, handledF...)
 			return ret, transform.NewTree, nil
 		case *plan.JSONTable:
-			switch j := c.Parent.(type) {
-			case *plan.JoinNode:
-				newExprs, same, err := fixidx.FixFieldIndexesOnExpressions(scope, a.LogFn(), j.Left().Schema(), n.Expressions()...)
-				if same || err != nil {
-					return n, transform.SameTree, err
-				}
-				newJt, err := n.WithExpressions(newExprs...)
-				if err != nil {
-					return n, transform.SameTree, err
-				}
-				return newJt, transform.NewTree, nil
-			}
 			return n, transform.SameTree, nil
 		default:
 			return pushdownFixIndices(ctx, a, n, scope)