gibheer
/
bleve
0
0
Fork 0
Code

Revert "refactor to use less panics, return more errors" 

This reverts commit dec37fed07.
This commit is contained in:
Marty Schoch 2014-04-18 16:09:34 -04:00
parent dec37fed07
commit bb2f66be92
4 changed files with 58 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
index/upside_down/reader.go
View File

@ -29,20 +29,12 @@ func newUpsideDownCouchTermFieldReader(index *UpsideDownCouch, term []byte, fiel
it := index.db.NewIterator(ro)
tfr := NewTermFrequencyRow(term, field, "", 0, 0)
tfrkey, err := tfr.Key()
if err != nil {
return nil, err
}
it.Seek(tfrkey)
it.Seek(tfr.Key())
var count uint64 = 0
if it.Valid() {
if bytes.Equal(it.Key(), tfrkey) {
if bytes.Equal(it.Key(), tfr.Key()) {
tfr = ParseFromKeyValue(it.Key(), it.Value()).(*TermFrequencyRow)
tfrkey, err = tfr.Key()
if err != nil {
return nil, err
}
count = tfr.freq
}
@ -67,11 +59,7 @@ func (r *UpsideDownCouchTermFieldReader) Next() (*index.TermFieldDoc, error) {
r.iterator.Next()
if r.iterator.Valid() {
tfr := NewTermFrequencyRow(r.term, r.field, "", 0, 0)
tfrkey, err := tfr.Key()
if err != nil {
return nil, err
}
if !bytes.HasPrefix(r.iterator.Key(), tfrkey) {
if !bytes.HasPrefix(r.iterator.Key(), tfr.Key()) {
// end of the line
return nil, nil
}
@ -89,18 +77,10 @@ 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)
tfrkey, err := tfr.Key()
if err != nil {
return nil, err
}
r.iterator.Seek(tfrkey)
r.iterator.Seek(tfr.Key())
if r.iterator.Valid() {
tfr := NewTermFrequencyRow(r.term, r.field, "", 0, 0)
tfrkey, err := tfr.Key()
if err != nil {
return nil, err
}
if !bytes.HasPrefix(r.iterator.Key(), tfrkey) {
if !bytes.HasPrefix(r.iterator.Key(), tfr.Key()) {
// 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, error)
Value() ([]byte, error)
Key() []byte
Value() []byte
}
func ParseFromKeyValue(key, value []byte) UpsideDownCouchRow {
@ -44,18 +44,17 @@ type VersionRow struct {
version uint8
}
func (v *VersionRow) Key() ([]byte, error) {
return []byte{'v'}, nil
func (v *VersionRow) Key() []byte {
return []byte{'v'}
}
func (v *VersionRow) Value() ([]byte, error) {
func (v *VersionRow) Value() []byte {
buf := new(bytes.Buffer)
err := binary.Write(buf, binary.LittleEndian, v.version)
if err != nil {
//panic(fmt.Sprintf("binary.Write failed: %v", err))
return nil, err
panic(fmt.Sprintf("binary.Write failed: %v", err))
}
return buf.Bytes(), nil
return buf.Bytes()
}
func (v *VersionRow) String() string {
@ -85,30 +84,30 @@ type FieldRow struct {
name string
}
func (f *FieldRow) Key() ([]byte, error) {
func (f *FieldRow) Key() []byte {
buf := new(bytes.Buffer)
err := buf.WriteByte('f')
if err != nil {
return nil, err
panic(fmt.Sprintf("Buffer.WriteByte failed: %v", err))
}
err = binary.Write(buf, binary.LittleEndian, f.index)
if err != nil {
return nil, err
panic(fmt.Sprintf("binary.Write failed: %v", err))
}
return buf.Bytes(), nil
return buf.Bytes()
}
func (f *FieldRow) Value() ([]byte, error) {
func (f *FieldRow) Value() []byte {
buf := new(bytes.Buffer)
_, err := buf.WriteString(f.name)
if err != nil {
return nil, err
panic(fmt.Sprintf("Buffer.WriteString failed: %v", err))
}
err = buf.WriteByte(BYTE_SEPARATOR)
if err != nil {
return nil, err
panic(fmt.Sprintf("Buffer.WriteByte failed: %v", err))
}
return buf.Bytes(), nil
return buf.Bytes()
}
func (f *FieldRow) String() string {
@ -164,60 +163,60 @@ type TermFrequencyRow struct {
vectors []*TermVector
}
func (tfr *TermFrequencyRow) Key() ([]byte, error) {
func (tfr *TermFrequencyRow) Key() []byte {
buf := new(bytes.Buffer)
err := buf.WriteByte('t')
if err != nil {
return nil, err
panic(fmt.Sprintf("Buffer.WriteByte failed: %v", err))
}
_, err = buf.Write(tfr.term)
if err != nil {
return nil, err
panic(fmt.Sprintf("Buffer.Write failed: %v", err))
}
err = buf.WriteByte(BYTE_SEPARATOR)
if err != nil {
return nil, err
panic(fmt.Sprintf("Buffer.WriteByte failed: %v", err))
}
err = binary.Write(buf, binary.LittleEndian, tfr.field)
if err != nil {
return nil, err
panic(fmt.Sprintf("binary.Write failed: %v", err))
}
_, err = buf.Write(tfr.doc)
if err != nil {
return nil, err
panic(fmt.Sprintf("Buffer.Write failed: %v", err))
}
return buf.Bytes(), nil
return buf.Bytes()
}
func (tfr *TermFrequencyRow) Value() ([]byte, error) {
func (tfr *TermFrequencyRow) Value() []byte {
buf := new(bytes.Buffer)
err := binary.Write(buf, binary.LittleEndian, tfr.freq)
if err != nil {
return nil, err
panic(fmt.Sprintf("binary.Write failed: %v", err))
}
err = binary.Write(buf, binary.LittleEndian, tfr.norm)
if err != nil {
return nil, err
panic(fmt.Sprintf("binary.Write failed: %v", err))
}
for _, vector := range tfr.vectors {
err = binary.Write(buf, binary.LittleEndian, vector.field)
if err != nil {
return nil, err
panic(fmt.Sprintf("binary.Write failed: %v", err))
}
err = binary.Write(buf, binary.LittleEndian, vector.pos)
if err != nil {
return nil, err
panic(fmt.Sprintf("binary.Write failed: %v", err))
}
err = binary.Write(buf, binary.LittleEndian, vector.start)
if err != nil {
return nil, err
panic(fmt.Sprintf("binary.Write failed: %v", err))
}
err = binary.Write(buf, binary.LittleEndian, vector.end)
if err != nil {
return nil, err
panic(fmt.Sprintf("binary.Write failed: %v", err))
}
}
return buf.Bytes(), nil
return buf.Bytes()
}
func (tfr *TermFrequencyRow) String() string {
@ -330,36 +329,36 @@ type BackIndexRow struct {
entries []*BackIndexEntry
}
func (br *BackIndexRow) Key() ([]byte, error) {
func (br *BackIndexRow) Key() []byte {
buf := new(bytes.Buffer)
err := buf.WriteByte('b')
if err != nil {
return nil, err
panic(fmt.Sprintf("Buffer.WriteByte failed: %v", err))
}
err = binary.Write(buf, binary.LittleEndian, br.doc)
if err != nil {
return nil, err
panic(fmt.Sprintf("binary.Write failed: %v", err))
}
return buf.Bytes(), nil
return buf.Bytes()
}
func (br *BackIndexRow) Value() ([]byte, error) {
func (br *BackIndexRow) Value() []byte {
buf := new(bytes.Buffer)
for _, e := range br.entries {
_, err := buf.Write(e.term)
if err != nil {
return nil, err
panic(fmt.Sprintf("Buffer.Write failed: %v", err))
}
err = buf.WriteByte(BYTE_SEPARATOR)
if err != nil {
return nil, err
panic(fmt.Sprintf("Buffer.WriteByte failed: %v", err))
}
err = binary.Write(buf, binary.LittleEndian, e.field)
if err != nil {
return nil, err
panic(fmt.Sprintf("binary.Write failed: %v", err))
}
}
return buf.Bytes(), nil
return buf.Bytes()
}
func (br *BackIndexRow) String() string {

10
index/upside_down/row_test.go
View File

@ -68,17 +68,11 @@ func TestRows(t *testing.T) {
// test going from struct to k/v bytes
for _, test := range tests {
rk, err := test.input.Key()
if err != nil {
t.Error(err)
}
rk := test.input.Key()
if !reflect.DeepEqual(rk, test.outKey) {
t.Errorf("Expected key to be %v got: %v", test.outKey, rk)
}
rv, err := test.input.Value()
if err != nil {
t.Error(err)
}
rv := test.input.Value()
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,50 +99,26 @@ func (udc *UpsideDownCouch) batchRows(addRows []UpsideDownCouchRow, updateRows [
if ok {
// need to increment counter
tr := NewTermFrequencyRow(tfr.term, tfr.field, "", 0, 0)
trkey, err := tr.Key()
if err != nil {
return err
}
val, err := udc.db.Get(ro, trkey)
val, err := udc.db.Get(ro, tr.Key())
if err != nil {
return err
}
if val != nil {
tr = ParseFromKeyValue(trkey, val).(*TermFrequencyRow)
tr = ParseFromKeyValue(tr.Key(), val).(*TermFrequencyRow)
tr.freq += 1 // incr
} else {
tr = NewTermFrequencyRow(tfr.term, tfr.field, "", 1, 0)
}
// now add this to the batch
trval, err := tr.Value()
if err != nil {
return err
}
wb.Put(trkey, trval)
wb.Put(tr.Key(), tr.Value())
}
rowkey, err := row.Key()
if err != nil {
return err
}
rowval, err := row.Value()
if err != nil {
return err
}
wb.Put(rowkey, rowval)
wb.Put(row.Key(), row.Value())
}
// update
for _, row := range updateRows {
rowkey, err := row.Key()
if err != nil {
return err
}
rowval, err := row.Value()
if err != nil {
return err
}
wb.Put(rowkey, rowval)
wb.Put(row.Key(), row.Value())
}
// delete
@ -151,38 +127,26 @@ func (udc *UpsideDownCouch) batchRows(addRows []UpsideDownCouchRow, updateRows [
if ok {
// need to decrement counter
tr := NewTermFrequencyRow(tfr.term, tfr.field, "", 0, 0)
trkey, err := tr.Key()
if err != nil {
return err
}
val, err := udc.db.Get(ro, trkey)
val, err := udc.db.Get(ro, tr.Key())
if err != nil {
return err
}
if val != nil {
tr = ParseFromKeyValue(trkey, val).(*TermFrequencyRow)
tr = ParseFromKeyValue(tr.Key(), val).(*TermFrequencyRow)
tr.freq -= 1 // incr
} else {
return fmt.Errorf("unexpected missing row, deleting term, expected count row to exit: %v", trkey)
log.Panic(fmt.Sprintf("unexpected missing row, deleting term, expected count row to exit: %v", tr.Key()))
}
if tr.freq == 0 {
wb.Delete(trkey)
wb.Delete(tr.Key())
} else {
// now add this to the batch
trval, err := tr.Value()
if err != nil {
return err
}
wb.Put(trkey, trval)
wb.Put(tr.Key(), tr.Value())
}
}
rowkey, err := row.Key()
if err != nil {
return err
}
wb.Delete(rowkey)
wb.Delete(row.Key())
}
// write out the batch
@ -403,10 +367,7 @@ func (udc *UpsideDownCouch) backIndexRowForDoc(docId string) (*BackIndexRow, err
tempRow := &BackIndexRow{
doc: []byte(docId),
}
key, err := tempRow.Key()
if err != nil {
return nil, err
}
key := tempRow.Key()
value, err := udc.db.Get(ro, key)
if err != nil {
return nil, err