public void Can_Read_Natural_Negated_Between_Expression()
{
var tokenizer = NewTokenizer("A.Field NOT BETWEEN 10 AND 20");
tokenizer.ReadNextToken();
ExpressionParser parser = new ExpressionParser(tokenizer);
// exercise
Expression expression = parser.Execute();
// verify
Assert.IsNotNull(expression);
Assert.IsTrue(expression is BetweenExpression);
BetweenExpression betweenExpression = (BetweenExpression)expression;
Expression expr = betweenExpression.Expression;
Assert.IsTrue(expr is IdentifierExpression);
Assert.AreEqual("A.Field", expr.Value);
Expression from = betweenExpression.From;
Assert.IsTrue(from is IdentifierExpression);
Assert.AreEqual("10", from.Value);
Expression to = betweenExpression.To;
Assert.IsTrue(to is IdentifierExpression);
Assert.AreEqual("20", to.Value);
}
public void TestCloneBetweenExpression()
{
BetweenExpression betweenExpression = new BetweenExpression()
{
Expression = new ColumnReference {
Identifiers = new List <string>()
{
"c1"
}
},
From = new IntegerLiteral()
{
Value = 3
},
To = new IntegerLiteral()
{
Value = 17
}
};
var clone = betweenExpression.Clone() as BetweenExpression;
Assert.AreEqual(betweenExpression, clone);
Assert.IsFalse(ReferenceEquals(betweenExpression, clone));
Assert.IsFalse(ReferenceEquals(betweenExpression.Expression, clone.Expression));
Assert.IsFalse(ReferenceEquals(betweenExpression.From, clone.From));
Assert.IsFalse(ReferenceEquals(betweenExpression.To, clone.To));
}
public QueryBuilder <T> Between(object lo, object hi)
{
AbstractCriterion betweenExpression = new BetweenExpression(name, lo, hi);
AddCriterion(betweenExpression);
return(this);
}
public virtual void VisitBetweenExpression(BetweenExpression betweenExpression)
{
Visit(betweenExpression.Expression);
Visit(betweenExpression.From);
Visit(betweenExpression.To);
//DONE
}
public void TestBetweenExpressionAccept()
{
Mock <KoraliumSqlVisitor> mock = new Mock <KoraliumSqlVisitor>();
BetweenExpression betweenExpression = new BetweenExpression();
betweenExpression.Accept(mock.Object);
mock.Verify(x => x.VisitBetweenExpression(betweenExpression));
}
protected BetweenExpression UpdateBetween(BetweenExpression between, Expression expression, Expression lower, Expression upper)
{
if (expression != between.Expression || lower != between.Lower || upper != between.Upper)
{
return new BetweenExpression(expression, lower, upper);
}
return between;
}
/// <summary>
/// Visits the between.
/// </summary>
/// <param name="between">The between.</param>
/// <returns></returns>
protected override Expression VisitBetween(BetweenExpression between)
{
this.VisitValue(between.Expression);
this.Write(" BETWEEN ");
this.VisitValue(between.Lower);
this.Write(" AND ");
this.VisitValue(between.Upper);
return(between);
}
private void WriteBetweenExpression(BetweenExpression e)
{
WriteName(e.Expression.Name);
sb.Append(" between ");
Write(e.Start);
sb.Append(" and ");
Write(e.End);
}
private void WriteBetweenExpression(BetweenExpression e)
{
WriteName(e.Property.ToString());
sb.Append(" between ");
WriteValue(e.Start);
sb.Append(" and ");
WriteValue(e.End);
}
/// <summary>
///
/// </summary>
/// <param name="select"></param>
/// <returns></returns>
protected override Expression VisitSelect(SelectExpression select)
{
switch (_dataType)
{
case Nequeo.Data.DataType.ConnectionContext.ConnectionDataType.OracleDataType:
case Nequeo.Data.DataType.ConnectionContext.ConnectionDataType.SqlDataType:
select = (SelectExpression)base.VisitSelect(select);
if (select.Skip != null)
{
SelectExpression newSelect = select.SetSkip(null).SetTake(null);
bool canAddColumn = !select.IsDistinct && (select.GroupBy == null || select.GroupBy.Count == 0);
if (!canAddColumn)
{
newSelect = newSelect.AddRedundantSelect(new TableAlias());
}
newSelect = newSelect.AddColumn(new ColumnDeclaration("ROW_NUM", new RowNumberExpression(select.OrderBy)));
// add layer for WHERE clause that references new rownum column
newSelect = newSelect.AddRedundantSelect(new TableAlias());
newSelect = newSelect.RemoveColumn(newSelect.Columns[newSelect.Columns.Count - 1]);
var newAlias = ((SelectExpression)newSelect.From).Alias;
ColumnExpression rnCol = new ColumnExpression(typeof(int), newAlias, "ROW_NUM");
Expression where;
if (select.Take != null)
{
where = new BetweenExpression(rnCol, Expression.Add(select.Skip, Expression.Constant(1)), Expression.Add(select.Skip, select.Take));
}
else
{
where = Expression.GreaterThan(rnCol, select.Skip);
}
if (newSelect.Where != null)
{
where = Expression.And(newSelect.Where, where);
}
newSelect = newSelect.SetWhere(where);
select = newSelect;
}
return(select);
default:
select = (SelectExpression)base.VisitSelect(select);
if (select.Skip != null)
{
SelectExpression newSelect = select.SetSkip(select.Skip).SetTake(select.Take);
select = newSelect;
}
return(select);
}
}
private BetweenExpression ProcessBetween(Expression parent, Expression expression)
{
BetweenExpression betweenExpression = new BetweenExpression(parent);
betweenExpression.Expression = expression;
betweenExpression.From = ReadCriteria(betweenExpression);
ExpectToken(Constants.And);
betweenExpression.To = ReadCriteria(betweenExpression);
return(betweenExpression);
}
public void BetweenInclusiveHigher_MissingAtSymb()
{
BetweenExpression <string> expression = null;
Dictionary <string, object> parameters = null;
string whereParam = null;
expression = Expression.BetweenInclusiveHigher("a", "b");
parameters = expression.GetDynamicParameters("p1");
whereParam = expression.ToSqlExpression("[Table].[Field]", "p1");
Console.WriteLine(String.Join(",", parameters.Keys));
Assert.AreEqual(parameters["p1___LOW"], "a");
Assert.AreEqual(parameters["p1___HIGH"], "b");
Assert.AreEqual(whereParam, " and [Table].[Field] > @p1___LOW and [Table].[Field] <= @p1___HIGH");
}
protected override Expression VisitSelect(SelectExpression select)
{
select = (SelectExpression)base.VisitSelect(select);
if (select.Skip != null)
{
SelectExpression newSelect = select.SetSkip(null).SetTake(null);
bool canAddColumn = !select.IsDistinct && (select.GroupBy == null || select.GroupBy.Count == 0);
if (!canAddColumn)
{
newSelect = newSelect.AddRedundantSelect(new TableAlias());
}
var colType = DbTypeSystem.GetColumnType(typeof(int));
newSelect = newSelect.AddColumn(new ColumnDeclaration(columnName, new RowNumberExpression(select.OrderBy), colType));
// add layer for WHERE clause that references new rownum column
newSelect = newSelect.AddRedundantSelect(new TableAlias());
newSelect = newSelect.RemoveColumn(newSelect.Columns.Single(c => c.Name == columnName));
var newAlias = ((SelectExpression)newSelect.From).Alias;
ColumnExpression rnCol = new ColumnExpression(typeof(int), colType, newAlias, columnName);
Expression where;
if (select.Take != null)
{
where = new BetweenExpression(
rnCol, Expression.Add(select.Skip, Expression.Constant(1)), Expression.Add(select.Skip, select.Take));
}
else
{
where = rnCol.GreaterThan(select.Skip);
}
if (newSelect.Where != null)
{
where = newSelect.Where.And(where);
}
newSelect = newSelect.SetWhere(where);
select = newSelect;
}
return select;
}
protected override Expression VisitSelect(SelectExpression select)
{
select = (SelectExpression)base.VisitSelect(select);
if (select.Skip != null)
{
var newSelect = select.SetSkip(null).SetTake(null).AddRedundantSelect(_language, new TableAlias());
_hasRowNumberExpression = true;
var colType = _language.TypeSystem.GetColumnType(typeof(int));
newSelect = newSelect.AddColumn(new ColumnDeclaration("rownum", new RowNumberExpression(select.OrderBy), colType));
// add layer for WHERE clause that references new rownum column
newSelect = newSelect.AddRedundantSelect(_language, new TableAlias());
newSelect = newSelect.RemoveColumn(newSelect.Columns.Single(c => c.Name == "rownum"));
var newAlias = ((SelectExpression)newSelect.From).Alias;
var rowNumberColumn = new ColumnExpression(typeof(int), colType, newAlias, "rownum");
Expression where;
if (select.Take != null)
{
where = new BetweenExpression(rowNumberColumn, Expression.Add(select.Skip, Expression.Constant(1)), Expression.Add(select.Skip, select.Take));
}
else
{
where = rowNumberColumn.GreaterThan(select.Skip);
}
if (newSelect.Where != null)
{
where = newSelect.Where.And(where);
}
newSelect = newSelect.SetWhere(where);
select = newSelect;
}
return(select);
}
protected override Expression VisitSelect(SelectExpression select)
{
select = (SelectExpression)base.VisitSelect(select);
if (select.Skip != null)
{
SelectExpression newSelect = select.SetSkip(null).SetTake(null);
bool canAddColumn = !select.IsDistinct && (select.GroupBy == null || select.GroupBy.Count == 0);
if (!canAddColumn)
{
newSelect = newSelect.AddRedundantSelect(new TableAlias());
}
newSelect = newSelect.AddColumn(new ColumnDeclaration(COLUMN_NAME, new RowNumberExpression(select.OrderBy)));
// add layer for WHERE clause that references new rownum column
newSelect = newSelect.AddRedundantSelect(new TableAlias());
newSelect = newSelect.RemoveColumn(newSelect.Columns.Single(c => c.Name == COLUMN_NAME));
var newAlias = ((SelectExpression)newSelect.From).Alias;
ColumnExpression rnCol = new ColumnExpression(typeof(int), newAlias, COLUMN_NAME, null);
Expression where;
if (select.Take != null)
{
where = new BetweenExpression(rnCol, Expression.Add(select.Skip, Expression.Constant(1)), Expression.Add(select.Skip, select.Take));
}
else
{
where = rnCol.GreaterThan(select.Skip);
}
if (newSelect.Where != null)
{
where = newSelect.Where.And(where);
}
newSelect = newSelect.SetWhere(where);
select = newSelect;
}
return(select);
}
public void TestVisitBetweenExpression()
{
Mock <ScalarExpression> expMock = new Mock <ScalarExpression>();
Mock <ScalarExpression> fromMock = new Mock <ScalarExpression>();
Mock <ScalarExpression> toMock = new Mock <ScalarExpression>();
BetweenExpression betweenExpression = new BetweenExpression()
{
Expression = expMock.Object,
From = fromMock.Object,
To = toMock.Object
};
KoraliumSqlVisitor koraliumSqlVisitor = new KoraliumSqlVisitor();
koraliumSqlVisitor.Visit(betweenExpression);
expMock.Verify(x => x.Accept(koraliumSqlVisitor));
fromMock.Verify(x => x.Accept(koraliumSqlVisitor));
toMock.Verify(x => x.Accept(koraliumSqlVisitor));
}
protected override Expression VisitSelect(SelectExpression select)
{
select = (SelectExpression)base.VisitSelect(select);
if (select.Skip != null) {
var newSelect = select.SetSkip(null).SetTake(null).AddRedundantSelect(_language, new TableAlias());
_hasRowNumberExpression = true;
var colType = _language.TypeSystem.GetColumnType(typeof(int));
newSelect = newSelect.AddColumn(new ColumnDeclaration("rownum", new RowNumberExpression(select.OrderBy), colType));
// add layer for WHERE clause that references new rownum column
newSelect = newSelect.AddRedundantSelect(_language, new TableAlias());
newSelect = newSelect.RemoveColumn(newSelect.Columns.Single(c => c.Name == "rownum"));
var newAlias = ((SelectExpression)newSelect.From).Alias;
var rowNumberColumn = new ColumnExpression(typeof(int), colType, newAlias, "rownum");
Expression where;
if (select.Take != null) {
where = new BetweenExpression(rowNumberColumn, Expression.Add(select.Skip, Expression.Constant(1)), Expression.Add(select.Skip, select.Take));
}
else {
where = rowNumberColumn.GreaterThan(select.Skip);
}
if (newSelect.Where != null) {
where = newSelect.Where.And(where);
}
newSelect = newSelect.SetWhere(where);
select = newSelect;
}
return select;
}
private List <TB_EXPENSE> Query()
{
List <TB_EXPENSE> rtn = null;
try
{
List <ICriterion> IClist = new List <ICriterion>();
//IClist.Add(new EqExpression("OPNAME", usercode));
IClist.Add(new EqExpression("STATUS", 1));
//IClist.Add(new EqExpression("OBJECTID", objectId));
if (txtProj.Tag != null)
{
IClist.Add(new EqExpression("OBJECTID", (txtProj.Tag as TB_PROJECT).Id));
}
if (cmbExpenseType.SelectedIndex > 0)
{
IClist.Add(new EqExpression("EXPENSETYPE", (cmbExpenseType.SelectedItem as PTS_TABLE_SRC).ID));
}
if (chk.IsChecked == true)
{
BetweenExpression and1 = new BetweenExpression("CREATEDATE", dtpBeginDate.DateTime, DateTime.Parse(dtpEndDate.DateTime.ToString("yyyy-MM-dd 23:59:59")));
IClist.Add(and1);
}
if (txtUser.Tag != null)
{
IClist.Add(new EqExpression("OPNAME", (txtUser.Tag as TB_User).USER_CODE));
}
TB_EXPENSE[] arr = TB_EXPENSEDAO.FindAll(IClist.ToArray());
if (arr != null && arr.Length > 0)
{
rtn = new List <TB_EXPENSE>(arr);
}
}
catch (Exception ex)
{
MessageHelper.ShowMessage(ex.Message);
}
return(rtn);
}
/*
* BNF:
* <expression> ::=
* <logical and expression> <logical operator clause list>
*
* <logical operator clause> ::=
* <logical ternary clause> |
* <logical binary clause>
*
* <logical ternary clause> ::=
* <logical ternary operator> <additive expression> and <additive expression>
*
* <logical ternary operator> ::=
* between
*
* <logical binary clause> ::=
* <logical binary operator> <logical and expression>
*
* <logical binary operator> ::=
* in | or | xor | like | matches
*/
protected Expression Expression(Lexer lexer)
{
Expression localExpression = LogicalAndExpression(lexer);
while (IsLogicalOperator(lexer.PeekTokenSymbol(1)))
{
if (lexer.PeekTokenSymbol(1) == Keywords.Between)
{
lexer.NextToken();
BetweenExpression LBetweenExpression = new BetweenExpression();
LBetweenExpression.Expression = localExpression;
LBetweenExpression.LowerExpression = AdditiveExpression(lexer);
lexer.NextToken().CheckSymbol(Keywords.And);
LBetweenExpression.UpperExpression = AdditiveExpression(lexer);
localExpression = LBetweenExpression;
}
else
{
BinaryExpression binaryExpression = new BinaryExpression();
binaryExpression.LeftExpression = localExpression;
switch (lexer.NextToken().Token)
{
case Keywords.In: binaryExpression.Instruction = Instructions.In; break;
case Keywords.Or: binaryExpression.Instruction = Instructions.Or; break;
case Keywords.Xor: binaryExpression.Instruction = Instructions.Xor; break;
case Keywords.Like: binaryExpression.Instruction = Instructions.Like; break;
case Keywords.Matches: binaryExpression.Instruction = Instructions.Matches; break;
}
binaryExpression.RightExpression = LogicalAndExpression(lexer);
localExpression = binaryExpression;
}
}
return(localExpression);
}
/// <summary>
/// 线路工程查询
/// </summary>
/// <param name="objectName">工程名称</param>
/// <param name="leaderName">工程负责人</param>
/// <param name="projectType">工程类型</param>
/// <param name="start">工期开始时间</param>
/// <param name="end">工期结束时间</param>
/// <returns></returns>
public static List <TB_PROJECT> QueryProject(string projName, string leader, string projectType, DateTime?start = null, DateTime?end = null)
{
List <TB_PROJECT> list = new List <TB_PROJECT>();
try
{
List <ICriterion> IClist = new List <ICriterion>();
IClist.Add(new EqExpression("STATUS", 1));
if (!string.IsNullOrEmpty(projName))
{
IClist.Add(new LikeExpression("OBJECTNAME", "%" + projName + "%"));
}
if (!string.IsNullOrEmpty(leader))
{
IClist.Add(new LikeExpression("TEAMLEDER", leader));
}
if (!string.IsNullOrEmpty(projectType))
{
IClist.Add(new LikeExpression("OBJECTTYPENAME", "%" + projectType + "%"));
}
if (start != null && end != null)
{
BetweenExpression betw1 = new BetweenExpression("BEGINDATE", start, end);//(new GeExpression("BEGINDATE", start), new LeExpression("ENDDATE", end));
//BetweenExpression betw2 = new BetweenExpression("ENDDATE", start, end);
IClist.Add(betw1);
}
TB_PROJECT[] arr = TB_PROJECTDAO.FindAll(IClist.ToArray());
if (arr != null && arr.Length > 0)
{
list = new List <TB_PROJECT>(arr);
}
}
catch (Exception ex)
{
MessageHelper.ShowMessage(ex.Message);
}
return(list);
}
public override void VisitBetweenExpression(BetweenExpression betweenExpression)
{
//Convert the between expression into a boolean binary expression
var convertedExpression = new BooleanBinaryExpression()
{
Left = new BooleanComparisonExpression()
{
Left = betweenExpression.Expression,
Right = betweenExpression.From,
Type = BooleanComparisonType.GreaterThanOrEqualTo
},
Right = new BooleanComparisonExpression()
{
Left = betweenExpression.Expression,
Right = betweenExpression.To,
Type = BooleanComparisonType.LessThanOrEqualTo
},
Type = BooleanBinaryType.AND
};
//Visit the newly constructed boolean binary expression instead
convertedExpression.Accept(this);
}
private ICriterion BuildCriterion(QueryMember member, IEnumerator values)
{
ICriterion criterion;
WhereOperator wo;
if (!Enum.TryParse(member.Type.ToString(), out wo))
{
wo = WhereOperator.Equal;
}
switch (wo)
{
case WhereOperator.Between:
criterion = new BetweenExpression(member.PropertyName, values.NextValue(), values.NextValue());
break;
case WhereOperator.In:
criterion = new InExpression(member.PropertyName, values.NextValue <object[]>());
break;
case WhereOperator.Null:
criterion = new NullExpression(member.PropertyName);
break;
default:
criterion = new SimpleExpression(member.PropertyName, wo, values.NextValue());
break;
}
if (member.HasNot)
{
criterion = new NotExpression(criterion);
}
return(criterion);
}
/// <summary>
/// 报销查询
/// </summary>
/// <param name="usercode">工号</param>
/// <param name="expenseType">报销类型</param>
/// <param name="objectId">项目ID</param>
/// <param name="start">开始时间</param>
/// <param name="end">结束时间</param>
/// <returns></returns>
public static List <TB_EXPENSE> QueryExpense2(string usercode, int expenseType, int objectId, DateTime?start = null, DateTime?end = null)
{
List <TB_EXPENSE> list = new List <TB_EXPENSE>();
try
{
List <ICriterion> IClist = new List <ICriterion>();
IClist.Add(new EqExpression("STATUS", 1));
if (!string.IsNullOrEmpty(usercode))
{
IClist.Add(new EqExpression("OPNAME", usercode));
}
if (objectId > 0)
{
IClist.Add(new EqExpression("OBJECTID", objectId));
}
if (expenseType > 0)
{
IClist.Add(new EqExpression("EXPENSTYPE", expenseType));
}
if (start != null && end != null)
{
BetweenExpression and1 = new BetweenExpression("CREATEDATE", start, end);
IClist.Add(and1);
}
TB_EXPENSE[] arr = TB_EXPENSEDAO.FindAll(IClist.ToArray());
if (arr != null && arr.Length > 0)
{
list = new List <TB_EXPENSE>(arr);
}
}
catch (Exception ex)
{
MessageHelper.ShowMessage(ex.Message);
}
return(list);
}
public void TestBetween()
{
var actual = new BetweenExpression()
{
Expression = new ColumnReference()
{
Identifiers = new List <string>()
{
"c1"
}
},
From = new IntegerLiteral()
{
Value = 1
},
To = new IntegerLiteral()
{
Value = 10
}
}.Print();
var expected = "c1 BETWEEN 1 AND 10";
actual.Should().Be(expected);
}
private string GetExpression(BetweenExpression expression, ref List <OleDbParameter> parameters)
{
return(" ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " BETWEEN " +
GetExpressionDispatch(expression.Children[1], ref parameters) + " AND " +
GetExpressionDispatch(expression.Children[2], ref parameters) + " ) ");
}
protected virtual Expression VisitBetween(BetweenExpression between)
{
Expression expr = this.Visit(between.Expression);
Expression lower = this.Visit(between.Lower);
Expression upper = this.Visit(between.Upper);
if (expr != between.Expression || lower != between.Lower || upper != between.Upper)
{
return new BetweenExpression(expr, lower, upper);
}
return between;
}
protected virtual bool CompareBetween(BetweenExpression a, BetweenExpression b)
{
return this.Compare(a.Expression, b.Expression)
&& this.Compare(a.Lower, b.Lower)
&& this.Compare(a.Upper, b.Upper);
}
private bool Operator(bool fieldRequired, out QueryExpression op)
{
OperatorType type;
FieldExpression field = null;
if (Scanner.TryScan("true"))
{
op = new TrueExpression();
return(true);
}
else
{
if (fieldRequired && Field(out field) == false)
{
op = null;
return(false);
}
if (Scanner.TryScan(OperatorStartMatches, out var match) == false)
{
if (fieldRequired == false)
{
op = null;
return(false);
}
ThrowParseException("Invalid operator expected any of (In, Between, =, <, >, <=, >=)");
}
switch (match)
{
case "<":
type = OperatorType.LessThan;
break;
case ">":
type = OperatorType.GreaterThan;
break;
case "<=":
type = OperatorType.LessThanEqual;
break;
case ">=":
type = OperatorType.GreaterThanEqual;
break;
case "=":
case "==":
type = OperatorType.Equal;
break;
case "!=":
case "<>":
type = OperatorType.NotEqual;
break;
case "BETWEEN":
if (Value(out var fst) == false)
{
ThrowParseException("parsing Between, expected value (1st)");
}
if (Scanner.TryScan("AND") == false)
{
ThrowParseException("parsing Between, expected AND");
}
if (Value(out var snd) == false)
{
ThrowParseException("parsing Between, expected value (2nd)");
}
if (fst.Type != snd.Type)
{
ThrowQueryException(
$"Invalid Between expression, values must have the same type but got {fst.Type} and {snd.Type}");
}
op = new BetweenExpression(field, fst, snd);
return(true);
case "IN":
case "ALL IN":
if (Scanner.TryScan('(') == false)
{
ThrowParseException("parsing In, expected '('");
}
var list = new List <QueryExpression>();
do
{
if (Scanner.TryScan(')'))
{
break;
}
if (list.Count != 0)
{
if (Scanner.TryScan(',') == false)
{
ThrowParseException("parsing In expression, expected ','");
}
}
if (Value(out var inVal) == false)
{
ThrowParseException("parsing In, expected a value");
}
if (list.Count > 0)
{
if (list[0].Type != inVal.Type)
{
ThrowQueryException(
$"Invalid In expression, all values must have the same type, expected {list[0].Type} but got {inVal.Type}");
}
}
list.Add(inVal);
} while (true);
op = new InExpression(field, list, match == "ALL IN");
return(true);
case "(":
var isMethod = Method(field, out var method);
op = method;
if (isMethod && Operator(false, out var methodOperator))
{
if (methodOperator is BinaryExpression be)
{
be.Left = method;
op = be;
return(true);
}
if (methodOperator is InExpression ie)
{
ie.Source = method;
op = ie;
return(true);
}
if (methodOperator is BetweenExpression between)
{
between.Source = method;
op = between;
return(true);
}
if (methodOperator is MethodExpression me)
{
op = me;
return(true);
}
ThrowParseException("Unexpected operator after method call: " + methodOperator);
}
return(isMethod);
default:
op = null;
return(false);
}
}
if (Value(out var val))
{
op = new BinaryExpression(field, val, type);
return(true);
}
if (Operator(true, out var op2))
{
op = new BinaryExpression(field, op2, type);
return(true);
}
op = null;
return(false);
}
private bool CompareBetween(BetweenExpression a, BetweenExpression b)
{
return this.Compare(a.Expression, b.Expression) && this.Compare(a.Lower, b.Lower) && this.Compare(a.Upper, b.Upper);
}
protected override Expression VisitMethodCall(MethodCallExpression m)
{
var methodName = m.Method.Name;
var declaringType = m.Method.DeclaringType;
if (declaringType == typeof(SqlFunctions) && methodName == "Between")
{
var between = new BetweenExpression(m.Arguments[0], m.Arguments[1], m.Arguments[2]);
return VisitBetween(between);
}
var key = methodName;
IFunctionView fn;
if (FuncRegistry.TryGetFunction(key, out fn))
{
if (key == "Concat")
fn.Render(this, (m.Arguments[0] as NewArrayExpression).Expressions.ToArray());
else
{
if (m.Method.IsStatic)
fn.Render(this, m.Arguments.ToArray());
else
{
var args = new List<Expression>();
args.Add(m.Object);
args.AddRange(m.Arguments);
fn.Render(this, args.ToArray());
}
}
return m;
}
if (methodName == "CompareString"
&& declaringType.FullName == "Microsoft.VisualBasic.CompilerServices.Operators")
{
FuncRegistry.SqlFunctions[FunctionType.Compare].Render(this, m.Arguments.ToArray());
return m;
}
if (methodName == "Compare" && m.Arguments.Count > 1
&& m.Method.ReturnType == typeof(int))
{
FuncRegistry.SqlFunctions[FunctionType.Compare].Render(this, m.Arguments.ToArray());
return m;
}
if (methodName == "CompareTo" && m.Arguments.Count == 1
&& m.Method.ReturnType == typeof(int))
{
FuncRegistry.SqlFunctions[FunctionType.Compare].Render(this, m.Object, m.Arguments[0]);
return m;
}
if (methodName == "Equals")
{
var a = m.Arguments[0];
var b = m.Method.IsStatic ? m.Arguments[1] : m.Object;
a = a.NodeType == ExpressionType.Convert ? (a as UnaryExpression).Operand : a;
b = b.NodeType == ExpressionType.Convert ? (b as UnaryExpression).Operand : b;
if (a.NodeType == ExpressionType.Constant)
FunctionView.Equal.Render(this, b, a);
else
FunctionView.Equal.Render(this, a, b);
return m;
}
if (methodName == "ToString" && !m.Method.IsStatic && m.Arguments.Count == 0)
{
ConvertTo(m.Object, Types.String);
return m;
}
if (methodName == "Convert" && declaringType == typeof(SqlFunctions))
{
if (m.Method.IsGenericMethod)
ConvertTo(m.Arguments[0], m.Type);
else
ConvertTo(m.Arguments[0], (m.Arguments[1] as ConstantExpression).Value as Type);
return m;
}
if (declaringType == Types.Decimal)
{
switch (methodName)
{
case "Add":
sb.Append("(");
Visit(m.Arguments[0]);
sb.Append("+");
Visit(m.Arguments[1]);
sb.Append(")");
return m;
case "Subtract":
sb.Append("(");
Visit(m.Arguments[0]);
sb.Append("-");
Visit(m.Arguments[1]);
sb.Append(")");
return m;
case "Multiply":
sb.Append("(");
Visit(m.Arguments[0]);
sb.Append("*");
Visit(m.Arguments[1]);
sb.Append(")");
return m;
case "Divide":
sb.Append("(");
Visit(m.Arguments[0]);
sb.Append("/");
Visit(m.Arguments[1]);
sb.Append(")");
return m;
case "Remainder":
FuncRegistry.SqlFunctions["Decimal." + methodName].Render(this, m.Arguments.ToArray());
return m;
case "Negate":
sb.Append("-");
Visit(m.Arguments[0]);
return m;
}
}
if (declaringType == Types.DateTime)
{
switch (methodName)
{
case "Add":
FuncRegistry.SqlFunctions[FunctionType.DateTime.DateAdd].Render(this, Expression.Constant(DateParts.TimeSpan), m.Object, m.Arguments[0]);
return m;
case "Subtract":
if (m.Arguments[0].Type == Types.TimeSpan)
{
FuncRegistry.SqlFunctions[FunctionType.DateTime.DateAdd].Render(this, Expression.Constant(DateParts.TimeSpan), m.Object, m.Arguments[0], Expression.Constant(false));
return m;
}
break;
}
}
throw new NotSupportedException(string.Format("The method '{0}' is not supported", m));
}
private string GetExpression(BetweenExpression expression, ref List<OleDbParameter> parameters)
{
return " ( " + GetExpressionDispatch(expression.Children[0], ref parameters) + " BETWEEN " +
GetExpressionDispatch(expression.Children[1], ref parameters) + " AND " +
GetExpressionDispatch(expression.Children[2], ref parameters) + " ) ";
}
protected override Expression VisitBetween(BetweenExpression between)
{
VisitValue(between.Expression);
sb.Append(" BETWEEN ");
VisitValue(between.Lower);
sb.Append(" AND ");
VisitValue(between.Upper);
return between;
}
protected virtual Expression VisitBetween(BetweenExpression between)
{
var expr = this.Visit(between.Expression);
var lower = this.Visit(between.Lower);
var upper = this.Visit(between.Upper);
return this.UpdateBetween(between, expr, lower, upper);
}
protected override Expression VisitMethodCall(MethodCallExpression m)
{
var methodName = m.Method.Name;
var declaringType = m.Method.DeclaringType;
if (declaringType == typeof(SqlFunctions) && methodName == "Between")
{
var between = new BetweenExpression(m.Arguments[0], m.Arguments[1], m.Arguments[2]);
return(VisitBetween(between));
}
var key = methodName;
IFunctionView fn;
if (FuncRegistry.TryGetFunction(key, out fn))
{
if (key == "Concat")
{
fn.Render(this, (m.Arguments[0] as NewArrayExpression).Expressions.ToArray());
}
else
{
if (m.Method.IsStatic)
{
fn.Render(this, m.Arguments.ToArray());
}
else
{
var args = new List <Expression>();
args.Add(m.Object);
args.AddRange(m.Arguments);
fn.Render(this, args.ToArray());
}
}
return(m);
}
if (methodName == "CompareString" &&
declaringType.FullName == "Microsoft.VisualBasic.CompilerServices.Operators")
{
FuncRegistry.SqlFunctions[FunctionType.Compare].Render(this, m.Arguments.ToArray());
return(m);
}
if (methodName == "Compare" && m.Arguments.Count > 1 &&
m.Method.ReturnType == typeof(int))
{
FuncRegistry.SqlFunctions[FunctionType.Compare].Render(this, m.Arguments.ToArray());
return(m);
}
if (methodName == "CompareTo" && m.Arguments.Count == 1 &&
m.Method.ReturnType == typeof(int))
{
FuncRegistry.SqlFunctions[FunctionType.Compare].Render(this, m.Object, m.Arguments[0]);
return(m);
}
if (methodName == "Equals")
{
var a = m.Arguments[0];
var b = m.Method.IsStatic ? m.Arguments[1] : m.Object;
a = a.NodeType == ExpressionType.Convert ? (a as UnaryExpression).Operand : a;
b = b.NodeType == ExpressionType.Convert ? (b as UnaryExpression).Operand : b;
if (a.NodeType == ExpressionType.Constant)
{
FunctionView.Equal.Render(this, b, a);
}
else
{
FunctionView.Equal.Render(this, a, b);
}
return(m);
}
if (methodName == "ToString" && !m.Method.IsStatic && m.Arguments.Count == 0)
{
ConvertTo(m.Object, Types.String);
return(m);
}
if (methodName == "Convert" && declaringType == typeof(SqlFunctions))
{
if (m.Method.IsGenericMethod)
{
ConvertTo(m.Arguments[0], m.Type);
}
else
{
ConvertTo(m.Arguments[0], (m.Arguments[1] as ConstantExpression).Value as Type);
}
return(m);
}
if (declaringType == Types.Decimal)
{
switch (methodName)
{
case "Add":
sb.Append("(");
Visit(m.Arguments[0]);
sb.Append("+");
Visit(m.Arguments[1]);
sb.Append(")");
return(m);
case "Subtract":
sb.Append("(");
Visit(m.Arguments[0]);
sb.Append("-");
Visit(m.Arguments[1]);
sb.Append(")");
return(m);
case "Multiply":
sb.Append("(");
Visit(m.Arguments[0]);
sb.Append("*");
Visit(m.Arguments[1]);
sb.Append(")");
return(m);
case "Divide":
sb.Append("(");
Visit(m.Arguments[0]);
sb.Append("/");
Visit(m.Arguments[1]);
sb.Append(")");
return(m);
case "Remainder":
FuncRegistry.SqlFunctions["Decimal." + methodName].Render(this, m.Arguments.ToArray());
return(m);
case "Negate":
sb.Append("-");
Visit(m.Arguments[0]);
return(m);
}
}
if (declaringType == Types.DateTime)
{
switch (methodName)
{
case "Add":
FuncRegistry.SqlFunctions[FunctionType.DateTime.DateAdd].Render(this, Expression.Constant(DateParts.TimeSpan), m.Object, m.Arguments[0]);
return(m);
case "Subtract":
if (m.Arguments[0].Type == Types.TimeSpan)
{
FuncRegistry.SqlFunctions[FunctionType.DateTime.DateAdd].Render(this, Expression.Constant(DateParts.TimeSpan), m.Object, m.Arguments[0], Expression.Constant(false));
return(m);
}
break;
}
}
throw new NotSupportedException(string.Format("The method '{0}' is not supported", m));
}
public EntityBetweenExpression(BetweenExpression betweenExpression)
{
Assert.NotNull(betweenExpression, "BetweenExpression must not be null");
this.betweenExpression = betweenExpression;
}
public override T VisitBetweenExpression(BetweenExpression node)
{
throw new NotImplementedException();
}
protected virtual bool CompareBetween(BetweenExpression a, BetweenExpression b)
{
return(Compare(a.Argument, b.Argument) &&
Compare(a.Lower, b.Lower) &&
Compare(a.Upper, b.Upper));
}
protected override Expression VisitBetween(BetweenExpression between)
{
this.VisitValue(between.Expression);
this.Write(" BETWEEN ");
this.VisitValue(between.Lower);
this.Write(" AND ");
this.VisitValue(between.Upper);
return between;
}
public void TestBetweenExpressionEquals()
{
BetweenExpression first = new BetweenExpression()
{
Expression = new ColumnReference {
Identifiers = new List <string>()
{
"c1"
}
},
From = new IntegerLiteral()
{
Value = 3
},
To = new IntegerLiteral()
{
Value = 17
}
};
BetweenExpression firstClone = new BetweenExpression()
{
Expression = new ColumnReference {
Identifiers = new List <string>()
{
"c1"
}
},
From = new IntegerLiteral()
{
Value = 3
},
To = new IntegerLiteral()
{
Value = 17
}
};
BetweenExpression second = new BetweenExpression()
{
Expression = new ColumnReference {
Identifiers = new List <string>()
{
"c2"
}
},
From = new IntegerLiteral()
{
Value = 3
},
To = new IntegerLiteral()
{
Value = 17
}
};
BetweenExpression third = new BetweenExpression()
{
Expression = new ColumnReference {
Identifiers = new List <string>()
{
"c1"
}
},
From = new IntegerLiteral()
{
Value = 4
},
To = new IntegerLiteral()
{
Value = 17
}
};
BetweenExpression fourth = new BetweenExpression()
{
Expression = new ColumnReference {
Identifiers = new List <string>()
{
"c1"
}
},
From = new IntegerLiteral()
{
Value = 3
},
To = new IntegerLiteral()
{
Value = 19
}
};
//Equals
Assert.IsTrue(Equals(first, firstClone));
Assert.IsFalse(Equals(first, null));
Assert.IsFalse(Equals(first, second));
Assert.IsFalse(Equals(first, third));
Assert.IsFalse(Equals(first, fourth));
Assert.IsFalse(Equals(first, "other type"));
//Hash code
Assert.AreEqual(first.GetHashCode(), firstClone.GetHashCode());
Assert.AreNotEqual(first.GetHashCode(), second.GetHashCode());
Assert.AreNotEqual(first.GetHashCode(), third.GetHashCode());
Assert.AreNotEqual(first.GetHashCode(), fourth.GetHashCode());
}
