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