public virtual T Visit(LogicalBinaryExpression node) { Visit((BinaryExpression)node); traverse(node.left); traverse(node.right); return(DefaultReturnValue()); }
// Currently only working with ints public override Value Visit(LogicalBinaryExpression node) { Visit((BinaryExpression)node); Value l = traverse(node.left); Value r = traverse(node.right); if (l.IsNull || r.IsNull) { return(Value.Null); } switch (node.op) { case LogicalBinaryOp.AND: return(builder.BuildAnd(l, r)); case LogicalBinaryOp.OR: return(builder.BuildOr(l, r)); case LogicalBinaryOp.XOR: return(builder.BuildXor(l, r)); default: // never happens return(Value.Null); } }
public override bool Visit(LogicalBinaryExpression node) { Visit((BinaryExpression)node); TraversePrint(node.left); TraversePrint(node.right); return(true); }
public void EmitLogicalOperator(LogicalBinaryExpression logical) { switch (logical.Operator) { case Operator.Less: Emit(OpCodes.Clt); break; case Operator.LessOrEq: Emit(OpCodes.Cgt); Emit(OpCodes.Ldc_I4_0); Emit(OpCodes.Ceq); break; case Operator.Greater: Emit(OpCodes.Cgt); break; case Operator.GreaterOrEq: Emit(OpCodes.Clt); Emit(OpCodes.Ldc_I4_0); Emit(OpCodes.Ceq); break; case Operator.Eq: Emit(OpCodes.Ceq); break; case Operator.NoEq: Emit(OpCodes.Ceq); Emit(OpCodes.Ldc_I4_0); Emit(OpCodes.Ceq); break; } }
public IExpression AndLogical() { var result = EqualsNoEquals(); while (_semTokens.Current?.Type == TokenType.And) { _semTokens.Step(); result = new LogicalBinaryExpression(result, EqualsNoEquals(), Operator.And); } return(result); }
public IExpression OrLogical() { var result = AndLogical(); while (_semTokens.Current?.Type == TokenType.Or) { _semTokens.Step(); result = new LogicalBinaryExpression(result, AndLogical(), Operator.Or); } return(result); }
public override bool Visit(LogicalBinaryExpression node) { Visit(node.left); Visit(node.right); if (node.left.Value == null || node.right == null) { return(false); } node.Value = new IntegralValue(Fold(node)); return(true); }
/// <summary> /// 依据表达式,生成Delete语句到数据库执行。 /// </summary> /// <param name="logical">Sparrow.Query.SqlExpression表达式</param> /// <returns></returns> public int Delete(LogicalBinaryExpression logical) { if (logical == null) { throw new ArgumentNullException("logical"); } // var parameters = CreateParamterCollection(); var sql = SqlBuilder.DeleteFormat(metaInfo.Name, logical.OutputSqlString(SqlBuilder, parameters), SqlOptions.None); // return(DoExecuteByDbWriter(sql, parameters, null)); }
bool Fold(LogicalBinaryExpression n) { bool vleft = n.left.Value.Val <bool>(); bool vright = n.right.Value.Val <bool>(); switch (n.op) { case LogicalBinaryOp.AND: return(Operator.And(vleft, vright)); case LogicalBinaryOp.OR: return(Operator.Or(vleft, vright)); case LogicalBinaryOp.XOR: return(Operator.Xor(vleft, vright)); default: throw new SemanticException("Invalid operator " + n.op + " in logical binary expr"); } }
public IExpression EqualsNoEquals() { var result = Logical(); while (_semTokens.Current?.Type == TokenType.EqualTo || _semTokens.Current?.Type == TokenType.NotEqualTo) { switch (_semTokens.Current?.Type) { case TokenType.EqualTo: _semTokens.Step(); result = new LogicalBinaryExpression(result, Logical(), Operator.Eq); break; case TokenType.NotEqualTo: _semTokens.Step(); result = new LogicalBinaryExpression(result, Logical(), Operator.NoEq); break; } } return(result); }
public LogicalBinaryExpression PrepareForConditionalIfNeeded(IExpression expression) { LogicalBinaryExpression result = null; if (expression.TryCast <UnaryExpression>(out var unary)) { if (unary.Expression.TryCast <LogicalBinaryExpression>(out var logicalBinaryExpression)) { result = UnWrapUnaryExpression(logicalBinaryExpression); } else if (ExpressionType.Variables.HasFlag(unary.Expression.ExpressionType)) { result = new LogicalBinaryExpression(unary.Expression, new PrimaryExpression("false"), Operator.Eq); } } else if (ExpressionType.Variables.HasFlag(expression.ExpressionType)) { result = new LogicalBinaryExpression(expression, new PrimaryExpression("true"), Operator.Eq); } else if (expression.TryCast <PrimaryExpression>(out var primary) && primary.ReturnType == CompilerType.Bool) { result = new LogicalBinaryExpression(primary, new PrimaryExpression("true"), Operator.Eq); }
public override bool Visit(LogicalBinaryExpression node) { Visit((BinaryExpression)node); return(true); }
public TValue Sum <TValue>(System.Linq.Expressions.Expression <Func <T, object> > field, LogicalBinaryExpression logical) { var parameters = CreateParamterCollection(); string sql = new Queryable <T>(DbReader) .Sum(field) .Where(logical) .OutputSqlString(parameters); return(DbReader.ExecuteScalar <TValue>(sql, parameters)); }
public IDictionary <TKey, int> GroupbyCount <TKey>(Expression <Func <T, object> > field, LogicalBinaryExpression logical) { var parameters = CreateParamterCollection(); string sql = new Queryable <T>(DbReader) .Select(field) .Count(field) .Where(logical) .GroupBy(field) .OutputSqlString(parameters); using (var reader = DbReader.ExecuteReader(sql, parameters)) { return(reader.ToDictionary <TKey, int>()); } }
public IDictionary <TKey, TValue> GroupbyMax <TKey, TValue>(Expression <Func <T, object> > keyField, Expression <Func <T, object> > valueField, LogicalBinaryExpression logical) { var parameters = CreateParamterCollection(); string sql = new Queryable <T>(DbReader) .Select(keyField) .Max(valueField) .Where(logical) .GroupBy(keyField) .OutputSqlString(parameters); using (var reader = DbReader.ExecuteReader(sql, parameters)) { return(reader.ToDictionary <TKey, TValue>()); } }