gibheer
/
bleve
0
0
Fork 0
Code

refactor to use less panics, return more errors

This commit is contained in:
Marty Schoch 2014-04-18 15:54:29 -04:00
parent 144cea8367
commit dec37fed07
4 changed files with 124 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
index/upside_down/reader.go
View File

@ -29,12 +29,20 @@ func newUpsideDownCouchTermFieldReader(index *UpsideDownCouch, term []byte, fiel
it := index.db.NewIterator(ro)
tfr := NewTermFrequencyRow(term, field, "", 0, 0)
it.Seek(tfr.Key())
tfrkey, err := tfr.Key()
if err != nil {
return nil, err
}
it.Seek(tfrkey)
var count uint64 = 0
if it.Valid() {
if bytes.Equal(it.Key(), tfr.Key()) {
if bytes.Equal(it.Key(), tfrkey) {
tfr = ParseFromKeyValue(it.Key(), it.Value()).(*TermFrequencyRow)
tfrkey, err = tfr.Key()
if err != nil {
return nil, err
}
count = tfr.freq
}
@ -59,7 +67,11 @@ func (r *UpsideDownCouchTermFieldReader) Next() (*index.TermFieldDoc, error) {
r.iterator.Next()
if r.iterator.Valid() {
tfr := NewTermFrequencyRow(r.term, r.field, "", 0, 0)
if !bytes.HasPrefix(r.iterator.Key(), tfr.Key()) {
tfrkey, err := tfr.Key()
if err != nil {
return nil, err
}
if !bytes.HasPrefix(r.iterator.Key(), tfrkey) {
// end of the line
return nil, nil
}
@ -77,10 +89,18 @@ func (r *UpsideDownCouchTermFieldReader) Next() (*index.TermFieldDoc, error) {
func (r *UpsideDownCouchTermFieldReader) Advance(docId string) (*index.TermFieldDoc, error) {
tfr := NewTermFrequencyRow(r.term, r.field, docId, 0, 0)
r.iterator.Seek(tfr.Key())
tfrkey, err := tfr.Key()
if err != nil {
return nil, err
}
r.iterator.Seek(tfrkey)
if r.iterator.Valid() {
tfr := NewTermFrequencyRow(r.term, r.field, "", 0, 0)
if !bytes.HasPrefix(r.iterator.Key(), tfr.Key()) {
tfrkey, err := tfr.Key()
if err != nil {
return nil, err
}
if !bytes.HasPrefix(r.iterator.Key(), tfrkey) {
// end of the line
return nil, nil
}

79
index/upside_down/row.go
View File

@ -20,8 +20,8 @@ const BYTE_SEPARATOR byte = 0xff
type UpsideDownCouchRowStream chan UpsideDownCouchRow
type UpsideDownCouchRow interface {
Key() []byte
Value() []byte
Key() ([]byte, error)
Value() ([]byte, error)
}
func ParseFromKeyValue(key, value []byte) UpsideDownCouchRow {
@ -44,17 +44,18 @@ type VersionRow struct {
version uint8
}
func (v *VersionRow) Key() []byte {
return []byte{'v'}
func (v *VersionRow) Key() ([]byte, error) {
return []byte{'v'}, nil
}
func (v *VersionRow) Value() []byte {
func (v *VersionRow) Value() ([]byte, error) {
buf := new(bytes.Buffer)
err := binary.Write(buf, binary.LittleEndian, v.version)
if err != nil {
panic(fmt.Sprintf("binary.Write failed: %v", err))
//panic(fmt.Sprintf("binary.Write failed: %v", err))
return nil, err
}
return buf.Bytes()
return buf.Bytes(), nil
}
func (v *VersionRow) String() string {
@ -84,30 +85,30 @@ type FieldRow struct {
name string
}
func (f *FieldRow) Key() []byte {
func (f *FieldRow) Key() ([]byte, error) {
buf := new(bytes.Buffer)
err := buf.WriteByte('f')
if err != nil {
panic(fmt.Sprintf("Buffer.WriteByte failed: %v", err))
return nil, err
}
err = binary.Write(buf, binary.LittleEndian, f.index)
if err != nil {
panic(fmt.Sprintf("binary.Write failed: %v", err))
return nil, err
}
return buf.Bytes()
return buf.Bytes(), nil
}
func (f *FieldRow) Value() []byte {
func (f *FieldRow) Value() ([]byte, error) {
buf := new(bytes.Buffer)
_, err := buf.WriteString(f.name)
if err != nil {
panic(fmt.Sprintf("Buffer.WriteString failed: %v", err))
return nil, err
}
err = buf.WriteByte(BYTE_SEPARATOR)
if err != nil {
panic(fmt.Sprintf("Buffer.WriteByte failed: %v", err))
return nil, err
}
return buf.Bytes()
return buf.Bytes(), nil
}
func (f *FieldRow) String() string {
@ -163,60 +164,60 @@ type TermFrequencyRow struct {
vectors []*TermVector
}
func (tfr *TermFrequencyRow) Key() []byte {
func (tfr *TermFrequencyRow) Key() ([]byte, error) {
buf := new(bytes.Buffer)
err := buf.WriteByte('t')
if err != nil {
panic(fmt.Sprintf("Buffer.WriteByte failed: %v", err))
return nil, err
}
_, err = buf.Write(tfr.term)
if err != nil {
panic(fmt.Sprintf("Buffer.Write failed: %v", err))
return nil, err
}
err = buf.WriteByte(BYTE_SEPARATOR)
if err != nil {
panic(fmt.Sprintf("Buffer.WriteByte failed: %v", err))
return nil, err
}
err = binary.Write(buf, binary.LittleEndian, tfr.field)
if err != nil {
panic(fmt.Sprintf("binary.Write failed: %v", err))
return nil, err
}
_, err = buf.Write(tfr.doc)
if err != nil {
panic(fmt.Sprintf("Buffer.Write failed: %v", err))
return nil, err
}
return buf.Bytes()
return buf.Bytes(), nil
}
func (tfr *TermFrequencyRow) Value() []byte {
func (tfr *TermFrequencyRow) Value() ([]byte, error) {
buf := new(bytes.Buffer)
err := binary.Write(buf, binary.LittleEndian, tfr.freq)
if err != nil {
panic(fmt.Sprintf("binary.Write failed: %v", err))
return nil, err
}
err = binary.Write(buf, binary.LittleEndian, tfr.norm)
if err != nil {
panic(fmt.Sprintf("binary.Write failed: %v", err))
return nil, err
}
for _, vector := range tfr.vectors {
err = binary.Write(buf, binary.LittleEndian, vector.field)
if err != nil {
panic(fmt.Sprintf("binary.Write failed: %v", err))
return nil, err
}
err = binary.Write(buf, binary.LittleEndian, vector.pos)
if err != nil {
panic(fmt.Sprintf("binary.Write failed: %v", err))
return nil, err
}
err = binary.Write(buf, binary.LittleEndian, vector.start)
if err != nil {
panic(fmt.Sprintf("binary.Write failed: %v", err))
return nil, err
}
err = binary.Write(buf, binary.LittleEndian, vector.end)
if err != nil {
panic(fmt.Sprintf("binary.Write failed: %v", err))
return nil, err
}
}
return buf.Bytes()
return buf.Bytes(), nil
}
func (tfr *TermFrequencyRow) String() string {
@ -329,36 +330,36 @@ type BackIndexRow struct {
entries []*BackIndexEntry
}
func (br *BackIndexRow) Key() []byte {
func (br *BackIndexRow) Key() ([]byte, error) {
buf := new(bytes.Buffer)
err := buf.WriteByte('b')
if err != nil {
panic(fmt.Sprintf("Buffer.WriteByte failed: %v", err))
return nil, err
}
err = binary.Write(buf, binary.LittleEndian, br.doc)
if err != nil {
panic(fmt.Sprintf("binary.Write failed: %v", err))
return nil, err
}
return buf.Bytes()
return buf.Bytes(), nil
}
func (br *BackIndexRow) Value() []byte {
func (br *BackIndexRow) Value() ([]byte, error) {
buf := new(bytes.Buffer)
for _, e := range br.entries {
_, err := buf.Write(e.term)
if err != nil {
panic(fmt.Sprintf("Buffer.Write failed: %v", err))
return nil, err
}
err = buf.WriteByte(BYTE_SEPARATOR)
if err != nil {
panic(fmt.Sprintf("Buffer.WriteByte failed: %v", err))
return nil, err
}
err = binary.Write(buf, binary.LittleEndian, e.field)
if err != nil {
panic(fmt.Sprintf("binary.Write failed: %v", err))
return nil, err
}
}
return buf.Bytes()
return buf.Bytes(), nil
}
func (br *BackIndexRow) String() string {

10
index/upside_down/row_test.go
View File

@ -68,11 +68,17 @@ func TestRows(t *testing.T) {
// test going from struct to k/v bytes
for _, test := range tests {
rk := test.input.Key()
rk, err := test.input.Key()
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(rk, test.outKey) {
t.Errorf("Expected key to be %v got: %v", test.outKey, rk)
}
rv := test.input.Value()
rv, err := test.input.Value()
if err != nil {
t.Error(err)
}
if !reflect.DeepEqual(rv, test.outVal) {
t.Errorf("Expected value to be %v got: %v", test.outVal, rv)
}

63
index/upside_down/upside_down.go
View File

@ -99,26 +99,50 @@ func (udc *UpsideDownCouch) batchRows(addRows []UpsideDownCouchRow, updateRows [
if ok {
// need to increment counter
tr := NewTermFrequencyRow(tfr.term, tfr.field, "", 0, 0)
val, err := udc.db.Get(ro, tr.Key())
trkey, err := tr.Key()
if err != nil {
return err
}
val, err := udc.db.Get(ro, trkey)
if err != nil {
return err
}
if val != nil {
tr = ParseFromKeyValue(tr.Key(), val).(*TermFrequencyRow)
tr = ParseFromKeyValue(trkey, val).(*TermFrequencyRow)
tr.freq += 1 // incr
} else {
tr = NewTermFrequencyRow(tfr.term, tfr.field, "", 1, 0)
}
// now add this to the batch
wb.Put(tr.Key(), tr.Value())
trval, err := tr.Value()
if err != nil {
return err
}
wb.Put(trkey, trval)
}
wb.Put(row.Key(), row.Value())
rowkey, err := row.Key()
if err != nil {
return err
}
rowval, err := row.Value()
if err != nil {
return err
}
wb.Put(rowkey, rowval)
}
// update
for _, row := range updateRows {
wb.Put(row.Key(), row.Value())
rowkey, err := row.Key()
if err != nil {
return err
}
rowval, err := row.Value()
if err != nil {
return err
}
wb.Put(rowkey, rowval)
}
// delete
@ -127,26 +151,38 @@ func (udc *UpsideDownCouch) batchRows(addRows []UpsideDownCouchRow, updateRows [
if ok {
// need to decrement counter
tr := NewTermFrequencyRow(tfr.term, tfr.field, "", 0, 0)
val, err := udc.db.Get(ro, tr.Key())
trkey, err := tr.Key()
if err != nil {
return err
}
val, err := udc.db.Get(ro, trkey)
if err != nil {
return err
}
if val != nil {
tr = ParseFromKeyValue(tr.Key(), val).(*TermFrequencyRow)
tr = ParseFromKeyValue(trkey, val).(*TermFrequencyRow)
tr.freq -= 1 // incr
} else {
log.Panic(fmt.Sprintf("unexpected missing row, deleting term, expected count row to exit: %v", tr.Key()))
return fmt.Errorf("unexpected missing row, deleting term, expected count row to exit: %v", trkey)
}
if tr.freq == 0 {
wb.Delete(tr.Key())
wb.Delete(trkey)
} else {
// now add this to the batch
wb.Put(tr.Key(), tr.Value())
trval, err := tr.Value()
if err != nil {
return err
}
wb.Put(trkey, trval)
}
}
wb.Delete(row.Key())
rowkey, err := row.Key()
if err != nil {
return err
}
wb.Delete(rowkey)
}
// write out the batch
@ -367,7 +403,10 @@ func (udc *UpsideDownCouch) backIndexRowForDoc(docId string) (*BackIndexRow, err
tempRow := &BackIndexRow{
doc: []byte(docId),
}
key := tempRow.Key()
key, err := tempRow.Key()
if err != nil {
return nil, err
}
value, err := udc.db.Get(ro, key)
if err != nil {
return nil, err