Ld index bugs

memory/ascend_index.go

@@ -0,0 +1,63 @@
+package memory
+
+import (
+	"github.com/src-d/go-mysql-server/sql"
+	"github.com/src-d/go-mysql-server/sql/expression"
+)
+
+type AscendIndexLookup struct {
+	id    string
+	Gte   []interface{}
+	Lt    []interface{}
+	Index ExpressionsIndex
+}
+
+var _ memoryIndexLookup = (*AscendIndexLookup)(nil)
+
+func (l *AscendIndexLookup) ID() string { return l.id }
+
+func (l *AscendIndexLookup) Values(p sql.Partition) (sql.IndexValueIter, error) {
+	return &indexValIter{
+		tbl:             l.Index.MemTable(),
+		partition:       p,
+		matchExpression: l.EvalExpression(),
+	}, nil
+}
+
+func (l *AscendIndexLookup) Indexes() []string {
+	return []string{l.id}
+}
+
+func (l *AscendIndexLookup) IsMergeable(lookup sql.IndexLookup) bool {
+	_, ok := lookup.(MergeableLookup)
+	return ok
+}
+
+func (l *AscendIndexLookup) Union(lookups ...sql.IndexLookup) sql.IndexLookup {
+	return union(l.Index, l, lookups...)
+}
+
+func (l *AscendIndexLookup) EvalExpression() sql.Expression {
+	if len(l.Index.ColumnExpressions()) > 1 {
+		panic("Ascend index unsupported for multi-column indexes")
+	}
+
+	lt, typ := getType(l.Lt[0])
+	ltexpr := expression.NewLessThan(l.Index.ColumnExpressions()[0], expression.NewLiteral(lt, typ))
+	if len(l.Gte) > 0 {
+		gte, _ := getType(l.Gte[0])
+		return and(
+			ltexpr,
+			expression.NewGreaterThanOrEqual(l.Index.ColumnExpressions()[0], expression.NewLiteral(gte, typ)),
+		)
+	}
+	return ltexpr
+}
+
+func (*AscendIndexLookup) Difference(...sql.IndexLookup) sql.IndexLookup {
+	panic("ascendIndexLookup.Difference is not implemented")
+}
+
+func (l *AscendIndexLookup) Intersection(lookups ...sql.IndexLookup) sql.IndexLookup {
+	return intersection(l.Index, l, lookups...)
+}

memory/descend_index.go

@@ -0,0 +1,64 @@
+package memory
+
+import (
+	"github.com/src-d/go-mysql-server/sql"
+	"github.com/src-d/go-mysql-server/sql/expression"
+)
+
+type DescendIndexLookup struct {
+	id    string
+	Gt    []interface{}
+	Lte   []interface{}
+	Index ExpressionsIndex
+}
+
+var _ memoryIndexLookup = (*DescendIndexLookup)(nil)
+
+func (l *DescendIndexLookup) ID() string { return l.id }
+
+func (l *DescendIndexLookup) Values(p sql.Partition) (sql.IndexValueIter, error) {
+	return &indexValIter{
+		tbl:             l.Index.MemTable(),
+		partition:       p,
+		matchExpression: l.EvalExpression(),
+	}, nil
+}
+
+func (l *DescendIndexLookup) EvalExpression() sql.Expression {
+	if len(l.Index.ColumnExpressions()) > 1 {
+		panic("Descend index unsupported for multi-column indexes")
+	}
+
+	gt, typ := getType(l.Gt[0])
+	gtexpr := expression.NewGreaterThan(l.Index.ColumnExpressions()[0], expression.NewLiteral(gt, typ))
+	if len(l.Lte) > 0 {
+		lte, _ := getType(l.Lte[0])
+		return and(
+			gtexpr,
+			expression.NewLessThanOrEqual(l.Index.ColumnExpressions()[0], expression.NewLiteral(lte, typ)),
+		)
+	}
+	return gtexpr
+}
+
+func (l *DescendIndexLookup) Indexes() []string {
+	return []string{l.id}
+}
+
+func (l *DescendIndexLookup) IsMergeable(lookup sql.IndexLookup) bool {
+	_, ok := lookup.(MergeableLookup)
+	return ok
+}
+
+func (l *DescendIndexLookup) Union(lookups ...sql.IndexLookup) sql.IndexLookup {
+	return union(l.Index, l, lookups...)
+}
+
+func (*DescendIndexLookup) Difference(...sql.IndexLookup) sql.IndexLookup {
+	panic("descendIndexLookup.Difference is not implemented")
+}
+
+func (l *DescendIndexLookup) Intersection(lookups ...sql.IndexLookup) sql.IndexLookup {
+	return intersection(l.Index, l, lookups...)
+}
+

memory/index_driver.go

@@ -0,0 +1,43 @@
+package memory
+
+import (
+	"github.com/src-d/go-mysql-server/sql"
+)
+
+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}
+}
+
+func (d *TestIndexDriver) ID() string {
+	return IndexDriverId
+}
+
+func (d *TestIndexDriver) LoadAll(db, table string) ([]sql.Index, error) {
+	if d.db != db {
+		return nil, nil
+	}
+	return d.indexes[table], nil
+}
+
+func (d *TestIndexDriver) Save(*sql.Context, sql.Index, sql.PartitionIndexKeyValueIter) error {
+	panic("not implemented")
+}
+
+func (d *TestIndexDriver) Delete(sql.Index, sql.PartitionIter) error {
+	panic("not implemented")
+}
+
+func (d *TestIndexDriver) Create(db, table, id string, expressions []sql.Expression, config map[string]string) (sql.Index, error) {
+	panic("not implemented")
+}