Uses of Interface
com.bigdata.bop.BOp

Packages that use BOp

Package	Description
com.bigdata.bop	This package provides an API for query operators.
com.bigdata.bop.aggregate
com.bigdata.bop.ap
com.bigdata.bop.ap.filter	These filters are based on the striterator patterns.
com.bigdata.bop.bset
com.bigdata.bop.constraint	This package provides implementations for operators which impose constraints on elements visited by some access path.
com.bigdata.bop.controller	This package provides operators for subquery, including UNION, STEPS, and STAR (transitive closure).
com.bigdata.bop.engine
com.bigdata.bop.fed
com.bigdata.bop.join
com.bigdata.bop.joinGraph.rto
com.bigdata.bop.mutation
com.bigdata.bop.paths
com.bigdata.bop.rdf.aggregate
com.bigdata.bop.rdf.filter
com.bigdata.bop.rdf.join
com.bigdata.bop.rdf.update	This package provides bigdata operators for SPARQL update.
com.bigdata.bop.solutions	This package provides distinct, sort, and aggregation operators.
com.bigdata.rdf.internal.constraints
com.bigdata.rdf.internal.encoder
com.bigdata.rdf.lexicon
com.bigdata.rdf.rules
com.bigdata.rdf.sail.sparql	This package was imported from the org.openrdf.query.parser.sparql package of the openrdf distribution.
com.bigdata.rdf.sparql.ast	This package contains an Abstract Syntax Tree which provides an intermediate translation target for SPARQL parsers.
com.bigdata.rdf.sparql.ast.eval
com.bigdata.rdf.sparql.ast.eval.update
com.bigdata.rdf.sparql.ast.explainhints
com.bigdata.rdf.sparql.ast.service	This package provides support for SPARQL 1.1 Federated Query, including the special case of "service" end points which live within the same JVM and use direct method calls rather than SPARQL Query and remote (HTTP) end points for which we will generate an appropriate SPARQL query.
com.bigdata.rdf.spo	This package defines a statement model using long term identifiers rather than RDF Value objects.
com.bigdata.relation	This package includes an abstraction layer for relations.
com.bigdata.relation.rule	This package includes an abstraction layer for rules.

Uses of BOp in com.bigdata.bop

Subinterfaces of BOp in com.bigdata.bop

Modifier and Type	Interface and Description
interface	IBind<E> A marker interface for an IValueExpression which has the side-effect of binding a value on an IVariable.
interface	IConstant<E> A constant.
interface	IConstraint An interface for specifying constraints on the allowable states of an IBindingSet.
interface	IPredicate<E> An immutable constraint on the elements visited using an IAccessPath.
interface	IValueExpression<E> An expression which may be evaluated to a value.
interface	IValueExpressionConstraint<X>
interface	IVariable<E> A variable.
interface	IVariableOrConstant<E> Abstraction models either a constant or an unbound variable.

Classes in com.bigdata.bop that implement BOp

Modifier and Type	Class and Description
class	AbstractAccessPathOp<E> Interface for evaluating operations producing chunks of elements (tuples materialized from some index of a relation).
class	Bind<E> Operator causes a variable to be bound to the result of its evaluation as a side-effect.
class	BOpBase Abstract base class for copy-on-write BOps.
class	Constant<E> A constant.
class	CoreBaseBOp Base class with some common methods for mutable and copy-on-write BOp s.
class	ImmutableBOp Base class for immutable operators such as Var and Constant.
class	ModifiableBOpBase Abstract base class for mutable BOps.
class	PipelineOp Abstract base class for pipeline operators where the data moving along the pipeline is chunks of IBindingSets.
class	Var<E> A variable.

Fields in com.bigdata.bop declared as BOp

Modifier and Type	Field and Description
static BOp[]	BOp.NOARGS An empty array.

Methods in com.bigdata.bop with type parameters of type BOp

Modifier and Type	Method and Description
static <T extends BOp> T	BOpUtility.deepCopy(T op) Deep copy.

Methods in com.bigdata.bop that return BOp

Modifier and Type	Method and Description
protected BOp[]	BOpBase.argsCopy() A copy of the args[] array.
BOp	BOpBase.clearAnnotations(String[] names) Strips off the named annotations.
BOp	BOp.clone() Deep copy clone of the operator.
protected static BOp[]	BOpBase.deepCopy(BOp[] a) Deep copy the arguments.
BOp	BOpBase.get(int index)
BOp	ModifiableBOpBase.get(int index)
BOp	BOp.get(int index) Return an argument to the operation.
static BOp	BOpUtility.getParent(BOp root, BOp op) Return the parent of the operator in the operator tree (this does not search the annotations, just the children).
static BOp	BOpUtility.getPipelineStart(BOp op) Return the left-deep child of the operator.
BOp	BOp.setProperty(String name, Object value) Unconditionally sets the property.
BOp[]	BOpBase.toArray()
BOp[]	ModifiableBOpBase.toArray()
BOp[]	BOp.toArray() A shallow copy of the operator's arguments.

Methods in com.bigdata.bop that return types with arguments of type BOp

Modifier and Type	Method and Description
static Iterator<BOp>	BOpUtility.annotationOpIterator(BOp op) Visit all annotations which are BOps (non-recursive).
Iterator<BOp>	BOpBase.argIterator() An iterator visiting the operator's arguments.
Iterator<BOp>	ModifiableBOpBase.argIterator() An iterator visiting the operator's arguments.
Iterator<BOp>	BOp.argIterator() An iterator visiting the operator's arguments.
List<BOp>	BOpBase.args() The operator's arguments as list.
List<BOp>	ModifiableBOpBase.args() An unmodifiable view of the list of arguments (aka children) of this node.
List<BOp>	BOp.args() The operator's arguments as list.
static Map<Integer,BOp>	BOpUtility.getIndex(BOp op) Return an index from the BOp.Annotations.BOP_ID to the BOp for each spanned PipelineOp.
static Iterator<BOp>	BOpUtility.postOrderIterator(BOp op) Post-order recursive visitation of the operator tree (arguments only, no annotations).
static Iterator<BOp>	BOpUtility.postOrderIteratorWithAnnotations(BOp op) Recursive post-order traversal of the operator tree with visitation of all operator annotations.
static Iterator<BOp>	BOpUtility.preOrderIterator(BOp op) Pre-order recursive visitation of the operator tree (arguments only, no annotations).
static Iterator<BOp>	BOpUtility.preOrderIteratorWithAnnotations(BOp op) Recursive pre-order traversal of the operator tree with visitation of all operator annotations.

Methods in com.bigdata.bop with parameters of type BOp

Modifier and Type	Method and Description
void	BOpBase.__replaceArg(int index, BOp newArg) Effectively overwrites the specified argument with the provided value.
protected void	BOpBase._set(int index, BOp op) Set the value of an operand.
void	ModifiableBOpBase.addArg(BOp newArg) Add a new argument (core mutation method).
void	ModifiableBOpBase.addArg(int index, BOp newArg) Add a new argument (core mutation method) at the specified index.
void	ModifiableBOpBase.addArgIfAbsent(BOp arg) Add an argument iff it is not already present.
static Iterator<BOp>	BOpUtility.annotationOpIterator(BOp op) Visit all annotations which are BOps (non-recursive).
protected boolean	BOpBase.annotationsEqual(BOp o)
protected boolean	ModifiableBOpBase.annotationsEqual(BOp o)
protected boolean	CoreBaseBOp.annotationsEqual(BOp o) Return true iff the annotations of this BOp and the other BOp are equals.
protected void	CoreBaseBOp.annotationValueToString(StringBuilder sb, BOp val, int indent) Add a string representation of a BOp annotation value into a string builder.
protected void	CoreBaseBOp.checkArgs(BOp[] args) Check the operator argument.
static int	BOpUtility.countVarOccurrencesOutsideProjections(BOp op, IVariable inputVar) Counts the number of occurrences of a BOp inside another BOp.
protected static BOp[]	BOpBase.deepCopy(BOp[] a) Deep copy the arguments.
static int	BOpUtility.getArgumentVariableCount(BOp op) The #of arguments to this operation which are variables.
static Iterator<IVariable<?>>	BOpUtility.getArgumentVariables(BOp op) Return the variables from the operator's arguments.
static Integer	BOpUtility.getEffectiveDefaultSink(BOp bop, BOp p) Return the effective default sink.
static Integer[]	BOpUtility.getEvaluationOrder(BOp op) Return a list containing the evaluation order for the pipeline.
static Map<Integer,BOp>	BOpUtility.getIndex(BOp op) Return an index from the BOp.Annotations.BOP_ID to the BOp for each spanned PipelineOp.
static <C> C	BOpUtility.getOnly(BOp op, Class<C> class1) Return the sole instance of the specified class.
static BOp	BOpUtility.getParent(BOp root, BOp op) Return the parent of the operator in the operator tree (this does not search the annotations, just the children).
static BOp	BOpUtility.getPipelineStart(BOp op) Return the left-deep child of the operator.
static Set<IVariable<?>>	BOpUtility.getSharedVars(BOp p, BOp c) Return the variable references shared by two operators.
static Iterator<IVariable<?>>	BOpUtility.getSpannedVariables(BOp op) Return the distinct variables recursively using a pre-order traversal present whether in the operator tree or on annotations attached to operators.
int	ModifiableBOpBase.indexOf(BOp bop) Return the index of the bop in the args.
static Iterator<BOp>	BOpUtility.postOrderIterator(BOp op) Post-order recursive visitation of the operator tree (arguments only, no annotations).
static Iterator<BOp>	BOpUtility.postOrderIteratorWithAnnotations(BOp op) Recursive post-order traversal of the operator tree with visitation of all operator annotations.
static Iterator<BOp>	BOpUtility.preOrderIterator(BOp op) Pre-order recursive visitation of the operator tree (arguments only, no annotations).
static Iterator<BOp>	BOpUtility.preOrderIteratorWithAnnotations(BOp op) Recursive pre-order traversal of the operator tree with visitation of all operator annotations.
boolean	ModifiableBOpBase.removeArg(BOp arg) Remove the 1st occurrence of the argument (core mutation method).
int	ModifiableBOpBase.replaceWith(BOp oldChild, BOp newChild) Replace a child of a node with another reference (destructive modification).
BOpBase	BOpBase.setArg(int index, BOp newArg) Return a new BOpBase in which the child operand has been replaced by the given expression.
ModifiableBOpBase	ModifiableBOpBase.setArg(int index, BOp newArg) Replace the value of the argument at the specified index (core mutation method).
ModifiableBOpBase	ModifiableBOpBase.setArgs(BOp[] args) Replace the arguments.
static <C> List<C>	BOpUtility.toList(BOp op, Class<C> clas) Return a list containing references to all nodes of the given type (recursive, including annotations).
static String	BOpUtility.toString(BOp bop) Pretty print a bop.
static String	BOpUtility.toString2(BOp bop)
static <C> Iterator<C>	BOpUtility.visitAll(BOp op, Class<C> clas) Return an iterator visiting references to all nodes of the given type (recursive, including annotations).

Constructors in com.bigdata.bop with parameters of type BOp

Constructor and Description
AbstractAccessPathOp(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
Bind(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
BOpBase(BOp[] args, Map<String,Object> annotations) Shallow copy constructor (required).
ImmutableBOp(BOp[] args, Map<String,Object> annotations)
ModifiableBOpBase(BOp[] args, Map<String,Object> annotations) Shallow copy constructor (required).
PipelineOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.

Uses of BOp in com.bigdata.bop.aggregate

Subinterfaces of BOp in com.bigdata.bop.aggregate

Modifier and Type	Interface and Description
interface	IAggregate<E> An aggregate operator, such as SUM, COUNT, MIN, MAX, etc.

Classes in com.bigdata.bop.aggregate that implement BOp

Modifier and Type	Class and Description
class	AggregateBase<E> Abstract base class for aggregate functions.

Constructors in com.bigdata.bop.aggregate with parameters of type BOp

Constructor and Description
AggregateBase(BOp[] args, Map<String,Object> annotations) Core shallow copy constructor.

Uses of BOp in com.bigdata.bop.ap

Classes in com.bigdata.bop.ap that implement BOp

Modifier and Type	Class and Description
class	Predicate<E> A generic implementation of an immutable IPredicate.
class	SampleIndex<E> Sampling operator for the IAccessPath implied by an IPredicate.
protected class	TestPredicateAccessPath.MockPipelineOp

Methods in com.bigdata.bop.ap with parameters of type BOp

Modifier and Type	Method and Description
protected void	Predicate.checkArgs(BOp[] args) Disallows null in any position.

Method parameters in com.bigdata.bop.ap with type arguments of type BOp

Modifier and Type	Method and Description
E	R.newElement(List<BOp> a, IBindingSet bindingSet)

Constructors in com.bigdata.bop.ap with parameters of type BOp

Constructor and Description
Predicate(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
Predicate(BOp[] args, NV... annotations) Variable argument version of the shallow constructor.
SampleIndex(BOp[] args, Map<String,Object> annotations)
TestPredicateAccessPath.MockPipelineOp(BOp[] args, NV... anns)

Uses of BOp in com.bigdata.bop.ap.filter

Classes in com.bigdata.bop.ap.filter that implement BOp

Modifier and Type	Class and Description
class	BOpFilter Used to filter for objects which satisfy some criteria.
class	BOpFilterBase Base class for operators which apply striterator patterns for access paths.
class	BOpFilterNOP A filter which does nothing.
class	BOpResolver Striterator resolver pattern.
class	BOpTupleFilter<E> Filter supporting ITupleIterators.
class	DistinctFilter A DISTINCT operator based for elements in a relation.

Constructors in com.bigdata.bop.ap.filter with parameters of type BOp

Constructor and Description
BOpFilter(BOp[] args, Map<String,Object> annotations) Shallow copy.
BOpFilterBase(BOp[] args, Map<String,Object> annotations) Shallow copy.
BOpFilterNOP(BOp[] args, Map<String,Object> annotations) Shallow copy.
BOpResolver(BOp[] args, Map<String,Object> annotations)
BOpTupleFilter(BOp[] args, Map<String,Object> annotations) Shallow copy.
DistinctFilter(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.

Uses of BOp in com.bigdata.bop.bset

Classes in com.bigdata.bop.bset that implement BOp

Modifier and Type	Class and Description
class	ConditionalRoutingOp An operator for conditional routing of binding sets in a pipeline.
class	CopyOp This operator copies its source to its sink(s).
class	EndOp A operator which may be used at the end of query pipelines when there is a requirement to marshal solutions back to the query controller but no requirement to slice solutions.
class	StartOp A version of CopyOp which is always evaluated on the query controller.
class	Tee TEE(op):[sinkRef=X; altSinkRef=Y]

Constructors in com.bigdata.bop.bset with parameters of type BOp

Constructor and Description
ConditionalRoutingOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
ConditionalRoutingOp(BOp[] args, NV... anns)
CopyOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
CopyOp(BOp[] args, NV... annotations)
EndOp(BOp[] args, Map<String,Object> annotations)
StartOp(BOp[] args, Map<String,Object> annotations)
Tee(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.

Uses of BOp in com.bigdata.bop.constraint

Subinterfaces of BOp in com.bigdata.bop.constraint

Modifier and Type	Interface and Description
interface	BooleanValueExpression Interface for boolean value expression BOps.

Classes in com.bigdata.bop.constraint that implement BOp

Modifier and Type	Class and Description
class	AND Imposes the constraint x AND y.
class	Constraint<X> Constraint wraps a BooleanValueExpression.
class	EQ Imposes the constraint x == y.
class	EQConstant Imposes the constraint var == constant.
class	INBinarySearch<T> A constraint that a variable may only take on the bindings enumerated by some set.
class	INConstraint<T> Abstract base class for "IN" IConstraint implementations.
class	INHashMap<T> A constraint that a variable may only take on the bindings enumerated by some set.
class	NE Imposes the constraint x != y.
class	NEConstant Imposes the constraint var != constant.
class	OR Imposes the constraint x OR y.

Constructors in com.bigdata.bop.constraint with parameters of type BOp

Constructor and Description
AND(BOp[] args, Map<String,Object> anns) Shallow copy constructor (required).
Constraint(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
EQ(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
EQConstant(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
INBinarySearch(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
INConstraint(BOp[] args, Map<String,Object> annotations)
INHashMap(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
NE(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
NEConstant(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
OR(BOp[] args, Map<String,Object> anns) Shallow copy constructor (required).

Uses of BOp in com.bigdata.bop.controller

Classes in com.bigdata.bop.controller that implement BOp

Modifier and Type	Class and Description
class	AbstractSubqueryOp Executes each of the operands as a subquery.
class	HTreeNamedSubqueryOp Evaluation of a subquery, producing a named result set.
class	JVMNamedSubqueryOp Evaluation of a subquery, producing a named result set.
class	ServiceCallJoin Vectored pipeline join of the source solution(s) with solutions from a a SERVICE invocation.
class	Steps STEPS(ops)
class	SubqueryOp Pipelined join with subquery.
class	Union UNION()[maxParallel(default all); subqueries=ops]

Constructors in com.bigdata.bop.controller with parameters of type BOp

Constructor and Description
AbstractSubqueryOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
HTreeNamedSubqueryOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
HTreeNamedSubqueryOp(BOp[] args, NV... annotations)
JVMNamedSubqueryOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
JVMNamedSubqueryOp(BOp[] args, NV... annotations)
ServiceCallJoin(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
ServiceCallJoin(BOp[] args, NV... annotations)
Steps(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
Steps(BOp[] args, NV... annotations)
SubqueryOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
SubqueryOp(BOp[] args, NV... annotations)
Union(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
Union(BOp[] args, NV... annotations)

Uses of BOp in com.bigdata.bop.engine

Classes in com.bigdata.bop.engine that implement BOp

Modifier and Type	Class and Description
class	PipelineDelayOp Operator blocks evaluation (sleeps) for the specified PipelineDelayOp.Annotations.DELAY and then throws an PipelineDelayError.

Methods in com.bigdata.bop.engine that return BOp

Modifier and Type	Method and Description
BOp	AbstractRunningQuery.getBOp(int bopId) Return the BOp having the specified id.
BOp	MockRunningQuery.getQuery()
BOp	IRunningQuery.getQuery() The query.

Methods in com.bigdata.bop.engine that return types with arguments of type BOp

Modifier and Type	Method and Description
Map<Integer,BOp>	MockRunningQuery.getBOpIndex()
Map<Integer,BOp>	AbstractRunningQuery.getBOpIndex()
Map<Integer,BOp>	IRunningQuery.getBOpIndex() Return an unmodifiable index from BOp.Annotations#BOP_ID to BOp.

Methods in com.bigdata.bop.engine with parameters of type BOp

Modifier and Type	Method and Description
static void	AbstractQueryEngineTestCase.diff(BOp o1, BOp o2) Throw an exception for the first operator having a ground difference (different Class, different arity, or different annotation).
AbstractRunningQuery	QueryEngine.eval(BOp op) Evaluate a query.
AbstractRunningQuery	QueryEngine.eval(BOp op, IBindingSet bset) Evaluate a query.
AbstractRunningQuery	QueryEngine.eval(BOp op, IBindingSet[] bsets) Evaluate a query.
AbstractRunningQuery	QueryEngine.eval(BOp op, IBindingSet[] bsets, Map<Object,Object> attribs) Evaluate a query.
AbstractRunningQuery	QueryEngine.eval(UUID queryId, BOp op, IBindingSet bset) Note: Used only by the test suite.
AbstractRunningQuery	QueryEngine.eval(UUID queryId, BOp op, Map<Object,Object> queryAttributes, IBindingSet[] bset) Note: Used only by the test suite.
AbstractRunningQuery	QueryEngine.eval(UUID queryId, BOp op, Map<Object,Object> queryAttributes, IBindingSet[][] bset) Note: Used only by the test suite.
static void	SolutionsLog.log(UUID queryId, BOp bop, int bopId, int partitionId, IBindingSet[] a)

Constructors in com.bigdata.bop.engine with parameters of type BOp

Constructor and Description
PipelineDelayOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.

Uses of BOp in com.bigdata.bop.fed

Classes in com.bigdata.bop.fed that implement BOp

Modifier and Type	Class and Description
protected class	TestRemoteAccessPath.MockPipelineOp

Constructors in com.bigdata.bop.fed with parameters of type BOp

Constructor and Description
TestRemoteAccessPath.MockPipelineOp(BOp[] args, NV... anns)

Uses of BOp in com.bigdata.bop.join

Classes in com.bigdata.bop.join that implement BOp

Modifier and Type	Class and Description
protected class	AbstractHashJoinUtilityTestCase.MockPipelineOp
class	AbstractMergeJoin Abstract base class for MERGE JOIN implementations.
class	DistinctTermScanOp<E> This operator performs a distinct terms scan for an IPredicate, binding the distinct values for the specified variable(s) from the IAccessPath for the IPredicate.
class	FastRangeCountOp<E> This operator reports the fast-range count for an as-bound IPredicate .
class	HashIndexOp Operator builds a hash index from the source solutions.
class	HashIndexOpBase Base class for operators that use a hash index.
class	HashJoinOp<E> Abstract base class for both JVM and native memory hash join against an IAccessPath.
class	HTreeHashJoinOp<E> A hash join against an IAccessPath based on the HTree and suitable for very large intermediate result sets.
class	HTreeMergeJoin An N-way merge join based on the HTree.
class	HTreeSolutionSetHashJoinOp
class	JVMHashJoinOp<E> A hash join against an IAccessPath based on the Java collections classes.
class	JVMMergeJoin An N-way merge join on the Java heap.
class	JVMSolutionSetHashJoinOp
class	NestedLoopJoinOp This operator performs a nested loop join for solutions.
class	PipelinedHashIndexAndSolutionSetJoinOp Operator for pipelined hash index construction and subsequent join.
class	PipelineJoin<E> Pipelined join operator for online (selective) queries.
class	SolutionSetHashJoinOp Operator joins a solution set modeled as a hash index into the pipeline.

Methods in com.bigdata.bop.join with parameters of type BOp

Modifier and Type	Method and Description
protected HashIndexOp	TestHTreeHashIndexOp.newHashIndexOp(String namespace, BOp[] args, NV... anns)
protected abstract HashIndexOp	HashIndexOpTestCase.newHashIndexOp(String namespace, BOp[] args, NV... anns) Factory for the HashIndexOp implementations.
protected HashIndexOp	TestJVMHashIndexOp.newHashIndexOp(String namespace, BOp[] args, NV... anns)
protected abstract PipelineOp	AbstractHashJoinOpTestCase.newJoin(BOp[] args, int joinId, IVariable<IV>[] joinVars, Predicate<IV> predOp, UUID queryId, NV... annotations) Return a new join operator instance for the test.
protected PipelineOp	TestJVMHashJoinOp.newJoin(BOp[] args, int joinId, IVariable<IV>[] joinVars, Predicate<IV> predOp, UUID queryId, NV... annotations)
protected PipelineOp	TestHTreeHashJoinOp.newJoin(BOp[] args, int joinId, IVariable<IV>[] joinVars, Predicate<IV> predOp, UUID queryId, NV... annotations)
protected SolutionSetHashJoinOp	TestHTreeHashIndexOp.newSolutionSetHashJoinOp(BOp[] args, NV... anns)
protected abstract SolutionSetHashJoinOp	HashIndexOpTestCase.newSolutionSetHashJoinOp(BOp[] args, NV... anns) Factory for the SolutionSetHashJoinOp implementation.
protected SolutionSetHashJoinOp	TestJVMHashIndexOp.newSolutionSetHashJoinOp(BOp[] args, NV... anns)

Constructors in com.bigdata.bop.join with parameters of type BOp

Constructor and Description
AbstractHashJoinUtilityTestCase.MockPipelineOp(BOp[] args, NV... anns)
AbstractMergeJoin(BOp[] args, Map<String,Object> annotations)
AbstractMergeJoin(BOp[] args, NV... annotations)
DistinctTermScanOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
DistinctTermScanOp(BOp[] args, NV... annotations)
FastRangeCountOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
FastRangeCountOp(BOp[] args, NV... annotations)
HashIndexOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
HashIndexOp(BOp[] args, NV... annotations)
HashIndexOpBase(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
HashIndexOpBase(BOp[] args, NV... annotations)
HashJoinOp(BOp[] args, Map<String,Object> annotations)
HashJoinOp(BOp[] args, NV... annotations)
HTreeHashJoinOp(BOp[] args, Map<String,Object> annotations)
HTreeHashJoinOp(BOp[] args, NV... annotations)
HTreeMergeJoin(BOp[] args, Map<String,Object> annotations)
HTreeMergeJoin(BOp[] args, NV... annotations)
HTreeSolutionSetHashJoinOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
HTreeSolutionSetHashJoinOp(BOp[] args, NV... annotations)
JVMHashJoinOp(BOp[] args, Map<String,Object> annotations)
JVMHashJoinOp(BOp[] args, NV... annotations)
JVMMergeJoin(BOp[] args, Map<String,Object> annotations)
JVMMergeJoin(BOp[] args, NV... annotations)
JVMSolutionSetHashJoinOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
JVMSolutionSetHashJoinOp(BOp[] args, NV... annotations)
NestedLoopJoinOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
NestedLoopJoinOp(BOp[] args, NV... annotations)
PipelinedHashIndexAndSolutionSetJoinOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
PipelinedHashIndexAndSolutionSetJoinOp(BOp[] args, NV... annotations)
PipelineJoin(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
PipelineJoin(BOp[] args, NV... annotations) Shallow copy vararg constructor.
SolutionSetHashJoinOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
SolutionSetHashJoinOp(BOp[] args, NV... annotations)

Uses of BOp in com.bigdata.bop.joinGraph.rto

Classes in com.bigdata.bop.joinGraph.rto that implement BOp

Modifier and Type	Class and Description
class	JoinGraph A join graph with annotations for estimated cardinality and other details in support of runtime query optimization.

Constructors in com.bigdata.bop.joinGraph.rto with parameters of type BOp

Constructor and Description
JoinGraph(BOp[] args, Map<String,Object> anns)
JoinGraph(BOp[] args, NV... anns)

Uses of BOp in com.bigdata.bop.mutation

Classes in com.bigdata.bop.mutation that implement BOp

Modifier and Type	Class and Description
class	InsertOp<E> This operator writes elements constructed from binding sets and an orders list of variables and constants on an index.

Constructors in com.bigdata.bop.mutation with parameters of type BOp

Constructor and Description
InsertOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.

Uses of BOp in com.bigdata.bop.paths

Classes in com.bigdata.bop.paths that implement BOp

Modifier and Type	Class and Description
class	ArbitraryLengthPathOp
class	ZeroLengthPathOp Deprecated. Does not work. Leads to cardinality problems and can be removed. Zero Length Paths are integrated into the ALP node / ArbitraryLengthPathOp now.

Constructors in com.bigdata.bop.paths with parameters of type BOp

Constructor and Description
ArbitraryLengthPathOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
ArbitraryLengthPathOp(BOp[] args, NV... annotations)
ZeroLengthPathOp(BOp[] args, Map<String,Object> annotations) Deprecated. Shallow copy constructor.
ZeroLengthPathOp(BOp[] args, NV... annotations) Deprecated.

Uses of BOp in com.bigdata.bop.rdf.aggregate

Classes in com.bigdata.bop.rdf.aggregate that implement BOp

Modifier and Type	Class and Description
class	AVERAGE Operator computes the running sum over the presented binding sets for the given variable.
class	COUNT Operator computes the number of non-null values over the presented binding sets for the given variable.
class	GROUP_CONCAT Operator combines the string values over the presented binding sets for the given variable.
class	MAX Operator reports the minimum observed value over the presented binding sets for the given variable using SPARQL ORDER_BY semantics.
class	MIN Operator reports the minimum observed value over the presented binding sets for the given variable using SPARQL ORDER_BY semantics.
class	SAMPLE Operator reports an arbitrary value from presented binding sets for the given variable.
class	SUM Operator computes the running sum over the presented binding sets for the given variable.

Constructors in com.bigdata.bop.rdf.aggregate with parameters of type BOp

Constructor and Description
AVERAGE(BOp[] args, Map<String,Object> annotations)
COUNT(BOp[] args, Map<String,Object> annotations)
GROUP_CONCAT(BOp[] args, Map<String,Object> annotations)
MAX(BOp[] args, Map<String,Object> annotations)
MIN(BOp[] args, Map<String,Object> annotations)
SAMPLE(BOp[] args, Map<String,Object> annotations)
SUM(BOp[] args, Map<String,Object> annotations)

Uses of BOp in com.bigdata.bop.rdf.filter

Classes in com.bigdata.bop.rdf.filter that implement BOp

Modifier and Type	Class and Description
class	NativeDistinctFilter A scalable DISTINCT operator based for SPOs.
class	StripContextFilter Strips the context information from an SPO.

Constructors in com.bigdata.bop.rdf.filter with parameters of type BOp

Constructor and Description
NativeDistinctFilter(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
StripContextFilter(BOp[] args, Map<String,Object> annotations)

Uses of BOp in com.bigdata.bop.rdf.join

Classes in com.bigdata.bop.rdf.join that implement BOp

Modifier and Type	Class and Description
class	ChunkedMaterializationOp A vectored materialization operator based on pretty much the same logic as BigdataBindingSetResolverator.
class	DataSetJoin DataSetJoin(left)[var=g; graphs={graphIds}]
class	InlineMaterializeOp<E> This operator is used as part of the BigdataValue materialization step inside the pipeline.
class	MockTermResolverOp A vectored operator that resolves variables bound to mocked terms in binding sets through a dictionary join.
class	VariableUnificationOp Operator computing a join over two variables already bound variables in the mapping set (for which the IV has been computed already).

Constructors in com.bigdata.bop.rdf.join with parameters of type BOp

Constructor and Description
ChunkedMaterializationOp(BOp[] args, IVariable<?>[] vars, String namespace, long timestamp)
ChunkedMaterializationOp(BOp[] args, Map<String,Object> annotations)
ChunkedMaterializationOp(BOp[] args, NV... annotations)
DataSetJoin(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
DataSetJoin(BOp[] args, NV... annotations)
InlineMaterializeOp(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
InlineMaterializeOp(BOp[] args, NV... anns)
MockTermResolverOp(BOp[] args, IVariable<?>[] vars, String namespace, long timestamp)
MockTermResolverOp(BOp[] args, Map<String,Object> annotations)
MockTermResolverOp(BOp[] args, NV... annotations)
VariableUnificationOp(BOp[] args, Map<String,Object> annotations)
VariableUnificationOp(BOp[] args, NV... annotations)

Uses of BOp in com.bigdata.bop.rdf.update

Classes in com.bigdata.bop.rdf.update that implement BOp

Modifier and Type	Class and Description
class	AbstractAddRemoveStatementsOp Abstract base class for operations which add or remove statements from the statement indices.
class	ChunkedResolutionOp Vectored operator adds and/or resolves the RDF Values associated with mock IVs.
class	CommitOp Commit the operation.
class	InsertDataOp Operator to insert ISPOs into bigdata.
class	InsertStatementsOp Vectored insert operator for RDF Statements.
class	ParseOp Operator parses a RDF data source, writing bindings which represent statements onto the output sink.
class	RemoveStatementsOp Vectored remove operator for RDF Statements.

Constructors in com.bigdata.bop.rdf.update with parameters of type BOp

Constructor and Description
AbstractAddRemoveStatementsOp(BOp[] args, Map<String,Object> annotations)
ChunkedResolutionOp(BOp[] args, Map<String,Object> annotations)
CommitOp(BOp[] args, Map<String,Object> annotations)
InsertDataOp(BOp[] args, Map<String,Object> annotations)
InsertStatementsOp(BOp[] args, Map<String,Object> annotations)
ParseOp(BOp[] args, Map<String,Object> annotations)
RemoveStatementsOp(BOp[] args, Map<String,Object> annotations)

Uses of BOp in com.bigdata.bop.solutions

Classes in com.bigdata.bop.solutions that implement BOp

Modifier and Type	Class and Description
class	DropOp Operator drops the identified variables from the solutions
class	GroupByOp Base class for operators which perform aggregation operations on binding sets.
class	HTreeDistinctBindingSetsOp A pipelined DISTINCT operator based on the persistence capable HTree suitable for very large solution sets.
class	JVMDistinctBindingSetsOp A pipelined DISTINCT operator based on a hash table.
class	MemoryGroupByOp An in-memory at-once generalized aggregation operator.
class	MemorySortOp An in-memory merge sort for binding sets.
class	MockQuery
class	PipelinedAggregationOp A pipelined aggregation operator based on an in memory hash table associating with per-group state for each aggregate expression (it can also handle the degenerate case where all solutions form a single implicit group).
class	ProjectionOp Operator projects only the identified variables.
class	SliceOp An operator which imposes an offset/limit on a binding set pipeline.
class	SortOp Base class for operators which sort binding sets.

Methods in com.bigdata.bop.solutions with parameters of type BOp

Modifier and Type	Method and Description
protected boolean	GroupByState.isAggregate(BOp op, boolean isSelectClause, AtomicBoolean isSelectDependency, AtomicBoolean isNestedAggregates, AtomicBoolean isAnyDistinct) Return true iff the expression is an aggregate.
protected abstract PipelineOp	AbstractDistinctSolutionsTestCase.newDistinctBindingSetsOp(BOp[] args, NV... anns) Factory for a DISTINCT SOLUTIONS operator.
protected PipelineOp	TestHTreeDistinctBindingSets.newDistinctBindingSetsOp(BOp[] args, NV... anns)
protected PipelineOp	TestJVMDistinctBindingSets.newDistinctBindingSetsOp(BOp[] args, NV... anns)

Constructors in com.bigdata.bop.solutions with parameters of type BOp

Constructor and Description
DropOp(BOp[] args, Map<String,Object> annotations)
DropOp(BOp[] args, NV... annotations)
GroupByOp(BOp[] args, Map<String,Object> annotations)
HTreeDistinctBindingSetsOp(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
HTreeDistinctBindingSetsOp(BOp[] args, NV... annotations)
JVMDistinctBindingSetsOp(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
JVMDistinctBindingSetsOp(BOp[] args, NV... annotations)
MemoryGroupByOp(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
MemorySortOp(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
PipelinedAggregationOp(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
ProjectionOp(BOp[] args, Map<String,Object> annotations)
ProjectionOp(BOp[] args, NV... annotations)
SliceOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
SliceOp(BOp[] args, NV... annotations)
SortOp(BOp[] args, Map<String,Object> annotations)

Uses of BOp in com.bigdata.rdf.internal.constraints

Classes in com.bigdata.rdf.internal.constraints that implement BOp

Modifier and Type	Class and Description
class	AndBOp Imposes the constraint x AND y.
class	BNodeBOp The BNODE()/BNODE(Literal) function as defined in SPARQL 1.1 Query Language for RDF.
class	CoalesceBOp Coalesce BOp The COALESCE function form returns the RDF term value of the first expression that evaluates without error.
class	CompareBOp Perform open-world value comparison operations per the SPARQL spec (the LT operator).
class	ComputedIN "IN" and "NOT IN" operator based on testing of the enumerated value expressions.
class	ConcatBOp
class	ConditionalBind<E extends IV> Operator causes a variable to be bound to the result of its evaluation as a side-effect unless the variable is already bound and the as-bound value does not compare as equals.
class	DatatypeBOp Return the datatype of the literal argument.
class	DateBOp A date expression involving a left IValueExpression operand.
class	DigestBOp A Digest expression involving a IValueExpression operand.
class	EBVBOp Calculates the "effective boolean value" of an IValueExpression.
class	EncodeForURIBOp
class	FalseBOp Always evaluates to false.
class	FuncBOp Call one of the Sesame casting functions.
class	IfBOp Conditional if BOp
class	InBinaryBOp A constraint that a variable may only take on the bindings enumerated by some set.
class	InBOp Abstract base class for "IN" IConstraint implementations.
class	InferenceBVE
class	InHashBOp A constraint that a value expression which may only take on the bindings enumerated by some set of constants.
class	IriBOp The IRI function, as defined in SPARQL 1.1 Query Language for RDF.
class	IsBNodeBOp Imposes the constraint isBNode(x).
class	IsBoundBOp Imposes the constraint bound(x) for the variable x.
class	IsInlineBOp Imposes the constraint isInline(x).
class	IsLiteralBOp Imposes the constraint isLiteral(x).
class	IsMaterializedBOp Imposes the constraint isMaterialized(x).
class	IsNumericBOp Imposes the constraint isLiteral(x).
class	IsURIBOp Imposes the constraint isURI(x).
class	IVValueExpression<T extends IV> A specialized IValueExpression that evaluates to an IV.
class	LangBOp Return the language tag of the literal argument.
class	LangMatchesBOp Implements the langMatches SPARQL operator.
class	LcaseBOp http://www.w3.org/2005/xpath-functions#lower-case
class	MathBOp A math expression involving a left and right IValueExpression operand.
class	NeedsMaterializationBOp Attempts to run a constraint prior to materialization.
class	NotBOp Imposes the constraint !x.
class	NowBOp Implements the now() operator.
class	NumericBOp A math expression involving a left and right IValueExpression operand.
class	OrBOp Imposes the constraint x OR y.
class	ProjectedConstraint This class implements 'AS' in a projection as found in both subselects and bind, e.g.
class	RandBOp
class	RangeBOp Operator used to impose a key-range constraint on a variable on access path.
class	RegexBOp SPARQL REGEX operator.
class	ReplaceBOp
class	SameTermBOp Compare two terms for exact equality.
class	SPARQLConstraint<X extends XSDBooleanIV> BOpConstraint that wraps a EBVBOp, which itself computes the effective boolean value of an IValueExpression.
class	SparqlTypeErrorBOp Always throws a SparqlTypeError.
class	StrAfterBOp
class	StrBeforeBOp
class	StrBOp Convert the IV to a xsd:string.
class	StrcontainsBOp
class	StrdtBOp
class	StrendsBOp
class	StrlangBOp
class	StrlenBOp
class	StrstartsBOp
class	SubstrBOp This function has an origin of ONE (1) not ZERO (0).
class	TrueBOp Always evaluates to true.
class	TryBeforeMaterializationConstraint This is useful when a solution can be filtered out before it goes through the materialization pipeline.
class	UcaseBOp
class	UUIDBOp Implements the now() operator.
class	XSDBooleanIVValueExpression Base class for RDF value expression BOps that happen to evaluate to an XSDBooleanIV.
class	XsdLongBOp Convert the IV to a xsd:long.
class	XsdStrBOp Convert the IV to a xsd:string.
class	XsdUnsignedLongBOp Convert the IV to a xsd:unsignedLong.

Constructors in com.bigdata.rdf.internal.constraints with parameters of type BOp

Constructor and Description
AndBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
BNodeBOp(BOp[] args, Map<String,Object> anns)
CoalesceBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
CompareBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
ComputedIN(BOp[] args, Map<String,Object> annotations)
ConcatBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
ConditionalBind(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
DatatypeBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
DateBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
DigestBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
EBVBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
EncodeForURIBOp(BOp[] args, Map<String,Object> anns)
FalseBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
FuncBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
IfBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
InBinaryBOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
InBOp(BOp[] args, Map<String,Object> annotations)
InferenceBVE(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
InHashBOp(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
IriBOp(BOp[] args, Map<String,Object> anns)
IsBNodeBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
IsBoundBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
IsInlineBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
IsLiteralBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
IsMaterializedBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
IsNumericBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
IsURIBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
IVValueExpression(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
LangBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
LangMatchesBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
LcaseBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
MathBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
NeedsMaterializationBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
NotBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
NowBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
NumericBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
OrBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
ProjectedConstraint(BOp[] args, Map<String,Object> annotations)
RandBOp(BOp[] args, Map<String,Object> anns)
RangeBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
RegexBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
ReplaceBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
SameTermBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
SPARQLConstraint(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
SparqlTypeErrorBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
StrAfterBOp(BOp[] args, Map<String,Object> anns)
StrBeforeBOp(BOp[] args, Map<String,Object> anns)
StrBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
StrcontainsBOp(BOp[] args, Map<String,Object> anns)
StrdtBOp(BOp[] args, Map<String,Object> anns)
StrendsBOp(BOp[] args, Map<String,Object> anns)
StrlangBOp(BOp[] args, Map<String,Object> anns)
StrlenBOp(BOp[] args, Map<String,Object> anns)
StrstartsBOp(BOp[] args, Map<String,Object> anns)
SubstrBOp(BOp[] args, Map<String,Object> anns)
TrueBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
TryBeforeMaterializationConstraint(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
UcaseBOp(BOp[] args, Map<String,Object> anns)
UUIDBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
XSDBooleanIVValueExpression(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
XsdLongBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
XsdStrBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
XsdUnsignedLongBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.

Uses of BOp in com.bigdata.rdf.internal.encoder

Constructors in com.bigdata.rdf.internal.encoder with parameters of type BOp

Constructor and Description
IVBindingSetEncoderWithIVCache(IRawStore store, boolean filter, BOp op) Deprecated.

Uses of BOp in com.bigdata.rdf.lexicon

Classes in com.bigdata.rdf.lexicon that implement BOp

Modifier and Type	Class and Description
class	CacheValueFilter Cache the BigdataValue on the IV (create a cross linkage).
class	LexPredicate A lex(BigdataValue,IV) predicate used for querying the LexiconRelation's TERMS index.

Method parameters in com.bigdata.rdf.lexicon with type arguments of type BOp

Modifier and Type	Method and Description
BigdataValue	LexiconRelation.newElement(List<BOp> a, IBindingSet bindingSet) Note : this method is part of the mutation api.

Constructors in com.bigdata.rdf.lexicon with parameters of type BOp

Constructor and Description
CacheValueFilter(BOp[] args, Map<String,Object> annotations)
LexPredicate(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
LexPredicate(BOp[] args, NV... anns) Variable argument version of the shallow copy constructor.

Uses of BOp in com.bigdata.rdf.rules

Classes in com.bigdata.rdf.rules that implement BOp

Modifier and Type	Class and Description
class	RejectAnythingSameAsItself Rejects (x y z) iff x==z and y==owl:sameAs, where x, y, and z are variables.

Constructors in com.bigdata.rdf.rules with parameters of type BOp

Constructor and Description
RejectAnythingSameAsItself(BOp[] values, Map<String,Object> annotations) Required shallow copy constructor.

Uses of BOp in com.bigdata.rdf.sail.sparql

Methods in com.bigdata.rdf.sail.sparql with parameters of type BOp

Modifier and Type	Method and Description
protected boolean	VerifyAggregates.isAggregate(BOp op, boolean isSelectClause, AtomicBoolean isSelectDependency, AtomicBoolean isNestedAggregates, AtomicBoolean isAnyDistinct) Return true iff the expression is an aggregate.

Uses of BOp in com.bigdata.rdf.sparql.ast

Subinterfaces of BOp in com.bigdata.rdf.sparql.ast

Modifier and Type	Interface and Description
interface	IBindingProducerNode A marker interface for IQueryNodes which are capable of producing bindings.
interface	IGroupMemberNode An interface for an IQueryNode which may appear in an IGroupNode.
interface	IGroupNode<E extends IGroupMemberNode> A type of query node that groups a set of query nodes together.
interface	IJoinNode A marker interface for any kind of AST Node which joins stuff.
interface	IQueryNode This is the basic interface for any AST operator that appears in the query plan.
interface	IReorderableNode Interface for things which can be re-ordered by the static join optimizer.
interface	IStatementContainer Marker interface for things which either are statements (or statement patterns) or contain statements (or statement pattern).

Classes in com.bigdata.rdf.sparql.ast that implement BOp

Modifier and Type	Class and Description
class	AbstractFromToGraphManagement Any of the operations which has a FROM and/or TO graph.
class	AbstractGraphDataUpdate Abstract base class for the INSERT DATA and DELETE DATA operations.
class	AbstractOneGraphManagement Any of the operations which acts on a single target graph.
class	AbstractStatementContainer<E extends IStatementContainer> Recursive container for ground StatementPatternNodes.
class	AddGraph Graph management operation inserts all data from one graph into another.
class	ArbitraryLengthPathNode A special kind of AST node that represents the SPARQL 1.1 arbitrary length path operator.
class	AssignmentNode AST node models the assignment of a value expression to a variable
class	ASTBase Base class for the AST.
class	ASTContainer A super container for the AST.
class	BindingsClause The solutions declared by a BINDINGS clause.
class	ClearGraph The CLEAR operation removes all the triples in the specified graph(s) in the Graph Store.
class	ConstantNode Used to represent a constant in the AST.
class	ConstructNode A template for the construction of one or more graphs based on the solutions projected by a query.
class	CopyGraph The COPY operation is a shortcut for inserting all data from an input graph into a destination graph.
class	CreateEntailments The CREATE ENTAILMENTS operation compute entailments in the Graph Store.
class	CreateGraph This operation creates a graph in the Graph Store (this operation is a NOP for bigdata).
class	DatasetNode AST node models a SPARQL default graph and/or named graph data set.
class	DeleteData The DELETE DATA operation removes some triples, given inline in the request, if the respective graphs in the Graph Store contain those:
class	DeleteInsertGraph The DELETE/INSERT operation can be used to remove or add triples from/to the Graph Store based on bindings for a query pattern specified in a WHERE clause:
class	DisableEntailments The DISABLE ENTAILMENTS operation disable incremental truth maintenance.
class	DropEntailments The DROP ENTAILMENTS operation removes all entailments from the Graph Store.
class	DropGraph The DROP operation removes the specified graph(s) from the Graph Store.
class	DummyConstantNode The dummy constant node is used to represent constants in the AST that do not actually exist in the database.
class	EnableEntailments The ENABLE ENTAILMENTS operation enable incremental truth maintenance.
class	ExistsNode A special function node for modeling EXISTS.
class	FilterNode AST node models a value expression which imposes a constraint.
class	FunctionNode AST node for anything which is neither a constant nor a variable, including math operators, string functions, etc.
static class	FunctionRegistry.UnknownFunctionBOp
class	GraphManagement A Graph Management operation.
class	GraphPatternGroup<E extends IGroupMemberNode> Join group or union.
class	GraphUpdate A Graph Update operation.
class	GroupByNode AST node for a GROUP BY clause.
class	GroupMemberNodeBase<E extends IGroupMemberNode> Anything which can appear in an IGroupNode.
class	GroupMemberValueExpressionNodeBase
class	GroupNodeBase<E extends IGroupMemberNode> Base class for AST group nodes.
class	HavingNode AST node for a HAVING clause.
class	InsertData The INSERT DATA operation adds some triples, given inline in the request, into the Graph Store:
class	JoinGroupNode An optional or non-optional collection of query nodes that run together in a group.
class	LoadGraph The LOAD operation reads an RDF document from a IRI and inserts its triples into the specified graph in the Graph Store.
class	MoveGraph The MOVE operation is a shortcut for moving all data from an input graph into a destination graph.
class	NamedSubqueriesNode A node whose children are a list of NamedSubqueryRoots.
class	NamedSubqueryInclude An AST node which provides a reference in an IGroupNode and indicates that a named solution set should be joined with the solutions in the group.
class	NamedSubqueryRoot A subquery with a named solution set which can be referenced from other parts of the query.
class	NotExistsNode A special function node for modeling NOT EXISTS.
class	OrderByExpr An IValueExpressionNode paired with a flag to indicating an ascending or descending sort order.
class	OrderByNode AST node models an ORDER BY clause.
class	PathNode AST Node used to represent a property path.
static class	PathNode.PathAlternative Used to signify an OR (UNION) of multiple possible subpaths.
static class	PathNode.PathElt A specific path element.
static class	PathNode.PathNegatedPropertySet
static class	PathNode.PathOneInPropertySet
static class	PathNode.PathSequence A sequence of paths (JOINS).
class	ProjectionNode AST node modeling projected value expressions.
class	PropertyPathNode A node in the AST representing a triple pattern with a property path.
class	PropertyPathUnionNode This node is purely to trick the ASTJoinOrderByTypeOptimizer - we need to keep the property path stuff in the right order, even the UNIONs.
class	QuadData Recursive container for ground StatementPatternNodes.
class	QuadsDataOrNamedSolutionSet An AST node which models either QuadData or a named solution set in support of the INSERT clause and DELETE clause of a DeleteInsertGraph operations.
class	QueryBase Contains the projection clause, where clause, and solution modified clauses.
class	QueryNodeBase AST node base class.
class	QueryNodeListBaseNode<E extends IQueryNode> Base class for AST nodes which model an ordered list of children.
class	QueryRoot The top-level Query.
class	RangeNode It's a value expression because it does eventually evaluate to a value - a Range value.
class	SliceNode AST node for a SLICE (offset/limit).
class	SolutionModifierBase AST node for solution modifiers (SLICE, ORDER BY, GROUP BY)
class	StatementPatternNode A node in the AST representing a statement pattern.
class	SubqueryBase AST node for subqueries.
class	SubqueryFunctionNodeBase A special function node for modeling value expression nodes which are evaluated against an inner graph expression, such as EXISTS and NOT EXISTS.
class	SubqueryRoot A SPARQL 1.1 style subquery.
class	TermNode Used to represent a variable or constant in the AST (a term in a statement pattern for example).
class	UnionNode A special kind of group IGroupNode that represents the sparql union operator.
class	Update A SPARQL Update operation.
class	UpdateRoot The top level container for a sequence of UPDATE operations.
class	ValueExpressionListBaseNode<E extends IValueExpressionNode> Base class for AST nodes which model an ordered list of value expressions.
class	ValueExpressionNode AST node for value expressions.
class	VarNode Used to represent a variable in the AST.
class	ZeroLengthPathNode Deprecated. Does not work - leads to cardinality problems and can be removed. Zero Length Paths are integrated into the ALP node / ArbitraryLengthPathOp now.

Methods in com.bigdata.rdf.sparql.ast with parameters of type BOp

Modifier and Type	Method and Description
void	GroupNodeBase.addArg(BOp newArg) Add a new argument (core mutation method).
void	UnionNode.addArg(BOp newArg)
void	GroupNodeBase.addArg(int index, BOp newArg) Add a new argument (core mutation method) at the specified index.
void	UnionNode.addArg(int index, BOp newArg)
protected void	SubqueryFunctionNodeBase.annotationValueToString(StringBuilder sb, BOp val, int i)
static INeedsMaterialization.Requirement	StaticAnalysis.gatherVarsToMaterialize(BOp c, Set<IVariable<IV>> terms) Static helper used to determine materialization requirements.
static INeedsMaterialization.Requirement	StaticAnalysis.gatherVarsToMaterialize(BOp c, Set<IVariable<IV>> terms, boolean includeVarsInAnnotations) Static helper used to determine materialization requirements.
static INeedsMaterialization.Requirement	StaticAnalysis.gatherVarsToMaterialize(BOp c, Set<IVariable<IV>> terms, Map<IVariable<?>,IValueExpression<?>> varMap) Static helper used to determine materialization requirements.
static INeedsMaterialization.Requirement	StaticAnalysis.gatherVarsToMaterialize(BOp c, Set<IVariable<IV>> terms, Map<IVariable<?>,IValueExpression<?>> varMap, boolean includeVarsInAnnotations) Static helper used to determine materialization requirements.
Set<IVariable<?>>	StaticAnalysisBase.getSpannedVariables(BOp op, boolean filters, Set<IVariable<?>> varSet) Return the distinct variables in the operator tree.
Set<IVariable<?>>	StaticAnalysisBase.getSpannedVariables(BOp op, Set<IVariable<?>> varSet) Return the distinct variables in the operator tree, including on those on annotations attached to operators.
static boolean	StaticAnalysis.isMinus(BOp node) Checks whether a given node is a MINUS node.
static boolean	StaticAnalysis.isMinusOrOptional(BOp node) Checks whether a given node is a MINUS or OPTIONAL node.
static boolean	StaticAnalysis.isOptional(BOp node) Checks whether a given node is an OPTIONAL node.
boolean	GroupNodeBase.removeArg(BOp child) Remove the 1st occurrence of the argument (core mutation method).
int	AssignmentNode.replaceAllWith(BOp oldVal, BOp newVal)
int	ASTBase.replaceAllWith(BOp oldVal, BOp newVal) Replace all occurrences of the old value with the new value in both the arguments and annotations of this operator (recursive).
int	GroupNodeBase.replaceWith(BOp oldChild, BOp newChild) Replace a child of a node with another reference (destructive modification).
int	UnionNode.replaceWith(BOp oldChild, BOp newChild)
ModifiableBOpBase	GroupNodeBase.setArg(int index, BOp newArg) Replace the value of the argument at the specified index (core mutation method).
ModifiableBOpBase	AssignmentNode.setArg(int index, BOp newArg)
ModifiableBOpBase	AssignmentNode.setArgs(BOp[] args)

Constructors in com.bigdata.rdf.sparql.ast with parameters of type BOp

Constructor and Description
AbstractFromToGraphManagement(BOp[] args, Map<String,Object> anns)
AbstractGraphDataUpdate(BOp[] args, Map<String,Object> anns)
AbstractOneGraphManagement(BOp[] args, Map<String,Object> anns)
AbstractStatementContainer(BOp[] args, Map<String,Object> anns)
AddGraph(BOp[] args, Map<String,Object> anns)
ArbitraryLengthPathNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
AssignmentNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
ASTBase(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
ASTContainer(BOp[] args, Map<String,Object> annotations) Shallow copy constructor.
BindingsClause(BOp[] args, Map<String,Object> anns)
ClearGraph(BOp[] args, Map<String,Object> anns)
ConstantNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
ConstructNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
CopyGraph(BOp[] args, Map<String,Object> anns)
CreateEntailments(BOp[] args, Map<String,Object> anns)
CreateGraph(BOp[] args, Map<String,Object> anns)
DatasetNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
DeleteData(BOp[] args, Map<String,Object> anns)
DeleteInsertGraph(BOp[] args, Map<String,Object> anns)
DisableEntailments(BOp[] args, Map<String,Object> anns)
DropEntailments(BOp[] args, Map<String,Object> anns)
DropGraph(BOp[] args, Map<String,Object> anns)
DummyConstantNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
EnableEntailments(BOp[] args, Map<String,Object> anns)
ExistsNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
FilterNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
FunctionNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
FunctionRegistry.UnknownFunctionBOp(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
GraphManagement(BOp[] args, Map<String,Object> anns)
GraphPatternGroup(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
GraphUpdate(BOp[] args, Map<String,Object> anns)
GroupByNode(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
GroupMemberNodeBase(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
GroupMemberValueExpressionNodeBase(BOp[] args, Map<String,Object> anns)
GroupNodeBase(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
HavingNode(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
InsertData(BOp[] args, Map<String,Object> anns)
JoinGroupNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
LoadGraph(BOp[] args, Map<String,Object> anns)
MoveGraph(BOp[] args, Map<String,Object> anns)
NamedSubqueriesNode(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
NamedSubqueryInclude(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
NamedSubqueryRoot(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
NotExistsNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
OrderByExpr(BOp[] args, Map<String,Object> annotations) Required shallow copy constructor.
OrderByNode(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
PathNode.PathAlternative(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
PathNode.PathElt(BOp arg)
PathNode.PathElt(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
PathNode.PathElt(BOp arg, boolean inverse)
PathNode.PathElt(BOp arg, boolean inverse, PathNode.PathMod mod)
PathNode.PathElt(BOp arg, PathNode.PathMod mod)
PathNode.PathNegatedPropertySet(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
PathNode.PathOneInPropertySet(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
PathNode.PathSequence(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
PathNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
ProjectionNode(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
PropertyPathNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
PropertyPathUnionNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
QuadData(BOp[] args, Map<String,Object> anns)
QuadsDataOrNamedSolutionSet(BOp[] args, Map<String,Object> annotations)
QueryBase(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
QueryNodeBase(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
QueryNodeListBaseNode(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
QueryRoot(BOp[] args, Map<String,Object> anns)
RangeNode(BOp[] args, Map<String,Object> anns)
SliceNode(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
SolutionModifierBase(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
StatementPatternNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
SubqueryBase(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
SubqueryFunctionNodeBase(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
SubqueryRoot(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
TermNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
UnionNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
Update(BOp[] args, Map<String,Object> anns)
UpdateRoot(BOp[] args, Map<String,Object> anns)
ValueExpressionListBaseNode(BOp[] args, Map<String,Object> anns) Shallow copy constructor.
ValueExpressionNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
VarNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.
ZeroLengthPathNode(BOp[] args, Map<String,Object> anns) Deprecated. Required shallow copy constructor.

Uses of BOp in com.bigdata.rdf.sparql.ast.eval

Methods in com.bigdata.rdf.sparql.ast.eval that return BOp

Modifier and Type	Method and Description
protected static BOp[]	AST2BOpBase.leftOrEmpty(PipelineOp left) Return either left wrapped as the sole member of an array or NOARGS iff left is null.

Uses of BOp in com.bigdata.rdf.sparql.ast.eval.update

Methods in com.bigdata.rdf.sparql.ast.eval.update that return BOp

Modifier and Type	Method and Description
protected static BOp[]	TestUpdateBootstrap.leftOrEmpty(PipelineOp left) Return either left wrapped as the sole member of an array or NOARGS iff left is null.

Uses of BOp in com.bigdata.rdf.sparql.ast.explainhints

Methods in com.bigdata.rdf.sparql.ast.explainhints that return BOp

Modifier and Type	Method and Description
BOp	ExplainHint.getExplainHintNode()
BOp	IExplainHint.getExplainHintNode()

Methods in com.bigdata.rdf.sparql.ast.explainhints that return types with arguments of type BOp

Modifier and Type	Method and Description
static Iterator<BOp>	ExplainHints.explainHintAnnotatedBOpIterator(BOp astBase) Returns all BOps that are annotated with ExplainHints.

Methods in com.bigdata.rdf.sparql.ast.explainhints with parameters of type BOp

Modifier and Type	Method and Description
static Iterator<BOp>	ExplainHints.explainHintAnnotatedBOpIterator(BOp astBase) Returns all BOps that are annotated with ExplainHints.
static void	ExplainHints.removeExplainHintAnnotationsFromBOp(BOp bop) Utility function to remove explain hint annotations from a BOp.

Constructors in com.bigdata.rdf.sparql.ast.explainhints with parameters of type BOp

Constructor and Description
BottomUpSemanticsExplainHint(IVariable<?> original, IVariable<?> renamed, BOp explainHintASTBase)
ExplainHint(String explainHintDescription, String explainHintType, IExplainHint.ExplainHintCategory explainHintCategory, IExplainHint.ExplainHintSeverity explainHintSeverity, BOp explainHintNode) Constructor
UnsatisfiableMinusExplainHint(BOp explainHintASTBase)

Uses of BOp in com.bigdata.rdf.sparql.ast.service

Classes in com.bigdata.rdf.sparql.ast.service that implement BOp

Modifier and Type	Class and Description
class	ServiceNode An extension point for external service calls which produce solution multisets (a SPARQL SERVICE).

Constructors in com.bigdata.rdf.sparql.ast.service with parameters of type BOp

Constructor and Description
ServiceNode(BOp[] args, Map<String,Object> anns) Required shallow copy constructor.

Uses of BOp in com.bigdata.rdf.spo

Classes in com.bigdata.rdf.spo that implement BOp

Modifier and Type	Class and Description
class	SPOPredicate A predicate that is a triple with one or more variables.
class	SPOStarJoin Implementation of a star join for SPOs.
protected static class	TestSPORelation.P

Method parameters in com.bigdata.rdf.spo with type arguments of type BOp

Modifier and Type	Method and Description
SPO	SPORelation.newElement(List<BOp> a, IBindingSet bindingSet)

Constructors in com.bigdata.rdf.spo with parameters of type BOp

Constructor and Description
SPOPredicate(BOp[] values, Map<String,Object> annotations) Required shallow copy constructor.
SPOPredicate(BOp[] values, NV... annotations) Variable argument version of the shallow copy constructor.
SPOStarJoin(BOp[] values, Map<String,Object> annotations) Required shallow copy constructor.
TestSPORelation.P(BOp[] values, Map<String,Object> annotations) Required shallow copy constructor.

Uses of BOp in com.bigdata.relation

Method parameters in com.bigdata.relation with type arguments of type BOp

Modifier and Type	Method and Description
E	RelationFusedView.newElement(List<BOp> a, IBindingSet bindingSet) Deprecated.
E	IRelation.newElement(List<BOp> args, IBindingSet bindingSet) Create and return a new element.

Uses of BOp in com.bigdata.relation.rule

Subinterfaces of BOp in com.bigdata.relation.rule

Modifier and Type	Interface and Description
interface	IStarJoin<E> Deprecated. This is not currently supported. It was implemented, but we did not find improved performance for it.

Classes in com.bigdata.relation.rule that implement BOp

Modifier and Type	Class and Description
protected static class	AbstractRuleTestCase.P

Constructors in com.bigdata.relation.rule with parameters of type BOp

Constructor and Description
AbstractRuleTestCase.P(BOp[] values, Map<String,Object> annotations) Required shallow copy constructor.