id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c12500 | if err != nil {
return nil, err
}
s.havingExpressionEvaluator = eval
}
return f, nil
}
return f
} | |
c12501 |
}
if l.Type() != literal.Int64 {
return nil, fmt.Errorf("limit required an int64 value; found %s instead", l)
}
lv, err := l.Int64()
if err != nil {
return nil, fmt.Errorf("failed to retrieve the int64 value for literal %v with error %v", l, err)
}
st.limitSet, st.limit = true, lv
return f, nil
... | |
c12502 | return nil, err
}
if p.ID() != "" {
return nil, fmt.Errorf("global time bounds do not accept individual predicate IDs; found %s instead", p)
}
ta, err := p.TimeAnchor()
if err != nil {
return nil, err
}
if lastToken.Type == lexer.ItemComma || lastToken.Type == lexer.ItemBefore {
st.l... | |
c12503 | *Statement, _ Symbol) (ClauseHook, error) {
s.ResetWorkingConstructClause()
return f, nil
}
return f
} | |
c12504 | *Statement, _ Symbol) (ClauseHook, error) {
s.AddWorkingConstructClause()
return f, nil
}
return f
} | |
c12505 |
}
switch tkn.Type {
case lexer.ItemNode, lexer.ItemBlankNode:
n, err := ToNode(ce)
if err != nil {
return nil, err
}
c.S = n
case lexer.ItemBinding:
c.SBinding = tkn.Text
}
return f, nil
}
return f
} | |
c12506 | predicate %v in construct clause, predicate already set to %v", tkn.Type, p.PBinding)
}
switch tkn.Type {
case lexer.ItemPredicate:
pred, pID, pAnchorBinding, pTemporal, err := processPredicate(ce)
if err != nil {
return nil, err
}
p.P, p.PID, p.PAnchorBinding, p.PTemporal = pred, pID, pAnchorBin... | |
c12507 | p.O = obj
case lexer.ItemPredicate:
var (
pred *predicate.Predicate
err error
)
pred, p.OID, p.OAnchorBinding, p.OTemporal, err = processPredicate(ce)
if err != nil {
return nil, err
}
if pred != nil {
p.O = triple.NewPredicateObject(pred)
}
case lexer.ItemBinding:
p.OBind... | |
c12508 | _ Symbol) (ClauseHook, error) {
s.WorkingConstructClause().AddWorkingPredicateObjectPair()
return f, nil
}
return f
} | |
c12509 | *Statement, _ Symbol) (ClauseHook, error) {
s.sType = Show
return f, nil
}
return f
} | |
c12510 | != nil {
return nil, err
}
gens = append(gens, t)
}
return gens, nil
} | |
c12511 | != nil {
return nil, err
}
gens = append(gens, t)
}
return gens, nil
} | |
c12512 | s)
fmt.Println("done.")
}
if empty {
fmt.Println("No stories found!")
fmt.Println("-------------------------------------------------------------")
return 2
}
fmt.Println("-------------------------------------------------------------")
fmt.Printf("Evaluating %d stories... ", len(stories))
results := compl... | |
c12513 | idx+1, len(lines), stm)
tbl, err := BQL(ctx, stm, store, chanSize, bulkSize)
if err != nil {
fmt.Printf("[FAIL] %v\n\n", err)
continue
}
fmt.Println("Result:")
if tbl.NumRows() > 0 {
fmt.Println(tbl)
}
fmt.Printf("OK\n\n")
}
return 0
} | |
c12514 | {
return nil, fmt.Errorf("[ERROR] Should have not failed to create a plan using memory.DefaultStorage for statement %v with error %v", stm, err)
}
res, err := pln.Execute(ctx)
if err != nil {
return nil, fmt.Errorf("[ERROR] Failed to execute BQL statement with error %v", err)
}
return res, nil
} | |
c12515 |
isSymbol: false,
token: tkn,
}
} | |
c12516 | return nil, fmt.Errorf("semantic.ToNode cannot convert token type %s to a node", tkn.Type)
}
return node.Parse(tkn.Text)
} | |
c12517 | return nil, fmt.Errorf("semantic.ToPredicate cannot convert token type %s to a predicate", tkn.Type)
}
return predicate.Parse(tkn.Text)
} | |
c12518 | return nil, fmt.Errorf("semantic.ToLiteral cannot convert token type %s to a literal", tkn.Type)
}
return literal.DefaultBuilder().Parse(tkn.Text)
} | |
c12519 | // /type/foo is covariant of /type, but /typefoo is not covariant of /type.
return len(t.String()) == len(ot.String()) || t.String()[len(ot.String())] == '/'
} | |
c12520 | fmt.Sprintf("%s<%s>", n.t.String(), n.id.String())
} | |
c12521 | return nil, fmt.Errorf("node.Parse: pretty printing should finish with '>' in %q", raw)
}
id, err := NewID(raw[idx+1 : len(raw)-1])
if err != nil {
return nil, fmt.Errorf("node.Parse: invalid ID in %q, %v", raw, err)
}
return NewNode(t, id), nil
case underscore:
id, err := NewID(raw[2:len(raw)])
if ... | |
c12522 | n.t.Covariant(on.t)
} | |
c12523 | end with '/'", t)
}
if t == "" {
return nil, fmt.Errorf("node.NewType(%q) cannot create empty types", t)
}
nt := Type(t)
return &nt, nil
} | |
c12524 | nil, fmt.Errorf("node.NewID(%q) cannot create empty ID", id)
}
nID := ID(id)
return &nID, nil
} | |
c12525 |
t: t,
id: id,
}
} | |
c12526 | err != nil {
return nil, err
}
return NewNode(t, n), nil
} | |
c12527 |
return &Node{
t: &tBlank,
id: &id,
}
} | |
c12528 |
buffer.WriteString(string(*n.id))
return uuid.NewSHA1(uuid.NIL, buffer.Bytes())
} | |
c12529 | return "CONSTRUCT"
case Deconstruct:
return "DECONSTRUCT"
case Show:
return "SHOW"
default:
return "UNKNOWN"
}
} | |
c12530 |
addToBindings(bm, c.OTypeAlias)
addToBindings(bm, c.OIDAlias)
addToBindings(bm, c.OAnchorAlias)
addToBindings(bm, c.OAnchorBinding)
addToBindings(bm, c.OLowerBoundAlias)
addToBindings(bm, c.OUpperBoundAlias)
return bm
} | |
c12531 | range c.BindingsMap() {
bs = append(bs, k)
}
return bs
} | |
c12532 | c.PredicateObjectPairs() {
b.WriteString(fmt.Sprintf("%v;", pop))
}
b.Truncate(b.Len() - 1)
b.WriteString(" }")
return b.String()
} | |
c12533 |
// Predicate portion.
if !object {
if c.OBinding != "" {
b.WriteString(" ")
b.WriteString(c.OBinding)
}
if c.OID != "" {
b.WriteString(" \"")
b.WriteString(c.OID)
b.WriteString("\"")
}
if !c.OTemporal {
b.WriteString("[]")
} else {
b.WriteString("[")
if c.OAnchorBinding != "" {
... | |
c12534 | append(s.graphNames, g)
} | |
c12535 | append(s.inputGraphNames, g)
} | |
c12536 | append(s.outputGraphNames, g)
} | |
c12537 | for _, ogn := range s.outputGraphNames {
og, err := st.Graph(ctx, ogn)
if err != nil {
return err
}
s.outputGraphs = append(s.outputGraphs, og)
}
return nil
} | |
c12538 | s.data = append(s.data, d)
} | |
c12539 | s.pattern = append(s.pattern, s.workingClause)
}
s.ResetWorkingGraphClause()
} | |
c12540 | cls.PBinding)
addToBindings(bm, cls.PLowerBoundAlias)
addToBindings(bm, cls.PUpperBoundAlias)
addToBindings(bm, cls.PIDAlias)
addToBindings(bm, cls.PAnchorAlias)
addToBindings(bm, cls.OBinding)
addToBindings(bm, cls.OAlias)
addToBindings(bm, cls.OTypeAlias)
addToBindings(bm, cls.OIDAlias)
ad... | |
c12541 | range s.BindingsMap() {
bs = append(bs, k)
}
return bs
} | |
c12542 | s[i], s[j] = s[j], s[i]
} | |
c12543 | {
return s[i].Specificity() >= s[j].Specificity()
} | |
c12544 | ptrns = append(ptrns, cls)
}
}
sort.Sort(bySpecificity(ptrns))
return ptrns
} | |
c12545 | lexer.ItemError {
b.WriteString(" via ")
b.WriteString(p.OP.String())
if p.Modifier != lexer.ItemError {
b.WriteString(" ")
b.WriteString(p.Modifier.String())
}
}
return b.String()
} | |
c12546 | "" && p.Alias == "" && p.OP == lexer.ItemError && p.Modifier == lexer.ItemError
} | |
c12547 |
s.ResetProjection()
}
return s.workingProjection
} | |
c12548 | s.projection = append(s.projection, s.workingProjection)
}
s.ResetProjection()
} | |
c12549 | if p.PAnchorBinding != "" {
res = append(res, p.PAnchorBinding)
}
if p.OBinding != "" {
res = append(res, p.OBinding)
}
if p.OAnchorBinding != "" {
res = append(res, p.OAnchorBinding)
}
}
}
return res
} | |
c12550 | set[c.SBinding] = true
}
for _, p := range c.predicateObjectPairs {
if _, ok := set[p.PBinding]; !ok {
res = append(res, p.PBinding)
set[p.PBinding] = true
}
if _, ok := set[p.PAnchorBinding]; !ok {
res = append(res, p.PAnchorBinding)
set[p.PAnchorBinding] = true
}
if _, ok := set[p.... | |
c12551 | = append(s.constructClauses, s.workingConstructClause)
}
s.ResetWorkingConstructClause()
} | |
c12552 | = append(c.predicateObjectPairs, c.workingPredicateObjectPair)
}
c.ResetWorkingPredicateObjectPair()
} | |
c12553 |
isSymbol: true,
symbol: s,
}
} | |
c12554 |
isSymbol: false,
tokenType: t,
}
} | |
c12555 | }
if cls.Elements[0].isSymbol {
return nil, fmt.Errorf("grammar.NewParser: not left factored grammar in %v", clauses)
}
}
}
return &Parser{
grammar: grammar,
}, nil
} | |
c12556 | inconsitent parser, no error found, and no tokens were consumed")
}
return nil
} | |
c12557 |
}
if llk.CanAccept(elem.Token()) {
return p.expect(llk, st, s, clause)
}
}
return false, fmt.Errorf("Parser.consume: could not consume token %s in production %s", llk.Current(), s)
} | |
c12558 | %v", elem.Symbol(), err)
}
} else {
if !llk.Consume(elem.Token()) {
return false, fmt.Errorf("Parser.parse: Failed to consume %s, got %s instead", elem.Token(), llk.Current().Type)
}
}
if cls.ProcessedElement != nil {
var ce semantic.ConsumedElement
if elem.isSymbol {
ce = semantic.NewCons... | |
c12559 | if err == nil {
return g, nil
}
return st.NewGraph(ctx, id)
} | |
c12560 | if err != nil {
return err
}
trps = append(trps, t)
}
if err := g.AddTriples(ctx, trps); err != nil {
return err
}
}
return nil
} | |
c12561 | err := st.DeleteGraph(ctx, src.ID); err != nil {
return err
}
}
return nil
} | |
c12562 | statement with error %v", err))
}
pln, err := planner.New(ctx, st, stm, chanSize, bulkSize, nil)
if err != nil {
return errorizer(fmt.Errorf("Should have not failed to create a plan using memory.DefaultStorage for statement %v with error %v", stm, err))
}
tbl, err := pln.Execute(ctx)
if err != nil {
return e... | |
c12563 | aName := fmt.Sprintf("requires %s", strings.TrimSpace(a.Requires))
m[aName] = &AssertionOutcome{
Equal: b,
Got: got,
Want: want,
}
}
// Clean the sources.
if err := s.cleanSources(ctx, st); err != nil {
return nil, err
}
return m, nil
} | |
c12564 |
results.Entries = append(results.Entries, &AssertionBatteryEntry{
Story: s,
Outcome: o,
Err: err,
})
}
return results
} | |
c12565 | time.Now(), port)
s := &serverConfig{
store: store,
chanSize: chanSize,
bulkSize: bulkSize,
}
http.HandleFunc("/bql", s.bqlHandler)
http.HandleFunc("/", defaultHandler)
if err := http.ListenAndServe(":"+p, nil); err != nil {
log.Printf("[%v] Failed to start server on port %s; %v", time.Now(), p, err)
... | |
c12566 | s.chanSize, s.bulkSize)
r := &result{
Q: q,
T: t,
}
if err != nil {
log.Printf("[%s] %q failed; %v", time.Now(), q, err.Error())
r.Msg = err.Error()
} else {
r.Msg = "[OK]"
}
res = append(res, r)
}
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(`[`))
cnt := len(res)
... | |
c12567 | nq := strings.TrimSpace(qs); len(nq) > 0 {
res = append(res, nq+";")
}
}
}
return res
} | |
c12568 | defaultEntryTemplate.Execute(w, nil); err != nil {
reportError(w, r, err)
}
} | |
c12569 |
log.Printf("[%s] %v\n", time.Now(), err)
errorTemplate.Execute(w, err)
} | |
c12570 | fmt.Println("[WARNING] Tracing is on. This may slow your BQL queries.")
case 3:
// Start tracing to file.
stopTracing()
f, err := os.Create(args[2])
if err != nil {
fmt.Println(err)
} else {
tracer, isTracingToFile = f, true
fmt.Println("[WARNING] Tracing is on. This may slow you... | |
c12571 | load triples into the specified graphs.")
fmt.Println("run <file_with_bql_statements> - runs all the BQL statements in the file.")
fmt.Println("start tracing [trace_file] - starts tracing queries.")
fmt.Println("stop tracing ... | |
c12572 | []string{msg.Error()}
})
return "", 0, msg
}
for idx, stm := range lines {
fmt.Printf("Processing statement (%d/%d)\n", idx+1, len(lines))
_, err := runBQL(ctx, stm, driver, chanSize, bulkSize, w)
if err != nil {
msg := fmt.Errorf("%q; %v", stm, err)
tracer.Trace(w, func() []string {
return []str... | |
c12573 | msg := fmt.Errorf("planner.Execute: failed to execute; %v", err)
tracer.Trace(w, func() []string {
return []string{msg.Error()}
})
return nil, msg
}
tracer.Trace(w, func() []string {
return []string{fmt.Sprintf("planner execute returned %d rows", res.NumRows())}
})
return res, nil
} | |
c12574 | return []string{msg.Error()}
})
return nil, msg
}
stm := &semantic.Statement{}
if err := p.Parse(grammar.NewLLk(bql, 1), stm); err != nil {
msg := fmt.Errorf("NewLLk parser failed; %v", err)
tracer.Trace(w, func() []string {
return []string{msg.Error()}
})
return nil, msg
}
pln, err := planner.New(... | |
c12575 | {
return "", err
}
return string(b), nil
} | |
c12576 | json.Unmarshal([]byte(ss), s)
} | |
c12577 | l}
}
t, err := time.Parse(time.RFC3339Nano, s)
if err == nil {
return &table.Cell{T: &t}
}
return &table.Cell{S: table.CellString(s)}
} | |
c12578 |
// bindings.
bs = bo
}
// Build the table.
if len(bo) != len(bs) {
return nil, fmt.Errorf("incompatible bindings; got %v, want %v", bs, bo)
}
for _, b := range bo {
if _, ok := mBdngs[b]; !first && !ok {
return nil, fmt.Errorf("missing binding %q; want bining in %v", b, bo)
}
}
t, err := table.New(... | |
c12579 | nlo.LowerAnchor = cls.PLowerBound
}
}
if cls.PUpperBound != nil {
if lo.UpperAnchor == nil || (lo.UpperAnchor != nil && cls.PUpperBound.Before(*lo.UpperAnchor)) {
nlo.UpperAnchor = cls.PUpperBound
}
}
return nlo
} | |
c12580 | ok := r[cls.PUpperBoundAlias]
if ok && v.T == nil {
return nil, fmt.Errorf("invalid time anchor value %v for bound %s", v, cls.PUpperBoundAlias)
}
if lo.UpperAnchor == nil || (lo.UpperAnchor != nil && v.T.After(*lo.UpperAnchor)) {
lo.UpperAnchor = v.T
}
}
nlo := updateTimeBounds(lo, cls)
return nlo, n... | |
c12581 |
if b {
unfeasible = false
ts := make(chan *triple.Triple, 1)
ts <- t
close(ts)
if err := addTriples(ts, cls, tbl); err != nil {
return true, nil, err
}
}
}
return unfeasible, tbl, nil
} | |
c12582 | return fmt.Errorf("failed to retrieve time anchor from time predicate in triple %s with error %v", t, err)
}
// Need to check the bounds of the triple.
if cls.OLowerBound != nil && cls.OLowerBound.After(*ta) {
continue
}
if cls.OUpperBound != nil && cls.OUpperBound.Before(*ta) {
co... | |
c12583 | return c, nil
}
if l, err := o.Literal(); err == nil {
c.L = l
return c, nil
}
return nil, fmt.Errorf("unknown object type in object %q", o)
} | |
c12584 | st, "removing non existing graph triples", chanSize, bulkSize, batteries.RemoveGraphTriplesBenchmark)
// Remove existing triples.
out += runBattery(ctx, st, "removing existing tree triples", chanSize, bulkSize, batteries.RemoveExistingTreeTriplesBenchmark)
out += runBattery(ctx, st, "removing existing graph triple... | |
c12585 | }
sortAndPrint := func(ss []string) {
sort.Strings(ss)
for _, s := range ss {
fmt.Println(s)
}
}
fmt.Printf("Stats for sequentially run %s benchmark\n", name)
var ress []string
for _, br := range brs {
ress = append(ress, format(br))
}
sortAndPrint(ress)
fmt.Println()
fmt.Printf("Stats for concu... | |
c12586 | nil {
return nil, err
}
return stms, nil
} | |
c12587 | == ";" {
lines = append(lines, strings.TrimSpace(line))
line = ""
}
}
if line != "" {
lines = append(lines, strings.TrimSpace(line))
}
return lines, scanner.Err()
} | |
c12588 | if len(l) == 0 || strings.Index(l, "#") == 0 {
continue
}
if err := fp(l); err != nil {
return cnt, err
}
}
return cnt, scanner.Err()
} | |
c12589 | continue
}
t, err := triple.Parse(text, b)
if err != nil {
return cnt, err
}
cnt++
g.AddTriples(ctx, []*triple.Triple{t})
}
return cnt, nil
} | |
c12590 | t.String())); err != nil {
wErr = err
continue
}
cnt++
}
wg.Wait()
if tErr != nil {
return 0, tErr
}
if wErr != nil {
return 0, wErr
}
return cnt, nil
} | |
c12591 | trplSets[i]
bes = append(bes, &runtime.BenchEntry{
BatteryID: "Add non existing triples",
ID: fmt.Sprintf("%s, reps=%02d", ids[i], r),
Triples: gSizes[i],
Reps: r,
Setup: func() error {
var err error
g, err = st.NewGraph(ctx, gID)
return err
},
F: func() erro... | |
c12592 | func() (storage.Store, error) {
return memory.NewStore(), nil
},
}
} | |
c12593 | }
go l.run() // Concurrently run state machine.
return l, l.tokens
} | |
c12594 | 0
}
_, c := lex(input, capacity)
return c
} | |
c12595 | if state := isSingleSymbolToken(l, ItemComma, comma); state != nil {
return state
}
if state := isSingleSymbolToken(l, ItemLT, lt); state != nil {
return state
}
if state := isSingleSymbolToken(l, ItemGT, gt); state != nil {
return state
}
if state := isSingleSymbolToken(l, ItemEQ, eq); state != ... | |
c12596 |
l.next()
l.emit(tt)
return lexSpace // Next state.
}
return nil
} | |
c12597 | {
l.backup()
l.emit(ItemBinding)
break
}
}
return lexSpace
} | |
c12598 |
}
}
l.backup()
l.ignore()
return lexToken
} | |
c12599 | for {
if r := l.next(); !unicode.IsLetter(r) && !unicode.IsDigit(r) && r != rune('_') || r == eof {
l.backup()
l.emit(ItemBlankNode)
break
}
}
return lexSpace
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.