Skip to content
This repository was archived by the owner on Jan 28, 2021. It is now read-only.

Commit 2da211e

Browse files
ajnavarroajnavarro
authored
Merge pull request #550 from kuba--/fix-filteredindex
Fix filtered index
2 parents cd34c1a + 04ae740 commit 2da211e

File tree

3 files changed

+149
-38
lines changed

3 files changed

+149
-38
lines changed

‎sql/index/pilosa/driver.go‎

Lines changed: 0 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -498,15 +498,6 @@ func (b *bitBatch) Add(row, col uint64) {
498498
b.cols = append(b.cols, col)
499499
}
500500

501-
func (b *bitBatch) NextRecord() (uint64, uint64, error) {
502-
if b.pos >= uint64(len(b.rows)) {
503-
return 0, 0, io.EOF
504-
}
505-
506-
b.pos++
507-
return b.rows[b.pos-1], b.cols[b.pos-1], nil
508-
}
509-
510501
func indexName(db, table string) string {
511502
h := sha1.New()
512503
io.WriteString(h, db)

‎sql/index/pilosa/driver_test.go‎

Lines changed: 82 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1041,6 +1041,88 @@ func TestNegateIndex(t *testing.T) {
10411041
require.Equal(expected, values)
10421042
}
10431043

1044+
func TestEqualAndLessIndex(t *testing.T) {
1045+
require := require.New(t)
1046+
setup(t)
1047+
defer cleanup(t)
1048+
1049+
ctx := sql.NewContext(context.Background())
1050+
db, table := "db_name", "table_name"
1051+
d := NewDriver(tmpDir)
1052+
1053+
idxEqA, err := d.Create(db, table, "idx_eq_a", makeExpressions(table, "a"), nil)
1054+
require.NoError(err)
1055+
pilosaIdxEqA, ok := idxEqA.(*pilosaIndex)
1056+
require.True(ok)
1057+
itA := &fixturePartitionKeyValueIter{
1058+
fixtures: []partitionKeyValueFixture{
1059+
{
1060+
testPartition(0),
1061+
[]kvfixture{
1062+
{"1", []interface{}{int64(2)}},
1063+
{"2", []interface{}{int64(7)}},
1064+
{"3", []interface{}{int64(1)}},
1065+
{"4", []interface{}{int64(1)}},
1066+
{"5", []interface{}{int64(1)}},
1067+
{"6", []interface{}{int64(10)}},
1068+
{"7", []interface{}{int64(5)}},
1069+
{"8", []interface{}{int64(6)}},
1070+
{"9", []interface{}{int64(4)}},
1071+
{"10", []interface{}{int64(1)}},
1072+
},
1073+
},
1074+
},
1075+
}
1076+
err = d.Save(ctx, pilosaIdxEqA, itA)
1077+
require.NoError(err)
1078+
eqALookup, err := pilosaIdxEqA.Get(int64(1))
1079+
require.NoError(err)
1080+
1081+
values, err := lookupValues(eqALookup)
1082+
require.NoError(err)
1083+
expected := []string{"3", "4", "5", "10"}
1084+
require.Equal(expected, values)
1085+
1086+
idxLessB, err := d.Create(db, table, "idx_less_b", makeExpressions(table, "b"), nil)
1087+
require.NoError(err)
1088+
pilosaIdxLessB, ok := idxLessB.(*pilosaIndex)
1089+
require.True(ok)
1090+
itB := &fixturePartitionKeyValueIter{
1091+
fixtures: []partitionKeyValueFixture{
1092+
{
1093+
testPartition(0),
1094+
[]kvfixture{
1095+
{"1", []interface{}{int64(1)}},
1096+
{"2", []interface{}{int64(2)}},
1097+
{"3", []interface{}{int64(3)}},
1098+
{"4", []interface{}{int64(4)}},
1099+
{"5", []interface{}{int64(5)}},
1100+
{"6", []interface{}{int64(6)}},
1101+
{"7", []interface{}{int64(7)}},
1102+
{"8", []interface{}{int64(8)}},
1103+
{"9", []interface{}{int64(9)}},
1104+
{"10", []interface{}{int64(10)}},
1105+
},
1106+
},
1107+
},
1108+
}
1109+
err = d.Save(ctx, pilosaIdxLessB, itB)
1110+
require.NoError(err)
1111+
lessB, err := pilosaIdxLessB.AscendLessThan(int64(5))
1112+
require.NoError(err)
1113+
lessBLookup := lessB.(*ascendLookup)
1114+
1115+
values, err = lookupValues(lessBLookup)
1116+
require.NoError(err)
1117+
expected = []string{"1", "2", "3", "4"}
1118+
require.Equal(expected, values)
1119+
1120+
interLookup := eqALookup.(sql.SetOperations).Intersection(lessBLookup)
1121+
values, err = lookupValues(interLookup)
1122+
require.NoError(err)
1123+
expected = []string{"3", "4"}
1124+
require.Equal(expected, values)
1125+
}
10441126
func TestPilosaHolder(t *testing.T) {
10451127
require := require.New(t)
10461128
setup(t)

‎sql/index/pilosa/lookup.go‎

Lines changed: 67 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -80,15 +80,7 @@ func (l *indexLookup) indexName() string {
8080
return l.index.Name()
8181
}
8282

83-
func (l *indexLookup) values(p sql.Partition) (*pilosa.Row, error) {
84-
if err := l.mapping.open(); err != nil {
85-
return nil, err
86-
}
87-
defer l.mapping.close()
88-
89-
if err := l.index.Open(); err != nil {
90-
return nil, err
91-
}
83+
func (l *indexLookup) intersectExpressions(p sql.Partition) (*pilosa.Row, error) {
9284
var row *pilosa.Row
9385
for i, expr := range l.expressions {
9486
field := l.index.Field(fieldName(l.id, expr, p))
@@ -107,7 +99,25 @@ func (l *indexLookup) values(p sql.Partition) (*pilosa.Row, error) {
10799

108100
row = intersect(row, r)
109101
}
110-
if err := l.index.Close(); err != nil {
102+
return row, nil
103+
}
104+
105+
func (l *indexLookup) values(p sql.Partition) (*pilosa.Row, error) {
106+
if err := l.mapping.open(); err != nil {
107+
return nil, err
108+
}
109+
defer l.mapping.close()
110+
111+
if err := l.index.Open(); err != nil {
112+
return nil, err
113+
}
114+
row, err := l.intersectExpressions(p)
115+
if e := l.index.Close(); e != nil {
116+
if err == nil {
117+
err = e
118+
}
119+
}
120+
if err != nil {
111121
return nil, err
112122
}
113123

@@ -213,14 +223,10 @@ func (l *filteredLookup) indexName() string {
213223
return l.index.Name()
214224
}
215225

216-
func (l *filteredLookup) values(p sql.Partition) (*pilosa.Row, error) {
217-
if err := l.mapping.open(); err != nil {
218-
return nil, err
219-
}
220-
defer l.mapping.close()
221-
222-
// evaluate Intersection of bitmaps
226+
// evaluate Intersection of bitmaps
227+
func (l *filteredLookup) intersectExpressions(p sql.Partition) (*pilosa.Row, error) {
223228
var row *pilosa.Row
229+
224230
for i, expr := range l.expressions {
225231
field := l.index.Field(fieldName(l.id, expr, p))
226232
rows, err := l.mapping.filter(field.Name(), func(b []byte) (bool, error) {
@@ -242,6 +248,28 @@ func (l *filteredLookup) values(p sql.Partition) (*pilosa.Row, error) {
242248
row = intersect(row, r)
243249
}
244250

251+
return row, nil
252+
}
253+
254+
func (l *filteredLookup) values(p sql.Partition) (*pilosa.Row, error) {
255+
if err := l.mapping.open(); err != nil {
256+
return nil, err
257+
}
258+
defer l.mapping.close()
259+
260+
if err := l.index.Open(); err != nil {
261+
return nil, err
262+
}
263+
row, err := l.intersectExpressions(p)
264+
if e := l.index.Close(); e != nil {
265+
if err == nil {
266+
err = e
267+
}
268+
}
269+
if err != nil {
270+
return nil, err
271+
}
272+
245273
// evaluate composition of operations
246274
for _, op := range l.operations {
247275
var (
@@ -269,9 +297,6 @@ func (l *filteredLookup) values(p sql.Partition) (*pilosa.Row, error) {
269297
}
270298

271299
func (l *filteredLookup) Values(p sql.Partition) (sql.IndexValueIter, error) {
272-
l.index.Open()
273-
defer l.index.Close()
274-
275300
row, err := l.values(p)
276301
if err != nil {
277302
return nil, err
@@ -359,12 +384,7 @@ type negateLookup struct {
359384

360385
func (l *negateLookup) indexName() string { return l.index.Name() }
361386

362-
func (l *negateLookup) values(p sql.Partition) (*pilosa.Row, error) {
363-
if err := l.mapping.open(); err != nil {
364-
return nil, err
365-
}
366-
defer l.mapping.close()
367-
387+
func (l *negateLookup) intersectExpressions(p sql.Partition) (*pilosa.Row, error) {
368388
var row *pilosa.Row
369389
for i, expr := range l.expressions {
370390
field := l.index.Field(fieldName(l.id, expr, p))
@@ -401,6 +421,27 @@ func (l *negateLookup) values(p sql.Partition) (*pilosa.Row, error) {
401421

402422
row = intersect(row, r)
403423
}
424+
return row, nil
425+
}
426+
427+
func (l *negateLookup) values(p sql.Partition) (*pilosa.Row, error) {
428+
if err := l.mapping.open(); err != nil {
429+
return nil, err
430+
}
431+
defer l.mapping.close()
432+
433+
if err := l.index.Open(); err != nil {
434+
return nil, err
435+
}
436+
row, err := l.intersectExpressions(p)
437+
if e := l.index.Close(); e != nil {
438+
if err == nil {
439+
err = e
440+
}
441+
}
442+
if err != nil {
443+
return nil, err
444+
}
404445

405446
// evaluate composition of operations
406447
for _, op := range l.operations {
@@ -431,9 +472,6 @@ func (l *negateLookup) values(p sql.Partition) (*pilosa.Row, error) {
431472

432473
// Values implements sql.IndexLookup.Values
433474
func (l *negateLookup) Values(p sql.Partition) (sql.IndexValueIter, error) {
434-
l.index.Open()
435-
defer l.index.Close()
436-
437475
row, err := l.values(p)
438476
if err != nil {
439477
return nil, err

0 commit comments

Comments
 (0)