_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q12500 | havingExpressionBuilder | train | func havingExpressionBuilder() ClauseHook {
var f ClauseHook
f = func(s *Statement, _ Symbol) (ClauseHook, error) {
s.havingExpressionEvaluator = &AlwaysReturn{V: true}
if len(s.havingExpression) > 0 {
eval, err := NewEvaluator(s.havingExpression)
if err != nil {
return nil, err
}
s.havingExpressi... | go | {
"resource": ""
} |
q12501 | limitCollection | train | func limitCollection() ElementHook {
var f func(st *Statement, ce ConsumedElement) (ElementHook, error)
f = func(st *Statement, ce ConsumedElement) (ElementHook, error) {
if ce.IsSymbol() || ce.token.Type == lexer.ItemLimit {
return f, nil
}
if ce.token.Type != lexer.ItemLiteral {
return nil, fmt.Errorf("... | go | {
"resource": ""
} |
q12502 | collectGlobalBounds | train | func collectGlobalBounds() ElementHook {
var (
f func(st *Statement, ce ConsumedElement) (ElementHook, error)
opToken *lexer.Token
lastToken *lexer.Token
)
f = func(st *Statement, ce ConsumedElement) (ElementHook, error) {
if ce.IsSymbol() {
return f, nil
}
tkn := ce.token
switch tkn.Type ... | go | {
"resource": ""
} |
q12503 | InitWorkingConstructClause | train | func InitWorkingConstructClause() ClauseHook {
var f ClauseHook
f = func(s *Statement, _ Symbol) (ClauseHook, error) {
s.ResetWorkingConstructClause()
return f, nil
}
return f
} | go | {
"resource": ""
} |
q12504 | NextWorkingConstructClause | train | func NextWorkingConstructClause() ClauseHook {
var f ClauseHook
f = func(s *Statement, _ Symbol) (ClauseHook, error) {
s.AddWorkingConstructClause()
return f, nil
}
return f
} | go | {
"resource": ""
} |
q12505 | constructSubject | train | func constructSubject() ElementHook {
var f ElementHook
f = func(st *Statement, ce ConsumedElement) (ElementHook, error) {
if ce.IsSymbol() {
return f, nil
}
tkn := ce.Token()
c := st.WorkingConstructClause()
if c.S != nil {
return nil, fmt.Errorf("invalid subject %v in construct clause, subject alrea... | go | {
"resource": ""
} |
q12506 | constructPredicate | train | func constructPredicate() ElementHook {
var f ElementHook
f = func(st *Statement, ce ConsumedElement) (ElementHook, error) {
if ce.IsSymbol() {
return f, nil
}
tkn := ce.Token()
p := st.WorkingConstructClause().WorkingPredicateObjectPair()
if p.P != nil {
return nil, fmt.Errorf("invalid predicate %v i... | go | {
"resource": ""
} |
q12507 | constructObject | train | func constructObject() ElementHook {
var f ElementHook
f = func(st *Statement, ce ConsumedElement) (ElementHook, error) {
if ce.IsSymbol() {
return f, nil
}
tkn := ce.Token()
p := st.WorkingConstructClause().WorkingPredicateObjectPair()
if p.O != nil {
return nil, fmt.Errorf("invalid object %v in cons... | go | {
"resource": ""
} |
q12508 | NextWorkingConstructPredicateObjectPair | train | func NextWorkingConstructPredicateObjectPair() ClauseHook {
var f ClauseHook
f = func(s *Statement, _ Symbol) (ClauseHook, error) {
s.WorkingConstructClause().AddWorkingPredicateObjectPair()
return f, nil
}
return f
} | go | {
"resource": ""
} |
q12509 | ShowClauseHook | train | func ShowClauseHook() ClauseHook {
var f ClauseHook
f = func(s *Statement, _ Symbol) (ClauseHook, error) {
s.sType = Show
return f, nil
}
return f
} | go | {
"resource": ""
} |
q12510 | getTreeGenerators | train | func getTreeGenerators(bFactors []int) ([]generator.Generator, error) {
var gens []generator.Generator
for _, b := range bFactors {
t, err := tree.New(b)
if err != nil {
return nil, err
}
gens = append(gens, t)
}
return gens, nil
} | go | {
"resource": ""
} |
q12511 | getGraphGenerators | train | func getGraphGenerators(nodes []int) ([]generator.Generator, error) {
var gens []generator.Generator
for _, b := range nodes {
t, err := graph.NewRandomGraph(b)
if err != nil {
return nil, err
}
gens = append(gens, t)
}
return gens, nil
} | go | {
"resource": ""
} |
q12512 | assertCommand | train | func assertCommand(ctx context.Context, cmd *command.Command, args []string, store storage.Store, builder literal.Builder, chanSize, bulkSize int) int {
if len(args) < 2 {
log.Printf("Missing required folder path. ")
cmd.Usage()
return 2
}
// Open the folder.
folder := strings.TrimSpace(args[len(args)-1])
f,... | go | {
"resource": ""
} |
q12513 | runCommand | train | func runCommand(ctx context.Context, cmd *command.Command, args []string, store storage.Store, chanSize, bulkSize int) int {
if len(args) < 2 {
log.Printf("[ERROR] Missing required file path. ")
cmd.Usage()
return 2
}
file := strings.TrimSpace(args[len(args)-1])
lines, err := io.GetStatementsFromFile(file)
i... | go | {
"resource": ""
} |
q12514 | BQL | train | func BQL(ctx context.Context, bql string, s storage.Store, chanSize, bulkSize int) (*table.Table, error) {
p, err := grammar.NewParser(grammar.SemanticBQL())
if err != nil {
return nil, fmt.Errorf("[ERROR] Failed to initilize a valid BQL parser")
}
stm := &semantic.Statement{}
if err := p.Parse(grammar.NewLLk(bq... | go | {
"resource": ""
} |
q12515 | NewConsumedToken | train | func NewConsumedToken(tkn *lexer.Token) ConsumedElement {
return ConsumedElement{
isSymbol: false,
token: tkn,
}
} | go | {
"resource": ""
} |
q12516 | ToNode | train | func ToNode(ce ConsumedElement) (*node.Node, error) {
if ce.IsSymbol() {
return nil, fmt.Errorf("semantic.ToNode cannot convert symbol %v to a node", ce)
}
tkn := ce.Token()
if tkn.Type != lexer.ItemNode && tkn.Type != lexer.ItemBlankNode {
return nil, fmt.Errorf("semantic.ToNode cannot convert token type %s to... | go | {
"resource": ""
} |
q12517 | ToPredicate | train | func ToPredicate(ce ConsumedElement) (*predicate.Predicate, error) {
if ce.IsSymbol() {
return nil, fmt.Errorf("semantic.ToPredicate cannot convert symbol %v to a predicate", ce)
}
tkn := ce.Token()
if tkn.Type != lexer.ItemPredicate {
return nil, fmt.Errorf("semantic.ToPredicate cannot convert token type %s to... | go | {
"resource": ""
} |
q12518 | ToLiteral | train | func ToLiteral(ce ConsumedElement) (*literal.Literal, error) {
if ce.IsSymbol() {
return nil, fmt.Errorf("semantic.ToLiteral cannot convert symbol %v to a literal", ce)
}
tkn := ce.Token()
if tkn.Type != lexer.ItemLiteral {
return nil, fmt.Errorf("semantic.ToLiteral cannot convert token type %s to a literal", t... | go | {
"resource": ""
} |
q12519 | Covariant | train | func (t *Type) Covariant(ot *Type) bool {
if !strings.HasPrefix(t.String(), ot.String()) {
return false
}
// /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())] == '/'
} | go | {
"resource": ""
} |
q12520 | String | train | func (n *Node) String() string {
return fmt.Sprintf("%s<%s>", n.t.String(), n.id.String())
} | go | {
"resource": ""
} |
q12521 | Parse | train | func Parse(s string) (*Node, error) {
raw := strings.TrimSpace(s)
switch raw[0] {
case slash:
idx := strings.Index(raw, "<")
if idx < 0 {
return nil, fmt.Errorf("node.Parse: invalid format, could not find ID in %v", raw)
}
t, err := NewType(raw[:idx])
if err != nil {
return nil, fmt.Errorf("node.Pars... | go | {
"resource": ""
} |
q12522 | Covariant | train | func (n *Node) Covariant(on *Node) bool {
return n.t.Covariant(on.t)
} | go | {
"resource": ""
} |
q12523 | NewType | train | func NewType(t string) (*Type, error) {
if strings.ContainsAny(t, " \t\n\r") {
return nil, fmt.Errorf("node.NewType(%q) does not allow spaces", t)
}
if !strings.HasPrefix(t, "/") || strings.HasSuffix(t, "/") {
return nil, fmt.Errorf("node.NewType(%q) should start with a '/' and do not end with '/'", t)
}
if t ... | go | {
"resource": ""
} |
q12524 | NewID | train | func NewID(id string) (*ID, error) {
if strings.ContainsAny(id, "<>") {
return nil, fmt.Errorf("node.NewID(%q) does not allow '<' or '>'", id)
}
if id == "" {
return nil, fmt.Errorf("node.NewID(%q) cannot create empty ID", id)
}
nID := ID(id)
return &nID, nil
} | go | {
"resource": ""
} |
q12525 | NewNode | train | func NewNode(t *Type, id *ID) *Node {
return &Node{
t: t,
id: id,
}
} | go | {
"resource": ""
} |
q12526 | NewNodeFromStrings | train | func NewNodeFromStrings(sT, sID string) (*Node, error) {
t, err := NewType(sT)
if err != nil {
return nil, err
}
n, err := NewID(sID)
if err != nil {
return nil, err
}
return NewNode(t, n), nil
} | go | {
"resource": ""
} |
q12527 | NewBlankNode | train | func NewBlankNode() *Node {
uuid := <-nextVal
id := ID(uuid.String())
return &Node{
t: &tBlank,
id: &id,
}
} | go | {
"resource": ""
} |
q12528 | UUID | train | func (n *Node) UUID() uuid.UUID {
var buffer bytes.Buffer
buffer.WriteString(string(*n.t))
buffer.WriteString(string(*n.id))
return uuid.NewSHA1(uuid.NIL, buffer.Bytes())
} | go | {
"resource": ""
} |
q12529 | String | train | func (t StatementType) String() string {
switch t {
case Query:
return "QUERY"
case Insert:
return "INSERT"
case Delete:
return "DELETE"
case Create:
return "CREATE"
case Drop:
return "DROP"
case Construct:
return "CONSTRUCT"
case Deconstruct:
return "DECONSTRUCT"
case Show:
return "SHOW"
defa... | go | {
"resource": ""
} |
q12530 | BindingsMap | train | func (c *GraphClause) BindingsMap() map[string]int {
bm := make(map[string]int)
addToBindings(bm, c.SBinding)
addToBindings(bm, c.SAlias)
addToBindings(bm, c.STypeAlias)
addToBindings(bm, c.SIDAlias)
addToBindings(bm, c.PAlias)
addToBindings(bm, c.PAnchorBinding)
addToBindings(bm, c.PBinding)
addToBindings(bm... | go | {
"resource": ""
} |
q12531 | Bindings | train | func (c *GraphClause) Bindings() []string {
var bs []string
for k := range c.BindingsMap() {
bs = append(bs, k)
}
return bs
} | go | {
"resource": ""
} |
q12532 | String | train | func (c *ConstructClause) String() string {
b := bytes.NewBufferString("{ ")
// Subject section.
if c.S != nil {
b.WriteString(c.S.String())
} else {
b.WriteString(c.SBinding)
}
// Predicate-object pairs section.
for _, pop := range c.PredicateObjectPairs() {
b.WriteString(fmt.Sprintf("%v;", pop))
}
b.... | go | {
"resource": ""
} |
q12533 | String | train | func (c *ConstructPredicateObjectPair) String() string {
b := bytes.NewBufferString("")
// Predicate section.
predicate := false
if c.P != nil {
b.WriteString(" ")
b.WriteString(c.P.String())
predicate = true
}
if c.PBinding != "" {
b.WriteString(" ")
b.WriteString(c.PBinding)
}
if c.PID != "" {
b.... | go | {
"resource": ""
} |
q12534 | AddGraph | train | func (s *Statement) AddGraph(g string) {
s.graphNames = append(s.graphNames, g)
} | go | {
"resource": ""
} |
q12535 | AddInputGraph | train | func (s *Statement) AddInputGraph(g string) {
s.inputGraphNames = append(s.inputGraphNames, g)
} | go | {
"resource": ""
} |
q12536 | AddOutputGraph | train | func (s *Statement) AddOutputGraph(g string) {
s.outputGraphNames = append(s.outputGraphNames, g)
} | go | {
"resource": ""
} |
q12537 | Init | train | func (s *Statement) Init(ctx context.Context, st storage.Store) error {
for _, gn := range s.graphNames {
g, err := st.Graph(ctx, gn)
if err != nil {
return err
}
s.graphs = append(s.graphs, g)
}
for _, ign := range s.inputGraphNames {
ig, err := st.Graph(ctx, ign)
if err != nil {
return err
}
... | go | {
"resource": ""
} |
q12538 | AddData | train | func (s *Statement) AddData(d *triple.Triple) {
s.data = append(s.data, d)
} | go | {
"resource": ""
} |
q12539 | AddWorkingGraphClause | train | func (s *Statement) AddWorkingGraphClause() {
if s.workingClause != nil && !s.workingClause.IsEmpty() {
s.pattern = append(s.pattern, s.workingClause)
}
s.ResetWorkingGraphClause()
} | go | {
"resource": ""
} |
q12540 | BindingsMap | train | func (s *Statement) BindingsMap() map[string]int {
bm := make(map[string]int)
for _, cls := range s.pattern {
if cls != nil {
addToBindings(bm, cls.SBinding)
addToBindings(bm, cls.SAlias)
addToBindings(bm, cls.STypeAlias)
addToBindings(bm, cls.SIDAlias)
addToBindings(bm, cls.PAlias)
addToBindings... | go | {
"resource": ""
} |
q12541 | Bindings | train | func (s *Statement) Bindings() []string {
var bs []string
for k := range s.BindingsMap() {
bs = append(bs, k)
}
return bs
} | go | {
"resource": ""
} |
q12542 | Swap | train | func (s bySpecificity) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q12543 | Less | train | func (s bySpecificity) Less(i, j int) bool {
return s[i].Specificity() >= s[j].Specificity()
} | go | {
"resource": ""
} |
q12544 | SortedGraphPatternClauses | train | func (s *Statement) SortedGraphPatternClauses() []*GraphClause {
var ptrns []*GraphClause
// Filter empty clauses.
for _, cls := range s.pattern {
if cls != nil && !cls.IsEmpty() {
ptrns = append(ptrns, cls)
}
}
sort.Sort(bySpecificity(ptrns))
return ptrns
} | go | {
"resource": ""
} |
q12545 | String | train | func (p *Projection) String() string {
b := bytes.NewBufferString(p.Binding)
b.WriteString(" as ")
b.WriteString(p.Binding)
if p.OP != lexer.ItemError {
b.WriteString(" via ")
b.WriteString(p.OP.String())
if p.Modifier != lexer.ItemError {
b.WriteString(" ")
b.WriteString(p.Modifier.String())
}
}
re... | go | {
"resource": ""
} |
q12546 | IsEmpty | train | func (p *Projection) IsEmpty() bool {
return p.Binding == "" && p.Alias == "" && p.OP == lexer.ItemError && p.Modifier == lexer.ItemError
} | go | {
"resource": ""
} |
q12547 | WorkingProjection | train | func (s *Statement) WorkingProjection() *Projection {
if s.workingProjection == nil {
s.ResetProjection()
}
return s.workingProjection
} | go | {
"resource": ""
} |
q12548 | AddWorkingProjection | train | func (s *Statement) AddWorkingProjection() {
if s.workingProjection != nil && !s.workingProjection.IsEmpty() {
s.projection = append(s.projection, s.workingProjection)
}
s.ResetProjection()
} | go | {
"resource": ""
} |
q12549 | InputBindings | train | func (s *Statement) InputBindings() []string {
var res []string
for _, p := range s.projection {
if p.Binding != "" {
res = append(res, p.Binding)
}
}
for _, c := range s.constructClauses {
if c.SBinding != "" {
res = append(res, c.SBinding)
}
for _, p := range c.predicateObjectPairs {
if p.PBind... | go | {
"resource": ""
} |
q12550 | OutputBindings | train | func (s *Statement) OutputBindings() []string {
var res []string
for _, p := range s.projection {
if p.Alias != "" {
res = append(res, p.Alias)
continue
}
if p.Binding != "" {
res = append(res, p.Binding)
}
}
set := make(map[string]bool)
set[""] = true
for _, c := range s.constructClauses {
if ... | go | {
"resource": ""
} |
q12551 | AddWorkingConstructClause | train | func (s *Statement) AddWorkingConstructClause() {
if s.workingConstructClause != nil && !s.workingConstructClause.IsEmpty() {
s.constructClauses = append(s.constructClauses, s.workingConstructClause)
}
s.ResetWorkingConstructClause()
} | go | {
"resource": ""
} |
q12552 | AddWorkingPredicateObjectPair | train | func (c *ConstructClause) AddWorkingPredicateObjectPair() {
if c.workingPredicateObjectPair != nil && !c.workingPredicateObjectPair.IsEmpty() {
c.predicateObjectPairs = append(c.predicateObjectPairs, c.workingPredicateObjectPair)
}
c.ResetWorkingPredicateObjectPair()
} | go | {
"resource": ""
} |
q12553 | NewSymbol | train | func NewSymbol(s semantic.Symbol) Element {
return Element{
isSymbol: true,
symbol: s,
}
} | go | {
"resource": ""
} |
q12554 | NewTokenType | train | func NewTokenType(t lexer.TokenType) Element {
return Element{
isSymbol: false,
tokenType: t,
}
} | go | {
"resource": ""
} |
q12555 | NewParser | train | func NewParser(grammar *Grammar) (*Parser, error) {
// Check that the grammar is left factorized.
for _, clauses := range *grammar {
idx := 0
for _, cls := range clauses {
if len(cls.Elements) == 0 {
if idx == 0 {
idx++
continue
}
return nil, fmt.Errorf("grammar.NewParser: invalid extra e... | go | {
"resource": ""
} |
q12556 | Parse | train | func (p *Parser) Parse(llk *LLk, st *semantic.Statement) error {
b, err := p.consume(llk, st, "START")
if err != nil {
return err
}
if !b {
return fmt.Errorf("Parser.Parse: inconsitent parser, no error found, and no tokens were consumed")
}
return nil
} | go | {
"resource": ""
} |
q12557 | consume | train | func (p *Parser) consume(llk *LLk, st *semantic.Statement, s semantic.Symbol) (bool, error) {
for _, clause := range (*p.grammar)[s] {
if len(clause.Elements) == 0 {
return true, nil
}
elem := clause.Elements[0]
if elem.isSymbol {
return false, fmt.Errorf("Parser.consume: not left factored grammar in %v"... | go | {
"resource": ""
} |
q12558 | expect | train | func (p *Parser) expect(llk *LLk, st *semantic.Statement, s semantic.Symbol, cls *Clause) (bool, error) {
if cls.ProcessStart != nil {
if _, err := cls.ProcessStart(st, s); err != nil {
return false, err
}
}
for _, elem := range cls.Elements {
tkn := llk.Current()
if elem.isSymbol {
if b, err := p.cons... | go | {
"resource": ""
} |
q12559 | getGraphFromStore | train | func getGraphFromStore(ctx context.Context, st storage.Store, id string) (storage.Graph, error) {
g, err := st.Graph(ctx, id)
if err == nil {
return g, nil
}
return st.NewGraph(ctx, id)
} | go | {
"resource": ""
} |
q12560 | populateSources | train | func (s *Story) populateSources(ctx context.Context, st storage.Store, b literal.Builder) error {
for _, src := range s.Sources {
g, err := getGraphFromStore(ctx, st, src.ID)
if err != nil {
return err
}
var trps []*triple.Triple
for _, trp := range src.Facts {
t, err := triple.Parse(trp, b)
if err ... | go | {
"resource": ""
} |
q12561 | cleanSources | train | func (s *Story) cleanSources(ctx context.Context, st storage.Store) error {
for _, src := range s.Sources {
if err := st.DeleteGraph(ctx, src.ID); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q12562 | runAssertion | train | func (a *Assertion) runAssertion(ctx context.Context, st storage.Store, chanSize, bulkSize int) (bool, *table.Table, *table.Table, error) {
errorizer := func(e error) (bool, *table.Table, *table.Table, error) {
if a.WillFail && e != nil {
return true, nil, nil, nil
}
return false, nil, nil, e
}
// Run the ... | go | {
"resource": ""
} |
q12563 | Run | train | func (s *Story) Run(ctx context.Context, st storage.Store, b literal.Builder, chanSize, bulkSize int) (map[string]*AssertionOutcome, error) {
// Populate the sources.
if err := s.populateSources(ctx, st, b); err != nil {
return nil, err
}
// Run assertions.
m := make(map[string]*AssertionOutcome)
for _, a := ra... | go | {
"resource": ""
} |
q12564 | RunStories | train | func RunStories(ctx context.Context, st storage.Store, b literal.Builder, stories []*Story, chanSize, bulkSize int) *AssertionBattery {
results := &AssertionBattery{}
for _, s := range stories {
o, err := s.Run(ctx, st, b, chanSize, bulkSize)
results.Entries = append(results.Entries, &AssertionBatteryEntry{
St... | go | {
"resource": ""
} |
q12565 | runServer | train | func runServer(ctx context.Context, cmd *command.Command, args []string, store storage.Store, chanSize, bulkSize int) int {
// Check parameters.
if len(args) < 2 {
log.Printf("[%v] Missing required port number. ", time.Now())
cmd.Usage()
return 2
}
// Validate port number.
p := strings.TrimSpace(args[len(ar... | go | {
"resource": ""
} |
q12566 | bqlHandler | train | func (s *serverConfig) bqlHandler(w http.ResponseWriter, r *http.Request) {
if err := r.ParseForm(); err != nil {
w.WriteHeader(http.StatusMethodNotAllowed)
reportError(w, r, err)
return
}
if r.Method != http.MethodPost {
reportError(w, r, fmt.Errorf("invalid %s request on %q endpoint. Only POST request are ... | go | {
"resource": ""
} |
q12567 | getQueries | train | func getQueries(raw []string) []string {
var res []string
for _, q := range raw {
for _, qs := range strings.Split(q, ";") {
if nq := strings.TrimSpace(qs); len(nq) > 0 {
res = append(res, nq+";")
}
}
}
return res
} | go | {
"resource": ""
} |
q12568 | defaultHandler | train | func defaultHandler(w http.ResponseWriter, r *http.Request) {
if err := defaultEntryTemplate.Execute(w, nil); err != nil {
reportError(w, r, err)
}
} | go | {
"resource": ""
} |
q12569 | reportError | train | func reportError(w http.ResponseWriter, r *http.Request, err error) {
w.WriteHeader(http.StatusInternalServerError)
log.Printf("[%s] %v\n", time.Now(), err)
errorTemplate.Execute(w, err)
} | go | {
"resource": ""
} |
q12570 | REPL | train | func REPL(od storage.Store, input *os.File, rl ReadLiner, chanSize, bulkSize, builderSize int, done chan bool) int {
var tracer io.Writer
ctx, isTracingToFile, sessionStart := context.Background(), false, time.Now()
driverPlain := func() storage.Store {
return od
}
driverWithMemoization := func() storage.Store... | go | {
"resource": ""
} |
q12571 | printHelp | train | func printHelp() {
fmt.Println()
fmt.Println("help - prints help for the bw console.")
fmt.Println("disable memoization - disables partial result memoization on query resolution.")
fmt.Println("enable memoization ... | go | {
"resource": ""
} |
q12572 | runBQLFromFile | train | func runBQLFromFile(ctx context.Context, driver storage.Store, chanSize, bulkSize int, line string, w io.Writer) (string, int, error) {
ss := strings.Split(strings.TrimSpace(line), " ")
if len(ss) != 2 {
return "", 0, fmt.Errorf("wrong syntax: run <file_with_bql_statements>")
}
path := ss[1]
tracer.Trace(w, func... | go | {
"resource": ""
} |
q12573 | runBQL | train | func runBQL(ctx context.Context, bql string, s storage.Store, chanSize, bulkSize int, w io.Writer) (*table.Table, error) {
tracer.Trace(w, func() []string {
return []string{fmt.Sprintf("Executing query: %s", bql)}
})
pln, err := planBQL(ctx, bql, s, chanSize, bulkSize, w)
if err != nil {
return nil, err
}
if ... | go | {
"resource": ""
} |
q12574 | planBQL | train | func planBQL(ctx context.Context, bql string, s storage.Store, chanSize, bulkSize int, w io.Writer) (planner.Executor, error) {
bql = strings.TrimSpace(bql)
if bql == ";" {
tracer.Trace(w, func() []string {
return []string{"Empty statement found"}
})
return nil, nil
}
p, err := grammar.NewParser(grammar.Se... | go | {
"resource": ""
} |
q12575 | Marshal | train | func (s *Story) Marshal() (string, error) {
b, err := json.MarshalIndent(s, "", " ")
if err != nil {
return "", err
}
return string(b), nil
} | go | {
"resource": ""
} |
q12576 | Unmarshal | train | func (s *Story) Unmarshal(ss string) error {
return json.Unmarshal([]byte(ss), s)
} | go | {
"resource": ""
} |
q12577 | inferCell | train | func inferCell(s string) *table.Cell {
if n, err := node.Parse(s); err == nil {
return &table.Cell{N: n}
}
if p, err := predicate.Parse(s); err == nil {
return &table.Cell{P: p}
}
if l, err := literal.DefaultBuilder().Parse(s); err == nil {
return &table.Cell{L: l}
}
t, err := time.Parse(time.RFC3339Nano, ... | go | {
"resource": ""
} |
q12578 | OutputTable | train | func (a *Assertion) OutputTable(bo []string) (*table.Table, error) {
// Return the already computed output table.
if a.table != nil {
return a.table, nil
}
// Compute the output table.
var (
first bool
mBdngs map[string]bool
data []table.Row
bs []string
)
mBdngs, first = make(map[string]bool), t... | go | {
"resource": ""
} |
q12579 | updateTimeBounds | train | func updateTimeBounds(lo *storage.LookupOptions, cls *semantic.GraphClause) *storage.LookupOptions {
nlo := &storage.LookupOptions{
MaxElements: lo.MaxElements,
LowerAnchor: lo.LowerAnchor,
UpperAnchor: lo.UpperAnchor,
}
if cls.PLowerBound != nil {
if lo.LowerAnchor == nil || (lo.LowerAnchor != nil && cls.PL... | go | {
"resource": ""
} |
q12580 | updateTimeBoundsForRow | train | func updateTimeBoundsForRow(lo *storage.LookupOptions, cls *semantic.GraphClause, r table.Row) (*storage.LookupOptions, error) {
lo = updateTimeBounds(lo, cls)
if cls.PLowerBoundAlias != "" {
v, ok := r[cls.PLowerBoundAlias]
if ok && v.T == nil {
return nil, fmt.Errorf("invalid time anchor value %v for bound %... | go | {
"resource": ""
} |
q12581 | simpleExist | train | func simpleExist(ctx context.Context, gs []storage.Graph, cls *semantic.GraphClause, t *triple.Triple) (bool, *table.Table, error) {
unfeasible := true
tbl, err := table.New(cls.Bindings())
if err != nil {
return true, nil, err
}
for _, g := range gs {
b, err := g.Exist(ctx, t)
if err != nil {
return true... | go | {
"resource": ""
} |
q12582 | addTriples | train | func addTriples(ts <-chan *triple.Triple, cls *semantic.GraphClause, tbl *table.Table) error {
for t := range ts {
if cls.PID != "" {
// The triples need to be filtered.
if string(t.Predicate().ID()) != cls.PID {
continue
}
if cls.PTemporal {
if t.Predicate().Type() != predicate.Temporal {
c... | go | {
"resource": ""
} |
q12583 | objectToCell | train | func objectToCell(o *triple.Object) (*table.Cell, error) {
c := &table.Cell{}
if n, err := o.Node(); err == nil {
c.N = n
return c, nil
}
if p, err := o.Predicate(); err == nil {
c.P = p
return c, nil
}
if l, err := o.Literal(); err == nil {
c.L = l
return c, nil
}
return nil, fmt.Errorf("unknown ob... | go | {
"resource": ""
} |
q12584 | runAll | train | func runAll(ctx context.Context, st storage.Store, chanSize, bulkSize int) int {
// - Add non existing triples. (done)
// - Add triples that already exist. (done)
// - Remove non existing triples. (done)
// - Remove existing triples. (done)
// - BQL tree walking from root. (done)... | go | {
"resource": ""
} |
q12585 | runBattery | train | func runBattery(ctx context.Context, st storage.Store, name string, chanSize, bulkSize int, f func(context.Context, storage.Store, int, int) ([]*runtime.BenchEntry, error)) int {
// Add triples.
fmt.Printf("Creating %s triples benchmark... ", name)
bes, err := f(ctx, st, chanSize, bulkSize)
if err != nil {
log.Pr... | go | {
"resource": ""
} |
q12586 | GetStatementsFromFile | train | func GetStatementsFromFile(path string) ([]string, error) {
stms, err := ReadLines(path)
if err != nil {
return nil, err
}
return stms, nil
} | go | {
"resource": ""
} |
q12587 | ReadLines | train | func ReadLines(path string) ([]string, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
var lines []string
scanner := bufio.NewScanner(f)
line := ""
for scanner.Scan() {
l := strings.TrimSpace(scanner.Text())
if len(l) == 0 || strings.Index(l, "#") == 0 {
continue
}... | go | {
"resource": ""
} |
q12588 | ProcessLines | train | func ProcessLines(path string, fp func(line string) error) (int, error) {
f, err := os.Open(path)
if err != nil {
return 0, err
}
defer f.Close()
scanner := bufio.NewScanner(f)
cnt := 0
for scanner.Scan() {
l := strings.TrimSpace(scanner.Text())
cnt++
if len(l) == 0 || strings.Index(l, "#") == 0 {
co... | go | {
"resource": ""
} |
q12589 | ReadIntoGraph | train | func ReadIntoGraph(ctx context.Context, g storage.Graph, r io.Reader, b literal.Builder) (int, error) {
cnt, scanner := 0, bufio.NewScanner(r)
scanner.Split(bufio.ScanLines)
for scanner.Scan() {
text := strings.TrimSpace(scanner.Text())
if text == "" {
continue
}
t, err := triple.Parse(text, b)
if err !... | go | {
"resource": ""
} |
q12590 | WriteGraph | train | func WriteGraph(ctx context.Context, w io.Writer, g storage.Graph) (int, error) {
var (
wg sync.WaitGroup
tErr error
wErr error
)
cnt, ts := 0, make(chan *triple.Triple)
wg.Add(1)
go func() {
defer wg.Done()
tErr = g.Triples(ctx, storage.DefaultLookup, ts)
}()
for t := range ts {
if wErr != nil {
... | go | {
"resource": ""
} |
q12591 | AddGraphTriplesBenchmark | train | func AddGraphTriplesBenchmark(ctx context.Context, st storage.Store, chanSize, bulkSize int) ([]*runtime.BenchEntry, error) {
nodes := []int{317, 1000}
sizes := []int{10, 1000, 100000}
var trplSets [][]*triple.Triple
var ids []string
var gids []string
var gSizes []int
gs, err := getGraphGenerators(nodes)
if err... | go | {
"resource": ""
} |
q12592 | registerDrivers | train | func registerDrivers() {
registeredDrivers = map[string]common.StoreGenerator{
// Memory only storage driver.
"VOLATILE": func() (storage.Store, error) {
return memory.NewStore(), nil
},
}
} | go | {
"resource": ""
} |
q12593 | lex | train | func lex(input string, capacity int) (*lexer, <-chan Token) {
l := &lexer{
input: input,
tokens: make(chan Token, capacity),
}
go l.run() // Concurrently run state machine.
return l, l.tokens
} | go | {
"resource": ""
} |
q12594 | New | train | func New(input string, capacity int) <-chan Token {
if capacity < 0 {
capacity = 0
}
_, c := lex(input, capacity)
return c
} | go | {
"resource": ""
} |
q12595 | lexToken | train | func lexToken(l *lexer) stateFn {
for {
{
r := l.peek()
switch r {
case binding:
l.next()
return lexBinding
case slash:
return lexNode
case underscore:
l.next()
return lexBlankNode
case quote:
return lexPredicateOrLiteral
}
if unicode.IsLetter(r) {
return lexKeywor... | go | {
"resource": ""
} |
q12596 | isSingleSymbolToken | train | func isSingleSymbolToken(l *lexer, tt TokenType, symbol rune) stateFn {
if r := l.peek(); r == symbol {
l.next()
l.emit(tt)
return lexSpace // Next state.
}
return nil
} | go | {
"resource": ""
} |
q12597 | lexBinding | train | func lexBinding(l *lexer) stateFn {
for {
if r := l.next(); !unicode.IsLetter(r) && !unicode.IsDigit(r) && r != rune('_') || r == eof {
l.backup()
l.emit(ItemBinding)
break
}
}
return lexSpace
} | go | {
"resource": ""
} |
q12598 | lexSpace | train | func lexSpace(l *lexer) stateFn {
for {
if r := l.next(); !unicode.IsSpace(r) || r == eof {
break
}
}
l.backup()
l.ignore()
return lexToken
} | go | {
"resource": ""
} |
q12599 | lexBlankNode | train | func lexBlankNode(l *lexer) stateFn {
if r := l.next(); r != colon {
l.emitError("blank node should start with _:")
return nil
}
if r := l.next(); !unicode.IsLetter(r) {
l.emitError("blank node label should begin with a letter")
return nil
}
for {
if r := l.next(); !unicode.IsLetter(r) && !unicode.IsDigi... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.