public static DataObject EvaluateAll(SqlExpressionType plainType, DataObject ob1, DataObject ob2, EvaluateContext context) { 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."); }
private static bool IsTrue(DataObject b) { return(!b.IsNull && b.Type is BooleanType && b.Value.Equals(SqlBoolean.True)); }
public static DataObject EvaluateAny(SqlExpressionType plainType, DataObject ob1, DataObject ob2, EvaluateContext context) { 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."); }
private static DataObject Evaluate(DataObject left, SqlExpressionType binaryType, DataObject right, EvaluateContext context) { 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)); } }
public override DataObject Evaluate(DataObject ob1, DataObject ob2, IGroupResolver group, IVariableResolver resolver, IQueryContext context) { return(ob1.Is(ob2)); }
public DataObject Evaluate(DataObject obj1, DataObject obj2) { return(Evaluate(obj1, obj2, null, null, null)); }
public abstract DataObject Evaluate(DataObject ob1, DataObject ob2, IGroupResolver group, IVariableResolver resolver, IQueryContext context);
public override DataObject Evaluate(DataObject ob1, DataObject ob2, IGroupResolver group, IVariableResolver resolver, IQueryContext context) { throw new ApplicationException("SimpleOperator should never be evaluated!"); }