Documentation

Overview

Package dsl provide an API for writing gremlin dsl queries almost as-is in Go without using strings in the code.

Note that, the API is not type-safe and assume the provided query and its arguments are valid.

Index

Constants

This section is empty.

Variables

var (
	G   = Token("g")
	Dot = Token(".")
)

predefined nodes.


Functions

This section is empty.

Types

type Bindings

type Bindings map[string]interface{}

Bindings are used to associate a variable with a value.

func (Bindings) Add

func (b Bindings) Add(v interface{}) string

Add adds new value to the bindings map, formats it if needed, and returns its generated name.

type Block

type Block struct {
	Nodes []interface{}
}

Block represents a block/group of nodes.

func (Block) Code

func (b Block) Code() (string, []interface{})

Code returns the code representation of group/block of nodes.

type Cardinality

type Cardinality string

Cardinality of vertex properties.

const (
	Set    Cardinality = "set"
	Single Cardinality = "single"
)

Cardinality options.

func (Cardinality) Code

func (c Cardinality) Code() (string, []interface{})

Code implements the Node interface.

type Column

type Column string

Column references a particular type of column in a complex data structure such as a Map, a Map.Entry, or a Path.

const (
	Keys   Column = "keys"
	Values Column = "values"
)

Column options.

func (Column) Code

func (o Column) Code() (string, []interface{})

Code implements the Node interface.

type Func

type Func struct {
	Name string
	Args []interface{}
}

Func represents a function call.

func NewFunc

func NewFunc(name string, args ...interface{}) *Func

NewFunc returns a new function node.

func (Func) Code

func (f Func) Code() (string, []interface{})

Code returns the code representation of a function call.

type List

type List struct {
	Elements []interface{}
}

List represents a list of elements.

func NewList

func NewList(args ...interface{}) *List

NewList returns a new list node.

func (List) Code

func (l List) Code() (string, []interface{})

Code returns the code representation of a list.

type Node

type Node interface {
	// Code returns the code representation of the element and its bindings (if any).
	Code() (string, []interface{})
}

Node represents a DSL step in the traversal.

type Order

type Order string

Order of vertex properties.

const (
	Incr    Order = "incr"
	Decr    Order = "decr"
	Shuffle Order = "shuffle"
)

Order options.

func (Order) Code

func (o Order) Code() (string, []interface{})

Code implements the Node interface.

type Querier

type Querier interface {
	// Query returns the query-string (similar to the Gremlin byte-code) and its bindings.
	Query() (string, Bindings)
}

Querier is the interface that wraps the Query method.

type Scope

type Scope string

Scope used for steps that have a variable scope which alter the manner in which the step will behave in relation to how the traverses are processed.

const (
	Local  Scope = "local"
	Global Scope = "global"
)

Scope options.

func (Scope) Code

func (s Scope) Code() (string, []interface{})

Code implements the Node interface.

type Token

type Token string

Token holds a simple token, like assignment.

func (Token) Code

func (t Token) Code() (string, []interface{})

Code stringified the token.

type Traversal

type Traversal struct {
	// contains filtered or unexported fields
}

Traversal mimics the TinkerPop graph traversal.

func Each

func Each(v interface{}, cb func(it *Traversal) *Traversal) *Traversal

Each is a Groovy each-loop function.

func Group

func Group(trs ...*Traversal) *Traversal

Group groups a list of traversals into one. all traversals are assigned into a temporary variables named by their index. The last variable functions as a return value of the query. Note that, this "temporary hack" is not perfect and may not work in some cases because of the limitation of evaluation order.

func Join

func Join(trs ...*Traversal) *Traversal

Join joins a list of traversals with a semicolon separator.

func NewTraversal

func NewTraversal() *Traversal

NewTraversal returns a new default traversal with "g" as a reference name to the Graph.

func (*Traversal) Add

func (t *Traversal) Add(n ...Node) *Traversal

Add is the public API for adding new nodes to the traversal by its sub packages.

func (*Traversal) AddE

func (t *Traversal) AddE(args ...interface{}) *Traversal

AddE adds an edge.

func (*Traversal) AddV

func (t *Traversal) AddV(args ...interface{}) *Traversal

AddV adds a vertex.

func (*Traversal) And

func (t *Traversal) And(args ...interface{}) *Traversal

And ensures that all of the provided traversals yield a result.

func (*Traversal) As

func (t *Traversal) As(args ...interface{}) *Traversal

As provides a label to the step that can be accessed later in the traversal by other steps.

func (*Traversal) Both

func (t *Traversal) Both(args ...interface{}) *Traversal

Both maps the Vertex to its adjacent vertices given the edge labels.

func (*Traversal) BothE

func (t *Traversal) BothE(args ...interface{}) *Traversal

BothE maps the Vertex to its incident edges given the edge labels.

func (*Traversal) By

func (t *Traversal) By(args ...interface{}) *Traversal

By can be applied to a number of different step to alter their behaviors. This form is essentially an identity() modulation.

func (*Traversal) Choose

func (t *Traversal) Choose(args ...interface{}) *Traversal

Choose routes the current traverser to a particular traversal branch option which allows the creation of if-then-else like semantics within a traversal.

func (*Traversal) Clone

func (t *Traversal) Clone() *Traversal

Clone creates a deep copy of an existing traversal.

func (*Traversal) Coalesce

func (t *Traversal) Coalesce(args ...interface{}) *Traversal

Coalesce evaluates the provided traversals and returns the result of the first traversal to emit at least one object.

func (*Traversal) Constant

func (t *Traversal) Constant(args ...interface{}) *Traversal

Constant maps any object to a fixed E value.

func (*Traversal) Count

func (t *Traversal) Count(args ...interface{}) *Traversal

Count maps the traversal stream to its reduction as a sum of the Traverser.bulk() values (i.e. count the number of traversers up to this point).

func (*Traversal) Dedup

func (t *Traversal) Dedup(args ...interface{}) *Traversal

Dedup removes all duplicates in the traversal stream up to this point.

func (*Traversal) Drop

func (t *Traversal) Drop() *Traversal

Drop removes elements and properties from the graph.

func (*Traversal) E

func (t *Traversal) E(args ...interface{}) *Traversal

E step is usually used to start a traversal but it may also be used mid-traversal.

func (*Traversal) Fold

func (t *Traversal) Fold() *Traversal

Fold rolls up objects in the stream into an aggregate list..

func (*Traversal) From

func (t *Traversal) From(args ...interface{}) *Traversal

From provides from()-modulation to respective steps.

func (*Traversal) Group

func (t *Traversal) Group() *Traversal

Group organizes objects in the stream into a Map.Calls to group() are typically accompanied with by() modulators which help specify how the grouping should occur.

func (*Traversal) Has

func (t *Traversal) Has(args ...interface{}) *Traversal

Has filters vertices, edges and vertex properties based on their properties. See: http://tinkerpop.apache.org/docs/current/reference/#has-step.

func (*Traversal) HasID

func (t *Traversal) HasID(args ...interface{}) *Traversal

HasID filters vertices, edges and vertex properties based on their identifier.

func (*Traversal) HasLabel

func (t *Traversal) HasLabel(args ...interface{}) *Traversal

HasLabel filters vertices, edges and vertex properties based on their label.

func (*Traversal) HasNext

func (t *Traversal) HasNext() *Traversal

HasNext returns true if the iteration has more elements.

func (*Traversal) HasNot

func (t *Traversal) HasNot(args ...interface{}) *Traversal

HasNot filters vertices, edges and vertex properties based on the non-existence of properties. See: http://tinkerpop.apache.org/docs/current/reference/#has-step.

func (*Traversal) ID

func (t *Traversal) ID() *Traversal

ID maps the Element to its Element.id().

func (*Traversal) In

func (t *Traversal) In(args ...interface{}) *Traversal

In maps the Vertex to its incoming adjacent vertices given the edge labels.

func (*Traversal) InE

func (t *Traversal) InE(args ...interface{}) *Traversal

InE maps the Vertex to its incoming incident edges given the edge labels.

func (*Traversal) InV

func (t *Traversal) InV(args ...interface{}) *Traversal

InV maps the Edge to its incoming/head incident Vertex.

func (*Traversal) Is

func (t *Traversal) Is(args ...interface{}) *Traversal

Is filters the E object if it is not P.eq(V) to the provided value.

func (*Traversal) Iterate

func (t *Traversal) Iterate() *Traversal

Iterate iterates the traversal presumably for the generation of side-effects.

func (*Traversal) Label

func (t *Traversal) Label() *Traversal

Label maps the Element to its Element.label().

func (*Traversal) Limit

func (t *Traversal) Limit(args ...interface{}) *Traversal

Limit filters the objects in the traversal by the number of them to pass through the stream, where only the first n objects are allowed as defined by the limit argument.

func (*Traversal) Match

func (t *Traversal) Match(args ...interface{}) *Traversal

Match maps the Traverser to a Map of bindings as specified by the provided match traversals.

func (*Traversal) Max

func (t *Traversal) Max(args ...interface{}) *Traversal

Max determines the greatest value in the stream.

func (*Traversal) Mean

func (t *Traversal) Mean(args ...interface{}) *Traversal

Mean determines the mean value in the stream.

func (*Traversal) Min

func (t *Traversal) Min(args ...interface{}) *Traversal

Min determines the smallest value in the stream.

func (*Traversal) Next

func (t *Traversal) Next() *Traversal

Next gets the next n-number of results from the traversal.

func (*Traversal) Not

func (t *Traversal) Not(args ...interface{}) *Traversal

Not removes objects from the traversal stream when the traversal provided as an argument does not return any objects.

func (*Traversal) Or

func (t *Traversal) Or(args ...interface{}) *Traversal

Or ensures that at least one of the provided traversals yield a result.

func (*Traversal) Order

func (t *Traversal) Order(args ...interface{}) *Traversal

Order all the objects in the traversal up to this point and then emit them one-by-one in their ordered sequence.

func (*Traversal) OtherV

func (t *Traversal) OtherV() *Traversal

OtherV maps the Edge to the incident vertex that was not just traversed from in the path history.

func (*Traversal) Out

func (t *Traversal) Out(args ...interface{}) *Traversal

Out maps the Vertex to its outgoing adjacent vertices given the edge labels.

func (*Traversal) OutE

func (t *Traversal) OutE(args ...interface{}) *Traversal

OutE maps the Vertex to its outgoing incident edges given the edge labels.

func (*Traversal) OutV

func (t *Traversal) OutV(args ...interface{}) *Traversal

OutV maps the Edge to its outgoing/tail incident Vertex.

func (*Traversal) Properties

func (t *Traversal) Properties(args ...interface{}) *Traversal

Properties maps the Element to its associated properties given the provide property keys.

func (*Traversal) Property

func (t *Traversal) Property(args ...interface{}) *Traversal

Property sets a Property value and related meta properties if supplied, if supported by the Graph and if the Element is a VertexProperty.

func (*Traversal) Query

func (t *Traversal) Query() (string, Bindings)

Query returns the query-representation and its binding of this traversal object.

func (*Traversal) Range

func (t *Traversal) Range(args ...interface{}) *Traversal

Range filters the objects in the traversal by the number of them to pass through the stream.

func (*Traversal) Select

func (t *Traversal) Select(args ...interface{}) *Traversal

Select arbitrary values from the traversal.

func (*Traversal) SideEffect

func (t *Traversal) SideEffect(args ...interface{}) *Traversal

SideEffect allows the traverser to proceed unchanged, but yield some computational sideEffect in the process.

func (*Traversal) Sum

func (t *Traversal) Sum(args ...interface{}) *Traversal

Sum maps the traversal stream to its reduction as a sum of the Traverser.get() values multiplied by their Traverser.bulk().

func (*Traversal) To

func (t *Traversal) To(args ...interface{}) *Traversal

To used as a modifier to addE(String) this method specifies the traversal to use for selecting the incoming vertex of the newly added Edge.

func (*Traversal) ToList

func (t *Traversal) ToList() *Traversal

ToList puts all the results into a Groovy list.

func (*Traversal) Undo

func (t *Traversal) Undo() *Traversal

Undo reverts the last-step of the traversal.

func (*Traversal) Unfold

func (t *Traversal) Unfold() *Traversal

Unfold unrolls a Iterator, Iterable or Map into a linear form or simply emits the object if it is not one of those types.

func (*Traversal) Union

func (t *Traversal) Union(args ...interface{}) *Traversal

Union merges the results of an arbitrary number of traversals.

func (*Traversal) V

func (t *Traversal) V(args ...interface{}) *Traversal

V step is usually used to start a traversal but it may also be used mid-traversal.

func (*Traversal) ValueMap

func (t *Traversal) ValueMap(args ...interface{}) *Traversal

ValueMap maps the Element to a Map of the property values key'd according to their Property.key().

func (*Traversal) Values

func (t *Traversal) Values(args ...string) *Traversal

Values maps the Element to the values of the associated properties given the provide property keys.

func (*Traversal) Where

func (t *Traversal) Where(args ...interface{}) *Traversal

Where filters the current object based on the object itself or the path history.

type Var

type Var struct {
	Name string
	Elem interface{}
}

Var represents a variable assignment and usage.

func (Var) Code

func (v Var) Code() (string, []interface{})

Code returns the code representation of variable declaration or its identifier.

Directories

Path Synopsis
g
p