Package org.eclipse.rdf4j.query.algebra.evaluation.util

## Class QueryEvaluationUtility

- java.lang.Object
- - org.eclipse.rdf4j.query.algebra.evaluation.util.QueryEvaluationUtility

-     @InternalUseOnly
      public class QueryEvaluationUtility
      extends Object

  This class will take over for QueryEvaluationUtil. Currently marked as InternalUseOnly because there may still be changes to how this class works.
  Author:
    Arjohn Kampman, Håvard M. Ottestad

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class | Description
    --- | --- | ---
    `static class` | `QueryEvaluationUtility.Result` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `QueryEvaluationUtility()` |

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `static QueryEvaluationUtility.Result` | `compare​(Value leftVal, Value rightVal, Compare.CompareOp operator)` |
    `static QueryEvaluationUtility.Result` | `compare​(Value leftVal, Value rightVal, Compare.CompareOp operator, boolean strict)` |
    `static org.eclipse.rdf4j.query.algebra.evaluation.util.QueryEvaluationUtility.Order` | `compareLiterals​(Literal leftLit, Literal rightLit, boolean strict)` |
    `static QueryEvaluationUtility.Result` | `compareLiterals​(Literal leftLit, Literal rightLit, Compare.CompareOp operator)` | Compares the supplied `Literal` arguments using the supplied operator, using strict (minimally-conforming) SPARQL 1.1 operator behavior.
    `static QueryEvaluationUtility.Result` | `compareLiterals​(Literal leftLit, Literal rightLit, Compare.CompareOp operator, boolean strict)` | Compares the supplied `Literal` arguments using the supplied operator.
    `static boolean` | `compatibleArguments​(Literal arg1, Literal arg2)` | Checks whether the supplied two literal arguments are 'argument compatible' according to the SPARQL definition.
    `static QueryEvaluationUtility.Result` | `getEffectiveBooleanValue​(Value value)` | Determines the effective boolean value (EBV) of the supplied value as defined in the SPARQL specification: The EBV of any literal whose type is CoreDatatype.XSD:boolean or numeric is false if the lexical form is not valid for that datatype (e.g.
    `static boolean` | `isPlainLiteral​(Literal l)` |
    `static boolean` | `isPlainLiteral​(Value v)` | Checks whether the supplied value is a "plain literal".
    `static boolean` | `isSimpleLiteral​(boolean isLang, CoreDatatype datatype)` | Checks whether the supplied literal is a "simple literal".
    `static boolean` | `isSimpleLiteral​(Literal l)` | Checks whether the supplied literal is a "simple literal".
    `static boolean` | `isSimpleLiteral​(Value v)` | Checks whether the supplied value is a "simple literal".
    `static boolean` | `isStringLiteral​(Literal l)` | Checks whether the supplied literal is a "string literal".
    `static boolean` | `isStringLiteral​(Value v)` | Checks whether the supplied literal is a "string literal".

    - ### Methods inherited from class java.lang.Object

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

- - ### Constructor Detail

    - #### QueryEvaluationUtility

          public QueryEvaluationUtility()

  - ### Method Detail

    - #### getEffectiveBooleanValue

          public static QueryEvaluationUtility.Result getEffectiveBooleanValue​(Value value)

      Determines the effective boolean value (EBV) of the supplied value as defined in the SPARQL specification:
      - The EBV of any literal whose type is CoreDatatype.XSD:boolean or numeric is false if the lexical form is not valid for that datatype (e.g. "abc"^^xsd:integer).
      - If the argument is a typed literal with a datatype of CoreDatatype.XSD:boolean, the EBV is the value of that argument.
      - If the argument is a plain literal or a typed literal with a datatype of CoreDatatype.XSD:string, the EBV is false if the operand value has zero length; otherwise the EBV is true.
      - If the argument is a numeric type or a typed literal with a datatype derived from a numeric type, the EBV is false if the operand value is NaN or is numerically equal to zero; otherwise the EBV is true.
      - All other arguments, including unbound arguments, produce a type error.
      Parameters:
        `value` - Some value.
      Returns:
        The EBV of value.

    - #### compare

          public static QueryEvaluationUtility.Result compare​(Value leftVal,
                                                              Value rightVal,
                                                              Compare.CompareOp operator)

    - #### compare

          public static QueryEvaluationUtility.Result compare​(Value leftVal,
                                                              Value rightVal,
                                                              Compare.CompareOp operator,
                                                              boolean strict)

    - #### compareLiterals

          public static QueryEvaluationUtility.Result compareLiterals​(Literal leftLit,
                                                                      Literal rightLit,
                                                                      Compare.CompareOp operator)

      Compares the supplied `Literal` arguments using the supplied operator, using strict (minimally-conforming) SPARQL 1.1 operator behavior.
      Parameters:
        `leftLit` - the left literal argument of the comparison.
        `rightLit` - the right literal argument of the comparison.
        `operator` - the comparison operator to use.
      Returns:
        `true` if execution of the supplied operator on the supplied arguments succeeds, `false` otherwise.

    - #### compareLiterals

          public static org.eclipse.rdf4j.query.algebra.evaluation.util.QueryEvaluationUtility.Order compareLiterals​(Literal leftLit,
                                                                                                                     Literal rightLit,
                                                                                                                     boolean strict)

    - #### compareLiterals

          public static QueryEvaluationUtility.Result compareLiterals​(Literal leftLit,
                                                                      Literal rightLit,
                                                                      Compare.CompareOp operator,
                                                                      boolean strict)

      Compares the supplied `Literal` arguments using the supplied operator.
      Parameters:
        `leftLit` - the left literal argument of the comparison.
        `rightLit` - the right literal argument of the comparison.
        `operator` - the comparison operator to use.
        `strict` - boolean indicating whether comparison should use strict (minimally-conforming) SPARQL 1.1 operator behavior, or extended behavior.
      Returns:
        `true` if execution of the supplied operator on the supplied arguments succeeds, `false` otherwise.

    - #### isPlainLiteral

          public static boolean isPlainLiteral​(Value v)

      Checks whether the supplied value is a "plain literal". A "plain literal" is a literal with no datatype and optionally a language tag.
      See Also:
        RDF Literal Documentation

    - #### isPlainLiteral

          public static boolean isPlainLiteral​(Literal l)

    - #### isSimpleLiteral

          public static boolean isSimpleLiteral​(Value v)

      Checks whether the supplied value is a "simple literal". A "simple literal" is a literal with no language tag nor datatype.
      See Also:
        SPARQL Simple Literal Documentation

    - #### isSimpleLiteral

          public static boolean isSimpleLiteral​(Literal l)

      Checks whether the supplied literal is a "simple literal". A "simple literal" is a literal with no language tag and the datatype `CoreDatatype.XSD.STRING`.
      See Also:
        SPARQL Simple Literal Documentation

    - #### isSimpleLiteral

          public static boolean isSimpleLiteral​(boolean isLang,
                                                CoreDatatype datatype)

      Checks whether the supplied literal is a "simple literal". A "simple literal" is a literal with no language tag and the datatype `CoreDatatype.XSD.STRING`.
      See Also:
        SPARQL Simple Literal Documentation

    - #### isStringLiteral

          public static boolean isStringLiteral​(Value v)

      Checks whether the supplied literal is a "string literal". A "string literal" is either a simple literal, a plain literal with language tag, or a literal with datatype CoreDatatype.XSD:string.
      See Also:
        SPARQL Functions on Strings Documentation

    - #### compatibleArguments

          public static boolean compatibleArguments​(Literal arg1,
                                                    Literal arg2)

      Checks whether the supplied two literal arguments are 'argument compatible' according to the SPARQL definition.
      Parameters:
        `arg1` - the first argument
        `arg2` - the second argument
      Returns:
        true iff the two supplied arguments are argument compatible, false otherwise
      See Also:
        SPARQL Argument Compatibility Rules

    - #### isStringLiteral

          public static boolean isStringLiteral​(Literal l)

      Checks whether the supplied literal is a "string literal". A "string literal" is either a simple literal, a plain literal with language tag, or a literal with datatype CoreDatatype.XSD:string.
      See Also:
        SPARQL Functions on Strings Documentation