DseGraphTraversal

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val TraversersColumn: Column

val TraversersColumnName: String

def V(arg0: <repeated...>[AnyRef]): GraphTraversal[Row, Vertex]

def addE(arg0: Traversal[_, String]): GraphTraversal[Row, Edge]

def addE(arg0: String): GraphTraversal[Row, Edge]

def addStart(arg0: Admin[Row]): Unit

def addStarts(arg0: Iterator[Admin[Row]]): Unit

def addStep[E2](arg0: Step[_, E2]): Admin[Row, E2]

def addStep[S2, E2](arg0: Int, arg1: Step[_, _]): Admin[S2, E2]

def addTraverserColumn(label: String, df: DataFrame): DataFrame

as(), where() and some other steps need a place to store a state of the treverser.

def addV(): GraphTraversal[Row, Vertex]

def addV(arg0: Traversal[_, String]): GraphTraversal[Row, Vertex]

def addV(arg0: String): GraphTraversal[Row, Vertex]

def aggregate(arg0: Scope, arg1: String): GraphTraversal[Row, E]

def aggregate(arg0: String): GraphTraversal[Row, E]

def and(arg0: <repeated...>[Traversal[_, _]]): GraphTraversal[Row, E]

def applyStrategies(): Unit

def as(arg0: String, arg1: <repeated...>[String]): GraphTraversal[Row, E]

def asAdmin(): Admin[Row, E]

final def asInstanceOf[T0]: T0

def barrier(arg0: Consumer[TraverserSet[AnyRef]]): GraphTraversal[Row, E]

def barrier(arg0: Int): GraphTraversal[Row, E]

def barrier(): GraphTraversal[Row, E]

def both(arg0: <repeated...>[String]): GraphTraversal[Row, Vertex]

def bothE(arg0: <repeated...>[String]): GraphTraversal[Row, Edge]

def bothV(): GraphTraversal[Row, Vertex]

def branch[M, E2](arg0: Function[Traverser[E], M]): GraphTraversal[Row, E2]

def branch[M, E2](arg0: Traversal[_, M]): GraphTraversal[Row, E2]

def by[U](arg0: Function[U, AnyRef], arg1: Comparator): GraphTraversal[Row, E]

def by[V](arg0: String, arg1: Comparator[V]): GraphTraversal[Row, E]

def by(arg0: org.apache.tinkerpop.gremlin.process.traversal.Order): GraphTraversal[Row, E]

def by(arg0: Comparator[E]): GraphTraversal[Row, E]

def by[V](arg0: Traversal[_, _], arg1: Comparator[V]): GraphTraversal[Row, E]

def by[V](arg0: Function[V, AnyRef]): GraphTraversal[Row, E]

def by(arg0: String): GraphTraversal[Row, E]

def by(arg0: T): GraphTraversal[Row, E]

def by(arg0: Traversal[_, _]): GraphTraversal[Row, E]

def by(): GraphTraversal[Row, E]

def cap[E2](arg0: String, arg1: <repeated...>[String]): GraphTraversal[Row, E2]

def catalystTypeConverter(dataType: DataType): TypeConverter[_]

select proper connector type converter base on Catalyst type.

def choose[E2](arg0: Predicate[E], arg1: Traversal[_, E2]): GraphTraversal[Row, E2]

def choose[E2](arg0: Predicate[E], arg1: Traversal[_, E2], arg2: Traversal[_, E2]): GraphTraversal[Row, E2]

def choose[M, E2](arg0: Function[E, M]): GraphTraversal[Row, E2]

def choose[E2](arg0: Traversal[_, _], arg1: Traversal[_, E2]): GraphTraversal[Row, E2]

def choose[E2](arg0: Traversal[_, _], arg1: Traversal[_, E2], arg2: Traversal[_, E2]): GraphTraversal[Row, E2]

def choose[M, E2](arg0: Traversal[_, M]): GraphTraversal[Row, E2]

def clone(): DefaultGraphTraversal[Row, E]

def close(): Unit

def coalesce[E2](arg0: <repeated...>[Traversal[_, E2]]): GraphTraversal[Row, E2]

def coin(arg0: Double): GraphTraversal[Row, E]

def connectedComponent(): GraphTraversal[Row, E]

def constant[E2](arg0: E2): GraphTraversal[Row, E2]

def copySteps[T](traversal: Admin[_, _]): DseGraphTraversal[T]

add steps from another traversal, the first graph step is skipped.

def count(arg0: Scope): GraphTraversal[Row, Long]

def count(): GraphTraversal[Row, Long]

def customPredicateUdf(p: P[_], column: Column, columnName: String): Column

def cyclicPath(): GraphTraversal[Row, E]

def dedup(arg0: <repeated...>[String]): GraphTraversal[Row, E]

def dedup(arg0: Scope, arg1: <repeated...>[String]): GraphTraversal[Row, E]

def df: DataFrame

the main processing method.

val dgf: DseGraphFrame

def drop(): GraphTraversal[Row, E]

def edgeToVertexWithDirection(v: DataFrame, e: DataFrame, in: Boolean, idOnly: Boolean): DataFrame

def elementMap[E2](arg0: <repeated...>[String]): GraphTraversal[Row, Map[AnyRef, E2]]

def emit(): GraphTraversal[Row, E]

def emit(arg0: Predicate[Traverser[E]]): GraphTraversal[Row, E]

def emit(arg0: Traversal[_, _]): GraphTraversal[Row, E]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def equals(arg0: Admin[Row, E]): Boolean

def explain(): TraversalExplanation

def extractColumnsFromElementTraversal(traversal: Traversal[_, _], result: DataFrame): Seq[String]

def fill[C <: Collection[E]](arg0: C): C

def filter(arg0: Traversal[_, _]): GraphTraversal[Row, E]

def filter(arg0: Predicate[Traverser[E]]): GraphTraversal[Row, E]

def finalize(): Unit

def findResultStep(step: Step[_, _]): Step[_, _]

val find result step by skipping sorting and dedup

def flatMap[E2](arg0: Traversal[_, E2]): GraphTraversal[Row, E2]

def flatMap[E2](arg0: Function[Traverser[E], Iterator[E2]]): GraphTraversal[Row, E2]

def fold[E2](arg0: E2, arg1: BiFunction[E2, E, E2]): GraphTraversal[Row, E2]

def fold(): GraphTraversal[Row, List[E]]

def forEachRemaining(arg0: Consumer[_ >: E]): Unit

def forEachRemaining[E2](arg0: Class[E2], arg1: Consumer[E2]): Unit

def from(arg0: Vertex): GraphTraversal[Row, E]

def from(arg0: Traversal[_, Vertex]): GraphTraversal[Row, E]

def from(arg0: String): GraphTraversal[Row, E]

def getBytecode(): Bytecode

final def getClass(): Class[_]

def getEndStep(): Step[_, E]

def getGraph(): Optional[Graph]

def getParent(): TraversalParent

def getPrivateField[T](o: Any, fieldName: String): T

Use this method to get Step properties to work around interface inconsistency.

def getSideEffects(): TraversalSideEffects

def getStartStep(): Step[Row, _]

def getSteps(): List[Step[_, _]]

def getStrategies(): TraversalStrategies

def getTraversalSource(): Optional[TraversalSource]

def getTraverserGenerator(): TraverserGenerator

def getTraverserRequirements(): Set[TraverserRequirement]

def graphName: String

Returns the graph name of the referenced DseGraphFrame object.

def graphName(name: String): DseGraphTraversal[E]

Set name of the graph in case it was lost during conversion operations or the result should be stored in another graph The name will be updated in the DseGraphFrame

def group(arg0: String): GraphTraversal[Row, E]

def group[K, V](): GraphTraversal[Row, Map[K, V]]

def groupCount(arg0: String): GraphTraversal[Row, E]

def groupCount[K](): GraphTraversal[Row, Map[K, Long]]

def groupCountIterator: Iterator[E]

def has(arg0: String): GraphTraversal[Row, E]

def has(arg0: String, arg1: Traversal[_, _]): GraphTraversal[Row, E]

def has(arg0: T, arg1: Traversal[_, _]): GraphTraversal[Row, E]

def has(arg0: String, arg1: String, arg2: Any): GraphTraversal[Row, E]

def has(arg0: String, arg1: String, arg2: P[_]): GraphTraversal[Row, E]

def has(arg0: T, arg1: Any): GraphTraversal[Row, E]

def has(arg0: String, arg1: Any): GraphTraversal[Row, E]

def has(arg0: T, arg1: P[_]): GraphTraversal[Row, E]

def has(arg0: String, arg1: P[_]): GraphTraversal[Row, E]

def hasId(arg0: P[AnyRef]): GraphTraversal[Row, E]

def hasId(arg0: Any, arg1: <repeated...>[AnyRef]): GraphTraversal[Row, E]

def hasKey(arg0: P[String]): GraphTraversal[Row, E]

def hasKey(arg0: String, arg1: <repeated...>[String]): GraphTraversal[Row, E]

def hasLabel(arg0: P[String]): GraphTraversal[Row, E]

def hasLabel(arg0: String, arg1: <repeated...>[String]): GraphTraversal[Row, E]

def hasNext(): Boolean

Iterator methods cause DataFrame collect() call, that materializes all rows on the driver call at the end of computations.

def hasNot(arg0: String): GraphTraversal[Row, E]

def hasValue(arg0: P[AnyRef]): GraphTraversal[Row, E]

def hasValue(arg0: Any, arg1: <repeated...>[AnyRef]): GraphTraversal[Row, E]

def hashCode(): Int

def id(): GraphTraversal[Row, AnyRef]

def idColumnNames: Seq[String]

def idColumns: Seq[Column]

def idGroupCountIterator: Iterator[E]

def idIterator: Iterator[E]

def idOnlyVertexStep(step: Step[_, _]): Boolean

Check the step is required only id column The method is used in traversal steps to reduce number of join operations

def identity(): GraphTraversal[Row, E]

def identityGroupCountIterator: Iterator[E]

def in(arg0: <repeated...>[String]): GraphTraversal[Row, Vertex]

def inE(arg0: <repeated...>[String]): GraphTraversal[Row, Edge]

def inV(): GraphTraversal[Row, Vertex]

def index[E2](): GraphTraversal[Row, E2]

def infixToPrefix(steps: Seq[Step[_, _]]): Seq[Step[_, _]]

Find OrStep and AndStep in infix notation and rearrange them to prefix one so leftSteps().and().rightSteps() => and(leftSteps(), rightSteps())

def inject(arg0: <repeated...>[E]): GraphTraversal[Row, E]

def is(arg0: Any): GraphTraversal[Row, E]

def is(arg0: P[E]): GraphTraversal[Row, E]

def isEdgeTraversal: Boolean

final def isInstanceOf[T0]: Boolean

def isLastStep(step: Step[_, _]): Boolean

def isLocked(): Boolean

def isStdPredicate(p: BiPredicate[_, _]): Boolean

def isVertexTraversal: Boolean

def iterate(): GraphTraversal[Row, E]

def iterate[A, B](): Traversal[A, B]

lazy val iterator: Iterator[E]

Iterator methods cause DataFrame collect() call, that materializes all rows on the driver only count().next() is supported for now It is recommended to get table like results with df() method.

def key(): GraphTraversal[Row, String]

def label(): GraphTraversal[Row, String]

def limit[E2](arg0: Scope, arg1: Long): GraphTraversal[Row, E2]

def limit(arg0: Long): GraphTraversal[Row, E]

def local[E2](arg0: Traversal[_, E2]): GraphTraversal[Row, E2]

def loops(arg0: String): GraphTraversal[Row, Integer]

def loops(): GraphTraversal[Row, Integer]

def map[E2](arg0: Traversal[_, E2]): GraphTraversal[Row, E2]

def map[E2](arg0: Function[Traverser[E], E2]): GraphTraversal[Row, E2]

def match[E2](arg0: <repeated...>[Traversal[_, _]]): GraphTraversal[Row, Map[String, E2]]

def math(arg0: String): GraphTraversal[Row, Double]

def max[E2 <: Comparable[_]](arg0: Scope): GraphTraversal[Row, E2]

def max[E2 <: Comparable[_]](): GraphTraversal[Row, E2]

def mayIgnoreLocal(steps: List[Step[_, _]]): Boolean

def mayIgnoreLocal(step: Step[_, _]): Boolean

DSE Graph Frames does not fully support the LocalStep, however there are some steps that can be ignored within a LocalStep.

def mean[E2 <: Number](arg0: Scope): GraphTraversal[Row, E2]

def mean[E2 <: Number](): GraphTraversal[Row, E2]

def min[E2 <: Comparable[_]](arg0: Scope): GraphTraversal[Row, E2]

def min[E2 <: Comparable[_]](): GraphTraversal[Row, E2]

final def ne(arg0: AnyRef): Boolean

def next(): E

Iterator methods cause DataFrame collect() call, that materializes all rows on the driver call at the end of computations.

def next(arg0: Int): List[E]

def nextTraverser(): Admin[E]

def none(): Traversal[Row, E]

def not(arg0: Traversal[_, _]): GraphTraversal[Row, E]

final def notify(): Unit

final def notifyAll(): Unit

def option[E2](arg0: Traversal[_, E2]): GraphTraversal[Row, E]

def option[M, E2](arg0: M, arg1: Traversal[_, E2]): GraphTraversal[Row, E]

def optional[E2](arg0: Traversal[_, E2]): GraphTraversal[Row, E2]

def or(arg0: <repeated...>[Traversal[_, _]]): GraphTraversal[Row, E]

def order(arg0: Scope): GraphTraversal[Row, E]

def order(): GraphTraversal[Row, E]

def otherV(): GraphTraversal[Row, Vertex]

def out(arg0: <repeated...>[String]): GraphTraversal[Row, Vertex]

def outE(arg0: <repeated...>[String]): GraphTraversal[Row, Edge]

def outV(): GraphTraversal[Row, Vertex]

def pageRank(arg0: Double): GraphTraversal[Row, E]

def pageRank(): GraphTraversal[Row, E]

def path(): GraphTraversal[Row, Path]

def peerPressure(): GraphTraversal[Row, E]

def process(step: RangeGlobalStep[_], df: DataFrame): DataFrame

def process(step: OrderGlobalStep[_, _], df: DataFrame): DataFrame

def process(step: LocalStep[_, _], df: DataFrame): DataFrame

def process(step: SelectOneStep[_, _], df: DataFrame): DataFrame

def process(step: SelectStep[_, _], df: DataFrame): DataFrame

def process(step: StartStep[_], df: DataFrame): DataFrame

def process(step: GroupCountStep[_, _], df: DataFrame): DataFrame

def process(step: OrStep[_], df: DataFrame): DataFrame

def process(step: AndStep[_], df: DataFrame): DataFrame

def process(step: NotStep[_], result: DataFrame): DataFrame

def process(step: TraversalFilterStep[_], result: DataFrame): DataFrame

def process(step: VertexStep[_], df: DataFrame): DataFrame

there are two combination of vertex steps Vertex->Vertex | g.V().out() Vertex->Egde | g.V().outE() with three direcctions: IN, OUT, BOTH

def process(step: EdgeVertexStep, df: DataFrame): DataFrame

there are three combination of edge steps g.E().outV() g.E().inV() g.E().bothV() with three directions: IN, OUT, BOTH

def process(step: DedupGlobalStep[_], df: DataFrame): DataFrame

def process(step: WherePredicateStep[_], df: DataFrame): DataFrame

def process(step: HasStep[_], df: DataFrame): DataFrame

def process(step: IsStep[_], df: DataFrame): DataFrame

def process(step: PageRankVertexProgramStep, df: DataFrame): DataFrame

def process(step: AddPropertyStep[_], df: DataFrame): DataFrame

def process(step: IoStep[_], df: DataFrame): DataFrame

def process(step: NoneStep[_], df: DataFrame): DataFrame

def process(step: DropStep[_], df: DataFrame): DataFrame

def process(step: PropertiesStep[_], df: DataFrame): DataFrame

def process(step: PropertyMapStep[_, _], df: DataFrame): DataFrame

def process(step: LabelStep[_], df: DataFrame): DataFrame

def process(step: IdStep[_], df: DataFrame): DataFrame

def process(step: CountGlobalStep[_], df: DataFrame): DataFrame

def process(step: GraphStep[_, _], df: DataFrame): DataFrame

def process(steps: List[Step[_, _]], df: DataFrame): DataFrame

def process(df: DataFrame): DataFrame

def processLabels(step: Step[_, _], df: DataFrame): DataFrame

def profile(): GraphTraversal[Row, TraversalMetrics]

def profile(arg0: String): GraphTraversal[Row, E]

def program(arg0: VertexProgram[_]): GraphTraversal[Row, E]

def project[E2](arg0: String, arg1: <repeated...>[String]): GraphTraversal[Row, Map[String, E2]]

def promise[T](arg0: Function[Traversal[Row, E], T]): CompletableFuture[T]

def properties[E2](arg0: <repeated...>[String]): GraphTraversal[Row, _ <: Property[E2]]

def propertiesIterator: Iterator[E]

def property(arg0: Any, arg1: Any, arg2: <repeated...>[AnyRef]): GraphTraversal[Row, E]

def property(arg0: Cardinality, arg1: Any, arg2: Any, arg3: <repeated...>[AnyRef]): GraphTraversal[Row, E]

def propertyMap[E2](arg0: <repeated...>[String]): GraphTraversal[Row, Map[String, E2]]

def propertyMapIterator(includeId: Boolean, selectStep: Boolean = false): Iterator[E]

def range[E2](arg0: Scope, arg1: Long, arg2: Long): GraphTraversal[Row, E2]

def range(arg0: Long, arg1: Long): GraphTraversal[Row, E]

def read(): GraphTraversal[Row, E]

def remove(): Unit

def removeStep[S2, E2](arg0: Int): Admin[S2, E2]

def removeStep[S2, E2](arg0: Step[_, _]): Admin[S2, E2]

def repeat(arg0: String, arg1: Traversal[_, E]): GraphTraversal[Row, E]

def repeat(arg0: Traversal[_, E]): GraphTraversal[Row, E]

def reset(): Unit

def sack[V, U](arg0: BiFunction[V, U, V]): GraphTraversal[Row, E]

def sack[E2](): GraphTraversal[Row, E2]

def sample(arg0: Scope, arg1: Int): GraphTraversal[Row, E]

def sample(arg0: Int): GraphTraversal[Row, E]

def select[E2](arg0: Column): GraphTraversal[Row, Collection[E2]]

def select[E2](arg0: Traversal[Row, E2]): GraphTraversal[Row, E2]

def select[E2](arg0: Pop, arg1: Traversal[Row, E2]): GraphTraversal[Row, E2]

def select[E2](arg0: String): GraphTraversal[Row, E2]

def select[E2](arg0: Pop, arg1: String): GraphTraversal[Row, E2]

def select[E2](arg0: String, arg1: String, arg2: <repeated...>[String]): GraphTraversal[Row, Map[String, E2]]

def select[E2](arg0: Pop, arg1: String, arg2: String, arg3: <repeated...>[String]): GraphTraversal[Row, Map[String, E2]]

def setEdgeTraversal: Unit

def setGraph(arg0: Graph): Unit

def setParent(arg0: TraversalParent): Unit

def setSideEffects(arg0: TraversalSideEffects): Unit

def setStrategies(arg0: TraversalStrategies): Unit

def setVertexTraversal: Unit

def shortestPath(): GraphTraversal[Row, Path]

def sideEffect(arg0: Traversal[_, _]): GraphTraversal[Row, E]

def sideEffect(arg0: Consumer[Traverser[E]]): GraphTraversal[Row, E]

def simplePath(): GraphTraversal[Row, E]

def skip[E2](arg0: Scope, arg1: Long): GraphTraversal[Row, E2]

def skip(arg0: Long): GraphTraversal[Row, E]

def stdPredicateUdf(p: P[_], column: Column): Column

def subgraph(arg0: String): GraphTraversal[Row, Edge]

def sum[E2 <: Number](arg0: Scope): GraphTraversal[Row, E2]

def sum[E2 <: Number](): GraphTraversal[Row, E2]

final def synchronized[T0](arg0: ⇒ T0): T0

def systemColumnNames: Seq[String]

def systemColumns: Seq[Column]

def tail[E2](arg0: Scope, arg1: Long): GraphTraversal[Row, E2]

def tail[E2](arg0: Scope): GraphTraversal[Row, E2]

def tail(arg0: Long): GraphTraversal[Row, E]

def tail(): GraphTraversal[Row, E]

def throwLocalFileException(cause: Exception, uri: URI): Nothing

def timeLimit(arg0: Long): GraphTraversal[Row, E]

def times(arg0: Int): GraphTraversal[Row, E]

def to(arg0: Vertex): GraphTraversal[Row, E]

def to(arg0: Traversal[_, Vertex]): GraphTraversal[Row, E]

def to(arg0: String): GraphTraversal[Row, E]

def to(arg0: Direction, arg1: <repeated...>[String]): GraphTraversal[Row, Vertex]

def toBulkSet(): BulkSet[E]

def toE(arg0: Direction, arg1: <repeated...>[String]): GraphTraversal[Row, Edge]

def toList(): List[E]

def toSet(): Set[E]

def toStream(): Stream[E]

def toString(): String

def toV(arg0: Direction): GraphTraversal[Row, Vertex]

var traversalType: scala.reflect.api.JavaUniverse.Type

traversal is mutable when steps are applied the typeTag is used to control step to step safety and type of the last step result for the iterator.

def tree(arg0: String): GraphTraversal[Row, E]

def tree(): GraphTraversal[Row, Tree]

def tryNext(): Optional[E]

def unfold[E2](): GraphTraversal[Row, E2]

def union[E2](arg0: <repeated...>[Traversal[_, E2]]): GraphTraversal[Row, E2]

def until(arg0: Predicate[Traverser[E]]): GraphTraversal[Row, E]

def until(arg0: Traversal[_, _]): GraphTraversal[Row, E]

def value[E2](): GraphTraversal[Row, E2]

def valueMap[E2](arg0: <repeated...>[String]): GraphTraversal[Row, Map[AnyRef, E2]]

def values[E2](arg0: <repeated...>[String]): GraphTraversal[Row, E2]

def vertexToEdgeWithDirection(v: DataFrame, e: DataFrame, in: Boolean, returnEdge: Boolean, idOnly: Boolean): DataFrame

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def where(arg0: Traversal[_, _]): GraphTraversal[Row, E]

def where(arg0: P[String]): GraphTraversal[Row, E]

def where(arg0: String, arg1: P[String]): GraphTraversal[Row, E]

def with(arg0: String, arg1: Any): GraphTraversal[Row, E]

def with(arg0: String): GraphTraversal[Row, E]

def write(): GraphTraversal[Row, E]

def store(arg0: String): GraphTraversal[Row, E]

def valueMap[E2](arg0: Boolean, arg1: <repeated...>[String]): GraphTraversal[Row, Map[AnyRef, E2]]