func (this *DNF) VisitFunction(expr expression.Function) (interface{}, error) {
var exp expression.Expression = expr
switch expr := expr.(type) {
case *expression.IsBoolean:
exp = expression.NewLE(expr.Operand(), expression.TRUE_EXPR)
case *expression.IsNumber:
exp = expression.NewAnd(
expression.NewGT(expr.Operand(), expression.TRUE_EXPR),
expression.NewLT(expr.Operand(), expression.EMPTY_STRING_EXPR))
case *expression.IsString:
exp = expression.NewAnd(
expression.NewGE(expr.Operand(), expression.EMPTY_STRING_EXPR),
expression.NewLT(expr.Operand(), expression.EMPTY_ARRAY_EXPR))
case *expression.IsArray:
exp = expression.NewAnd(
expression.NewGE(expr.Operand(), expression.EMPTY_ARRAY_EXPR),
expression.NewLT(expr.Operand(), _EMPTY_OBJECT_EXPR))
case *expression.IsObject:
// Not equivalent to IS OBJECT. Includes BINARY values.
exp = expression.NewGE(expr.Operand(), _EMPTY_OBJECT_EXPR)
}
return exp, exp.MapChildren(this)
}
func minimalIndexes(sargables map[datastore.Index]*indexEntry, pred expression.Expression) (
map[datastore.Index]*indexEntry, error) {
for s, se := range sargables {
for t, te := range sargables {
if t == s {
continue
}
if narrowerOrEquivalent(se, te) {
delete(sargables, t)
}
}
}
minimals := make(map[datastore.Index]*indexEntry, len(sargables))
for s, se := range sargables {
spans, err := SargFor(pred, se.sargKeys, len(se.keys))
if err != nil || len(spans) == 0 {
logging.Errorp("Sargable index not sarged", logging.Pair{"pred", pred},
logging.Pair{"sarg_keys", se.sargKeys}, logging.Pair{"error", err})
return nil, errors.NewPlanError(nil, fmt.Sprintf("Sargable index not sarged; pred=%v, sarg_keys=%v, error=%v",
pred.String(), se.sargKeys.String(), err))
return nil, err
}
se.spans = spans
minimals[s] = se
}
return minimals, nil
}
func LessThan(expr1, expr2 expression.Expression) bool {
value1 := expr1.Value()
value2 := expr2.Value()
return value1 != nil && value2 != nil &&
value1.Collate(value2) < 0
}
func (this *JSConverter) Visit(expr expression.Expression) string {
var buf bytes.Buffer
s, err := expr.Accept(this)
if err != nil {
logging.Errorf("Unexpected error in JSConverter: %v", err)
return ""
}
switch s := s.(type) {
case string:
buf.WriteString(s)
for this.stack.Size() != 0 {
funcExpr := this.stack.Pop().(*funcExpr)
buf.WriteString(funcExpr.name)
if funcExpr.operands.Front() != nil {
buf.WriteString(writeOperands(funcExpr.operands))
}
}
case []byte:
buf.WriteString(string(s))
for this.stack.Size() != 0 {
funcExpr := this.stack.Pop().(*funcExpr)
buf.WriteString(funcExpr.name)
if funcExpr.operands.Front() != nil {
buf.WriteString(writeOperands(funcExpr.operands))
}
}
default:
buf.WriteString(s.(string))
}
return buf.String()
}
/*
Constrain the WHERE condition to reflect the aggregate query. For
example:
SELECT AVG(v) FROM widget w;
is rewritten as:
SELECT AVG(v) FROM widget w WHERE v IS NOT NULL;
This enables the query to use an index on v.
*/
func constrainAggregate(cond expression.Expression, aggs map[string]algebra.Aggregate) expression.Expression {
var first expression.Expression
for _, agg := range aggs {
if first == nil {
first = agg.Operand()
if first == nil {
return cond
}
continue
}
op := agg.Operand()
if op == nil || !first.EquivalentTo(op) {
return cond
}
}
if first == nil {
return cond
}
var constraint expression.Expression = expression.NewIsNotNull(first)
if cond != nil {
constraint = expression.NewAnd(cond, constraint)
}
return constraint
}
func SubsetOf(expr1, expr2 expression.Expression) bool {
v2 := expr2.Value()
if v2 != nil {
return v2.Truth()
}
s := newSubset(expr1)
result, _ := expr2.Accept(s)
return result.(bool)
}
func sargFor(pred, expr expression.Expression, missingHigh bool) (plan.Spans, error) {
s := newSarg(pred)
s.SetMissingHigh(missingHigh)
r, err := expr.Accept(s)
if err != nil || r == nil {
return nil, err
}
rs := r.(plan.Spans)
return rs, nil
}
/*
The function NewExecute returns a pointer to the Execute
struct with the input argument expressions value as a field.
*/
func NewExecute(prepared expression.Expression) *Execute {
var preparedValue value.Value
switch prepared := prepared.(type) {
case *expression.Identifier:
preparedValue = value.NewValue(prepared.Alias())
default:
preparedValue = prepared.Value()
}
rv := &Execute{
prepared: preparedValue,
}
rv.stmt = rv
return rv
}
/*
Create a key value pair using the operands of the input
expression Array construct and return.
*/
func NewPair(expr expression.Expression) (*Pair, error) {
array, ok := expr.(*expression.ArrayConstruct)
if !ok {
return nil, fmt.Errorf("Invalid VALUES expression %s", expr.String())
}
operands := array.Operands()
if len(operands) != 2 {
return nil, fmt.Errorf("Invalid VALUES expression %s", expr.String())
}
pair := &Pair{
Key: operands[0],
Value: operands[1],
}
return pair, nil
}
func dnfComplexity(expr expression.Expression, max int) int {
comp := 0
switch expr := expr.(type) {
case *expression.Or:
comp = len(expr.Operands())
}
if comp < max {
children := expr.Children()
for _, child := range children {
childComp := dnfComplexity(child, max-comp)
comp += childComp
if comp >= max {
break
}
}
}
return comp
}
func (this *DNF) VisitNot(expr *expression.Not) (interface{}, error) {
err := expr.MapChildren(this)
if err != nil {
return nil, err
}
var exp expression.Expression = expr
switch operand := expr.Operand().(type) {
case *expression.Not:
exp = operand.Operand()
case *expression.And:
operands := make(expression.Expressions, len(operand.Operands()))
for i, op := range operand.Operands() {
operands[i] = expression.NewNot(op)
}
exp = expression.NewOr(operands...)
case *expression.Or:
operands := make(expression.Expressions, len(operand.Operands()))
for i, op := range operand.Operands() {
operands[i] = expression.NewNot(op)
}
and := expression.NewAnd(operands...)
return this.VisitAnd(and)
case *expression.Eq:
exp = expression.NewOr(expression.NewLT(operand.First(), operand.Second()),
expression.NewLT(operand.Second(), operand.First()))
case *expression.LT:
exp = expression.NewLE(operand.Second(), operand.First())
case *expression.LE:
exp = expression.NewLT(operand.Second(), operand.First())
default:
return expr, nil
}
return exp, exp.MapChildren(this)
}
func newSargDefault(pred expression.Expression) *sargDefault {
var spans plan.Spans
if pred.PropagatesNull() {
spans = _VALUED_SPANS
} else if pred.PropagatesMissing() {
spans = _FULL_SPANS
}
rv := &sargDefault{}
rv.sarger = func(expr2 expression.Expression) (plan.Spans, error) {
if SubsetOf(pred, expr2) {
return _SELF_SPANS, nil
}
if spans != nil && pred.DependsOn(expr2) {
return spans, nil
}
return nil, nil
}
return rv
}
func LessThanOrEquals(expr1, expr2 expression.Expression) bool {
return LessThan(expr1, expr2) || expr1.EquivalentTo(expr2)
}
func newSubset(expr expression.Expression) expression.Visitor {
s, _ := expr.Accept(_SUBSET_FACTORY)
return s.(expression.Visitor)
}
// Formalize e by prefixing field names with the bucketName
func (this *JsStatement) formalize(bucketName string, e expression.Expression) (expression.Expression, error) {
f := expression.NewFormalizer()
f.Keyspace = bucketName
f.Allowed.SetField(bucketName, true)
return f.Map(e.Copy())
}
func newSargable(pred expression.Expression) expression.Visitor {
s, _ := pred.Accept(_SARGABLE_FACTORY)
return s.(expression.Visitor)
}
func newSubsetDefault(expr expression.Expression) *subsetDefault {
rv := &subsetDefault{}
rv.test = func(expr2 expression.Expression) (bool, error) {
value2 := expr2.Value()
if value2 != nil {
return value2.Truth(), nil
}
if expr.EquivalentTo(expr2) {
return true, nil
}
switch expr2 := expr2.(type) {
case *expression.And:
for _, op := range expr2.Operands() {
if !SubsetOf(expr, op) {
return false, nil
}
}
return true, nil
case *expression.Or:
for _, op := range expr2.Operands() {
if SubsetOf(expr, op) {
return true, nil
}
}
return false, nil
case *expression.IsNotMissing:
return expr.PropagatesMissing() &&
expr.DependsOn(expr2.Operand()), nil
case *expression.IsNotNull:
return expr.PropagatesNull() &&
expr.DependsOn(expr2.Operand()), nil
case *expression.IsValued:
return expr.PropagatesNull() &&
expr.DependsOn(expr2.Operand()), nil
}
return false, nil
}
return rv
}
func newSarg(pred expression.Expression) sarg {
s, _ := pred.Accept(_SARG_FACTORY)
return s.(sarg)
}
// Formalize e by prefixing field names with the bucketName
func (this *JsStatement) formalize(bucketName string, e expression.Expression) (expression.Expression, error) {
f := expression.NewFormalizer(bucketName, nil)
return f.Map(e.Copy())
}