Uses of Class
org.d2rq.db.expr.Expression

Packages that use Expression
org.d2rq.algebra   
org.d2rq.db.expr   
org.d2rq.db.op   
org.d2rq.db.op.util   
org.d2rq.db.renamer   
org.d2rq.db.vendor   
org.d2rq.lang   
org.d2rq.nodes   
org.d2rq.values   
 

Uses of Expression in org.d2rq.algebra
 

Methods in org.d2rq.algebra with parameters of type Expression
static NodeRelation NodeRelationUtil.select(NodeRelation original, Expression expression)
           
 

Uses of Expression in org.d2rq.db.expr
 

Subclasses of Expression in org.d2rq.db.expr
 class Add
           
 class BinaryOperator
           
 class BooleanToIntegerCaseExpression
          A CASE statement that turns a BOOLEAN (TRUE, FALSE) into an INT (1, 0)
 class ColumnExpr
           
 class ColumnListEquality
          Compares two lists of columns in two tables.
 class Concatenation
           
 class Conjunction
           
 class Constant
          A constant-valued expression.
 class Disjunction
           
 class Divide
           
 class Equality
          An expression that is TRUE iff its two constituent expressions are true.
 class GreaterThan
           
 class GreaterThanOrEqual
           
 class LessThan
           
 class LessThanOrEqual
           
 class Multiply
           
 class Negation
          An expression that negates an underlying expression
 class NotNull
           
 class SQLExpression
          An Expression defined directly by a raw SQL string.
 class Subtract
           
 class UnaryMinus
           
 

Fields in org.d2rq.db.expr declared as Expression
protected  Expression BinaryOperator.expr1
           
protected  Expression BinaryOperator.expr2
           
static Expression Expression.FALSE
           
static Expression Expression.TRUE
           
 

Methods in org.d2rq.db.expr that return Expression
 Expression Expression.and(Expression other)
           
static Expression Disjunction.create(Collection<Expression> expressions)
           
static Expression Conjunction.create(Collection<Expression> expressions)
           
static Expression Concatenation.create(Expression... expressions)
           
static Expression NotNull.create(Expression expr)
           
static Expression Equality.create(Expression expr1, Expression expr2)
           
static Expression Disjunction.create(Expression expr1, Expression expr2)
           
static Expression Concatenation.create(List<Expression> expressions)
           
static Expression SQLExpression.create(String sql, DataType.GenericType dataType)
          Only usable for expressions that don't mention any columns
static Expression Equality.createColumnEquality(ColumnName column1, ColumnName column2)
           
static Expression Equality.createColumnValue(ColumnName column, String value, DataType dataType)
           
static Expression Equality.createExpressionValue(Expression expression, String value, DataType dataType)
           
 Expression UnaryMinus.getBase()
           
 Expression Negation.getBase()
           
 Expression BooleanToIntegerCaseExpression.getBase()
           
 Expression Expression.or(Expression other)
           
 Expression UnaryMinus.rename(Renamer columnRenamer)
           
 Expression Subtract.rename(Renamer columnRenamer)
           
 Expression SQLExpression.rename(Renamer renamer)
           
 Expression NotNull.rename(Renamer columnRenamer)
           
 Expression Negation.rename(Renamer columnRenamer)
           
 Expression Multiply.rename(Renamer columnRenamer)
           
 Expression LessThanOrEqual.rename(Renamer columnRenamer)
           
 Expression LessThan.rename(Renamer columnRenamer)
           
 Expression GreaterThanOrEqual.rename(Renamer columnRenamer)
           
 Expression GreaterThan.rename(Renamer columnRenamer)
           
abstract  Expression Expression.rename(Renamer columnRenamer)
           
 Expression Equality.rename(Renamer columnRenamer)
           
 Expression Divide.rename(Renamer columnRenamer)
           
 Expression Disjunction.rename(Renamer columnRenamer)
           
 Expression Constant.rename(Renamer columnRenamer)
           
 Expression Conjunction.rename(Renamer columnRenamer)
           
 Expression Concatenation.rename(Renamer columnRenamer)
           
 Expression ColumnListEquality.rename(Renamer renamer)
           
 Expression ColumnExpr.rename(Renamer columnRenamer)
           
 Expression BooleanToIntegerCaseExpression.rename(Renamer columnRenamer)
           
 Expression Add.rename(Renamer columnRenamer)
           
 

Methods in org.d2rq.db.expr with parameters of type Expression
 Expression Expression.and(Expression other)
           
static Expression Concatenation.create(Expression... expressions)
           
static Expression NotNull.create(Expression expr)
           
static Expression Equality.create(Expression expr1, Expression expr2)
           
static Expression Disjunction.create(Expression expr1, Expression expr2)
           
static Constant Constant.create(String value, Expression expressionForType)
           
static Expression Equality.createExpressionValue(Expression expression, String value, DataType dataType)
           
 Expression Expression.or(Expression other)
           
 

Method parameters in org.d2rq.db.expr with type arguments of type Expression
static Expression Disjunction.create(Collection<Expression> expressions)
           
static Expression Conjunction.create(Collection<Expression> expressions)
           
static Expression Concatenation.create(List<Expression> expressions)
           
 

Constructors in org.d2rq.db.expr with parameters of type Expression
Add(Expression expr1, Expression expr2)
           
BinaryOperator(Expression expr1, Expression expr2, String operator, boolean isCommutative, DataType.GenericType dataType)
           
BooleanToIntegerCaseExpression(Expression base)
           
Divide(Expression expr1, Expression expr2)
           
GreaterThan(Expression expr1, Expression expr2)
           
GreaterThanOrEqual(Expression expr1, Expression expr2)
           
LessThan(Expression expr1, Expression expr2)
           
LessThanOrEqual(Expression expr1, Expression expr2)
           
Multiply(Expression expr1, Expression expr2)
           
Negation(Expression base)
           
Subtract(Expression expr1, Expression expr2)
           
UnaryMinus(Expression base)
           
 

Uses of Expression in org.d2rq.db.op
 

Methods in org.d2rq.db.op that return Expression
 Expression SelectOp.getCondition()
           
 Expression ProjectionSpec.ExprProjectionSpec.getExpression()
           
 Expression OrderOp.OrderSpec.getExpression()
           
 

Methods in org.d2rq.db.op with parameters of type Expression
static ProjectionSpec ProjectionSpec.create(Expression expression, Vendor vendor)
          Creates a projection spec from an expression.
static DatabaseOp SelectOp.select(DatabaseOp original, Expression condition)
           
 

Constructors in org.d2rq.db.op with parameters of type Expression
OrderOp.OrderSpec(Expression expression)
           
OrderOp.OrderSpec(Expression expression, boolean ascending)
           
 

Uses of Expression in org.d2rq.db.op.util
 

Constructors in org.d2rq.db.op.util with parameters of type Expression
OpSelecter(DatabaseOp table, Expression expression)
           
 

Uses of Expression in org.d2rq.db.renamer
 

Methods in org.d2rq.db.renamer that return Expression
 Expression Renamer.applyTo(Expression original)
           
 

Methods in org.d2rq.db.renamer with parameters of type Expression
 Expression Renamer.applyTo(Expression original)
           
 

Uses of Expression in org.d2rq.db.vendor
 

Methods in org.d2rq.db.vendor that return Expression
 Expression Vendor.booleanExpressionToSimpleExpression(Expression expression)
          Turns a BOOLEAN expression into an expression that is guaranteed to be usable in any place where an expression is allowed.
 Expression SQL92.booleanExpressionToSimpleExpression(Expression expression)
          In most databases, we don't have to do anything because boolean expressions are allowed anywhere.
 Expression Oracle.booleanExpressionToSimpleExpression(Expression expression)
          Oracle doesn't actually support booolean expressions, except in a few places.
 Expression Vendor.getRowNumLimitAsExpression(int limit)
          Returns an expression for limiting the number of returned rows for engines that support this (ROWNUM <= n)
 Expression SQL92.getRowNumLimitAsExpression(int limit)
           
 Expression Oracle.getRowNumLimitAsExpression(int limit)
           
 

Methods in org.d2rq.db.vendor with parameters of type Expression
 Expression Vendor.booleanExpressionToSimpleExpression(Expression expression)
          Turns a BOOLEAN expression into an expression that is guaranteed to be usable in any place where an expression is allowed.
 Expression SQL92.booleanExpressionToSimpleExpression(Expression expression)
          In most databases, we don't have to do anything because boolean expressions are allowed anywhere.
 Expression Oracle.booleanExpressionToSimpleExpression(Expression expression)
          Oracle doesn't actually support booolean expressions, except in a few places.
 

Uses of Expression in org.d2rq.lang
 

Methods in org.d2rq.lang that return Expression
static Expression Microsyntax.parseSQLExpression(String expression, DataType.GenericType dataType)
          Parses a SQL expression, such as "table1.foo > 0", and returns a corresponding Expression.
 

Methods in org.d2rq.lang with parameters of type Expression
 void TabularBuilder.addCondition(Expression expression)
           
 

Uses of Expression in org.d2rq.nodes
 

Methods in org.d2rq.nodes with parameters of type Expression
 void NodeSetFilter.limitValuesToExpression(Expression expression)
          Limits this node set to nodes whose value matches the given SQL expression.
 

Uses of Expression in org.d2rq.values
 

Methods in org.d2rq.values that return Expression
 Expression TemplateValueMaker.toExpression()
           
 Expression BlankNodeIDValueMaker.toExpression()
           
 Expression ValueMaker.valueExpression(String value, DatabaseOp tabular, Vendor vendor)
          A SQL expression that selects only rows where this value maker produces the specified value.
 Expression TemplateValueMaker.valueExpression(String value, DatabaseOp table, Vendor vendor)
           
 Expression SQLExpressionValueMaker.valueExpression(String value, DatabaseOp table, Vendor vendor)
           
 Expression DecoratingValueMaker.valueExpression(String value, DatabaseOp table, Vendor vendor)
           
 Expression ColumnValueMaker.valueExpression(String value, DatabaseOp tabular, Vendor vendor)
           
 Expression BlankNodeIDValueMaker.valueExpression(String value, DatabaseOp table, Vendor vendor)
           
 Expression BaseIRIValueMaker.valueExpression(String value, DatabaseOp tabular, Vendor vendor)
           
 

Constructors in org.d2rq.values with parameters of type Expression
SQLExpressionValueMaker(Expression expression, Vendor vendor)