barak/cayley
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Merge branch 'master' of https://github.com/google/cayley into operators

Browse source 
Conflicts:
	query/gremlin/build_iterator.go
This commit is contained in:
Matei Chiperi 2014-09-08 17:04:48 -07:00
commit a718130f4a
83 changed files with 2370 additions and 2659 deletions
Download patch file Download diff file Expand all files Collapse all files

162
query/gremlin/build_iterator.go
View file

@ -34,11 +34,11 @@ func propertiesOf(obj *otto.Object, name string) []string {
return export.([]string)
}
func buildIteratorTree(obj *otto.Object, ts graph.TripleStore) graph.Iterator {
func buildIteratorTree(obj *otto.Object, qs graph.QuadStore) graph.Iterator {
if !isVertexChain(obj) {
return iterator.NewNull()
}
return buildIteratorTreeHelper(obj, ts, iterator.NewNull())
return buildIteratorTreeHelper(obj, qs, iterator.NewNull())
}
func stringsFrom(obj *otto.Object) []string {
@ -57,16 +57,16 @@ func stringsFrom(obj *otto.Object) []string {
return output
}
func buildIteratorFromValue(val otto.Value, ts graph.TripleStore) graph.Iterator {
func buildIteratorFromValue(val otto.Value, qs graph.QuadStore) graph.Iterator {
if val.IsNull() || val.IsUndefined() {
return ts.NodesAllIterator()
return qs.NodesAllIterator()
}
if val.IsPrimitive() {
thing, _ := val.Export()
switch v := thing.(type) {
case string:
it := ts.FixedIterator()
it.Add(ts.ValueOf(v))
it := qs.FixedIterator()
it.Add(qs.ValueOf(v))
return it
default:
glog.Errorln("Trying to build unknown primitive value.")
@ -74,13 +74,13 @@ func buildIteratorFromValue(val otto.Value, ts graph.TripleStore) graph.Iterator
}
switch val.Class() {
case "Object":
return buildIteratorTree(val.Object(), ts)
return buildIteratorTree(val.Object(), qs)
case "Array":
// Had better be an array of strings
strings := stringsFrom(val.Object())
it := ts.FixedIterator()
it := qs.FixedIterator()
for _, x := range strings {
it.Add(ts.ValueOf(x))
it.Add(qs.ValueOf(x))
}
return it
case "Number":
@ -90,8 +90,8 @@ func buildIteratorFromValue(val otto.Value, ts graph.TripleStore) graph.Iterator
case "Date":
fallthrough
case "String":
it := ts.FixedIterator()
it.Add(ts.ValueOf(val.String()))
it := qs.FixedIterator()
it.Add(qs.ValueOf(val.String()))
return it
default:
glog.Errorln("Trying to handle unsupported Javascript value.")
@ -99,7 +99,7 @@ func buildIteratorFromValue(val otto.Value, ts graph.TripleStore) graph.Iterator
}
}
func buildInOutIterator(obj *otto.Object, ts graph.TripleStore, base graph.Iterator, isReverse bool) graph.Iterator {
func buildInOutIterator(obj *otto.Object, qs graph.QuadStore, base graph.Iterator, isReverse bool) graph.Iterator {
argList, _ := obj.Get("_gremlin_values")
if argList.Class() != "GoArray" {
glog.Errorln("How is arglist not an array? Return nothing.", argList.Class())
@ -110,10 +110,10 @@ func buildInOutIterator(obj *otto.Object, ts graph.TripleStore, base graph.Itera
length, _ := lengthVal.ToInteger()
var predicateNodeIterator graph.Iterator
if length == 0 {
predicateNodeIterator = ts.NodesAllIterator()
predicateNodeIterator = qs.NodesAllIterator()
} else {
zero, _ := argArray.Get("0")
predicateNodeIterator = buildIteratorFromValue(zero, ts)
predicateNodeIterator = buildIteratorFromValue(zero, qs)
}
if length >= 2 {
var tags []string
@ -132,22 +132,22 @@ func buildInOutIterator(obj *otto.Object, ts graph.TripleStore, base graph.Itera
if isReverse {
in, out = out, in
}
lto := iterator.NewLinksTo(ts, base, in)
lto := iterator.NewLinksTo(qs, base, in)
and := iterator.NewAnd()
and.AddSubIterator(iterator.NewLinksTo(ts, predicateNodeIterator, quad.Predicate))
and.AddSubIterator(iterator.NewLinksTo(qs, predicateNodeIterator, quad.Predicate))
and.AddSubIterator(lto)
return iterator.NewHasA(ts, and, out)
return iterator.NewHasA(qs, and, out)
}
func buildIteratorTreeHelper(obj *otto.Object, ts graph.TripleStore, base graph.Iterator) graph.Iterator {
var it graph.Iterator = base
func buildIteratorTreeHelper(obj *otto.Object, qs graph.QuadStore, base graph.Iterator) graph.Iterator {
it := base
// TODO: Better error handling
var subIt graph.Iterator
if prev, _ := obj.Get("_gremlin_prev"); !prev.IsObject() {
subIt = base
} else {
subIt = buildIteratorTreeHelper(prev.Object(), ts, base)
subIt = buildIteratorTreeHelper(prev.Object(), qs, base)
}
stringArgs := propertiesOf(obj, "string_args")
@ -155,11 +155,11 @@ func buildIteratorTreeHelper(obj *otto.Object, ts graph.TripleStore, base graph.
switch val.String() {
case "vertex":
if len(stringArgs) == 0 {
it = ts.NodesAllIterator()
it = qs.NodesAllIterator()
} else {
fixed := ts.FixedIterator()
fixed := qs.FixedIterator()
for _, name := range stringArgs {
fixed.Add(ts.ValueOf(name))
fixed.Add(qs.ValueOf(name))
}
it = fixed
}
@ -169,7 +169,7 @@ func buildIteratorTreeHelper(obj *otto.Object, ts graph.TripleStore, base graph.
it.Tagger().Add(tag)
}
case "save":
all := ts.NodesAllIterator()
all := qs.NodesAllIterator()
if len(stringArgs) > 2 || len(stringArgs) == 0 {
return iterator.NewNull()
}
@ -178,18 +178,18 @@ func buildIteratorTreeHelper(obj *otto.Object, ts graph.TripleStore, base graph.
} else {
all.Tagger().Add(stringArgs[0])
}
predFixed := ts.FixedIterator()
predFixed.Add(ts.ValueOf(stringArgs[0]))
predFixed := qs.FixedIterator()
predFixed.Add(qs.ValueOf(stringArgs[0]))
subAnd := iterator.NewAnd()
subAnd.AddSubIterator(iterator.NewLinksTo(ts, predFixed, quad.Predicate))
subAnd.AddSubIterator(iterator.NewLinksTo(ts, all, quad.Object))
hasa := iterator.NewHasA(ts, subAnd, quad.Subject)
subAnd.AddSubIterator(iterator.NewLinksTo(qs, predFixed, quad.Predicate))
subAnd.AddSubIterator(iterator.NewLinksTo(qs, all, quad.Object))
hasa := iterator.NewHasA(qs, subAnd, quad.Subject)
and := iterator.NewAnd()
and.AddSubIterator(hasa)
and.AddSubIterator(subIt)
it = and
case "saver":
all := ts.NodesAllIterator()
all := qs.NodesAllIterator()
if len(stringArgs) > 2 || len(stringArgs) == 0 {
return iterator.NewNull()
}
@ -198,30 +198,30 @@ func buildIteratorTreeHelper(obj *otto.Object, ts graph.TripleStore, base graph.
} else {
all.Tagger().Add(stringArgs[0])
}
predFixed := ts.FixedIterator()
predFixed.Add(ts.ValueOf(stringArgs[0]))
predFixed := qs.FixedIterator()
predFixed.Add(qs.ValueOf(stringArgs[0]))
subAnd := iterator.NewAnd()
subAnd.AddSubIterator(iterator.NewLinksTo(ts, predFixed, quad.Predicate))
subAnd.AddSubIterator(iterator.NewLinksTo(ts, all, quad.Subject))
hasa := iterator.NewHasA(ts, subAnd, quad.Object)
subAnd.AddSubIterator(iterator.NewLinksTo(qs, predFixed, quad.Predicate))
subAnd.AddSubIterator(iterator.NewLinksTo(qs, all, quad.Subject))
hasa := iterator.NewHasA(qs, subAnd, quad.Object)
and := iterator.NewAnd()
and.AddSubIterator(hasa)
and.AddSubIterator(subIt)
it = and
case "has":
fixed := ts.FixedIterator()
fixed := qs.FixedIterator()
if len(stringArgs) < 2 {
return iterator.NewNull()
}
for _, name := range stringArgs[1:] {
fixed.Add(ts.ValueOf(name))
fixed.Add(qs.ValueOf(name))
}
predFixed := ts.FixedIterator()
predFixed.Add(ts.ValueOf(stringArgs[0]))
predFixed := qs.FixedIterator()
predFixed.Add(qs.ValueOf(stringArgs[0]))
subAnd := iterator.NewAnd()
subAnd.AddSubIterator(iterator.NewLinksTo(ts, predFixed, quad.Predicate))
subAnd.AddSubIterator(iterator.NewLinksTo(ts, fixed, quad.Object))
hasa := iterator.NewHasA(ts, subAnd, quad.Subject)
subAnd.AddSubIterator(iterator.NewLinksTo(qs, predFixed, quad.Predicate))
subAnd.AddSubIterator(iterator.NewLinksTo(qs, fixed, quad.Object))
hasa := iterator.NewHasA(qs, subAnd, quad.Subject)
and := iterator.NewAnd()
and.AddSubIterator(hasa)
and.AddSubIterator(subIt)
@ -234,7 +234,7 @@ func buildIteratorTreeHelper(obj *otto.Object, ts graph.TripleStore, base graph.
if !isVertexChain(firstArg.Object()) {
return iterator.NewNull()
}
argIt := buildIteratorTree(firstArg.Object(), ts)
argIt := buildIteratorTree(firstArg.Object(), qs)
and := iterator.NewAnd()
and.AddSubIterator(subIt)
@ -242,15 +242,15 @@ func buildIteratorTreeHelper(obj *otto.Object, ts graph.TripleStore, base graph.
it = and
case "back":
arg, _ := obj.Get("_gremlin_back_chain")
argIt := buildIteratorTree(arg.Object(), ts)
argIt := buildIteratorTree(arg.Object(), qs)
and := iterator.NewAnd()
and.AddSubIterator(subIt)
and.AddSubIterator(argIt)
it = and
case "is":
fixed := ts.FixedIterator()
fixed := qs.FixedIterator()
for _, name := range stringArgs {
fixed.Add(ts.ValueOf(name))
fixed.Add(qs.ValueOf(name))
}
and := iterator.NewAnd()
and.AddSubIterator(fixed)
@ -262,7 +262,7 @@ func buildIteratorTreeHelper(obj *otto.Object, ts graph.TripleStore, base graph.
if !isVertexChain(firstArg.Object()) {
return iterator.NewNull()
}
argIt := buildIteratorTree(firstArg.Object(), ts)
argIt := buildIteratorTree(firstArg.Object(), qs)
or := iterator.NewOr()
or.AddSubIterator(subIt)
@ -272,15 +272,15 @@ func buildIteratorTreeHelper(obj *otto.Object, ts graph.TripleStore, base graph.
// Hardly the most efficient pattern, but the most general.
// Worth looking into an Optimize() optimization here.
clone := subIt.Clone()
it1 := buildInOutIterator(obj, ts, subIt, false)
it2 := buildInOutIterator(obj, ts, clone, true)
it1 := buildInOutIterator(obj, qs, subIt, false)
it2 := buildInOutIterator(obj, qs, clone, true)
or := iterator.NewOr()
or.AddSubIterator(it1)
or.AddSubIterator(it2)
it = or
case "out":
it = buildInOutIterator(obj, ts, subIt, false)
it = buildInOutIterator(obj, qs, subIt, false)
case "follow":
// Follow a morphism
arg, _ := obj.Get("_gremlin_values")
@ -288,14 +288,14 @@ func buildIteratorTreeHelper(obj *otto.Object, ts graph.TripleStore, base graph.
if isVertexChain(firstArg.Object()) {
return iterator.NewNull()
}
it = buildIteratorTreeHelper(firstArg.Object(), ts, subIt)
it = buildIteratorTreeHelper(firstArg.Object(), qs, subIt)
case "followr":
// Follow a morphism
arg, _ := obj.Get("_gremlin_followr")
if isVertexChain(arg.Object()) {
return iterator.NewNull()
}
it = buildIteratorTreeHelper(arg.Object(), ts, subIt)
it = buildIteratorTreeHelper(arg.Object(), qs, subIt)
case "in":
it = buildInOutIterator(obj, ts, subIt, true)
case "except":
@ -313,64 +313,6 @@ func buildIteratorTreeHelper(obj *otto.Object, ts graph.TripleStore, base graph.
and.AddSubIterator(subIt)
and.AddSubIterator(notIt)
it = and
case "loop":
arg, _ := obj.Get("_gremlin_values")
firstArg, _ := arg.Object().Get("0")
secondArg, _ := arg.Object().Get("1")
thirdArg, _ := arg.Object().Get("2")
// Parse the loop iterating sequence
if isVertexChain(firstArg.Object()) {
return iterator.NewNull()
}
// Create the loop iterator: first, create an entry point iterator.
loopEntryIt := iterator.NewEntryPoint(subIt)
// Then create a loop iterator on top of the entry point.
loopIt := buildIteratorTreeHelper(firstArg.Object(), ts, loopEntryIt)
// Parse the number of loops to execute.
// bounded=false means it will loop until no more results are produced.
noLoops := 0
bounded := false
if secondArg.IsNumber() {
if no, err := secondArg.ToInteger(); err == nil {
noLoops = int(no)
bounded = true
} else {
return iterator.NewNull()
}
} else if secondArg.IsBoolean() {
if boolVal, err := secondArg.ToBoolean(); err == nil && boolVal {
bounded = false
} else {
return iterator.NewNull()
}
} else {
thirdArg = secondArg
}
// If the number of loops is le 0, the loop is unbounded
if noLoops <= 0 {
bounded = false
} else {
bounded = true
}
// Create the filter iterator
filterEntryIt := iterator.NewEntryPoint(nil)
var filterIt graph.Iterator
if thirdArg.IsNull() || thirdArg.IsUndefined() {
// There is no filter morphism, use the entry point as a filter.
filterIt = filterEntryIt
} else if isVertexChain(thirdArg.Object()) {
return iterator.NewNull()
} else {
// There is a filter morphism, create the filter iterator based on the entry point.
filterIt = buildIteratorTreeHelper(thirdArg.Object(), ts, filterEntryIt)
}
it = iterator.NewLoop(ts, subIt, loopIt, filterIt, loopEntryIt, filterEntryIt, noLoops, bounded)
}
return it
}

6
query/gremlin/environ.go
View file

@ -26,7 +26,7 @@ import (
)
type worker struct {
ts graph.TripleStore
qs graph.QuadStore
env *otto.Otto
sync.Mutex
@ -39,10 +39,10 @@ type worker struct {
kill <-chan struct{}
}
func newWorker(ts graph.TripleStore) *worker {
func newWorker(qs graph.QuadStore) *worker {
env := otto.New()
wk := &worker{
ts: ts,
qs: qs,
env: env,
limit: -1,
}

22
query/gremlin/finals.go
View file

@ -39,7 +39,7 @@ func (wk *worker) embedFinals(env *otto.Otto, obj *otto.Object) {
func (wk *worker) allFunc(env *otto.Otto, obj *otto.Object) func(otto.FunctionCall) otto.Value {
return func(call otto.FunctionCall) otto.Value {
it := buildIteratorTree(obj, wk.ts)
it := buildIteratorTree(obj, wk.qs)
it.Tagger().Add(TopResultTag)
wk.limit = -1
wk.count = 0
@ -52,7 +52,7 @@ func (wk *worker) limitFunc(env *otto.Otto, obj *otto.Object) func(otto.Function
return func(call otto.FunctionCall) otto.Value {
if len(call.ArgumentList) > 0 {
limitVal, _ := call.Argument(0).ToInteger()
it := buildIteratorTree(obj, wk.ts)
it := buildIteratorTree(obj, wk.qs)
it.Tagger().Add(TopResultTag)
wk.limit = int(limitVal)
wk.count = 0
@ -64,7 +64,7 @@ func (wk *worker) limitFunc(env *otto.Otto, obj *otto.Object) func(otto.Function
func (wk *worker) toArrayFunc(env *otto.Otto, obj *otto.Object, withTags bool) func(otto.FunctionCall) otto.Value {
return func(call otto.FunctionCall) otto.Value {
it := buildIteratorTree(obj, wk.ts)
it := buildIteratorTree(obj, wk.qs)
it.Tagger().Add(TopResultTag)
limit := -1
if len(call.ArgumentList) > 0 {
@ -91,7 +91,7 @@ func (wk *worker) toArrayFunc(env *otto.Otto, obj *otto.Object, withTags bool) f
func (wk *worker) toValueFunc(env *otto.Otto, obj *otto.Object, withTags bool) func(otto.FunctionCall) otto.Value {
return func(call otto.FunctionCall) otto.Value {
it := buildIteratorTree(obj, wk.ts)
it := buildIteratorTree(obj, wk.qs)
it.Tagger().Add(TopResultTag)
limit := 1
var val otto.Value
@ -112,15 +112,14 @@ func (wk *worker) toValueFunc(env *otto.Otto, obj *otto.Object, withTags bool) f
if err != nil {
glog.Error(err)
return otto.NullValue()
} else {
return val
}
return val
}
}
func (wk *worker) mapFunc(env *otto.Otto, obj *otto.Object) func(otto.FunctionCall) otto.Value {
return func(call otto.FunctionCall) otto.Value {
it := buildIteratorTree(obj, wk.ts)
it := buildIteratorTree(obj, wk.qs)
it.Tagger().Add(TopResultTag)
limit := -1
if len(call.ArgumentList) == 0 {
@ -139,7 +138,7 @@ func (wk *worker) mapFunc(env *otto.Otto, obj *otto.Object) func(otto.FunctionCa
func (wk *worker) tagsToValueMap(m map[string]graph.Value) map[string]string {
outputMap := make(map[string]string)
for k, v := range m {
outputMap[k] = wk.ts.NameOf(v)
outputMap[k] = wk.qs.NameOf(v)
}
return outputMap
}
@ -196,7 +195,7 @@ func (wk *worker) runIteratorToArrayNoTags(it graph.Iterator, limit int) []strin
if !graph.Next(it) {
break
}
output = append(output, wk.ts.NameOf(it.Result()))
output = append(output, wk.qs.NameOf(it.Result()))
n++
if limit >= 0 && n >= limit {
break
@ -260,16 +259,15 @@ func (wk *worker) send(r *Result) bool {
wk.count++
if wk.limit >= 0 && wk.limit == wk.count {
return false
} else {
return true
}
return true
}
return false
}
func (wk *worker) runIterator(it graph.Iterator) {
if wk.wantShape() {
iterator.OutputQueryShapeForIterator(it, wk.ts, wk.shape)
iterator.OutputQueryShapeForIterator(it, wk.qs, wk.shape)
return
}
it, _ = it.Optimize()

8
query/gremlin/gremlin_test.go
View file

@ -54,12 +54,12 @@ var simpleGraph = []quad.Quad{
}
func makeTestSession(data []quad.Quad) *Session {
ts, _ := graph.NewTripleStore("memstore", "", nil)
w, _ := graph.NewQuadWriter("single", ts, nil)
qs, _ := graph.NewQuadStore("memstore", "", nil)
w, _ := graph.NewQuadWriter("single", qs, nil)
for _, t := range data {
w.AddQuad(t)
}
return NewSession(ts, -1, false)
return NewSession(qs, -1, false)
}
var testQueries = []struct {
@ -273,7 +273,7 @@ func runQueryGetTag(g []quad.Quad, query string, tag string) []string {
if data.val == nil {
val := data.actualResults[tag]
if val != nil {
results = append(results, js.ts.NameOf(val))
results = append(results, js.qs.NameOf(val))
}
}
}

25
query/gremlin/session.go
View file

@ -21,6 +21,7 @@ import (
"time"
"github.com/robertkrimen/otto"
// Provide underscore JS library.
_ "github.com/robertkrimen/otto/underscore"
"github.com/google/cayley/graph"
@ -30,7 +31,7 @@ import (
var ErrKillTimeout = errors.New("query timed out")
type Session struct {
ts graph.TripleStore
qs graph.QuadStore
wk *worker
script *otto.Script
@ -45,10 +46,10 @@ type Session struct {
err error
}
func NewSession(ts graph.TripleStore, timeout time.Duration, persist bool) *Session {
func NewSession(qs graph.QuadStore, timeout time.Duration, persist bool) *Session {
g := Session{
ts: ts,
wk: newWorker(ts),
qs: qs,
wk: newWorker(qs),
timeout: timeout,
}
if persist {
@ -176,7 +177,7 @@ func (s *Session) ToText(result interface{}) string {
tags := data.actualResults
tagKeys := make([]string, len(tags))
i := 0
for k, _ := range tags {
for k := range tags {
tagKeys[i] = k
i++
}
@ -185,7 +186,7 @@ func (s *Session) ToText(result interface{}) string {
if k == "$_" {
continue
}
out += fmt.Sprintf("%s : %s\n", k, s.ts.NameOf(tags[k]))
out += fmt.Sprintf("%s : %s\n", k, s.qs.NameOf(tags[k]))
}
} else {
if data.val.IsObject() {
@ -203,7 +204,7 @@ func (s *Session) ToText(result interface{}) string {
}
// Web stuff
func (s *Session) BuildJson(result interface{}) {
func (s *Session) BuildJSON(result interface{}) {
data := result.(*Result)
if !data.metaresult {
if data.val == nil {
@ -211,13 +212,13 @@ func (s *Session) BuildJson(result interface{}) {
tags := data.actualResults
tagKeys := make([]string, len(tags))
i := 0
for k, _ := range tags {
for k := range tags {
tagKeys[i] = k
i++
}
sort.Strings(tagKeys)
for _, k := range tagKeys {
obj[k] = s.ts.NameOf(tags[k])
obj[k] = s.qs.NameOf(tags[k])
}
s.dataOutput = append(s.dataOutput, obj)
} else {
@ -232,8 +233,8 @@ func (s *Session) BuildJson(result interface{}) {
}
}
func (s *Session) GetJson() ([]interface{}, error) {
defer s.ClearJson()
func (s *Session) GetJSON() ([]interface{}, error) {
defer s.ClearJSON()
if s.err != nil {
return nil, s.err
}
@ -245,6 +246,6 @@ func (s *Session) GetJson() ([]interface{}, error) {
}
}
func (s *Session) ClearJson() {
func (s *Session) ClearJSON() {
s.dataOutput = nil
}

36
query/mql/build_iterator.go
View file

@ -27,13 +27,13 @@ import (
)
func (q *Query) buildFixed(s string) graph.Iterator {
f := q.ses.ts.FixedIterator()
f.Add(q.ses.ts.ValueOf(s))
f := q.ses.qs.FixedIterator()
f.Add(q.ses.qs.ValueOf(s))
return f
}
func (q *Query) buildResultIterator(path Path) graph.Iterator {
all := q.ses.ts.NodesAllIterator()
all := q.ses.qs.NodesAllIterator()
all.Tagger().Add(string(path))
return all
}
@ -47,7 +47,7 @@ func (q *Query) BuildIteratorTree(query interface{}) {
var isOptional bool
q.it, isOptional, q.err = q.buildIteratorTreeInternal(query, NewPath())
if isOptional {
q.err = errors.New("Optional iterator at the top level?")
q.err = errors.New("optional iterator at the top level")
}
}
@ -68,7 +68,7 @@ func (q *Query) buildIteratorTreeInternal(query interface{}, path Path) (it grap
// Damn you, Javascript, and your lack of integer values.
if math.Floor(t) == t {
// Treat it like an integer.
it = q.buildFixed(fmt.Sprintf("%d", t))
it = q.buildFixed(fmt.Sprintf("%0.f", t))
} else {
it = q.buildFixed(fmt.Sprintf("%f", t))
}
@ -84,7 +84,7 @@ func (q *Query) buildIteratorTreeInternal(query interface{}, path Path) (it grap
} else if len(t) == 1 {
it, optional, err = q.buildIteratorTreeInternal(t[0], path)
} else {
err = errors.New(fmt.Sprintf("Multiple fields at location root%s", path.DisplayString()))
err = fmt.Errorf("multiple fields at location root %s", path.DisplayString())
}
case map[string]interface{}:
// for JSON objects
@ -104,7 +104,7 @@ func (q *Query) buildIteratorTreeInternal(query interface{}, path Path) (it grap
func (q *Query) buildIteratorTreeMapInternal(query map[string]interface{}, path Path) (graph.Iterator, error) {
it := iterator.NewAnd()
it.AddSubIterator(q.ses.ts.NodesAllIterator())
it.AddSubIterator(q.ses.qs.NodesAllIterator())
var err error
err = nil
outputStructure := make(map[string]interface{})
@ -138,18 +138,18 @@ func (q *Query) buildIteratorTreeMapInternal(query map[string]interface{}, path
return nil, err
}
subAnd := iterator.NewAnd()
predFixed := q.ses.ts.FixedIterator()
predFixed.Add(q.ses.ts.ValueOf(pred))
subAnd.AddSubIterator(iterator.NewLinksTo(q.ses.ts, predFixed, quad.Predicate))
predFixed := q.ses.qs.FixedIterator()
predFixed.Add(q.ses.qs.ValueOf(pred))
subAnd.AddSubIterator(iterator.NewLinksTo(q.ses.qs, predFixed, quad.Predicate))
if reverse {
lto := iterator.NewLinksTo(q.ses.ts, builtIt, quad.Subject)
lto := iterator.NewLinksTo(q.ses.qs, builtIt, quad.Subject)
subAnd.AddSubIterator(lto)
hasa := iterator.NewHasA(q.ses.ts, subAnd, quad.Object)
hasa := iterator.NewHasA(q.ses.qs, subAnd, quad.Object)
subit = hasa
} else {
lto := iterator.NewLinksTo(q.ses.ts, builtIt, quad.Object)
lto := iterator.NewLinksTo(q.ses.qs, builtIt, quad.Object)
subAnd.AddSubIterator(lto)
hasa := iterator.NewHasA(q.ses.ts, subAnd, quad.Subject)
hasa := iterator.NewHasA(q.ses.qs, subAnd, quad.Subject)
subit = hasa
}
}
@ -166,13 +166,13 @@ func (q *Query) buildIteratorTreeMapInternal(query map[string]interface{}, path
return it, nil
}
type ResultPathSlice []ResultPath
type byRecordLength []ResultPath
func (p ResultPathSlice) Len() int {
func (p byRecordLength) Len() int {
return len(p)
}
func (p ResultPathSlice) Less(i, j int) bool {
func (p byRecordLength) Less(i, j int) bool {
iLen := len(strings.Split(string(p[i]), "\x30"))
jLen := len(strings.Split(string(p[j]), "\x30"))
if iLen < jLen {
@ -186,6 +186,6 @@ func (p ResultPathSlice) Less(i, j int) bool {
return false
}
func (p ResultPathSlice) Swap(i, j int) {
func (p byRecordLength) Swap(i, j int) {
p[i], p[j] = p[j], p[i]
}

10
query/mql/fill.go
View file

@ -27,20 +27,18 @@ func (q *Query) treeifyResult(tags map[string]graph.Value) map[ResultPath]string
if v == nil {
continue
}
results[Path(k)] = q.ses.ts.NameOf(v)
results[Path(k)] = q.ses.qs.NameOf(v)
}
resultPaths := make(map[ResultPath]string)
for k, v := range results {
resultPaths[k.ToResultPathFromMap(results)] = v
}
var paths ResultPathSlice
for path, _ := range resultPaths {
paths := make([]ResultPath, 0, len(resultPaths))
for path := range resultPaths {
paths = append(paths, path)
}
sort.Sort(paths)
sort.Sort(byRecordLength(paths))
// Build Structure
for _, path := range paths {

12
query/mql/mql_test.go
View file

@ -53,12 +53,12 @@ var simpleGraph = []quad.Quad{
}
func makeTestSession(data []quad.Quad) *Session {
ts, _ := graph.NewTripleStore("memstore", "", nil)
w, _ := graph.NewQuadWriter("single", ts, nil)
qs, _ := graph.NewQuadStore("memstore", "", nil)
w, _ := graph.NewQuadWriter("single", qs, nil)
for _, t := range data {
w.AddQuad(t)
}
return NewSession(ts)
return NewSession(qs)
}
var testQueries = []struct {
@ -172,9 +172,9 @@ func runQuery(g []quad.Quad, query string) interface{} {
c := make(chan interface{}, 5)
go s.ExecInput(query, c, -1)
for result := range c {
s.BuildJson(result)
s.BuildJSON(result)
}
result, _ := s.GetJson()
result, _ := s.GetJSON()
return result
}
@ -186,7 +186,7 @@ func TestMQL(t *testing.T) {
if !reflect.DeepEqual(got, expect) {
b, err := json.MarshalIndent(got, "", " ")
if err != nil {
t.Fatalf("unexpected JSON marshal error", err)
t.Fatalf("unexpected JSON marshal error: %v", err)
}
t.Errorf("Failed to %s, got: %s expected: %s", test.message, b, test.expect)
}

6
query/mql/query.go
View file

@ -21,8 +21,10 @@ import (
"github.com/google/cayley/graph"
)
type Path string
type ResultPath string
type (
Path string
ResultPath string
)
type Query struct {
ses *Session

44
query/mql/session.go
View file

@ -27,40 +27,39 @@ import (
)
type Session struct {
ts graph.TripleStore
qs graph.QuadStore
currentQuery *Query
debug bool
}
func NewSession(ts graph.TripleStore) *Session {
func NewSession(qs graph.QuadStore) *Session {
var m Session
m.ts = ts
m.qs = qs
return &m
}
func (m *Session) ToggleDebug() {
m.debug = !m.debug
func (s *Session) ToggleDebug() {
s.debug = !s.debug
}
func (m *Session) GetQuery(input string, output_struct chan map[string]interface{}) {
defer close(output_struct)
func (s *Session) GetQuery(input string, out chan map[string]interface{}) {
defer close(out)
var mqlQuery interface{}
err := json.Unmarshal([]byte(input), &mqlQuery)
if err != nil {
return
}
m.currentQuery = NewQuery(m)
m.currentQuery.BuildIteratorTree(mqlQuery)
s.currentQuery = NewQuery(s)
s.currentQuery.BuildIteratorTree(mqlQuery)
output := make(map[string]interface{})
iterator.OutputQueryShapeForIterator(m.currentQuery.it, m.ts, output)
nodes := output["nodes"].([]iterator.Node)
new_nodes := make([]iterator.Node, 0)
for _, n := range nodes {
iterator.OutputQueryShapeForIterator(s.currentQuery.it, s.qs, output)
nodes := make([]iterator.Node, 0)
for _, n := range output["nodes"].([]iterator.Node) {
n.Tags = nil
new_nodes = append(new_nodes, n)
nodes = append(nodes, n)
}
output["nodes"] = new_nodes
output_struct <- output
output["nodes"] = nodes
out <- output
}
func (s *Session) InputParses(input string) (query.ParseResult, error) {
@ -109,7 +108,7 @@ func (s *Session) ToText(result interface{}) string {
r, _ := json.MarshalIndent(s.currentQuery.results, "", " ")
fmt.Println(string(r))
i := 0
for k, _ := range tags {
for k := range tags {
tagKeys[i] = string(k)
i++
}
@ -118,25 +117,24 @@ func (s *Session) ToText(result interface{}) string {
if k == "$_" {
continue
}
out += fmt.Sprintf("%s : %s\n", k, s.ts.NameOf(tags[k]))
out += fmt.Sprintf("%s : %s\n", k, s.qs.NameOf(tags[k]))
}
return out
}
func (s *Session) BuildJson(result interface{}) {
func (s *Session) BuildJSON(result interface{}) {
s.currentQuery.treeifyResult(result.(map[string]graph.Value))
}
func (s *Session) GetJson() ([]interface{}, error) {
func (s *Session) GetJSON() ([]interface{}, error) {
s.currentQuery.buildResults()
if s.currentQuery.isError() {
return nil, s.currentQuery.err
} else {
return s.currentQuery.results, nil
}
return s.currentQuery.results, nil
}
func (s *Session) ClearJson() {
func (s *Session) ClearJSON() {
// Since we create a new Query underneath every query, clearing isn't necessary.
return
}

8
query/session.go
View file

@ -32,14 +32,14 @@ type Session interface {
ToggleDebug()
}
type HttpSession interface {
type HTTP interface {
// Return whether the string is a valid expression.
InputParses(string) (ParseResult, error)
// Runs the query and returns individual results on the channel.
ExecInput(string, chan interface{}, int)
GetQuery(string, chan map[string]interface{})
BuildJson(interface{})
GetJson() ([]interface{}, error)
ClearJson()
BuildJSON(interface{})
GetJSON() ([]interface{}, error)
ClearJSON()
ToggleDebug()
}

29
query/sexp/parser.go
View file

@ -22,9 +22,9 @@ import (
"github.com/google/cayley/quad"
)
func BuildIteratorTreeForQuery(ts graph.TripleStore, query string) graph.Iterator {
func BuildIteratorTreeForQuery(qs graph.QuadStore, query string) graph.Iterator {
tree := parseQuery(query)
return buildIteratorTree(tree, ts)
return buildIteratorTree(tree, qs)
}
func ParseString(input string) string {
@ -181,15 +181,15 @@ func getIdentString(tree *peg.ExpressionTree) string {
return out
}
func buildIteratorTree(tree *peg.ExpressionTree, ts graph.TripleStore) graph.Iterator {
func buildIteratorTree(tree *peg.ExpressionTree, qs graph.QuadStore) graph.Iterator {
switch tree.Name {
case "Start":
return buildIteratorTree(tree.Children[0], ts)
return buildIteratorTree(tree.Children[0], qs)
case "NodeIdentifier":
var out graph.Iterator
nodeID := getIdentString(tree)
if tree.Children[0].Name == "Variable" {
allIt := ts.NodesAllIterator()
allIt := qs.NodesAllIterator()
allIt.Tagger().Add(nodeID)
out = allIt
} else {
@ -197,8 +197,8 @@ func buildIteratorTree(tree *peg.ExpressionTree, ts graph.TripleStore) graph.Ite
if tree.Children[0].Children[0].Name == "ColonIdentifier" {
n = nodeID[1:]
}
fixed := ts.FixedIterator()
fixed.Add(ts.ValueOf(n))
fixed := qs.FixedIterator()
fixed.Add(qs.ValueOf(n))
out = fixed
}
return out
@ -208,8 +208,8 @@ func buildIteratorTree(tree *peg.ExpressionTree, ts graph.TripleStore) graph.Ite
//Taken care of below
i++
}
it := buildIteratorTree(tree.Children[i], ts)
lto := iterator.NewLinksTo(ts, it, quad.Predicate)
it := buildIteratorTree(tree.Children[i], qs)
lto := iterator.NewLinksTo(qs, it, quad.Predicate)
return lto
case "RootConstraint":
constraintCount := 0
@ -219,7 +219,7 @@ func buildIteratorTree(tree *peg.ExpressionTree, ts graph.TripleStore) graph.Ite
case "NodeIdentifier":
fallthrough
case "Constraint":
it := buildIteratorTree(c, ts)
it := buildIteratorTree(c, qs)
and.AddSubIterator(it)
constraintCount++
continue
@ -241,7 +241,7 @@ func buildIteratorTree(tree *peg.ExpressionTree, ts graph.TripleStore) graph.Ite
topLevelDir = quad.Object
subItDir = quad.Subject
}
it := buildIteratorTree(c, ts)
it := buildIteratorTree(c, qs)
subAnd.AddSubIterator(it)
continue
case "PredicateKeyword":
@ -252,15 +252,15 @@ func buildIteratorTree(tree *peg.ExpressionTree, ts graph.TripleStore) graph.Ite
case "NodeIdentifier":
fallthrough
case "RootConstraint":
it := buildIteratorTree(c, ts)
l := iterator.NewLinksTo(ts, it, subItDir)
it := buildIteratorTree(c, qs)
l := iterator.NewLinksTo(qs, it, subItDir)
subAnd.AddSubIterator(l)
continue
default:
continue
}
}
hasa = iterator.NewHasA(ts, subAnd, topLevelDir)
hasa = iterator.NewHasA(qs, subAnd, topLevelDir)
if isOptional {
optional := iterator.NewOptional(hasa)
return optional
@ -269,5 +269,4 @@ func buildIteratorTree(tree *peg.ExpressionTree, ts graph.TripleStore) graph.Ite
default:
return &iterator.Null{}
}
panic("Not reached")
}

48
query/sexp/parser_test.go
View file

@ -39,14 +39,14 @@ var testQueries = []struct {
expect string
}{
{
message: "get a single triple linkage",
message: "get a single quad linkage",
add: quad.Quad{"i", "can", "win", ""},
query: "($a (:can \"win\"))",
typ: graph.And,
expect: "i",
},
{
message: "get a single triple linkage",
message: "get a single quad linkage",
add: quad.Quad{"i", "can", "win", ""},
query: "(\"i\" (:can $a))",
typ: graph.And,
@ -55,9 +55,9 @@ var testQueries = []struct {
}
func TestMemstoreBackedSexp(t *testing.T) {
ts, _ := graph.NewTripleStore("memstore", "", nil)
w, _ := graph.NewQuadWriter("single", ts, nil)
it := BuildIteratorTreeForQuery(ts, "()")
qs, _ := graph.NewQuadStore("memstore", "", nil)
w, _ := graph.NewQuadWriter("single", qs, nil)
it := BuildIteratorTreeForQuery(qs, "()")
if it.Type() != graph.Null {
t.Errorf(`Incorrect type for empty query, got:%q expect: "null"`, it.Type())
}
@ -65,7 +65,7 @@ func TestMemstoreBackedSexp(t *testing.T) {
if test.add.IsValid() {
w.AddQuad(test.add)
}
it := BuildIteratorTreeForQuery(ts, test.query)
it := BuildIteratorTreeForQuery(qs, test.query)
if it.Type() != test.typ {
t.Errorf("Incorrect type for %s, got:%q expect %q", test.message, it.Type(), test.expect)
}
@ -73,56 +73,56 @@ func TestMemstoreBackedSexp(t *testing.T) {
t.Errorf("Failed to %s", test.message)
}
got := it.Result()
if expect := ts.ValueOf(test.expect); got != expect {
if expect := qs.ValueOf(test.expect); got != expect {
t.Errorf("Incorrect result for %s, got:%v expect %v", test.message, got, expect)
}
}
}
func TestTreeConstraintParse(t *testing.T) {
ts, _ := graph.NewTripleStore("memstore", "", nil)
w, _ := graph.NewQuadWriter("single", ts, nil)
qs, _ := graph.NewQuadStore("memstore", "", nil)
w, _ := graph.NewQuadWriter("single", qs, nil)
w.AddQuad(quad.Quad{"i", "like", "food", ""})
w.AddQuad(quad.Quad{"food", "is", "good", ""})
query := "(\"i\"\n" +
"(:like\n" +
"($a (:is :good))))"
it := BuildIteratorTreeForQuery(ts, query)
it := BuildIteratorTreeForQuery(qs, query)
if it.Type() != graph.And {
t.Error("Odd iterator tree. Got: %s", it.DebugString(0))
t.Errorf("Odd iterator tree. Got: %s", it.DebugString(0))
}
if !graph.Next(it) {
t.Error("Got no results")
}
out := it.Result()
if out != ts.ValueOf("i") {
t.Errorf("Got %d, expected %d", out, ts.ValueOf("i"))
if out != qs.ValueOf("i") {
t.Errorf("Got %d, expected %d", out, qs.ValueOf("i"))
}
}
func TestTreeConstraintTagParse(t *testing.T) {
ts, _ := graph.NewTripleStore("memstore", "", nil)
w, _ := graph.NewQuadWriter("single", ts, nil)
qs, _ := graph.NewQuadStore("memstore", "", nil)
w, _ := graph.NewQuadWriter("single", qs, nil)
w.AddQuad(quad.Quad{"i", "like", "food", ""})
w.AddQuad(quad.Quad{"food", "is", "good", ""})
query := "(\"i\"\n" +
"(:like\n" +
"($a (:is :good))))"
it := BuildIteratorTreeForQuery(ts, query)
it := BuildIteratorTreeForQuery(qs, query)
if !graph.Next(it) {
t.Error("Got no results")
}
tags := make(map[string]graph.Value)
it.TagResults(tags)
if ts.NameOf(tags["$a"]) != "food" {
t.Errorf("Got %s, expected food", ts.NameOf(tags["$a"]))
if qs.NameOf(tags["$a"]) != "food" {
t.Errorf("Got %s, expected food", qs.NameOf(tags["$a"]))
}
}
func TestMultipleConstraintParse(t *testing.T) {
ts, _ := graph.NewTripleStore("memstore", "", nil)
w, _ := graph.NewQuadWriter("single", ts, nil)
qs, _ := graph.NewQuadStore("memstore", "", nil)
w, _ := graph.NewQuadWriter("single", qs, nil)
for _, tv := range []quad.Quad{
{"i", "like", "food", ""},
{"i", "like", "beer", ""},
@ -135,16 +135,16 @@ func TestMultipleConstraintParse(t *testing.T) {
(:like :beer)
(:like "food")
)`
it := BuildIteratorTreeForQuery(ts, query)
it := BuildIteratorTreeForQuery(qs, query)
if it.Type() != graph.And {
t.Error("Odd iterator tree. Got: %s", it.DebugString(0))
t.Errorf("Odd iterator tree. Got: %s", it.DebugString(0))
}
if !graph.Next(it) {
t.Error("Got no results")
}
out := it.Result()
if out != ts.ValueOf("i") {
t.Errorf("Got %d, expected %d", out, ts.ValueOf("i"))
if out != qs.ValueOf("i") {
t.Errorf("Got %d, expected %d", out, qs.ValueOf("i"))
}
if graph.Next(it) {
t.Error("Too many results")

14
query/sexp/session.go
View file

@ -26,13 +26,13 @@ import (
)
type Session struct {
ts graph.TripleStore
qs graph.QuadStore
debug bool
}
func NewSession(inputTripleStore graph.TripleStore) *Session {
func NewSession(qs graph.QuadStore) *Session {
var s Session
s.ts = inputTripleStore
s.qs = qs
return &s
}
@ -53,7 +53,7 @@ func (s *Session) InputParses(input string) (query.ParseResult, error) {
if (i - 10) > min {
min = i - 10
}
return query.ParseFail, errors.New(fmt.Sprintf("Too many close parens at char %d: %s", i, input[min:i]))
return query.ParseFail, fmt.Errorf("too many close parentheses at char %d: %s", i, input[min:i])
}
}
}
@ -63,11 +63,11 @@ func (s *Session) InputParses(input string) (query.ParseResult, error) {
if len(ParseString(input)) > 0 {
return query.Parsed, nil
}
return query.ParseFail, errors.New("Invalid Syntax")
return query.ParseFail, errors.New("invalid syntax")
}
func (s *Session) ExecInput(input string, out chan interface{}, limit int) {
it := BuildIteratorTreeForQuery(s.ts, input)
it := BuildIteratorTreeForQuery(s.qs, input)
newIt, changed := it.Optimize()
if changed {
it = newIt
@ -112,7 +112,7 @@ func (s *Session) ToText(result interface{}) string {
if k == "$_" {
continue
}
out += fmt.Sprintf("%s : %s\n", k, s.ts.NameOf(tags[k]))
out += fmt.Sprintf("%s : %s\n", k, s.qs.NameOf(tags[k]))
}
return out
}