/// <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;
}
