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()); }