ai.grakn.graql.internal.gremlin.fragment

Class Fragment

java.lang.Object

ai.grakn.graql.internal.gremlin.fragment.Fragment

Direct Known Subclasses:

AbstractRolePlayerFragment, InIsaFragment, InSubFragment, LabelFragment, NeqFragment, OutIsaFragment, OutSubFragment

public abstract class Fragment
extends Object

represents a graph traversal, with one start point and optionally an end point A fragment is composed of four things:

• A gremlin traversal function, that takes a gremlin traversal and appends some new gremlin steps
• A starting variable name, where the gremlin traversal must start from
• An optional ending variable name, if the gremlin traversal navigates to a new Graql variable
• A priority, that describes how efficient this traversal is to help with ordering the traversals

Variable names refer to Graql variables. Some of these variable names may be randomly-generated UUIDs, such as for castings. A Fragment is usually contained in a EquivalentFragmentSet, which contains multiple fragments describing the different directions the traversal can be followed in, with different starts and ends. A gremlin traversal is created from a Query by appending together fragments in order of priority, one from each EquivalentFragmentSet describing the Query.

Author:

Grakn Warriors

Property Summary

Type	Property and Description
abstract VarProperty	var Get the corresponding property

Field Summary

Fields

Modifier and Type	Field and Description
static double	SHARD_LOAD_FACTOR

Constructor Summary

Constructors

Constructor and Description
Fragment()

Method Summary

Modifier and Type	Method and Description
org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,? extends org.apache.tinkerpop.gremlin.structure.Element>	applyTraversal(org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,? extends org.apache.tinkerpop.gremlin.structure.Element> traversal, EmbeddedGraknTx<?> tx, Collection<Var> vars, Var currentVar)
boolean	canOperateOnEdges() Indicates whether the fragment can be used on an Edge as well as a Vertex.
Set<Var>	dependencies()
Set<Weighted<DirectedEdge<Node>>>	directedEdges(Map<NodeId,Node> nodes, Map<Node,Map<Node,Fragment>> edges) Convert the fragment to a set of weighted edges for query planning
Var	end()
double	fragmentCost() Get the cost for executing the fragment.
Fragment	getInverse()
Long	getShardCount(EmbeddedGraknTx<?> tx)
boolean	hasFixedFragmentCost() If a fragment has fixed cost, the traversal is done using index.
abstract double	internalFragmentCost()
boolean	isStartingFragment() A starting fragment is a fragment that can start a traversal.
abstract String	name() The name of the fragment
void	setAccurateFragmentCost(double fragmentCost)
abstract Var	start()
String	toString()
Fragment	transform(Map<Var,ConceptId> transform)
abstract VarProperty	varProperty() Get the corresponding property
Set<Var>	vars() Get all variables in the fragment including the start and end (if present)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Property Detail

var

@Nullable
public abstract VarProperty varProperty

Get the corresponding property

Field Detail

SHARD_LOAD_FACTOR

public static final double SHARD_LOAD_FACTOR

See Also:

Constant Field Values

Constructor Detail

Fragment

public Fragment()

Method Detail

transform

public Fragment transform(Map<Var,ConceptId> transform)

Parameters:

transform - map defining id transform var -> new id

Returns:

transformed fragment with id predicates transformed according to the transform

varProperty

@Nullable
public abstract VarProperty varProperty()

Get the corresponding property

start

public abstract Var start()

Returns:

the variable name that this fragment starts from in the query

end

@Nullable
public Var end()

Returns:

the variable name that this fragment ends at in the query, if this query has an end variable

dependencies

public Set<Var> dependencies()

Returns:

the variable names that this fragment requires to have already been visited

directedEdges

public Set<Weighted<DirectedEdge<Node>>> directedEdges(Map<NodeId,Node> nodes,
                                                       Map<Node,Map<Node,Fragment>> edges)

Convert the fragment to a set of weighted edges for query planning

Parameters:

nodes - all nodes in the query

edges - a mapping from edge(child, parent) to its corresponding fragment

Returns:

a set of edges

applyTraversal

public final org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,? extends org.apache.tinkerpop.gremlin.structure.Element> applyTraversal(org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal<org.apache.tinkerpop.gremlin.structure.Vertex,? extends org.apache.tinkerpop.gremlin.structure.Element> traversal,
                                                                                                                                                                                                            EmbeddedGraknTx<?> tx,
                                                                                                                                                                                                            Collection<Var> vars,
                                                                                                                                                                                                            @Nullable
                                                                                                                                                                                                            Var currentVar)

Parameters:

traversal - the traversal to extend with this Fragment

tx - the graph to execute the traversal on

name

public abstract String name()

The name of the fragment

isStartingFragment

public boolean isStartingFragment()

A starting fragment is a fragment that can start a traversal. If any other fragment is present that refers to the same variable, the starting fragment can be omitted.

fragmentCost

public double fragmentCost()

Get the cost for executing the fragment.

setAccurateFragmentCost

public void setAccurateFragmentCost(double fragmentCost)

internalFragmentCost

public abstract double internalFragmentCost()

hasFixedFragmentCost

public boolean hasFixedFragmentCost()

If a fragment has fixed cost, the traversal is done using index. This makes the fragment a good starting point. A plan should always start with these fragments when possible.

getInverse

public Fragment getInverse()

getShardCount

public Long getShardCount(EmbeddedGraknTx<?> tx)

canOperateOnEdges

public boolean canOperateOnEdges()

Indicates whether the fragment can be used on an Edge as well as a Vertex.

vars

public final Set<Var> vars()

Get all variables in the fragment including the start and end (if present)

toString

public final String toString()

Overrides:

toString in class Object