Cleaned up and added better comments on a couple types

Signed-off-by: Zach Musgrave <zach@liquidata.co>

Author: zachmu

memory/ascend_index.go

@@ -28,8 +28,9 @@ func (l *AscendIndexLookup) Indexes() []string {
 	return []string{l.id}
 }
 
-func (l *AscendIndexLookup) IsMergeable(sql.IndexLookup) bool {
-	return true
+func (l *AscendIndexLookup) IsMergeable(lookup sql.IndexLookup) bool {
+	_, ok := lookup.(MergeableLookup)
+	return ok
 }
 
 func (l *AscendIndexLookup) Union(lookups ...sql.IndexLookup) sql.IndexLookup {

memory/descend_index.go

@@ -45,8 +45,9 @@ func (l *DescendIndexLookup) Indexes() []string {
 	return []string{l.id}
 }
 
-func (l *DescendIndexLookup) IsMergeable(sql.IndexLookup) bool {
-	return true
+func (l *DescendIndexLookup) IsMergeable(lookup sql.IndexLookup) bool {
+	_, ok := lookup.(MergeableLookup)
+	return ok
 }
 
 func (l *DescendIndexLookup) Union(lookups ...sql.IndexLookup) sql.IndexLookup {

memory/index_driver.go

@@ -6,11 +6,15 @@ import (
 
 const IndexDriverId = "MemoryIndexDriver"
 
+// TestIndexDriver is a non-performant index driver meant to aid in verification of engine correctness. It can not
+// create or delete indexes, but will use the index types defined in this package to alter how queries are executed,
+// retrieving values from the indexes rather than from the tables directly.
 type TestIndexDriver struct {
 	db string
 	indexes map[string][]sql.Index
 }
 
+// NewIndexDriver returns a new index driver for database and the indexes given, keyed by the table name.
 func NewIndexDriver(db string, indexes map[string][]sql.Index) *TestIndexDriver {
 	return &TestIndexDriver{db: db, indexes: indexes}
 }

memory/mergeable_index.go

@@ -84,26 +84,34 @@ func (i *MergeableDummyIndex) ID() string {
 
 func (i *MergeableDummyIndex) Table() string { return i.TableName }
 
+// All lookups in this package, except for UnmergeableLookup, are MergeableLookups. The IDs are mostly for testing /
+// verification purposes.
 type MergeableLookup interface {
 	ID() string
 }
 
-// ExpressionsIndex is an index made out of one or more expressions (usually field expressions)
+// ExpressionsIndex is an index made out of one or more expressions (usually field expressions), linked to a Table.
 type ExpressionsIndex interface {
 	MemTable() 					*Table
 	ColumnExpressions() []sql.Expression
 }
 
+// MergeableIndexLookup is a lookup linked to an ExpressionsIndex. It can be merged with any other MergeableIndexLookup.  All lookups in this package are Merge
 type MergeableIndexLookup struct {
-	Key           []interface{}
-	Index         ExpressionsIndex
+	Key   []interface{}
+	Index ExpressionsIndex
+}
+
+// memoryIndexLookup is a lookup that defines an expression to evaluate which rows are part of the index values
+type memoryIndexLookup interface {
+	EvalExpression() sql.Expression
 }
 
 var _ sql.Mergeable = (*MergeableIndexLookup)(nil)
 var _ sql.SetOperations = (*MergeableIndexLookup)(nil)
 var _ memoryIndexLookup = (*MergeableIndexLookup)(nil)
 
-func (i *MergeableIndexLookup) ID() string 													{ return strings.Join(i.Indexes(), ",") }
+func (i *MergeableIndexLookup) ID() string { return strings.Join(i.Indexes(), ",") }
 
 func (i *MergeableIndexLookup) IsMergeable(lookup sql.IndexLookup) bool {
 	_, ok := lookup.(MergeableLookup)
@@ -198,8 +206,9 @@ func union(idx ExpressionsIndex, left sql.IndexLookup, lookups ...sql.IndexLooku
 	}
 }
 
-// An index lookup that has been merged with another.
-// Exactly one of the Unions or Intersections fields should be set.
+// MergedIndexLookup is an index lookup that has been merged with another.
+// Exactly one of the Unions or Intersections fields should be set, and correspond to a logical AND or OR operation,
+// respectively.
 type MergedIndexLookup struct {
 	Unions        []sql.IndexLookup
 	Intersections []sql.IndexLookup
@@ -252,6 +261,14 @@ func (m *MergedIndexLookup) Values(p sql.Partition) (sql.IndexValueIter, error)
 	}, nil
 }
 
+func (m *MergedIndexLookup) Indexes() []string {
+	panic("implement me")
+}
+
+func (m *MergedIndexLookup) ID() string {
+	panic("implement me")
+}
+
 func or(expressions ...sql.Expression) sql.Expression {
 	if len(expressions) == 1 {
 		return expressions[0]
@@ -264,12 +281,4 @@ func and(expressions ...sql.Expression) sql.Expression {
 		return expressions[0]
 	}
 	return expression.NewAnd(expressions[0], and(expressions[1:]...))
-}
-
-func (m *MergedIndexLookup) Indexes() []string {
-	panic("implement me")
-}
-
-func (m *MergedIndexLookup) ID() string {
-	panic("implement me")
 }

memory/negative_index.go

@@ -30,8 +30,9 @@ func (l *NegateIndexLookup) Indexes() []string {
 	return []string{l.ID()}
 }
 
-func (*NegateIndexLookup) IsMergeable(sql.IndexLookup) bool {
-	return true
+func (*NegateIndexLookup) IsMergeable(lookup sql.IndexLookup) bool {
+	_, ok := lookup.(MergeableLookup)
+	return ok
 }
 
 func (l *NegateIndexLookup) Union(lookups ...sql.IndexLookup) sql.IndexLookup {

memory/unmergeable_index.go

@@ -37,21 +37,13 @@ func (u *UnmergeableDummyIndex) Get(key ...interface{}) (sql.IndexLookup, error)
 	}, nil
 }
 
+// UnmergeableIndexLookup is the only IndexLookup in this package that doesn't implement Mergeable, and therefore
+// can't be merged with other lookups.
 type UnmergeableIndexLookup struct {
 	key []interface{}
 	idx *UnmergeableDummyIndex
 }
 
-func (u *UnmergeableIndexLookup) EvalExpression() sql.Expression {
-	return nil
-}
-
-type memoryIndexLookup interface {
-	EvalExpression() sql.Expression
-}
-
-var _ memoryIndexLookup = (*UnmergeableIndexLookup)(nil)
-
 // dummyIndexValueIter does a very simple and verifiable iteration over the table values for a given index. It does this
 // by iterating over all the table rows for a partition and evaluating each of them for inclusion in the index. This is
 // not an efficient way to store an index, and is only suitable for testing the correctness of index code in the engine.