Class QueryEvaluationUtil


  • public class QueryEvaluationUtil
    extends java.lang.Object
    • Constructor Detail

      • QueryEvaluationUtil

        public QueryEvaluationUtil()
    • Method Detail

      • getEffectiveBooleanValue

        public static boolean getEffectiveBooleanValue​(Value value)
                                                throws ValueExprEvaluationException
        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.
        Throws:
        ValueExprEvaluationException - In case the application of the EBV algorithm results in a type error.
      • compareLiterals

        public static boolean compareLiterals​(Literal leftLit,
                                              Literal rightLit,
                                              Compare.CompareOp operator)
                                       throws ValueExprEvaluationException
        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.
        Throws:
        ValueExprEvaluationException - if a type error occurred.
      • compareLiterals

        public static boolean compareLiterals​(Literal leftLit,
                                              Literal rightLit,
                                              Compare.CompareOp operator,
                                              boolean strict)
                                       throws ValueExprEvaluationException
        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.
        Throws:
        ValueExprEvaluationException - if a type error occurred.
      • validateDatatypeCompatibility

        private static void validateDatatypeCompatibility​(boolean strict,
                                                          CoreDatatype.XSD leftCoreDatatype,
                                                          CoreDatatype.XSD rightCoreDatatype)
                                                   throws ValueExprEvaluationException
        Validate if we are comparing supported but incompatible datatypes. Throws a ValueExprEvaluationException if this is the case.

        Used in a strict / minimally-conforming interpretation of the SPARQL specification. In the SPARQL 1.1 operator mapping table, when comparing two literals with different datatypes (that cannot be cast to a common type), the only mapping that applies is comparison using RDF term-equality:

        A != B RDF term RDF term fn:not(RDFterm-equal(A, B)) xsd:boolean
        RDFterm-equal is defined as follows:
        Returns TRUE if term1 and term2 are the same RDF term as defined in Resource Description Framework (RDF): Concepts and Abstract Syntax [CONCEPTS]; produces a type error if the arguments are both literal but are not the same RDF term; returns FALSE otherwise. term1 and term2 are the same if any of the following is true:
        (emphasis ours)

        When applying the SPARQL specification in a minimally-conforming manner, RDFterm-equal is supposed to return a type error whenever we compare two literals with incompatible datatypes: we have two literals, but they are not the same RDF term (as they are not equivalent literals as defined in the linked section in RDF Concepts). This holds even if those two datatypes that fully supported and understood (say, when comparing an xsd:string and an xsd:boolean).

        In a non-strict interpretation, however, we allow comparing comparing two literals with incompatible but supported datatypes (string, numeric, calendar): An equality comparison will result in false, and an inequality comparison will result in true. Note that this does not violate the SPARQL specification as it falls under operator extensibility (section 17.3.1).

        Parameters:
        strict - flag indicating if query evaluation is operating in strict/minimally-conforming mode.
        leftCoreDatatype - the left datatype to compare
        rightCoreDatatype - the right datatype to compare
        Throws:
        ValueExprEvaluationException - if query evaluation is operating in strict mode, and the two supplied datatypes are both supported datatypes but not comparable.
        See Also:
        Github issue #3947
      • compareWithOperator

        private static boolean compareWithOperator​(Compare.CompareOp operator,
                                                   int i)
      • 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
      • 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
      • isSupportedDatatype

        private static boolean isSupportedDatatype​(CoreDatatype.XSD datatype)