Package org.eclipse.rdf4j.sparqlbuilder.constraint

Class Expressions

java.lang.Object

org.eclipse.rdf4j.sparqlbuilder.constraint.Expressions

public class Expressions
extends Object

A class with static methods to create SPARQL expressions. Obviously there's some more flushing out TODO still

See Also:

SPARQL Function Definitions

Method Summary

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

Methods inherited from class java.lang.Object

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

Method Detail

abs

public static Expression<?> abs(Number operand)

ABS(operand)

Parameters:

operand - the argument to the absolute value function

Returns:

an ABS() function

See Also:

SPARQL ABS Function

abs

public static Expression<?> abs(Operand operand)

ABS(operand)

Parameters:

operand - the argument to the absolute value function

Returns:

an ABS() function

See Also:

SPARQL ABS Function

bnode

public static Expression<?> bnode()

BNODE()

Returns:

a no-arg BNODE() function

See Also:

SPARQL BNODE Function

bnode

public static Expression<?> bnode(RdfLiteral<?> literal)

BNODE(operand)

Parameters:

literal - the RDF literal argument to the function

Returns:

a BNODE() function

See Also:

SPARQL BNODE Function

bnode

public static Expression<?> bnode(String literal)

BNODE(operand)

Parameters:

literal - the String literal argument to the function

Returns:

a BNODE() function

See Also:

SPARQL BNODE Function

bound

public static Expression<?> bound(Variable var)

BOUND(operand)

Parameters:

var - the SPARQL variable argument to the function

Returns:

a BOUND() function

See Also:

SPARQL BOUND Function

ceil

public static Expression<?> ceil(Operand operand)

CEIL(operand)

Parameters:

operand - the argument to the function

Returns:

a CEIL() function

See Also:

SPARQL CEIL Function

coalesce

public static Expression<?> coalesce(Operand... operands)

COALESCE(operand1, operand2, ... , operandN)

Parameters:

operands - the arguments to the function

Returns:

a COALESCE() function

See Also:

SPARQL COALESCE Function

concat

public static Expression<?> concat(Operand... operands)

CONCAT(operand1, operand2, ... , operandN)

Parameters:

operands - the arguments to the function

Returns:

a CONCAT() function

See Also:

SPARQL CONCAT Function

regex

public static Expression<?> regex(Operand testString,
                                  String pattern)

REGEX(testString, pattern)

Parameters:

testString - the text to match against

pattern - the regex pattern to match

Returns:

a REGEX() function

See Also:

SPARQL REGEX Function

regex

public static Expression<?> regex(Operand testString,
                                  String pattern,
                                  String flags)

REGEX(testString, pattern, flags)

Parameters:

testString - the text to match against

pattern - the regular expression pattern to match

flags - flags to specify matching options

Returns:

a REGEX() function

See Also:

SPARQL REGEX Function

regex

public static Expression<?> regex(Operand testString,
                                  Operand pattern)

REGEX(testString, pattern)

Parameters:

testString - the text to match against

pattern - the regex pattern to match

Returns:

a REGEX() function

See Also:

SPARQL REGEX Function

regex

public static Expression<?> regex(Operand testString,
                                  Operand pattern,
                                  Operand flags)

REGEX(testString, pattern, flags)

Parameters:

testString - the text to match against

pattern - the regular expression pattern to match

flags - flags to specify matching options

Returns:

a REGEX() function

See Also:

SPARQL REGEX Function

str

public static Expression<?> str(Operand operand)

STR(literal) or STR(iri)

Parameters:

operand - the arg to convert to a string

Returns:

a STR() function

See Also:

SPARQL STR Function

custom

public static Expression<?> custom(Iri functionIri,
                                   Operand... operands)

custom

public static Expression<?> custom(IRI functionIri,
                                   Operand... operands)

in

public static Expression<?> in(Operand searchTerm,
                               Operand... expressions)

operand IN (expression1, expression2...)

Parameters:

searchTerm -

expressions -

Returns:

an IN function

See Also:

SPARQL IN Function

notIn

public static Expression<?> notIn(Operand searchTerm,
                                  Operand... expressions)

operand NOT IN (expression1, expression2...)

Parameters:

searchTerm -

expressions -

Returns:

an NOT IN function

See Also:

SPARQL NOT IN Function

function

public static Expression<?> function(SparqlFunction function,
                                     Operand... operands)

Too lazy at the moment. Make the rest of the functions this way for now.

Parameters:

function - a SPARQL Function

operands - arguments to the function

Returns:

a function object of the given function type and operands

not

public static Expression<?> not(Operand operand)

!operand

Parameters:

operand - argument to the function

Returns:

logical not operation

See Also:

SPARQL Operators

plus

public static Expression<?> plus(Operand operand)

+operand

Parameters:

operand - argument to the function

Returns:

unary plus operation

See Also:

SPARQL Operators

minus

public static Expression<?> minus(Operand operand)

-operand

Parameters:

operand - argument to the function

Returns:

unary minus operation

See Also:

SPARQL Operators

equals

public static Expression<?> equals(Operand left,
                                   Operand right)

left = right

Parameters:

left - the left operand

right - the right operand

Returns:

logical equals operation

See Also:

SPARQL Operators

notEquals

public static Expression<?> notEquals(Operand left,
                                      Operand right)

left != right

Parameters:

left - the left operand

right - the right operand

Returns:

logical not equals operation

See Also:

SPARQL Operators

notEquals

public static Expression<?> notEquals(Variable left,
                                      RdfValue right)

notEquals

public static Expression<?> notEquals(Variable left,
                                      IRI right)

gt

public static Expression<?> gt(Number left,
                               Number right)

left > right

Parameters:

left - the left operand

right - the right operand

Returns:

logical greater than operation

See Also:

SPARQL Operators

gt

public static Expression<?> gt(Number left,
                               Operand right)

left > right

Parameters:

left - the left operand

right - the right operand

Returns:

logical greater than operation

See Also:

SPARQL Operators

gt

public static Expression<?> gt(Operand left,
                               Number right)

left > right

Parameters:

left - the left operand

right - the right operand

Returns:

logical greater than operation

See Also:

SPARQL Operators

gt

public static Expression<?> gt(Operand left,
                               Operand right)

left > right

Parameters:

left - the left operand

right - the right operand

Returns:

logical greater than operation

See Also:

SPARQL Operators

gte

public static Expression<?> gte(Operand left,
                                Operand right)

left >= right

Parameters:

left - the left operand

right - the right operand

Returns:

logical greater than or equals operation

See Also:

SPARQL Operators

lt

public static Expression<?> lt(Number left,
                               Number right)

left < right

Parameters:

left - the left operand

right - the right operand

Returns:

logical less than operation

See Also:

SPARQL Operators

lt

public static Expression<?> lt(Number left,
                               Operand right)

left < right

Parameters:

left - the left operand

right - the right operand

Returns:

logical less than operation

See Also:

SPARQL Operators

lt

public static Expression<?> lt(Operand left,
                               Number right)

left < right

Parameters:

left - the left operand

right - the right operand

Returns:

logical less than operation

See Also:

SPARQL Operators

lt

public static Expression<?> lt(Operand left,
                               Operand right)

left < right

Parameters:

left - the left operand

right - the right operand

Returns:

logical less than operation

See Also:

SPARQL Operators

lte

public static Expression<?> lte(Operand left,
                                Operand right)

left <= right

Parameters:

left - the left operand

right - the right operand

Returns:

logical less than or equals operation

See Also:

SPARQL Operators

and

public static Expression<?> and(Operand... operands)

operand1 && operand2 && ... operandN

Parameters:

operands - the arguments

Returns:

logical and operation

See Also:

SPARQL Operators

or

public static Expression<?> or(Operand... operands)

operand1 || operand2 || ... || operandN

Parameters:

operands - the arguments

Returns:

logical or operation

See Also:

SPARQL Operators

add

public static Expression<?> add(Operand... operands)

operand1 + operand2 + ... + operandN

Parameters:

operands - the arguments

Returns:

arithmetic addition operation

See Also:

SPARQL Operators

subtract

public static Expression<?> subtract(Operand... operands)

operand1 - operand2 - ... - operandN

Parameters:

operands - the arguments

Returns:

arithmetic subtraction operation

See Also:

SPARQL Operators

multiply

public static Expression<?> multiply(Operand... operands)

operand1 * operand2 * ... * operandN

Parameters:

operands - the arguments

Returns:

arithmetic multiplication operation

See Also:

SPARQL Operators

divide

public static Expression<?> divide(Operand... operands)

operand1 / operand2 / ... / operandN

Parameters:

operands - the arguments

Returns:

arithmetic division operation

See Also:

SPARQL Operators

avg

public static Aggregate avg(Operand operand)

avg(...)

Parameters:

operand - the expression to average

Returns:

an avg aggregate function

See Also:

SPARQL aggregates

count

public static Aggregate count(Operand operand)

count()

Parameters:

operand - the expression to count

Returns:

a count aggregate

See Also:

SPARQL aggregates

countAll

public static Aggregate countAll()

group_concat

public static Aggregate group_concat(Operand... operands)

group_concat

public static Aggregate group_concat(String separator,
                                     Operand... operands)

max

public static Aggregate max(Operand operand)

min

public static Aggregate min(Operand operand)

sample

public static Aggregate sample(Operand operand)

sum

public static Aggregate sum(Operand operand)

bind

public static Bind bind(Assignable exp,
                        Variable var)

notIn

public static Expression<?> notIn(Variable var,
                                  RdfValue... options)

notIn

public static Expression<?> notIn(Variable var,
                                  IRI... options)

in

public static Expression<?> in(Variable var,
                               RdfValue... options)

in

public static Expression<?> in(Variable var,
                               IRI... options)

strdt

public static Expression<?> strdt(Operand lexicalForm,
                                  Operand datatype)

strlen

public static Expression<?> strlen(Operand operand)

isBlank

public static Expression<?> isBlank(Variable var)

datatype

public static Expression<?> datatype(Variable var)

iff

public static Expression<?> iff(Operand testExp,
                                Operand thenExp,
                                Operand elseExp)