de.fuberlin.wiwiss.d2rq.rdql
Class ExpressionTranslator

java.lang.Object
  extended by de.fuberlin.wiwiss.d2rq.rdql.ExpressionTranslator
Direct Known Subclasses:
MySQLExpressionTranslator

public class ExpressionTranslator
extends Object

Translates an RDQL expression into a SQL expression. The SQL expression that may be weaker than the RDQL expression. Idea: traverse the RDQL expression tree. If there is a mapping defined for an operator, translate its arguments, and construct the SQL term. Issues: 1) we must keep track of argument types, because a + might be a plus or a concatenate. 2) Negation turns weaker into stronger. 3) Some arguments in AND can be skipped (expression becomes weaker) 4) Translation of variables into Columns needs access to calling context (ConstraintHandler and SQLStatementMaker) TODO: split code into modules for 1) Query Language expressions 2) SQL dialects 3) Variable translators

Version:
$Id: ExpressionTranslator.java,v 1.21 2006/09/18 16:59:26 cyganiak Exp $
Author:
jgarbers

Nested Class Summary
static interface ExpressionTranslator.Result
          A Result is an auxiliary construct used with the ExpressionTranslator class only.
 
Field Summary
static int AnyType
           
static int BitType
           
static int BoolType
           
static String concatenateOp
           
static ExpressionTranslator.Result falseBuffer
           
static int LeftRightType
           
static int LeftType
           
static Collection logSqlExpressions
           
static int NoType
           
static int NumberType
           
static int RightType
           
static int SameType
           
static int StringType
           
static ExpressionTranslator.Result trueBuffer
           
static int UriType
           
 
Constructor Summary
ExpressionTranslator(ConstraintHandler handler, ConnectedDB database)
           
 
Method Summary
 ExpressionTranslator.Result castToString(ExpressionTranslator.Result r)
           
static String expressionToString(Expression e)
           
static void expressionToStringBuffer(Expression e, StringBuffer b, String indent)
           
static ExpressionTranslator.Result newResult(StringBuffer expr, int type)
           
static ExpressionTranslator.Result newResult(String expr, int type)
           
 ExpressionTranslator.Result translate(Expression.Variable var)
           
 ExpressionTranslator.Result translate(Expression e)
          Translates a Jena RDQL Expression into an SQL expression.
 ExpressionTranslator.Result translate(com.hp.hpl.jena.rdql.parser.ParsedLiteral e)
           
 ExpressionTranslator.Result translate(com.hp.hpl.jena.rdql.parser.Q_LogicalAnd e)
           
 ExpressionTranslator.Result translate(com.hp.hpl.jena.rdql.parser.Q_LogicalOr e)
           
 ExpressionTranslator.Result translate(com.hp.hpl.jena.rdql.parser.Q_UnaryNot e)
          is this really the logical Not or bit not or both?
 ExpressionTranslator.Result translate(com.hp.hpl.jena.rdql.parser.Q_Var var)
          translate a variable.
 ExpressionTranslator.Result translate(com.hp.hpl.jena.rdql.parser.WorkingVar var)
           
 ExpressionTranslator.Result translateAnd(com.hp.hpl.jena.rdql.parser.Q_LogicalAnd e)
           
 List translateArgs(Expression e, boolean strict, ExpressionTranslator.Result neutral)
          translates an RDQL expression
 ExpressionTranslator.Result translateBinary(de.fuberlin.wiwiss.d2rq.rdql.OperatorMap op, Expression e)
           
 ExpressionTranslator.Result translateColumn(Attribute col)
           
 ExpressionTranslator.Result translateExprVariable(Expression.Variable var)
           
 ExpressionTranslator.Result translateNode(Node n)
           
 ExpressionTranslator.Result translateNodeConstraint(NodeConstraintImpl c)
           
 ExpressionTranslator.Result translateNot(com.hp.hpl.jena.rdql.parser.Q_UnaryNot e)
           
 ExpressionTranslator.Result translateOr(com.hp.hpl.jena.rdql.parser.Q_LogicalOr e)
           
 ExpressionTranslator.Result translateParsedLiteral(com.hp.hpl.jena.rdql.parser.ParsedLiteral e)
           
 ExpressionTranslator.Result translatePattern(Pattern p)
           
 ExpressionTranslator.Result translateQ_Var(com.hp.hpl.jena.rdql.parser.Q_Var var)
           
 ExpressionTranslator.Result translateString(String s)
           
 ExpressionTranslator.Result translateString(String s, int resultType)
           
 String translateToString(Expression e)
           
 ExpressionTranslator.Result translateUnary(de.fuberlin.wiwiss.d2rq.rdql.OperatorMap op, Expression e)
          no operator checking is performed
 ExpressionTranslator.Result translateValue(com.hp.hpl.jena.rdql.parser.NodeValue val)
           
 ExpressionTranslator.Result translateVarName(String varName)
           
 ExpressionTranslator.Result translateWorkingVar(com.hp.hpl.jena.rdql.parser.WorkingVar var)
           
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

NoType

public static final int NoType
See Also:
Constant Field Values

BoolType

public static final int BoolType
See Also:
Constant Field Values

BitType

public static final int BitType
See Also:
Constant Field Values

StringType

public static final int StringType
See Also:
Constant Field Values

NumberType

public static final int NumberType
See Also:
Constant Field Values

UriType

public static final int UriType
See Also:
Constant Field Values

AnyType

public static final int AnyType
See Also:
Constant Field Values

LeftRightType

public static final int LeftRightType
See Also:
Constant Field Values

LeftType

public static final int LeftType
See Also:
Constant Field Values

RightType

public static final int RightType
See Also:
Constant Field Values

SameType

public static final int SameType
See Also:
Constant Field Values

logSqlExpressions

public static Collection logSqlExpressions

concatenateOp

public static final String concatenateOp
See Also:
Constant Field Values

trueBuffer

public static ExpressionTranslator.Result trueBuffer

falseBuffer

public static ExpressionTranslator.Result falseBuffer
Constructor Detail

ExpressionTranslator

public ExpressionTranslator(ConstraintHandler handler,
                            ConnectedDB database)
Method Detail

expressionToStringBuffer

public static void expressionToStringBuffer(Expression e,
                                            StringBuffer b,
                                            String indent)

expressionToString

public static String expressionToString(Expression e)

translateToString

public String translateToString(Expression e)

translate

public ExpressionTranslator.Result translate(Expression e)
Translates a Jena RDQL Expression into an SQL expression. We should try to resolve the strongest SQL condition possible. Maybe for each expression we should calculate both the strongest and the weakest condition, so that negation flips the meaning. There is one generic method for operators, that do not need special handling. For others, such as logical operators (and, or, not) and d2rq-map items (variables, values), there are custom methods that match by type.

Parameters:
e -
Returns:
null if no 1:1 translation possible.
See Also:
Expression

translateBinary

public ExpressionTranslator.Result translateBinary(de.fuberlin.wiwiss.d2rq.rdql.OperatorMap op,
                                                   Expression e)

translateUnary

public ExpressionTranslator.Result translateUnary(de.fuberlin.wiwiss.d2rq.rdql.OperatorMap op,
                                                  Expression e)
no operator checking is performed

Parameters:
op -
e -
Returns:
result

translate

public ExpressionTranslator.Result translate(com.hp.hpl.jena.rdql.parser.ParsedLiteral e)

translateParsedLiteral

public ExpressionTranslator.Result translateParsedLiteral(com.hp.hpl.jena.rdql.parser.ParsedLiteral e)

translateString

public ExpressionTranslator.Result translateString(String s)

translateString

public ExpressionTranslator.Result translateString(String s,
                                                   int resultType)

translate

public ExpressionTranslator.Result translate(com.hp.hpl.jena.rdql.parser.Q_Var var)
translate a variable. To translate a variable, we must either resolve its value or a reference to a column

Parameters:
var -
Returns:
translated variable

translateQ_Var

public ExpressionTranslator.Result translateQ_Var(com.hp.hpl.jena.rdql.parser.Q_Var var)

translate

public ExpressionTranslator.Result translate(Expression.Variable var)

translateExprVariable

public ExpressionTranslator.Result translateExprVariable(Expression.Variable var)

translate

public ExpressionTranslator.Result translate(com.hp.hpl.jena.rdql.parser.WorkingVar var)

translateWorkingVar

public ExpressionTranslator.Result translateWorkingVar(com.hp.hpl.jena.rdql.parser.WorkingVar var)

translateValue

public ExpressionTranslator.Result translateValue(com.hp.hpl.jena.rdql.parser.NodeValue val)

translateVarName

public ExpressionTranslator.Result translateVarName(String varName)

translateNodeConstraint

public ExpressionTranslator.Result translateNodeConstraint(NodeConstraintImpl c)

translateColumn

public ExpressionTranslator.Result translateColumn(Attribute col)

castToString

public ExpressionTranslator.Result castToString(ExpressionTranslator.Result r)

translatePattern

public ExpressionTranslator.Result translatePattern(Pattern p)

translateNode

public ExpressionTranslator.Result translateNode(Node n)

translateArgs

public List translateArgs(Expression e,
                          boolean strict,
                          ExpressionTranslator.Result neutral)
translates an RDQL expression

Parameters:
e - the RDQL expression
strict - if set, all arguments must be translatable to create a complex SQL expression
neutral - the neutral element of the current operation
Returns:
tranlated argument list

translate

public ExpressionTranslator.Result translate(com.hp.hpl.jena.rdql.parser.Q_LogicalAnd e)

translateAnd

public ExpressionTranslator.Result translateAnd(com.hp.hpl.jena.rdql.parser.Q_LogicalAnd e)

translate

public ExpressionTranslator.Result translate(com.hp.hpl.jena.rdql.parser.Q_LogicalOr e)

translateOr

public ExpressionTranslator.Result translateOr(com.hp.hpl.jena.rdql.parser.Q_LogicalOr e)

translate

public ExpressionTranslator.Result translate(com.hp.hpl.jena.rdql.parser.Q_UnaryNot e)
is this really the logical Not or bit not or both?


translateNot

public ExpressionTranslator.Result translateNot(com.hp.hpl.jena.rdql.parser.Q_UnaryNot e)

newResult

public static ExpressionTranslator.Result newResult(String expr,
                                                    int type)

newResult

public static ExpressionTranslator.Result newResult(StringBuffer expr,
                                                    int type)