Package org.aksw.jena_sparql_api.views

Class SqlTranslationUtils

java.lang.Object
org.aksw.jena_sparql_api.views.SqlTranslationUtils
Type Parameters:
T -
public class SqlTranslationUtils extends Object
Iterator for iterating all of a list's subLists with a given offset (default 0) and increasing size.
Author:
raven

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final org.slf4j.Logger
    logger
     
    static final org.apache.jena.sparql.expr.NodeValue
    TYPE_BLANK
     
    static final org.apache.jena.sparql.expr.NodeValue
    TYPE_PLAIN_LITERAL
     
    static final org.apache.jena.sparql.expr.NodeValue
    TYPE_TYPED_LITERAL
     
    static final org.apache.jena.sparql.expr.NodeValue
    TYPE_URI
     

  • Constructor Summary

    Constructors
    Constructor
    Description
    SqlTranslationUtils()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static ExprEvaluator
    createDefaultEvaluator()
     
    static E_RdfTerm
    expandAnyToTerm(org.apache.jena.sparql.expr.Expr expr)
    Expands both constants and functions to RDF terms I don't want to touch the legacy function - thats why this function has this name
    static E_RdfTerm
    expandConstant(org.apache.jena.graph.Node node)
     
    static E_RdfTerm
    expandConstant(org.apache.jena.sparql.expr.Expr expr)
     
    static E_RdfTerm
    expandRdfTerm(org.apache.jena.sparql.expr.Expr expr)
     
    static E_RdfTerm
    expandRdfTerm(org.apache.jena.sparql.expr.ExprFunction expr)
    Deprecated.
    static org.apache.jena.sparql.expr.Expr
    extractLanguageTag(org.apache.jena.sparql.expr.Expr expr)
     
    static org.apache.jena.sparql.expr.Expr
    getDatatypeOrExpr(org.apache.jena.sparql.expr.Expr expr)
     
    static org.apache.jena.sparql.expr.Expr
    getLexicalValueOrExpr(org.apache.jena.sparql.expr.Expr expr)
    TODO: If we really want the ___lexical value___, we need to apply a transformation to value field based on its type and on the RDF datatype.
    static List<org.apache.jena.sparql.expr.Expr>
    getOptimizedConcatArgs(org.apache.jena.sparql.expr.Expr expr)
     
    static org.apache.jena.sparql.expr.Expr
    getTypeOrExpr(org.apache.jena.sparql.expr.Expr expr)
     
    static boolean
    isConcatExpr(org.apache.jena.sparql.expr.Expr expr)
     
    static boolean
    isOpConcatExpr(org.apache.jena.sparql.expr.Expr ta, org.apache.jena.sparql.expr.Expr tb)
     
    static org.apache.jena.sparql.expr.ExprList
    mergeConsecutiveConstants(Iterable<org.apache.jena.sparql.expr.Expr> exprs)
    Merges arguments that are constants together Used for concat: concat("a", "b", "c") becomes concat("abc");
    static org.apache.jena.sparql.expr.Expr
    optimizeEqualsConcat(org.apache.jena.sparql.expr.Expr ta, org.apache.jena.sparql.expr.Expr tb)
     
    static org.apache.jena.sparql.expr.Expr
    optimizeEqualsConcatAlign(List<org.apache.jena.sparql.expr.Expr> la, List<org.apache.jena.sparql.expr.Expr> lb)
    Deprecated.
    static org.apache.jena.sparql.expr.Expr
    optimizeOpConcat(org.apache.jena.sparql.expr.ExprFunction fn)
    Optimizes Equals(Concat(argsA), Concat(argsB)) FIXME: An combinations, where there are constants - Equals(Concat(args), const) //Assumes optimized form (the whole prefix in a single arg) The following cases are being handled: concat(prefixA, restA) = concat(prefixB, restB) If none of the prefixes is a substring of the other, the whole expression evaluated to false.
    static org.apache.jena.sparql.expr.Expr
    optimizeOpConcat(org.apache.jena.sparql.expr.ExprFunction2 fn)
     
    static org.apache.jena.sparql.expr.Expr
    optimizeOpConcat(org.apache.jena.sparql.expr.Expr ta, org.apache.jena.sparql.expr.Expr tb, BinaryOperator<org.apache.jena.sparql.expr.Expr> exprFactory)
     
    static org.apache.jena.sparql.expr.Expr
    optimizeRdfTerm(org.apache.jena.sparql.expr.E_Equals expr)
    Converts op(f(argsA), f(argsB)) -> op1(op2(argsA[1], argsB[2]), ..., op2(...)) This is mainly used for translating Equals(rdfTerm(argsA), rdfTerm(argsB)) to And(Equals(argsA[0], argsB[0]), Equals(...), ...) Example: f(argsA) = f(argsB) -> argsA = argsB -> argsA.1 = argsB.1 && argsA.2 = argsB.2 && ...
    static List<List<org.apache.jena.sparql.expr.Expr>>
    splitEqualsConcat(List<org.apache.jena.sparql.expr.Expr> la, List<org.apache.jena.sparql.expr.Expr> lb)
    Returns a list of alternatives (ors), whereas each alternative is a list of Equals expressions: [ [Equals("x", "x"), Equals(?a, ?b)], [...], ...
    static List<List<org.apache.jena.sparql.expr.Expr>>
    splitEqualsConcat(org.apache.jena.sparql.expr.Expr ta, org.apache.jena.sparql.expr.Expr tb)
     
    static List<org.apache.jena.sparql.expr.Expr>
    splitOpConcat(List<org.apache.jena.sparql.expr.Expr> la, List<org.apache.jena.sparql.expr.Expr> lb, BinaryOperator<org.apache.jena.sparql.expr.Expr> exprFactory)
    [(a1, b1)], [(a1, b1), (a2, b2)]
    static List<org.apache.jena.sparql.expr.Expr>
    splitOpConcat(org.apache.jena.sparql.expr.Expr ta, org.apache.jena.sparql.expr.Expr tb, BinaryOperator<org.apache.jena.sparql.expr.Expr> exprFactory)
     
    static org.apache.jena.sparql.expr.Expr
    translate(org.apache.jena.sparql.expr.E_GreaterThan expr)
     
    static org.apache.jena.sparql.expr.Expr
    translate(org.apache.jena.sparql.expr.E_GreaterThanOrEqual expr)
     
    static org.apache.jena.sparql.expr.Expr
    translate(org.apache.jena.sparql.expr.E_LessThan expr)
    The expression (a < b), where a and b are RdfTerm(type, obj, lang, datatype), could become: Worst case: a.type < b.type || a.type = b.type && a.obj < b.obj || a.type = b.type && a.type = 2 && a.obj = b.obj && a.lang < b.lang || a.type = b.type && a.type = 3 && a.obj = b.obj && a.datatype < b.datatype || Optimization: Skip datatype and language in comparisions.
    static org.apache.jena.sparql.expr.Expr
    translate(org.apache.jena.sparql.expr.E_LessThanOrEqual expr)
     
    static org.apache.jena.sparql.expr.Expr
    translateCompare(org.apache.jena.sparql.expr.ExprFunction2 expr)
     
    static org.apache.jena.sparql.expr.Expr
    translateCompare(org.apache.jena.sparql.expr.Expr a, org.apache.jena.sparql.expr.Expr b, Class<?> clazz)
     
    static org.apache.jena.sparql.expr.Expr
    translateCompare(org.apache.jena.sparql.expr.Expr ea, org.apache.jena.sparql.expr.Expr eb, BinaryOperator<org.apache.jena.sparql.expr.Expr> factory)
    FIXME The following expression is crap.

    Methods inherited from class java.lang.Object

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

  • Field Details

    • logger

      public static final org.slf4j.Logger logger

    • TYPE_BLANK

      public static final org.apache.jena.sparql.expr.NodeValue TYPE_BLANK

    • TYPE_URI

      public static final org.apache.jena.sparql.expr.NodeValue TYPE_URI

    • TYPE_PLAIN_LITERAL

      public static final org.apache.jena.sparql.expr.NodeValue TYPE_PLAIN_LITERAL

    • TYPE_TYPED_LITERAL

      public static final org.apache.jena.sparql.expr.NodeValue TYPE_TYPED_LITERAL

  • Constructor Details

    • SqlTranslationUtils

      public SqlTranslationUtils()

  • Method Details

    • getTypeOrExpr

      public static org.apache.jena.sparql.expr.Expr getTypeOrExpr(org.apache.jena.sparql.expr.Expr expr)

    • getLexicalValueOrExpr

      public static org.apache.jena.sparql.expr.Expr getLexicalValueOrExpr(org.apache.jena.sparql.expr.Expr expr)
      TODO: If we really want the ___lexical value___, we need to apply a transformation to value field based on its type and on the RDF datatype.
      Parameters:
      expr -
      Returns:

    • getDatatypeOrExpr

      public static org.apache.jena.sparql.expr.Expr getDatatypeOrExpr(org.apache.jena.sparql.expr.Expr expr)

    • extractLanguageTag

      public static org.apache.jena.sparql.expr.Expr extractLanguageTag(org.apache.jena.sparql.expr.Expr expr)

    • expandAnyToTerm

      public static E_RdfTerm expandAnyToTerm(org.apache.jena.sparql.expr.Expr expr)
      Expands both constants and functions to RDF terms I don't want to touch the legacy function - thats why this function has this name
      Parameters:
      expr -
      Returns:

    • expandRdfTerm

      public static E_RdfTerm expandRdfTerm(org.apache.jena.sparql.expr.Expr expr)

    • expandRdfTerm

      @Deprecated public static E_RdfTerm expandRdfTerm(org.apache.jena.sparql.expr.ExprFunction expr)
      Deprecated.
      Expands blankNode, uri, plainLiteral and typedLiteral to E_RdfTerm. Returns the expr if it already is of type E_RdfTerm. Return null for any other function, variable or constant.
      Parameters:
      expr -
      Returns:

    • expandConstant

      public static E_RdfTerm expandConstant(org.apache.jena.sparql.expr.Expr expr)

    • expandConstant

      public static E_RdfTerm expandConstant(org.apache.jena.graph.Node node)

    • optimizeRdfTerm

      public static org.apache.jena.sparql.expr.Expr optimizeRdfTerm(org.apache.jena.sparql.expr.E_Equals expr)
      Converts op(f(argsA), f(argsB)) -> op1(op2(argsA[1], argsB[2]), ..., op2(...)) This is mainly used for translating Equals(rdfTerm(argsA), rdfTerm(argsB)) to And(Equals(argsA[0], argsB[0]), Equals(...), ...) Example: f(argsA) = f(argsB) -> argsA = argsB -> argsA.1 = argsB.1 && argsA.2 = argsB.2 && ... TODO: How to account for extra information that might be available on the constraints on the variables, such as argX.y is a constant? Note: This does not work it many cases for e.g. concat : concat("ab", "c") = concat("a", "bc")
      Parameters:
      expr -
      Returns:

    • mergeConsecutiveConstants

      public static org.apache.jena.sparql.expr.ExprList mergeConsecutiveConstants(Iterable<org.apache.jena.sparql.expr.Expr> exprs)
      Merges arguments that are constants together Used for concat: concat("a", "b", "c") becomes concat("abc");
      Parameters:
      concat -
      Returns:

    • isConcatExpr

      public static boolean isConcatExpr(org.apache.jena.sparql.expr.Expr expr)

    • optimizeOpConcat

      public static org.apache.jena.sparql.expr.Expr optimizeOpConcat(org.apache.jena.sparql.expr.ExprFunction fn)
      Optimizes Equals(Concat(argsA), Concat(argsB)) FIXME: An combinations, where there are constants - Equals(Concat(args), const) //Assumes optimized form (the whole prefix in a single arg) The following cases are being handled: concat(prefixA, restA) = concat(prefixB, restB) If none of the prefixes is a substring of the other, the whole expression evaluated to false. otherwise, if the prefixes are equal, they will be removed. if only one further argument remains, the concat will be removed. Also, if one of the arguments is a constant, then it is treated as Concat(const), and theabove rules are applied
      Parameters:
      expr -
      Returns:

    • optimizeOpConcat

      public static org.apache.jena.sparql.expr.Expr optimizeOpConcat(org.apache.jena.sparql.expr.ExprFunction2 fn)

    • optimizeEqualsConcat

      public static org.apache.jena.sparql.expr.Expr optimizeEqualsConcat(org.apache.jena.sparql.expr.Expr ta, org.apache.jena.sparql.expr.Expr tb)

    • optimizeOpConcat

      public static org.apache.jena.sparql.expr.Expr optimizeOpConcat(org.apache.jena.sparql.expr.Expr ta, org.apache.jena.sparql.expr.Expr tb, BinaryOperator<org.apache.jena.sparql.expr.Expr> exprFactory)

    • isOpConcatExpr

      public static boolean isOpConcatExpr(org.apache.jena.sparql.expr.Expr ta, org.apache.jena.sparql.expr.Expr tb)

    • getOptimizedConcatArgs

      public static List<org.apache.jena.sparql.expr.Expr> getOptimizedConcatArgs(org.apache.jena.sparql.expr.Expr expr)
      Parameters:
      expr -
      Returns:

    • splitEqualsConcat

      public static List<List<org.apache.jena.sparql.expr.Expr>> splitEqualsConcat(org.apache.jena.sparql.expr.Expr ta, org.apache.jena.sparql.expr.Expr tb)
      Parameters:
      ta - The first concat expression
      tb - The second concat expression
      Returns:

    • splitOpConcat

      public static List<org.apache.jena.sparql.expr.Expr> splitOpConcat(org.apache.jena.sparql.expr.Expr ta, org.apache.jena.sparql.expr.Expr tb, BinaryOperator<org.apache.jena.sparql.expr.Expr> exprFactory)

    • splitOpConcat

      public static List<org.apache.jena.sparql.expr.Expr> splitOpConcat(List<org.apache.jena.sparql.expr.Expr> la, List<org.apache.jena.sparql.expr.Expr> lb, BinaryOperator<org.apache.jena.sparql.expr.Expr> exprFactory)
      [(a1, b1)], [(a1, b1), (a2, b2)]
      Parameters:
      la -
      lb -
      Returns:

    • splitEqualsConcat

      public static List<List<org.apache.jena.sparql.expr.Expr>> splitEqualsConcat(List<org.apache.jena.sparql.expr.Expr> la, List<org.apache.jena.sparql.expr.Expr> lb)
      Returns a list of alternatives (ors), whereas each alternative is a list of Equals expressions: [ [Equals("x", "x"), Equals(?a, ?b)], [...], ... ]
      Parameters:
      la -
      lb -
      Returns:

    • optimizeEqualsConcatAlign

      @Deprecated public static org.apache.jena.sparql.expr.Expr optimizeEqualsConcatAlign(List<org.apache.jena.sparql.expr.Expr> la, List<org.apache.jena.sparql.expr.Expr> lb)
      Deprecated.

    • translate

      public static org.apache.jena.sparql.expr.Expr translate(org.apache.jena.sparql.expr.E_LessThan expr)
      The expression (a < b), where a and b are RdfTerm(type, obj, lang, datatype), could become: Worst case: a.type < b.type || a.type = b.type && a.obj < b.obj || a.type = b.type && a.type = 2 && a.obj = b.obj && a.lang < b.lang || a.type = b.type && a.type = 3 && a.obj = b.obj && a.datatype < b.datatype || Optimization: Skip datatype and language in comparisions. TODO We have to consider datatypes to rule out invalid comparisions (in regard to the datatypes). However, this should be done on the SQL level.

    • translate

      public static org.apache.jena.sparql.expr.Expr translate(org.apache.jena.sparql.expr.E_LessThanOrEqual expr)

    • translate

      public static org.apache.jena.sparql.expr.Expr translate(org.apache.jena.sparql.expr.E_GreaterThan expr)

    • translate

      public static org.apache.jena.sparql.expr.Expr translate(org.apache.jena.sparql.expr.E_GreaterThanOrEqual expr)

    • translateCompare

      public static org.apache.jena.sparql.expr.Expr translateCompare(org.apache.jena.sparql.expr.ExprFunction2 expr)

    • translateCompare

      public static org.apache.jena.sparql.expr.Expr translateCompare(org.apache.jena.sparql.expr.Expr a, org.apache.jena.sparql.expr.Expr b, Class<?> clazz)

    • translateCompare

      public static org.apache.jena.sparql.expr.Expr translateCompare(org.apache.jena.sparql.expr.Expr ea, org.apache.jena.sparql.expr.Expr eb, BinaryOperator<org.apache.jena.sparql.expr.Expr> factory)
      FIXME The following expression is crap. I must have written it before I was clear about type errors... a.type < b.type || a.type = b.type && a.obj < b.obj || a.type = b.type && a.type = 2 && a.obj = b.obj && a.lang < b.lang || a.type = b.type && a.type = 3 && a.obj = b.obj && a.datatype < b.datatype ||
      Parameters:
      a -
      b -
      exprFactory - Factory for creating a comparision expression
      Returns:

    • createDefaultEvaluator

      public static ExprEvaluator createDefaultEvaluator()