Skip to content

Commit cc348d5

Browse files
zachmuzachmu
committed
Renamed UnmergeableDummyIndex and MergeableDummyIndex to remove the Dummy from the name. Moved a few interface assertions left over from assignindex_test into the type files.
Signed-off-by: Zach Musgrave <zach@liquidata.co>
1 parent 2f78b7f commit cc348d5

File tree

8 files changed

+64
-63
lines changed

8 files changed

+64
-63
lines changed

‎engine_test.go

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1717,8 +1717,8 @@ func mergableIndexDriver(tables map[string]*memory.Table) sql.IndexDriver {
17171717
}
17181718

17191719

1720-
func newUnmergableIndex(tables map[string]*memory.Table, tableName string, exprs ...sql.Expression) *memory.UnmergeableDummyIndex {
1721-
return &memory.UnmergeableDummyIndex{
1720+
func newUnmergableIndex(tables map[string]*memory.Table, tableName string, exprs ...sql.Expression) *memory.UnmergeableIndex {
1721+
return &memory.UnmergeableIndex{
17221722
DB: "mydb",
17231723
DriverName: memory.IndexDriverId,
17241724
TableName: tableName,
@@ -1727,8 +1727,8 @@ func newUnmergableIndex(tables map[string]*memory.Table, tableName string, exprs
17271727
}
17281728
}
17291729

1730-
func newMergableIndex(tables map[string]*memory.Table, tableName string, exprs ...sql.Expression) *memory.MergeableDummyIndex {
1731-
return &memory.MergeableDummyIndex {
1730+
func newMergableIndex(tables map[string]*memory.Table, tableName string, exprs ...sql.Expression) *memory.MergeableIndex {
1731+
return &memory.MergeableIndex{
17321732
DB: "mydb",
17331733
DriverName: memory.IndexDriverId,
17341734
TableName: tableName,

‎memory/ascend_index.go

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ var _ memoryIndexLookup = (*AscendIndexLookup)(nil)
1717
func (l *AscendIndexLookup) ID() string { return l.id }
1818

1919
func (l *AscendIndexLookup) Values(p sql.Partition) (sql.IndexValueIter, error) {
20-
return &dummyIndexValueIter{
20+
return &indexValIter{
2121
tbl: l.Index.MemTable(),
2222
partition: p,
2323
matchExpression: l.EvalExpression(),

‎memory/descend_index.go

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ var _ memoryIndexLookup = (*DescendIndexLookup)(nil)
1717
func (l *DescendIndexLookup) ID() string { return l.id }
1818

1919
func (l *DescendIndexLookup) Values(p sql.Partition) (sql.IndexValueIter, error) {
20-
return &dummyIndexValueIter{
20+
return &indexValIter{
2121
tbl: l.Index.MemTable(),
2222
partition: p,
2323
matchExpression: l.EvalExpression(),

‎memory/mergeable_index.go

Lines changed: 24 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -7,52 +7,57 @@ import (
77
"strings"
88
)
99

10-
type MergeableDummyIndex struct {
10+
type MergeableIndex struct {
1111
DB string // required for engine tests with driver
1212
DriverName string // required for engine tests with driver
1313
Tbl *Table // required for engine tests with driver
1414
TableName string
1515
Exprs []sql.Expression
1616
}
1717

18-
func (i *MergeableDummyIndex) Database() string { return i.DB }
19-
func (i *MergeableDummyIndex) Driver() string { return i.DriverName }
20-
func (i *MergeableDummyIndex) MemTable() *Table { return i.Tbl }
21-
func (i *MergeableDummyIndex) ColumnExpressions() []sql.Expression { return i.Exprs }
18+
var _ sql.Index = (*MergeableIndex)(nil)
19+
var _ sql.AscendIndex = (*MergeableIndex)(nil)
20+
var _ sql.DescendIndex = (*MergeableIndex)(nil)
21+
var _ sql.NegateIndex = (*MergeableIndex)(nil)
2222

23-
func (i *MergeableDummyIndex) Expressions() []string {
23+
func (i *MergeableIndex) Database() string { return i.DB }
24+
func (i *MergeableIndex) Driver() string { return i.DriverName }
25+
func (i *MergeableIndex) MemTable() *Table { return i.Tbl }
26+
func (i *MergeableIndex) ColumnExpressions() []sql.Expression { return i.Exprs }
27+
28+
func (i *MergeableIndex) Expressions() []string {
2429
var exprs []string
2530
for _, e := range i.Exprs {
2631
exprs = append(exprs, e.String())
2732
}
2833
return exprs
2934
}
3035

31-
func (i *MergeableDummyIndex) AscendGreaterOrEqual(keys ...interface{}) (sql.IndexLookup, error) {
36+
func (i *MergeableIndex) AscendGreaterOrEqual(keys ...interface{}) (sql.IndexLookup, error) {
3237
return &AscendIndexLookup{Gte: keys, Index: i}, nil
3338
}
3439

35-
func (i *MergeableDummyIndex) AscendLessThan(keys ...interface{}) (sql.IndexLookup, error) {
40+
func (i *MergeableIndex) AscendLessThan(keys ...interface{}) (sql.IndexLookup, error) {
3641
return &AscendIndexLookup{Lt: keys, Index: i}, nil
3742
}
3843

39-
func (i *MergeableDummyIndex) AscendRange(greaterOrEqual, lessThan []interface{}) (sql.IndexLookup, error) {
44+
func (i *MergeableIndex) AscendRange(greaterOrEqual, lessThan []interface{}) (sql.IndexLookup, error) {
4045
return &AscendIndexLookup{Gte: greaterOrEqual, Lt: lessThan, Index: i}, nil
4146
}
4247

43-
func (i *MergeableDummyIndex) DescendGreater(keys ...interface{}) (sql.IndexLookup, error) {
48+
func (i *MergeableIndex) DescendGreater(keys ...interface{}) (sql.IndexLookup, error) {
4449
return &DescendIndexLookup{Gt: keys, Index: i}, nil
4550
}
4651

47-
func (i *MergeableDummyIndex) DescendLessOrEqual(keys ...interface{}) (sql.IndexLookup, error) {
52+
func (i *MergeableIndex) DescendLessOrEqual(keys ...interface{}) (sql.IndexLookup, error) {
4853
return &DescendIndexLookup{Lte: keys, Index: i}, nil
4954
}
5055

51-
func (i *MergeableDummyIndex) DescendRange(lessOrEqual, greaterThan []interface{}) (sql.IndexLookup, error) {
56+
func (i *MergeableIndex) DescendRange(lessOrEqual, greaterThan []interface{}) (sql.IndexLookup, error) {
5257
return &DescendIndexLookup{Gt: greaterThan, Lte: lessOrEqual, Index: i}, nil
5358
}
5459

55-
func (i *MergeableDummyIndex) Not(keys ...interface{}) (sql.IndexLookup, error) {
60+
func (i *MergeableIndex) Not(keys ...interface{}) (sql.IndexLookup, error) {
5661
lookup, err := i.Get(keys...)
5762
if err != nil {
5863
return nil, err
@@ -62,15 +67,15 @@ func (i *MergeableDummyIndex) Not(keys ...interface{}) (sql.IndexLookup, error)
6267
return &NegateIndexLookup{Lookup: mergeable, Index: mergeable.Index}, nil
6368
}
6469

65-
func (i *MergeableDummyIndex) Get(key ...interface{}) (sql.IndexLookup, error) {
70+
func (i *MergeableIndex) Get(key ...interface{}) (sql.IndexLookup, error) {
6671
return &MergeableIndexLookup{Key: key, Index: i}, nil
6772
}
6873

69-
func (i *MergeableDummyIndex) Has(sql.Partition, ...interface{}) (bool, error) {
74+
func (i *MergeableIndex) Has(sql.Partition, ...interface{}) (bool, error) {
7075
panic("not implemented")
7176
}
7277

73-
func (i *MergeableDummyIndex) ID() string {
78+
func (i *MergeableIndex) ID() string {
7479
if len(i.Exprs) == 1 {
7580
return i.Exprs[0].String()
7681
}
@@ -82,7 +87,7 @@ func (i *MergeableDummyIndex) ID() string {
8287
return "(" + strings.Join(parts, ", ") + ")"
8388
}
8489

85-
func (i *MergeableDummyIndex) Table() string { return i.TableName }
90+
func (i *MergeableIndex) Table() string { return i.TableName }
8691

8792
// All lookups in this package, except for UnmergeableLookup, are MergeableLookups. The IDs are mostly for testing /
8893
// verification purposes.
@@ -125,7 +130,7 @@ func (i *MergeableIndexLookup) Values(p sql.Partition) (sql.IndexValueIter, erro
125130
exprs = append(exprs, expression.NewEquals(expr, expression.NewLiteral(lit, typ)))
126131
}
127132

128-
return &dummyIndexValueIter{
133+
return &indexValIter{
129134
tbl: i.Index.MemTable(),
130135
partition: p,
131136
matchExpression: and(exprs...),
@@ -254,7 +259,7 @@ func (m *MergedIndexLookup) IsMergeable(lookup sql.IndexLookup) bool {
254259
}
255260

256261
func (m *MergedIndexLookup) Values(p sql.Partition) (sql.IndexValueIter, error) {
257-
return &dummyIndexValueIter{
262+
return &indexValIter{
258263
tbl: m.Index.MemTable(),
259264
partition: p,
260265
matchExpression: m.EvalExpression(),

‎memory/negative_index.go

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,7 @@ var _ memoryIndexLookup = (*NegateIndexLookup)(nil)
1515
func (l *NegateIndexLookup) ID() string { return "not " + l.Lookup.ID() }
1616

1717
func (l *NegateIndexLookup) Values(p sql.Partition) (sql.IndexValueIter, error) {
18-
return &dummyIndexValueIter{
18+
return &indexValIter{
1919
tbl: l.Index.MemTable(),
2020
partition: p,
2121
matchExpression: l.EvalExpression(),

‎memory/unmergeable_index.go

Lines changed: 16 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -11,26 +11,28 @@ import (
1111
// A very dumb index that iterates over the rows of a table, evaluates its matching expressions against each row, and
1212
// stores those values to be later retrieved. Only here to test the functionality of indexed queries. This kind of index
1313
// cannot be merged with any other index.
14-
type UnmergeableDummyIndex struct {
14+
type UnmergeableIndex struct {
1515
DB string // required for engine tests with driver
1616
DriverName string // required for engine tests with driver
1717
Tbl *Table // required for engine tests with driver
1818
TableName string
1919
Exprs []sql.Expression
2020
}
2121

22-
func (u *UnmergeableDummyIndex) Database() string { return u.DB }
23-
func (u *UnmergeableDummyIndex) Driver() string { return u.DriverName }
22+
var _ sql.Index = (*UnmergeableIndex)(nil)
2423

25-
func (u *UnmergeableDummyIndex) Expressions() []string {
24+
func (u *UnmergeableIndex) Database() string { return u.DB }
25+
func (u *UnmergeableIndex) Driver() string { return u.DriverName }
26+
27+
func (u *UnmergeableIndex) Expressions() []string {
2628
var exprs []string
2729
for _, e := range u.Exprs {
2830
exprs = append(exprs, e.String())
2931
}
3032
return exprs
3133
}
3234

33-
func (u *UnmergeableDummyIndex) Get(key ...interface{}) (sql.IndexLookup, error) {
35+
func (u *UnmergeableIndex) Get(key ...interface{}) (sql.IndexLookup, error) {
3436
return &UnmergeableIndexLookup{
3537
key: key,
3638
idx: u,
@@ -41,21 +43,21 @@ func (u *UnmergeableDummyIndex) Get(key ...interface{}) (sql.IndexLookup, error)
4143
// can't be merged with other lookups.
4244
type UnmergeableIndexLookup struct {
4345
key []interface{}
44-
idx *UnmergeableDummyIndex
46+
idx *UnmergeableIndex
4547
}
4648

4749
// dummyIndexValueIter does a very simple and verifiable iteration over the table values for a given index. It does this
4850
// by iterating over all the table rows for a partition and evaluating each of them for inclusion in the index. This is
4951
// not an efficient way to store an index, and is only suitable for testing the correctness of index code in the engine.
50-
type dummyIndexValueIter struct {
52+
type indexValIter struct {
5153
tbl *Table
5254
partition sql.Partition
5355
matchExpression sql.Expression
5456
values [][]byte
5557
i int
5658
}
5759

58-
func (u *dummyIndexValueIter) Next() ([]byte, error) {
60+
func (u *indexValIter) Next() ([]byte, error) {
5961
err := u.initValues()
6062
if err != nil {
6163
return nil, err
@@ -70,7 +72,7 @@ func (u *dummyIndexValueIter) Next() ([]byte, error) {
7072
return nil, io.EOF
7173
}
7274

73-
func (u *dummyIndexValueIter) initValues() error {
75+
func (u *indexValIter) initValues() error {
7476
if u.values == nil {
7577
rows, ok := u.tbl.partitions[string(u.partition.Key())]
7678
if !ok {
@@ -130,7 +132,7 @@ func getType(val interface{}) (interface{}, sql.Type) {
130132
}
131133
}
132134

133-
func (u *dummyIndexValueIter) Close() error {
135+
func (u *indexValIter) Close() error {
134136
return nil
135137
}
136138

@@ -141,7 +143,7 @@ func (u *UnmergeableIndexLookup) Values(p sql.Partition) (sql.IndexValueIter, er
141143
exprs = append(exprs, expression.NewEquals(expr, expression.NewLiteral(lit, typ)))
142144
}
143145

144-
return &dummyIndexValueIter{
146+
return &indexValIter{
145147
tbl: u.idx.Tbl,
146148
partition: p,
147149
matchExpression: and(exprs...),
@@ -156,11 +158,11 @@ func (u *UnmergeableIndexLookup) Indexes() []string {
156158
return idxes
157159
}
158160

159-
func (u *UnmergeableDummyIndex) Has(partition sql.Partition, key ...interface{}) (bool, error) {
161+
func (u *UnmergeableIndex) Has(partition sql.Partition, key ...interface{}) (bool, error) {
160162
panic("unimplemented")
161163
}
162164

163-
func (u *UnmergeableDummyIndex) ID() string {
165+
func (u *UnmergeableIndex) ID() string {
164166
if len(u.Exprs) == 1 {
165167
return u.Exprs[0].String()
166168
}
@@ -172,6 +174,6 @@ func (u *UnmergeableDummyIndex) ID() string {
172174
return "(" + strings.Join(parts, ", ") + ")"
173175
}
174176

175-
func (u *UnmergeableDummyIndex) Table() string {
177+
func (u *UnmergeableIndex) Table() string {
176178
return u.TableName
177179
}

‎sql/analyzer/assign_indexes_test.go

Lines changed: 14 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@ func TestNegateIndex(t *testing.T) {
1414
require := require.New(t)
1515

1616
catalog := sql.NewCatalog()
17-
idx1 := &memory.MergeableDummyIndex{
17+
idx1 := &memory.MergeableIndex{
1818
TableName: "t1",
1919
Exprs: []sql.Expression{
2020
expression.NewGetFieldWithTable(0, sql.Int64, "t1", "foo", false),
@@ -59,7 +59,7 @@ func TestAssignIndexes(t *testing.T) {
5959
require := require.New(t)
6060

6161
catalog := sql.NewCatalog()
62-
idx1 := &memory.MergeableDummyIndex{
62+
idx1 := &memory.MergeableIndex{
6363
TableName: "t2",
6464
Exprs: []sql.Expression{
6565
expression.NewGetFieldWithTable(0, sql.Int64, "t2", "bar", false),
@@ -70,7 +70,7 @@ func TestAssignIndexes(t *testing.T) {
7070
close(done)
7171
<-ready
7272

73-
idx2 := &memory.MergeableDummyIndex{
73+
idx2 := &memory.MergeableIndex{
7474
TableName: "t1",
7575
Exprs: []sql.Expression{
7676
expression.NewGetFieldWithTable(0, sql.Int64, "t1", "foo", false),
@@ -82,7 +82,7 @@ func TestAssignIndexes(t *testing.T) {
8282
close(done)
8383
<-ready
8484

85-
idx3 := &memory.UnmergeableDummyIndex{
85+
idx3 := &memory.UnmergeableIndex{
8686
TableName: "t1",
8787
Exprs: []sql.Expression{
8888
expression.NewGetFieldWithTable(0, sql.Int64, "t1", "bar", false),
@@ -230,35 +230,35 @@ func mergeableIndexLookup(table string, column string, colIdx int, key ...interf
230230
}
231231
}
232232

233-
func mergeableIndex(table string, column string, colIdx int) *memory.MergeableDummyIndex {
234-
return &memory.MergeableDummyIndex{
233+
func mergeableIndex(table string, column string, colIdx int) *memory.MergeableIndex {
234+
return &memory.MergeableIndex{
235235
TableName: table,
236236
Exprs: []sql.Expression{col(colIdx, table, column)},
237237
}
238238
}
239239

240240
func TestGetIndexes(t *testing.T) {
241241
indexes := []sql.Index {
242-
&memory.MergeableDummyIndex{
242+
&memory.MergeableIndex{
243243
TableName: "t1",
244244
Exprs: []sql.Expression{
245245
col(0, "t1", "bar"),
246246
},
247247
},
248-
&memory.MergeableDummyIndex{
248+
&memory.MergeableIndex{
249249
TableName: "t2",
250250
Exprs: []sql.Expression{
251251
col(0, "t2", "foo"),
252252
col(0, "t2", "bar"),
253253
},
254254
},
255-
&memory.MergeableDummyIndex{
255+
&memory.MergeableIndex{
256256
TableName: "t2",
257257
Exprs: []sql.Expression{
258258
col(0, "t2", "bar"),
259259
},
260260
},
261-
&memory.UnmergeableDummyIndex{
261+
&memory.UnmergeableIndex{
262262
TableName: "t3",
263263
Exprs: []sql.Expression{
264264
col(0, "t3", "foo"),
@@ -504,7 +504,7 @@ func TestGetIndexes(t *testing.T) {
504504
"t2": &indexLookup{
505505
&memory.MergeableIndexLookup{
506506
Key: []interface{}{int64(1), int64(2)},
507-
Index: &memory.MergeableDummyIndex{
507+
Index: &memory.MergeableIndex{
508508
TableName: "t2",
509509
Exprs: []sql.Expression{
510510
col(0, "t2", "foo"),
@@ -556,7 +556,7 @@ func TestGetIndexes(t *testing.T) {
556556
mergeableIndexLookup("t2", "bar", 0, int64(5)),
557557
&memory.MergeableIndexLookup{
558558
Key: []interface{}{int64(1), int64(2)},
559-
Index: &memory.MergeableDummyIndex{
559+
Index: &memory.MergeableIndex{
560560
TableName: "t2",
561561
Exprs: []sql.Expression{
562562
col(0, "t2", "foo"),
@@ -918,7 +918,7 @@ func TestGetMultiColumnIndexes(t *testing.T) {
918918
require := require.New(t)
919919

920920
catalog := sql.NewCatalog()
921-
indexes := []*memory.MergeableDummyIndex{
921+
indexes := []*memory.MergeableIndex{
922922
{
923923
TableName: "t1",
924924
Exprs: []sql.Expression{
@@ -1134,16 +1134,10 @@ func (DummyIndexLookup) Values(sql.Partition) (sql.IndexValueIter, error) {
11341134
return nil, nil
11351135
}
11361136

1137-
var _ sql.Index = (*memory.MergeableDummyIndex)(nil)
1138-
var _ sql.Index = (*memory.UnmergeableDummyIndex)(nil)
1139-
var _ sql.AscendIndex = (*memory.MergeableDummyIndex)(nil)
1140-
var _ sql.DescendIndex = (*memory.MergeableDummyIndex)(nil)
1141-
var _ sql.NegateIndex = (*memory.MergeableDummyIndex)(nil)
1142-
11431137
func TestIndexesIntersection(t *testing.T) {
11441138
require := require.New(t)
11451139

1146-
idx1, idx2 := &memory.MergeableDummyIndex{TableName: "bar"}, &memory.MergeableDummyIndex{TableName: "foo"}
1140+
idx1, idx2 := &memory.MergeableIndex{TableName: "bar"}, &memory.MergeableIndex{TableName: "foo"}
11471141

11481142
left := map[string]*indexLookup{
11491143
"a": &indexLookup{&memory.MergeableIndexLookup{Key: []interface{}{"a"}}, nil},

0 commit comments

Comments
 (0)