func (this *builder) selectScan(keyspace datastore.Keyspace, node *algebra.KeyspaceTerm,
limit expression.Expression) (op plan.Operator, err error) {
keys := node.Keys()
if keys != nil {
switch keys := keys.(type) {
case *expression.ArrayConstruct:
this.maxParallelism = util.MaxInt(1, len(keys.Operands()))
case *algebra.NamedParameter, *algebra.PositionalParameter:
this.maxParallelism = 0
default:
this.maxParallelism = 1
}
return plan.NewKeyScan(keys), nil
}
this.maxParallelism = 0 // Use default parallelism for index scans
secondary, primary, err := this.buildScan(keyspace, node, limit)
if err != nil {
return nil, err
}
if secondary != nil {
return secondary, nil
} else {
return primary, nil
}
}
func (this *builder) VisitKeyspaceTerm(node *algebra.KeyspaceTerm) (interface{}, error) {
node.SetDefaultNamespace(this.namespace)
keyspace, err := this.getTermKeyspace(node)
if err != nil {
return nil, err
}
if this.subquery && this.correlated && node.Keys() == nil {
return nil, errors.NewSubqueryMissingKeysError(node.Keyspace())
}
scan, err := this.selectScan(keyspace, node, this.limit)
if err != nil {
return nil, err
}
this.children = append(this.children, scan)
if this.coveringScan == nil {
fetch := plan.NewFetch(keyspace, node)
this.subChildren = append(this.subChildren, fetch)
}
return nil, nil
}
func (this *builder) buildJoinScan(keyspace datastore.Keyspace, node *algebra.KeyspaceTerm, op string) (
datastore.Index, expression.Covers, error) {
indexes, err := allIndexes(keyspace)
if err != nil {
return nil, nil, err
}
var pred expression.Expression
pred = expression.NewIsNotNull(node.Keys().Copy())
dnf := NewDNF()
pred, err = dnf.Map(pred)
if err != nil {
return nil, nil, err
}
subset := pred
if this.where != nil {
subset = expression.NewAnd(subset, this.where.Copy())
subset, err = dnf.Map(subset)
if err != nil {
return nil, nil, err
}
}
formalizer := expression.NewFormalizer()
formalizer.Keyspace = node.Alias()
primaryKey := expression.Expressions{
expression.NewField(
expression.NewMeta(expression.NewConstant(node.Alias())),
expression.NewFieldName("id", false)),
}
sargables, err := sargableIndexes(indexes, pred, subset, primaryKey, dnf, formalizer)
if err != nil {
return nil, nil, err
}
minimals, err := minimalIndexes(sargables, pred)
if err != nil {
return nil, nil, err
}
if len(minimals) == 0 {
return nil, nil, errors.NewNoIndexJoinError(node.Alias(), op)
}
return this.buildCoveringJoinScan(minimals, node, op)
}
