protected SqlExpression(SqlExpressionType sqlNodeType, Type type)
: base()
{
SqlNodeType = sqlNodeType;
_type = type;
Operands = new List<Expression>();
}
private SqlBinaryExpression(SerializationInfo info, StreamingContext context)
: base(info, context)
{
Left = (SqlExpression)info.GetValue("Left", typeof(SqlExpression));
Right = (SqlExpression)info.GetValue("Right", typeof(SqlExpression));
expressionType = (SqlExpressionType) info.GetInt32("ExpressionType");
}
public JoinNode(IQueryPlanNode left, IQueryPlanNode right, ObjectName leftColumnName, SqlExpressionType @operator, SqlExpression rightExpression)
: base(left, right)
{
LeftColumnName = leftColumnName;
Operator = @operator;
RightExpression = rightExpression;
}
public SimpleSelectNode(IQueryPlanNode child, ObjectName columnName, SqlExpressionType op, SqlExpression expression)
: base(child)
{
ColumnName = columnName;
OperatorType = op;
Expression = expression;
}
private SqlBinaryExpression(SerializationInfo info, StreamingContext context)
: base(info, context)
{
Left = (SqlExpression)info.GetValue("Left", typeof(SqlExpression));
Right = (SqlExpression)info.GetValue("Right", typeof(SqlExpression));
expressionType = (SqlExpressionType)info.GetInt32("ExpressionType");
}
public static SqlBinaryExpression All(SqlExpression left, SqlExpressionType allType, SqlExpression right)
{
if (allType == SqlExpressionType.Equal ||
allType == SqlExpressionType.AllEqual)
{
return(AllEqual(left, right));
}
if (allType == SqlExpressionType.NotEqual ||
allType == SqlExpressionType.AllNotEqual)
{
return(AllNotEqual(left, right));
}
if (allType == SqlExpressionType.GreaterThan ||
allType == SqlExpressionType.AllGreaterThan)
{
return(AllGreaterThan(left, right));
}
if (allType == SqlExpressionType.SmallerThan ||
allType == SqlExpressionType.AllSmallerThan)
{
return(AllSmallerThan(left, right));
}
if (allType == SqlExpressionType.GreaterOrEqualThan ||
allType == SqlExpressionType.AllGreaterOrEqualThan)
{
return(AllGreaterOrEqualThan(left, right));
}
if (allType == SqlExpressionType.SmallerOrEqualThan ||
allType == SqlExpressionType.AllSmallerOrEqualThan)
{
return(AllSmallerOrEqualThan(left, right));
}
throw new ArgumentException(String.Format("The type '{0}' cannot be part of an ALL operator.", allType));
}
private void EvaluateSingles(List <SqlBinaryExpression> list, List <ExpressionPlan> plans)
{
// The list of simple expression plans (lhs = single)
var simplePlanList = new List <SingleColumnPlan>();
// The list of complex function expression plans (lhs = expression)
var complexPlanList = new List <SingleColumnPlan>();
foreach (var expression in list)
{
// The single var
ObjectName singleVar;
SqlExpressionType op = expression.ExpressionType;
SqlExpression left = expression.Left, right = expression.Right;
if (expression.Right is SqlQuantifiedExpression)
{
singleVar = expression.Left.AsReferenceName();
if (singleVar != null)
{
plans.Add(new SimpleSelectPlan(this, singleVar, op, expression.Right));
}
else
{
singleVar = expression.Left.DiscoverReferences().First();
plans.Add(new ComplexSinglePlan(this, singleVar, expression));
}
}
else
{
singleVar = expression.Left.DiscoverReferences().FirstOrDefault();
if (singleVar == null)
{
// Reverse the expressions and the operator
var tempExp = left;
left = right;
right = tempExp;
op = op.Reverse();
singleVar = left.DiscoverReferences().First();
}
var tableSource = FindPlan(singleVar);
// Simple LHS?
var v = left.AsReferenceName();
if (v != null)
{
AddSingleColumnPlan(simplePlanList, tableSource, v, singleVar, new [] { left, right }, op);
}
else
{
// No, complex lhs
AddSingleColumnPlan(complexPlanList, tableSource, null, singleVar, new [] { left, right }, op);
}
}
}
plans.AddRange(simplePlanList.Select(plan => new SimpleSinglePlan(this, plan.UniqueName, plan.Expression)).Cast <ExpressionPlan>());
plans.AddRange(complexPlanList.Select(plan => new ComplexSinglePlan(this, plan.UniqueName, plan.Expression)).Cast <ExpressionPlan>());
}
private SqlBinaryExpression(ObjectData data)
: base(data)
{
Left = data.GetValue<SqlExpression>("Left");
Right = data.GetValue<SqlExpression>("Right");
expressionType = (SqlExpressionType) data.GetInt32("ExpressionType");
}
public JoinNode(IQueryPlanNode left, IQueryPlanNode right, ObjectName leftColumnName, SqlExpressionType @operator, SqlExpression rightExpression)
: base(left, right)
{
LeftColumnName = leftColumnName;
Operator = @operator;
RightExpression = rightExpression;
}
public bool BinaryInfixTests(string infix, SqlExpressionType type)
{
var value =
_generator.GenerateSql(new SqlBinaryExpression(type, constants[0], constants[1]));
return($"(2 {infix} 5)" == value);
}
private SqlObject Relational(SqlExpressionType opType, SqlObject a, SqlObject b)
{
switch (opType)
{
case SqlExpressionType.Equal:
return(a.Equal(b));
case SqlExpressionType.NotEqual:
return(a.NotEqual(b));
case SqlExpressionType.GreaterThan:
return(a.GreaterThan(b));
case SqlExpressionType.LessThan:
return(a.LessThan(b));
case SqlExpressionType.GreaterThanOrEqual:
return(a.GreaterThanOrEqual(b));
case SqlExpressionType.LessThanOrEqual:
return(a.LessOrEqualThan(b));
case SqlExpressionType.Is:
return(a.Is(b));
case SqlExpressionType.IsNot:
return(a.IsNot(b));
default:
return(SqlObject.Unknown);
}
}
public NonCorrelatedAnyAllNode(IQueryPlanNode left, IQueryPlanNode right, ObjectName[] leftColumnNames, SqlExpressionType subQueryType, bool isAll)
: base(left, right)
{
LeftColumnNames = leftColumnNames;
SubQueryType = subQueryType;
IsAll = isAll;
}
public NonCorrelatedAnyAllNode(IQueryPlanNode left, IQueryPlanNode right, ObjectName[] leftColumnNames, SqlExpressionType subQueryType, bool isAll)
: base(left, right)
{
LeftColumnNames = leftColumnNames;
SubQueryType = subQueryType;
IsAll = isAll;
}
public SimpleSelectNode(IQueryPlanNode child, ObjectName columnName, SqlExpressionType op, SqlExpression expression)
: base(child)
{
ColumnName = columnName;
OperatorType = op;
Expression = expression;
}
public static SqlExpressionType Reverse(this SqlExpressionType type)
{
if (type == SqlExpressionType.Equal ||
type == SqlExpressionType.NotEqual ||
type == SqlExpressionType.Is ||
type == SqlExpressionType.IsNot)
{
return(type);
}
if (type == SqlExpressionType.GreaterThan)
{
return(SqlExpressionType.SmallerThan);
}
if (type == SqlExpressionType.SmallerThan)
{
return(SqlExpressionType.GreaterThan);
}
if (type == SqlExpressionType.GreaterOrEqualThan)
{
return(SqlExpressionType.SmallerOrEqualThan);
}
if (type == SqlExpressionType.SmallerOrEqualThan)
{
return(SqlExpressionType.GreaterOrEqualThan);
}
throw new InvalidOperationException("Cannot reverse a non conditional operator.");
}
public static SqlExpressionType All(this SqlExpressionType type)
{
if (type == SqlExpressionType.Equal)
{
return(SqlExpressionType.AllEqual);
}
if (type == SqlExpressionType.NotEqual)
{
return(SqlExpressionType.AllNotEqual);
}
if (type == SqlExpressionType.GreaterThan)
{
return(SqlExpressionType.AllGreaterThan);
}
if (type == SqlExpressionType.GreaterOrEqualThan)
{
return(SqlExpressionType.AllGreaterOrEqualThan);
}
if (type == SqlExpressionType.SmallerThan)
{
return(SqlExpressionType.AllSmallerThan);
}
if (type == SqlExpressionType.SmallerOrEqualThan)
{
return(SqlExpressionType.AllSmallerOrEqualThan);
}
throw new ArgumentException();
}
public static bool IsBinary(this SqlExpressionType expressionType)
{
switch (expressionType)
{
case SqlExpressionType.Add:
case SqlExpressionType.Subtract:
case SqlExpressionType.Divide:
case SqlExpressionType.Multiply:
case SqlExpressionType.Modulo:
case SqlExpressionType.And:
case SqlExpressionType.Or:
case SqlExpressionType.XOr:
case SqlExpressionType.Equal:
case SqlExpressionType.NotEqual:
case SqlExpressionType.GreaterThan:
case SqlExpressionType.GreaterThanOrEqual:
case SqlExpressionType.LessThan:
case SqlExpressionType.LessThanOrEqual:
case SqlExpressionType.Is:
case SqlExpressionType.IsNot:
return(true);
default:
return(false);
}
}
public static SqlExpressionType SubQueryPlainType(this SqlExpressionType type)
{
if (type.IsAny())
{
if (type == SqlExpressionType.AnyEqual)
{
return(SqlExpressionType.Equal);
}
if (type == SqlExpressionType.AnyNotEqual)
{
return(SqlExpressionType.NotEqual);
}
if (type == SqlExpressionType.AnyGreaterThan)
{
return(SqlExpressionType.GreaterThan);
}
if (type == SqlExpressionType.AnyGreaterOrEqualThan)
{
return(SqlExpressionType.GreaterOrEqualThan);
}
if (type == SqlExpressionType.AnySmallerThan)
{
return(SqlExpressionType.AnySmallerThan);
}
if (type == SqlExpressionType.AnySmallerOrEqualThan)
{
return(SqlExpressionType.SmallerOrEqualThan);
}
}
if (type.IsAll())
{
if (type == SqlExpressionType.AllEqual)
{
return(SqlExpressionType.Equal);
}
if (type == SqlExpressionType.AllNotEqual)
{
return(SqlExpressionType.NotEqual);
}
if (type == SqlExpressionType.AllGreaterThan)
{
return(SqlExpressionType.GreaterThan);
}
if (type == SqlExpressionType.AllGreaterOrEqualThan)
{
return(SqlExpressionType.GreaterOrEqualThan);
}
if (type == SqlExpressionType.AllSmallerThan)
{
return(SqlExpressionType.AllSmallerThan);
}
if (type == SqlExpressionType.AllSmallerOrEqualThan)
{
return(SqlExpressionType.SmallerOrEqualThan);
}
}
throw new ArgumentException();
}
private SqlBinaryExpression(ObjectData data)
: base(data)
{
Left = data.GetValue <SqlExpression>("Left");
Right = data.GetValue <SqlExpression>("Right");
expressionType = (SqlExpressionType)data.GetInt32("ExpressionType");
}
public static void ParseString(string s, SqlExpressionType expressionType)
{
var exp = SqlExpression.Parse(s);
Assert.NotNull(exp);
Assert.Equal(expressionType, exp.ExpressionType);
Assert.IsType <SqlBinaryExpression>(exp);
}
protected OperandsMutableSqlExpression(SqlExpressionType sqlExpressionType, Type type, IList <Expression> operands)
: base(sqlExpressionType, type)
{
if (operands != null)
{
this.Operands.AddRange(operands);
}
}
public void ParseUnaryString(string s, SqlExpressionType expressionType)
{
var exp = SqlExpression.Parse(context, s);
Assert.NotNull(exp);
Assert.Equal(expressionType, exp.ExpressionType);
Assert.IsType <SqlUnaryExpression>(exp);
}
public SimpleSelectPlan(QueryTablePlanner planner, ObjectName columnName, SqlExpressionType op, SqlExpression expression)
: base(0.2f)
{
this.planner = planner;
this.columnName = columnName;
this.op = op;
this.expression = expression;
}
public static SqlExpressionType Inverse(this SqlExpressionType type)
{
if (type.IsSubQuery())
{
var plainType = type.SubQueryPlainType();
var invType = plainType.Inverse();
if (type.IsAny())
{
return(invType.Any());
}
if (type.IsAll())
{
return(invType.All());
}
}
switch (type)
{
case SqlExpressionType.Equal:
return(SqlExpressionType.NotEqual);
case SqlExpressionType.NotEqual:
return(SqlExpressionType.Equal);
case SqlExpressionType.GreaterThan:
return(SqlExpressionType.SmallerOrEqualThan);
case SqlExpressionType.SmallerThan:
return(SqlExpressionType.GreaterOrEqualThan);
case SqlExpressionType.GreaterOrEqualThan:
return(SqlExpressionType.SmallerThan);
case SqlExpressionType.SmallerOrEqualThan:
return(SqlExpressionType.GreaterThan);
case SqlExpressionType.And:
return(SqlExpressionType.Or);
case SqlExpressionType.Or:
return(SqlExpressionType.And);
case SqlExpressionType.Like:
return(SqlExpressionType.NotLike);
case SqlExpressionType.NotLike:
return(SqlExpressionType.Like);
case SqlExpressionType.Is:
return(SqlExpressionType.IsNot);
case SqlExpressionType.IsNot:
return(SqlExpressionType.Is);
}
throw new ArgumentException();
}
public IndexRangeSet Intersect(SqlExpressionType op, DataObject value)
{
lock (this) {
int sz = ranges.Count;
var list = ranges.GetRange(0, sz);
if (op.IsSubQuery())
{
op = op.SubQueryPlainType();
}
if (op == SqlExpressionType.NotEqual ||
op == SqlExpressionType.IsNot)
{
bool nullCheck = op == SqlExpressionType.NotEqual;
int j = 0;
while (j < sz)
{
var range = list[j];
var leftRange = IntersectOn(range, SqlExpressionType.SmallerThan, value, nullCheck);
var rightRange = IntersectOn(range, SqlExpressionType.GreaterThan, value, nullCheck);
list.RemoveAt(j);
if (leftRange != IndexRange.Null)
{
list.Add(leftRange);
}
if (rightRange != IndexRange.Null)
{
list.Add(rightRange);
}
j++;
}
return(new IndexRangeSet(list));
}
else
{
bool nullCheck = op != SqlExpressionType.Is;
int j = 0;
while (j < sz)
{
var range = list[j];
range = IntersectOn(range, op, value, nullCheck);
if (range == IndexRange.Null)
{
list.RemoveAt(j);
}
else
{
list[j] = range;
}
j++;
}
return(new IndexRangeSet(list));
}
}
}
/// <summary>
/// Renders SqlExpression
/// </summary>
/// <param name="builder"></param>
/// <param name="expr"></param>
protected virtual void Expression(StringBuilder builder, SqlExpression expr)
{
SqlExpressionType type = expr.Type;
if (type == SqlExpressionType.Field)
{
QualifiedIdentifier(builder, expr.TableAlias, expr.Value.ToString());
}
else if (type == SqlExpressionType.Function)
{
Function(builder, expr.AggFunction, expr.SubExpr1);
}
else if (type == SqlExpressionType.Constant)
{
Constant(builder, (SqlConstant)expr.Value);
}
else if (type == SqlExpressionType.SubQueryText)
{
builder.AppendFormat("({0})", (string)expr.Value);
}
else if (type == SqlExpressionType.SubQueryObject)
{
builder.AppendFormat("({0})", RenderSelect((SelectQuery)expr.Value));
}
else if (type == SqlExpressionType.PseudoField)
{
builder.AppendFormat("{0}", (string)expr.Value);
}
else if (type == SqlExpressionType.Parameter)
{
builder.AppendFormat("{0}{1}", this.PrefixNamed, (string)expr.Value);
}
else if (type == SqlExpressionType.Raw)
{
builder.AppendFormat("{0}", (string)expr.Value);
}
else if (type == SqlExpressionType.Case)
{
CaseClause(builder, expr.CaseClause);
}
else if (type == SqlExpressionType.IfNull)
{
IfNull(builder, expr);
}
else if (type == SqlExpressionType.Null)
{
builder.Append("null");
}
else if (type == SqlExpressionType.Round)
{
Round(builder, expr);
}
else
{
throw new InvalidQueryException("Unkown expression type: " + type.ToString());
}
}
public async Task SimpleSelect(string column, SqlExpressionType op, object value, long expectedRowCount)
{
var columnName = new ObjectName(left.TableInfo.TableName, column);
var expression = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(value)));
var result = await left.SimpleSelectAsync(null, columnName, op, expression);
Assert.NotNull(result);
Assert.Equal(expectedRowCount, result.RowCount);
}
/// <summary>
/// Creates a new binary expression of the given type.
/// </summary>
/// <param name="expressionType">The type of the binary expression to be created</param>
/// <param name="left">The left as side of the binary expression</param>
/// <param name="right">The right as side of the binary expression</param>
/// <remarks>
/// <para>
/// The allowed binary <see cref="SqlExpressionType">expression types</see> are:
/// <list type="bullet">
/// <item><description><see cref="SqlExpressionType.Add"/></description></item>
/// <item><description><see cref="SqlExpressionType.Subtract"/></description></item>
/// <item><description><see cref="SqlExpressionType.Multiply"/></description></item>
/// <item><description><see cref="SqlExpressionType.Divide"/></description></item>
/// <item><description><see cref="SqlExpressionType.Modulo"/></description></item>
/// <item><description><see cref="SqlExpressionType.And"/></description></item>
/// <item><description><see cref="SqlExpressionType.Or"/></description></item>
/// <item><description><see cref="SqlExpressionType.XOr"/></description></item>
/// <item><description><see cref="SqlExpressionType.Equal"/></description></item>
/// <item><description><see cref="SqlExpressionType.NotEqual"/></description></item>
/// <item><description><see cref="SqlExpressionType.LessThan"/></description></item>
/// <item><description><see cref="SqlExpressionType.LessThanOrEqual"/></description></item>
/// <item><description><see cref="SqlExpressionType.GreaterThan"/></description></item>
/// <item><description><see cref="SqlExpressionType.GreaterThanOrEqual"/></description></item>
/// <item><description><see cref="SqlExpressionType.Is"/></description></item>
/// <item><description><see cref="SqlExpressionType.IsNot"/></description></item>
/// </list>
/// </para>
/// </remarks>
/// <returns>
/// Returns an instance of <see cref="SqlBinaryExpression"/> of the given
/// <paramref name="expressionType"/> and with the given operands.
/// </returns>
/// <exception cref="ArgumentException">If the given <paramref name="expressionType"/> is not a valid
/// binary type.</exception>
/// <exception cref="ArgumentNullException">If either <paramref name="left"/> or
/// <paramref name="right"/> is <c>null</c></exception>
/// <seealso cref="SqlExpressionType.Add"/>
/// <seealso cref="SqlExpressionType.Subtract"/>
/// <seealso cref="SqlExpressionType.Multiply"/>
/// <seealso cref="SqlExpressionType.Modulo"/>
/// <seealso cref="SqlExpressionType.Divide"/>
/// <seealso cref="SqlExpressionType.And"/>
/// <seealso cref="SqlExpressionType.Or"/>
/// <seealso cref="SqlExpressionType.XOr"/>
/// <seealso cref="SqlExpressionType.LessThan"/>
/// <seealso cref="SqlExpressionType.LessThanOrEqual"/>
/// <seealso cref="SqlExpressionType.GreaterThan"/>
/// <seealso cref="SqlExpressionType.GreaterThanOrEqual"/>
/// <seealso cref="SqlExpressionType.Is"/>
/// <seealso cref="SqlExpressionType.IsNot"/>
/// <seealso cref="SqlExpressionType.Equal"/>
/// <seealso cref="SqlExpressionType.NotEqual"/>
public static SqlBinaryExpression Binary(SqlExpressionType expressionType, SqlExpression left, SqlExpression right)
{
if (!expressionType.IsBinary())
{
throw new ArgumentException($"Expression type {expressionType} is not binary");
}
return(new SqlBinaryExpression(expressionType, left, right));
}
/// <summary>
/// Construtor completo.
/// </summary>
/// <param name="value">Expressão.</param>
/// <param name="type">Tipo da expressão.</param>
public SqlExpression(Expression value, SqlExpressionType type)
{
_type = type;
if (type == SqlExpressionType.Column && value.Length > 0 && (value.Text[0] == '?' || value.Text[0] == '@'))
{
_type = SqlExpressionType.Variable;
}
_value = value;
}
public void CreateInvalidQuantify(SqlExpressionType expressionType, SqlExpressionType opType)
{
var left = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(212)));
var right = SqlExpression.Constant(SqlObject.New(SqlValueUtil.FromObject(array)));
var binary = SqlExpression.Binary(opType, left, right);
Assert.Throws <ArgumentException>(() => SqlExpression.Quantify(expressionType, binary));
}
public static void CreateUnary(SqlExpressionType expressionType, object value)
{
var obj = SqlObject.New(SqlValueUtil.FromObject(value));
var operand = SqlExpression.Constant(obj);
var exp = SqlExpression.Unary(expressionType, operand);
Assert.NotNull(exp.Operand);
Assert.IsType <SqlConstantExpression>(exp.Operand);
}
public IExpressionBuilder Quantified(SqlExpressionType quantifyType, Action<IExpressionBuilder> exp)
{
var builder = new ExpressionBuilder();
exp(builder);
expression = SqlExpression.Quantified(quantifyType, builder.Build());
return this;
}
public static bool IsAll(this SqlExpressionType type)
{
return(type == SqlExpressionType.AllEqual ||
type == SqlExpressionType.AllNotEqual ||
type == SqlExpressionType.AllGreaterThan ||
type == SqlExpressionType.AllSmallerThan ||
type == SqlExpressionType.AllGreaterOrEqualThan ||
type == SqlExpressionType.AllSmallerOrEqualThan);
}
public static bool IsAny(this SqlExpressionType type)
{
return(type == SqlExpressionType.AnyEqual ||
type == SqlExpressionType.AnyNotEqual ||
type == SqlExpressionType.AnyGreaterThan ||
type == SqlExpressionType.AnySmallerThan ||
type == SqlExpressionType.AnyGreaterOrEqualThan ||
type == SqlExpressionType.AnySmallerOrEqualThan);
}
public Field All(SqlExpressionType type, Field other, EvaluateContext context)
{
if (IsNull)
{
return(this);
}
return(GroupOperatorHelper.EvaluateAll(type, this, other, context));
}
public static SqlUnaryExpression Unary(SqlExpressionType expressionType, SqlExpression operand)
{
if (!expressionType.IsUnary())
{
throw new ArgumentException($"Expression type {expressionType} is not unary");
}
return(new SqlUnaryExpression(expressionType, operand));
}
public static SqlQuantifyExpression Quantify(SqlExpressionType expressionType, SqlBinaryExpression expression)
{
if (!expressionType.IsQuantify())
{
throw new ArgumentException($"The expression type {expressionType} is not a quantification expression");
}
return(new SqlQuantifyExpression(expressionType, expression));
}
public static Field EvaluateAll(SqlExpressionType plainType, Field ob1, Field 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, context.Request);
}
// Clear the cache in the context
context.Request.Access().ClearCachedTables();
}
// Evaluate the plan,
var t = planObj.QueryPlan.Evaluate(context.Request);
var revPlainOp = plainType.Reverse();
return Field.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.
Field retVal = Field.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 = Field.BooleanNull;
} else if (!IsTrue(Evaluate(ob1, plainType, evalItem.Value, context/*, true, false*/))) {
// If it doesn't match return false
return Field.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.");
}
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.QueryContext.TableCache.Clear();
}
// Evaluate the plan,
var t = plan.Evaluate(context.QueryContext);
// 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.");
}
internal SqlBinaryExpression(SqlExpression left, SqlExpressionType expressionType, SqlExpression right)
{
if (left == null)
throw new ArgumentNullException("left");
if (right == null)
throw new ArgumentNullException("right");
this.expressionType = expressionType;
Left = left;
Right = right;
}
internal SqlQuantifiedExpression(SqlExpressionType type, SqlExpression value)
{
if (type != SqlExpressionType.All &&
type != SqlExpressionType.Any)
throw new ArgumentException("Invalid quantified type");
if (value == null)
throw new ArgumentNullException("value");
this.type = type;
ValueExpression = value;
}
public IExpressionBuilder Binary(SqlExpressionType binaryType, Action<IExpressionBuilder> right)
{
if (expression == null)
throw new InvalidOperationException();
var builder = new ExpressionBuilder();
right(builder);
expression = SqlExpression.Binary(expression, binaryType, builder.Build());
VerifyUnary();
return this;
}
public IndexRangeSet Intersect(SqlExpressionType op, DataObject value)
{
lock (this) {
int sz = ranges.Count;
var list = ranges.GetRange(0, sz);
if (op.IsSubQuery())
op = op.SubQueryPlainType();
if (op == SqlExpressionType.NotEqual ||
op == SqlExpressionType.IsNot) {
bool nullCheck = op == SqlExpressionType.NotEqual;
int j = 0;
while (j < sz) {
var range = list[j];
var leftRange = IntersectOn(range, SqlExpressionType.SmallerThan, value, nullCheck);
var rightRange = IntersectOn(range, SqlExpressionType.GreaterThan, value, nullCheck);
list.RemoveAt(j);
if (leftRange != IndexRange.Null) {
list.Add(leftRange);
}
if (rightRange != IndexRange.Null) {
list.Add(rightRange);
}
j++;
}
return new IndexRangeSet(list);
} else {
bool nullCheck = op != SqlExpressionType.Is;
int j = 0;
while (j < sz) {
var range = list[j];
range = IntersectOn(range, op, value, nullCheck);
if (range == IndexRange.Null) {
list.RemoveAt(j);
} else {
list[j] = range;
}
j++;
}
return new IndexRangeSet(list);
}
}
}
public SimpleSelectPlan(QueryTablePlanner planner, ObjectName columnName, SqlExpressionType op, SqlExpression expression)
: base(0.2f)
{
this.planner = planner;
this.columnName = columnName;
this.op = op;
this.expression = expression;
}
private DataObject EvaluateUnary(DataObject operand, SqlExpressionType unaryType)
{
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));
}
}
private SqlExpression EvaluateBinary(SqlExpression left, SqlExpressionType binaryType, SqlExpression right)
{
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);
}
private DataObject EvaluateBinary(DataObject left, SqlExpressionType binaryType, DataObject right)
{
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));
}
}
private static Field Evaluate(Field left, SqlExpressionType binaryType, Field right, EvaluateContext context/*, bool isAll, bool isAny*/)
{
//if (isAny)
// return left.Any(binaryType, right, context);
//if (isAll)
// return left.All(binaryType, 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 IExpressionBuilder Unary(SqlExpressionType unaryType)
{
prevUnaryType = unaryType;
return this;
}
private static string GetBinaryOperatorString(SqlExpressionType expressionType)
{
switch (expressionType) {
case SqlExpressionType.Add:
return "+";
case SqlExpressionType.Subtract:
return "-";
case SqlExpressionType.Divide:
return "/";
case SqlExpressionType.Multiply:
return "*";
case SqlExpressionType.Modulo:
return "%";
case SqlExpressionType.Equal:
return "=";
case SqlExpressionType.NotEqual:
return "<>";
case SqlExpressionType.GreaterThan:
return ">";
case SqlExpressionType.GreaterOrEqualThan:
return ">=";
case SqlExpressionType.SmallerThan:
return "<";
case SqlExpressionType.SmallerOrEqualThan:
return "<=";
case SqlExpressionType.Is:
return "IS";
case SqlExpressionType.IsNot:
return "IS NOT";
case SqlExpressionType.Like:
return "LIKE";
case SqlExpressionType.NotLike:
return "NOT LIKE";
case SqlExpressionType.AllEqual:
return "= ALL";
case SqlExpressionType.AllNotEqual:
return "<> ALL";
case SqlExpressionType.AllGreaterThan:
return "> ALL";
case SqlExpressionType.AllGreaterOrEqualThan:
return ">= ALL";
case SqlExpressionType.AllSmallerThan:
return "< ALL";
case SqlExpressionType.AllSmallerOrEqualThan:
return "<= ALL";
case SqlExpressionType.AnyEqual:
return "= ANY";
case SqlExpressionType.AnyNotEqual:
return "<> ANY";
case SqlExpressionType.AnyGreaterThan:
return "> ANY";
case SqlExpressionType.AnyGreaterOrEqualThan:
return ">= ANY";
case SqlExpressionType.AnySmallerThan:
return "< ANY";
case SqlExpressionType.AnySmallerOrEqualThan:
return "<= ANY";
case SqlExpressionType.Or:
return "OR";
case SqlExpressionType.And:
return "AND";
case SqlExpressionType.XOr:
return "XOR";
default:
throw new NotSupportedException();
}
}
private string GetUnaryOperatorString(SqlExpressionType unaryType)
{
switch (unaryType) {
case SqlExpressionType.UnaryPlus:
return "+";
case SqlExpressionType.Negate:
return "-";
case SqlExpressionType.Not:
return "NOT";
default:
throw new NotSupportedException();
}
}
public static IEnumerable<int> SelectRows(this ITable table, int[] columnOffsets, SqlExpressionType op,
DataObject[] values)
{
if (columnOffsets.Length > 1)
throw new NotSupportedException("Multi-column selects not supported yet.");
return SelectRows(table, columnOffsets[0], op, values[0]);
}
public static IEnumerable<int> SelectFromPattern(this ITable table, int column, SqlExpressionType op, DataObject ob)
{
if (ob.IsNull)
return new List<int>();
if (op == SqlExpressionType.NotLike) {
// How this works:
// Find the set or rows that are like the pattern.
// Find the complete set of rows in the column.
// Sort the 'like' rows
// For each row that is in the original set and not in the like set,
// add to the result list.
// Result is the set of not like rows ordered by the column.
var likeSet = (List<int>)table.Search(column, ob.ToString());
// Don't include NULL values
var nullCell = DataObject.Null(ob.Type);
IList<int> originalSet = table.SelectRows(column, SqlExpressionType.IsNot, nullCell).ToList();
int listSize = System.Math.Max(4, (originalSet.Count - likeSet.Count) + 4);
List<int> resultSet = new List<int>(listSize);
likeSet.Sort();
int size = originalSet.Count;
for (int i = 0; i < size; ++i) {
int val = originalSet[i];
// If val not in like set, add to result
if (likeSet.BinarySearch(val) == 0) {
resultSet.Add(val);
}
}
return resultSet;
}
// if (op.is("like")) {
return table.Search(column, ob.ToString());
}
public static ITable SelectAnyAllNonCorrelated(this ITable table, ObjectName[] leftColumns, SqlExpressionType op, ITable rightTable)
{
if (rightTable.TableInfo.ColumnCount != leftColumns.Length) {
throw new ArgumentException(String.Format("The right table has {0} columns that is different from the specified column names ({1})",
rightTable.TableInfo.ColumnCount, leftColumns.Length));
}
// Handle trivial case of no entries to select from
if (table.RowCount == 0)
return table;
// Resolve the vars in the left table and check the references are
// compatible.
var sz = leftColumns.Length;
var leftColMap = new int[sz];
var rightColMap = new int[sz];
for (int i = 0; i < sz; ++i) {
leftColMap[i] = table.FindColumn(leftColumns[i]);
rightColMap[i] = i;
if (leftColMap[i] == -1)
throw new Exception("Invalid reference: " + leftColumns[i]);
var leftType = table.TableInfo[leftColMap[i]].ColumnType;
var rightType = rightTable.TableInfo[i].ColumnType;
if (!leftType.IsComparable(rightType)) {
throw new ArgumentException(String.Format("The type of the sub-query expression {0}({1}) " +
"is not compatible with the sub-query type {2}.",
leftColumns[i], leftType, rightType));
}
}
IEnumerable<int> rows;
if (!op.IsSubQuery())
throw new ArgumentException(String.Format("The operator {0} is not a sub-query form.", op));
if (op.IsAll()) {
// ----- ALL operation -----
// We work out as follows:
// For >, >= type ALL we find the highest value in 'table' and
// select from 'source' all the rows that are >, >= than the
// highest value.
// For <, <= type ALL we find the lowest value in 'table' and
// select from 'source' all the rows that are <, <= than the
// lowest value.
// For = type ALL we see if 'table' contains a single value. If it
// does we select all from 'source' that equals the value, otherwise an
// empty table.
// For <> type ALL we use the 'not in' algorithm.
if (op == SqlExpressionType.AllGreaterThan ||
op == SqlExpressionType.AllGreaterOrEqualThan) {
// Select the last from the set (the highest value),
var highestCells = rightTable.GetLastValues(rightColMap);
// Select from the source table all rows that are > or >= to the
// highest cell,
rows = table.SelectRows(leftColMap, op, highestCells);
} else if (op == SqlExpressionType.AllSmallerThan ||
op == SqlExpressionType.AllSmallerOrEqualThan) {
// Select the first from the set (the lowest value),
var lowestCells = rightTable.GetFirstValues(rightColMap);
// Select from the source table all rows that are < or <= to the
// lowest cell,
rows = table.SelectRows(leftColMap, op, lowestCells);
} else if (op == SqlExpressionType.AllEqual) {
// Select the single value from the set (if there is one).
var singleCell = rightTable.GetSingleValues(rightColMap);
if (singleCell != null) {
// Select all from source_table all values that = this cell
rows = table.SelectRows(leftColMap, op, singleCell);
} else {
// No single value so return empty set (no value in LHS will equal
// a value in RHS).
return table.EmptySelect();
}
} else if (op == SqlExpressionType.AllNotEqual) {
// Equiv. to NOT IN
rows = table.SelectRowsNotIn(rightTable, leftColMap, rightColMap);
} else {
throw new ArgumentException(String.Format("Operator of type {0} is not valid in ALL functions.", op.SubQueryPlainType()));
}
} else {
// ----- ANY operation -----
// We work out as follows:
// For >, >= type ANY we find the lowest value in 'table' and
// select from 'source' all the rows that are >, >= than the
// lowest value.
// For <, <= type ANY we find the highest value in 'table' and
// select from 'source' all the rows that are <, <= than the
// highest value.
// For = type ANY we use same method from INHelper.
// For <> type ANY we iterate through 'source' only including those
// rows that a <> query on 'table' returns size() != 0.
if (op == SqlExpressionType.AnyGreaterThan ||
op == SqlExpressionType.AnyGreaterOrEqualThan) {
// Select the first from the set (the lowest value),
var lowestCells = rightTable.GetFirstValues(rightColMap);
// Select from the source table all rows that are > or >= to the
// lowest cell,
rows = table.SelectRows(leftColMap, op, lowestCells);
} else if (op == SqlExpressionType.AnySmallerThan ||
op == SqlExpressionType.AnySmallerOrEqualThan) {
// Select the last from the set (the highest value),
var highestCells = rightTable.GetLastValues(rightColMap);
// Select from the source table all rows that are < or <= to the
// highest cell,
rows = table.SelectRows(leftColMap, op, highestCells);
} else if (op == SqlExpressionType.AnyEqual) {
// Equiv. to IN
rows = table.SelectRowsIn(rightTable, leftColMap, rightColMap);
} else if (op == SqlExpressionType.AnyNotEqual) {
// Select the value that is the same of the entire column
var cells = rightTable.GetSingleValues(rightColMap);
if (cells != null) {
// All values from 'source_table' that are <> than the given cell.
rows = table.SelectRows(leftColMap, op, cells);
} else {
// No, this means there are different values in the given set so the
// query evaluates to the entire table.
return table;
}
} else {
throw new ArgumentException(String.Format("Operator of type {0} is not valid in ANY functions.", op.SubQueryPlainType()));
}
}
return new VirtualTable(table, rows.ToArray());
}
private static void AddSingleColumnPlan(IList<SingleColumnPlan> list, TablePlan table, ObjectName columnName, ObjectName uniqueName, SqlExpression[] expParts, SqlExpressionType op)
{
var exp = SqlExpression.Binary(expParts[0], op, expParts[1]);
// Is this source in the list already?
foreach (var existingPlan in list) {
if (existingPlan.TablePlan == table &&
(columnName == null || existingPlan.ColumnName.Equals(columnName))) {
// Append to end of current expression
existingPlan.SetSource(columnName, SqlExpression.And(existingPlan.Expression, exp));
return;
}
}
// Didn't find so make a new entry in the list.
list.Add(new SingleColumnPlan(table, columnName, uniqueName, exp));
}
public static bool AllRowsMatchColumnValue(this ITable table, int columnOffset, SqlExpressionType op, DataObject value)
{
var rows = table.SelectRows(columnOffset, op, value);
return rows.Count() == table.RowCount;
}
private static IndexRange IntersectOn(IndexRange range, SqlExpressionType op, Field value, bool nullCheck)
{
var start = range.StartValue;
var startPosition = range.StartOffset;
var end = range.EndValue;
var endPosition = range.EndOffset;
bool inclusive = op == SqlExpressionType.Is ||
op == SqlExpressionType.Equal ||
op == SqlExpressionType.GreaterOrEqualThan ||
op == SqlExpressionType.SmallerOrEqualThan;
if (op == SqlExpressionType.Is ||
op == SqlExpressionType.Equal ||
op == SqlExpressionType.GreaterThan ||
op == SqlExpressionType.GreaterOrEqualThan) {
// With this operator, NULL values must return null.
if (nullCheck && value.IsNull) {
return IndexRange.Null;
}
if (start.Equals(IndexRange.FirstInSet)) {
start = value;
startPosition = inclusive ? RangeFieldOffset.FirstValue : RangeFieldOffset.AfterLastValue;
} else {
int c = value.CompareTo(start);
if ((c == 0 && startPosition == RangeFieldOffset.FirstValue) || c > 0) {
start = value;
startPosition = inclusive ? RangeFieldOffset.FirstValue : RangeFieldOffset.AfterLastValue;
}
}
}
if (op == SqlExpressionType.Is ||
op == SqlExpressionType.Equal ||
op == SqlExpressionType.SmallerThan ||
op == SqlExpressionType.SmallerOrEqualThan) {
// With this operator, NULL values must return null.
if (nullCheck && value.IsNull) {
return IndexRange.Null;
}
// If start is first in set, then we have to change it to after NULL
if (nullCheck && start.Equals(IndexRange.FirstInSet)) {
start = Field.Null();
startPosition = RangeFieldOffset.AfterLastValue;
}
if (end.Equals(IndexRange.LastInSet)) {
end = value;
endPosition = inclusive ? RangeFieldOffset.LastValue : RangeFieldOffset.BeforeFirstValue;
} else {
int c = value.CompareTo(end);
if ((c == 0 && endPosition == RangeFieldOffset.LastValue) || c < 0) {
end = value;
endPosition = inclusive ? RangeFieldOffset.LastValue : RangeFieldOffset.BeforeFirstValue;
}
}
}
// If start and end are not null types (if either are, then it means it
// is a placeholder value meaning start or end of set).
if (!start.Equals(IndexRange.FirstInSet) &&
!end.Equals(IndexRange.LastInSet)) {
// If start is higher than end, return null
int c = start.CompareTo(end);
if ((c == 0 && (startPosition == RangeFieldOffset.AfterLastValue ||
endPosition == RangeFieldOffset.BeforeFirstValue)) ||
c > 0) {
return IndexRange.Null;
}
}
// The new intersected range
return new IndexRange(startPosition, start, endPosition, end);
}
internal SqlUnaryExpression(SqlExpressionType expressionType, SqlExpression operand)
{
this.expressionType = expressionType;
Operand = operand;
}
protected OperandsMutableSqlExpression(SqlExpressionType sqlExpressionType, Type type, IList<Expression> operands)
: base(sqlExpressionType, type)
{
if(operands !=null)
this.Operands.AddRange(operands);
}
private SqlUnaryExpression(ObjectData data)
: base(data)
{
Operand = data.GetValue<SqlExpression>("Operand");
expressionType = (SqlExpressionType) data.GetInt32("Operator");
}
