// Initializes the column structures.
func (n *scanNode) initDescDefaults(scanVisibility scanVisibility) {
n.index = &n.desc.PrimaryIndex
n.cols = make([]sqlbase.ColumnDescriptor, 0, len(n.desc.Columns)+len(n.desc.Mutations))
switch scanVisibility {
case publicColumns:
n.cols = append(n.cols, n.desc.Columns...)
case publicAndNonPublicColumns:
n.cols = append(n.cols, n.desc.Columns...)
for _, mutation := range n.desc.Mutations {
if c := mutation.GetColumn(); c != nil {
n.cols = append(n.cols, *c)
}
}
}
n.resultColumns = makeResultColumns(n.cols)
n.colIdxMap = make(map[sqlbase.ColumnID]int, len(n.cols))
for i, c := range n.cols {
n.colIdxMap[c.ID] = i
}
n.valNeededForCol = make([]bool, len(n.cols))
for i := range n.cols {
n.valNeededForCol[i] = true
}
n.row = make([]parser.Datum, len(n.cols))
n.filterVars = parser.MakeIndexedVarHelper(n, len(n.cols))
}
func (eh *exprHelper) init(
expr Expression, types []sqlbase.ColumnType_Kind, evalCtx *parser.EvalContext,
) error {
if expr.Expr == "" {
return nil
}
eh.types = types
eh.evalCtx = evalCtx
eh.vars = parser.MakeIndexedVarHelper(eh, len(types))
var err error
eh.expr, err = processExpression(expr, &eh.vars)
return err
}
// Initializes the column structures.
func (n *scanNode) initDescDefaults() {
n.index = &n.desc.PrimaryIndex
cols := n.desc.Columns
n.resultColumns = makeResultColumns(cols)
n.colIdxMap = make(map[sqlbase.ColumnID]int, len(cols))
for i, c := range cols {
n.colIdxMap[c.ID] = i
}
n.valNeededForCol = make([]bool, len(cols))
for i := range cols {
n.valNeededForCol[i] = true
}
n.row = make([]parser.Datum, len(cols))
n.filterVars = parser.MakeIndexedVarHelper(n, len(cols))
}
func TestProcessExpression(t *testing.T) {
defer leaktest.AfterTest(t)()
e := Expression{Expr: "$0 * ($1 + $2) + $0"}
h := parser.MakeIndexedVarHelper(testVarContainer{}, 4)
expr, err := processExpression(e, &h)
if err != nil {
t.Fatal(err)
}
if !h.IndexedVarUsed(0) || !h.IndexedVarUsed(1) || !h.IndexedVarUsed(2) || h.IndexedVarUsed(3) {
t.Errorf("invalid IndexedVarUsed results %t %t %t %t (expected false false false true)",
h.IndexedVarUsed(0), h.IndexedVarUsed(1), h.IndexedVarUsed(2), h.IndexedVarUsed(3))
}
str := expr.String()
expectedStr := "(var0 * (var1 + var2)) + var0"
if str != expectedStr {
t.Errorf("invalid expression string '%s', expected '%s'", str, expectedStr)
}
}
// newTableReader creates a tableReader.
func newTableReader(
spec *TableReaderSpec, txn *client.Txn, output rowReceiver, evalCtx parser.EvalContext,
) (*tableReader, error) {
tr := &tableReader{
desc: spec.Table,
txn: txn,
output: output,
evalCtx: evalCtx,
}
numCols := len(tr.desc.Columns)
tr.outputCols = make([]int, len(spec.OutputColumns))
for i, v := range spec.OutputColumns {
tr.outputCols[i] = int(v)
}
tr.filterVars = parser.MakeIndexedVarHelper(tr, numCols)
var err error
tr.filter, err = processExpression(spec.Filter, &tr.filterVars)
if err != nil {
return nil, err
}
// Figure out which columns we need: the output columns plus any other
// columns used by the filter expression.
valNeededForCol := make([]bool, numCols)
for _, c := range tr.outputCols {
if c < 0 || c >= numCols {
return nil, util.Errorf("invalid column index %d", c)
}
valNeededForCol[c] = true
}
for c := 0; c < numCols; c++ {
valNeededForCol[c] = valNeededForCol[c] || tr.filterVars.IndexedVarUsed(c)
}
var index *sqlbase.IndexDescriptor
var isSecondaryIndex bool
switch {
case spec.IndexIdx == 0:
index = &tr.desc.PrimaryIndex
case spec.IndexIdx <= uint32(len(tr.desc.Indexes)):
index = &tr.desc.Indexes[spec.IndexIdx-1]
isSecondaryIndex = true
default:
return nil, util.Errorf("Invalid indexIdx %d", spec.IndexIdx)
}
colIdxMap := make(map[sqlbase.ColumnID]int, len(tr.desc.Columns))
for i, c := range tr.desc.Columns {
colIdxMap[c.ID] = i
}
err = tr.fetcher.Init(&tr.desc, colIdxMap, index, spec.Reverse, isSecondaryIndex,
valNeededForCol)
if err != nil {
return nil, err
}
tr.spans = make(sqlbase.Spans, len(spec.Spans))
for i, s := range spec.Spans {
tr.spans[i] = sqlbase.Span{Start: s.Span.Key, End: s.Span.EndKey}
}
return tr, nil
}