Package org.umlg.sqlg.structure

Class __

java.lang.Object
org.umlg.sqlg.structure.__
public final class __ extends Object

  • Method Details

    • start

      public static <A> SqlgTraversal<A,A> start()

    • dijkstra

      public static <S> SqlgTraversal<S,org.apache.tinkerpop.gremlin.process.traversal.Path> dijkstra(long startVid, long endVid, boolean directed)

    • dijkstra

      public static <S> SqlgTraversal<S,org.apache.tinkerpop.gremlin.process.traversal.Path> dijkstra(List<Long> startVids, List<Long> endVids, boolean directed)

    • dijkstra

      public static <S> SqlgTraversal<S,org.apache.tinkerpop.gremlin.process.traversal.Path> dijkstra(long startVid, List<Long> endVids, boolean directed)

    • dijkstra

      public static <S> SqlgTraversal<S,org.apache.tinkerpop.gremlin.process.traversal.Path> dijkstra(List<Long> startVids, long endVid, boolean directed)

    • fun

      public static <R, S> SqlgTraversal<S,R> fun(String columnName, PropertyType functionResultPropertyType, Function<Object,String> fun)

    • l2distance

      public static <R, S> SqlgTraversal<S,R> l2distance(String columnName, String source, float... target)

    • l1distance

      public static <R, S> SqlgTraversal<S,R> l1distance(String columnName, String source, float... target)

    • innerProduct

      public static <R, S> SqlgTraversal<S,R> innerProduct(String columnName, String source, float... target)

    • cosineDistance

      public static <R, S> SqlgTraversal<S,R> cosineDistance(String columnName, String source, float... target)

    • hammingDistance

      public static <R, S> SqlgTraversal<S,R> hammingDistance(String columnName, String source, boolean... target)

    • jaccardDistance

      public static <R, S> SqlgTraversal<S,R> jaccardDistance(String columnName, String source, boolean... target)

    • __

      public static <A> SqlgTraversal<A,A> __(A... starts)

    • map

      public static <A, B> SqlgTraversal<A,B> map(Function<org.apache.tinkerpop.gremlin.process.traversal.Traverser<A>,B> function)

    • map

      public static <A, B> SqlgTraversal<A,B> map(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,B> mapTraversal)

    • flatMap

      public static <A, B> SqlgTraversal<A,B> flatMap(Function<org.apache.tinkerpop.gremlin.process.traversal.Traverser<A>,Iterator<B>> function)

    • flatMap

      public static <A, B> SqlgTraversal<A,B> flatMap(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,B> flatMapTraversal)

    • identity

      public static <A> SqlgTraversal<A,A> identity()

    • constant

      public static <A> SqlgTraversal<A,A> constant(A a)

    • label

      public static <A extends org.apache.tinkerpop.gremlin.structure.Element> SqlgTraversal<A,String> label()

    • id

      public static <A extends org.apache.tinkerpop.gremlin.structure.Element> SqlgTraversal<A,Object> id()

    • V

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Vertex> V(Object... vertexIdsOrElements)

    • E

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Edge> E(Object... edgeIdsOrElements)

    • to

      public static SqlgTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,org.apache.tinkerpop.gremlin.structure.Vertex> to(org.apache.tinkerpop.gremlin.structure.Direction direction, String... edgeLabels)

    • out

      public static SqlgTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,org.apache.tinkerpop.gremlin.structure.Vertex> out(String... edgeLabels)

    • in

      public static SqlgTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,org.apache.tinkerpop.gremlin.structure.Vertex> in(String... edgeLabels)

    • both

      public static SqlgTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,org.apache.tinkerpop.gremlin.structure.Vertex> both(String... edgeLabels)

    • toE

      public static SqlgTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,org.apache.tinkerpop.gremlin.structure.Edge> toE(org.apache.tinkerpop.gremlin.structure.Direction direction, String... edgeLabels)

    • outE

      public static SqlgTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,org.apache.tinkerpop.gremlin.structure.Edge> outE(String... edgeLabels)

    • inE

      public static SqlgTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,org.apache.tinkerpop.gremlin.structure.Edge> inE(String... edgeLabels)

    • bothE

      public static SqlgTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,org.apache.tinkerpop.gremlin.structure.Edge> bothE(String... edgeLabels)

    • toV

      public static SqlgTraversal<org.apache.tinkerpop.gremlin.structure.Edge,org.apache.tinkerpop.gremlin.structure.Vertex> toV(org.apache.tinkerpop.gremlin.structure.Direction direction)

    • inV

      public static SqlgTraversal<org.apache.tinkerpop.gremlin.structure.Edge,org.apache.tinkerpop.gremlin.structure.Vertex> inV()

    • outV

      public static SqlgTraversal<org.apache.tinkerpop.gremlin.structure.Edge,org.apache.tinkerpop.gremlin.structure.Vertex> outV()

    • bothV

      public static SqlgTraversal<org.apache.tinkerpop.gremlin.structure.Edge,org.apache.tinkerpop.gremlin.structure.Vertex> bothV()

    • otherV

      public static SqlgTraversal<org.apache.tinkerpop.gremlin.structure.Edge,org.apache.tinkerpop.gremlin.structure.Vertex> otherV()

    • order

      public static <A> SqlgTraversal<A,A> order()

    • order

      public static <A> SqlgTraversal<A,A> order(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • properties

      public static <A extends org.apache.tinkerpop.gremlin.structure.Element, B> SqlgTraversal<A,? extends org.apache.tinkerpop.gremlin.structure.Property<B>> properties(String... propertyKeys)

    • values

      public static <A extends org.apache.tinkerpop.gremlin.structure.Element, B> SqlgTraversal<A,B> values(String... propertyKeys)

    • propertyMap

      public static <A extends org.apache.tinkerpop.gremlin.structure.Element, B> SqlgTraversal<A,Map<String,B>> propertyMap(String... propertyKeys)

    • elementMap

      public static <A extends org.apache.tinkerpop.gremlin.structure.Element, B> SqlgTraversal<A,Map<Object,B>> elementMap(String... propertyKeys)

    • valueMap

      public static <A extends org.apache.tinkerpop.gremlin.structure.Element, B> SqlgTraversal<A,Map<Object,B>> valueMap(String... propertyKeys)

    • valueMap

      public static <A extends org.apache.tinkerpop.gremlin.structure.Element, B> SqlgTraversal<A,Map<Object,B>> valueMap(boolean includeTokens, String... propertyKeys)

    • project

      public static <A, B> SqlgTraversal<A,Map<String,B>> project(String projectKey, String... projectKeys)

    • select

      public static <A, B> SqlgTraversal<A,Collection<B>> select(org.apache.tinkerpop.gremlin.structure.Column column)

    • key

      public static <A extends org.apache.tinkerpop.gremlin.structure.Property> SqlgTraversal<A,String> key()

    • value

      public static <A extends org.apache.tinkerpop.gremlin.structure.Property, B> SqlgTraversal<A,B> value()

    • path

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.process.traversal.Path> path()

    • match

      public static <A, B> SqlgTraversal<A,Map<String,B>> match(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?>... matchTraversals)

    • sack

      public static <A, B> SqlgTraversal<A,B> sack()

    • loops

      public static <A> SqlgTraversal<A,Integer> loops()

    • loops

      public static <A> SqlgTraversal<A,Integer> loops(String loopName)

    • select

      public static <A, B> SqlgTraversal<A,B> select(org.apache.tinkerpop.gremlin.process.traversal.Pop pop, String selectKey)

    • select

      public static <A, B> SqlgTraversal<A,B> select(String selectKey)

    • select

      public static <A, B> SqlgTraversal<A,Map<String,B>> select(org.apache.tinkerpop.gremlin.process.traversal.Pop pop, String selectKey1, String selectKey2, String... otherSelectKeys)

    • select

      public static <A, B> SqlgTraversal<A,Map<String,B>> select(String selectKey1, String selectKey2, String... otherSelectKeys)

    • select

      public static <A, B> SqlgTraversal<A,B> select(org.apache.tinkerpop.gremlin.process.traversal.Pop pop, org.apache.tinkerpop.gremlin.process.traversal.Traversal<A,B> keyTraversal)

    • select

      public static <A, B> SqlgTraversal<A,B> select(org.apache.tinkerpop.gremlin.process.traversal.Traversal<A,B> keyTraversal)

    • unfold

      public static <A> SqlgTraversal<A,A> unfold()

    • fold

      public static <A> SqlgTraversal<A,List<A>> fold()

    • fold

      public static <A, B> SqlgTraversal<A,B> fold(B seed, BiFunction<B,A,B> foldFunction)

    • count

      public static <A> SqlgTraversal<A,Long> count()

    • count

      public static <A> SqlgTraversal<A,Long> count(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • sum

      public static <A> SqlgTraversal<A,Double> sum()

    • sum

      public static <A> SqlgTraversal<A,Double> sum(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • min

      public static <A, B extends Comparable> SqlgTraversal<A,B> min()

    • min

      public static <A, B extends Comparable> SqlgTraversal<A,B> min(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • max

      public static <A, B extends Comparable> SqlgTraversal<A,B> max()

    • max

      public static <A, B extends Comparable> SqlgTraversal<A,B> max(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • mean

      public static <A> SqlgTraversal<A,Double> mean()

    • mean

      public static <A> SqlgTraversal<A,Double> mean(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • group

      public static <A, K, V> SqlgTraversal<A,Map<K,V>> group()

    • groupCount

      public static <A, K> SqlgTraversal<A,Map<K,Long>> groupCount()

    • tree

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.process.traversal.step.util.Tree> tree()

    • addV

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Vertex> addV(String vertexLabel)

    • addV

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Vertex> addV(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,String> vertexLabelTraversal)

    • addV

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Vertex> addV()

    • mergeV

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Vertex> mergeV()

    • mergeV

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Vertex> mergeV(Map<Object,Object> searchCreate)

    • mergeV

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Vertex> mergeV(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,Map<Object,Object>> searchCreate)

    • addE

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Edge> addE(String edgeLabel)

    • addE

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Edge> addE(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,String> edgeLabelTraversal)

    • mergeE

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Edge> mergeE()

    • mergeE

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Edge> mergeE(Map<Object,Object> searchCreate)

    • mergeE

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Edge> mergeE(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,Map<Object,Object>> searchCreate)

    • math

      public static <A> SqlgTraversal<A,Double> math(String expression)

    • concat

      public static <A> SqlgTraversal<A,String> concat(org.apache.tinkerpop.gremlin.process.traversal.Traversal<A,String> concatTraversal, org.apache.tinkerpop.gremlin.process.traversal.Traversal<A,String>... otherConcatTraversals)

    • concat

      public static <A> SqlgTraversal<A,String> concat(String... concatString)

    • asString

      public static <A> SqlgTraversal<A,String> asString()

    • asString

      public static <A, B> SqlgTraversal<A,B> asString(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • length

      public static <A> SqlgTraversal<A,Integer> length()

    • length

      public static <A, B> SqlgTraversal<A,B> length(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • toLower

      public static <A> SqlgTraversal<A,String> toLower()

    • toLower

      public static <A, B> SqlgTraversal<A,B> toLower(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • toUpper

      public static <A> SqlgTraversal<A,String> toUpper()

    • toUpper

      public static <A, B> SqlgTraversal<A,B> toUpper(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • trim

      public static <A> SqlgTraversal<A,String> trim()

    • trim

      public static <A, B> SqlgTraversal<A,B> trim(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • lTrim

      public static <A> SqlgTraversal<A,String> lTrim()

    • lTrim

      public static <A, B> SqlgTraversal<A,B> lTrim(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • rTrim

      public static <A> SqlgTraversal<A,String> rTrim()

    • rTrim

      public static <A, B> SqlgTraversal<A,B> rTrim(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • reverse

      public static <A, B> SqlgTraversal<A,B> reverse()

    • replace

      public static <A> SqlgTraversal<A,String> replace(String oldChar, String newChar)

    • replace

      public static <A, B> SqlgTraversal<A,B> replace(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, String oldChar, String newChar)

    • split

      public static <A> SqlgTraversal<A,List<String>> split(String separator)

    • split

      public static <A, B> SqlgTraversal<A,List<B>> split(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, String separator)

    • substring

      public static <A> SqlgTraversal<A,String> substring(int startIndex)

    • substring

      public static <A, B> SqlgTraversal<A,B> substring(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, int startIndex)

    • substring

      public static <A> SqlgTraversal<A,String> substring(int startIndex, int endIndex)

    • substring

      public static <A, B> SqlgTraversal<A,B> substring(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, int startIndex, int endIndex)

    • format

      public static <A> SqlgTraversal<A,String> format(String format)

    • asDate

      public static <A> SqlgTraversal<A,Date> asDate()

    • dateAdd

      public static <A> SqlgTraversal<A,Date> dateAdd(org.apache.tinkerpop.gremlin.process.traversal.DT dateToken, int value)

    • dateDiff

      public static <A> SqlgTraversal<A,Long> dateDiff(Date value)

    • dateDiff

      public static <A> SqlgTraversal<A,Long> dateDiff(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,Date> dateTraversal)

    • difference

      public static <A> SqlgTraversal<A,Set<?>> difference(Object values)

    • disjunct

      public static <A> SqlgTraversal<A,Set<?>> disjunct(Object values)

    • intersect

      public static <A> SqlgTraversal<A,Set<?>> intersect(Object values)

    • conjoin

      public static <A> SqlgTraversal<A,String> conjoin(String values)

    • merge

      public static <A, B> SqlgTraversal<A,B> merge(Object values)

    • combine

      public static <A> SqlgTraversal<A,List<?>> combine(Object values)

    • product

      public static <A> SqlgTraversal<A,List<List<?>>> product(Object values)

    • filter

      public static <A> SqlgTraversal<A,A> filter(Predicate<org.apache.tinkerpop.gremlin.process.traversal.Traverser<A>> predicate)

    • filter

      public static <A> SqlgTraversal<A,A> filter(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> filterTraversal)

    • and

      public static <A> SqlgTraversal<A,A> and(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?>... andTraversals)

    • or

      public static <A> SqlgTraversal<A,A> or(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?>... orTraversals)

    • inject

      public static <A> SqlgTraversal<A,A> inject(A... injections)

    • dedup

      public static <A> SqlgTraversal<A,A> dedup(String... dedupLabels)

    • dedup

      public static <A> SqlgTraversal<A,A> dedup(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, String... dedupLabels)

    • has

      public static <A> SqlgTraversal<A,A> has(String propertyKey, org.apache.tinkerpop.gremlin.process.traversal.P<?> predicate)

    • has

      public static <A> SqlgTraversal<A,A> has(org.apache.tinkerpop.gremlin.structure.T accessor, org.apache.tinkerpop.gremlin.process.traversal.P<?> predicate)

    • has

      public static <A> SqlgTraversal<A,A> has(String propertyKey, Object value)

    • has

      public static <A> SqlgTraversal<A,A> has(org.apache.tinkerpop.gremlin.structure.T accessor, Object value)

    • has

      public static <A> SqlgTraversal<A,A> has(String label, String propertyKey, Object value)

    • has

      public static <A> SqlgTraversal<A,A> has(String label, String propertyKey, org.apache.tinkerpop.gremlin.process.traversal.P<?> predicate)

    • has

      public static <A> SqlgTraversal<A,A> has(org.apache.tinkerpop.gremlin.structure.T accessor, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> propertyTraversal)

    • has

      public static <A> SqlgTraversal<A,A> has(String propertyKey, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> propertyTraversal)

    • has

      public static <A> SqlgTraversal<A,A> has(String propertyKey)

    • hasNot

      public static <A> SqlgTraversal<A,A> hasNot(String propertyKey)

    • hasLabel

      public static <A> SqlgTraversal<A,A> hasLabel(String label, String... otherLabels)

    • hasLabel

      public static <A> SqlgTraversal<A,A> hasLabel(org.apache.tinkerpop.gremlin.process.traversal.P<String> predicate)

    • hasId

      public static <A> SqlgTraversal<A,A> hasId(Object id, Object... otherIds)

    • hasId

      public static <A> SqlgTraversal<A,A> hasId(org.apache.tinkerpop.gremlin.process.traversal.P<Object> predicate)

    • hasKey

      public static <A> SqlgTraversal<A,A> hasKey(String label, String... otherLabels)

    • hasKey

      public static <A> SqlgTraversal<A,A> hasKey(org.apache.tinkerpop.gremlin.process.traversal.P<String> predicate)

    • hasValue

      public static <A> SqlgTraversal<A,A> hasValue(Object value, Object... values)

    • hasValue

      public static <A> SqlgTraversal<A,A> hasValue(org.apache.tinkerpop.gremlin.process.traversal.P<Object> predicate)

    • where

      public static <A> SqlgTraversal<A,A> where(String startKey, org.apache.tinkerpop.gremlin.process.traversal.P<String> predicate)

    • where

      public static <A> SqlgTraversal<A,A> where(org.apache.tinkerpop.gremlin.process.traversal.P<String> predicate)

    • where

      public static <A> SqlgTraversal<A,A> where(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> whereTraversal)

    • is

      public static <A> SqlgTraversal<A,A> is(org.apache.tinkerpop.gremlin.process.traversal.P<A> predicate)

    • is

      public static <A> SqlgTraversal<A,A> is(Object value)

    • not

      public static <A> SqlgTraversal<A,A> not(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> notTraversal)

    • coin

      public static <A> SqlgTraversal<A,A> coin(double probability)

    • range

      public static <A> SqlgTraversal<A,A> range(long low, long high)

    • range

      public static <A> SqlgTraversal<A,A> range(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, long low, long high)

    • limit

      public static <A> SqlgTraversal<A,A> limit(long limit)

    • limit

      public static <A> SqlgTraversal<A,A> limit(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, long limit)

    • skip

      public static <A> SqlgTraversal<A,A> skip(long skip)

    • skip

      public static <A> SqlgTraversal<A,A> skip(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, long skip)

    • tail

      public static <A> SqlgTraversal<A,A> tail()

    • tail

      public static <A> SqlgTraversal<A,A> tail(long limit)

    • tail

      public static <A> SqlgTraversal<A,A> tail(org.apache.tinkerpop.gremlin.process.traversal.Scope scope)

    • tail

      public static <A> SqlgTraversal<A,A> tail(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, long limit)

    • simplePath

      public static <A> SqlgTraversal<A,A> simplePath()

    • cyclicPath

      public static <A> SqlgTraversal<A,A> cyclicPath()

    • sample

      public static <A> SqlgTraversal<A,A> sample(int amountToSample)

    • sample

      public static <A> SqlgTraversal<A,A> sample(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, int amountToSample)

    • drop

      public static <A> SqlgTraversal<A,A> drop()

    • all

      public static <A> SqlgTraversal<A,A> all(org.apache.tinkerpop.gremlin.process.traversal.P<A> predicate)

    • any

      public static <A> SqlgTraversal<A,A> any(org.apache.tinkerpop.gremlin.process.traversal.P<A> predicate)

    • sideEffect

      public static <A> SqlgTraversal<A,A> sideEffect(Consumer<org.apache.tinkerpop.gremlin.process.traversal.Traverser<A>> consumer)

    • sideEffect

      public static <A> SqlgTraversal<A,A> sideEffect(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> sideEffectTraversal)

    • cap

      public static <A, B> SqlgTraversal<A,B> cap(String sideEffectKey, String... sideEffectKeys)

    • subgraph

      public static <A> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Edge> subgraph(String sideEffectKey)

    • aggregate

      public static <A> SqlgTraversal<A,A> aggregate(String sideEffectKey)

    • aggregate

      public static <A> SqlgTraversal<A,A> aggregate(org.apache.tinkerpop.gremlin.process.traversal.Scope scope, String sideEffectKey)

    • fail

      public static <A> SqlgTraversal<A,A> fail()

    • fail

      public static <A> SqlgTraversal<A,A> fail(String message)

    • group

      public static <A> SqlgTraversal<A,A> group(String sideEffectKey)

    • groupCount

      public static <A> SqlgTraversal<A,A> groupCount(String sideEffectKey)

    • timeLimit

      public static <A> SqlgTraversal<A,A> timeLimit(long timeLimit)

    • tree

      public static <A> SqlgTraversal<A,A> tree(String sideEffectKey)

    • sack

      public static <A, V, U> SqlgTraversal<A,A> sack(BiFunction<V,U,V> sackOperator)

    • store

      public static <A> SqlgTraversal<A,A> store(String sideEffectKey)

    • property

      public static <A> SqlgTraversal<A,A> property(Object key, Object value, Object... keyValues)

    • property

      public static <A> SqlgTraversal<A,A> property(org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality cardinality, Object key, Object value, Object... keyValues)

    • property

      public static <A> SqlgTraversal<A,A> property(Map<Object,Object> value)

    • branch

      public static <A, M, B> SqlgTraversal<A,B> branch(Function<org.apache.tinkerpop.gremlin.process.traversal.Traverser<A>,M> function)

    • branch

      public static <A, M, B> SqlgTraversal<A,B> branch(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,M> traversalFunction)

    • choose

      public static <A, B> SqlgTraversal<A,B> choose(Predicate<A> choosePredicate, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,B> trueChoice, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,B> falseChoice)

    • choose

      public static <A, B> SqlgTraversal<A,B> choose(Predicate<A> choosePredicate, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,B> trueChoice)

    • choose

      public static <A, M, B> SqlgTraversal<A,B> choose(Function<A,M> choiceFunction)

    • choose

      public static <A, M, B> SqlgTraversal<A,B> choose(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,M> traversalFunction)

    • choose

      public static <A, M, B> SqlgTraversal<A,B> choose(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,M> traversalPredicate, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,B> trueChoice, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,B> falseChoice)

    • choose

      public static <A, M, B> SqlgTraversal<A,B> choose(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,M> traversalPredicate, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,B> trueChoice)

    • optional

      public static <A> SqlgTraversal<A,A> optional(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,A> optionalTraversal)

    • union

      public static <A, B> SqlgTraversal<A,B> union(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,B>... traversals)

    • coalesce

      public static <A, B> SqlgTraversal<A,B> coalesce(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,B>... traversals)

    • repeat

      public static <A> SqlgTraversal<A,A> repeat(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,A> traversal)

    • repeat

      public static <A> SqlgTraversal<A,A> repeat(String loopName, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,A> traversal)

    • emit

      public static <A> SqlgTraversal<A,A> emit(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> emitTraversal)

    • emit

      public static <A> SqlgTraversal<A,A> emit(Predicate<org.apache.tinkerpop.gremlin.process.traversal.Traverser<A>> emitPredicate)

    • until

      public static <A> SqlgTraversal<A,A> until(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,?> untilTraversal)

    • until

      public static <A> SqlgTraversal<A,A> until(Predicate<org.apache.tinkerpop.gremlin.process.traversal.Traverser<A>> untilPredicate)

    • times

      public static <A> SqlgTraversal<A,A> times(int maxLoops)

    • emit

      public static <A> SqlgTraversal<A,A> emit()

    • local

      public static <A, B> SqlgTraversal<A,B> local(org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,B> localTraversal)

    • as

      public static <A> SqlgTraversal<A,A> as(String label, String... labels)

    • barrier

      public static <A> SqlgTraversal<A,A> barrier()

    • barrier

      public static <A> SqlgTraversal<A,A> barrier(int maxBarrierSize)

    • barrier

      public static <A> SqlgTraversal<A,A> barrier(Consumer<org.apache.tinkerpop.gremlin.process.traversal.traverser.util.TraverserSet<Object>> barrierConsumer)

    • index

      public static <A, B> SqlgTraversal<A,B> index()

    • element

      public static <A, B> SqlgTraversal<A,org.apache.tinkerpop.gremlin.structure.Element> element()

    • call

      public static <A, B> SqlgTraversal<A,B> call(String service)

    • call

      public static <A, B> SqlgTraversal<A,B> call(String service, Map params)

    • call

      public static <A, B> SqlgTraversal<A,B> call(String service, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,Map<?,?>> childTraversal)

    • call

      public static <A, B> SqlgTraversal<A,B> call(String service, Map params, org.apache.tinkerpop.gremlin.process.traversal.Traversal<?,Map<?,?>> childTraversal)