Uses of Class
org.eclipse.rdf4j.sparqlbuilder.constraint.Expression

Packages that use Expression

Package	Description
org.eclipse.rdf4j.sparqlbuilder.constraint
org.eclipse.rdf4j.sparqlbuilder.core	Core classes and interfaces for the SPARQLBuilder.
org.eclipse.rdf4j.sparqlbuilder.core.query
org.eclipse.rdf4j.sparqlbuilder.graphpattern

Uses of Expression in org.eclipse.rdf4j.sparqlbuilder.constraint

Classes in org.eclipse.rdf4j.sparqlbuilder.constraint with type parameters of type Expression

Modifier and Type	Class	Description
class	Expression<T extends Expression<T>>	A SPARQL expression.

Subclasses of Expression in org.eclipse.rdf4j.sparqlbuilder.constraint

Modifier and Type	Class	Description
class	Aggregate	A SPARQL aggregate expression.
(package private) class	BinaryOperation	Represents a SPARQL operation that takes exactly 2 arguments
(package private) class	ConnectiveOperation	Represents a SPARQL connective operation, which takes an arbitrary number of arguments
class	CustomFunction
(package private) class	Function	A SPARQL Function.
class	In
class	NotIn
(package private) class	Operation<T extends Operation<T>>	A SPARQL Operation.
(package private) class	UnaryOperation	Represents a SPARQL operation that takes exactly 1 argument

Methods in org.eclipse.rdf4j.sparqlbuilder.constraint that return Expression

Modifier and Type	Method	Description
static Expression<?>	Expressions.abs(Number operand)	ABS(operand)
static Expression<?>	Expressions.abs(Operand operand)	ABS(operand)
static Expression<?>	Expressions.add(Operand... operands)	operand1 + operand2 + ...
static Expression<?>	Expressions.and(Operand... operands)	operand1 invalid input: '&'invalid input: '&' operand2 invalid input: '&'invalid input: '&' ...
static Expression<?>	Expressions.bnode()	BNODE()
static Expression<?>	Expressions.bnode(String literal)	BNODE(operand)
static Expression<?>	Expressions.bnode(RdfLiteral<?> literal)	BNODE(operand)
static Expression<?>	Expressions.bound(Variable var)	BOUND(operand)
static Expression<?>	Expressions.ceil(Operand operand)	CEIL(operand)
static Expression<?>	Expressions.coalesce(Operand... operands)	COALESCE(operand1, operand2, ...
static Expression<?>	Expressions.concat(Operand... operands)	CONCAT(operand1, operand2, ...
static Expression<?>	Expressions.custom(IRI functionIri, Operand... operands)
static Expression<?>	Expressions.custom(Iri functionIri, Operand... operands)
static Expression<?>	Expressions.datatype(Variable var)
static Expression<?>	Expressions.divide(Operand... operands)	operand1 / operand2 / ...
static Expression<?>	Expressions.equals(Operand left, Operand right)	left = right
static Expression<?>	Expressions.function(SparqlFunction function, Operand... operands)	Too lazy at the moment.
static Expression<?>	Expressions.gt(Number left, Number right)	left > right
static Expression<?>	Expressions.gt(Number left, Operand right)	left > right
static Expression<?>	Expressions.gt(Operand left, Number right)	left > right
static Expression<?>	Expressions.gt(Operand left, Operand right)	left > right
static Expression<?>	Expressions.gte(Operand left, Operand right)	left >= right
static Expression<?>	Expressions.iff(Operand testExp, Operand thenExp, Operand elseExp)
static Expression<?>	Expressions.in(Operand searchTerm, Operand... expressions)	operand IN (expression1, expression2...)
static Expression<?>	Expressions.in(Variable var, IRI... options)
static Expression<?>	Expressions.in(Variable var, RdfValue... options)
static Expression<?>	Expressions.isBlank(Variable var)
static Expression<?>	Expressions.lt(Number left, Number right)	left invalid input: '<' right
static Expression<?>	Expressions.lt(Number left, Operand right)	left invalid input: '<' right
static Expression<?>	Expressions.lt(Operand left, Number right)	left invalid input: '<' right
static Expression<?>	Expressions.lt(Operand left, Operand right)	left invalid input: '<' right
static Expression<?>	Expressions.lte(Operand left, Operand right)	left invalid input: '<'= right
static Expression<?>	Expressions.minus(Operand operand)	-operand
static Expression<?>	Expressions.multiply(Operand... operands)	operand1 * operand2 * ...
static Expression<?>	Expressions.not(Operand operand)	!operand
static Expression<?>	Expressions.notEquals(Operand left, Operand right)	left != right
static Expression<?>	Expressions.notEquals(Variable left, IRI right)
static Expression<?>	Expressions.notEquals(Variable left, RdfValue right)
static Expression<?>	Expressions.notIn(Operand searchTerm, Operand... expressions)	operand NOT IN (expression1, expression2...)
static Expression<?>	Expressions.notIn(Variable var, IRI... options)
static Expression<?>	Expressions.notIn(Variable var, RdfValue... options)
static Expression<?>	Expressions.or(Operand... operands)	operand1 || operand2 || ...
static Expression<?>	Expressions.plus(Operand operand)	+operand
static Expression<?>	Expressions.regex(Operand testString, String pattern)	REGEX(testString, pattern)
static Expression<?>	Expressions.regex(Operand testString, String pattern, String flags)	REGEX(testString, pattern, flags)
static Expression<?>	Expressions.regex(Operand testString, Operand pattern)	REGEX(testString, pattern)
static Expression<?>	Expressions.regex(Operand testString, Operand pattern, Operand flags)	REGEX(testString, pattern, flags)
static Expression<?>	Expressions.str(Operand operand)	STR(literal) or STR(iri)
static Expression<?>	Expressions.strdt(Operand lexicalForm, Operand datatype)
static Expression<?>	Expressions.strlen(Operand operand)
static Expression<?>	Expressions.subtract(Operand... operands)	operand1 - operand2 - ...

Uses of Expression in org.eclipse.rdf4j.sparqlbuilder.core

Subclasses with type arguments of type Expression in org.eclipse.rdf4j.sparqlbuilder.core

Modifier and Type	Class	Description
class	Having	A SPARQL Having clause

Methods in org.eclipse.rdf4j.sparqlbuilder.core with parameters of type Expression

Modifier and Type	Method	Description
Having	Having.having(Expression<?>... expressions)	Add having conditions
static Having	SparqlBuilder.having(Expression<?>... expressions)	Create a SPARQL Having clause

Uses of Expression in org.eclipse.rdf4j.sparqlbuilder.core.query

Methods in org.eclipse.rdf4j.sparqlbuilder.core.query with parameters of type Expression

Modifier and Type	Method	Description
T	Query.having(Expression<?>... constraints)	Specify constraints for this query's Having clause.

Uses of Expression in org.eclipse.rdf4j.sparqlbuilder.graphpattern

Fields in org.eclipse.rdf4j.sparqlbuilder.graphpattern with type parameters of type Expression

Modifier and Type	Field	Description
private Optional<Expression<?>>	Filter.constraint

Methods in org.eclipse.rdf4j.sparqlbuilder.graphpattern with parameters of type Expression

Modifier and Type	Method	Description
Filter	Filter.filter(Expression<?> expression)	Set the constraint for this Filter clause
default GraphPattern	GraphPattern.filter(Expression<?> constraint)	Convert this graph pattern into a group graph pattern and add a filter:
GraphPatternNotTriples	GraphPatternNotTriples.filter(Expression<?> constraint)	Like GraphPattern.filter(Expression), but mutates and returns this instance
GroupGraphPattern	GroupGraphPattern.filter(Expression<?> constraint)

Constructors in org.eclipse.rdf4j.sparqlbuilder.graphpattern with parameters of type Expression

Modifier	Constructor	Description
(package private)	Filter(Expression<?> expression)