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: 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 addV(): GraphTraversal[Row, Vertex]

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

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: 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 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 constant[E2](arg0: E2): GraphTraversal[Row, E2]

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 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 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 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: Traversal[E, 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 getTraverserGenerator(): TraverserGenerator

def getTraverserRequirements(): Set[TraverserRequirement]

def graphName: String

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 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(): 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 max[E2 <: Number](arg0: Scope): GraphTraversal[Row, E2]

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

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

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

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

def min[E2 <: Number](): 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 not(arg0: Traversal[_, _]): GraphTraversal[Row, E]

final def notify(): Unit

final def notifyAll(): Unit

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

def option[M, E2](arg0: M, arg1: Traversal[E, 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: GroupCountStep[_, _], 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: 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: DropStep[_], df: DataFrame): DataFrame

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

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

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

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

def process(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): Iterator[E]

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

def range(arg0: Long, arg1: Long): 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: 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: 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 sideEffect(arg0: Traversal[_, _]): GraphTraversal[Row, E]

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

def simplePath(): GraphTraversal[Row, E]

def standardIdColumnNamesToRemove: Seq[String]

if standard id is used and user do not use it as regular properties in some vertices.

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

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

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 timeLimit(arg0: Long): GraphTraversal[Row, E]

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

def to(arg0: Traversal[E, 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: Boolean, arg1: <repeated...>[String]): GraphTraversal[Row, Map[String, E2]]

def valueMap[E2](arg0: <repeated...>[String]): GraphTraversal[Row, Map[String, 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 addE(arg0: Direction, arg1: String, arg2: String, arg3: <repeated...>[AnyRef]): GraphTraversal[Row, Edge]

def addInE(arg0: String, arg1: String, arg2: <repeated...>[AnyRef]): GraphTraversal[Row, Edge]

def addOutE(arg0: String, arg1: String, arg2: <repeated...>[AnyRef]): GraphTraversal[Row, Edge]

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

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

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

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

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

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