/// <summary> /// 构造函数 /// </summary> /// <param name="relation">条件组和其他条件组或条件的关系</param> /// <param name="condition">条件组和其他条件组或条件的关系</param> /// <param name="conditions">条件组中所包含的各种条件对象</param> public ConditionGroup(ConditionRelation relation, ICondition condition, params ICondition[] conditions) : this() { ConditionGroup group = null; if (condition != null) { if (condition is Condition) { this.ConditionCollection.Add((Condition)condition); } else if (condition is ConditionGroup) { group = (ConditionGroup)condition; group.GroupIndex = this.subGroup.Count + 1; this.AddSubGroup(group); } } if (conditions != null) { foreach (ICondition paramCond in conditions) { if (paramCond is Condition) { this.ConditionCollection.Add((Condition)paramCond); } else if (paramCond is ConditionGroup) { group = (ConditionGroup)paramCond; group.GroupIndex = this.subGroup.Count + 1; this.AddSubGroup(group); } } } }
public Automation WithCondition(ConditionRelation relation, Condition condition) { if (condition == null) throw new ArgumentNullException(nameof(condition)); Conditions.Add(new RelatedCondition().WithCondition(condition).WithRelation(relation)); return this; }
public SimpleQueryCondition(string field, string param, object value, ConditionRelation relation) { Field = field; Value = value; Relation = relation; Param = param; }
public void Not() { ConditionRelation = ConditionRelation == ConditionRelation.And ? ConditionRelation.Or : ConditionRelation.And; foreach (ConditionExpression item in this) { item.Not(); } }
public void AddCondition(ConditionRelation relation, Condition condition) { if (condition == null) { throw new ArgumentNullException(nameof(condition)); } _conditionsValidator.WithCondition(relation, condition); }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">条件关联关系</param> /// <param name="column">条件关联字段</param> public Condition(ConditionRelation relation, SearchColumn column) { this.relation = relation; if (column != null) { this.searchColumn = column; this.searchColumn.ConditionCollection.Add(this); } }
public ConditionalAction WithCondition(ConditionRelation relation, Condition condition) { if (condition == null) { throw new ArgumentNullException(nameof(condition)); } AddCondition(relation, condition); return(this); }
public Condition WithRelatedCondition(ConditionRelation relation, Condition condition) { if (condition == null) { throw new ArgumentNullException(nameof(condition)); } RelatedConditions.Add(new RelatedCondition().WithCondition(condition).WithRelation(relation)); return(this); }
public TurnOnAndOffAutomation WithTurnOffCondition(ConditionRelation relation, ICondition condition) { if (condition == null) { throw new ArgumentNullException(nameof(condition)); } _turnOffConditionsValidator.WithCondition(relation, condition); return(this); }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">条件关联关系</param> /// <param name="column">条件关联字段</param> public Condition(ConditionRelation relation, SearchColumn column) { this.relation = relation; if (column != null) { this.searchColumn = column; this.searchColumn.ConditionCollection.Add(this); } }
public ICondition Or(ICondition conditionExpression) { if (ConditionRelation == ConditionRelation.Or) { if (conditionExpression is IConditionExpression) { Add(conditionExpression); } else { IConditionExpressionCollection conditionCollection = (IConditionExpressionCollection)conditionExpression; if (conditionCollection.ConditionRelation == ConditionRelation.Or) { foreach (ICondition item in conditionCollection) { Add(item); } } else { Add(conditionCollection); } } } else { IConditionExpressionCollection cs = Copy(); Items.Clear(); Add(cs); ConditionRelation = ConditionRelation.Or; if (conditionExpression is IConditionExpression) { Add(conditionExpression); } else { IConditionExpressionCollection conditionCollection = (IConditionExpressionCollection)conditionExpression; if (conditionCollection.ConditionRelation == ConditionRelation.Or) { foreach (ICondition item in conditionCollection) { Add(item); } } else { Add(conditionCollection); } } } return(this); }
/// <summary> /// 添加对某个字段的限定,并指定与已存在之间的关系 /// </summary> /// <param name="relPrefix">已存在之间的关系</param> /// <param name="FieldName">字段名称</param> /// <param name="rel">与限定值直接的关系</param> /// <param name="val">The val.</param> /// <returns></returns> public RowCondition AddWithRelation(ConditionRelation relPrefix, string FieldName, ConditionRelation rel, object val) { if (ConditionList.Count > 0) { ConditionList.Add(relPrefix); } ConditionList.Add(FieldName); ConditionList.Add(rel); ConditionList.Add(val); return(this); }
/// <summary> /// 返回条件连接关键字,默认返回And /// </summary> /// <returns>返回条件连接关键字字符串,默认返回And</returns> protected virtual string RelationParse(ConditionRelation relation) { switch (relation) { case ConditionRelation.And: return(" AND "); case ConditionRelation.Or: return(" OR "); default: return(" AND "); } }
private static ConditionGroup AddCondition(ConditionRelation relation, ICondition condition1, ICondition condition2, params ICondition[] conditions) { ConditionGroup newGroup = new ConditionGroup(); List <ICondition> conditionList = new List <ICondition>(); conditionList.Add(condition1); conditionList.Add(condition2); if (conditions != null) { conditionList.AddRange(conditions); } Condition paramCondition = null; ConditionGroup conditionGroup = null; int groupIndex = 1; int conditionIndex = 1; foreach (ICondition con in conditionList) { if (con is ConditionGroup) { conditionGroup = (ConditionGroup)con; conditionGroup.GroupIndex = groupIndex; conditionGroup.GroupRelation = relation; newGroup.AddSubGroup(conditionGroup); groupIndex++; } else if (con is Condition) { paramCondition = (Condition)con; paramCondition.Index = conditionIndex; paramCondition.Group = newGroup; paramCondition.Relation = relation; conditionIndex++; } } return(newGroup); }
/// <summary> /// 子查询不等于条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="sql">子查询SQL</param> /// <returns>返回子查询不等于条件对象</returns> public static SQLNotEqualCondition SQLNotEqual(ConditionRelation relation, string sql) { SQLNotEqualCondition cond = new SQLNotEqualCondition(relation, sql); return cond; }
/// <summary> /// Between条件,用于查询介于两个值之间的值 /// </summary> /// <param name="relation">条件关系</param> /// <param name="column">查询字段对象</param> /// <param name="stratVal">开始值</param> /// <param name="endVal">结束值</param> /// <returns>返回Between条件对象</returns> public static BetweenCondition Between(ConditionRelation relation, SearchColumn column, object stratVal, object endVal) { BetweenCondition cond = new BetweenCondition(relation, column, stratVal, endVal); return cond; }
/// <summary> /// 非相似条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="column">查询字段对象</param> /// <param name="paramVal">比较的值</param> /// <returns>返回非相似条件对象</returns> public static NotLikeCondition NotLike(ConditionRelation relation, SearchColumn column, object paramVal) { NotLikeCondition cond = new NotLikeCondition(relation, column, paramVal); return cond; }
/// <summary> /// 小于等于条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="paramVal">比较的值</param> /// <returns>返回小于等于条件对象</returns> public static LessEqualCondition LessEqual(ConditionRelation relation, object paramVal) { LessEqualCondition cond = new LessEqualCondition(relation, paramVal); return cond; }
/// <summary> /// 相似条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="paramVal">比较的值</param> /// <returns>返回相似条件对象</returns> public static LikeCondition Like(ConditionRelation relation, object paramVal) { LikeCondition cond = new LikeCondition(relation, paramVal); return cond; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">条件组和其他条件组或条件的关系</param> /// <param name="groupIndex">组的排序序号</param> public ConditionGroup(ConditionRelation relation, int groupIndex) : this(groupIndex) { this.GroupRelation = relation; }
/// <summary> /// 大于等于条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="column">查询字段对象</param> /// <param name="paramVal">比较的值</param> /// <returns>返回大于等于条件对象</returns> public static LargeEqualCondition LargeEqual(ConditionRelation relation, SearchColumn column, object paramVal) { LargeEqualCondition cond = new LargeEqualCondition(relation, column, paramVal); return cond; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="sql">子查询语句</param> public SQLInCondition(ConditionRelation relation, string sql) : this(relation, null, sql) { }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">条件组和其他条件组或条件的关系</param> /// <param name="condition">条件组和其他条件组或条件的关系</param> /// <param name="conditions">条件组中所包含的各种条件对象</param> public ConditionGroup(ConditionRelation relation, ICondition condition, params ICondition[] conditions) : this() { ConditionGroup group = null; if (condition != null) { if (condition is Condition) { this.ConditionCollection.Add((Condition)condition); } else if (condition is ConditionGroup) { group = (ConditionGroup)condition; group.GroupIndex = this.subGroup.Count + 1; this.AddSubGroup(group); } } if (conditions != null) { foreach (ICondition paramCond in conditions) { if (paramCond is Condition) { this.ConditionCollection.Add((Condition)paramCond); } else if (paramCond is ConditionGroup) { group = (ConditionGroup)paramCond; group.GroupIndex = this.subGroup.Count + 1; this.AddSubGroup(group); } } } }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">条件关联关系</param> public Condition(ConditionRelation relation) : this(relation, null) { }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="column">查询字段对象</param> public IsNotNullCondition(ConditionRelation relation, SearchColumn column) : base(relation, column) { }
public ConditionsValidator WithCondition(ConditionRelation relation, Condition condition) { Conditions.Add(new RelatedCondition().WithRelation(relation).WithCondition(condition)); return this; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="column">查询字段对象</param> /// <param name="paramValue">条件的值</param> public NotLikeCondition(ConditionRelation relation, SearchColumn column, object paramValue) : base(relation, column) { this.ParamValue = paramValue; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="column">查询字段对象</param> /// <param name="startValue">赋值开始的值</param> /// <param name="endValue">赋值结束的值</param> public BetweenCondition(ConditionRelation relation, SearchColumn column, object startValue, object endValue) : base(relation, column) { this.StartValue = startValue; this.EndValue = endValue; }
/// <summary> /// 子查询非包含条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="column">查询字段对象</param> /// <param name="sql">子查询SQL</param> /// <returns>返回子查询非包含条件对象</returns> public static SQLNotInCondition SQLNotIn(ConditionRelation relation, SearchColumn column, string sql) { SQLNotInCondition cond = new SQLNotInCondition(relation, column, sql); return cond; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">条件组和其他条件组或条件的关系</param> public ConditionGroup(ConditionRelation relation) : this() { this.GroupRelation = relation; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="column">查询字段对象</param> /// <param name="sql">子查询sql语句</param> public SQLEqualCondition(ConditionRelation relation, SearchColumn column, string sql) : base(relation, column) { this.SQL = sql; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">条件组和其他条件组或条件的关系</param> /// <param name="groupIndex">组的排序序号</param> public ConditionGroup(ConditionRelation relation, int groupIndex) : this(groupIndex) { this.GroupRelation = relation; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="column">查询字段对象</param> /// <param name="sql">子查询sql语句</param> public SQLEqualCondition(ConditionRelation relation, SearchColumn column, string sql) : base(relation, column) { this.SQL = sql; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="sql">子查询语句</param> public NotExistsCondition(ConditionRelation relation, string sql) : this(relation, null, sql) { }
/// <summary> /// 大于条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="paramVal">比较的值</param> /// <returns>返回大于条件对象</returns> public static LargeThanCondition LargeThan(ConditionRelation relation, object paramVal) { LargeThanCondition cond = new LargeThanCondition(relation, paramVal); return cond; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="column">查询字段对象</param> /// <param name="sql">子查询语句</param> public NotExistsCondition(ConditionRelation relation, SearchColumn column, string sql) : base(relation, column) { this.SQL = sql; }
/// <summary> /// 小于条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="column">查询字段对象</param> /// <param name="paramVal">比较的值</param> /// <returns>返回小于条件对象</returns> public static LessThanCondition LessThan(ConditionRelation relation, SearchColumn column, object paramVal) { LessThanCondition cond = new LessThanCondition(relation, column, paramVal); return cond; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="sql">子查询语句</param> public NotExistsCondition(ConditionRelation relation, string sql) : this(relation, null, sql) { }
/// <summary> /// 不等于条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="paramVal">比较的值</param> /// <returns>返回不等于条件对象</returns> public static NotEqualCondition NotEqual(ConditionRelation relation, object paramVal) { NotEqualCondition cond = new NotEqualCondition(relation, paramVal); return cond; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> public IsNotNullCondition(ConditionRelation relation) : this(relation, null) { }
/// <summary> /// 非包含集合条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="column">查询字段对象</param> /// <param name="paramValueList">比较的值列表</param> /// <returns>返回非包含集合条件对象</returns> public static NotInCondition NotIn(ConditionRelation relation, SearchColumn column, object[] paramValueList) { NotInCondition cond = new NotInCondition(relation, column, paramValueList); return cond; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="column">查询字段对象</param> /// <param name="paramValue">条件的值</param> public LessEqualCondition(ConditionRelation relation, SearchColumn column, object paramValue) : base(relation, column) { this.ParamValue = paramValue; }
/// <summary> /// 子查询包含条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="sql">子查询SQL</param> /// <returns>返回子查询包含条件对象</returns> public static SQLInCondition SQLIn(ConditionRelation relation, string sql) { SQLInCondition cond = new SQLInCondition(relation, sql); return cond; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="paramValue">条件的值</param> public NotLikeCondition(ConditionRelation relation, object paramValue) : this(relation, null, paramValue) { }
/// <summary> /// 等于条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="paramVal">比较的值</param> /// <returns>返回等于条件对象</returns> public static EqualCondition Equal(ConditionRelation relation, object paramVal) { EqualCondition cond = new EqualCondition(relation, paramVal); return cond; }
public RelatedCondition WithRelation(ConditionRelation relation) { Relation = relation; return(this); }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="sql">子查询语句</param> public SQLEqualCondition(ConditionRelation relation, string sql) : this(relation, null, sql) { }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="column">查询字段对象</param> /// <param name="paramValueList">参数的值的集合</param> public InCondition(ConditionRelation relation, SearchColumn column, object[] paramValueList) : base(relation, column) { this.ParamValueList = paramValueList; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="paramValue">条件的值</param> public LargeThanCondition(ConditionRelation relation, object paramValue) : this(relation, null, paramValue) { }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">条件组和其他条件组或条件的关系</param> public ConditionGroup(ConditionRelation relation) : this() { this.GroupRelation = relation; }
/// <summary> /// 包含集合条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="paramValueList">比较的值列表</param> /// <returns>返回集合条件对象</returns> public static InCondition In(ConditionRelation relation, object[] paramValueList) { InCondition cond = new InCondition(relation, paramValueList); return cond; }
/// <summary> /// 空条件 /// </summary> /// <param name="relation">条件关系</param> /// <returns>返回空条件对象</returns> public static IsNullCondition IsNull(ConditionRelation relation) { IsNullCondition cond = new IsNullCondition(relation); return cond; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="paramValueList">参数的值的集合</param> public InCondition(ConditionRelation relation, object[] paramValueList) : this(relation, null, paramValueList) { }
/// <summary> /// 空条件 /// </summary> /// <param name="relation">条件关系</param> /// <param name="column">查询字段对象</param> /// <returns>返回空条件对象</returns> public static IsNullCondition IsNull(ConditionRelation relation, SearchColumn column) { IsNullCondition cond = new IsNullCondition(relation, column); return cond; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="column">查询字段对象</param> /// <param name="sql">子查询语句</param> public NotExistsCondition(ConditionRelation relation, SearchColumn column, string sql) : base(relation, column) { this.SQL = sql; }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="startValue">赋值开始的值</param> /// <param name="endValue">赋值结束的值</param> public BetweenCondition(ConditionRelation relation, object startValue, object endValue) : this(relation, null, startValue, endValue) { }
/// <summary> /// 构造函数 /// </summary> /// <param name="relation">关联关系</param> /// <param name="paramValue">条件的值</param> public LessEqualCondition(ConditionRelation relation, object paramValue) : this(relation, null, paramValue) { }
public ConditionsValidator WithCondition(ConditionRelation relation, Condition condition) { Conditions.Add(new RelatedCondition().WithRelation(relation).WithCondition(condition)); return(this); }
public TurnOnAndOffAutomation WithEnablingCondition(ConditionRelation relation, ICondition condition) { if (condition == null) throw new ArgumentNullException(nameof(condition)); _enablingConditionsValidator.WithCondition(relation, condition); return this; }
/// <summary> /// 条件分组 /// </summary> /// <param name="relation">组与组间的关系</param> /// <param name="condition">添加条件或组</param> /// <param name="conditions">可选参数,可以添加多个条件和组</param> /// <returns></returns> public static ConditionGroup Group(ConditionRelation relation, ICondition condition, params ICondition[] conditions) { ConditionGroup group = new ConditionGroup(relation, condition, conditions); return group; }