public async Task Arithmatic_Addition()
{
using (var queryResult = await DataProvider.ExecuteReaderAsync(
QueryExpression.Select(QueryExpression.Add(
QueryExpression.Value(1), QueryExpression.Value(2)
))
))
{
Assert.IsTrue(queryResult.HasRows);
Assert.IsTrue(await queryResult.ReadAsync());
Assert.AreEqual(3, queryResult.GetInt32(0));
}
}
public void Can_Write_Update_With_Expressions()
{
var query = QueryExpression.Update(
QueryExpression.Table("TestTable"),
new[] { QueryExpression.Column("Value1")},
new[] { QueryExpression.Add(QueryExpression.Column("Value2"), QueryExpression.Value(1)) }
);
var sql = TestHelpers.ConvertToSql(query, out var parameters);
var value1Parameter = parameters.First();
Assert.AreEqual(1, value1Parameter.Value);
Assert.AreEqual(sql, $"UPDATE [TestTable] SET [Value1] = [Value2] + @{value1Parameter.Key};");
}
protected override bool OnSave()
{
////这里要移动基类中,先放这里
//SysRole entity = base.GetControlsValue<SysRole>();
//if (entity.Id <= 0)
//{
// LiteDbHelper.Instanc.Insert(entity);
//}
//else
//{
// LiteDbHelper.Instanc.Update(entity);
//}
#region 单表
BaUint sysRole = new BaUint();
sysRole.Sort = 1;
QueryExpression <BaUint> query1 = QueryExpression <BaUint> .Instanc.True();
query1 = query1.Add(exp => exp.Id == 1 && exp.Id == sysRole.Sort || exp.CreateUserName == "456");
if (1 == 1)
{
query1 = query1.Add(exp => exp.IsEabled == true);
}
if (2 == 2)
{
DateTime d = new DateTime(2019, 2, 4);
query1 = query1.Or(exp => exp.UpdateTime == d);
query1 = query1.Or(exp => exp.UpdateTime == DateTime.Now);
}
//单表
List <BaUint> baUints = OmHelper.GetList <BaUint>(query1);
#endregion
#region 二表联查
//var sql = SqlBuilder.Query<SysPosition, SysRole>((a, b) => new object[] { JoinType.InnerJoin, a.Code == b.Code && a.Id == b.Id }, null);
#endregion
#region 表联查
QueryExpression <SysPosition> query = QueryExpression <SysPosition> .Instanc.True();
query = query.Add(exp => exp.Id == 1 && exp.Id == sysRole.Sort || exp.CreateUserName == "456");
if (1 == 1)
{
query = query.Add(exp => exp.IsEabled == true);
}
if (2 == 2)
{
DateTime d = new DateTime(2019, 2, 4);
query = query.Or(exp => exp.UpdateTime == d);
query = query.Or(exp => exp.UpdateTime == DateTime.Now);
}
QueryExpression <SysRole> query2 = QueryExpression <SysRole> .Instanc.True();
query2 = query2.Add(exp => exp.Id == 1 && exp.Id == sysRole.Sort || exp.CreateUserName == "456");
if (1 == 1)
{
query2 = query2.Add(exp => exp.IsEabled == true);
}
// OmHelper.GetList<SysPosition, SysRole, SysUser, object>((a, b, c) =>
// new object[] { JoinType.InnerJoin,
// a.Code == b.Code && a.Id == b.Id,
// JoinType.InnerJoin,
// a.Code == c.Code
// }).Where(query);
#endregion
return(base.OnSave());
}
protected override Expression VisitBinary(BinaryExpression node)
{
var leftExpression = ConvertToQueryExpression(node.Left);
var rightExpression = ConvertToQueryExpression(node.Right);
switch (node.NodeType)
{
case ExpressionType.AddChecked:
case ExpressionType.Add:
SetConversionResult(
QueryExpression.Add(leftExpression, rightExpression)
);
break;
case ExpressionType.SubtractChecked:
case ExpressionType.Subtract:
SetConversionResult(
QueryExpression.Subtract(leftExpression, rightExpression)
);
break;
case ExpressionType.MultiplyChecked:
case ExpressionType.Multiply:
SetConversionResult(
QueryExpression.Multiply(leftExpression, rightExpression)
);
break;
case ExpressionType.Divide:
SetConversionResult(
QueryExpression.Divide(leftExpression, rightExpression)
);
break;
case ExpressionType.And:
SetConversionResult(
new BitwiseOperationQueryExpression(leftExpression, BitwiseOperator.And, rightExpression)
);
break;
case ExpressionType.ExclusiveOr:
SetConversionResult(
new BitwiseOperationQueryExpression(leftExpression, BitwiseOperator.ExclusiveOr, rightExpression)
);
break;
case ExpressionType.Or:
SetConversionResult(
new BitwiseOperationQueryExpression(leftExpression, BitwiseOperator.Or, rightExpression)
);
break;
case ExpressionType.AndAlso:
SetConversionResult(
QueryExpression.AndAlso(leftExpression, rightExpression)
);
break;
case ExpressionType.OrElse:
SetConversionResult(
QueryExpression.OrElse(leftExpression, rightExpression)
);
break;
case ExpressionType.Equal:
SetConversionResult(
QueryExpression.Compare(leftExpression, ComparisonOperator.AreEqual, rightExpression)
);
break;
case ExpressionType.NotEqual:
SetConversionResult(
QueryExpression.Compare(leftExpression, ComparisonOperator.AreNotEqual, rightExpression)
);
break;
case ExpressionType.GreaterThan:
SetConversionResult(
QueryExpression.Compare(leftExpression, ComparisonOperator.GreaterThan, rightExpression)
);
break;
case ExpressionType.GreaterThanOrEqual:
SetConversionResult(
QueryExpression.Compare(leftExpression, ComparisonOperator.GreaterThanOrEqualTo, rightExpression)
);
break;
case ExpressionType.LessThan:
SetConversionResult(
QueryExpression.Compare(leftExpression, ComparisonOperator.LessThan, rightExpression)
);
break;
case ExpressionType.LessThanOrEqual:
SetConversionResult(
QueryExpression.Compare(leftExpression, ComparisonOperator.LessThanOrEqualTo, rightExpression)
);
break;
default:
throw new Exception($"Unsupported binary node type '{node.NodeType}'.");
}
return(node);
}
protected override Expression VisitBinary(BinaryExpression node)
{
var left = Visit(node.Left) as LinqQueryExpression <TEntity>;
if (left == null)
{
throw new InvalidOperationException("Couldn't convert expression to SQL query expression.");
}
var right = Visit(node.Right) as LinqQueryExpression <TEntity>;
if (right == null)
{
throw new InvalidOperationException("Couldn't convert expression to SQL query expression.");
}
var leftExpression = left.QueryExpression;
var rightExpression = right.QueryExpression;
switch (node.NodeType)
{
case ExpressionType.AddChecked:
case ExpressionType.Add:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Add(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.SubtractChecked:
case ExpressionType.Subtract:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Subtract(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.MultiplyChecked:
case ExpressionType.Multiply:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Multiply(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.Divide:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Divide(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.And:
return(new LinqQueryExpression <TEntity>(
QueryExpression.And(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.ExclusiveOr:
return(new LinqQueryExpression <TEntity>(
QueryExpression.ExclusiveOr(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.Or:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Or(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.AndAlso:
return(new LinqQueryExpression <TEntity>(
QueryExpression.AndAlso(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.OrElse:
return(new LinqQueryExpression <TEntity>(
QueryExpression.OrElse(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.Equal:
return(new LinqQueryExpression <TEntity>(
QueryExpression.AreEqual(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.NotEqual:
return(new LinqQueryExpression <TEntity>(
QueryExpression.AreNotEqual(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.GreaterThan:
return(new LinqQueryExpression <TEntity>(
QueryExpression.GreaterThan(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.GreaterThanOrEqual:
return(new LinqQueryExpression <TEntity>(
QueryExpression.GreaterThanOrEqualTo(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.LessThan:
return(new LinqQueryExpression <TEntity>(
QueryExpression.LessThan(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.LessThanOrEqual:
return(new LinqQueryExpression <TEntity>(
QueryExpression.LessThanOrEqualTo(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
default:
throw new Exception($"Unsupported binary node type '{node.NodeType}'.");
}
}