sql,colexec: minor cleanup of scan-related things

pkg/sql/colfetcher/colbatch_scan.go

@@ -168,10 +168,10 @@ func NewColBatchScan(
 	var sysColDescs []descpb.ColumnDescriptor
 	if spec.HasSystemColumns {
 		sysColDescs = colinfo.AllSystemColumnDescs
-	}
-	for i := range sysColDescs {
-		typs = append(typs, sysColDescs[i].Type)
-		columnIdxMap.Set(sysColDescs[i].ID, columnIdxMap.Len())
+		for i := range sysColDescs {
+			typs = append(typs, sysColDescs[i].Type)
+			columnIdxMap.Set(sysColDescs[i].ID, columnIdxMap.Len())
+		}
 	}
 
 	semaCtx := tree.MakeSemaContext()
@@ -192,9 +192,7 @@ func NewColBatchScan(
 
 	fetcher := cFetcherPool.Get().(*cFetcher)
 	if _, _, err := initCRowFetcher(
-		flowCtx.Codec(), allocator, fetcher, table, int(spec.IndexIdx), columnIdxMap,
-		spec.Reverse, neededColumns, spec.Visibility, spec.LockingStrength, spec.LockingWaitPolicy,
-		sysColDescs,
+		flowCtx.Codec(), allocator, fetcher, table, columnIdxMap, neededColumns, spec, sysColDescs,
 	); err != nil {
 		return nil, err
 	}
@@ -224,22 +222,18 @@ func initCRowFetcher(
 	allocator *colmem.Allocator,
 	fetcher *cFetcher,
 	desc *tabledesc.Immutable,
-	indexIdx int,
 	colIdxMap catalog.TableColMap,
-	reverseScan bool,
 	valNeededForCol util.FastIntSet,
-	scanVisibility execinfrapb.ScanVisibility,
-	lockStrength descpb.ScanLockingStrength,
-	lockWaitPolicy descpb.ScanLockingWaitPolicy,
+	spec *execinfrapb.TableReaderSpec,
 	systemColumnDescs []descpb.ColumnDescriptor,
 ) (index *descpb.IndexDescriptor, isSecondaryIndex bool, err error) {
-	index, isSecondaryIndex, err = desc.FindIndexByIndexIdx(indexIdx)
+	index, isSecondaryIndex, err = desc.FindIndexByIndexIdx(int(spec.IndexIdx))
 	if err != nil {
 		return nil, false, err
 	}
 
 	cols := desc.Columns
-	if scanVisibility == execinfra.ScanVisibilityPublicAndNotPublic {
+	if spec.Visibility == execinfra.ScanVisibilityPublicAndNotPublic {
 		cols = desc.ReadableColumns
 	}
 	// Add on any requested system columns. We slice cols to avoid modifying
@@ -254,7 +248,7 @@ func initCRowFetcher(
 		ValNeededForCol:  valNeededForCol,
 	}
 	if err := fetcher.Init(
-		codec, allocator, reverseScan, lockStrength, lockWaitPolicy, tableArgs,
+		codec, allocator, spec.Reverse, spec.LockingStrength, spec.LockingWaitPolicy, tableArgs,
 	); err != nil {
 		return nil, false, err
 	}

pkg/sql/distsql_physical_planner.go

@@ -965,7 +965,7 @@ func getIndexIdx(index *descpb.IndexDescriptor, desc *tabledesc.Immutable) (uint
 // initTableReaderSpec initializes a TableReaderSpec/PostProcessSpec that
 // corresponds to a scanNode, except for the Spans and OutputColumns.
 func initTableReaderSpec(
-	n *scanNode, planCtx *PlanningCtx, indexVarMap []int,
+	n *scanNode,
 ) (*execinfrapb.TableReaderSpec, execinfrapb.PostProcessSpec, error) {
 	s := physicalplan.NewTableReaderSpec()
 	*s = execinfrapb.TableReaderSpec{
@@ -1013,8 +1013,9 @@ func tableOrdinal(
 	}
 	if visibility == execinfra.ScanVisibilityPublicAndNotPublic {
 		offset := len(desc.Columns)
-		for i, col := range desc.MutationColumns() {
-			if col.ID == colID {
+		mutationColumns := desc.MutationColumns()
+		for i := range mutationColumns {
+			if mutationColumns[i].ID == colID {
 				return offset + i
 			}
 		}
@@ -1156,7 +1157,6 @@ func (dsp *DistSQLPlanner) CheckNodeHealthAndVersion(
 
 // createTableReaders generates a plan consisting of table reader processors,
 // one for each node that has spans that we are reading.
-// overridesResultColumns is optional.
 func (dsp *DistSQLPlanner) createTableReaders(
 	planCtx *PlanningCtx, n *scanNode,
 ) (*PhysicalPlan, error) {
@@ -1166,7 +1166,7 @@ func (dsp *DistSQLPlanner) createTableReaders(
 	// scanNodeToTableOrdinalMap is a map from scan node column ordinal to
 	// table reader column ordinal.
 	scanNodeToTableOrdinalMap := toTableOrdinals(n.cols, n.desc, n.colCfg.visibility)
-	spec, post, err := initTableReaderSpec(n, planCtx, scanNodeToTableOrdinalMap)
+	spec, post, err := initTableReaderSpec(n)
 	if err != nil {
 		return nil, err
 	}
@@ -1285,8 +1285,9 @@ func (dsp *DistSQLPlanner) planTableReaders(
 		typs = append(typs, info.desc.Columns[i].Type)
 	}
 	if returnMutations {
-		for _, col := range info.desc.MutationColumns() {
-			typs = append(typs, col.Type)
+		mutationColumns := info.desc.MutationColumns()
+		for i := range mutationColumns {
+			typs = append(typs, mutationColumns[i].Type)
 		}
 	}
 	if info.containsSystemColumns {
@@ -1308,8 +1309,9 @@ func (dsp *DistSQLPlanner) planTableReaders(
 		colID++
 	}
 	if returnMutations {
-		for _, c := range info.desc.MutationColumns() {
-			descColumnIDs.Set(colID, int(c.ID))
+		mutationColumns := info.desc.MutationColumns()
+		for i := range mutationColumns {
+			descColumnIDs.Set(colID, int(mutationColumns[i].ID))
 			colID++
 		}
 	}

pkg/sql/distsql_plan_scrub_physical.go

@@ -11,11 +11,9 @@
 package sql
 
 import (
-	"github.com/cockroachdb/cockroach/pkg/sql/catalog/descpb"
 	"github.com/cockroachdb/cockroach/pkg/sql/execinfrapb"
 	"github.com/cockroachdb/cockroach/pkg/sql/physicalplan"
 	"github.com/cockroachdb/cockroach/pkg/sql/rowexec"
-	"github.com/cockroachdb/cockroach/pkg/util/hlc"
 )
 
 // createScrubPhysicalCheck generates a plan for running a physical
@@ -24,13 +22,9 @@ import (
 // TableReaders will only emit errors encountered during scanning
 // instead of row data. The plan is finalized.
 func (dsp *DistSQLPlanner) createScrubPhysicalCheck(
-	planCtx *PlanningCtx,
-	n *scanNode,
-	desc descpb.TableDescriptor,
-	indexDesc descpb.IndexDescriptor,
-	readAsOf hlc.Timestamp,
+	planCtx *PlanningCtx, n *scanNode,
 ) (*PhysicalPlan, error) {
-	spec, _, err := initTableReaderSpec(n, planCtx, nil /* indexVarMap */)
+	spec, _, err := initTableReaderSpec(n)
 	if err != nil {
 		return nil, err
 	}

pkg/sql/distsql_plan_stats.go

@@ -80,6 +80,10 @@ func (dsp *DistSQLPlanner) createStatsPlan(
 	if err != nil {
 		return nil, err
 	}
+	var colIdxMap catalog.TableColMap
+	for i, c := range scan.cols {
+		colIdxMap.Set(c.ID, i)
+	}
 	sb := span.MakeBuilder(planCtx.EvalContext(), planCtx.ExtendedEvalCtx.Codec, desc, scan.index)
 	scan.spans, err = sb.UnconstrainedSpans()
 	if err != nil {
@@ -112,7 +116,7 @@ func (dsp *DistSQLPlanner) createStatsPlan(
 			StatName:            s.name,
 		}
 		for i, colID := range s.columns {
-			colIdx, ok := scan.colIdxMap.Get(colID)
+			colIdx, ok := colIdxMap.Get(colID)
 			if !ok {
 				panic("necessary column not scanned")
 			}

pkg/sql/scan.go

@@ -15,7 +15,6 @@ import (
 	"sync"
 
 	"github.com/cockroachdb/cockroach/pkg/roachpb"
-	"github.com/cockroachdb/cockroach/pkg/sql/catalog"
 	"github.com/cockroachdb/cockroach/pkg/sql/catalog/colinfo"
 	"github.com/cockroachdb/cockroach/pkg/sql/catalog/descpb"
 	"github.com/cockroachdb/cockroach/pkg/sql/catalog/tabledesc"
@@ -64,9 +63,6 @@ type scanNode struct {
 	// There is a 1-1 correspondence between cols and resultColumns.
 	resultColumns colinfo.ResultColumns
 
-	// Map used to get the index for columns in cols.
-	colIdxMap catalog.TableColMap
-
 	spans   []roachpb.Span
 	reverse bool
 
@@ -329,8 +325,5 @@ func (n *scanNode) initDescDefaults(colCfg scanColumnsConfig) error {
 
 	// Set up the rest of the scanNode.
 	n.resultColumns = colinfo.ResultColumnsFromColDescPtrs(n.desc.GetID(), n.cols)
-	for i, c := range n.cols {
-		n.colIdxMap.Set(c.ID, i)
-	}
 	return nil
 }

pkg/sql/scrub_physical.go

@@ -124,8 +124,7 @@ func (o *physicalCheckOperation) Start(params runParams) error {
 	// that scrubNode needs to perform, we need to make sure that scrubNode
 	// is not closed when this physical check operation is being cleaned up.
 	planCtx.ignoreClose = true
-	physPlan, err := params.extendedEvalCtx.DistSQLPlanner.createScrubPhysicalCheck(
-		planCtx, scan, *o.tableDesc.TableDesc(), *o.indexDesc, params.p.ExecCfg().Clock.Now())
+	physPlan, err := params.extendedEvalCtx.DistSQLPlanner.createScrubPhysicalCheck(planCtx, scan)
 	if err != nil {
 		return err
 	}