golang源码分析：cayley(4)

func NewMemoryGraph() (*Handle, error) {
  return NewGraph("memstore", "", nil)
}

func NewGraph(name, dbpath string, opts graph.Options) (*Handle, error) {
      qs, err := graph.NewQuadStore(name, dbpath, opts)
      qw, err := graph.NewQuadWriter("single", qs, nil)
      return &Handle{qs, qw}, nil

type Handle struct {
  graph.QuadStore
  graph.QuadWriter
}

func Unwrap(qs QuadStore) QuadStore {
  if h, ok := qs.(*Handle); ok {
    return h.QuadStore
  }
  return qs
}

type QuadWriter interface {
  // AddQuad adds a quad to the store.
  AddQuad(quad.Quad) error




  // TODO(barakmich): Deprecate in favor of transaction.
  // AddQuadSet adds a set of quads to the store, atomically if possible.
  AddQuadSet([]quad.Quad) error




  // RemoveQuad removes a quad matching the given one  from the database,
  // if it exists. Does nothing otherwise.
  RemoveQuad(quad.Quad) error




  // ApplyTransaction applies a set of quad changes.
  ApplyTransaction(*Transaction) error




  // RemoveNode removes all quads which have the given node as subject, predicate, object, or label.
  //
  // It returns ErrNodeNotExists if node is missing.
  RemoveNode(quad.Value) error




  // Close cleans up replication and closes the writing aspect of the database.
  Close() error
}

StartMorphism = path.StartMorphism
StartPath     = path.StartPath
NewTransaction = graph.NewTransaction

func StartPath(qs graph.QuadStore, nodes ...quad.Value) *Path {
  return newPath(qs, isMorphism(nodes...))
}

func isMorphism(nodes ...quad.Value) morphism {
        return morphism{
    Reversal: func(ctx *pathContext) (morphism, *pathContext) { return isMorphism(nodes...), ctx },
    Apply: func(in shape.Shape, ctx *pathContext) (shape.Shape, *pathContext) {

type morphism struct {
  IsTag    bool
  Reversal func(*pathContext) (morphism, *pathContext)
  Apply    applyMorphism
  tags     []string
}

func newPath(qs graph.QuadStore, m ...morphism) *Path {
  qs = graph.Unwrap(qs)
  return &Path{
    stack: m,
    qs:    qs,
  }

type Path struct {
  stack       []morphism
  qs          graph.QuadStore // Optionally. A nil qs is equivalent to a morphism.
  baseContext pathContext
}

func (p *Path) Out(via ...interface{}) *Path {
    np := p.clone()
    np.stack = append(np.stack, outMorphism(nil, via...))
    if len(tags) != 0 {
    via = Save{From: via, Tags: tags}
    }

func Out(from, via, labels Shape, tags ...string) Shape {
  return buildOut(from, via, labels, tags, false)
}

func buildOut(from, via, labels Shape, tags []string, in bool) Shape {
  start, goal := quad.Subject, quad.Object
  if in {
    start, goal = goal, start
  }
  if _, ok := from.(AllNodes); !ok {
    quads = append(quads, QuadFilter{
      Dir: start, Values: from,
    })
  if _, ok := via.(AllNodes); !ok {
    quads = append(quads, QuadFilter{
      Dir: quad.Predicate, Values: via,
    })
   if labels != nil {
   if _, ok := labels.(AllNodes); !ok {
      quads = append(quads, QuadFilter{
        Dir: quad.Label, Values: labels,
      })
  return NodesFrom{Quads: quads, Dir: goal}

func Iterate(ctx context.Context, qs graph.QuadStore, s Shape) *graph.IterateChain {
  it := BuildIterator(qs, s)
  return graph.Iterate(ctx, it).On(qs)

type Quads []QuadFilter
type QuadFilter struct {
  Dir    quad.Direction
  Values Shape
}    

type Shape interface {
  // BuildIterator constructs an iterator tree from a given shapes and binds it to QuadStore.
  BuildIterator(qs graph.QuadStore) graph.Iterator
  // Optimize runs an optimization pass over a query shape.
  //
  // It returns a bool that indicates if shape was replaced and should always return a copy of shape in this case.
  // In case no optimizations were made, it returns the same unmodified shape.
  //
  // If Optimizer is specified, it will be used instead of default optimizations.
  Optimize(r Optimizer) (Shape, bool)
}

func BuildIterator(qs graph.QuadStore, s Shape) graph.Iterator {
      qs = graph.Unwrap(qs)
      return s.BuildIterator(qs)

func (p *Path) Iterate(ctx context.Context) *graph.IterateChain {
  return shape.Iterate(ctx, p.qs, p.Shape())

type IterateChain struct {
  ctx context.Context
  s   IteratorShape
  it  Scanner
  qs  QuadStore




  paths    bool
  optimize bool




  limit int
  n     int
}

func Iterate(ctx context.Context, it Iterator) *IterateChain {
        return &IterateChain{
    ctx: ctx, s: AsShape(it),
    limit: -1, paths: true,
    optimize: true,
  }

func (c *IterateChain) On(qs QuadStore) *IterateChain {
        c.qs = qs
  return c

func (c *IterateChain) EachValue(qs QuadStore, fnc func(quad.Value)) error {
        return c.Each(func(v Ref) {
    if nv := c.qs.NameOf(v); nv != nil {
      fnc(nv)
    }
  })

func (c *IterateChain) Each(fnc func(Ref)) error {
  c.start()
  defer c.end()
  for c.next() {
    select {
    case <-done:
      return c.ctx.Err()
    default:
    }
    fnc(c.it.Result())
    for c.nextPath() {
      select {
      case <-done:
      
      fnc(c.it.Result())

func (c *IterateChain) start() {
      c.it = c.s.Iterate()

func (c *IterateChain) end() {

func (c *IterateChain) next() bool {
      ok := (c.limit < 0 || c.n < c.limit) && c.it.Next(c.ctx)

func (c *IterateChain) nextPath() bool {
      ok := c.paths && (c.limit < 0 || c.n < c.limit) && c.it.NextPath(c.ctx)

type Ref interface {
  // Key returns a dynamic type that is comparable according to the Go language specification.
  // The returned value must be unique for each receiver value.
  Key() interface{}
}