Deveel.Data.GroupOperatorHelper Class Reference

Static Public Member Functions
static DataObject	EvaluateAny (SqlExpressionType plainType, DataObject ob1, DataObject ob2, EvaluateContext context)
static DataObject	EvaluateAll (SqlExpressionType plainType, DataObject ob1, DataObject ob2, EvaluateContext context)

Static Private Member Functions
static bool	IsTrue (DataObject b)
static DataObject	Evaluate (DataObject left, SqlExpressionType binaryType, DataObject right, EvaluateContext context)

Detailed Description

Definition at line 27 of file GroupOperatorHelper.cs.

Member Function Documentation

static DataObject Deveel.Data.GroupOperatorHelper.Evaluate ( DataObject  left, SqlExpressionType  binaryType, DataObject  right, EvaluateContext  context  )

inlinestaticprivate

Definition at line 144 of file GroupOperatorHelper.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));
            }
        }

static DataObject Deveel.Data.GroupOperatorHelper.EvaluateAll ( SqlExpressionType  plainType, DataObject  ob1, DataObject  ob2, EvaluateContext  context  )

inlinestatic

Definition at line 88 of file GroupOperatorHelper.cs.

                                     {
            if (ob2.Type is QueryType) {
                // The sub-query plan
                var planObj = (SqlQueryObject) ob2.Value;

                // Discover the correlated variables for this plan.
                var list = planObj.QueryPlan.DiscoverQueryReferences(1);

                if (list.Count > 0) {
                    // Set the correlated variables from the IVariableResolver
                    foreach (var variable in list) {
                        variable.Evaluate(context.VariableResolver);
                    }

                    // Clear the cache in the context
                    context.Request.Query.ClearCachedTables();
                }

                // Evaluate the plan,
                var t = planObj.QueryPlan.Evaluate(context.Request);

                var revPlainOp = plainType.Reverse();
                return DataObject.Boolean(t.AllRowsMatchColumnValue(0, revPlainOp, ob1));
            }
            if (ob2.Type is ArrayType) {
                var expList = (SqlArray) ob2.Value;

                // Assume true unless otherwise found to be false or NULL.
                DataObject retVal = DataObject.BooleanTrue;
                foreach (var exp in expList) {
                    var expItem = exp.Evaluate(context);

                    if (expItem.ExpressionType != SqlExpressionType.Constant)
                        throw new InvalidOperationException();

                    var evalItem = (SqlConstantExpression)expItem;

                    // If there is a null item, we return null if not otherwise found to
                    // be false.
                    if (evalItem.Value.IsNull) {
                        retVal = DataObject.BooleanNull;
                    } else if (!IsTrue(Evaluate(ob1, plainType, evalItem.Value, context))) {
                        // If it doesn't match return false
                        return DataObject.BooleanFalse;
                    }
                }

                // Otherwise return true or null.  If all match and no NULLs return
                // true.  If all match and there are NULLs then return NULL.
                return retVal;
            }

            throw new InvalidOperationException("Unknown RHS of ALL.");
        }

static DataObject Deveel.Data.GroupOperatorHelper.EvaluateAny ( SqlExpressionType  plainType, DataObject  ob1, DataObject  ob2, EvaluateContext  context  )

inlinestatic

Definition at line 34 of file GroupOperatorHelper.cs.

                                                                                                                                   {
            if (ob2.Type is QueryType) {
                // The sub-query plan
                var plan = ((SqlQueryObject)ob2.Value).QueryPlan;
                // Discover the correlated variables for this plan.
                var list = plan.DiscoverQueryReferences(1);

                if (list.Count > 0) {
                    // Set the correlated variables from the IVariableResolver
                    foreach (var variable in list) {
                        variable.Evaluate(context.VariableResolver);
                    }

                    // Clear the cache in the context
                    context.Request.Query.ClearCachedTables();
                }

                // Evaluate the plan,
                var t = plan.Evaluate(context.Request);

                // The ANY operation
                var revPlainOp = plainType.Reverse();
                // TODO: return t.ColumnMatchesValue(0, revPlainOp, ob1);
                throw new NotImplementedException();
            }

            if (ob2.Type is ArrayType) {
                var expList = (SqlArray)ob2.Value;
                // Assume there are no matches
                var retVal = DataObject.BooleanFalse;
                foreach (var exp in expList) {
                    var expItem = exp.Evaluate(context);
                    if (expItem.ExpressionType != SqlExpressionType.Constant)
                        throw new InvalidOperationException();

                    var evalItem = (SqlConstantExpression) expItem;

                    // If null value, return null if there isn't otherwise a match found.
                    if (evalItem.Value.IsNull) {
                        retVal = DataObject.BooleanNull;
                    } else if (IsTrue(Evaluate(ob1, plainType, evalItem.Value, context))) {
                        // If there is a match, the ANY set test is true
                        return DataObject.BooleanTrue;
                    }
                }
                // No matches, so return either false or NULL.  If there are no matches
                // and no nulls, return false.  If there are no matches and there are
                // nulls present, return null.
                return retVal;
            }

            throw new InvalidOperationException("Unknown RHS of ANY.");
        }

static bool Deveel.Data.GroupOperatorHelper.IsTrue ( DataObject  b )

inlinestaticprivate

Definition at line 28 of file GroupOperatorHelper.cs.

                                                 {
            return (!b.IsNull &&
                    b.Type is BooleanType &&
                    b.Value.Equals(SqlBoolean.True));
        }

---

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

• /var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data/GroupOperatorHelper.cs