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:

  • Method Details

    • abs

      public static Expression<?> abs(Number operand)
      ABS(operand)
      Parameters:
      operand - the argument to the absolute value function
      Returns:
      an ABS() function
      See Also:

    • abs

      public static Expression<?> abs(Operand operand)
      ABS(operand)
      Parameters:
      operand - the argument to the absolute value function
      Returns:
      an ABS() function
      See Also:

    • bnode

      public static Expression<?> bnode()
      BNODE()
      Returns:
      a no-arg BNODE() function
      See Also:

    • bnode

      public static Expression<?> bnode(RdfLiteral<?> literal)
      BNODE(operand)
      Parameters:
      literal - the RDF literal argument to the function
      Returns:
      a BNODE() function
      See Also:

    • bnode

      public static Expression<?> bnode(String literal)
      BNODE(operand)
      Parameters:
      literal - the String literal argument to the function
      Returns:
      a BNODE() function
      See Also:

    • bound

      public static Expression<?> bound(Variable var)
      BOUND(operand)
      Parameters:
      var - the SPARQL variable argument to the function
      Returns:
      a BOUND() function
      See Also:

    • ceil

      public static Expression<?> ceil(Operand operand)
      CEIL(operand)
      Parameters:
      operand - the argument to the function
      Returns:
      a CEIL() function
      See Also:

    • coalesce

      public static Expression<?> coalesce(Operand... operands)
      COALESCE(operand1, operand2, ... , operandN)
      Parameters:
      operands - the arguments to the function
      Returns:
      a COALESCE() function
      See Also:

    • concat

      public static Expression<?> concat(Operand... operands)
      CONCAT(operand1, operand2, ... , operandN)
      Parameters:
      operands - the arguments to the function
      Returns:
      a CONCAT() function
      See Also:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • notIn

      public static Expression<?> notIn(Operand searchTerm, Operand... expressions)
      operand NOT IN (expression1, expression2...)
      Parameters:
      searchTerm -
      expressions -
      Returns:
      an NOT IN function
      See Also:

    • 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:

    • plus

      public static Expression<?> plus(Operand operand)
      +operand
      Parameters:
      operand - argument to the function
      Returns:
      unary plus operation
      See Also:

    • minus

      public static Expression<?> minus(Operand operand)
      -operand
      Parameters:
      operand - argument to the function
      Returns:
      unary minus operation
      See Also:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • 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:

    • lt

      public static Expression<?> lt(Number left, Number right)
      left invalid input: '<' right
      Parameters:
      left - the left operand
      right - the right operand
      Returns:
      logical less than operation
      See Also:

    • lt

      public static Expression<?> lt(Number left, Operand right)
      left invalid input: '<' right
      Parameters:
      left - the left operand
      right - the right operand
      Returns:
      logical less than operation
      See Also:

    • lt

      public static Expression<?> lt(Operand left, Number right)
      left invalid input: '<' right
      Parameters:
      left - the left operand
      right - the right operand
      Returns:
      logical less than operation
      See Also:

    • lt

      public static Expression<?> lt(Operand left, Operand right)
      left invalid input: '<' right
      Parameters:
      left - the left operand
      right - the right operand
      Returns:
      logical less than operation
      See Also:

    • lte

      public static Expression<?> lte(Operand left, Operand right)
      left invalid input: '<'= right
      Parameters:
      left - the left operand
      right - the right operand
      Returns:
      logical less than or equals operation
      See Also:

    • and

      public static Expression<?> and(Operand... operands)
      operand1 invalid input: '&'invalid input: '&' operand2 invalid input: '&'invalid input: '&' ... operandN
      Parameters:
      operands - the arguments
      Returns:
      logical and operation
      See Also:

    • or

      public static Expression<?> or(Operand... operands)
      operand1 || operand2 || ... || operandN
      Parameters:
      operands - the arguments
      Returns:
      logical or operation
      See Also:

    • add

      public static Expression<?> add(Operand... operands)
      operand1 + operand2 + ... + operandN
      Parameters:
      operands - the arguments
      Returns:
      arithmetic addition operation
      See Also:

    • subtract

      public static Expression<?> subtract(Operand... operands)
      operand1 - operand2 - ... - operandN
      Parameters:
      operands - the arguments
      Returns:
      arithmetic subtraction operation
      See Also:

    • multiply

      public static Expression<?> multiply(Operand... operands)
      operand1 * operand2 * ... * operandN
      Parameters:
      operands - the arguments
      Returns:
      arithmetic multiplication operation
      See Also:

    • divide

      public static Expression<?> divide(Operand... operands)
      operand1 / operand2 / ... / operandN
      Parameters:
      operands - the arguments
      Returns:
      arithmetic division operation
      See Also:

    • avg

      public static Aggregate avg(Operand operand)
      avg(...)
      Parameters:
      operand - the expression to average
      Returns:
      an avg aggregate function
      See Also:

    • count

      public static Aggregate count(Operand operand)
      count()
      Parameters:
      operand - the expression to count
      Returns:
      a count aggregate
      See Also:

    • 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)