public void WhereOperationAdd() { var c = new ObservableCollection<NotificationObject<string>>() { new NotificationObject<string>() { Value1 = "Test1" }, new NotificationObject<string>() { Value1 = "Test2" }, new NotificationObject<string>() { Value1 = "Test3" }, }; var op = new WhereOperation<NotificationObject<string>>(new OperationContext(), Expression.Call( typeof(Queryable).GetMethods() .Where(i => i.Name == "Where") .Where(i => i.IsGenericMethodDefinition) .Where(i => i.GetGenericArguments().Length == 1) .Select(i => i.MakeGenericMethod(typeof(NotificationObject<string>))) .Where(i => i.GetParameters().Length == 2) .Where(i => i.GetParameters()[1].ParameterType == typeof(Expression<Func<NotificationObject<string>, bool>>)) .Single(), new ObservableQuery<NotificationObject<string>>(c).Expression, Expression.Lambda<Func<NotificationObject<string>, bool>>( Expression.Constant(true), Expression.Parameter(typeof(NotificationObject<string>), "i")))); Assert.AreEqual(3, op.Value.Count()); c.Add(new NotificationObject<string>() { Value1 = "Test4" }); Assert.AreEqual(4, op.Value.Count()); }
//internal WhereCondition() //{ //} public WhereCondition(string field, WhereOperation operation, object value) { Field = field; Operation = operation; if (value != null) { Value = operation == WhereOperation.In ? value : value.ToString().Replace("'", "''").Replace("_", "\\_"); } }
public void WhereOperationPredicate() { var c = new ObservableCollection<NotificationObject<string>>() { new NotificationObject<string>() { Value1 = "False" }, new NotificationObject<string>() { Value1 = "True" }, new NotificationObject<string>() { Value1 = "False" }, }; var op = new WhereOperation<NotificationObject<string>>(new OperationContext(), Expression.Call( typeof(Queryable).GetMethods() .Where(i => i.Name == "Where") .Where(i => i.IsGenericMethodDefinition) .Where(i => i.GetGenericArguments().Length == 1) .Select(i => i.MakeGenericMethod(typeof(NotificationObject<string>))) .Where(i => i.GetParameters().Length == 2) .Where(i => i.GetParameters()[1].ParameterType == typeof(Expression<Func<NotificationObject<string>, bool>>)) .Single(), new ObservableQuery<NotificationObject<string>>(c).Expression, Expression.Lambda<Func<NotificationObject<string>, bool>>( Expression.Equal( Expression.MakeMemberAccess( Expression.Parameter(typeof(NotificationObject<string>), "i"), typeof(NotificationObject<string>).GetProperty("Value1")), Expression.Constant("True", typeof(string))), Expression.Parameter(typeof(NotificationObject<string>), "i")))); Assert.AreEqual(1, op.Value.Count()); c.Add(new NotificationObject<string>() { Value1 = "False" }); Assert.AreEqual(1, op.Value.Count()); c.Add(new NotificationObject<string>() { Value1 = "True" }); Assert.AreEqual(2, op.Value.Count()); c.Add(new NotificationObject<string>() { Value1 = "True" }); Assert.AreEqual(3, op.Value.Count()); c.RemoveAt(1); Assert.AreEqual(2, op.Value.Count()); c[0].Value1 = "True"; Assert.AreEqual(3, op.Value.Count()); c[1].Value1 = "True"; Assert.AreEqual(4, op.Value.Count()); }
public static IQueryable <T> Where <T>(this IQueryable <T> query, string column, object value, WhereOperation operation) { if (string.IsNullOrEmpty(column)) { return(query); } ParameterExpression parameter = Expression.Parameter(query.ElementType, "p"); MemberExpression memberAccess = null; foreach (var property in column.Split('.')) { memberAccess = MemberExpression.Property (memberAccess ?? (parameter as Expression), property); } //change param value type //necessary to getting bool from string ConstantExpression filter = Expression.Constant ( Convert.ChangeType(value, memberAccess.Type) ); //switch operation Expression condition = null; LambdaExpression lambda = null; switch (operation) { //equal == case WhereOperation.Equal: condition = Expression.Equal(memberAccess, filter); lambda = Expression.Lambda(condition, parameter); break; //not equal != case WhereOperation.NotEqual: condition = Expression.NotEqual(memberAccess, filter); lambda = Expression.Lambda(condition, parameter); break; //string.Contains() case WhereOperation.Contains: condition = Expression.Call(memberAccess, typeof(string).GetMethod("Contains"), Expression.Constant(value)); lambda = Expression.Lambda(condition, parameter); break; } MethodCallExpression result = Expression.Call( typeof(Queryable), "Where", new[] { query.ElementType }, query.Expression, lambda); return(query.Provider.CreateQuery <T>(result)); }
/// <summary> /// Inner Join。Lambda写法:.InnerJoin<Model2>((a, b) => a.ID == b.ID) /// </summary> /// <typeparam name="TEntity"></typeparam> /// <param name="where"></param> /// <param name="asName"></param> /// <param name="asName2"></param> /// <returns></returns> public Search <T> InnerJoin <TEntity>(WhereOperation where, string asName = "", string asName2 = "") where TEntity : Entity { return(Join(EntityCache.GetTableName <TEntity>(), EntityCache.GetUserName <TEntity>(), where, JoinType.InnerJoin)); }
public TextualWhereCondition(WhereOperation op, string column, object value) { WhereOperation = op; Column = column; Value = value; }
/// <summary> /// Having /// </summary> public new Search <T> Having(WhereOperation havingWhere) { return((Search <T>)base.Having(havingWhere)); }
/// <summary> /// whereclip /// </summary> public new Search <T> Where(WhereOperation where) { return((Search <T>)base.Where(where)); }
/// <summary> /// 连接 /// </summary> /// <param name="tableName"></param> /// <param name="userName"></param> /// <param name="where"></param> /// <param name="joinType"></param> /// <returns></returns> private Search <T> Join(string tableName, string userName, WhereOperation where, JoinType joinType) { return((Search <T>)base.join(tableName, userName, where, joinType)); }
/// <summary> /// Full Join /// </summary> /// <typeparam name="TEntity"></typeparam> /// <param name="where"></param> /// <returns></returns> public Search <T> FullJoin <TEntity>(WhereOperation where) where TEntity : Entity { return(Join(EntityCache.GetTableName <TEntity>(), EntityCache.GetUserName <TEntity>(), where, JoinType.FullJoin)); }
/// <summary> /// 创建更新DbCommand /// </summary> /// <typeparam name="TEntity"></typeparam> /// <param name="fields"></param> /// <param name="values"></param> /// <param name="where"></param> /// <returns></returns> public DbCommand CreateUpdateCommand <TEntity>(Field[] fields, object[] values, WhereOperation where) where TEntity : Entity { Check.Require(!EntityCache.IsReadOnly <TEntity>(), string.Concat("Entity(", EntityCache.GetTableName <TEntity>(), ") is readonly!")); if (null == fields || fields.Length == 0 || null == values || values.Length == 0) { return(null); } Check.Require(fields.Length == values.Length, "fields.Length must be equal values.Length"); var length = fields.Length; if (WhereOperation.IsNullOrEmpty(where)) { where = WhereOperation.All; } var sql = new StringBuilder(); sql.Append("UPDATE "); sql.Append(db.DbProvider.BuildTableName(EntityCache.GetTableName <TEntity>(), EntityCache.GetUserName <TEntity>())); sql.Append(" SET "); var identityField = EntityCache.GetIdentityField <TEntity>(); var identityExist = !Field.IsNullOrEmpty(identityField); var list = new List <Parameter>(); var colums = new StringBuilder(); for (var i = 0; i < length; i++) { if (identityExist) { //标识列 排除 if (fields[i].PropertyName.Equals(identityField.PropertyName)) { continue; } } colums.Append(","); colums.Append(fields[i].FieldName); colums.Append("="); if (values[i] is Expression) { var expression = (Expression)values[i]; colums.Append(expression); list.AddRange(expression.Parameters); } else if (values[i] is Field) { var fieldValue = (Field)values[i]; colums.Append(fieldValue.TableFieldName); } else { var pname = DataUtils.MakeUniqueKey(fields[i]); //var pname = string.Concat("@", fields[i].Name, i); colums.Append(pname); var p = new Parameter(pname, values[i], fields[i].ParameterDbType, fields[i].ParameterSize); list.Add(p); } } sql.Append(colums.ToString().Substring(1)); sql.Append(where.WhereString); list.AddRange(where.Parameters); var cmd = db.GetSqlStringCommand(sql.ToString()); db.AddCommandParameter(cmd, list.ToArray()); return(cmd); }
/// <summary> /// 创建删除DbCommand /// </summary> /// <param name="where"></param> /// <returns></returns> public DbCommand CreateDeleteCommand <TEntity>(WhereOperation where) where TEntity : Entity { return(CreateDeleteCommand(EntityCache.GetTableName <TEntity>(), EntityCache.GetUserName <TEntity>(), where)); }
public static IQueryable <T> Where <T>(this IQueryable <T> query, string column, object value, WhereOperation operation) { if (string.IsNullOrEmpty(column)) { return(query); } var parameter = Expression.Parameter(query.ElementType, "p"); var memberAccess = column.Split('.').Aggregate <string, MemberExpression>(null, (current, property) => Expression.Property(current ?? (parameter as Expression), property)); //change param value type necessary to getting bool from string ConstantExpression filter = null; try { filter = Expression.Constant ( Convert.ChangeType(value, memberAccess.Type, CultureInfo.InvariantCulture) ); } catch { return(query); } //switch operation LambdaExpression lambda = null; try { Expression condition = null; switch (operation) { case WhereOperation.Equal: condition = Expression.Equal(memberAccess, filter); lambda = Expression.Lambda(condition, parameter); break; case WhereOperation.NotEqual: condition = Expression.NotEqual(memberAccess, filter); lambda = Expression.Lambda(condition, parameter); break; case WhereOperation.Contains: condition = Expression.Call(memberAccess, typeof(string).GetMethod("Contains"), Expression.Constant(value)); lambda = Expression.Lambda(condition, parameter); break; } } catch { return(query); } var result = Expression.Call( typeof(Queryable), "Where", new[] { query.ElementType }, query.Expression, lambda); return(query.Provider.CreateQuery <T>(result)); }