Added UNION [ ALL ]. Simplified Index API.

Author: geraldss

algebra/aggregate.go

@@ -52,7 +52,11 @@ func (this *aggregateBase) EquivalentTo(other expression.Expression) bool {
 }
 
 func (this *aggregateBase) Dependencies() expression.Expressions {
-	return nil
+	if this.parameter != nil {
+		return expression.Expressions{this.parameter}
+	} else {
+		return nil
+	}
 }
 
 func (this *aggregateBase) Alias() string {
@@ -67,6 +71,14 @@ func (this *aggregateBase) Fold() expression.Expression {
 	return this
 }
 
+func (this *aggregateBase) SubsetOf(other expression.Expression) bool {
+	return false
+}
+
+func (this *aggregateBase) Spans(index expression.Index) expression.Spans {
+	return nil
+}
+
 func (this *aggregateBase) Parameter() expression.Expression {
 	return this.parameter
 }

catalog/index.go

@@ -25,13 +25,16 @@ const (
 
 // Index is the base type for all indexes.
 type Index interface {
+	expression.Index
 	BucketId() string
 	Id() string
 	Name() string
 	Type() IndexType
-	Equal() expression.CompositeExpression
-	Range() expression.CompositeExpression
 	Drop() err.Error // PrimaryIndexes cannot be dropped
+	Statistics(span *expression.Span) (Statistics, err.Error)
+	Scan(span *expression.Span, conn *IndexConnection)
+	CandidateMins(span *expression.Span, conn *IndexConnection)  // Anywhere from single min value to Scan()
+	CandidateMaxes(span *expression.Span, conn *IndexConnection) // Anywhere from single max value to Scan()
 }
 
 type IndexEntry struct {
@@ -44,65 +47,17 @@ type StopChannel chan bool
 
 // PrimaryIndex represents primary key indexes.
 type PrimaryIndex interface {
-	EqualIndex
-	PrimaryScan(conn *IndexConnection)
-}
-
-// EqualIndexes support equality matching.
-type EqualIndex interface {
 	Index
-	EqualScan(equal value.CompositeValue, conn *IndexConnection)
-	EqualCount(equal value.CompositeValue) (int64, err.Error)
-}
-
-// Inclusion controls how the boundary values of a range are treated.
-type RangeInclusion int
-
-const (
-	NEITHER RangeInclusion = iota
-	LOW
-	HIGH
-	BOTH
-)
-
-type Ranges []*Range
-
-type Range struct {
-	Low       value.CompositeValue
-	High      value.CompositeValue
-	Inclusion RangeInclusion
-}
-
-// RangeIndexes support unrestricted range queries.
-type RangeIndex interface {
-	Index
-	RangeStats(ranje *Range) (RangeStatistics, err.Error)
-	RangeScan(ranje *Range, conn *IndexConnection)
-	RangeCandidateMins(ranje *Range, conn *IndexConnection)  // Anywhere from single Min value to RangeScan()
-	RangeCandidateMaxes(ranje *Range, conn *IndexConnection) // Anywhere from single Max value to RangeScan()
-}
-
-type Dual struct {
-	Equal value.CompositeValue
-	Range
-}
-
-// DualIndexes support restricted range queries.
-type DualIndex interface {
-	Index
-	DualStats(dual *Dual) (RangeStatistics, err.Error)
-	DualScan(dual *Dual, conn *IndexConnection)
-	DualCandidateMins(dual *Dual, conn *IndexConnection)  // Anywhere from single Min value to DualScan()
-	DualCandidateMaxes(dual *Dual, conn *IndexConnection) // Anywhere from single Max value to DualScan()
+	PrimaryScan(conn *IndexConnection)
 }
 
-// RangeStatistics captures statistics for an index range.
-type RangeStatistics interface {
+// Statistics captures statistics for an index span.
+type Statistics interface {
 	Count() (int64, err.Error)
 	Min() (value.Value, err.Error)
 	Max() (value.Value, err.Error)
 	DistinctCount(int64, err.Error)
-	Bins() ([]RangeStatistics, err.Error)
+	Bins() ([]Statistics, err.Error)
 }
 
 type IndexConnection struct {

docs/diagram/Railroad-Diagram-Generator.png

@@ -5,7 +5,7 @@
 /*
  *  select statement
  */
-select ::= select-core order-by-clause? limit-clause? offset-clause?
+select ::= select-core ('UNION' 'ALL'? select-core)* order-by-clause? limit-clause? offset-clause?
 select-core ::= select-from-core | from-select-core
 select-from-core ::= select-clause from-clause? let-clause? where-clause? group-by-clause?
 from-select-core ::= from-clause let-clause? where-clause? group-by-clause? select-clause

docs/diagram/alias.png

@@ -0,0 +1,85 @@
+//  Copyright (c) 2014 Couchbase, Inc.
+//  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+//  except in compliance with the License. You may obtain a copy of the License at
+//    http://www.apache.org/licenses/LICENSE-2.0
+//  Unless required by applicable law or agreed to in writing, software distributed under the
+//  License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+//  either express or implied. See the License for the specific language governing permissions
+//  and limitations under the License.
+
+package execute
+
+import (
+	"github.com/couchbaselabs/query/value"
+)
+
+type All struct {
+	base
+	children     []Operator
+	childChannel StopChannel
+}
+
+func NewAll(children []Operator) *All {
+	rv := &All{
+		base:         newBase(),
+		children:     children,
+		childChannel: make(StopChannel, len(children)),
+	}
+
+	rv.output = rv
+	return rv
+}
+
+func (this *All) Accept(visitor Visitor) (interface{}, error) {
+	return visitor.VisitAll(this)
+}
+
+func (this *All) Copy() Operator {
+	rv := &All{
+		base:         this.base.copy(),
+		childChannel: make(StopChannel, len(this.children)),
+	}
+
+	children := make([]Operator, len(this.children))
+	for i, c := range this.children {
+		children[i] = c.Copy()
+	}
+
+	rv.children = children
+	return rv
+}
+
+func (this *All) RunOnce(context *Context, parent value.Value) {
+	this.once.Do(func() {
+		defer close(this.itemChannel) // Broadcast that I have stopped
+		defer this.notify()           // Notify that I have stopped
+
+		n := len(this.children)
+
+		// Run children in parallel
+		for _, child := range this.children {
+			child.SetOutput(this.output)
+			go child.RunOnce(context, parent)
+		}
+
+		for n > 0 {
+			select {
+			case <-this.childChannel: // Never closed
+				// Wait for all children
+				n--
+			case <-this.stopChannel: // Never closed
+				this.notifyStop()
+				for _, child := range this.children {
+					select {
+					case child.StopChannel() <- false:
+					default:
+					}
+				}
+			}
+		}
+	})
+}
+
+func (this *All) ChildChannel() StopChannel {
+	return this.childChannel
+}

docs/diagram/arithmetic-term.png

@@ -44,16 +44,8 @@ func (this *Builder) VisitParentScan(plan *plan.ParentScan) (interface{}, error)
 	return NewParentScan(), nil
 }
 
-func (this *Builder) VisitEqualScan(plan *plan.EqualScan) (interface{}, error) {
-	return NewEqualScan(plan), nil
-}
-
-func (this *Builder) VisitRangeScan(plan *plan.RangeScan) (interface{}, error) {
-	return NewRangeScan(plan), nil
-}
-
-func (this *Builder) VisitDualScan(plan *plan.DualScan) (interface{}, error) {
-	return NewDualScan(plan), nil
+func (this *Builder) VisitIndexScan(plan *plan.IndexScan) (interface{}, error) {
+	return NewIndexScan(plan), nil
 }
 
 func (this *Builder) VisitKeyScan(plan *plan.KeyScan) (interface{}, error) {
@@ -142,6 +134,21 @@ func (this *Builder) VisitDistinct(plan *plan.Distinct) (interface{}, error) {
 	return NewDistinct(), nil
 }
 
+// Union [ All ]
+func (this *Builder) VisitAll(plan *plan.All) (interface{}, error) {
+	children := make([]Operator, len(plan.Children()))
+	for i, child := range plan.Children() {
+		c, e := child.Accept(this)
+		if e != nil {
+			return nil, e
+		}
+
+		children[i] = c.(Operator)
+	}
+
+	return NewAll(children), nil
+}
+
 // Order
 func (this *Builder) VisitOrder(plan *plan.Order) (interface{}, error) {
 	return NewOrder(plan), nil

docs/diagram/array-expr.png

@@ -10,7 +10,6 @@
 package execute
 
 import (
-	_ "fmt"
 	"runtime"
 
 	"github.com/couchbaselabs/query/value"