org.aksw.sparqlify.core.algorithms

Class MappingOpsImpl

java.lang.Object

org.aksw.sparqlify.core.algorithms.MappingOpsImpl

All Implemented Interfaces:

MappingOps

public class MappingOpsImpl
extends Object
implements MappingOps

Constructor Summary

Constructors

Constructor and Description
MappingOpsImpl(SqlTranslator sqlTranslator, ExprDatatypeNorm exprNormalizer)

Method Summary

Methods

Modifier and Type	Method and Description
static com.hp.hpl.jena.sparql.expr.E_Function	aggregatorToFunction(com.hp.hpl.jena.sparql.expr.aggregate.Aggregator agg) Convert an aggregator to a function object.
com.hp.hpl.jena.sparql.expr.ExprList	compactConjuction(com.hp.hpl.jena.sparql.expr.ExprList exprs)
static List<Map<com.hp.hpl.jena.sparql.core.Var,com.hp.hpl.jena.sparql.expr.Expr>>	createBindingProduct(VarDefinition varDef, Collection<com.hp.hpl.jena.sparql.core.Var> vars)
static Mapping	createEmptyMapping()
static Mapping	createEmptyMapping(ViewInstance<ViewDefinition> viewInstance)
List<org.aksw.sparqlify.core.algorithms.SqlExprContext>	createExprContexts(com.hp.hpl.jena.sparql.expr.Expr e, Mapping source)
static List<org.aksw.sparqlify.core.algorithms.SqlExprContext>	createExprSqlRewrites(com.hp.hpl.jena.sparql.expr.Expr condition, Mapping m, SqlTranslator sqlTranslator)
static List<org.aksw.sparqlify.core.algorithms.SqlExprContext>	createExprSqlRewrites(com.hp.hpl.jena.sparql.expr.Expr condition, VarDefinition varDef, Map<String,TypeToken> typeMap, SqlTranslator sqlTranslator) Returns a list of Binding-Sql Expr pairs.
Mapping	createMapping(ViewInstance<ViewDefinition> viewInstance) Creates a mapping from a view instance: - For every binding variable, that maps to multiple things (contants + variables), we need to equate all these things being mapped to Schematically, we need to transform the binding to variable definitions from the original structure (query view definition) q v d / dx1 ?x / \ dxn ?s \ / dy1 ?y \ dyn to conceptually a CNF: (dx1 = dy1 OR ...
static SqlExpr	createSqlCondition(com.hp.hpl.jena.sparql.expr.Expr condition, VarDefinition varDef, Map<String,TypeToken> typeMap, SqlTranslator sqlTranslator)
static List<SqlExpr>	createSqlConditionItems(com.hp.hpl.jena.sparql.expr.Expr condition, VarDefinition varDef, Map<String,TypeToken> typeMap, SqlTranslator sqlTranslator)
static SqlExpr	createSqlConditionOld(com.hp.hpl.jena.sparql.expr.Expr condition, VarDefinition varDef, Map<String,TypeToken> typeMap, SqlTranslator sqlTranslator) Deprecated.
Mapping	distinct(Mapping a)
Mapping	doJoinRename(Mapping a, Mapping b, com.hp.hpl.jena.sdb.core.Generator gen) Returns a new mapping for b: All column names that a and b have in commons are renamed in b.
ExprDatatypeNorm	exprNormalizer()
Mapping	extend(Mapping a, VarDefinition varDef) Extends a mapping with additional variable definitions.
Mapping	filter(Mapping a, com.hp.hpl.jena.sparql.expr.ExprList exprs)
static Set<String>	getReferencedColumnNames(List<Mapping> mappings)
SqlTranslator	getSqlTranslator()
TypeSystem	getTypeSystem() TODO HACK Hacky function, get rid of it
Mapping	groupBy(Mapping a, com.hp.hpl.jena.sparql.core.VarExprList groupVars, List<com.hp.hpl.jena.sparql.expr.ExprAggregator> aggregators) GroupBy
Mapping	groupByOld(Mapping a, com.hp.hpl.jena.sparql.core.VarExprList groupVars, List<com.hp.hpl.jena.sparql.expr.ExprAggregator> aggregators)
Mapping	join(Mapping a, Mapping b)
Mapping	joinCommon(Mapping a, Mapping initB, boolean isLeftJoin)
static org.aksw.sparqlify.core.algorithms.VarDefKey	joinDefinitionsOnEquals(Collection<RestrictedExpr> a, Collection<RestrictedExpr> b, Map<String,TypeToken> typeMap, SqlTranslator sqlTranslator) Joins two var definitions on the given queryVar.
static org.aksw.sparqlify.core.algorithms.VarDefKey	joinDefinitionsOnEquals(com.hp.hpl.jena.sparql.core.Var queryVar, ViewInstance<ViewDefinition> viewInstance, SqlTranslator sqlTranslator) Returns a set of equals expressions, created from equating all pickDefs to the given varDefs The set is intended to be interpreted as a disjunction between the elements.
Mapping	leftJoin(Mapping a, Mapping b)
Mapping	order(Mapping a, List<com.hp.hpl.jena.query.SortCondition> sortConditions) FIXME The var definitions should not be lists rather than sets in order to ensure deterministic behaviour! 1.
Mapping	project(Mapping a, List<com.hp.hpl.jena.sparql.core.Var> vars) Removes variables from the definitions.
static List<Mapping>	pushConstants(List<Mapping> mappings)
static Mapping	pushConstants(Mapping mapping) Pushes all constants of a given mapping's varDefinition into the SQL.
static List<Mapping>	removeEmptyMembers(List<Mapping> mappings)
Mapping	rename(Mapping a, Map<String,String> rename) Creates a new mapping with all column references in the variable definition renamed, and injects an approprate SqlProjection into the logical table
ExprSqlRewrite	rewrite(com.hp.hpl.jena.sdb.core.Gensym gensym, com.hp.hpl.jena.sparql.expr.aggregate.AggCount agg)
static ExprSqlRewrite	rewrite(Mapping mapping, com.hp.hpl.jena.sparql.expr.aggregate.Aggregator agg, com.hp.hpl.jena.sdb.core.Generator generator, TypeSystem typeSystem, SqlTranslator sqlTranslator) TODO: Without the toDouble coercion, SUM(int) will be discarded even after already been found out as a candidate.
ExprSqlRewrite	rewriteOld(com.hp.hpl.jena.sdb.core.Gensym gensym, com.hp.hpl.jena.sparql.expr.aggregate.Aggregator agg) Returns a pair comprised of: - A SPARQL expression that references the SQL column of the aggregater - A projection // Ignore: the typeMap is implied by the projection - A type map
Mapping	slice(Mapping a, Long limit, Long offset)
static SqlExpr	translateSql(com.hp.hpl.jena.sparql.expr.Expr expr, Map<String,TypeToken> typeMap, SqlTranslator sqlTranslator)
static SqlExpr	translateSql(RestrictedExpr restExpr, Map<String,TypeToken> typeMap, SqlTranslator sqlTranslator)
ExprSqlRewrite	unifyAlternatives(com.hp.hpl.jena.sparql.expr.Expr e, Mapping source) Two variants: - create a case-block for each expression - create a union - but with the union we would eval the expression over and over again - so we go with the case block
Mapping	union(List<Mapping> members) [ null, h: int, i: string, null ] [ a: int null, null, x: geo ] ?s = uri(concat("http://...", ?c1, ?c2)); ?s -> [c1: string, c2: int] with expr foo and restriction bar.
Mapping	unionIfNeeded(List<Mapping> members)

Methods inherited from class java.lang.Object

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

Constructor Detail

MappingOpsImpl

public MappingOpsImpl(SqlTranslator sqlTranslator,
              ExprDatatypeNorm exprNormalizer)

Method Detail

getSqlTranslator

public SqlTranslator getSqlTranslator()

exprNormalizer

public ExprDatatypeNorm exprNormalizer()

rename

public Mapping rename(Mapping a,
             Map<String,String> rename)

Description copied from interface: MappingOps

Creates a new mapping with all column references in the variable definition renamed, and injects an approprate SqlProjection into the logical table

Specified by:

rename in interface MappingOps

translateSql

public static SqlExpr translateSql(RestrictedExpr restExpr,
                   Map<String,TypeToken> typeMap,
                   SqlTranslator sqlTranslator)

translateSql

public static SqlExpr translateSql(com.hp.hpl.jena.sparql.expr.Expr expr,
                   Map<String,TypeToken> typeMap,
                   SqlTranslator sqlTranslator)

createExprSqlRewrites

public static List<org.aksw.sparqlify.core.algorithms.SqlExprContext> createExprSqlRewrites(com.hp.hpl.jena.sparql.expr.Expr condition,
                                                                            VarDefinition varDef,
                                                                            Map<String,TypeToken> typeMap,
                                                                            SqlTranslator sqlTranslator)

Returns a list of Binding-Sql Expr pairs. List<{Map, SqlExpr} IMPORTANT NOTE: Negation is dealt with once the result of this method is obtained I.e. if expr is of type E_LogicalNot, the result needs to be ANDified, otherwise ORified

Parameters:

condition -

varDef -

typeMap -

sqlTranslator -

Returns:

createExprSqlRewrites

public static List<org.aksw.sparqlify.core.algorithms.SqlExprContext> createExprSqlRewrites(com.hp.hpl.jena.sparql.expr.Expr condition,
                                                                            Mapping m,
                                                                            SqlTranslator sqlTranslator)

createSqlConditionItems

public static List<SqlExpr> createSqlConditionItems(com.hp.hpl.jena.sparql.expr.Expr condition,
                                    VarDefinition varDef,
                                    Map<String,TypeToken> typeMap,
                                    SqlTranslator sqlTranslator)

createSqlCondition

public static SqlExpr createSqlCondition(com.hp.hpl.jena.sparql.expr.Expr condition,
                         VarDefinition varDef,
                         Map<String,TypeToken> typeMap,
                         SqlTranslator sqlTranslator)

createSqlConditionOld

@Deprecated
public static SqlExpr createSqlConditionOld(com.hp.hpl.jena.sparql.expr.Expr condition,
                                       VarDefinition varDef,
                                       Map<String,TypeToken> typeMap,
                                       SqlTranslator sqlTranslator)

Deprecated.

joinDefinitionsOnEquals

public static org.aksw.sparqlify.core.algorithms.VarDefKey joinDefinitionsOnEquals(Collection<RestrictedExpr> a,
                                                                   Collection<RestrictedExpr> b,
                                                                   Map<String,TypeToken> typeMap,
                                                                   SqlTranslator sqlTranslator)

Joins two var definitions on the given queryVar.

Parameters:

queryVar -

a -

b -

sqlTranslator -

Returns:

joinDefinitionsOnEquals

public static org.aksw.sparqlify.core.algorithms.VarDefKey joinDefinitionsOnEquals(com.hp.hpl.jena.sparql.core.Var queryVar,
                                                                   ViewInstance<ViewDefinition> viewInstance,
                                                                   SqlTranslator sqlTranslator)

Returns a set of equals expressions, created from equating all pickDefs to the given varDefs The set is intended to be interpreted as a disjunction between the elements. Empty set therefore indicates "no constraint" null indicates "unsatisfiable constraint"

Parameters:

queryVar -

viewInstance -

Returns:

createEmptyMapping

public static Mapping createEmptyMapping()

createEmptyMapping

public static Mapping createEmptyMapping(ViewInstance<ViewDefinition> viewInstance)

createMapping

public Mapping createMapping(ViewInstance<ViewDefinition> viewInstance)

Creates a mapping from a view instance: - For every binding variable, that maps to multiple things (contants + variables), we need to equate all these things being mapped to Schematically, we need to transform the binding to variable definitions from the original structure (query view definition) q v d / dx1 ?x / \ dxn ?s \ / dy1 ?y \ dyn to conceptually a CNF: (dx1 = dy1 OR ... OR dx1 = dyn) AND ... AND (dxn = dy1 OR ... OR dxn = dyn) However, as equals is transitive and symmetric, it is sufficient to just pick the set of definitions for one view variable.

Specified by:

createMapping in interface MappingOps

Parameters:

generator -

viewInstance -

Returns:

doJoinRename

public Mapping doJoinRename(Mapping a,
                   Mapping b,
                   com.hp.hpl.jena.sdb.core.Generator gen)

Returns a new mapping for b: All column names that a and b have in commons are renamed in b.

Parameters:

a -

b -

Returns:

join

public Mapping join(Mapping a,
           Mapping b)

Specified by:

join in interface MappingOps

leftJoin

public Mapping leftJoin(Mapping a,
               Mapping b)

Specified by:

leftJoin in interface MappingOps

joinCommon

public Mapping joinCommon(Mapping a,
                 Mapping initB,
                 boolean isLeftJoin)

slice

public Mapping slice(Mapping a,
            Long limit,
            Long offset)

Specified by:

slice in interface MappingOps

limit - The limit. Null for no limit

offset - The offset. Null for no offset

Returns:

distinct

public Mapping distinct(Mapping a)

Specified by:

distinct in interface MappingOps

project

public Mapping project(Mapping a,
              List<com.hp.hpl.jena.sparql.core.Var> vars)

Removes variables from the definitions. Also projects away unreferenced columns in the sqlOp.

Specified by:

project in interface MappingOps

compactConjuction

public com.hp.hpl.jena.sparql.expr.ExprList compactConjuction(com.hp.hpl.jena.sparql.expr.ExprList exprs)

filter

public Mapping filter(Mapping a,
             com.hp.hpl.jena.sparql.expr.ExprList exprs)

Specified by:

filter in interface MappingOps

unionIfNeeded

public Mapping unionIfNeeded(List<Mapping> members)

removeEmptyMembers

public static List<Mapping> removeEmptyMembers(List<Mapping> mappings)

pushConstants

public static List<Mapping> pushConstants(List<Mapping> mappings)

pushConstants

public static Mapping pushConstants(Mapping mapping)

Pushes all constants of a given mapping's varDefinition into the SQL. Used for creating union's of mappings: By pushing variables into the SQL we do not have to deal with disjoint unions (i.e. unions with discriminator columns) in order to know which union member yields the constant.

Parameters:

mapping - The mapping to process.

Returns:

A new mapping with all constants pushed.

getReferencedColumnNames

public static Set<String> getReferencedColumnNames(List<Mapping> mappings)

union

public Mapping union(List<Mapping> members)

[ null, h: int, i: string, null ] [ a: int null, null, x: geo ] ?s = uri(concat("http://...", ?c1, ?c2)); ?s -> [c1: string, c2: int] with expr foo and restriction bar.

Specified by:

union in interface MappingOps

createBindingProduct

public static List<Map<com.hp.hpl.jena.sparql.core.Var,com.hp.hpl.jena.sparql.expr.Expr>> createBindingProduct(VarDefinition varDef,
                                                                                               Collection<com.hp.hpl.jena.sparql.core.Var> vars)

extend

public Mapping extend(Mapping a,
             VarDefinition varDef)

Extends a mapping with additional variable definitions. Ignore below for now. FIXME We need to introduce var orders in the var definitions, if extending may refer to other variables. Example: extend(?c = ?x) group (?s) (?x=(count))

Specified by:

extend in interface MappingOps

groupBy

public Mapping groupBy(Mapping a,
              com.hp.hpl.jena.sparql.core.VarExprList groupVars,
              List<com.hp.hpl.jena.sparql.expr.ExprAggregator> aggregators)

GroupBy

Specified by:

groupBy in interface MappingOps

groupByOld

public Mapping groupByOld(Mapping a,
                 com.hp.hpl.jena.sparql.core.VarExprList groupVars,
                 List<com.hp.hpl.jena.sparql.expr.ExprAggregator> aggregators)

aggregatorToFunction

public static com.hp.hpl.jena.sparql.expr.E_Function aggregatorToFunction(com.hp.hpl.jena.sparql.expr.aggregate.Aggregator agg)

Convert an aggregator to a function object. By this we can use the same infrastructure as being used for all other types of functions.

Parameters:

agg -

Returns:

getTypeSystem

public TypeSystem getTypeSystem()

TODO HACK Hacky function, get rid of it

rewrite

public static ExprSqlRewrite rewrite(Mapping mapping,
                     com.hp.hpl.jena.sparql.expr.aggregate.Aggregator agg,
                     com.hp.hpl.jena.sdb.core.Generator generator,
                     TypeSystem typeSystem,
                     SqlTranslator sqlTranslator)

TODO: Without the toDouble coercion, SUM(int) will be discarded even after already been found out as a candidate. However, an error should be raised. TODO: If there are no candidates (e.g. sum(?s) where ?s can only be resources), we get an incorrect error telling us that no candidate could be decided upon. However, there simple was no candidate to decide from.

Parameters:

mapping -

agg -

generator -

Returns:

rewriteOld

public ExprSqlRewrite rewriteOld(com.hp.hpl.jena.sdb.core.Gensym gensym,
                        com.hp.hpl.jena.sparql.expr.aggregate.Aggregator agg)

Returns a pair comprised of: - A SPARQL expression that references the SQL column of the aggregater - A projection // Ignore: the typeMap is implied by the projection - A type map

Parameters:

agg -

rewrite

public ExprSqlRewrite rewrite(com.hp.hpl.jena.sdb.core.Gensym gensym,
                     com.hp.hpl.jena.sparql.expr.aggregate.AggCount agg)

createExprContexts

public List<org.aksw.sparqlify.core.algorithms.SqlExprContext> createExprContexts(com.hp.hpl.jena.sparql.expr.Expr e,
                                                                         Mapping source)

unifyAlternatives

public ExprSqlRewrite unifyAlternatives(com.hp.hpl.jena.sparql.expr.Expr e,
                               Mapping source)

Two variants: - create a case-block for each expression - create a union - but with the union we would eval the expression over and over again - so we go with the case block

Parameters:

var -

target -

source -

order

public Mapping order(Mapping a,
            List<com.hp.hpl.jena.query.SortCondition> sortConditions)

FIXME The var definitions should not be lists rather than sets in order to ensure deterministic behaviour! 1. Expand mappings according to their var definitions, so that each mapping relates a variable only to a single expression. ?a = {uri(?name), plainLiteral(?id) -> Two mappings with ?a = uri(?name) and ?a = plainLiteral(?id) 2. Because we know that rdf terms are sorted by (blank node, uri, plain literals, typed literals) we can ensure this by Examples Order By ?p ?o Order By !Bound(?p)

Specified by:

order in interface MappingOps