org.aksw.sparqlify.core.cast

Class TypedExprTransformerImpl

java.lang.Object

org.aksw.sparqlify.core.cast.TypedExprTransformerImpl

All Implemented Interfaces:

TypedExprTransformer

public class TypedExprTransformerImpl
extends Object
implements TypedExprTransformer

Computes the datatype of each expression node. TODO: I think this class should not actually transform expressions

Author:

Claus Stadler

Constructor Summary

Constructors

Constructor and Description
TypedExprTransformerImpl(TypeSystem typeSystem)

Method Summary

Methods

Modifier and Type	Method and Description
com.hp.hpl.jena.sparql.expr.ExprVar	allocateVariable(SqlExpr sqlExpr, org.aksw.sparqlify.core.cast.RewriteState state)
static boolean	containsTypeError(Iterable<SqlExpr> exprs)
static SqlExpr	createSqlExpr(CandidateMethod<TypeToken> candidate, List<SqlExpr> args)
static List<TypeToken>	getTypes(Collection<SqlExpr> sqlExprs)
SqlExpr	processFunction(String functionId, List<SqlExpr> newArgs)
org.aksw.sparqlify.core.cast.ExprHolder	rewrite(com.hp.hpl.jena.sparql.expr.ExprFunction fn, Map<String,TypeToken> typeMap, org.aksw.sparqlify.core.cast.RewriteState state)
ExprSqlRewrite	rewrite(com.hp.hpl.jena.sparql.expr.Expr expr, Map<String,TypeToken> typeMap)
org.aksw.sparqlify.core.cast.ExprHolder	rewrite(com.hp.hpl.jena.sparql.expr.Expr expr, Map<String,TypeToken> typeMap, org.aksw.sparqlify.core.cast.RewriteState state)
ExprSqlRewrite	rewriteOld(com.hp.hpl.jena.sparql.expr.Expr expr, Map<String,TypeToken> typeMap)
SqlExpr	translate(com.hp.hpl.jena.sparql.expr.ExprFunction fn, Map<String,TypeToken> typeMap) This function requires a type-constructor free expression as input: That is an expression that can be translated directly to SQL - i.e.
SqlExpr	translate(com.hp.hpl.jena.sparql.expr.Expr expr, Map<String,TypeToken> typeMap)
SqlExpr	translate(com.hp.hpl.jena.sparql.expr.ExprVar expr, Map<String,TypeToken> typeMap)
SqlExpr	translate(com.hp.hpl.jena.sparql.expr.NodeValue expr)

Methods inherited from class java.lang.Object

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

Constructor Detail

TypedExprTransformerImpl

public TypedExprTransformerImpl(TypeSystem typeSystem)

Method Detail

getTypes

public static List<TypeToken> getTypes(Collection<SqlExpr> sqlExprs)

containsTypeError

public static boolean containsTypeError(Iterable<SqlExpr> exprs)

allocateVariable

public com.hp.hpl.jena.sparql.expr.ExprVar allocateVariable(SqlExpr sqlExpr,
                                                   org.aksw.sparqlify.core.cast.RewriteState state)

rewrite

public ExprSqlRewrite rewrite(com.hp.hpl.jena.sparql.expr.Expr expr,
                     Map<String,TypeToken> typeMap)

Specified by:

rewrite in interface TypedExprTransformer

rewriteOld

public ExprSqlRewrite rewriteOld(com.hp.hpl.jena.sparql.expr.Expr expr,
                        Map<String,TypeToken> typeMap)

rewrite

public org.aksw.sparqlify.core.cast.ExprHolder rewrite(com.hp.hpl.jena.sparql.expr.Expr expr,
                                              Map<String,TypeToken> typeMap,
                                              org.aksw.sparqlify.core.cast.RewriteState state)

rewrite

public org.aksw.sparqlify.core.cast.ExprHolder rewrite(com.hp.hpl.jena.sparql.expr.ExprFunction fn,
                                              Map<String,TypeToken> typeMap,
                                              org.aksw.sparqlify.core.cast.RewriteState state)

processFunction

public SqlExpr processFunction(String functionId,
                      List<SqlExpr> newArgs)

createSqlExpr

public static SqlExpr createSqlExpr(CandidateMethod<TypeToken> candidate,
                    List<SqlExpr> args)

translate

public SqlExpr translate(com.hp.hpl.jena.sparql.expr.ExprFunction fn,
                Map<String,TypeToken> typeMap)

This function requires a type-constructor free expression as input: That is an expression that can be translated directly to SQL - i.e. all bnode/uri/literal type constructors have been removed from it TODO How to pass the type error to SPARQL functions, such as logical AND/OR/NOT, so they get a chance to deal with it? Using the SPARQL level evaluator is not really possible anymore, because we already translated to the SQL level. We could either: . have special treatment for logical and/or/not But then we can't extend the system to our liking . have an evaluator on the SqlExpr level, rather than the expr level Very generic, but can we avoid the duplication with Expr and SqlExpr? Probably we can't. The expr structure does not allow adding a custom datatype, and mapping it externally turned out to be quite a hassle.

Parameters:

fn -

binding -

typeMap -

Returns:

translate

public SqlExpr translate(com.hp.hpl.jena.sparql.expr.NodeValue expr)

translate

public SqlExpr translate(com.hp.hpl.jena.sparql.expr.ExprVar expr,
                Map<String,TypeToken> typeMap)

translate

public SqlExpr translate(com.hp.hpl.jena.sparql.expr.Expr expr,
                Map<String,TypeToken> typeMap)

Specified by:

translate in interface TypedExprTransformer