|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of Op in com.hp.hpl.jena.sparql.algebra |
---|
Methods in com.hp.hpl.jena.sparql.algebra that return Op | |
---|---|
static Op |
OpExtRegistry.buildExt(String tag,
ItemList args)
|
static Op |
PropertyFunctionGenerator.buildPropertyFunctions(OpBGP opBGP,
Context context)
|
static Op |
Algebra.compile(Element elt)
Compile a pattern. |
Op |
AlgebraGenerator.compile(Element elt)
|
static Op |
Algebra.compile(Query query)
Compile a query - pattern and modifiers. |
Op |
AlgebraGenerator.compile(Query query)
|
Op |
OpExtRegistry.BuildExtExt.make(ItemList list)
|
Op |
OpExtRegistry.BuildExt2.make(ItemList list)
|
static Op |
Algebra.optimize(Op op)
Apply static transformations to a query to optimize it |
static Op |
Algebra.optimize(Op op,
Context context)
Apply static transformations to a query to optimize it |
static Op |
Algebra.parse(Item item)
|
static Op |
Algebra.parse(String string)
|
static Op |
Algebra.parse(String string,
com.hp.hpl.jena.shared.PrefixMapping pmap)
|
static Op |
AlgebraQuad.quadize(Op op)
|
static Op |
Algebra.read(String filename)
|
static Op |
OpLib.sub(Op1 op)
|
static Op |
Algebra.toQuadForm(Op op)
Turn an algebra expression into quad form |
static Op |
TransformUnionQuery.transform(Op op)
|
Op |
TransformBase.transform(OpAssign opAssign,
Op subOp)
|
Op |
TransformWrapper.transform(OpAssign opAssign,
Op subOp)
|
Op |
TransformCopy.transform(OpAssign opAssign,
Op subOp)
|
Op |
Transform.transform(OpAssign opAssign,
Op subOp)
|
Op |
TransformUnionQuery.transform(OpBGP opBGP)
|
Op |
TransformBase.transform(OpBGP opBGP)
|
Op |
TransformWrapper.transform(OpBGP opBGP)
|
Op |
TransformCopy.transform(OpBGP opBGP)
|
Op |
Transform.transform(OpBGP opBGP)
|
Op |
TransformBase.transform(OpConditional opCond,
Op left,
Op right)
|
Op |
TransformWrapper.transform(OpConditional opCond,
Op left,
Op right)
|
Op |
TransformCopy.transform(OpConditional opCond,
Op left,
Op right)
|
Op |
Transform.transform(OpConditional opCondition,
Op left,
Op right)
|
Op |
TransformBase.transform(OpDatasetNames dsNames)
|
Op |
TransformWrapper.transform(OpDatasetNames dsNames)
|
Op |
TransformCopy.transform(OpDatasetNames opDatasetNames)
|
Op |
Transform.transform(OpDatasetNames dsNames)
|
Op |
TransformBase.transform(OpDiff opDiff,
Op left,
Op right)
|
Op |
TransformWrapper.transform(OpDiff opDiff,
Op left,
Op right)
|
Op |
TransformCopy.transform(OpDiff opDiff,
Op left,
Op right)
|
Op |
Transform.transform(OpDiff opDiff,
Op left,
Op right)
|
Op |
TransformBase.transform(OpDisjunction opDisjunction,
List<Op> elts)
|
Op |
TransformWrapper.transform(OpDisjunction opDisjunction,
List<Op> elts)
|
Op |
TransformCopy.transform(OpDisjunction opDisjunction,
List<Op> elts)
|
Op |
Transform.transform(OpDisjunction opDisjunction,
List<Op> elts)
|
Op |
TransformBase.transform(OpDistinct opDistinct,
Op subOp)
|
Op |
TransformWrapper.transform(OpDistinct opDistinct,
Op subOp)
|
Op |
TransformCopy.transform(OpDistinct opDistinct,
Op subOp)
|
Op |
Transform.transform(OpDistinct opDistinct,
Op subOp)
|
Op |
TransformBase.transform(OpExt opExt)
|
Op |
TransformWrapper.transform(OpExt opExt)
|
Op |
TransformCopy.transform(OpExt opExt)
|
Op |
Transform.transform(OpExt opExt)
|
Op |
TransformBase.transform(OpExtend opExtend,
Op subOp)
|
Op |
TransformWrapper.transform(OpExtend opExtend,
Op subOp)
|
Op |
TransformCopy.transform(OpExtend opExtend,
Op subOp)
|
Op |
Transform.transform(OpExtend opExtend,
Op subOp)
|
Op |
TransformBase.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformWrapper.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformCopy.transform(OpFilter opFilter,
Op subOp)
|
Op |
Transform.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformUnionQuery.transform(OpGraph opGraph,
Op x)
|
Op |
TransformBase.transform(OpGraph opGraph,
Op subOp)
|
Op |
TransformWrapper.transform(OpGraph opGraph,
Op subOp)
|
Op |
TransformCopy.transform(OpGraph opGraph,
Op subOp)
|
Op |
Transform.transform(OpGraph opGraph,
Op subOp)
|
Op |
TransformBase.transform(OpGroup opGroup,
Op subOp)
|
Op |
TransformWrapper.transform(OpGroup opGroup,
Op subOp)
|
Op |
TransformCopy.transform(OpGroup opGroup,
Op subOp)
|
Op |
Transform.transform(OpGroup opGroup,
Op subOp)
|
Op |
TransformBase.transform(OpJoin opJoin,
Op left,
Op right)
|
Op |
TransformWrapper.transform(OpJoin opJoin,
Op left,
Op right)
|
Op |
TransformCopy.transform(OpJoin opJoin,
Op left,
Op right)
|
Op |
Transform.transform(OpJoin opJoin,
Op left,
Op right)
|
Op |
TransformBase.transform(OpLabel opLabel,
Op subOp)
|
Op |
TransformWrapper.transform(OpLabel opLabel,
Op subOp)
|
Op |
TransformCopy.transform(OpLabel opLabel,
Op subOp)
|
Op |
Transform.transform(OpLabel opLabel,
Op subOp)
|
Op |
TransformBase.transform(OpLeftJoin opLeftJoin,
Op left,
Op right)
|
Op |
TransformWrapper.transform(OpLeftJoin opLeftJoin,
Op left,
Op right)
|
Op |
TransformCopy.transform(OpLeftJoin opLeftJoin,
Op left,
Op right)
|
Op |
Transform.transform(OpLeftJoin opLeftJoin,
Op left,
Op right)
|
Op |
TransformBase.transform(OpList opList,
Op subOp)
|
Op |
TransformWrapper.transform(OpList opList,
Op subOp)
|
Op |
TransformCopy.transform(OpList opList,
Op subOp)
|
Op |
Transform.transform(OpList opList,
Op subOp)
|
Op |
TransformBase.transform(OpMinus opMinus,
Op left,
Op right)
|
Op |
TransformWrapper.transform(OpMinus opMinus,
Op left,
Op right)
|
Op |
TransformCopy.transform(OpMinus opMinus,
Op left,
Op right)
|
Op |
Transform.transform(OpMinus opMinus,
Op left,
Op right)
|
Op |
TransformBase.transform(OpNull opNull)
|
Op |
TransformWrapper.transform(OpNull opNull)
|
Op |
TransformCopy.transform(OpNull opNull)
|
Op |
Transform.transform(OpNull opNull)
|
Op |
TransformBase.transform(OpOrder opOrder,
Op subOp)
|
Op |
TransformWrapper.transform(OpOrder opOrder,
Op subOp)
|
Op |
TransformCopy.transform(OpOrder opOrder,
Op subOp)
|
Op |
Transform.transform(OpOrder opOrder,
Op subOp)
|
Op |
TransformBase.transform(OpPath opPath)
|
Op |
TransformWrapper.transform(OpPath opPath)
|
Op |
TransformCopy.transform(OpPath opPath)
|
Op |
Transform.transform(OpPath opPath)
|
Op |
TransformBase.transform(OpProcedure opProc,
Op subOp)
|
Op |
TransformWrapper.transform(OpProcedure opProc,
Op subOp)
|
Op |
TransformCopy.transform(OpProcedure opProc,
Op subOp)
|
Op |
Transform.transform(OpProcedure opProcedure,
Op subOp)
|
Op |
TransformBase.transform(OpProject opProject,
Op subOp)
|
Op |
TransformWrapper.transform(OpProject opProject,
Op subOp)
|
Op |
TransformCopy.transform(OpProject opProject,
Op subOp)
|
Op |
Transform.transform(OpProject opProject,
Op subOp)
|
Op |
TransformBase.transform(OpPropFunc opPropFunc,
Op subOp)
|
Op |
TransformWrapper.transform(OpPropFunc opPropFunc,
Op subOp)
|
Op |
TransformCopy.transform(OpPropFunc opPropFunc,
Op subOp)
|
Op |
Transform.transform(OpPropFunc opPropFunc,
Op subOp)
|
Op |
TransformBase.transform(OpQuad opQuad)
|
Op |
TransformWrapper.transform(OpQuad opQuad)
|
Op |
TransformCopy.transform(OpQuad opQuad)
|
Op |
Transform.transform(OpQuad opQuad)
|
Op |
TransformUnionQuery.transform(OpQuadPattern quadPattern)
|
Op |
TransformBase.transform(OpQuadPattern quadPattern)
|
Op |
TransformWrapper.transform(OpQuadPattern quadPattern)
|
Op |
TransformCopy.transform(OpQuadPattern opQuadPattern)
|
Op |
Transform.transform(OpQuadPattern quadPattern)
|
Op |
TransformBase.transform(OpReduced opReduced,
Op subOp)
|
Op |
TransformWrapper.transform(OpReduced opReduced,
Op subOp)
|
Op |
TransformCopy.transform(OpReduced opReduced,
Op subOp)
|
Op |
Transform.transform(OpReduced opReduced,
Op subOp)
|
Op |
TransformBase.transform(OpSequence opSequence,
List<Op> elts)
|
Op |
TransformWrapper.transform(OpSequence opSequence,
List<Op> elts)
|
Op |
TransformCopy.transform(OpSequence opSequence,
List<Op> elts)
|
Op |
Transform.transform(OpSequence opSequence,
List<Op> elts)
|
Op |
TransformBase.transform(OpService opService,
Op subOp)
|
Op |
TransformWrapper.transform(OpService opService,
Op subOp)
|
Op |
TransformCopy.transform(OpService opService,
Op subOp)
|
Op |
Transform.transform(OpService opService,
Op subOp)
|
Op |
TransformBase.transform(OpSlice opSlice,
Op subOp)
|
Op |
TransformWrapper.transform(OpSlice opSlice,
Op subOp)
|
Op |
TransformCopy.transform(OpSlice opSlice,
Op subOp)
|
Op |
Transform.transform(OpSlice opSlice,
Op subOp)
|
Op |
TransformBase.transform(OpTable opTable)
|
Op |
TransformWrapper.transform(OpTable opTable)
|
Op |
TransformCopy.transform(OpTable opTable)
|
Op |
Transform.transform(OpTable opUnit)
|
Op |
TransformBase.transform(OpTopN opTop,
Op subOp)
|
Op |
TransformWrapper.transform(OpTopN opTop,
Op subOp)
|
Op |
TransformCopy.transform(OpTopN opTop,
Op subOp)
|
Op |
Transform.transform(OpTopN opTop,
Op subOp)
|
Op |
TransformBase.transform(OpTriple opTriple)
|
Op |
TransformWrapper.transform(OpTriple opTriple)
|
Op |
TransformCopy.transform(OpTriple opTriple)
|
Op |
Transform.transform(OpTriple opTriple)
|
Op |
TransformBase.transform(OpUnion opUnion,
Op left,
Op right)
|
Op |
TransformWrapper.transform(OpUnion opUnion,
Op left,
Op right)
|
Op |
TransformCopy.transform(OpUnion opUnion,
Op left,
Op right)
|
Op |
Transform.transform(OpUnion opUnion,
Op left,
Op right)
|
static Op |
Transformer.transform(Transform transform,
Op op)
Transform an algebra expression |
static Op |
Transformer.transform(Transform transform,
Op op,
OpVisitor beforeVisitor,
OpVisitor afterVisitor)
|
static Op |
Transformer.transformSkipService(Transform transform,
Op op)
Transform an algebra expression except skip (leave alone) any OpService nodes |
static Op |
Transformer.transformSkipService(Transform transform,
Op op,
OpVisitor beforeVisitor,
OpVisitor afterVisitor)
Transform an algebra expression except skip (leave alone) any OpService nodes |
static Op |
Algebra.unionDefaultGraph(Op op)
Transform an algebra expression so that default graph is union of the named graphs. |
Methods in com.hp.hpl.jena.sparql.algebra with parameters of type Op | |
---|---|
static Collection<Var> |
OpVars.allVars(Op op)
|
static void |
OpVars.allVars(Op op,
Set<Var> acc)
|
static OpDistinct |
OpLib.asDistinct(Op op)
|
static OpOrder |
OpLib.asOrder(Op op)
|
static OpProject |
OpLib.asProject(Op op)
|
static Query |
OpAsQuery.asQuery(Op op)
|
static OpReduced |
OpLib.asReduced(Op op)
|
static OpSlice |
OpLib.asSlice(Op op)
|
boolean |
Op.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
static QueryIterator |
Algebra.exec(Op op,
Dataset ds)
|
static QueryIterator |
Algebra.exec(Op op,
DatasetGraph ds)
|
static QueryIterator |
Algebra.exec(Op op,
com.hp.hpl.jena.graph.Graph graph)
|
static QueryIterator |
Algebra.exec(Op op,
com.hp.hpl.jena.rdf.model.Model model)
|
static QueryIterator |
Algebra.execRef(Op op,
Dataset ds)
|
static QueryIterator |
Algebra.execRef(Op op,
DatasetGraph dsg)
|
static QueryIterator |
Algebra.execRef(Op op,
com.hp.hpl.jena.graph.Graph graph)
|
static QueryIterator |
Algebra.execRef(Op op,
com.hp.hpl.jena.rdf.model.Model model)
|
static boolean |
OpLib.isDistinct(Op op)
|
static boolean |
OpLib.isOrder(Op op)
|
static boolean |
OpLib.isProject(Op op)
|
static boolean |
OpLib.isReduced(Op op)
|
static boolean |
OpLib.isSlice(Op op)
|
static Op |
Algebra.optimize(Op op)
Apply static transformations to a query to optimize it |
static Op |
Algebra.optimize(Op op,
Context context)
Apply static transformations to a query to optimize it |
static Set<Var> |
OpVars.patternVars(Op op)
|
static void |
OpVars.patternVars(Op op,
Set<Var> acc)
|
static Op |
AlgebraQuad.quadize(Op op)
|
static Op |
Algebra.toQuadForm(Op op)
Turn an algebra expression into quad form |
static Op |
TransformUnionQuery.transform(Op op)
|
Op |
TransformBase.transform(OpAssign opAssign,
Op subOp)
|
Op |
TransformWrapper.transform(OpAssign opAssign,
Op subOp)
|
Op |
TransformCopy.transform(OpAssign opAssign,
Op subOp)
|
Op |
Transform.transform(OpAssign opAssign,
Op subOp)
|
Op |
TransformBase.transform(OpConditional opCond,
Op left,
Op right)
|
Op |
TransformWrapper.transform(OpConditional opCond,
Op left,
Op right)
|
Op |
TransformCopy.transform(OpConditional opCond,
Op left,
Op right)
|
Op |
Transform.transform(OpConditional opCondition,
Op left,
Op right)
|
Op |
TransformBase.transform(OpDiff opDiff,
Op left,
Op right)
|
Op |
TransformWrapper.transform(OpDiff opDiff,
Op left,
Op right)
|
Op |
TransformCopy.transform(OpDiff opDiff,
Op left,
Op right)
|
Op |
Transform.transform(OpDiff opDiff,
Op left,
Op right)
|
Op |
TransformBase.transform(OpDistinct opDistinct,
Op subOp)
|
Op |
TransformWrapper.transform(OpDistinct opDistinct,
Op subOp)
|
Op |
TransformCopy.transform(OpDistinct opDistinct,
Op subOp)
|
Op |
Transform.transform(OpDistinct opDistinct,
Op subOp)
|
Op |
TransformBase.transform(OpExtend opExtend,
Op subOp)
|
Op |
TransformWrapper.transform(OpExtend opExtend,
Op subOp)
|
Op |
TransformCopy.transform(OpExtend opExtend,
Op subOp)
|
Op |
Transform.transform(OpExtend opExtend,
Op subOp)
|
Op |
TransformBase.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformWrapper.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformCopy.transform(OpFilter opFilter,
Op subOp)
|
Op |
Transform.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformUnionQuery.transform(OpGraph opGraph,
Op x)
|
Op |
TransformBase.transform(OpGraph opGraph,
Op subOp)
|
Op |
TransformWrapper.transform(OpGraph opGraph,
Op subOp)
|
Op |
TransformCopy.transform(OpGraph opGraph,
Op subOp)
|
Op |
Transform.transform(OpGraph opGraph,
Op subOp)
|
Op |
TransformBase.transform(OpGroup opGroup,
Op subOp)
|
Op |
TransformWrapper.transform(OpGroup opGroup,
Op subOp)
|
Op |
TransformCopy.transform(OpGroup opGroup,
Op subOp)
|
Op |
Transform.transform(OpGroup opGroup,
Op subOp)
|
Op |
TransformBase.transform(OpJoin opJoin,
Op left,
Op right)
|
Op |
TransformWrapper.transform(OpJoin opJoin,
Op left,
Op right)
|
Op |
TransformCopy.transform(OpJoin opJoin,
Op left,
Op right)
|
Op |
Transform.transform(OpJoin opJoin,
Op left,
Op right)
|
Op |
TransformBase.transform(OpLabel opLabel,
Op subOp)
|
Op |
TransformWrapper.transform(OpLabel opLabel,
Op subOp)
|
Op |
TransformCopy.transform(OpLabel opLabel,
Op subOp)
|
Op |
Transform.transform(OpLabel opLabel,
Op subOp)
|
Op |
TransformBase.transform(OpLeftJoin opLeftJoin,
Op left,
Op right)
|
Op |
TransformWrapper.transform(OpLeftJoin opLeftJoin,
Op left,
Op right)
|
Op |
TransformCopy.transform(OpLeftJoin opLeftJoin,
Op left,
Op right)
|
Op |
Transform.transform(OpLeftJoin opLeftJoin,
Op left,
Op right)
|
Op |
TransformBase.transform(OpList opList,
Op subOp)
|
Op |
TransformWrapper.transform(OpList opList,
Op subOp)
|
Op |
TransformCopy.transform(OpList opList,
Op subOp)
|
Op |
Transform.transform(OpList opList,
Op subOp)
|
Op |
TransformBase.transform(OpMinus opMinus,
Op left,
Op right)
|
Op |
TransformWrapper.transform(OpMinus opMinus,
Op left,
Op right)
|
Op |
TransformCopy.transform(OpMinus opMinus,
Op left,
Op right)
|
Op |
Transform.transform(OpMinus opMinus,
Op left,
Op right)
|
Op |
TransformBase.transform(OpOrder opOrder,
Op subOp)
|
Op |
TransformWrapper.transform(OpOrder opOrder,
Op subOp)
|
Op |
TransformCopy.transform(OpOrder opOrder,
Op subOp)
|
Op |
Transform.transform(OpOrder opOrder,
Op subOp)
|
Op |
TransformBase.transform(OpProcedure opProc,
Op subOp)
|
Op |
TransformWrapper.transform(OpProcedure opProc,
Op subOp)
|
Op |
TransformCopy.transform(OpProcedure opProc,
Op subOp)
|
Op |
Transform.transform(OpProcedure opProcedure,
Op subOp)
|
Op |
TransformBase.transform(OpProject opProject,
Op subOp)
|
Op |
TransformWrapper.transform(OpProject opProject,
Op subOp)
|
Op |
TransformCopy.transform(OpProject opProject,
Op subOp)
|
Op |
Transform.transform(OpProject opProject,
Op subOp)
|
Op |
TransformBase.transform(OpPropFunc opPropFunc,
Op subOp)
|
Op |
TransformWrapper.transform(OpPropFunc opPropFunc,
Op subOp)
|
Op |
TransformCopy.transform(OpPropFunc opPropFunc,
Op subOp)
|
Op |
Transform.transform(OpPropFunc opPropFunc,
Op subOp)
|
Op |
TransformBase.transform(OpReduced opReduced,
Op subOp)
|
Op |
TransformWrapper.transform(OpReduced opReduced,
Op subOp)
|
Op |
TransformCopy.transform(OpReduced opReduced,
Op subOp)
|
Op |
Transform.transform(OpReduced opReduced,
Op subOp)
|
Op |
TransformBase.transform(OpService opService,
Op subOp)
|
Op |
TransformWrapper.transform(OpService opService,
Op subOp)
|
Op |
TransformCopy.transform(OpService opService,
Op subOp)
|
Op |
Transform.transform(OpService opService,
Op subOp)
|
Op |
TransformBase.transform(OpSlice opSlice,
Op subOp)
|
Op |
TransformWrapper.transform(OpSlice opSlice,
Op subOp)
|
Op |
TransformCopy.transform(OpSlice opSlice,
Op subOp)
|
Op |
Transform.transform(OpSlice opSlice,
Op subOp)
|
Op |
TransformBase.transform(OpTopN opTop,
Op subOp)
|
Op |
TransformWrapper.transform(OpTopN opTop,
Op subOp)
|
Op |
TransformCopy.transform(OpTopN opTop,
Op subOp)
|
Op |
Transform.transform(OpTopN opTop,
Op subOp)
|
Op |
TransformBase.transform(OpUnion opUnion,
Op left,
Op right)
|
Op |
TransformWrapper.transform(OpUnion opUnion,
Op left,
Op right)
|
Op |
TransformCopy.transform(OpUnion opUnion,
Op left,
Op right)
|
Op |
Transform.transform(OpUnion opUnion,
Op left,
Op right)
|
static Op |
Transformer.transform(Transform transform,
Op op)
Transform an algebra expression |
static Op |
Transformer.transform(Transform transform,
Op op,
OpVisitor beforeVisitor,
OpVisitor afterVisitor)
|
static Op |
Transformer.transformSkipService(Transform transform,
Op op)
Transform an algebra expression except skip (leave alone) any OpService nodes |
static Op |
Transformer.transformSkipService(Transform transform,
Op op,
OpVisitor beforeVisitor,
OpVisitor afterVisitor)
Transform an algebra expression except skip (leave alone) any OpService nodes |
static Op |
Algebra.unionDefaultGraph(Op op)
Transform an algebra expression so that default graph is union of the named graphs. |
static com.hp.hpl.jena.shared.PrefixMapping |
OpPrefixesUsed.used(Op op,
com.hp.hpl.jena.shared.PrefixMapping pmap)
|
static void |
OpWalker.walk(Op op,
OpVisitor visitor)
|
static void |
OpWalker.walk(Op op,
OpVisitor visitor,
OpVisitor beforeVisitor,
OpVisitor afterVisitor)
|
static void |
OpWalker.walk(OpWalker.WalkerVisitor walkerVisitor,
Op op,
OpVisitor visitor)
|
static void |
OpWalker.walk(OpWalker.WalkerVisitor walkerVisitor,
Op op,
OpVisitor visitor,
OpVisitor beforeVisitor,
OpVisitor afterVisitor)
|
Method parameters in com.hp.hpl.jena.sparql.algebra with type arguments of type Op | |
---|---|
Op |
TransformBase.transform(OpDisjunction opDisjunction,
List<Op> elts)
|
Op |
TransformWrapper.transform(OpDisjunction opDisjunction,
List<Op> elts)
|
Op |
TransformCopy.transform(OpDisjunction opDisjunction,
List<Op> elts)
|
Op |
Transform.transform(OpDisjunction opDisjunction,
List<Op> elts)
|
Op |
TransformBase.transform(OpSequence opSequence,
List<Op> elts)
|
Op |
TransformWrapper.transform(OpSequence opSequence,
List<Op> elts)
|
Op |
TransformCopy.transform(OpSequence opSequence,
List<Op> elts)
|
Op |
Transform.transform(OpSequence opSequence,
List<Op> elts)
|
Uses of Op in com.hp.hpl.jena.sparql.algebra.op |
---|
Classes in com.hp.hpl.jena.sparql.algebra.op that implement Op | |
---|---|
class |
Op0
Super class for operators that do not combine other operators |
class |
Op1
Super class for operators that operate on a single sub-operation (i.e. |
class |
Op2
Super class for operators that combine two sub-operators |
class |
OpAssign
|
class |
OpBase
|
class |
OpBGP
|
class |
OpConditional
Conditional execution - works with streamed execution and is known to safe to evaluate that way (no issues from nested optionals). |
class |
OpDatasetNames
|
class |
OpDiff
|
class |
OpDisjunction
N-way disjunction. |
class |
OpDistinct
|
class |
OpExt
Marker for extension points Execution will be per-engine specific |
class |
OpExtend
This is the operation in stadard SPARQL 1.1 OpAssign is specifically in support of LET. |
class |
OpFetch
|
class |
OpFilter
|
class |
OpGraph
|
class |
OpGroup
|
class |
OpJoin
|
class |
OpLabel
Do-nothing class that means that tags/labels/comments can be left in the algebra tree. |
class |
OpLeftJoin
|
class |
OpList
|
class |
OpMinus
|
class |
OpModifier
Mark solution modifiers |
class |
OpN
|
class |
OpNull
|
class |
OpOrder
|
class |
OpPath
|
class |
OpProcedure
General procedure in algebra evaluation (a stored procedure facility) Syntax (ARQ extension): CALL |
class |
OpProject
|
class |
OpPropFunc
Property functions (or any OpBGP replacement) Execution will be per-engine specific |
class |
OpQuad
Algebra operation for a single quad. |
class |
OpQuadPattern
|
class |
OpReduced
|
class |
OpSequence
A "sequence" is a join-like operation where it is know that the the output of one step can be fed into the input of the next (that is, no scoping issues arise). |
class |
OpService
|
class |
OpSlice
|
class |
OpTable
|
class |
OpTopN
Top N from a stream of items - for small N, better than ORDER BY + LIMIT N |
class |
OpTriple
Algebra operation for a single triple. |
class |
OpUnion
|
Methods in com.hp.hpl.jena.sparql.algebra.op that return Op | |
---|---|
Op |
OpTriple.apply(Transform transform)
|
Op |
OpBGP.apply(Transform transform)
|
Op |
OpTable.apply(Transform transform)
|
Op |
OpQuad.apply(Transform transform)
|
Op |
OpQuadPattern.apply(Transform transform)
|
Op |
OpDatasetNames.apply(Transform transform)
|
Op |
OpPath.apply(Transform transform)
|
Op |
OpNull.apply(Transform transform)
|
abstract Op |
Op0.apply(Transform transform)
|
abstract Op |
OpN.apply(Transform transform,
List<Op> elts)
|
Op |
OpSequence.apply(Transform transform,
List<Op> elts)
|
Op |
OpDisjunction.apply(Transform transform,
List<Op> elts)
|
Op |
OpTopN.apply(Transform transform,
Op subOp)
|
Op |
OpGroup.apply(Transform transform,
Op subOp)
|
Op |
OpGraph.apply(Transform transform,
Op op)
|
Op |
OpService.apply(Transform transform,
Op subOp)
|
Op |
OpProcedure.apply(Transform transform,
Op subOp)
|
Op |
OpReduced.apply(Transform transform,
Op subOp)
|
Op |
OpList.apply(Transform transform,
Op subOp)
|
Op |
OpOrder.apply(Transform transform,
Op subOp)
|
Op |
OpAssign.apply(Transform transform,
Op subOp)
|
Op |
OpSlice.apply(Transform transform,
Op subOp)
|
Op |
OpPropFunc.apply(Transform transform,
Op subOp)
|
Op |
OpLabel.apply(Transform transform,
Op subOp)
|
Op |
OpProject.apply(Transform transform,
Op subOp)
|
Op |
OpDistinct.apply(Transform transform,
Op subOp)
|
Op |
OpFilter.apply(Transform transform,
Op subOp)
|
abstract Op |
Op1.apply(Transform transform,
Op subOp)
|
Op |
OpExtend.apply(Transform transform,
Op subOp)
|
Op |
OpConditional.apply(Transform transform,
Op left,
Op right)
|
Op |
OpDiff.apply(Transform transform,
Op left,
Op right)
|
Op |
OpJoin.apply(Transform transform,
Op left,
Op right)
|
Op |
OpUnion.apply(Transform transform,
Op left,
Op right)
|
Op |
OpMinus.apply(Transform transform,
Op left,
Op right)
|
Op |
OpLeftJoin.apply(Transform transform,
Op left,
Op right)
|
abstract Op |
Op2.apply(Transform transform,
Op left,
Op right)
|
static Op |
OpAssign.assign(Op op,
Var var,
Expr expr)
|
static Op |
OpAssign.assign(Op op,
VarExprList exprs)
|
Op |
OpTriple.copy()
|
Op |
OpBGP.copy()
|
Op |
OpTable.copy()
|
Op |
OpQuad.copy()
|
Op |
OpQuadPattern.copy()
|
Op |
OpDatasetNames.copy()
|
Op |
OpPath.copy()
|
Op |
OpNull.copy()
|
Op |
OpSlice.copy()
|
abstract Op |
Op0.copy()
|
abstract Op |
OpN.copy(List<Op> elts)
|
Op |
OpSequence.copy(List<Op> elts)
|
Op |
OpDisjunction.copy(List<Op> elts)
|
Op |
OpTopN.copy(Op subOp)
|
Op |
OpGroup.copy(Op subOp)
|
Op |
OpGraph.copy(Op newOp)
|
Op |
OpService.copy(Op newOp)
|
Op |
OpProcedure.copy(Op subOp)
|
Op |
OpReduced.copy(Op subOp)
|
Op |
OpList.copy(Op subOp)
|
Op |
OpOrder.copy(Op subOp)
|
Op |
OpAssign.copy(Op subOp)
|
Op |
OpSlice.copy(Op subOp)
|
Op |
OpPropFunc.copy(Op op)
|
Op |
OpLabel.copy(Op subOp)
|
Op |
OpProject.copy(Op subOp)
|
Op |
OpDistinct.copy(Op subOp)
|
Op |
OpFilter.copy(Op subOp)
|
abstract Op |
Op1.copy(Op subOp)
|
Op |
OpExtend.copy(Op subOp)
|
Op |
OpConditional.copy(Op newLeft,
Op newRight)
|
Op |
OpDiff.copy(Op newLeft,
Op newRight)
|
Op |
OpJoin.copy(Op newLeft,
Op newRight)
|
Op |
OpUnion.copy(Op newLeft,
Op newRight)
|
Op |
OpMinus.copy(Op newLeft,
Op newRight)
|
Op |
OpLeftJoin.copy(Op newLeft,
Op newRight)
|
abstract Op |
Op2.copy(Op left,
Op right)
|
static Op |
OpLabel.create(Object label,
Op op)
|
static Op |
OpReduced.create(Op op)
|
static Op |
OpDistinct.create(Op op)
|
static Op |
OpSequence.create(Op left,
Op right)
|
static Op |
OpDiff.create(Op left,
Op right)
|
static Op |
OpJoin.create(Op left,
Op right)
|
static Op |
OpUnion.create(Op left,
Op right)
|
static Op |
OpMinus.create(Op left,
Op right)
|
static Op |
OpDisjunction.create(Op left,
Op right)
|
static Op |
OpLeftJoin.create(Op left,
Op right,
Expr expr)
|
static Op |
OpLeftJoin.create(Op left,
Op right,
ExprList exprs)
|
Op |
OpFetch.effectiveOp()
|
abstract Op |
OpExt.effectiveOp()
Return an op that will used by query processing algorithms such as optimization. |
static Op |
OpExtend.extend(Op op,
Var var,
Expr expr)
|
static Op |
OpExtend.extend(Op op,
VarExprList exprs)
|
static Op |
OpFilter.filter(ExprList exprs,
Op op)
|
static Op |
OpFilter.filter(Expr expr,
Op op)
|
Op |
OpN.get(int idx)
|
Op |
Op2.getLeft()
|
Op |
Op2.getRight()
|
Op |
Op1.getSubOp()
|
static Op |
OpModifier.removeModifiers(Op op)
|
Methods in com.hp.hpl.jena.sparql.algebra.op that return types with arguments of type Op | |
---|---|
List<Op> |
OpN.getElements()
|
Iterator<Op> |
OpN.iterator()
|
Methods in com.hp.hpl.jena.sparql.algebra.op with parameters of type Op | |
---|---|
void |
OpN.add(Op op)
|
Op |
OpTopN.apply(Transform transform,
Op subOp)
|
Op |
OpGroup.apply(Transform transform,
Op subOp)
|
Op |
OpGraph.apply(Transform transform,
Op op)
|
Op |
OpService.apply(Transform transform,
Op subOp)
|
Op |
OpProcedure.apply(Transform transform,
Op subOp)
|
Op |
OpReduced.apply(Transform transform,
Op subOp)
|
Op |
OpList.apply(Transform transform,
Op subOp)
|
Op |
OpOrder.apply(Transform transform,
Op subOp)
|
Op |
OpAssign.apply(Transform transform,
Op subOp)
|
Op |
OpSlice.apply(Transform transform,
Op subOp)
|
Op |
OpPropFunc.apply(Transform transform,
Op subOp)
|
Op |
OpLabel.apply(Transform transform,
Op subOp)
|
Op |
OpProject.apply(Transform transform,
Op subOp)
|
Op |
OpDistinct.apply(Transform transform,
Op subOp)
|
Op |
OpFilter.apply(Transform transform,
Op subOp)
|
abstract Op |
Op1.apply(Transform transform,
Op subOp)
|
Op |
OpExtend.apply(Transform transform,
Op subOp)
|
Op |
OpConditional.apply(Transform transform,
Op left,
Op right)
|
Op |
OpDiff.apply(Transform transform,
Op left,
Op right)
|
Op |
OpJoin.apply(Transform transform,
Op left,
Op right)
|
Op |
OpUnion.apply(Transform transform,
Op left,
Op right)
|
Op |
OpMinus.apply(Transform transform,
Op left,
Op right)
|
Op |
OpLeftJoin.apply(Transform transform,
Op left,
Op right)
|
abstract Op |
Op2.apply(Transform transform,
Op left,
Op right)
|
static Op |
OpAssign.assign(Op op,
Var var,
Expr expr)
|
static Op |
OpAssign.assign(Op op,
VarExprList exprs)
|
static OpAssign |
OpAssign.assignDirect(Op op,
VarExprList exprs)
Make a OpAssign - guaranteed to return an OpAssign |
Op |
OpTopN.copy(Op subOp)
|
Op |
OpGroup.copy(Op subOp)
|
Op |
OpGraph.copy(Op newOp)
|
Op |
OpService.copy(Op newOp)
|
Op |
OpProcedure.copy(Op subOp)
|
Op |
OpReduced.copy(Op subOp)
|
Op |
OpList.copy(Op subOp)
|
Op |
OpOrder.copy(Op subOp)
|
Op |
OpAssign.copy(Op subOp)
|
Op |
OpSlice.copy(Op subOp)
|
Op |
OpPropFunc.copy(Op op)
|
Op |
OpLabel.copy(Op subOp)
|
Op |
OpProject.copy(Op subOp)
|
Op |
OpDistinct.copy(Op subOp)
|
Op |
OpFilter.copy(Op subOp)
|
abstract Op |
Op1.copy(Op subOp)
|
Op |
OpExtend.copy(Op subOp)
|
Op |
OpConditional.copy(Op newLeft,
Op newRight)
|
Op |
OpDiff.copy(Op newLeft,
Op newRight)
|
Op |
OpJoin.copy(Op newLeft,
Op newRight)
|
Op |
OpUnion.copy(Op newLeft,
Op newRight)
|
Op |
OpMinus.copy(Op newLeft,
Op newRight)
|
Op |
OpLeftJoin.copy(Op newLeft,
Op newRight)
|
abstract Op |
Op2.copy(Op left,
Op right)
|
static Op |
OpLabel.create(Object label,
Op op)
|
static Op |
OpReduced.create(Op op)
|
static Op |
OpDistinct.create(Op op)
|
static Op |
OpSequence.create(Op left,
Op right)
|
static Op |
OpDiff.create(Op left,
Op right)
|
static Op |
OpJoin.create(Op left,
Op right)
|
static Op |
OpUnion.create(Op left,
Op right)
|
static Op |
OpMinus.create(Op left,
Op right)
|
static Op |
OpDisjunction.create(Op left,
Op right)
|
static Op |
OpLeftJoin.create(Op left,
Op right,
Expr expr)
|
static Op |
OpLeftJoin.create(Op left,
Op right,
ExprList exprs)
|
boolean |
OpFetch.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpTriple.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpTopN.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpSequence.equalTo(Op op,
NodeIsomorphismMap labelMap)
|
boolean |
OpConditional.equalTo(Op op2,
NodeIsomorphismMap labelMap)
|
boolean |
OpBGP.equalTo(Op op2,
NodeIsomorphismMap labelMap)
|
boolean |
OpGroup.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpDiff.equalTo(Op op2,
NodeIsomorphismMap labelMap)
|
boolean |
OpGraph.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpService.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpTable.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpProcedure.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpQuad.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
abstract boolean |
OpBase.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpJoin.equalTo(Op op2,
NodeIsomorphismMap labelMap)
|
boolean |
OpQuadPattern.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpDatasetNames.equalTo(Op op2,
NodeIsomorphismMap labelMap)
|
boolean |
OpUnion.equalTo(Op op2,
NodeIsomorphismMap labelMap)
|
boolean |
OpPath.equalTo(Op other,
NodeIsomorphismMap isoMap)
|
boolean |
OpReduced.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpList.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpNull.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpOrder.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpAssign.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpMinus.equalTo(Op op2,
NodeIsomorphismMap labelMap)
|
boolean |
OpLeftJoin.equalTo(Op op2,
NodeIsomorphismMap labelMap)
|
boolean |
OpSlice.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpPropFunc.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpLabel.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpProject.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpDisjunction.equalTo(Op op,
NodeIsomorphismMap labelMap)
|
boolean |
OpDistinct.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpFilter.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
boolean |
OpExtend.equalTo(Op other,
NodeIsomorphismMap labelMap)
|
static Op |
OpExtend.extend(Op op,
Var var,
Expr expr)
|
static Op |
OpExtend.extend(Op op,
VarExprList exprs)
|
static OpExtend |
OpExtend.extendDirect(Op op,
VarExprList exprs)
Make a OpExtend - guaranteed to return an OpExtend |
static Op |
OpFilter.filter(ExprList exprs,
Op op)
|
static Op |
OpFilter.filter(Expr expr,
Op op)
|
static OpFilter |
OpFilter.filter(Op op)
|
static OpFilter |
OpFilter.filterDirect(ExprList exprs,
Op op)
Make a OpFilter - guarantteed to return an OpFilter |
static boolean |
OpBGP.isBGP(Op op)
|
static boolean |
OpJoin.isJoinIdentify(Op op)
|
static boolean |
OpQuadPattern.isQuadPattern(Op op)
|
static Op |
OpModifier.removeModifiers(Op op)
|
void |
Op2.setLeft(Op op)
|
void |
Op2.setRight(Op op)
|
Method parameters in com.hp.hpl.jena.sparql.algebra.op with type arguments of type Op | |
---|---|
abstract Op |
OpN.apply(Transform transform,
List<Op> elts)
|
Op |
OpSequence.apply(Transform transform,
List<Op> elts)
|
Op |
OpDisjunction.apply(Transform transform,
List<Op> elts)
|
abstract Op |
OpN.copy(List<Op> elts)
|
Op |
OpSequence.copy(List<Op> elts)
|
Op |
OpDisjunction.copy(List<Op> elts)
|
Constructors in com.hp.hpl.jena.sparql.algebra.op with parameters of type Op | |
---|---|
Op1(Op subOp)
|
|
Op2(Op left,
Op right)
|
|
OpConditional(Op left,
Op right)
|
|
OpDistinct(Op subOp)
|
|
OpGraph(com.hp.hpl.jena.graph.Node node,
Op pattern)
|
|
OpGroup(Op subOp,
VarExprList groupVars,
List<ExprAggregator> aggregators)
|
|
OpList(Op subOp)
|
|
OpModifier(Op subOp)
|
|
OpOrder(Op subOp,
List<SortCondition> conditions)
|
|
OpProcedure(com.hp.hpl.jena.graph.Node procId,
ExprList args,
Op op)
|
|
OpProcedure(String iri,
ExprList args,
Op op)
|
|
OpProject(Op subOp,
List<Var> vars)
|
|
OpPropFunc(com.hp.hpl.jena.graph.Node uri,
PropFuncArg args1,
PropFuncArg args2,
Op op)
|
|
OpService(com.hp.hpl.jena.graph.Node serviceNode,
Op subOp,
boolean silent)
|
|
OpService(com.hp.hpl.jena.graph.Node serviceNode,
Op subOp,
ElementService elt,
boolean silent)
|
|
OpSlice(Op subOp,
long start,
long length)
|
|
OpTopN(Op subOp,
int N,
List<SortCondition> conditions)
|
|
OpUnion(Op left,
Op right)
|
Uses of Op in com.hp.hpl.jena.sparql.algebra.optimize |
---|
Methods in com.hp.hpl.jena.sparql.algebra.optimize that return Op | |
---|---|
static Op |
Optimize.apply(String label,
Transform transform,
Op op)
|
static Op |
Optimize.apply(Transform transform,
Op op)
|
static Op |
TransformPattern2Join.expand(BasicPattern bgp)
|
static Op |
TransformPattern2Join.expand(QuadPattern quads)
|
static Op |
TransformFilterDisjunction.expandDisjunction(Expr expr,
Op subOp)
|
static Op |
Optimize.optimize(Op op,
Context context)
|
static Op |
Optimize.optimize(Op op,
ExecutionContext execCxt)
|
static Op |
TransformFilterEquality.processFilter(Expr e,
Op subOp)
Return null for "no change" |
static Op |
TransformFilterEquality.processFilterOrOpFilter(Expr e,
Op subOp)
Return an optimized filter for equality expressions |
Op |
Rewrite.rewrite(Op op)
|
Op |
Optimize.rewrite(Op op)
|
static Op |
TransformFilterPlacement.transform(ExprList exprs,
BasicPattern bgp)
|
static Op |
TransformFilterPlacement.transform(ExprList exprs,
com.hp.hpl.jena.graph.Node graphNode,
BasicPattern bgp)
|
static Op |
TransformScopeRename.transform(Op op)
|
Op |
TransformPropertyFunction.transform(OpBGP opBGP)
|
Op |
TransformPattern2Join.transform(OpBGP opBGP)
|
Op |
TransformDistinctToReduced.transform(OpDistinct opDistinct,
Op subOp)
|
Op |
TransformFilterPlacement.transform(OpFilter opFilter,
Op x)
|
Op |
TransformExpandOneOf.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformFilterDisjunction.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformFilterConjunction.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformFilterEquality.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformApplyInsideExprFunctionOp.transform(OpFilter opFilter,
Op x)
|
Op |
TransformSimplify.transform(OpJoin opJoin,
Op left,
Op right)
|
Op |
TransformJoinStrategy.transform(OpJoin opJoin,
Op left,
Op right)
|
Op |
TransformRemoveLabels.transform(OpLabel opLabel,
Op subOp)
|
Op |
TransformJoinStrategy.transform(OpLeftJoin opLeftJoin,
Op opLeft,
Op opRight)
|
Op |
TransformExpandOneOf.transform(OpLeftJoin opLeftJoin,
Op opLeft,
Op opRight)
|
Op |
TransformPathFlattern.transform(OpPath opPath)
|
Op |
TransformPattern2Join.transform(OpQuadPattern quadPattern)
|
Op |
TransformSimplify.transform(OpSequence opSequence,
List<Op> elts)
|
Op |
TransformTopN.transform(OpSlice opSlice,
Op subOp)
|
Op |
TransformPropertyFunction.transform(OpTriple opTriple)
|
Methods in com.hp.hpl.jena.sparql.algebra.optimize with parameters of type Op | |
---|---|
static Op |
Optimize.apply(String label,
Transform transform,
Op op)
|
static Op |
Optimize.apply(Transform transform,
Op op)
|
static Op |
TransformFilterDisjunction.expandDisjunction(Expr expr,
Op subOp)
|
static Op |
Optimize.optimize(Op op,
Context context)
|
static Op |
Optimize.optimize(Op op,
ExecutionContext execCxt)
|
static Op |
TransformFilterEquality.processFilter(Expr e,
Op subOp)
Return null for "no change" |
static Op |
TransformFilterEquality.processFilterOrOpFilter(Expr e,
Op subOp)
Return an optimized filter for equality expressions |
Op |
Rewrite.rewrite(Op op)
|
Op |
Optimize.rewrite(Op op)
|
Expr |
ExprTransformApplyTransform.transform(ExprFunctionOp funcOp,
ExprList args,
Op opArg)
|
static Op |
TransformScopeRename.transform(Op op)
|
Op |
TransformDistinctToReduced.transform(OpDistinct opDistinct,
Op subOp)
|
Op |
TransformFilterPlacement.transform(OpFilter opFilter,
Op x)
|
Op |
TransformExpandOneOf.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformFilterDisjunction.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformFilterConjunction.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformFilterEquality.transform(OpFilter opFilter,
Op subOp)
|
Op |
TransformApplyInsideExprFunctionOp.transform(OpFilter opFilter,
Op x)
|
Op |
TransformSimplify.transform(OpJoin opJoin,
Op left,
Op right)
|
Op |
TransformJoinStrategy.transform(OpJoin opJoin,
Op left,
Op right)
|
Op |
TransformRemoveLabels.transform(OpLabel opLabel,
Op subOp)
|
Op |
TransformJoinStrategy.transform(OpLeftJoin opLeftJoin,
Op opLeft,
Op opRight)
|
Op |
TransformExpandOneOf.transform(OpLeftJoin opLeftJoin,
Op opLeft,
Op opRight)
|
Op |
TransformTopN.transform(OpSlice opSlice,
Op subOp)
|
Method parameters in com.hp.hpl.jena.sparql.algebra.optimize with type arguments of type Op | |
---|---|
Op |
TransformSimplify.transform(OpSequence opSequence,
List<Op> elts)
|
Uses of Op in com.hp.hpl.jena.sparql.core |
---|
Methods in com.hp.hpl.jena.sparql.core that return Op | |
---|---|
static Op |
Substitute.substitute(Op op,
Binding binding)
|
static Op |
Substitute.substitute(Op op,
Var var,
com.hp.hpl.jena.graph.Node node)
|
Methods in com.hp.hpl.jena.sparql.core with parameters of type Op | |
---|---|
static Op |
Substitute.substitute(Op op,
Binding binding)
|
static Op |
Substitute.substitute(Op op,
Var var,
com.hp.hpl.jena.graph.Node node)
|
Uses of Op in com.hp.hpl.jena.sparql.engine |
---|
Methods in com.hp.hpl.jena.sparql.engine that return Op | |
---|---|
Op |
QueryEngineBase.getOp()
Algebra expression (including any optimization) |
Op |
PlanBase.getOp()
|
Op |
Plan.getOp()
|
static Op |
Rename.renameNode(Op op,
com.hp.hpl.jena.graph.Node oldName,
com.hp.hpl.jena.graph.Node newName)
Rename one node to another |
static Op |
Rename.renameVar(Op op,
Var oldName,
Var newName)
Rename one variable to another |
static Op |
Rename.renameVars(Op op,
Collection<Var> constants)
Rename all variables in a pattern, EXCEPT for those named as constant |
static Op |
Rename.reverseVarRename(Op op,
boolean repeatedly)
Undo the effect of the rename operation, once or repeatedly. |
Methods in com.hp.hpl.jena.sparql.engine with parameters of type Op | |
---|---|
boolean |
QueryEngineFactory.accept(Op op,
DatasetGraph dataset,
Context context)
|
Plan |
QueryEngineFactory.create(Op op,
DatasetGraph dataset,
Binding inputBinding,
Context context)
|
QueryIterator |
OpEval.evaluate(Op op,
DatasetGraph dsg,
Binding binding,
Context context)
|
QueryIterator |
QueryEngineBase.evaluate(Op op,
DatasetGraph dsg,
Binding binding,
Context context)
|
QueryEngineFactory |
QueryEngineRegistry.find(Op op,
DatasetGraph dataset,
Context context)
Locate a suitable factory for this algebra expression and dataset |
static QueryEngineFactory |
QueryEngineRegistry.findFactory(Op op,
DatasetGraph dataset,
Context context)
Locate a suitable factory for this algebra expression and dataset from the default registry |
static Op |
Rename.renameNode(Op op,
com.hp.hpl.jena.graph.Node oldName,
com.hp.hpl.jena.graph.Node newName)
Rename one node to another |
static Op |
Rename.renameVar(Op op,
Var oldName,
Var newName)
Rename one variable to another |
static Op |
Rename.renameVars(Op op,
Collection<Var> constants)
Rename all variables in a pattern, EXCEPT for those named as constant |
static Op |
Rename.reverseVarRename(Op op,
boolean repeatedly)
Undo the effect of the rename operation, once or repeatedly. |
Constructors in com.hp.hpl.jena.sparql.engine with parameters of type Op | |
---|---|
PlanOp(Op op,
Closeable closeable,
QueryIterator qIter)
|
|
PlanOp(String label,
Closeable closeable,
Op op,
QueryIterator qIter)
|
Uses of Op in com.hp.hpl.jena.sparql.engine.main |
---|
Methods in com.hp.hpl.jena.sparql.engine.main that return Op | |
---|---|
static Op |
JoinClassifier.effectiveOp(Op op)
|
static Op |
QC.substitute(Op op,
Binding binding)
|
Methods in com.hp.hpl.jena.sparql.engine.main with parameters of type Op | |
---|---|
static Op |
JoinClassifier.effectiveOp(Op op)
|
QueryIterator |
QueryEngineMain.eval(Op op,
DatasetGraph dsg,
Binding input,
Context context)
|
static QueryIterator |
QC.execute(Op op,
Binding binding,
ExecutionContext execCxt)
|
static QueryIterator |
QC.execute(Op op,
QueryIterator qIter,
ExecutionContext execCxt)
|
QueryIterator |
OpExecutor.executeOp(Op op,
QueryIterator input)
|
static Set<Var> |
VarFinder.filter(Op op)
|
static Set<Var> |
VarFinder.fixed(Op op)
|
static boolean |
JoinClassifier.isLinear(Op left,
Op right)
|
static boolean |
LeftJoinClassifier.isLinear(Op left,
Op right)
|
static Set<Var> |
VarFinder.optDefined(Op op)
|
static Op |
QC.substitute(Op op,
Binding binding)
|
Constructors in com.hp.hpl.jena.sparql.engine.main with parameters of type Op | |
---|---|
QueryEngineMain(Op op,
DatasetGraph dataset,
Binding input,
Context context)
|
|
QueryEngineMainQuad(Op op,
DatasetGraph dataset,
Binding input,
Context context)
|
|
VarFinder(Op op)
|
Uses of Op in com.hp.hpl.jena.sparql.engine.main.iterator |
---|
Constructors in com.hp.hpl.jena.sparql.engine.main.iterator with parameters of type Op | |
---|---|
QueryIterOptionalIndex(QueryIterator input,
Op op,
ExecutionContext context)
|
Constructor parameters in com.hp.hpl.jena.sparql.engine.main.iterator with type arguments of type Op | |
---|---|
QueryIterUnion(QueryIterator input,
List<Op> subOps,
ExecutionContext context)
|
Uses of Op in com.hp.hpl.jena.sparql.engine.ref |
---|
Methods in com.hp.hpl.jena.sparql.engine.ref with parameters of type Op | |
---|---|
static Table |
Eval.eval(Evaluator evaluator,
Op op)
|
QueryIterator |
QueryEngineRef.eval(Op op,
DatasetGraph dsg,
Binding binding,
Context context)
|
Constructors in com.hp.hpl.jena.sparql.engine.ref with parameters of type Op | |
---|---|
QueryEngineRef(Op op,
DatasetGraph dataset,
Binding input,
Context context)
|
|
QueryEngineRef(Op op,
DatasetGraph dataset,
Context context)
|
|
QueryEngineRefQuad(Op op,
DatasetGraph dataset,
Binding input,
Context context)
|
|
QueryEngineRefQuad(Op op,
DatasetGraph dataset,
Context context)
|
Uses of Op in com.hp.hpl.jena.sparql.expr |
---|
Methods in com.hp.hpl.jena.sparql.expr that return Op | |
---|---|
Op |
ExprNode.getGraphPattern()
|
Op |
ExprFunctionOp.getGraphPattern()
|
Methods in com.hp.hpl.jena.sparql.expr with parameters of type Op | |
---|---|
Expr |
ExprFunctionOp.apply(ExprTransform transform,
ExprList args,
Op x)
|
ExprFunctionOp |
E_Scalar.copy(ExprList args,
Op x)
|
ExprFunctionOp |
E_NotExists.copy(ExprList args,
Op x)
|
abstract ExprFunctionOp |
ExprFunctionOp.copy(ExprList args,
Op x)
|
ExprFunctionOp |
E_Exists.copy(ExprList args,
Op x)
|
Expr |
ExprTransformCopy.transform(ExprFunctionOp funcOp,
ExprList args,
Op opArg)
|
Expr |
ExprTransform.transform(ExprFunctionOp funcOp,
ExprList args,
Op opArg)
|
Expr |
ExprTransformBase.transform(ExprFunctionOp funcOp,
ExprList args,
Op opArg)
|
Constructors in com.hp.hpl.jena.sparql.expr with parameters of type Op | |
---|---|
E_Exists(Element el,
Op op)
|
|
E_Exists(Op op)
|
|
E_NotExists(Element el,
Op op)
|
|
E_NotExists(Op op)
|
Uses of Op in com.hp.hpl.jena.sparql.graph |
---|
Methods in com.hp.hpl.jena.sparql.graph that return Op | |
---|---|
static Op |
NodeTransformLib.transform(NodeTransform nodeTransform,
Op op)
Do a node->node conversion of an Op - return original BGP for "no change" |
Methods in com.hp.hpl.jena.sparql.graph with parameters of type Op | |
---|---|
static Op |
NodeTransformLib.transform(NodeTransform nodeTransform,
Op op)
Do a node->node conversion of an Op - return original BGP for "no change" |
Uses of Op in com.hp.hpl.jena.sparql.mgt |
---|
Methods in com.hp.hpl.jena.sparql.mgt with parameters of type Op | |
---|---|
static void |
Explain.explain(Op op,
Context context)
|
static void |
Explain.explain(String message,
Op op,
Context context)
|
void |
QueryEngineInfo.setLastOp(Op op)
|
Uses of Op in com.hp.hpl.jena.sparql.path |
---|
Methods in com.hp.hpl.jena.sparql.path that return Op | |
---|---|
static Op |
PathLib.pathToTriples(PathBlock pattern)
Convert any paths of exactly one predicate to a triple pattern |
Uses of Op in com.hp.hpl.jena.sparql.sse |
---|
Methods in com.hp.hpl.jena.sparql.sse that return Op | |
---|---|
static Op |
SSE.parseOp(String s)
Parse a string and obtain a SPARQL algebra op |
static Op |
SSE.parseOp(String s,
com.hp.hpl.jena.shared.PrefixMapping pmap)
Parse a string and obtain a SPARQL algebra op, given a prefix mapping |
static Op |
SSE.readOp(String filename)
Read in a file, parse, and obtain a SPARQL algebra op |
Methods in com.hp.hpl.jena.sparql.sse with parameters of type Op | |
---|---|
static void |
WriterSSE.out(IndentedWriter out,
Op op,
Prologue prologue)
|
static void |
SSE.write(IndentedWriter out,
Op op)
|
static void |
SSE.write(Op op)
|
static void |
SSE.write(OutputStream out,
Op op)
|
Uses of Op in com.hp.hpl.jena.sparql.sse.builders |
---|
Methods in com.hp.hpl.jena.sparql.sse.builders that return Op | |
---|---|
static Op |
BuilderOp.build(Item item)
|
Op |
BuilderOp.Build.make(ItemList list)
|
Uses of Op in com.hp.hpl.jena.sparql.sse.writers |
---|
Methods in com.hp.hpl.jena.sparql.sse.writers with parameters of type Op | |
---|---|
static void |
WriterOp.out(OutputStream out,
Op op,
SerializationContext sCxt)
|
static void |
WriterOp.output(IndentedWriter iWriter,
Op op)
|
static void |
WriterOp.output(IndentedWriter iWriter,
Op op,
com.hp.hpl.jena.shared.PrefixMapping pMap)
|
static void |
WriterOp.output(IndentedWriter iWriter,
Op op,
Prologue prologue)
|
static void |
WriterOp.output(IndentedWriter iWriter,
Op op,
SerializationContext sCxt)
|
static void |
WriterOp.output(Op op)
|
static void |
WriterOp.output(Op op,
com.hp.hpl.jena.shared.PrefixMapping pMap)
|
static void |
WriterOp.output(Op op,
Prologue prologue)
|
static void |
WriterOp.output(OutputStream out,
Op op)
|
static void |
WriterOp.output(OutputStream out,
Op op,
com.hp.hpl.jena.shared.PrefixMapping pMap)
|
static void |
WriterOp.output(OutputStream out,
Op op,
Prologue prologue)
|
Uses of Op in com.hp.hpl.jena.sparql.util |
---|
Methods in com.hp.hpl.jena.sparql.util with parameters of type Op | |
---|---|
static void |
QueryExecUtils.execute(Op op,
DatasetGraph dsg)
|
static void |
QueryExecUtils.execute(Op op,
DatasetGraph dsg,
ResultsFormat outputFormat)
|
static void |
QueryExecUtils.executeAlgebra(Op op,
DatasetGraph dsg)
Deprecated. Use execute(Op, DatasetGraph) |
static void |
QueryExecUtils.executeAlgebra(Op op,
DatasetGraph dsg,
ResultsFormat outputFormat)
Deprecated. Use execute(Op, DatasetGraph) |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |