func (qs *QuadStore) Quad(k graph.Value) quad.Quad {
var d proto.LogDelta
tok := k.(*Token)
err := qs.db.View(func(tx *bolt.Tx) error {
b := tx.Bucket(tok.bucket)
data := b.Get(tok.key)
if data == nil {
return nil
}
var in proto.HistoryEntry
err := in.Unmarshal(data)
if err != nil {
return err
}
if len(in.History) == 0 {
return nil
}
b = tx.Bucket(logBucket)
data = b.Get(qs.createDeltaKeyFor(int64(in.History[len(in.History)-1])))
if data == nil {
// No harm, no foul.
return nil
}
return d.Unmarshal(data)
})
if err != nil {
glog.Error("Error getting quad: ", err)
return quad.Quad{}
}
return d.Quad.ToNative()
}
func (qs *QuadStore) Quad(k graph.Value) quad.Quad {
var in proto.HistoryEntry
b, err := qs.db.Get(k.(Token), qs.readopts)
if err == leveldb.ErrNotFound {
// No harm, no foul.
return quad.Quad{}
} else if err != nil {
glog.Error("Error: could not get quad from DB.")
return quad.Quad{}
}
err = in.Unmarshal(b)
if err != nil {
glog.Error("Error: could not reconstruct history.", err)
return quad.Quad{}
}
b, err = qs.db.Get(createDeltaKeyFor(int64(in.History[len(in.History)-1])), qs.readopts)
if err == leveldb.ErrNotFound {
// No harm, no foul.
return quad.Quad{}
} else if err != nil {
glog.Error("Error: could not get quad from DB.")
return quad.Quad{}
}
var d proto.LogDelta
err = d.Unmarshal(b)
if err != nil {
glog.Error("Error: could not reconstruct quad.", err)
return quad.Quad{}
}
return d.Quad.ToNative()
}
func (qs *QuadStore) buildQuadWrite(batch *leveldb.Batch, q quad.Quad, id int64, isAdd bool) error {
var entry proto.HistoryEntry
data, err := qs.db.Get(createKeyFor(spo, q), qs.readopts)
if err != nil && err != leveldb.ErrNotFound {
glog.Error("could not access DB to prepare index: ", err)
return err
}
if data != nil {
// We got something.
err = entry.Unmarshal(data)
if err != nil {
return err
}
}
if isAdd && len(entry.History)%2 == 1 {
if glog.V(2) {
glog.Errorf("attempt to add existing quad %v: %#v", entry, q)
}
return graph.ErrQuadExists
}
if !isAdd && len(entry.History)%2 == 0 {
if glog.V(2) {
glog.Errorf("attempt to delete non-existent quad %v: %#c", entry, q)
}
return graph.ErrQuadNotExist
}
entry.History = append(entry.History, uint64(id))
bytes, err := entry.Marshal()
if err != nil {
glog.Errorf("could not write to buffer for entry %#v: %s", entry, err)
return err
}
batch.Put(createKeyFor(spo, q), bytes)
batch.Put(createKeyFor(osp, q), bytes)
batch.Put(createKeyFor(pos, q), bytes)
if q.Get(quad.Label) != nil {
batch.Put(createKeyFor(cps, q), bytes)
}
return nil
}
func (qs *QuadStore) buildQuadWrite(tx *bolt.Tx, q quad.Quad, id int64, isAdd bool) error {
var entry proto.HistoryEntry
b := tx.Bucket(spoBucket)
b.FillPercent = localFillPercent
data := b.Get(qs.createKeyFor(spo, q))
if data != nil {
// We got something.
err := entry.Unmarshal(data)
if err != nil {
return err
}
}
if isAdd && len(entry.History)%2 == 1 {
glog.Errorf("attempt to add existing quad %v: %#v", entry, q)
return graph.ErrQuadExists
}
if !isAdd && len(entry.History)%2 == 0 {
glog.Errorf("attempt to delete non-existent quad %v: %#v", entry, q)
return graph.ErrQuadNotExist
}
entry.History = append(entry.History, uint64(id))
bytes, err := entry.Marshal()
if err != nil {
glog.Errorf("Couldn't write to buffer for entry %#v: %s", entry, err)
return err
}
for _, index := range [][4]quad.Direction{spo, osp, pos, cps} {
if index == cps && q.Get(quad.Label) == nil {
continue
}
b := tx.Bucket(bucketFor(index))
b.FillPercent = localFillPercent
err = b.Put(qs.createKeyFor(index, q), bytes)
if err != nil {
return err
}
}
return nil
}
// Quad ??
func (qs *QuadStore) Quad(k graph.Value) quad.Quad {
var d proto.LogDelta
tok := k.(*Token)
err := qs.env.View(func(tx *lmdb.Txn) (err error) {
tx.RawRead = true
dbi := qs.dbis[tok.db]
data, _ := tx.Get(dbi, tok.key)
if data == nil {
return nil
}
var in proto.HistoryEntry
err = in.Unmarshal(data)
if err != nil {
return err
}
if len(in.History) == 0 {
return nil
}
data, _ = tx.Get(qs.logDBI, qs.createDeltaKeyFor(int64(in.History[len(in.History)-1])))
if data == nil {
// No harm, no foul.
return nil
}
return d.Unmarshal(data)
})
if err != nil {
glog.Error("Error getting quad: ", err)
return quad.Quad{}
}
if d.Quad == nil {
glog.Error("Unable to get quad: ", err)
return quad.Quad{}
}
return quad.Quad{
d.Quad.Subject,
d.Quad.Predicate,
d.Quad.Object,
d.Quad.Label,
}
}
func (qs *QuadStore) buildQuadWriteLMDB(tx *lmdb.Txn, q quad.Quad, id int64, isAdd bool) error {
var entry proto.HistoryEntry
dbi := qs.dbis[spoDB]
data, err := tx.Get(dbi, qs.createKeyFor(spo, q))
if err == nil {
// We got something.
err := entry.Unmarshal(data)
if err != nil {
return err
}
}
if isAdd && len(entry.History)%2 == 1 {
glog.Errorf("attempt to add existing quad %v: %#v", entry, q)
return graph.ErrQuadExists
}
if !isAdd && len(entry.History)%2 == 0 {
glog.Errorf("attempt to delete non-existent quad %v: %#v", entry, q)
return graph.ErrQuadNotExist
}
entry.History = append(entry.History, uint64(id))
bytes, err := entry.Marshal()
if err != nil {
glog.Errorf("Couldn't write to buffer for entry %#v: %s", entry, err)
return err
}
for _, index := range [][4]quad.Direction{spo, osp, pos, cps} {
if index == cps && q.Get(quad.Label) == "" {
continue
}
dbi = qs.dbis[dbFor(index)]
err = tx.Put(dbi, qs.createKeyFor(index, q), bytes, 0)
if err != nil {
return err
}
}
return nil
}
func (it *Iterator) isLiveValue(val []byte) bool {
var entry proto.HistoryEntry
entry.Unmarshal(val)
return len(entry.History)%2 != 0
}
