func NewIterator(prefix string, d quad.Direction, value graph.Value, qs *QuadStore) *Iterator {
vb := value.(Token)
p := make([]byte, 0, 2+hashSize)
p = append(p, []byte(prefix)...)
p = append(p, []byte(vb[1:])...)
opts := &opt.ReadOptions{
DontFillCache: true,
}
it := Iterator{
uid: iterator.NextUID(),
nextPrefix: p,
checkID: vb,
dir: d,
originalPrefix: prefix,
ro: opts,
iter: qs.db.NewIterator(nil, opts),
open: true,
qs: qs,
}
ok := it.iter.Seek(it.nextPrefix)
if !ok {
it.open = false
it.iter.Release()
glog.Error("Opening LevelDB iterator couldn't seek to location ", it.nextPrefix)
}
return &it
}
func NewAllIterator(qs *QuadStore, kind string) *Iterator {
if kind != nodeKind && kind != quadKind {
glog.Error("Cannot create iterator for an unknown kind")
return &Iterator{done: true}
}
if qs.context == nil {
glog.Error("Cannot create iterator without a valid context")
return &Iterator{done: true}
}
var size int64
if kind == nodeKind {
size = qs.NodeSize()
} else {
size = qs.Size()
}
return &Iterator{
uid: iterator.NextUID(),
qs: qs,
size: size,
dir: quad.Any,
isAll: true,
kind: kind,
done: false,
}
}
func (it *Iterator) Clone() graph.Iterator {
var iter *b.Enumerator
if it.result != nil {
var ok bool
iter, ok = it.tree.Seek(it.result.(int64))
if !ok {
panic("value unexpectedly missing")
}
} else {
var err error
iter, err = it.tree.SeekFirst()
if err != nil {
iter = nil
}
}
m := &Iterator{
uid: iterator.NextUID(),
qs: it.qs,
tree: it.tree,
iter: iter,
data: it.data,
}
m.tags.CopyFrom(it)
return m
}
func NewAllIterator(bucket []byte, d quad.Direction, qs *QuadStore) *AllIterator {
return &AllIterator{
uid: iterator.NextUID(),
bucket: bucket,
dir: d,
qs: qs,
}
}
func NewAllIterator(qs *QuadStore, collection string) *Iterator {
return &Iterator{
uid: iterator.NextUID(),
qs: qs,
dir: quad.Any,
constraint: nil,
collection: collection,
iter: nil,
size: -1,
hash: "",
isAll: true,
}
}
func NewIterator(tree *b.Tree, data string, qs *QuadStore) *Iterator {
iter, err := tree.SeekFirst()
if err != nil {
iter = nil
}
return &Iterator{
uid: iterator.NextUID(),
qs: qs,
tree: tree,
iter: iter,
data: data,
}
}
func NewIterator(qs *QuadStore, collection string, d quad.Direction, val graph.Value) *Iterator {
name := qs.NameOf(val)
constraint := bson.M{d.String(): name}
return &Iterator{
uid: iterator.NextUID(),
name: name,
constraint: constraint,
collection: collection,
qs: qs,
dir: d,
iter: nil,
size: -1,
hash: val.(string),
isAll: false,
}
}
func NewIterator(bucket []byte, d quad.Direction, value graph.Value, qs *QuadStore) *Iterator {
tok := value.(*Token)
if !bytes.Equal(tok.bucket, nodeBucket) {
glog.Error("creating an iterator from a non-node value")
return &Iterator{done: true}
}
it := Iterator{
uid: iterator.NextUID(),
bucket: bucket,
dir: d,
qs: qs,
size: qs.SizeOf(value),
}
it.checkID = make([]byte, len(tok.key))
copy(it.checkID, tok.key)
return &it
}
func NewIterator(qs *QuadStore, k string, d quad.Direction, val graph.Value) *Iterator {
t := val.(*Token)
if t == nil {
glog.Error("Token == nil")
}
if t.Kind != nodeKind {
glog.Error("Cannot create an iterator from a non-node value")
return &Iterator{done: true}
}
if k != nodeKind && k != quadKind {
glog.Error("Cannot create iterator for unknown kind")
return &Iterator{done: true}
}
if qs.context == nil {
glog.Error("Cannot create iterator without a valid context")
return &Iterator{done: true}
}
name := qs.NameOf(t)
// The number of references to this node is held in the nodes entity
key := qs.createKeyFromToken(t)
foundNode := new(NodeEntry)
err := datastore.Get(qs.context, key, foundNode)
if err != nil && err != datastore.ErrNoSuchEntity {
glog.Errorf("Error: %v", err)
return &Iterator{done: true}
}
size := foundNode.Size
return &Iterator{
uid: iterator.NextUID(),
name: name,
dir: d,
qs: qs,
size: size,
isAll: false,
kind: k,
hash: t.Hash,
done: false,
}
}