Propagate context parameter.

nicktobey · nicktobey · commit a92ff64934f5 · 2025-03-16T22:37:29.000-07:00
diff --git a/enginetest/mysqlshim/table.go b/enginetest/mysqlshim/table.go
@@ -47,7 +47,7 @@ var _ sql.CheckTable = Table{}
 var _ sql.StatisticsTable = Table{}
 var _ sql.PrimaryKeyAlterableTable = Table{}
 
-func (t Table) IndexedAccess(sql.IndexLookup) sql.IndexedTable {
+func (t Table) IndexedAccess(*sql.Context, sql.IndexLookup) sql.IndexedTable {
 	panic("not implemented")
 }
 
diff --git a/enginetest/mysqlshim/table_editor.go b/enginetest/mysqlshim/table_editor.go
@@ -29,7 +29,7 @@ type tableEditor struct {
 	sch   sql.Schema
 }
 
-func (t *tableEditor) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTable {
+func (t *tableEditor) IndexedAccess(ctx *sql.Context, lookup sql.IndexLookup) sql.IndexedTable {
 	//TODO implement me
 	panic("implement me")
 }
diff --git a/memory/required_lookup_table.go b/memory/required_lookup_table.go
@@ -73,7 +73,7 @@ func (s RequiredLookupTable) Database() sql.Database {
 	return s.db
 }
 
-func (s RequiredLookupTable) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTable {
+func (s RequiredLookupTable) IndexedAccess(ctx *sql.Context, lookup sql.IndexLookup) sql.IndexedTable {
 	return RequiredLookupTable{indexOk: true, IntSequenceTable: s.IntSequenceTable}
 }
 
diff --git a/memory/sequence_table.go b/memory/sequence_table.go
@@ -212,7 +212,7 @@ func (s IntSequenceTable) LookupPartitions(context *sql.Context, lookup sql.Inde
 	return sql.PartitionsToPartitionIter(&sequencePartition{min: min.(int64), max: max.(int64)}), nil
 }
 
-func (s IntSequenceTable) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTable {
+func (s IntSequenceTable) IndexedAccess(ctx *sql.Context, lookup sql.IndexLookup) sql.IndexedTable {
 	return s
 }
 
diff --git a/memory/table.go b/memory/table.go
@@ -1734,7 +1734,7 @@ func (t *IndexedTable) PartitionRows(ctx *sql.Context, partition sql.Partition)
 	return iter, nil
 }
 
-func (t *Table) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTable {
+func (t *Table) IndexedAccess(ctx *sql.Context, lookup sql.IndexLookup) sql.IndexedTable {
 	return &IndexedTable{Table: t, Lookup: lookup}
 }
 
diff --git a/memory/table_data.go b/memory/table_data.go
@@ -16,6 +16,7 @@ package memory
 
 import (
 	"fmt"
+	"github.com/dolthub/go-mysql-server/sql/types"
 	"sort"
 	"strconv"
 	"strings"
@@ -114,7 +115,7 @@ func (td TableData) copy() *TableData {
 
 // partition returns the partition for the row given. Uses the primary key columns if they exist, or all columns
 // otherwise
-func (td TableData) partition(row sql.Row) (int, error) {
+func (td TableData) partition(ctx *sql.Context, row sql.Row) (int, error) {
 	var keyColumns []int
 	if len(td.schema.PkOrdinals) > 0 {
 		keyColumns = td.schema.PkOrdinals
@@ -138,7 +139,7 @@ func (td TableData) partition(row sql.Row) (int, error) {
 
 		t, isStringType := td.schema.Schema[keyColumns[i]].Type.(sql.StringType)
 		if isStringType && v != nil {
-			v, _, err = t.Convert(v)
+			v, err = types.ConvertToString(v, t, nil)
 			if err == nil {
 				err = t.Collation().WriteWeightString(hash, v.(string))
 			}
diff --git a/memory/table_editor.go b/memory/table_editor.go
@@ -100,7 +100,7 @@ func (t *tableEditor) Close(ctx *sql.Context) error {
 
 	// On the normal INSERT / UPDATE / DELETE path this happens at StatementComplete time, but for table rewrites it
 	// only happens at Close
-	err := t.ea.ApplyEdits(t.editedTable)
+	err := t.ea.ApplyEdits(ctx, t.editedTable)
 	if err != nil {
 		return err
 	}
@@ -127,7 +127,7 @@ func (t *tableEditor) DiscardChanges(ctx *sql.Context, errorEncountered error) e
 }
 
 func (t *tableEditor) StatementComplete(ctx *sql.Context) error {
-	err := t.ea.ApplyEdits(t.editedTable)
+	err := t.ea.ApplyEdits(ctx, t.editedTable)
 	if err != nil {
 		return nil
 	}
@@ -285,10 +285,10 @@ func (t *tableEditor) PreciseMatch() bool {
 	return true
 }
 
-func (t *tableEditor) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTable {
+func (t *tableEditor) IndexedAccess(ctx *sql.Context, lookup sql.IndexLookup) sql.IndexedTable {
 	// Before we return an indexed access for this table, we need to apply all the edits to the table
 	// TODO: optimize this, should create some struct that encloses the tableEditor and filters based on the lookup
-	err := t.ea.ApplyEdits(t.editedTable)
+	err := t.ea.ApplyEdits(ctx, t.editedTable)
 	if err != nil {
 		return nil
 	}
@@ -378,7 +378,7 @@ type tableEditAccumulator interface {
 	Get(value sql.Row) (sql.Row, bool, error)
 	// ApplyEdits updates the table provided with the inserts and deletes that have been added to the accumulator.
 	// Does not clear the accumulator.
-	ApplyEdits(table *Table) error
+	ApplyEdits(ctx *sql.Context, table *Table) error
 	// GetByCols returns the row in the table, or the pending edits, matching the ones given
 	GetByCols(value sql.Row, cols []int, prefixLengths []uint16) (sql.Row, bool, error)
 	// Clear wipes all of the stored inserts and deletes that may or may not have been applied.
@@ -487,7 +487,7 @@ func (pke *pkTableEditAccumulator) GetByCols(value sql.Row, cols []int, prefixLe
 }
 
 // ApplyEdits implements the tableEditAccumulator interface.
-func (pke *pkTableEditAccumulator) ApplyEdits(table *Table) error {
+func (pke *pkTableEditAccumulator) ApplyEdits(ctx *sql.Context, table *Table) error {
 
 	if err := pke.deletes.Foreach(func(key string, val sql.Row) error {
 		return pke.deleteHelper(pke.tableData, val)
@@ -497,7 +497,7 @@ func (pke *pkTableEditAccumulator) ApplyEdits(table *Table) error {
 	}
 
 	if err := pke.adds.Foreach(func(key string, val sql.Row) error {
-		return pke.insertHelper(pke.tableData, val)
+		return pke.insertHelper(ctx, pke.tableData, val)
 
 	}); err != nil {
 		return err
@@ -600,8 +600,8 @@ func deleteRowFromIndexes(table *TableData, partKey string, rowIdx int) {
 }
 
 // insertHelper inserts the given row into the given tableData.
-func (pke *pkTableEditAccumulator) insertHelper(table *TableData, row sql.Row) error {
-	partIdx, err := table.partition(row)
+func (pke *pkTableEditAccumulator) insertHelper(ctx *sql.Context, table *TableData, row sql.Row) error {
+	partIdx, err := table.partition(ctx, row)
 	if err != nil {
 		return err
 	}
@@ -748,7 +748,7 @@ func (k *keylessTableEditAccumulator) GetByCols(value sql.Row, cols []int, prefi
 }
 
 // ApplyEdits implements the tableEditAccumulator interface.
-func (k *keylessTableEditAccumulator) ApplyEdits(table *Table) error {
+func (k *keylessTableEditAccumulator) ApplyEdits(ctx *sql.Context, table *Table) error {
 	for _, val := range k.deletes {
 		err := k.deleteHelper(k.tableData, val)
 		if err != nil {
@@ -757,7 +757,7 @@ func (k *keylessTableEditAccumulator) ApplyEdits(table *Table) error {
 	}
 
 	for _, val := range k.adds {
-		err := k.insertHelper(k.tableData, val)
+		err := k.insertHelper(ctx, k.tableData, val)
 		if err != nil {
 			return err
 		}
@@ -814,8 +814,8 @@ func (k *keylessTableEditAccumulator) deleteHelper(table *TableData, row sql.Row
 }
 
 // insertHelper inserts into a keyless tableData.
-func (k *keylessTableEditAccumulator) insertHelper(table *TableData, row sql.Row) error {
-	partIdx, err := table.partition(row)
+func (k *keylessTableEditAccumulator) insertHelper(ctx *sql.Context, table *TableData, row sql.Row) error {
+	partIdx, err := table.partition(ctx, row)
 	if err != nil {
 		return err
 	}
@@ -866,8 +866,9 @@ func verifyRowTypes(row sql.Row, schema sql.Schema) error {
 			if wrapper, isWrapper := rowVal.(sql.AnyWrapper); isWrapper {
 				method, _ := reflect.TypeOf(wrapper).MethodByName("Unwrap")
 				valType = method.Type.Out(0)
+			} else {
+				valType = reflect.TypeOf(rowVal)
 			}
-			valType = reflect.TypeOf(rowVal)
 			expectedType := col.Type.ValueType()
 			if valType != expectedType && rowVal != nil && !valType.AssignableTo(expectedType) {
 				return fmt.Errorf("Actual Value Type: %s, Expected Value Type: %s", valType.String(), expectedType.String())
diff --git a/sql/analyzer/apply_indexes_from_outer_scope.go b/sql/analyzer/apply_indexes_from_outer_scope.go
@@ -105,7 +105,7 @@ func pushdownIndexToTable(ctx *sql.Context, a *Analyzer, tableNode sql.NameableN
 			}
 			a.Log("table %q transformed with pushdown of index", tableNode.Name())
 			lb := plan.NewLookupBuilder(index, keyExpr, nullmask)
-			ret, err := plan.NewIndexedAccessForTableNode(nn, lb)
+			ret, err := plan.NewIndexedAccessForTableNode(ctx, nn, lb)
 			if err != nil {
 				return nil, transform.SameTree, err
 			}
diff --git a/sql/analyzer/costed_index_scan.go b/sql/analyzer/costed_index_scan.go
@@ -76,7 +76,7 @@ func costedIndexScans(ctx *sql.Context, a *Analyzer, n sql.Node, qFlags *sql.Que
 				return n, transform.SameTree, err
 			}
 			if ok {
-				return indexSearchableLookup(n, rt, lookup, filter.Expression, newFilter, lookupFds, qFlags)
+				return indexSearchableLookup(ctx, n, rt, lookup, filter.Expression, newFilter, lookupFds, qFlags)
 			} else if is.SkipIndexCosting() {
 				return n, transform.SameTree, nil
 			}
@@ -88,13 +88,13 @@ func costedIndexScans(ctx *sql.Context, a *Analyzer, n sql.Node, qFlags *sql.Que
 	})
 }
 
-func indexSearchableLookup(n sql.Node, rt sql.TableNode, lookup sql.IndexLookup, oldFilter, newFilter sql.Expression, fds *sql.FuncDepSet, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
+func indexSearchableLookup(ctx *sql.Context, n sql.Node, rt sql.TableNode, lookup sql.IndexLookup, oldFilter, newFilter sql.Expression, fds *sql.FuncDepSet, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
 	if lookup.IsEmpty() {
 		return n, transform.SameTree, nil
 	}
 	var ret sql.Node
 	var err error
-	ret, err = plan.NewStaticIndexedAccessForTableNode(rt, lookup)
+	ret, err = plan.NewStaticIndexedAccessForTableNode(ctx, rt, lookup)
 	if err != nil {
 		return n, transform.SameTree, err
 	}
@@ -290,7 +290,7 @@ func getCostedIndexScan(ctx *sql.Context, statsProv sql.StatsProvider, rt sql.Ta
 			Table:        rt,
 		})
 	} else {
-		ret, err = plan.NewStaticIndexedAccessForTableNode(rt, lookup)
+		ret, err = plan.NewStaticIndexedAccessForTableNode(ctx, rt, lookup)
 		if err != nil {
 			return nil, nil, nil, err
 		}
@@ -326,7 +326,7 @@ func getCostedIndexScan(ctx *sql.Context, statsProv sql.StatsProvider, rt sql.Ta
 	return ret, bestStat, retFilters, nil
 }
 
-func addIndexScans(m *memo.Memo) error {
+func addIndexScans(ctx *sql.Context, m *memo.Memo) error {
 	return memo.DfsRel(m.Root(), func(e memo.RelExpr) error {
 		filter, ok := e.(*memo.Filter)
 		if !ok {
@@ -359,7 +359,7 @@ func addIndexScans(m *memo.Memo) error {
 				if lookup.IsEmpty() {
 					return nil
 				}
-				ret, err := plan.NewStaticIndexedAccessForTableNode(rt, lookup)
+				ret, err := plan.NewStaticIndexedAccessForTableNode(ctx, rt, lookup)
 				if err != nil {
 					m.HandleErr(err)
 				}
diff --git a/sql/analyzer/costed_index_scan_test.go b/sql/analyzer/costed_index_scan_test.go
@@ -921,7 +921,7 @@ func (i *indexSearchableTable) LookupForExpressions(ctx *sql.Context, exprs ...s
 	return sql.IndexLookup{}, nil, nil, false, nil
 }
 
-func (i *indexSearchableTable) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTable {
+func (i *indexSearchableTable) IndexedAccess(ctx *sql.Context, lookup sql.IndexLookup) sql.IndexedTable {
 	return i
 }
 
diff --git a/sql/analyzer/indexed_joins.go b/sql/analyzer/indexed_joins.go
@@ -158,7 +158,7 @@ func replanJoin(ctx *sql.Context, n *plan.JoinNode, a *Analyzer, scope *plan.Sco
 
 	qFlags.Set(sql.QFlagInnerJoin)
 
-	err = addIndexScans(m)
+	err = addIndexScans(ctx, m)
 	if err != nil {
 		return nil, err
 	}
@@ -170,12 +170,12 @@ func replanJoin(ctx *sql.Context, n *plan.JoinNode, a *Analyzer, scope *plan.Sco
 	if err != nil {
 		return nil, err
 	}
-	err = addRightSemiJoins(m)
+	err = addRightSemiJoins(ctx, m)
 	if err != nil {
 		return nil, err
 	}
 
-	err = addLookupJoins(m)
+	err = addLookupJoins(ctx, m)
 	if err != nil {
 		return nil, err
 	}
@@ -226,7 +226,7 @@ func replanJoin(ctx *sql.Context, n *plan.JoinNode, a *Analyzer, scope *plan.Sco
 // ii) with an index that matches a prefix of the indexable relation's free
 // attributes in the join filter. Costing is responsible for choosing the most
 // appropriate execution plan among options added to an expression group.
-func addLookupJoins(m *memo.Memo) error {
+func addLookupJoins(ctx *sql.Context, m *memo.Memo) error {
 	return memo.DfsRel(m.Root(), func(e memo.RelExpr) error {
 		var right *memo.ExprGroup
 		var join *memo.JoinBase
@@ -284,7 +284,7 @@ func addLookupJoins(m *memo.Memo) error {
 				for _, idx := range indexes {
 					keyExprs, _, nullmask := keyExprsForIndex(tableId, idx.Cols(), append(filters, extraFilters...))
 					if keyExprs != nil {
-						ita, err := plan.NewIndexedAccessForTableNode(rt, plan.NewLookupBuilder(idx.SqlIdx(), keyExprs, nullmask))
+						ita, err := plan.NewIndexedAccessForTableNode(ctx, rt, plan.NewLookupBuilder(idx.SqlIdx(), keyExprs, nullmask))
 						if err != nil {
 							return err
 						}
@@ -310,7 +310,7 @@ func addLookupJoins(m *memo.Memo) error {
 			if keyExprs == nil {
 				continue
 			}
-			ita, err := plan.NewIndexedAccessForTableNode(rt, plan.NewLookupBuilder(idx.SqlIdx(), keyExprs, nullmask))
+			ita, err := plan.NewIndexedAccessForTableNode(ctx, rt, plan.NewLookupBuilder(idx.SqlIdx(), keyExprs, nullmask))
 			if err != nil {
 				return err
 			}
@@ -605,7 +605,7 @@ func convertAntiToLeftJoin(m *memo.Memo) error {
 
 // addRightSemiJoins allows for a reversed semiJoin operator when
 // the join attributes of the left side are provably unique.
-func addRightSemiJoins(m *memo.Memo) error {
+func addRightSemiJoins(ctx *sql.Context, m *memo.Memo) error {
 	return memo.DfsRel(m.Root(), func(e memo.RelExpr) error {
 		semi, ok := e.(*memo.SemiJoin)
 		if !ok {
@@ -665,7 +665,7 @@ func addRightSemiJoins(m *memo.Memo) error {
 				rGroup.RelProps.Distinct = memo.HashDistinctOp
 			}
 
-			ita, err := plan.NewIndexedAccessForTableNode(leftRt, plan.NewLookupBuilder(idx.SqlIdx(), keyExprs, nullmask))
+			ita, err := plan.NewIndexedAccessForTableNode(ctx, leftRt, plan.NewLookupBuilder(idx.SqlIdx(), keyExprs, nullmask))
 			if err != nil {
 				return err
 			}
@@ -1348,7 +1348,7 @@ func makeIndexScan(ctx *sql.Context, statsProv sql.StatsProvider, tab plan.Table
 		return nil, false, fmt.Errorf("expected sql.TableNode, found: %T", n)
 	}
 
-	ret, err := plan.NewStaticIndexedAccessForTableNode(tn, l)
+	ret, err := plan.NewStaticIndexedAccessForTableNode(ctx, tn, l)
 	if err != nil {
 		return nil, false, err
 	}
diff --git a/sql/analyzer/replace_order_by_distance.go b/sql/analyzer/replace_order_by_distance.go
@@ -114,7 +114,7 @@ func replaceIdxOrderByDistanceHelper(ctx *sql.Context, scope *plan.Scope, node s
 				Literal: literal,
 			},
 		}
-		nn, err := plan.NewStaticIndexedAccessForTableNode(n, lookup)
+		nn, err := plan.NewStaticIndexedAccessForTableNode(ctx, n, lookup)
 		if err != nil {
 			return nil, transform.SameTree, err
 		}
diff --git a/sql/analyzer/replace_sort.go b/sql/analyzer/replace_sort.go
@@ -72,7 +72,7 @@ func replaceIdxSortHelper(ctx *sql.Context, scope *plan.Scope, node sql.Node, so
 			lookup.IsSpatialLookup,
 			true,
 		)
-		nn, err := plan.NewStaticIndexedAccessForTableNode(n.TableNode, lookup)
+		nn, err := plan.NewStaticIndexedAccessForTableNode(ctx, n.TableNode, lookup)
 		if err != nil {
 			return nil, transform.SameTree, err
 		}
@@ -143,7 +143,7 @@ func replaceIdxSortHelper(ctx *sql.Context, scope *plan.Scope, node sql.Node, so
 		if !idx.CanSupport(lookup.Ranges.(sql.MySQLRangeCollection).ToRanges()...) {
 			return n, transform.SameTree, nil
 		}
-		nn, err := plan.NewStaticIndexedAccessForTableNode(n, lookup)
+		nn, err := plan.NewStaticIndexedAccessForTableNode(ctx, n, lookup)
 		if err != nil {
 			return nil, transform.SameTree, err
 		}
diff --git a/sql/analyzer/vector_index_test.go b/sql/analyzer/vector_index_test.go
@@ -110,7 +110,7 @@ func TestVectorIndex(t *testing.T) {
 		IsReverse:       false,
 	}
 
-	vectorIndexTable := vectorIndexTable{child.IndexedAccess(indexLookup)}
+	vectorIndexTable := vectorIndexTable{child.IndexedAccess(ctx, indexLookup)}
 
 	for _, testCase := range vectorIndexTestCases(t, db, vectorIndexTable) {
 		t.Run(testCase.name, func(t *testing.T) {
@@ -221,7 +221,7 @@ func (i vectorIndexTable) IndexWithPrefix(ctx *sql.Context, expressions []string
 	panic("implement me")
 }
 
-func (i vectorIndexTable) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTable {
+func (i vectorIndexTable) IndexedAccess(ctx *sql.Context, lookup sql.IndexLookup) sql.IndexedTable {
 	return i
 }
 
diff --git a/sql/expression/matchagainst.go b/sql/expression/matchagainst.go
@@ -316,7 +316,7 @@ func (expr *MatchAgainst) inNaturalLanguageMode(ctx *sql.Context, row sql.Row) (
 			}, Index: expr.docCountIndex}
 		}
 
-		editorData := expr.DocCountTable.IndexedAccess(lookup)
+		editorData := expr.DocCountTable.IndexedAccess(ctx, lookup)
 		if err != nil {
 			return 0, err
 		}
@@ -348,7 +348,7 @@ func (expr *MatchAgainst) inNaturalLanguageMode(ctx *sql.Context, row sql.Row) (
 				sql.ClosedRangeColumnExpr(wordStr, wordStr, expr.GlobalCountTable.Schema()[0].Type),
 			},
 		}, Index: expr.globalCountIndex}
-		editorData = expr.GlobalCountTable.IndexedAccess(lookup)
+		editorData = expr.GlobalCountTable.IndexedAccess(ctx, lookup)
 		if err != nil {
 			return 0, err
 		}
@@ -374,7 +374,7 @@ func (expr *MatchAgainst) inNaturalLanguageMode(ctx *sql.Context, row sql.Row) (
 				sql.ClosedRangeColumnExpr(hash, hash, expr.RowCountTable.Schema()[0].Type),
 			},
 		}, Index: expr.rowCountIndex}
-		editorData = expr.RowCountTable.IndexedAccess(lookup)
+		editorData = expr.RowCountTable.IndexedAccess(ctx, lookup)
 		if err != nil {
 			return 0, err
 		}
diff --git a/sql/fulltext/fulltext_editor.go b/sql/fulltext/fulltext_editor.go
diff --git a/sql/fulltext/multi_editor.go b/sql/fulltext/multi_editor.go
diff --git a/sql/memo/rel_props_test.go b/sql/memo/rel_props_test.go
diff --git a/sql/plan/foreign_key_editor.go b/sql/plan/foreign_key_editor.go
diff --git a/sql/plan/indexed_table_access.go b/sql/plan/indexed_table_access.go
diff --git a/sql/rowexec/fulltext_filter.go b/sql/rowexec/fulltext_filter.go
diff --git a/sql/tables.go b/sql/tables.go

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ var _ sql.CheckTable = Table{}`
`47`	`47`	`var _ sql.StatisticsTable = Table{}`
`48`	`48`	`var _ sql.PrimaryKeyAlterableTable = Table{}`
`49`	`49`
`50`		`-func (t Table) IndexedAccess(sql.IndexLookup) sql.IndexedTable {`
	`50`	`+func (t Table) IndexedAccess(*sql.Context, sql.IndexLookup) sql.IndexedTable {`
`51`	`51`	`panic("not implemented")`
`52`	`52`	`}`
`53`	`53`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ type tableEditor struct {`
`29`	`29`	`sch sql.Schema`
`30`	`30`	`}`
`31`	`31`
`32`		`-func (t *tableEditor) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTable {`
	`32`	`+func (t tableEditor) IndexedAccess(ctx sql.Context, lookup sql.IndexLookup) sql.IndexedTable {`
`33`	`33`	`//TODO implement me`
`34`	`34`	`panic("implement me")`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ func (s RequiredLookupTable) Database() sql.Database {`
`73`	`73`	`return s.db`
`74`	`74`	`}`
`75`	`75`
`76`		`-func (s RequiredLookupTable) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTable {`
	`76`	`+func (s RequiredLookupTable) IndexedAccess(ctx *sql.Context, lookup sql.IndexLookup) sql.IndexedTable {`
`77`	`77`	`return RequiredLookupTable{indexOk: true, IntSequenceTable: s.IntSequenceTable}`
`78`	`78`	`}`
`79`	`79`
Original file line number	Diff line number	Diff line change
`@@ -212,7 +212,7 @@ func (s IntSequenceTable) LookupPartitions(context *sql.Context, lookup sql.Inde`
`212`	`212`	`return sql.PartitionsToPartitionIter(&sequencePartition{min: min.(int64), max: max.(int64)}), nil`
`213`	`213`	`}`
`214`	`214`
`215`		`-func (s IntSequenceTable) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTable {`
	`215`	`+func (s IntSequenceTable) IndexedAccess(ctx *sql.Context, lookup sql.IndexLookup) sql.IndexedTable {`
`216`	`216`	`return s`
`217`	`217`	`}`
`218`	`218`
Original file line number	Diff line number	Diff line change
`@@ -1734,7 +1734,7 @@ func (t IndexedTable) PartitionRows(ctx sql.Context, partition sql.Partition)`
`1734`	`1734`	`return iter, nil`
`1735`	`1735`	`}`
`1736`	`1736`
`1737`		`-func (t *Table) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTable {`
	`1737`	`+func (t Table) IndexedAccess(ctx sql.Context, lookup sql.IndexLookup) sql.IndexedTable {`
`1738`	`1738`	`return &IndexedTable{Table: t, Lookup: lookup}`
`1739`	`1739`	`}`
`1740`	`1740`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ func pushdownIndexToTable(ctx sql.Context, a Analyzer, tableNode sql.NameableN`
`105`	`105`	`}`
`106`	`106`	`a.Log("table %q transformed with pushdown of index", tableNode.Name())`
`107`	`107`	`lb := plan.NewLookupBuilder(index, keyExpr, nullmask)`
`108`		`- ret, err := plan.NewIndexedAccessForTableNode(nn, lb)`
	`108`	`+ ret, err := plan.NewIndexedAccessForTableNode(ctx, nn, lb)`
`109`	`109`	`if err != nil {`
`110`	`110`	`return nil, transform.SameTree, err`
`111`	`111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ func costedIndexScans(ctx sql.Context, a Analyzer, n sql.Node, qFlags *sql.Que`
`76`	`76`	`return n, transform.SameTree, err`
`77`	`77`	`}`
`78`	`78`	`if ok {`
`79`		`- return indexSearchableLookup(n, rt, lookup, filter.Expression, newFilter, lookupFds, qFlags)`
	`79`	`+ return indexSearchableLookup(ctx, n, rt, lookup, filter.Expression, newFilter, lookupFds, qFlags)`
`80`	`80`	`} else if is.SkipIndexCosting() {`
`81`	`81`	`return n, transform.SameTree, nil`
`82`	`82`	`}`
`@@ -88,13 +88,13 @@ func costedIndexScans(ctx sql.Context, a Analyzer, n sql.Node, qFlags *sql.Que`
`88`	`88`	`})`
`89`	`89`	`}`
`90`	`90`
`91`		`-func indexSearchableLookup(n sql.Node, rt sql.TableNode, lookup sql.IndexLookup, oldFilter, newFilter sql.Expression, fds sql.FuncDepSet, qFlags sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {`
	`91`	`+func indexSearchableLookup(ctx sql.Context, n sql.Node, rt sql.TableNode, lookup sql.IndexLookup, oldFilter, newFilter sql.Expression, fds sql.FuncDepSet, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {`
`92`	`92`	`if lookup.IsEmpty() {`
`93`	`93`	`return n, transform.SameTree, nil`
`94`	`94`	`}`
`95`	`95`	`var ret sql.Node`
`96`	`96`	`var err error`
`97`		`- ret, err = plan.NewStaticIndexedAccessForTableNode(rt, lookup)`
	`97`	`+ ret, err = plan.NewStaticIndexedAccessForTableNode(ctx, rt, lookup)`
`98`	`98`	`if err != nil {`
`99`	`99`	`return n, transform.SameTree, err`
`100`	`100`	`}`
`@@ -290,7 +290,7 @@ func getCostedIndexScan(ctx *sql.Context, statsProv sql.StatsProvider, rt sql.Ta`
`290`	`290`	`Table: rt,`
`291`	`291`	`})`
`292`	`292`	`} else {`
`293`		`- ret, err = plan.NewStaticIndexedAccessForTableNode(rt, lookup)`
	`293`	`+ ret, err = plan.NewStaticIndexedAccessForTableNode(ctx, rt, lookup)`
`294`	`294`	`if err != nil {`
`295`	`295`	`return nil, nil, nil, err`
`296`	`296`	`}`
`@@ -326,7 +326,7 @@ func getCostedIndexScan(ctx *sql.Context, statsProv sql.StatsProvider, rt sql.Ta`
`326`	`326`	`return ret, bestStat, retFilters, nil`
`327`	`327`	`}`
`328`	`328`
`329`		`-func addIndexScans(m *memo.Memo) error {`
	`329`	`+func addIndexScans(ctx sql.Context, m memo.Memo) error {`
`330`	`330`	`return memo.DfsRel(m.Root(), func(e memo.RelExpr) error {`
`331`	`331`	`filter, ok := e.(*memo.Filter)`
`332`	`332`	`if !ok {`
`@@ -359,7 +359,7 @@ func addIndexScans(m *memo.Memo) error {`
`359`	`359`	`if lookup.IsEmpty() {`
`360`	`360`	`return nil`
`361`	`361`	`}`
`362`		`- ret, err := plan.NewStaticIndexedAccessForTableNode(rt, lookup)`
	`362`	`+ ret, err := plan.NewStaticIndexedAccessForTableNode(ctx, rt, lookup)`
`363`	`363`	`if err != nil {`
`364`	`364`	`m.HandleErr(err)`
`365`	`365`	`}`
Original file line number	Diff line number	Diff line change
`@@ -921,7 +921,7 @@ func (i indexSearchableTable) LookupForExpressions(ctx sql.Context, exprs ...s`
`921`	`921`	`return sql.IndexLookup{}, nil, nil, false, nil`
`922`	`922`	`}`
`923`	`923`
`924`		`-func (i *indexSearchableTable) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTable {`
	`924`	`+func (i indexSearchableTable) IndexedAccess(ctx sql.Context, lookup sql.IndexLookup) sql.IndexedTable {`
`925`	`925`	`return i`
`926`	`926`	`}`
`927`	`927`