T - public class SqlTranslationUtils extends Object
| Modifier and Type | Field and Description |
|---|---|
static org.slf4j.Logger |
logger |
static com.hp.hpl.jena.sparql.expr.NodeValue |
TYPE_BLANK |
static com.hp.hpl.jena.sparql.expr.NodeValue |
TYPE_PLAIN_LITERAL |
static com.hp.hpl.jena.sparql.expr.NodeValue |
TYPE_TYPED_LITERAL |
static com.hp.hpl.jena.sparql.expr.NodeValue |
TYPE_URI |
| Constructor and Description |
|---|
SqlTranslationUtils() |
| Modifier and Type | Method and Description |
|---|---|
static ExprEvaluator |
createDefaultEvaluator() |
static E_RdfTerm |
expandAnyToTerm(com.hp.hpl.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(com.hp.hpl.jena.sparql.expr.Expr expr) |
static E_RdfTerm |
expandConstant(com.hp.hpl.jena.graph.Node node) |
static E_RdfTerm |
expandRdfTerm(com.hp.hpl.jena.sparql.expr.Expr expr) |
static E_RdfTerm |
expandRdfTerm(com.hp.hpl.jena.sparql.expr.ExprFunction expr)
Expands blankNode, uri, plainLiteral and typedLiteral to E_RdfTerm.
|
static com.hp.hpl.jena.sparql.expr.Expr |
extractLanguageTag(com.hp.hpl.jena.sparql.expr.Expr expr) |
static com.hp.hpl.jena.sparql.expr.Expr |
getDatatypeOrExpr(com.hp.hpl.jena.sparql.expr.Expr expr) |
static com.hp.hpl.jena.sparql.expr.Expr |
getLexicalValueOrExpr(com.hp.hpl.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<com.hp.hpl.jena.sparql.expr.Expr> |
getOptimizedConcatArgs(com.hp.hpl.jena.sparql.expr.Expr expr) |
static com.hp.hpl.jena.sparql.expr.Expr |
getTypeOrExpr(com.hp.hpl.jena.sparql.expr.Expr expr) |
static boolean |
isConcatExpr(com.hp.hpl.jena.sparql.expr.Expr expr) |
static boolean |
isOpConcatExpr(com.hp.hpl.jena.sparql.expr.Expr ta,
com.hp.hpl.jena.sparql.expr.Expr tb) |
static com.hp.hpl.jena.sparql.expr.ExprList |
mergeConsecutiveConstants(Iterable<com.hp.hpl.jena.sparql.expr.Expr> exprs)
Merges arguments that are constants together
Used for concat: concat("a", "b", "c") becomes concat("abc");
|
static com.hp.hpl.jena.sparql.expr.Expr |
optimizeEqualsConcat(com.hp.hpl.jena.sparql.expr.Expr ta,
com.hp.hpl.jena.sparql.expr.Expr tb) |
static com.hp.hpl.jena.sparql.expr.Expr |
optimizeEqualsConcatAlign(List<com.hp.hpl.jena.sparql.expr.Expr> la,
List<com.hp.hpl.jena.sparql.expr.Expr> lb)
Deprecated.
|
static com.hp.hpl.jena.sparql.expr.Expr |
optimizeOpConcat(com.hp.hpl.jena.sparql.expr.Expr ta,
com.hp.hpl.jena.sparql.expr.Expr tb,
Factory2<com.hp.hpl.jena.sparql.expr.Expr> exprFactory) |
static com.hp.hpl.jena.sparql.expr.Expr |
optimizeOpConcat(com.hp.hpl.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 com.hp.hpl.jena.sparql.expr.Expr |
optimizeOpConcat(com.hp.hpl.jena.sparql.expr.ExprFunction2 fn) |
static com.hp.hpl.jena.sparql.expr.Expr |
optimizeRdfTerm(com.hp.hpl.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<com.hp.hpl.jena.sparql.expr.Expr>> |
splitEqualsConcat(com.hp.hpl.jena.sparql.expr.Expr ta,
com.hp.hpl.jena.sparql.expr.Expr tb) |
static List<List<com.hp.hpl.jena.sparql.expr.Expr>> |
splitEqualsConcat(List<com.hp.hpl.jena.sparql.expr.Expr> la,
List<com.hp.hpl.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<com.hp.hpl.jena.sparql.expr.Expr> |
splitOpConcat(com.hp.hpl.jena.sparql.expr.Expr ta,
com.hp.hpl.jena.sparql.expr.Expr tb,
Factory2<com.hp.hpl.jena.sparql.expr.Expr> exprFactory) |
static List<com.hp.hpl.jena.sparql.expr.Expr> |
splitOpConcat(List<com.hp.hpl.jena.sparql.expr.Expr> la,
List<com.hp.hpl.jena.sparql.expr.Expr> lb,
Factory2<com.hp.hpl.jena.sparql.expr.Expr> exprFactory)
[(a1, b1)], [(a1, b1), (a2, b2)]
|
static com.hp.hpl.jena.sparql.expr.Expr |
translate(com.hp.hpl.jena.sparql.expr.E_GreaterThan expr) |
static com.hp.hpl.jena.sparql.expr.Expr |
translate(com.hp.hpl.jena.sparql.expr.E_GreaterThanOrEqual expr) |
static com.hp.hpl.jena.sparql.expr.Expr |
translate(com.hp.hpl.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 com.hp.hpl.jena.sparql.expr.Expr |
translate(com.hp.hpl.jena.sparql.expr.E_LessThanOrEqual expr) |
static com.hp.hpl.jena.sparql.expr.Expr |
translateCompare(com.hp.hpl.jena.sparql.expr.Expr a,
com.hp.hpl.jena.sparql.expr.Expr b,
Class<?> clazz) |
static com.hp.hpl.jena.sparql.expr.Expr |
translateCompare(com.hp.hpl.jena.sparql.expr.Expr ea,
com.hp.hpl.jena.sparql.expr.Expr eb,
Factory2<com.hp.hpl.jena.sparql.expr.Expr> factory)
FIXME The following expression is crap.
|
static com.hp.hpl.jena.sparql.expr.Expr |
translateCompare(com.hp.hpl.jena.sparql.expr.ExprFunction2 expr) |
public static final org.slf4j.Logger logger
public static final com.hp.hpl.jena.sparql.expr.NodeValue TYPE_BLANK
public static final com.hp.hpl.jena.sparql.expr.NodeValue TYPE_URI
public static final com.hp.hpl.jena.sparql.expr.NodeValue TYPE_PLAIN_LITERAL
public static final com.hp.hpl.jena.sparql.expr.NodeValue TYPE_TYPED_LITERAL
public static com.hp.hpl.jena.sparql.expr.Expr getTypeOrExpr(com.hp.hpl.jena.sparql.expr.Expr expr)
public static com.hp.hpl.jena.sparql.expr.Expr getLexicalValueOrExpr(com.hp.hpl.jena.sparql.expr.Expr expr)
expr - public static com.hp.hpl.jena.sparql.expr.Expr getDatatypeOrExpr(com.hp.hpl.jena.sparql.expr.Expr expr)
public static com.hp.hpl.jena.sparql.expr.Expr extractLanguageTag(com.hp.hpl.jena.sparql.expr.Expr expr)
public static E_RdfTerm expandAnyToTerm(com.hp.hpl.jena.sparql.expr.Expr expr)
expr - public static E_RdfTerm expandRdfTerm(com.hp.hpl.jena.sparql.expr.Expr expr)
public static E_RdfTerm expandRdfTerm(com.hp.hpl.jena.sparql.expr.ExprFunction expr)
expr - public static E_RdfTerm expandConstant(com.hp.hpl.jena.sparql.expr.Expr expr)
public static E_RdfTerm expandConstant(com.hp.hpl.jena.graph.Node node)
public static com.hp.hpl.jena.sparql.expr.Expr optimizeRdfTerm(com.hp.hpl.jena.sparql.expr.E_Equals expr)
expr - public static com.hp.hpl.jena.sparql.expr.ExprList mergeConsecutiveConstants(Iterable<com.hp.hpl.jena.sparql.expr.Expr> exprs)
concat - public static boolean isConcatExpr(com.hp.hpl.jena.sparql.expr.Expr expr)
public static com.hp.hpl.jena.sparql.expr.Expr optimizeOpConcat(com.hp.hpl.jena.sparql.expr.ExprFunction fn)
expr - public static com.hp.hpl.jena.sparql.expr.Expr optimizeOpConcat(com.hp.hpl.jena.sparql.expr.ExprFunction2 fn)
public static com.hp.hpl.jena.sparql.expr.Expr optimizeEqualsConcat(com.hp.hpl.jena.sparql.expr.Expr ta,
com.hp.hpl.jena.sparql.expr.Expr tb)
public static com.hp.hpl.jena.sparql.expr.Expr optimizeOpConcat(com.hp.hpl.jena.sparql.expr.Expr ta,
com.hp.hpl.jena.sparql.expr.Expr tb,
Factory2<com.hp.hpl.jena.sparql.expr.Expr> exprFactory)
public static boolean isOpConcatExpr(com.hp.hpl.jena.sparql.expr.Expr ta,
com.hp.hpl.jena.sparql.expr.Expr tb)
public static List<com.hp.hpl.jena.sparql.expr.Expr> getOptimizedConcatArgs(com.hp.hpl.jena.sparql.expr.Expr expr)
expr - public static List<List<com.hp.hpl.jena.sparql.expr.Expr>> splitEqualsConcat(com.hp.hpl.jena.sparql.expr.Expr ta, com.hp.hpl.jena.sparql.expr.Expr tb)
ta - The first concat expressiontb - The second concat expressionpublic static List<com.hp.hpl.jena.sparql.expr.Expr> splitOpConcat(com.hp.hpl.jena.sparql.expr.Expr ta, com.hp.hpl.jena.sparql.expr.Expr tb, Factory2<com.hp.hpl.jena.sparql.expr.Expr> exprFactory)
public static List<com.hp.hpl.jena.sparql.expr.Expr> splitOpConcat(List<com.hp.hpl.jena.sparql.expr.Expr> la, List<com.hp.hpl.jena.sparql.expr.Expr> lb, Factory2<com.hp.hpl.jena.sparql.expr.Expr> exprFactory)
la - lb - public static List<List<com.hp.hpl.jena.sparql.expr.Expr>> splitEqualsConcat(List<com.hp.hpl.jena.sparql.expr.Expr> la, List<com.hp.hpl.jena.sparql.expr.Expr> lb)
la - lb - @Deprecated public static com.hp.hpl.jena.sparql.expr.Expr optimizeEqualsConcatAlign(List<com.hp.hpl.jena.sparql.expr.Expr> la, List<com.hp.hpl.jena.sparql.expr.Expr> lb)
public static com.hp.hpl.jena.sparql.expr.Expr translate(com.hp.hpl.jena.sparql.expr.E_LessThan expr)
public static com.hp.hpl.jena.sparql.expr.Expr translate(com.hp.hpl.jena.sparql.expr.E_LessThanOrEqual expr)
public static com.hp.hpl.jena.sparql.expr.Expr translate(com.hp.hpl.jena.sparql.expr.E_GreaterThan expr)
public static com.hp.hpl.jena.sparql.expr.Expr translate(com.hp.hpl.jena.sparql.expr.E_GreaterThanOrEqual expr)
public static com.hp.hpl.jena.sparql.expr.Expr translateCompare(com.hp.hpl.jena.sparql.expr.ExprFunction2 expr)
public static com.hp.hpl.jena.sparql.expr.Expr translateCompare(com.hp.hpl.jena.sparql.expr.Expr a,
com.hp.hpl.jena.sparql.expr.Expr b,
Class<?> clazz)
public static com.hp.hpl.jena.sparql.expr.Expr translateCompare(com.hp.hpl.jena.sparql.expr.Expr ea,
com.hp.hpl.jena.sparql.expr.Expr eb,
Factory2<com.hp.hpl.jena.sparql.expr.Expr> factory)
a - b - exprFactory - Factory for creating a comparision expressionpublic static ExprEvaluator createDefaultEvaluator()
Copyright © 2014. All Rights Reserved.