func (this *builder) buildSecondaryScan(secondaries map[datastore.Index]*indexEntry,
node *algebra.KeyspaceTerm, limit expression.Expression) (plan.Operator, error) {
if this.cover != nil {
scan, err := this.buildCoveringScan(secondaries, node, limit)
if scan != nil || err != nil {
return scan, err
}
}
scans := make([]plan.Operator, 0, len(secondaries))
var op plan.Operator
for index, entry := range secondaries {
op = plan.NewIndexScan(index, node, entry.spans, false, limit, nil)
if len(entry.spans) > 1 {
// Use UnionScan to de-dup multiple spans
op = plan.NewUnionScan(op)
}
scans = append(scans, op)
}
if len(scans) > 1 {
return plan.NewIntersectScan(scans...), nil
} else {
return scans[0], nil
}
}
func (this *builder) buildCoveringScan(secondaries map[datastore.Index]*indexEntry,
node *algebra.KeyspaceTerm, limit expression.Expression) (*plan.IndexScan, error) {
if this.cover == nil {
return nil, nil
}
exprs := this.cover.Expressions()
outer:
for index, entry := range secondaries {
for _, expr := range exprs {
if !expr.CoveredBy(entry.keys) {
continue outer
}
}
covered := make([]*expression.Cover, len(entry.keys))
for i, key := range entry.keys {
covered[i] = expression.NewCover(key)
}
scan := plan.NewIndexScan(index, node, entry.spans, false, limit, covered)
this.coveringScan = scan
return scan, nil
}
return nil, nil
}
func (this *builder) buildCoveringScan(secondaries map[datastore.Index]*indexEntry,
node *algebra.KeyspaceTerm, limit expression.Expression) (plan.Operator, error) {
if this.cover == nil {
return nil, nil
}
alias := node.Alias()
exprs := this.cover.Expressions()
id := expression.NewField(
expression.NewMeta(expression.NewIdentifier(node.Alias())),
expression.NewFieldName("id", false))
outer:
for index, entry := range secondaries {
keys := entry.keys
if !index.IsPrimary() {
// Matches execution.spanScan.RunOnce()
keys = append(keys, id)
}
// Use the first available covering index
for _, expr := range exprs {
if !expr.CoveredBy(alias, keys) {
continue outer
}
}
covers := make(expression.Covers, 0, len(keys))
for _, key := range keys {
covers = append(covers, expression.NewCover(key))
}
scan := plan.NewIndexScan(index, node, entry.spans, false, limit, covers)
this.coveringScan = scan
if len(entry.spans) > 1 {
// Use UnionScan to de-dup multiple spans
return plan.NewUnionScan(scan), nil
}
return scan, nil
}
return nil, nil
}