Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor Class Reference

Inheritance diagram for Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor:

Classes
class	BinaryEvaluateInfo

Public Member Functions
	ExpressionEvaluatorVisitor (EvaluateContext context)
override SqlExpression	Visit (SqlExpression expression)
	Visits a given SQL expression. More...
override SqlExpression	VisitBinary (SqlBinaryExpression binaryEpression)
override SqlExpression	VisitCast (SqlCastExpression castExpression)
override SqlExpression	VisitFunctionCall (SqlFunctionCallExpression expression)
	Visits the expression that calls the function defined. More...
override SqlExpression	VisitQuery (SqlQueryExpression query)
override SqlExpression	VisitReference (SqlReferenceExpression reference)
override SqlExpression	VisitUnary (SqlUnaryExpression unary)
override SqlExpression	VisitAssign (SqlAssignExpression assign)
override SqlExpression	VisitTuple (SqlTupleExpression expression)
override SqlExpression	VisitVariableReference (SqlVariableReferenceExpression reference)
override SqlExpression	VisitConditional (SqlConditionalExpression conditional)
Public Member Functions inherited from Deveel.Data.Sql.Expressions.SqlExpressionVisitor
virtual SqlExpression[]	VisitExpressionList (SqlExpression[] list)
	Visits a list of expressions given. More...
virtual SqlExpression	VisitConstant (SqlConstantExpression constant)

Private Member Functions
SqlExpression	VisitQueryReference (QueryReferenceExpression expression)
SqlExpression[]	EvaluateSides (SqlBinaryExpression binary)
SqlExpression	EvaluateBinary (SqlExpression left, SqlExpressionType binaryType, SqlExpression right)
DataObject	EvaluateBinary (DataObject left, SqlExpressionType binaryType, DataObject right)
DataObject	EvaluateUnary (DataObject operand, SqlExpressionType unaryType)

Private Attributes
readonly EvaluateContext	context

Detailed Description

Definition at line 29 of file ExpressionEvaluatorVisitor.cs.

Constructor & Destructor Documentation

Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.ExpressionEvaluatorVisitor ( EvaluateContext  context )

inline

Definition at line 32 of file ExpressionEvaluatorVisitor.cs.

                                                                   {
            this.context = context;
        }

Member Function Documentation

SqlExpression Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.EvaluateBinary ( SqlExpression  left, SqlExpressionType  binaryType, SqlExpression  right  )

inlineprivate

Definition at line 64 of file ExpressionEvaluatorVisitor.cs.

                                                                                                                    {
            if (left.ExpressionType != SqlExpressionType.Constant)
                throw new ExpressionEvaluateException("The evaluated left side of a binary expression is not constant");
            if (right.ExpressionType != SqlExpressionType.Constant)
                throw new ExpressionEvaluateException("The evaluated right side of a binary expression is not constant.");

            var value1 = ((SqlConstantExpression) left).Value;
            var value2 = ((SqlConstantExpression) right).Value;

            var result = EvaluateBinary(value1, binaryType, value2);

            return SqlExpression.Constant(result);
        }

DataObject Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.EvaluateBinary ( DataObject  left, SqlExpressionType  binaryType, DataObject  right  )

inlineprivate

Definition at line 78 of file ExpressionEvaluatorVisitor.cs.

                                                                                                           {
            if (binaryType.IsAll())
                return left.Any(binaryType.SubQueryPlainType(), right, context);
            if (binaryType.IsAny())
                return left.All(binaryType.SubQueryPlainType(), right, context);

            switch (binaryType) {
                case SqlExpressionType.Add:
                    return left.Add(right);
                case SqlExpressionType.Subtract:
                    return left.Subtract(right);
                case SqlExpressionType.Multiply:
                    return left.Multiply(right);
                case SqlExpressionType.Divide:
                    return left.Divide(right);
                case SqlExpressionType.Modulo:
                    return left.Modulus(right);
                case SqlExpressionType.GreaterThan:
                    return left.IsGreaterThan(right);
                case SqlExpressionType.GreaterOrEqualThan:
                    return left.IsGreterOrEqualThan(right);
                case SqlExpressionType.SmallerThan:
                    return left.IsSmallerThan(right);
                case SqlExpressionType.SmallerOrEqualThan:
                    return left.IsSmallerOrEqualThan(right);
                case SqlExpressionType.Equal:
                    return left.IsEqualTo(right);
                case SqlExpressionType.NotEqual:
                    return left.IsNotEqualTo(right);
                case SqlExpressionType.Is:
                    return left.Is(right);
                case SqlExpressionType.IsNot:
                    return left.IsNot(right);
                case SqlExpressionType.Like:
                    return left.IsLike(right);
                case SqlExpressionType.NotLike:
                    return left.IsNotLike(right);
                case SqlExpressionType.And:
                    return left.And(right);
                case SqlExpressionType.Or:
                    return left.Or(right);
                case SqlExpressionType.XOr:
                    return left.XOr(right);
                // TODO: ANY and ALL
                default:
                    throw new ExpressionEvaluateException(String.Format("The type {0} is not a binary expression or is not supported.", binaryType));
            }
        }

SqlExpression [] Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.EvaluateSides ( SqlBinaryExpression  binary )

inlineprivate

Definition at line 49 of file ExpressionEvaluatorVisitor.cs.

                                                                          {
            var info = new List<BinaryEvaluateInfo> {
                new BinaryEvaluateInfo {Expression = binary.Left, Offset = 0},
                new BinaryEvaluateInfo {Expression = binary.Right, Offset = 1}
            }.OrderByDescending(x => x.Precedence);

            foreach (var evaluateInfo in info) {
                evaluateInfo.Expression = Visit(evaluateInfo.Expression);
            }

            return info.OrderBy(x => x.Offset)
                .Select(x => x.Expression)
                .ToArray();
        }

DataObject Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.EvaluateUnary ( DataObject  operand, SqlExpressionType  unaryType  )

inlineprivate

Definition at line 240 of file ExpressionEvaluatorVisitor.cs.

                                                                                          {
            switch (unaryType) {
                case SqlExpressionType.UnaryPlus:
                    return operand.Plus();
                case SqlExpressionType.Negate:
                case SqlExpressionType.Not:
                    return operand.Negate();
                default:
                    throw new ExpressionEvaluateException(String.Format("Expression of type '{0}' is not unary.", unaryType));
            }
        }

override SqlExpression Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.Visit ( SqlExpression  expression )

inlinevirtual

Visits a given SQL expression.

Parameters

expression

The SqlExpression to visit.

Returns

Returns an instance of SqlExpression as result of the visit.

Reimplemented from Deveel.Data.Sql.Expressions.SqlExpressionVisitor.

Definition at line 36 of file ExpressionEvaluatorVisitor.cs.

                                                                      {
            if (expression is QueryReferenceExpression)
                return VisitQueryReference((QueryReferenceExpression) expression);

            return base.Visit(expression);
        }

override SqlExpression Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.VisitAssign ( SqlAssignExpression  assign )

inlinevirtual

Parameters

assign

Returns

Reimplemented from Deveel.Data.Sql.Expressions.SqlExpressionVisitor.

Definition at line 252 of file ExpressionEvaluatorVisitor.cs.

                                                                              {
            if (context.Request == null)
                throw new ExpressionEvaluateException("Cannot assign a variable outside a query context.");

            var valueExpression = Visit(assign.ValueExpression);

            if (valueExpression.ExpressionType != SqlExpressionType.Constant)
                throw new ExpressionEvaluateException("Cannot assign a variable from a non constant value.");

            var reference = assign.ReferenceExpression;
            var value = ((SqlConstantExpression)valueExpression).Value;

            string variableName;

            if (reference is SqlVariableReferenceExpression) {
                variableName = ((SqlVariableReferenceExpression) reference).VariableName;
            } else if (reference is SqlReferenceExpression) {
                var refName = ((SqlReferenceExpression) reference).ReferenceName;
                if (refName.Parent != null)  // This might be the assignment to a complex type attribute
                    throw new NotSupportedException(string.Format("Reference to '{0}' is not supported.", refName));

                variableName = refName.Name;
            } else {
                throw new NotSupportedException();
            }

            try {
                context.Request.SetVariable(variableName, valueExpression);
            } catch (Exception ex) {
                throw new ExpressionEvaluateException(String.Format("Could not assign value to variable '{0}'", reference), ex);
            }


            return SqlExpression.Constant(value);
        }

override SqlExpression Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.VisitBinary ( SqlBinaryExpression  binaryEpression )

inlinevirtual

Parameters

binaryEpression

Returns

Reimplemented from Deveel.Data.Sql.Expressions.SqlExpressionVisitor.

Definition at line 127 of file ExpressionEvaluatorVisitor.cs.

                                                                                       {
            var sides = EvaluateSides(binaryEpression);

            var newLeft = sides[0];
            var newRight = sides[1];

            return EvaluateBinary(newLeft, binaryEpression.ExpressionType, newRight);
        }

override SqlExpression Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.VisitCast ( SqlCastExpression  castExpression )

inlinevirtual

Parameters

castExpression

Returns

Reimplemented from Deveel.Data.Sql.Expressions.SqlExpressionVisitor.

Definition at line 136 of file ExpressionEvaluatorVisitor.cs.

                                                                                  {
            var valueExp = Visit(castExpression.Value);
            if (valueExp.ExpressionType != SqlExpressionType.Constant)
                throw new ExpressionEvaluateException(String.Format("Cannot CAST an expression of type {0}.", valueExp.ExpressionType));

            var value = ((SqlConstantExpression) valueExp).Value;
            var casted = value.CastTo(castExpression.SqlType);
            return SqlExpression.Constant(casted);
        }

override SqlExpression Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.VisitConditional ( SqlConditionalExpression  conditional )

inlinevirtual

Parameters

conditional

Returns

Reimplemented from Deveel.Data.Sql.Expressions.SqlExpressionVisitor.

Definition at line 322 of file ExpressionEvaluatorVisitor.cs.

                                                                                             {
            var evalTest = Visit(conditional.TestExpression);
            if (evalTest.ExpressionType != SqlExpressionType.Constant)
                throw new ExpressionEvaluateException("The test expression of a conditional must evaluate to a constant value.");

            var evalTestValue = ((SqlConstantExpression) evalTest).Value;
            if (!(evalTestValue.Type is BooleanType))
                throw new ExpressionEvaluateException("The test expression of a conditional must be a boolean value.");

            if (evalTestValue)
                return Visit(conditional.TrueExpression);

            if (conditional.FalseExpression != null)
                return Visit(conditional.FalseExpression);

            return SqlExpression.Constant(PrimitiveTypes.Null());
        }

override SqlExpression Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.VisitFunctionCall ( SqlFunctionCallExpression  expression )

inlinevirtual

Visits the expression that calls the function defined.

Parameters

expression

The SqlFunctionCallExpression to visit.

Returns

Reimplemented from Deveel.Data.Sql.Expressions.SqlExpressionVisitor.

Definition at line 175 of file ExpressionEvaluatorVisitor.cs.

                                                                                              {
            try {
                var invoke = new Invoke(expression.FunctioName, expression.Arguments);
                IRequest request = null;
                IVariableResolver variableResolver = null;
                IGroupResolver groupResolver = null;
                if (context != null) {
                    request = context.Request;
                    variableResolver = context.VariableResolver;
                    groupResolver = context.GroupResolver;
                }

                // TODO: if we don't have a return value (PROCEDURES) what should w return?
                var result = invoke.Execute(request, variableResolver, groupResolver);
                if (!result.HasReturnValue)
                    return SqlExpression.Constant(DataObject.Null());

                return SqlExpression.Constant(result.ReturnValue);
            } catch (ExpressionEvaluateException) {
                throw;
            } catch (Exception ex) {
                throw new ExpressionEvaluateException(String.Format("Could not evaluate function expression '{0}' because of an error.", expression), ex);
            }
        }

override SqlExpression Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.VisitQuery ( SqlQueryExpression  query )

inlinevirtual

Parameters

query

Returns

Reimplemented from Deveel.Data.Sql.Expressions.SqlExpressionVisitor.

Definition at line 200 of file ExpressionEvaluatorVisitor.cs.

                                                                           {
            if (context.Request == null)
                throw new ExpressionEvaluateException("A query expression is required to evaluate a query.");

            try {
                var planner = context.Request.Context.QueryPlanner();
                var plan = planner.PlanQuery(new QueryInfo(context.Request, query));
                return SqlExpression.Constant(new DataObject(new QueryType(), new SqlQueryObject(plan)));
            } catch (ExpressionEvaluateException) {
                throw;
            } catch (Exception ex) {
                throw new ExpressionEvaluateException("Evaluation of a QUERY expression could not generate a plan.", ex);
            }
        }

SqlExpression Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.VisitQueryReference ( QueryReferenceExpression  expression )

inlineprivate

Definition at line 43 of file ExpressionEvaluatorVisitor.cs.

                                                                                       {
            var reference = expression.QueryReference;
            var value = reference.Evaluate(context.VariableResolver);
            return SqlExpression.Constant(value);
        }

override SqlExpression Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.VisitReference ( SqlReferenceExpression  reference )

inlinevirtual

Parameters

reference

Returns

Reimplemented from Deveel.Data.Sql.Expressions.SqlExpressionVisitor.

Definition at line 215 of file ExpressionEvaluatorVisitor.cs.

                                                                                       {
            var refName = reference.ReferenceName;

            if (context.VariableResolver == null)
                throw new ExpressionEvaluateException(String.Format("A resolver is required to dereference variable '{0}'.", refName));

            try {
                var value = context.VariableResolver.Resolve(refName);
                return SqlExpression.Constant(value);
            } catch (ExpressionEvaluateException) {
                throw;
            } catch (Exception ex) {
                throw new ExpressionEvaluateException(String.Format("An error occurred while trying to dereference '{0}' to a constant value", refName), ex);
            }
        }

override SqlExpression Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.VisitTuple ( SqlTupleExpression  expression )

inlinevirtual

Parameters

expression

Returns

Reimplemented from Deveel.Data.Sql.Expressions.SqlExpressionVisitor.

Definition at line 288 of file ExpressionEvaluatorVisitor.cs.

                                                                                {
            var list = expression.Expressions;
            if (list != null) {
                list = VisitExpressionList(list);
            }

            if (list == null)
                return SqlExpression.Constant(new DataObject(new ArrayType(-1), SqlArray.Null));

            // This is not an array, but a subquery
            if (list.Length == 1 &&
                list[0].ExpressionType == SqlExpressionType.Constant &&
                ((SqlConstantExpression)list[0]).Value.Type is QueryType)
                return list[0];

            return SqlExpression.Constant(new DataObject(new ArrayType(list.Length), new SqlArray(list)));
        }

override SqlExpression Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.VisitUnary ( SqlUnaryExpression  unary )

inlinevirtual

Parameters

unary

Returns

Reimplemented from Deveel.Data.Sql.Expressions.SqlExpressionVisitor.

Definition at line 231 of file ExpressionEvaluatorVisitor.cs.

                                                                           {
            var operand = Visit(unary.Operand);
            if (operand.ExpressionType != SqlExpressionType.Constant)
                throw new ExpressionEvaluateException("Operand of a unary operator could not be evaluated to a constant.");

            var result = EvaluateUnary(((SqlConstantExpression)operand).Value, unary.ExpressionType);
            return SqlExpression.Constant(result);
        }

override SqlExpression Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.VisitVariableReference ( SqlVariableReferenceExpression  reference )

inlinevirtual

Reimplemented from Deveel.Data.Sql.Expressions.SqlExpressionVisitor.

Definition at line 306 of file ExpressionEvaluatorVisitor.cs.

                                                                                                       {
            var refName = reference.VariableName;

            if (context.Request == null)
                throw new ExpressionEvaluateException(String.Format("Cannot dereference variable {0} outside a query context", refName));
            if (context.VariableResolver == null)
                throw new ExpressionEvaluateException("The query context does not handle variables.");

            
            var variable = context.Request.FindVariable(refName);
            if (variable == null)
                return SqlExpression.Constant(DataObject.Null());

            return SqlExpression.Constant(variable.Value);
        }

Member Data Documentation

readonly EvaluateContext Deveel.Data.Sql.Expressions.ExpressionEvaluatorVisitor.context

private

Definition at line 30 of file ExpressionEvaluatorVisitor.cs.

---

The documentation for this class was generated from the following file:

• /var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data.Sql.Expressions/ExpressionEvaluatorVisitor.cs

---

Generated by   1.8.10