protected override SequenceConvertInfo Convert(
ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo, ParameterExpression param)
{
var predicate = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var info = builder.ConvertSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]), predicate.Parameters[0]);
if (info != null)
{
info.Expression = methodCall.Transform(ex => ConvertMethod(methodCall, 0, info, predicate.Parameters[0], ex));
if (param != null)
{
if (param.Type != info.Parameter.Type)
param = Expression.Parameter(info.Parameter.Type, param.Name);
if (info.ExpressionsToReplace != null)
foreach (var path in info.ExpressionsToReplace)
{
path.Path = path.Path.Transform(e => e == info.Parameter ? param : e);
path.Expr = path.Expr.Transform(e => e == info.Parameter ? param : e);
}
}
info.Parameter = param;
return info;
}
return null;
}
static void BuildSkip(ExpressionBuilder builder, IBuildContext sequence, ISqlExpression prevSkipValue, ISqlExpression expr)
{
var sql = sequence.SqlQuery;
builder.SqlProvider.SqlQuery = sql;
sql.Select.Skip(expr);
builder.SqlProvider.SqlQuery = sql;
if (sql.Select.TakeValue != null)
{
if (builder.DataContextInfo.SqlProviderFlags.GetIsSkipSupportedFlag(sql) ||
!builder.DataContextInfo.SqlProviderFlags.IsTakeSupported)
sql.Select.Take(builder.Convert(
sequence,
new SqlBinaryExpression(typeof(int), sql.Select.TakeValue, "-", sql.Select.SkipValue, Precedence.Additive)));
if (prevSkipValue != null)
sql.Select.Skip(builder.Convert(
sequence,
new SqlBinaryExpression(typeof(int), prevSkipValue, "+", sql.Select.SkipValue, Precedence.Additive)));
}
if (!builder.DataContextInfo.SqlProviderFlags.GetAcceptsTakeAsParameterFlag(sql))
{
var p = sql.Select.SkipValue as SqlParameter;
if (p != null)
p.IsQueryParameter = false;
}
}
public bool IsSequence(ExpressionBuilder builder, BuildInfo buildInfo)
{
var expr = (ChangeTypeExpression)buildInfo.Expression;
var info = new BuildInfo(buildInfo, expr.Expression);
return GetBuilder(builder, info).IsSequence(builder, info);
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
if (sequence.SelectQuery.Select.TakeValue != null || sequence.SelectQuery.Select.SkipValue != null)
sequence = new SubQueryContext(sequence);
var lambda = (LambdaExpression)methodCall.Arguments[1].Unwrap();
var sparent = sequence.Parent;
var order = new ExpressionContext(buildInfo.Parent, sequence, lambda);
var body = lambda.Body.Unwrap();
var sql = builder.ConvertExpressions(order, body, ConvertFlags.Key);
builder.ReplaceParent(order, sparent);
if (!methodCall.Method.Name.StartsWith("Then"))
sequence.SelectQuery.OrderBy.Items.Clear();
foreach (var expr in sql)
{
var e = builder.ConvertSearchCondition(sequence, expr.Sql);
sequence.SelectQuery.OrderBy.Expr(e, methodCall.Method.Name.EndsWith("Descending"));
}
return sequence;
}
protected override IBuildContext BuildMethodCall(ExpressionBuilder builder, MethodCallExpression methodCall, BuildInfo buildInfo)
{
var sequence = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[0]));
var query = builder.BuildSequence(new BuildInfo(buildInfo, methodCall.Arguments[1], new SqlQuery()));
var except = query.SqlQuery;
sequence = new SubQueryContext(sequence);
var sql = sequence.SqlQuery;
except.ParentSql = sql;
if (methodCall.Method.Name == "Except")
sql.Where.Not.Exists(except);
else
sql.Where.Exists(except);
var keys1 = sequence.ConvertToSql(null, 0, ConvertFlags.Key);
var keys2 = query. ConvertToSql(null, 0, ConvertFlags.Key);
if (keys1.Length != keys2.Length)
throw new InvalidOperationException();
for (var i = 0; i < keys1.Length; i++)
{
except.Where
.Expr(keys1[i].Sql)
.Equal
.Expr(keys2[i].Sql);
}
return sequence;
}
public void NotEqualsTupleTrue_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<bool,bool, bool>> expression = builder.Create<Func<bool,bool, bool>>("A != B");
Func<bool,bool, bool> func = expression.Compile();
Assert.IsTrue(func(false, true));
}
public void LowerTupleTrue_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<int,int, bool>> expression = builder.Create<Func<int,int, bool>>("A < B");
Func<int,int, bool> func = expression.Compile();
Assert.IsTrue(func(1, 3));
}
public void GreaterOrEqualTupleTrue_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<int,int, bool>> expression = builder.Create<Func<int,int, bool>>("A >= B");
Func<int,int, bool> func = expression.Compile();
Assert.IsTrue(func(3, 0));
}
public void Sin_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<double,double>> expression = builder.Create<Func<double, double>>("SIN(A/2)");
Func<double,double> func = expression.Compile();
Assert.AreEqual(func(Math.PI), 1);
}
public void Cos_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<int,int>> expression = builder.Create<Func<int, int>>("COS A");
Func<int,int> func = expression.Compile();
Assert.AreEqual(func(0), 1);
}
public void EmptyParentesisExpression_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<int>> expression = builder.Create<Func<int>>("2+1+()-1");
Func<int> func = expression.Compile();
Assert.AreEqual(func(), 0);
}
public void EmptyExpression_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<bool>> expression = builder.Create<Func<bool>>("");
Func<bool> func = expression.Compile();
Assert.IsTrue(func());
}
public void EvaluateNumericalOperation2_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<int>> expression = builder.Create<Func<int>>("2^3");
Func<int> func = expression.Compile();
Assert.AreEqual(func(), 8);
}
public void EvaluateConstantValue_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<double>> expression = builder.Create<Func<double>>("-PI");
Func<double> func = expression.Compile();
Assert.AreEqual(func(), -1*Math.PI);
}
public void EvaluateBoolValue_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<bool>> expression = builder.Create<Func<bool>>("false");
Func<bool> func = expression.Compile();
Assert.AreEqual(func(), false);
}
public void EvaluateBoolExpression2_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<bool>> expression = builder.Create<Func<bool>>("NOT(false) AND true");
Func<bool> func = expression.Compile();
Assert.AreEqual(func(), true);
}
public override ISqlBuilder CreateSqlBuilder(string dataVer, ExpressionBuilder expBuilder, string name)
{
switch (dataVer)
{
case "2000": return new SqlServerSqlBuilder2000(this, expBuilder, name);
}
return new SqlServerSqlBuilder(this, expBuilder, name);
}
public void Cos_Test3()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<double,double>> expression = builder.Create<Func<double, double>>("-COS -A");
Func<double,double> func = expression.Compile();
Assert.AreEqual(func(Math.PI), 1);
}
public void Exp_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<double,double>> expression = builder.Create<Func<double, double>>("EXP A");
Func<double,double> func = expression.Compile();
Assert.AreEqual(func(0), 1);
}
/// <summary>
/// 查询支持的SQL方法
/// </summary>
/// <param name="dbProvider">数据库提供者（不同数据库的特性）</param>
/// <param name="expBuilder">表达式持久化</param>
/// <param name="name">表名/视图名/存储过程名</param>
internal SqlBuilder(AbsDbProvider dbProvider, ExpressionBuilder expBuilder, string name)
{
DbProvider = dbProvider;
ExpBuilder = expBuilder;
Name = name;
Param = new List<DbParameter>();
Sql = new StringBuilder();
}
public void ListContainsColumn()
{
var builder = new ExpressionBuilder<User>();
var condition = builder.BuildContains("Id", new int[] { 9, 10 });
var where = builder.Build(condition);
var results = db.Set<User>().Where(where).ToList();
Console.WriteLine(results.Count + "条数据");
}
public void TupleANDComparison_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<int,int, bool>> expression = builder.Create<Func<int,int, bool>>("A <= B AND B > 1");
Func<int,int, bool> func = expression.Compile();
Assert.IsTrue(func(1, 3));
}
public void TupleANDWithORComparisonMixedEquals_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<bool,bool, bool>> expression = builder.Create<Func<bool,bool, bool>>("A==A AND A!=B OR B==B");
Func<bool,bool, bool> func = expression.Compile();
Assert.IsTrue(func(true, false));
}
public void Poli3ArgsPlusConstantPlusParentesisFunction_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<int,int, int,int>> expression = builder.Create<Func<int,int, int, int>>("A * (B+C)+6");
Func<int,int, int, int> func = expression.Compile();
Assert.AreEqual(func(16, 2, -2), 6);
}
public void TupleAndNot_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<bool,bool, bool>> expression = builder.Create<Func<bool,bool, bool>>("A AND NOT B");
Func<bool,bool, bool> func = expression.Compile();
Assert.IsFalse(func(true, true));
}
public void TwoArgsMultiplication_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<int,int, int>> expression = builder.Create<Func<int,int, int>>("A * B");
Func<int,int, int> func = expression.Compile();
Assert.AreEqual(func(16, 2), 32);
}
public void Poli3ArgsFunction_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<int,int, int,int>> expression = builder.Create<Func<int,int, int, int>>("A * B+C");
Func<int,int, int, int> func = expression.Compile();
Assert.AreEqual(func(16, 2, -2), 30);
}
public void StringContainsString()
{
var builder = new ExpressionBuilder<User>();
var condition = builder.BuildContains("Password", "123");
var where = builder.Build(condition);
var results = db.Set<User>().Where(where).ToList();
Console.WriteLine(results.Count + "条数据");
}
public void Poli3ArgsPlusConstantPlusParentesisFunction3_Test()
{
ExpressionBuilder builder = new ExpressionBuilder();
Expression<Func<int,int, int,int>> expression = builder.Create<Func<int,int, int, int>>("(A + B + 1) + (B+C)*2 + 1");
Func<int,int, int, int> func = expression.Compile();
Assert.AreEqual(func(12, 2, -1), 18);
}
/// <summary>
/// 复制条件
/// </summary>
/// <param name="queue">队列</param>
internal void Copy(Queue queue)
{
ID = queue.ID;
Index = queue.Index;
ContextProvider = queue.ContextProvider;
_expBuilder = queue.ExpBuilder;
//_sqlBuilder = queue.SqlBuilder;
//_procBuilder = queue.ProcBuilder;
}
static ParserTests()
{
ExpressionBuilder.AddBuilder(new MyContextParser());
}
public override ISqlBuilder CreateSqlBuilder(string dataVer, ExpressionBuilder expBuilder, string name)
{
return(new SqLiteSqlBuilder(this, expBuilder, name));
}
public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
{
if (!IsClassType(ClassType.Interface) && (methodDeclaration.Modifier & Modifiers.Visibility) == 0)
{
methodDeclaration.Modifier |= Modifiers.Public;
}
if ("Finalize".Equals(methodDeclaration.Name, StringComparison.InvariantCultureIgnoreCase) &&
methodDeclaration.Parameters.Count == 0 &&
methodDeclaration.Modifier == (Modifiers.Protected | Modifiers.Override) &&
methodDeclaration.Body.Children.Count == 1)
{
TryCatchStatement tcs = methodDeclaration.Body.Children[0] as TryCatchStatement;
if (tcs != null &&
tcs.StatementBlock is BlockStatement &&
tcs.CatchClauses.Count == 0 &&
tcs.FinallyBlock is BlockStatement &&
tcs.FinallyBlock.Children.Count == 1)
{
ExpressionStatement se = tcs.FinallyBlock.Children[0] as ExpressionStatement;
if (se != null)
{
InvocationExpression ie = se.Expression as InvocationExpression;
if (ie != null &&
ie.Arguments.Count == 0 &&
ie.TargetObject is MemberReferenceExpression &&
(ie.TargetObject as MemberReferenceExpression).TargetObject is BaseReferenceExpression &&
"Finalize".Equals((ie.TargetObject as MemberReferenceExpression).MemberName, StringComparison.InvariantCultureIgnoreCase))
{
DestructorDeclaration des = new DestructorDeclaration("Destructor", Modifiers.None, methodDeclaration.Attributes);
ReplaceCurrentNode(des);
des.Body = (BlockStatement)tcs.StatementBlock;
return(base.VisitDestructorDeclaration(des, data));
}
}
}
}
if ((methodDeclaration.Modifier & (Modifiers.Static | Modifiers.Extern)) == Modifiers.Static &&
methodDeclaration.Body.Children.Count == 0)
{
foreach (AttributeSection sec in methodDeclaration.Attributes)
{
foreach (Attribute att in sec.Attributes)
{
if ("DllImport".Equals(att.Name, StringComparison.InvariantCultureIgnoreCase))
{
methodDeclaration.Modifier |= Modifiers.Extern;
methodDeclaration.Body = null;
}
}
}
}
if (methodDeclaration.TypeReference.Type != "System.Void" && methodDeclaration.Body.Children.Count > 0)
{
if (IsAssignmentTo(methodDeclaration.Body.Children[methodDeclaration.Body.Children.Count - 1], methodDeclaration.Name))
{
Expression returnValue = GetAssignmentFromStatement(methodDeclaration.Body.Children[methodDeclaration.Body.Children.Count - 1]).Right;
methodDeclaration.Body.Children.RemoveAt(methodDeclaration.Body.Children.Count - 1);
methodDeclaration.Body.Return(returnValue);
}
else
{
ReturnStatementForFunctionAssignment visitor = new ReturnStatementForFunctionAssignment(methodDeclaration.Name);
methodDeclaration.Body.AcceptVisitor(visitor, null);
if (visitor.replacementCount > 0)
{
Expression init;
init = ExpressionBuilder.CreateDefaultValueForType(methodDeclaration.TypeReference);
methodDeclaration.Body.Children.Insert(0, new LocalVariableDeclaration(new VariableDeclaration(FunctionReturnValueName, init, methodDeclaration.TypeReference)));
methodDeclaration.Body.Children[0].Parent = methodDeclaration.Body;
methodDeclaration.Body.Return(new IdentifierExpression(FunctionReturnValueName));
}
}
}
return(base.VisitMethodDeclaration(methodDeclaration, data));
}
public void TestParens()
{
Either <Error, Tuple <string, ExpressionBuilder> > res =
Parser.Expression(" 1 + 2 * 3 ");
Assert.AreEqual(new Right(new Tuple <string, ExpressionBuilder>("",
new ExpressionBuilder.Binary(
ExpressionBuilder.Op.Add,
new ExpressionBuilder.Value(Utils.Integer(1)),
new ExpressionBuilder.Binary(
ExpressionBuilder.Op.Mul,
new ExpressionBuilder.Value(Utils.Integer(2)),
new ExpressionBuilder.Value(Utils.Integer(3))
)
)
)),
res);
ExpressionBuilder e = res.Right.Item2;
SymbolTable s = new SymbolTable();
Biscuit.Datalog.Expressions.Expression ex = e.Convert(s);
Assert.IsTrue(
Arrays.AsList <Biscuit.Datalog.Expressions.Op>(
new Biscuit.Datalog.Expressions.Op.Value(new ID.Integer(1)),
new Biscuit.Datalog.Expressions.Op.Value(new ID.Integer(2)),
new Biscuit.Datalog.Expressions.Op.Value(new ID.Integer(3)),
new Biscuit.Datalog.Expressions.Op.Binary(Biscuit.Datalog.Expressions.Op.BinaryOp.Mul),
new Biscuit.Datalog.Expressions.Op.Binary(Biscuit.Datalog.Expressions.Op.BinaryOp.Add)
).SequenceEqual(
ex.GetOps())
);
Dictionary <ulong, ID> variables = new Dictionary <ulong, ID>();
Option <ID> value = ex.Evaluate(variables);
Assert.AreEqual(Option.Some(new ID.Integer(7)), value);
Assert.AreEqual("1 + 2 * 3", ex.Print(s).Get());
Either <Error, Tuple <string, ExpressionBuilder> > res2 =
Parser.Expression(" (1 + 2) * 3 ");
Assert.AreEqual(new ExpressionBuilder.Binary(
ExpressionBuilder.Op.Mul,
new ExpressionBuilder.Unary(
ExpressionBuilder.Op.Parens,
new ExpressionBuilder.Binary(
ExpressionBuilder.Op.Add,
new ExpressionBuilder.Value(Utils.Integer(1)),
new ExpressionBuilder.Value(Utils.Integer(2))
))
,
new ExpressionBuilder.Value(Utils.Integer(3))
)
,
res2.Right.Item2);
ExpressionBuilder e2 = res2.Right.Item2;
SymbolTable s2 = new SymbolTable();
Biscuit.Datalog.Expressions.Expression ex2 = e2.Convert(s2);
Assert.IsTrue(
Arrays.AsList <Biscuit.Datalog.Expressions.Op>(
new Biscuit.Datalog.Expressions.Op.Value(new ID.Integer(1)),
new Biscuit.Datalog.Expressions.Op.Value(new ID.Integer(2)),
new Biscuit.Datalog.Expressions.Op.Binary(Biscuit.Datalog.Expressions.Op.BinaryOp.Add),
new Biscuit.Datalog.Expressions.Op.Unary(Biscuit.Datalog.Expressions.Op.UnaryOp.Parens),
new Biscuit.Datalog.Expressions.Op.Value(new ID.Integer(3)),
new Biscuit.Datalog.Expressions.Op.Binary(Biscuit.Datalog.Expressions.Op.BinaryOp.Mul)
).SequenceEqual(
ex2.GetOps())
);
Dictionary <ulong, ID> variables2 = new Dictionary <ulong, ID>();
Option <ID> value2 = ex2.Evaluate(variables2);
Assert.AreEqual(Option.Some(new ID.Integer(9)), value2);
Assert.AreEqual("(1 + 2) * 3", ex2.Print(s2).Get());
}
/// <summary>
/// 查询支持的SQL方法
/// </summary>
/// <param name="dbProvider">数据库提供者（不同数据库的特性）</param>
/// <param name="expBuilder">表达式持久化</param>
/// <param name="name">表名/视图名/存储过程名</param>
internal OracleBuilder(AbsDbProvider dbProvider, ExpressionBuilder expBuilder, string name) : base(dbProvider, expBuilder, name)
{
}
/// <summary>
/// 查询支持的SQL方法
/// </summary>
/// <param name="dbProvider">数据库提供者（不同数据库的特性）</param>
/// <param name="expBuilder">表达式持久化</param>
/// <param name="name">表名/视图名/存储过程名</param>
public OleDbSqlBuilder(AbsDbProvider dbProvider, ExpressionBuilder expBuilder, string name) : base(dbProvider, expBuilder, name)
{
}
object ReplacePrimitiveCastWithConvertMethodCall(CastExpression castExpression, string methodName)
{
ReplaceCurrentNode(ExpressionBuilder.Identifier("Convert").Call(methodName, castExpression.Expression));
return(null);
}
public Query(IEfGraphQLService <GraphQlEfSampleDbContext> efGraphQlService) :
base(efGraphQlService)
{
AddQueryField(
name: "companies",
resolve: context => context.DbContext.Companies);
#endregion
AddSingleField(
resolve: context => context.DbContext.Companies,
name: "company");
AddSingleField(
resolve: context => context.DbContext.Companies,
name: "companyOrNull",
nullable: true);
AddQueryConnectionField(
name: "companiesConnection",
resolve: context => context.DbContext.Companies);
AddQueryField(
name: "employees",
resolve: context => context.DbContext.Employees);
AddQueryField(
name: "employeesByArgument",
resolve: context =>
{
var content = context.GetArgument <string>("content");
return(context.DbContext.Employees.Where(x => x.Content == content));
},
arguments: new QueryArguments(
new QueryArgument <StringGraphType>
{
Name = "content"
}));
AddQueryConnectionField(
name: "employeesConnection",
resolve: context => context.DbContext.Employees);
#region ManuallyApplyWhere
Field <ListGraphType <EmployeeSummaryGraph> >(
name: "employeeSummary",
arguments: new QueryArguments(
new QueryArgument <ListGraphType <WhereExpressionGraph> >
{
Name = "where"
}
),
resolve: context =>
{
var dbContext = ResolveDbContext(context);
IQueryable <Employee> query = dbContext.Employees;
if (context.HasArgument("where"))
{
var wheres = context.GetArgument <List <WhereExpression> >("where");
foreach (var where in wheres)
{
var predicate = ExpressionBuilder <Employee> .BuildPredicate(where);
query = query.Where(predicate);
}
}
return(from q in query
group q by new { q.CompanyId }
into g
select new EmployeeSummary
{
CompanyId = g.Key.CompanyId,
AverageAge = g.Average(x => x.Age),
});
});
#endregion
}
/// <summary>
/// 查询支持的SQL方法
/// </summary>
/// <param name="dbProvider">数据库提供者（不同数据库的特性）</param>
/// <param name="expBuilder">表达式持久化</param>
/// <param name="name">表名/视图名/存储过程名</param>
internal SqLiteSqlBuilder(AbsDbProvider dbProvider, ExpressionBuilder expBuilder, string name) : base(dbProvider, expBuilder, name)
{
}
public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
{
if (destinationType == typeof(string))
{
return(ExpressionBuilder.GetElementDisplayName(value));
}
if (destinationType == typeof(Brush) || destinationType == typeof(ElementCategory))
{
var expressionBuilder = ExpressionBuilder.Unwrap((ExpressionBuilder)value);
var elementAttributes = TypeDescriptor.GetAttributes(expressionBuilder);
var elementCategoryAttribute = (WorkflowElementCategoryAttribute)elementAttributes[typeof(WorkflowElementCategoryAttribute)];
var obsolete = (ObsoleteAttribute)elementAttributes[typeof(ObsoleteAttribute)] != null;
var disabled = expressionBuilder is DisableBuilder;
var workflowElement = ExpressionBuilder.GetWorkflowElement(expressionBuilder);
if (workflowElement != expressionBuilder)
{
var builderCategoryAttribute = elementCategoryAttribute;
elementAttributes = TypeDescriptor.GetAttributes(workflowElement);
elementCategoryAttribute = (WorkflowElementCategoryAttribute)elementAttributes[typeof(WorkflowElementCategoryAttribute)];
obsolete |= (ObsoleteAttribute)elementAttributes[typeof(ObsoleteAttribute)] != null;
if (elementCategoryAttribute == WorkflowElementCategoryAttribute.Default)
{
elementCategoryAttribute = builderCategoryAttribute;
}
}
if (destinationType == typeof(ElementCategory))
{
return(elementCategoryAttribute.Category);
}
switch (elementCategoryAttribute.Category)
{
case ElementCategory.Source:
return(disabled ? HatchBrushes.DiagonalViolet : obsolete?HatchBrushes.CrossViolet : Brushes.Violet);
case ElementCategory.Condition:
return(disabled ? HatchBrushes.DiagonalLightGreen : obsolete?HatchBrushes.CrossLightGreen : Brushes.LightGreen);
case ElementCategory.Transform:
return(disabled ? HatchBrushes.DiagonalWhite : obsolete?HatchBrushes.CrossWhite : Brushes.White);
case ElementCategory.Sink:
return(disabled ? HatchBrushes.DiagonalDarkGray : obsolete?HatchBrushes.CrossDarkGray : Brushes.DarkGray);
case ElementCategory.Nested:
case ElementCategory.Workflow:
return(disabled ? HatchBrushes.DiagonalGoldenrod : obsolete?HatchBrushes.CrossGoldenrod : Brushes.Goldenrod);
case ElementCategory.Property:
return(disabled ? HatchBrushes.DiagonalOrange : obsolete?HatchBrushes.CrossOrange : Brushes.Orange);
case ElementCategory.Combinator:
default:
return(disabled ? HatchBrushes.DiagonalLightBlue : obsolete?HatchBrushes.CrossLightBlue : Brushes.LightBlue);
}
}
if (destinationType == typeof(Type))
{
var expressionBuilder = (ExpressionBuilder)value;
var workflowElement = ExpressionBuilder.GetWorkflowElement(expressionBuilder);
return(workflowElement.GetType());
}
if (destinationType == typeof(Pen))
{
var expressionBuilder = (ExpressionBuilder)value;
return(expressionBuilder.IsBuildDependency() ? DashPen : SolidPen);
}
return(base.ConvertTo(context, culture, value, destinationType));
}
static void Main(string[] args)
{
var con = new SqlConnection(
" Data Source=192.168.13.55;Initial Catalog=SkyChen;Persist Security Info=True;User ID=sa;Password=123456789");
var deleteResult = con.CommandSet <SysUser>().Where(a => a.UserName == "chengong").Delete() > 0;
Console.WriteLine("删除数{0}", deleteResult);
var where = ExpressionBuilder.Init <SysUser>();
con.QuerySet <SysUser>().Where(where).OrderBy(b => b.Email).Top(10).Select(a => a.Email).ToList();
var insertResult2 = con.CommandSet <SysUser>().IfNotExists(a => a.Mobile == "18988563330").Insert(new SysUser
{
CreateDatetime = DateTime.Now,
Email = "*****@*****.**",
Mobile = "18988563330",
RealName = "陈珙",
SysUserid = Guid.NewGuid().ToString("N"),
UserName = "******",
UserStatus = 1,
UserType = 1,
Password = "******"
});
var insertResult = con.CommandSet <SysUser>().Insert(new SysUser
{
CreateDatetime = DateTime.Now,
Email = "*****@*****.**",
Mobile = "18988561111",
RealName = "陈珙",
SysUserid = Guid.NewGuid().ToString("N"),
UserName = "******",
UserStatus = 1,
UserType = 1,
Password = "******"
});
Console.WriteLine("添加数{0}", insertResult);
var countResult = con.QuerySet <SysUser>().Where(a => a.Email == "*****@*****.**").Count();
Console.WriteLine("查询个数{0}", insertResult);
var getResult = con.QuerySet <SysUser>().Where(a => a.Email == "*****@*****.**").Get();
var listResult = con.QuerySet <SysUser>().OrderBy(a => a.CreateDatetime).Select(a => a.Email).ToList();
var listResult2 = con.QuerySet <SysUser>().OrderBy(a => a.CreateDatetime).Top(2).Select(a => a.Email).ToList();
var updateResult = con.CommandSet <SysUser>().Where(a => a.Email == "*****@*****.**")
.Update(a => new SysUser {
UserStatus = 1
});
getResult.Email = "*****@*****.**";
var updateResult2 = con.CommandSet <SysUser>().Where(a => a.Email == "*****@*****.**").Update(getResult);
var updateResult3 = con.QuerySet <SysUser>().Where(a => a.Email == "*****@*****.**").OrderBy(b => b.Email)
.Top(10).Select(a => a.Email).ToList();
var updateResult8 = con.QuerySet <SysUser>().OrderBy(b => b.Email).Top(10).ToList();
var updateResult4 = con.QuerySet <SysUser>().Sum(a => a.UserStatus);
var updateResult5 = con.QuerySet <SysUser>().Where(a => a.Email == "*****@*****.**")
.Select(a => new SysUser {
Email = a.Email
})
.UpdateSelect(a => new SysUser {
Email = "*****@*****.**"
});
var updateResult6 = con.QuerySet <SysUser>().Where(a => a.Email == "*****@*****.**")
.OrderBy(a => a.CreateDatetime)
.Select(a => new SysUser {
Email = a.Email, Mobile = a.Mobile, Password = a.Password
}).PageList(1, 10);
var updateResult7 = con.QuerySet <SysUser>().Where(a => a.Email == "*****@*****.**")
.OrderBy(a => a.CreateDatetime)
.Select(a => new SysUser {
Email = a.Email
})
.UpdateSelect(a => new SysUser {
Email = "*****@*****.**"
});
con.Transaction(tc =>
{
var SysUserid1 = tc.QuerySet <SysUser>().Where(a => a.Mobile == "18988561110").Select(a => a.SysUserid).Get();
var SysUserid2 = tc.QuerySet <SysUser>().Where(a => a.Mobile == "18988561111").Select(a => a.SysUserid).Get();
tc.CommandSet <SysUser>().Where(a => a.SysUserid == SysUserid1).Delete();
tc.CommandSet <SysUser>().Where(a => a.SysUserid == SysUserid2).Delete();
tc.CommandSet <SysUser>().Insert(new SysUser
{
CreateDatetime = DateTime.Now,
Email = "*****@*****.**",
Mobile = "13536059332",
RealName = "大笨贞",
SysUserid = Guid.NewGuid().ToString("N"),
UserName = "******",
UserStatus = 1,
UserType = 1,
Password = "******"
});
});
con.Dispose();
}
internal static ExpressionBuilderGraph UpgradeBuilderNodes(ExpressionBuilderGraph workflow, SemanticVersion version)
{
var argumentCount = new Dictionary <ExpressionBuilder, int>();
GetArgumentCount(workflow, argumentCount);
return(workflow.Convert(builder =>
{
var sourceBuilder = builder as SourceBuilder;
if (sourceBuilder != null)
{
return new CombinatorBuilder
{
Combinator = sourceBuilder.Generator
};
}
var windowWorkflowBuilder = builder as WindowWorkflowBuilder;
if (windowWorkflowBuilder != null)
{
return new CreateObservableBuilder(windowWorkflowBuilder.Workflow)
{
Name = windowWorkflowBuilder.Name,
Description = windowWorkflowBuilder.Description
};
}
var property = builder as ExternalizedProperty;
if (property != null)
{
int count;
if (argumentCount.TryGetValue(property, out count))
{
var mapping = new PropertyMapping();
mapping.Name = property.MemberName;
return new PropertyMappingBuilder {
PropertyMappings = { mapping }
};
}
else
{
var mapping = new ExternalizedMapping();
mapping.Name = property.MemberName;
if (property.Name != property.MemberName)
{
mapping.DisplayName = property.Name;
}
return new ExternalizedMappingBuilder {
ExternalizedProperties = { mapping }
};
}
}
var workflowElement = ExpressionBuilder.GetWorkflowElement(builder);
var parse = workflowElement as ParseBuilder;
if (parse != null && version < RemoveMemberSelectorPrefixVersion)
{
return new ParseBuilder
{
Pattern = parse.Pattern.Replace("%p", "%T")
};
}
var index = workflowElement as Bonsai.Reactive.Index;
if (index != null)
{
return new CombinatorBuilder
{
Combinator = new Bonsai.Reactive.ElementIndex()
};
}
var builderElement = workflowElement as ExpressionBuilder;
if (builderElement != null && version < RemoveMemberSelectorPrefixVersion)
{
var mappingBuilder = builderElement as PropertyMappingBuilder;
if (mappingBuilder != null)
{
foreach (var mapping in mappingBuilder.PropertyMappings)
{
mapping.Selector = RemoveMemberSelectorPrefix(mapping.Selector);
}
var inputMapping = mappingBuilder as InputMappingBuilder;
if (inputMapping != null)
{
inputMapping.Selector = RemoveMemberSelectorPrefix(inputMapping.Selector);
}
}
else
{
var properties = from selectorProperty in TypeDescriptor.GetProperties(builderElement).Cast <PropertyDescriptor>()
where selectorProperty.PropertyType == typeof(string)
let editorAttribute = (EditorAttribute)selectorProperty.Attributes[typeof(EditorAttribute)]
where editorAttribute != null &&
editorAttribute.EditorTypeName.StartsWith("Bonsai.Design.MultiMemberSelectorEditor, Bonsai.Design")
select selectorProperty;
foreach (var selectorProperty in properties)
{
var selector = (string)selectorProperty.GetValue(builderElement);
selectorProperty.SetValue(builderElement, RemoveMemberSelectorPrefix(selector));
}
}
var builderType = builderElement.GetType();
if (builderType.FullName == "Bonsai.IO.CsvWriter")
{
var compatibilityMode = builderType.GetProperty("CompatibilityMode");
if (compatibilityMode != null)
{
compatibilityMode.SetValue(builderElement, true);
}
}
}
return builder;
}));
}
private Expression BuildReaderExpression()
{
if (MappingSchema.IsScalarType(ObjectType))
{
return(new ConvertFromDataReaderExpression(ObjectType, 0, null, DataReaderLocal, DataContext));
}
var entityDescriptor = MappingSchema.GetEntityDescriptor(ObjectType);
var inheritanceMapping = entityDescriptor.InheritanceMapping;
if (inheritanceMapping.Count == 0)
{
return(BuildReadExpression(true, ObjectType));
}
Expression?expr = null;
var defaultMapping = inheritanceMapping.SingleOrDefault(m => m.IsDefault);
if (defaultMapping != null)
{
expr = Expression.Convert(
BuildReadExpression(false, defaultMapping.Type),
ObjectType);
}
else
{
var exceptionMethod = MemberHelper.MethodOf(() => DefaultInheritanceMappingException(null !, null !));
var dindex = GetReaderIndex(entityDescriptor, null, inheritanceMapping[0].DiscriminatorName);
if (dindex >= 0)
{
expr = Expression.Convert(
Expression.Call(null, exceptionMethod,
Expression.Call(
DataReaderLocal,
ReflectionHelper.DataReader.GetValue,
Expression.Constant(dindex)),
Expression.Constant(ObjectType)),
ObjectType);
}
}
if (expr == null)
{
return(BuildReadExpression(true, ObjectType));
}
foreach (var mapping in inheritanceMapping.Select((m, i) => new { m, i }).Where(m => m.m != defaultMapping))
{
var ed = MappingSchema.GetEntityDescriptor(mapping.m.Type);
var dindex = GetReaderIndex(ed, null, mapping.m.DiscriminatorName);
if (dindex >= 0)
{
Expression testExpr;
var isNullExpr = Expression.Call(
DataReaderLocal,
ReflectionHelper.DataReader.IsDBNull,
Expression.Constant(dindex));
if (mapping.m.Code == null)
{
testExpr = isNullExpr;
}
else
{
var codeType = mapping.m.Code.GetType();
testExpr = ExpressionBuilder.Equal(
MappingSchema,
new ConvertFromDataReaderExpression(codeType, dindex, mapping.m.Discriminator.ValueConverter, DataReaderLocal, DataContext),
Expression.Constant(mapping.m.Code));
if (mapping.m.Discriminator.CanBeNull)
{
testExpr =
Expression.AndAlso(
Expression.Not(isNullExpr),
testExpr);
}
}
expr = Expression.Condition(
testExpr,
Expression.Convert(BuildReadExpression(false, mapping.m.Type),
ObjectType),
expr);
}
}
return(expr);
}
/// <summary>
/// Retrieves items where any of the defined properties
/// are greater than any of the supplied <paramref name="value">value</paramref>
/// </summary>
public QueryableChildSearch <TParent, TChild, TProperty> Between(TProperty minvalue, TProperty maxValue)
{
AppendExpression(ExpressionBuilder.BetweenExpression(Properties, minvalue, maxValue));
return(this);
}
/// <summary>
/// Retrieves items where any of the defined properties
/// are greater than any of the supplied <paramref name="value">value</paramref>
/// </summary>
/// <param name="value">A collection of values to match upon</param>
public QueryableChildSearch <TParent, TChild, TProperty> LessThanOrEqualTo(TProperty value)
{
AppendExpression(ExpressionBuilder.LessThanOrEqualExpression(Properties, value));
return(this);
}
/// <summary>
/// Retrieves items where any of the defined properties
/// are equal to any of the supplied <paramref name="values">values</paramref>
/// </summary>
/// <param name="values">A collection of values to match upon</param>
public QueryableChildSearch <TParent, TChild, TProperty> EqualTo(params TProperty[] values)
{
AppendExpression(ExpressionBuilder.EqualsExpression(Properties, values));
return(this);
}
static void Main(string[] args)
{
ExpressionBuilder eb = "MyColum";
eb.Equal("val1").And(ExpressionBuilder.Group(new ExpressionBuilder("Column2")
.GreaterThan("29").And("Column3").SmallerThan("20")).Or("foo").NotEqual("bar"));
Console.WriteLine((string)eb);
Console.ReadLine();
int cnt = 10000000;
Stopwatch stopWatch = new Stopwatch();
//Dictionary<string, string> D = new Dictionary<string, string>();
//for(int i= 0; i < 10000000; i++)
//{
// D.Add("Dict " + i, "val " + i);
//}
//stopWatch.Start();
//var test = D["Dict " + 675000];
//stopWatch.Stop();
//Console.WriteLine(test);
//Console.WriteLine(stopWatch.ElapsedMilliseconds + " ms");
//Console.ReadLine();
ISerialization serializer = Serializer.Instance;
IApi api = Seal.GetInstance();
api.Serializer = serializer;
api.Init <Employee>();
Employee jbo = new Employee();
jbo.Id = 210801;
jbo.LastModified = DateTime.Now;
jbo.Created = DateTime.Now;
jbo.Name = "Andika";
jbo.NickName = null;
jbo.Code = "aap";
jbo.Leader = null;
IList <object> des = new List <object>();
des.Add("Code");
des.Add("Name");
des.Add("NickName");
des.Add("210801");
des.Add(Stts.Permanent);
des.Add(1);
des.Add(123);
des.Add(DateTime.Now);
des.Add(DateTime.Now);
stopWatch = new Stopwatch();
stopWatch.Start();
IList <Employee> empList = new List <Employee>();
for (int i = 0; i < cnt; i++)
{
Employee objt = serializer.Deserialize <Employee>(des);
objt.SetJoinedObjValue("Leader", jbo);
empList.Add(objt);
}
stopWatch.Stop();
Console.WriteLine("Deserialize " + cnt);
Console.WriteLine("Total time: " + stopWatch.ElapsedMilliseconds + "ms");
Console.WriteLine("Average time: " + (double)stopWatch.ElapsedMilliseconds / (double)cnt + "ms");
Console.WriteLine("============");
IList <IList <object> > listAll = new List <IList <object> >();
stopWatch = new Stopwatch();
stopWatch.Start();
Employee obj = new Employee();
obj.Id = 1;
obj.LastModified = DateTime.Now;
obj.Created = DateTime.Now;
obj.Name = "Septian";
obj.NickName = null;
obj.Code = "Seal";
obj.Leader = jbo;
obj.Status = 0;
for (int i = 0; i < cnt; i++)
{
IList <object> raw = serializer.Serialize <Employee>(obj);
listAll.Add(raw);
}
stopWatch.Stop();
Console.WriteLine("Serialize " + cnt);
Console.WriteLine("Total time: " + stopWatch.ElapsedMilliseconds + "ms");
Console.WriteLine("Average time: " + (double)stopWatch.ElapsedMilliseconds / (double)cnt + "ms");
Console.ReadLine();
//ModelFactory q = ModelFactory.GetInstance();
//TableInfo ti = q["Employee"];
//Console.WriteLine("ob");
//Employee.InitMapping<Employee>();
//Timer t = new Timer();
//t.Start();
//EmployeeDao empDao = new EmployeeDao();
//BusinessEntityDao beDao = new BusinessEntityDao();
//seal.Transactor.setConnection(seal.Transactor.ConnectionStringBuilder("SEPTIAN-WST\\SQLSERVER", "AdventureWorks2019", "septianPr", "septian13"));
//List<Employee> empList = empDao.QueryBuilderSelect();
//int i = 0;
//foreach(Employee emp in empList)
//{
// Console.Write(++i + " | ");
// Console.Write(emp.KTP + " | ");
// Console.Write(emp.LoginID + " | ");
// Console.Write(emp.JobTitle + " | ");
// Console.Write(emp.OrgLevel.RowGuID + " | ");
// Console.WriteLine(emp.LastModified );
//}
//t.Stop();
//Console.WriteLine("\n\r\n\r\n\r Done ->" + i + " Data... Elapsed time: " + t.Interval / 1000 + " seconds");
//Console.ReadLine();
}
public override object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
{
if (!IsClassType(ClassType.Interface) && (propertyDeclaration.Modifier & Modifiers.Visibility) == 0)
{
propertyDeclaration.Modifier |= Modifiers.Private;
}
base.VisitPropertyDeclaration(propertyDeclaration, data);
ToVBNetRenameConflictingVariablesVisitor.RenameConflicting(propertyDeclaration);
if (!IsClassType(ClassType.Interface) && (propertyDeclaration.Modifier & Modifiers.Abstract) == 0)
{
if (propertyDeclaration.HasGetRegion && propertyDeclaration.HasSetRegion)
{
if (propertyDeclaration.GetRegion.Block.IsNull && propertyDeclaration.SetRegion.Block.IsNull)
{
// automatically implemented property
string fieldName = "m_" + propertyDeclaration.Name;
Modifiers fieldModifier = propertyDeclaration.Modifier & ~(Modifiers.Visibility) | Modifiers.Private;
FieldDeclaration newField = new FieldDeclaration(null, propertyDeclaration.TypeReference, fieldModifier);
newField.Fields.Add(new VariableDeclaration(fieldName));
InsertAfterSibling(propertyDeclaration, newField);
propertyDeclaration.GetRegion.Block = new BlockStatement();
propertyDeclaration.GetRegion.Block.Return(ExpressionBuilder.Identifier(fieldName));
propertyDeclaration.SetRegion.Block = new BlockStatement();
propertyDeclaration.SetRegion.Block.Assign(ExpressionBuilder.Identifier(fieldName), ExpressionBuilder.Identifier("Value"));
}
}
}
return(null);
}
protected abstract bool ContainsMapping(ExpressionBuilder builder, TMapping mapping);
public SearchQuery(ExpressionBuilder <TDocument> expressionBuilder)
{
this._expressionBuilder = expressionBuilder;
}
private protected abstract Expression BuildLifetimeAppliedExpression(ExpressionBuilder expressionBuilder,
ServiceRegistration serviceRegistration, ResolutionContext resolutionContext, Type requestedType);
public CustomQuery(Expression <Func <TEntity, bool> > expresion)
{
var predicate = (Expression <Func <TEntity, bool> >)ExpressionBuilder.ReplaceFilterValues(expresion);
SerializedExpression = new ExpressionSerializer().Serialize(predicate).ToString();
}
public bool CanBuild(ExpressionBuilder builder, BuildInfo buildInfo)
{
var call = buildInfo.Expression as MethodCallExpression;
return(call != null && call.Method.Name == "GetMyContext");
}
public async Task <IActionResult> List(string searchContent, string seniorQueryJson, int page = 1, int limit = 10, string sidx = "CreateDt", string sord = "desc")
{
try
{
SysRole query = null;
if (!string.IsNullOrEmpty(seniorQueryJson))
{
query = Newtonsoft.Json.JsonConvert.DeserializeObject <SysRole>(seniorQueryJson);
}
System.Linq.Expressions.Expression <Func <SysRole, bool> > predicate = ExpressionBuilder.True <SysRole>();
predicate = predicate.And(b => b.Id > 0);
if (searchContent != null)
{
predicate = predicate.And(b => b.RoleName.IndexOf(searchContent) != -1);
}
PageInfo pageinfo = new PageInfo {
};
(List <SysRole> list, long count)datas = await SysRoleDAL.QueryAsync(predicate, null, pageinfo);
var lists = datas.list;
return(lists.GetJson <SysRole>(sidx, sord, page, limit, SysTool.GetPropertyNameArray <SysRole>()));
}
catch (Exception ex)
{
throw ex;
}
}
public IBuildContext BuildSequence(ExpressionBuilder builder, BuildInfo buildInfo)
{
var call = (MethodCallExpression)buildInfo.Expression;
return(new Context(builder.BuildSequence(new BuildInfo(buildInfo, call.Arguments[0]))));
}
public SequenceConvertInfo Convert(ExpressionBuilder builder, BuildInfo buildInfo, ParameterExpression param)
{
return(null);
}
public Be(ExpressionBuilder expression, RWebElement rWebElement, AutomationManager automationManager)
{
_expression = expression;
_rWebElement = rWebElement;
_automationManager = automationManager;
}
public bool IsSequence(ExpressionBuilder builder, BuildInfo buildInfo)
{
return(builder.IsSequence(new BuildInfo(buildInfo, ((MethodCallExpression)buildInfo.Expression).Arguments[0])));
}
/// <summary>
/// Retrieves items where any of the defined properties
/// are greater than any of the supplied <paramref name="value">value</paramref>
/// </summary>
/// <param name="value">A collection of values to match upon</param>
public QueryableChildSearch <TParent, TChild, TProperty> GreaterThan(TProperty value)
{
AppendExpression(ExpressionBuilder.GreaterThanExpression(Properties, value));
return(this);
}
INode InitStaticVariable(string initFieldName, string variableName, Expression initializer, TypeDeclaration typeDeclaration)
{
const string helperMethodName = "InitStaticVariableHelper";
if (typeDeclaration != null)
{
if (!typeDeclaration.Children.OfType <MethodDeclaration>().Any(m => m.Name == helperMethodName))
{
// add helper method
var helperMethod = new MethodDeclaration {
Name = helperMethodName,
Modifier = Modifiers.Static,
TypeReference = new TypeReference("System.Boolean", true),
Parameters =
{
new ParameterDeclarationExpression(new TypeReference("Microsoft.VisualBasic.CompilerServices.StaticLocalInitFlag"), "flag")
},
Body = new BlockStatement()
};
BlockStatement trueBlock = new BlockStatement();
BlockStatement elseIfBlock = new BlockStatement();
BlockStatement falseBlock = new BlockStatement();
helperMethod.Body.AddStatement(
new IfElseStatement(ExpressionBuilder.Identifier("flag").Member("State").Operator(BinaryOperatorType.Equality, new PrimitiveExpression(0)))
{
TrueStatement = { trueBlock },
ElseIfSections =
{
new ElseIfSection(ExpressionBuilder.Identifier("flag").Member("State").Operator(BinaryOperatorType.Equality, new PrimitiveExpression(2)), elseIfBlock)
},
FalseStatement = { falseBlock }
});
trueBlock.Assign(ExpressionBuilder.Identifier("flag").Member("State"), new PrimitiveExpression(2));
trueBlock.Return(new PrimitiveExpression(true));
elseIfBlock.Throw(new TypeReference("Microsoft.VisualBasic.CompilerServices.IncompleteInitialization").New());
falseBlock.Return(new PrimitiveExpression(false));
typeDeclaration.AddChild(helperMethod);
}
}
BlockStatement tryBlock = new BlockStatement();
BlockStatement ifTrueBlock = new BlockStatement();
tryBlock.AddStatement(new IfElseStatement(ExpressionBuilder.Identifier(helperMethodName).Call(ExpressionBuilder.Identifier(initFieldName)), ifTrueBlock));
ifTrueBlock.Assign(ExpressionBuilder.Identifier(variableName), initializer);
BlockStatement finallyBlock = new BlockStatement();
finallyBlock.Assign(ExpressionBuilder.Identifier(initFieldName).Member("State"), new PrimitiveExpression(1));
BlockStatement lockBlock = new BlockStatement();
lockBlock.AddStatement(new TryCatchStatement(tryBlock, null, finallyBlock));
return(new LockStatement(ExpressionBuilder.Identifier(initFieldName), lockBlock));
}
