org.aksw.sparqlify.core.transformations

Class SqlTranslationUtils

java.lang.Object

org.aksw.sparqlify.core.transformations.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 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 Summary

Constructors

Constructor and Description
SqlTranslationUtils()

Method Summary

Methods

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)

Methods inherited from class java.lang.Object

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

Field Detail

logger

public static final org.slf4j.Logger logger

TYPE_BLANK

public static final com.hp.hpl.jena.sparql.expr.NodeValue TYPE_BLANK

TYPE_URI

public static final com.hp.hpl.jena.sparql.expr.NodeValue TYPE_URI

TYPE_PLAIN_LITERAL

public static final com.hp.hpl.jena.sparql.expr.NodeValue TYPE_PLAIN_LITERAL

TYPE_TYPED_LITERAL

public static final com.hp.hpl.jena.sparql.expr.NodeValue TYPE_TYPED_LITERAL

Constructor Detail

SqlTranslationUtils

public SqlTranslationUtils()

Method Detail

getTypeOrExpr

public static com.hp.hpl.jena.sparql.expr.Expr getTypeOrExpr(com.hp.hpl.jena.sparql.expr.Expr expr)

getLexicalValueOrExpr

public 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.

Parameters:

expr -

Returns:

getDatatypeOrExpr

public static com.hp.hpl.jena.sparql.expr.Expr getDatatypeOrExpr(com.hp.hpl.jena.sparql.expr.Expr expr)

extractLanguageTag

public static com.hp.hpl.jena.sparql.expr.Expr extractLanguageTag(com.hp.hpl.jena.sparql.expr.Expr expr)

expandAnyToTerm

public 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

Parameters:

expr -

Returns:

expandRdfTerm

public static E_RdfTerm expandRdfTerm(com.hp.hpl.jena.sparql.expr.Expr expr)

expandRdfTerm

public static E_RdfTerm expandRdfTerm(com.hp.hpl.jena.sparql.expr.ExprFunction expr)

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(com.hp.hpl.jena.sparql.expr.Expr expr)

expandConstant

public static E_RdfTerm expandConstant(com.hp.hpl.jena.graph.Node node)

optimizeRdfTerm

public 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 && ... 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 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");

Parameters:

concat -

Returns:

isConcatExpr

public static boolean isConcatExpr(com.hp.hpl.jena.sparql.expr.Expr expr)

optimizeOpConcat

public 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. 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 com.hp.hpl.jena.sparql.expr.Expr optimizeOpConcat(com.hp.hpl.jena.sparql.expr.ExprFunction2 fn)

optimizeEqualsConcat

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)

optimizeOpConcat

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)

isOpConcatExpr

public static boolean isOpConcatExpr(com.hp.hpl.jena.sparql.expr.Expr ta,
                     com.hp.hpl.jena.sparql.expr.Expr tb)

getOptimizedConcatArgs

public static List<com.hp.hpl.jena.sparql.expr.Expr> getOptimizedConcatArgs(com.hp.hpl.jena.sparql.expr.Expr expr)

Parameters:

expr -

Returns:

splitEqualsConcat

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)

Parameters:

ta - The first concat expression

tb - The second concat expression

Returns:

splitOpConcat

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

splitOpConcat

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)

[(a1, b1)], [(a1, b1), (a2, b2)]

Parameters:

la -

lb -

Returns:

splitEqualsConcat

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)

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 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.

translate

public 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. 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 com.hp.hpl.jena.sparql.expr.Expr translate(com.hp.hpl.jena.sparql.expr.E_LessThanOrEqual expr)

translate

public static com.hp.hpl.jena.sparql.expr.Expr translate(com.hp.hpl.jena.sparql.expr.E_GreaterThan expr)

translate

public static com.hp.hpl.jena.sparql.expr.Expr translate(com.hp.hpl.jena.sparql.expr.E_GreaterThanOrEqual expr)

translateCompare

public static com.hp.hpl.jena.sparql.expr.Expr translateCompare(com.hp.hpl.jena.sparql.expr.ExprFunction2 expr)

translateCompare

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)

translateCompare

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)

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