/// <summary>
/// 初始化Sql查询语句类
/// </summary>
/// <param name="baseCommand">源Sql语句</param>
/// <param name="parameterOne">参数一</param>
/// <param name="parameterTwo">参数二</param>
/// <param name="op">条件运算符</param>
private SqlBasicParameterCondition(AbstractSqlCommandWithWhere baseCommand, DataParameter parameterOne, DataParameter parameterTwo, SqlOperator op)
: base(baseCommand)
{
this._parameterOne = parameterOne;
this._parameterTwo = parameterTwo;
this._operator = op;
}
/// <summary>
/// 初始化Sql查询语句类
/// </summary>
/// <param name="baseCommand">源Sql语句</param>
/// <param name="parameterOne">参数一</param>
/// <param name="parameterTwo">参数二</param>
/// <param name="op">条件运算符</param>
private SqlBasicParameterCondition(AbstractSqlCommandWithWhere baseCommand, DataParameter parameterOne, DataParameter parameterTwo, SqlOperator op)
: base(baseCommand)
{
this._parameterOne = parameterOne;
this._parameterTwo = parameterTwo;
this._operator = op;
}
private static AbstractSqlCondition ParseBinaryExpression(AbstractSqlCommandWithWhere sourceCommand, BinaryExpression expr)
{
switch (expr.NodeType)
{
case ExpressionType.Equal:
return(ParseBinaryExpression(sourceCommand, expr, SqlOperator.Equal));
case ExpressionType.NotEqual:
return(ParseBinaryExpression(sourceCommand, expr, SqlOperator.NotEqual));
case ExpressionType.GreaterThan:
return(ParseBinaryExpression(sourceCommand, expr, SqlOperator.GreaterThan));
case ExpressionType.LessThan:
return(ParseBinaryExpression(sourceCommand, expr, SqlOperator.LessThan));
case ExpressionType.GreaterThanOrEqual:
return(ParseBinaryExpression(sourceCommand, expr, SqlOperator.GreaterThanOrEqual));
case ExpressionType.LessThanOrEqual:
return(ParseBinaryExpression(sourceCommand, expr, SqlOperator.LessThanOrEqual));
case ExpressionType.And:
case ExpressionType.AndAlso:
return(SqlLinqCondition.ParseCondition(sourceCommand, expr.Left) & SqlLinqCondition.ParseCondition(sourceCommand, expr.Right));
case ExpressionType.Or:
case ExpressionType.OrElse:
return(SqlLinqCondition.ParseCondition(sourceCommand, expr.Left) | SqlLinqCondition.ParseCondition(sourceCommand, expr.Right));
default:
throw new LinqNotSupportedException("Not supported this linq operation!");
}
}
private static AbstractSqlCondition ParseBetweenCallExpression(AbstractSqlCommandWithWhere sourceCommand, MethodCallExpression expr, Boolean isNot)
{
MemberExpression left = ExpressionHelper.GetMemberExpression(expr.Arguments[0]);
DatabaseColumnAttribute columnAttr = ExpressionHelper.GetColumnAttributeWithDataType(sourceCommand, left);
Object start = ExpressionHelper.GetExpressionValue(expr.Arguments[1]) as Object;
Object end = ExpressionHelper.GetExpressionValue(expr.Arguments[2]) as Object;
if (columnAttr == null)
{
throw new NullAttributeException();
}
AbstractSqlCondition condition = null;
if (isNot)
{
condition = sourceCommand.ConditionBuilder.NotBetweenNullable(columnAttr.ColumnName, columnAttr.DataType.Value, start, end);
}
else
{
condition = sourceCommand.ConditionBuilder.BetweenNullable(columnAttr.ColumnName, columnAttr.DataType.Value, start, end);
}
return(condition);
}
/// <summary>
/// 获取Sql语句条件
/// </summary>
/// <param name="sourceCommand">来源语句</param>
/// <param name="expr">Linq表达式</param>
/// <returns>Sql语句条件</returns>
private static AbstractSqlCondition ParseCondition(AbstractSqlCommandWithWhere sourceCommand, Expression expr)
{
BinaryExpression bexpr = expr as BinaryExpression;
if (bexpr != null)
{
return(ParseBinaryExpression(sourceCommand, bexpr));
}
MethodCallExpression mcexpr = expr as MethodCallExpression;
if (mcexpr != null)
{
return(ParseMethodCallExpression(sourceCommand, mcexpr));
}
UnaryExpression uexpr = expr as UnaryExpression;
if (uexpr != null)
{
return(ParseUnaryExpression(sourceCommand, uexpr));
}
throw new LinqNotSupportedException("Not supported this linq operation!");
}
private static AbstractSqlCondition ParseMethodCallExpression(AbstractSqlCommandWithWhere sourceCommand, MethodCallExpression expr)
{
switch (expr.Method.Name)
{
case "IsNull":
return(ParseNullExpression(sourceCommand, expr, false));
case "IsNotNull":
return(ParseNullExpression(sourceCommand, expr, true));
case "Like":
return(ParseLikeCallExpression(sourceCommand, expr, "{0}", false));
case "LikeAll":
case "Contains":
return(ParseLikeCallExpression(sourceCommand, expr, "%{0}%", false));
case "LikeStartWith":
case "StartsWith":
return(ParseLikeCallExpression(sourceCommand, expr, "{0}%", false));
case "LikeEndWith":
case "EndsWith":
return(ParseLikeCallExpression(sourceCommand, expr, "%{0}", false));
case "NotLike":
return(ParseLikeCallExpression(sourceCommand, expr, "{0}", true));
case "NotLikeAll":
return(ParseLikeCallExpression(sourceCommand, expr, "%{0}%", true));
case "NotLikeStartWith":
return(ParseLikeCallExpression(sourceCommand, expr, "{0}%", true));
case "NotLikeEndWith":
return(ParseLikeCallExpression(sourceCommand, expr, "%{0}", true));
case "Between":
return(ParseBetweenCallExpression(sourceCommand, expr, false));
case "NotBetween":
return(ParseBetweenCallExpression(sourceCommand, expr, true));
case "InThese":
return(ParseInTheseCallExpression(sourceCommand, expr, false));
case "NotInThese":
return(ParseInTheseCallExpression(sourceCommand, expr, true));
case "In":
return(ParseInCallExpression(sourceCommand, expr, false));
case "NotIn":
return(ParseInCallExpression(sourceCommand, expr, true));
}
throw new LinqNotSupportedException("Not supported this method!");
}
/// <summary>
/// 创建新的Sql Not条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="condition">条件语句</param>
/// <exception cref="ArgumentNullException">Sql条件语句不能为空</exception>
/// <returns>Sql Not条件语句</returns>
internal static SqlNotCondition Create(AbstractSqlCommandWithWhere cmd, ISqlCondition condition)
{
if (condition == null)
{
throw new ArgumentNullException("condition");
}
return(new SqlNotCondition(cmd, condition));
}
/// <summary>
/// 创建新的Sql IN条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="isNotIn">是否不在范围内</param>
/// <param name="columnName">字段名称</param>
/// <param name="action">设置选择语句的方法</param>
/// <exception cref="ArgumentNullException">设置语句的方法不能为空</exception>
/// <returns>Sql条件语句</returns>
internal static SqlInsideCommandCondition InternalCreate(AbstractSqlCommandWithWhere cmd, String columnName, Boolean isNotIn, Action <SelectCommand> action)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
return(new SqlInsideCommandCondition(cmd, columnName, isNotIn, cmd.TableName, action));
}
/// <summary>
/// 创建新的Sql条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="columnName">字段名称</param>
/// <param name="op">条件运算符</param>
/// <param name="action">设置选择语句的方法</param>
/// <exception cref="ArgumentNullException">设置语句的方法不能为空</exception>
/// <returns>Sql条件语句</returns>
internal static SqlBasicCommandCondition InternalCreate(AbstractSqlCommandWithWhere cmd, String columnName, SqlOperator op, Action <SelectCommand> action)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
return(new SqlBasicCommandCondition(cmd, columnName, op, cmd.TableName, action));
}
/// <summary>
/// 创建新的Sql IN条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="isNotIn">是否不在范围内</param>
/// <param name="parameters">参数集合</param>
/// <exception cref="ArgumentNullException">参数集合不能为空</exception>
/// <returns>Sql条件语句</returns>
internal static SqlInsideParametersCondition InternalCreate(AbstractSqlCommandWithWhere cmd, Boolean isNotIn, params DataParameter[] parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
return(new SqlInsideParametersCondition(cmd, isNotIn, parameters));
}
/// <summary>
/// 初始化Sql IN语句条件语句类
/// </summary>
/// <param name="baseCommand">源Sql语句</param>
/// <param name="columnName">字段名称</param>
/// <param name="isNotIn">是否不在范围内</param>
/// <param name="tableName">查询的表名</param>
/// <param name="action">设置选择语句的方法</param>
private SqlInsideCommandCondition(AbstractSqlCommandWithWhere baseCommand, String columnName, Boolean isNotIn, String tableName, Action<SelectCommand> action)
: base(baseCommand)
{
this._columnName = columnName;
this._isNotIn = isNotIn;
SelectCommand command = baseCommand.Database.InternalCreateSelectCommand((baseCommand.RootSource == null ? baseCommand : baseCommand.RootSource), tableName);
action(command);
this._command = command;
}
/// <summary>
/// 初始化Sql查询语句类
/// </summary>
/// <param name="baseCommand">源Sql语句</param>
/// <param name="columnName">字段名称</param>
/// <param name="op">条件运算符</param>
/// <param name="tableName">查询的表名</param>
/// <param name="action">设置选择语句的方法</param>
private SqlBasicCommandCondition(AbstractSqlCommandWithWhere baseCommand, String columnName, SqlOperator op, String tableName, Action<SelectCommand> action)
: base(baseCommand)
{
this._columnName = columnName;
this._operator = op;
SelectCommand command = baseCommand.Database.InternalCreateSelectCommand((baseCommand.RootSource == null ? baseCommand : baseCommand.RootSource), tableName);
action(command);
this._command = command;
}
/// <summary>
/// 初始化Sql IN语句条件语句类
/// </summary>
/// <param name="baseCommand">源Sql语句</param>
/// <param name="columnName">字段名称</param>
/// <param name="isNotIn">是否不在范围内</param>
/// <param name="tableName">查询的表名</param>
/// <param name="action">设置选择语句的方法</param>
private SqlInsideCommandCondition(AbstractSqlCommandWithWhere baseCommand, String columnName, Boolean isNotIn, String tableName, Action <SelectCommand> action)
: base(baseCommand)
{
this._columnName = columnName;
this._isNotIn = isNotIn;
SelectCommand command = baseCommand.Database.InternalCreateSelectCommand((baseCommand.RootSource == null ? baseCommand : baseCommand.RootSource), tableName);
action(command);
this._command = command;
}
private static AbstractSqlCondition ParseUnaryExpression(AbstractSqlCommandWithWhere sourceCommand, UnaryExpression expr)
{
switch (expr.NodeType)
{
case ExpressionType.Not:
return(!ParseCondition(sourceCommand, expr.Operand));
default:
throw new LinqNotSupportedException("Not supported this linq operation!");
}
}
/// <summary>
/// 初始化Sql查询语句类
/// </summary>
/// <param name="baseCommand">源Sql语句</param>
/// <param name="columnName">字段名称</param>
/// <param name="op">条件运算符</param>
/// <param name="tableName">查询的表名</param>
/// <param name="action">设置选择语句的方法</param>
private SqlBasicCommandCondition(AbstractSqlCommandWithWhere baseCommand, String columnName, SqlOperator op, String tableName, Action <SelectCommand> action)
: base(baseCommand)
{
this._columnName = columnName;
this._operator = op;
SelectCommand command = baseCommand.Database.InternalCreateSelectCommand((baseCommand.RootSource == null ? baseCommand : baseCommand.RootSource), tableName);
action(command);
this._command = command;
}
/// <summary>
/// 初始化Sql IN参数条件语句类
/// </summary>
/// <param name="baseCommand">源Sql语句</param>
/// <param name="isNotIn">是否不在范围内</param>
/// <param name="parameters">参数集合</param>
private SqlInsideParametersCondition(AbstractSqlCommandWithWhere baseCommand, Boolean isNotIn, params DataParameter[] parameters)
: base(baseCommand)
{
this._isNotIn = isNotIn;
this._parameters = new List <DataParameter>();
if (parameters != null)
{
this._parameters.AddRange(parameters);
}
}
/// <summary>
/// 创建新的Sql IN条件语句
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="cmd">Sql语句</param>
/// <param name="columnName">字段名</param>
/// <param name="isNotIn">是否不在范围内</param>
/// <param name="dataType">数据类型</param>
/// <param name="values">数据集合</param>
/// <returns>Sql条件语句</returns>
internal static SqlInsideParametersCondition InternalCreate <T>(AbstractSqlCommandWithWhere cmd, String columnName, Boolean isNotIn, DataType dataType, IEnumerable <T> values)
{
List <DataParameter> parameters = new List <DataParameter>();
if (values != null)
{
foreach (T value in values)
{
parameters.Add(cmd.CreateDataParameter(columnName, dataType, value));
}
}
return(new SqlInsideParametersCondition(cmd, isNotIn, parameters.ToArray()));
}
/// <summary>
/// 创建新的Sql条件语句集合
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="concatType">连接类型</param>
/// <param name="conditions">条件语句集合</param>
/// <returns>Sql条件语句集合</returns>
internal static SqlConditionList InternalCreate(AbstractSqlCommandWithWhere cmd, SqlWhereConcatType concatType, IEnumerable <ISqlCondition> conditions)
{
SqlConditionList list = new SqlConditionList(cmd, concatType);
if (conditions != null)
{
foreach (ISqlCondition condition in conditions)
{
list.Add(condition);
}
}
return(list);
}
private static AbstractSqlCondition ParseInTheseCallExpression(AbstractSqlCommandWithWhere sourceCommand, MethodCallExpression expr, Boolean isNot)
{
MemberExpression left = ExpressionHelper.GetMemberExpression(expr.Arguments[0]);
DatabaseColumnAttribute columnAttr = ExpressionHelper.GetColumnAttributeWithDataType(sourceCommand, left);
Array array = ExpressionHelper.GetExpressionValue(expr.Arguments[1]) as Array;
if (columnAttr == null)
{
throw new NullAttributeException();
}
AbstractSqlCondition condition = SqlInsideParametersCondition.InternalCreate(sourceCommand, columnAttr.ColumnName, isNot, columnAttr.DataType.Value, array);
return(condition);
}
/// <summary>
/// 创建新的Sql IN条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="columnName">字段名</param>
/// <param name="isNotIn">是否不在范围内</param>
/// <param name="values">分隔符号分隔的数据集合</param>
/// <param name="separator">分隔符号</param>
/// <returns>Sql条件语句</returns>
internal static SqlInsideParametersCondition InternalCreateWithStringList(AbstractSqlCommandWithWhere cmd, String columnName, Boolean isNotIn, String values, Char separator)
{
List <DataParameter> parameters = new List <DataParameter>();
if (!String.IsNullOrEmpty(values))
{
String[] valuesArray = values.Split(separator);
for (Int32 i = 0; i < valuesArray.Length; i++)
{
parameters.Add(cmd.CreateDataParameter(columnName, DataType.String, valuesArray[i].Trim()));
}
}
return(new SqlInsideParametersCondition(cmd, isNotIn, parameters.ToArray()));
}
private static AbstractSqlCondition ParseInCallExpression(AbstractSqlCommandWithWhere sourceCommand, MethodCallExpression expr, Boolean isNot)
{
MemberExpression left = ExpressionHelper.GetMemberExpression(expr.Arguments[0]);
DatabaseColumnAttribute columnAttr = ExpressionHelper.GetColumnAttributeWithDataType(sourceCommand, left);
Action <SelectCommand> action = ExpressionHelper.GetExpressionValue(expr.Arguments[1]) as Action <SelectCommand>;
if (columnAttr == null)
{
throw new NullAttributeException();
}
Type entityType = expr.Method.GetGenericArguments()[0];
String anotherTableName = EntityHelper.InternalGetTableName(entityType);
AbstractSqlCondition condition = SqlInsideCommandCondition.InternalCreate(sourceCommand, columnAttr.ColumnName, isNot, anotherTableName, action);
return(condition);
}
/// <summary>
/// 创建新的Sql IN条件语句
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="cmd">Sql语句</param>
/// <param name="columnName">字段名</param>
/// <param name="isNotIn">是否不在范围内</param>
/// <param name="values">数据集合</param>
/// <returns>Sql条件语句</returns>
internal static SqlInsideParametersCondition InternalCreate <T>(AbstractSqlCommandWithWhere cmd, String columnName, Boolean isNotIn, IEnumerable <T> values)
{
List <DataParameter> parameters = new List <DataParameter>();
if (values != null)
{
DataType?dataType = null;
foreach (T value in values)
{
if (!dataType.HasValue)
{
dataType = DataTypeHelper.InternalGetDataType(value);
}
parameters.Add(cmd.CreateDataParameter(columnName, dataType.Value, value));
}
}
return(new SqlInsideParametersCondition(cmd, isNotIn, parameters.ToArray()));
}
private static AbstractSqlCondition ParseBinaryExpression(AbstractSqlCommandWithWhere sourceCommand, BinaryExpression expr, SqlOperator op)
{
MemberExpression left = ExpressionHelper.GetMemberExpression(expr.Left);
String entityName = left.Expression.ToString();
DatabaseColumnAttribute columnAttr = ExpressionHelper.GetColumnAttributeWithDataType(sourceCommand, left);
if (columnAttr == null)
{
throw new NullAttributeException();
}
SqlBasicParameterCondition condition = null;
if (expr.Right.NodeType == ExpressionType.MemberAccess)//如果右侧为实体属性
{
MemberExpression right = expr.Right as MemberExpression;
if (right.Expression != null && String.Equals(entityName, right.Expression.ToString()))
{
String columnName2 = ExpressionHelper.GetColumnName(sourceCommand, right);
condition = SqlBasicParameterCondition.InternalCreateColumn(sourceCommand, columnAttr.ColumnName, op, columnName2);
return(condition);
}
}
Object value = ExpressionHelper.GetExpressionValue(expr.Right);
if (value == null && (op == SqlOperator.Equal || op == SqlOperator.NotEqual))
{
op = (op == SqlOperator.Equal ? SqlOperator.IsNull : SqlOperator.IsNotNull);
}
condition = SqlBasicParameterCondition.InternalCreate(sourceCommand, columnAttr.ColumnName, op, columnAttr.DataType.Value, value);
return(condition);
}
private static AbstractSqlCondition ParseNullExpression(AbstractSqlCommandWithWhere sourceCommand, MethodCallExpression expr, Boolean isNot)
{
MemberExpression left = ExpressionHelper.GetMemberExpression(expr.Arguments[0]);
DatabaseColumnAttribute columnAttr = ExpressionHelper.GetColumnAttributeWithDataType(sourceCommand, left);
if (columnAttr == null)
{
throw new NullAttributeException();
}
AbstractSqlCondition condition = null;
if (isNot)
{
condition = sourceCommand.ConditionBuilder.IsNotNull(columnAttr.ColumnName);
}
else
{
condition = sourceCommand.ConditionBuilder.IsNull(columnAttr.ColumnName);
}
return(condition);
}
/// <summary>
/// 创建新的Sql IN条件语句
/// </summary>
/// <typeparam name="T">数据类型</typeparam>
/// <param name="cmd">Sql语句</param>
/// <param name="columnName">字段名</param>
/// <param name="isNotIn">是否不在范围内</param>
/// <param name="dataType">数据类型</param>
/// <param name="values">分隔符号分隔的数据集合</param>
/// <param name="separator">分隔符号</param>
/// <returns>Sql条件语句</returns>
internal static SqlInsideParametersCondition InternalCreate <T>(AbstractSqlCommandWithWhere cmd, String columnName, Boolean isNotIn, DataType dataType, String values, Char separator) where T : IConvertible
{
List <DataParameter> parameters = new List <DataParameter>();
if (!String.IsNullOrEmpty(values))
{
String[] valuesArray = values.Split(separator);
Type t = typeof(T);
for (Int32 i = 0; i < valuesArray.Length; i++)
{
if (String.IsNullOrEmpty(valuesArray[i]))
{
continue;
}
Object value = Convert.ChangeType(valuesArray[i].Trim(), t);
parameters.Add(cmd.CreateDataParameter(columnName, dataType, value));
}
}
return(new SqlInsideParametersCondition(cmd, isNotIn, parameters.ToArray()));
}
private static AbstractSqlCondition ParseLikeCallExpression(AbstractSqlCommandWithWhere sourceCommand, MethodCallExpression expr, String format, Boolean isNot)
{
MemberExpression left = ExpressionHelper.GetMemberExpression(expr.Arguments[0]);
DatabaseColumnAttribute columnAttr = ExpressionHelper.GetColumnAttributeWithDataType(sourceCommand, left);
String value = ExpressionHelper.GetExpressionValue(expr.Arguments[1]) as String;
if (columnAttr == null)
{
throw new NullAttributeException();
}
AbstractSqlCondition condition = null;
if (isNot)
{
condition = sourceCommand.ConditionBuilder.NotLike(columnAttr.ColumnName, columnAttr.DataType.Value, String.Format(format, value));;
}
else
{
condition = sourceCommand.ConditionBuilder.Like(columnAttr.ColumnName, columnAttr.DataType.Value, String.Format(format, value));;
}
return(condition);
}
/// <summary>
/// 初始化Sql Not条件语句类
/// </summary>
/// <param name="baseCommand">源Sql语句</param>
/// <param name="baseCondition">基础Sql条件语句</param>
private SqlNotCondition(AbstractSqlCommandWithWhere baseCommand, ISqlCondition baseCondition)
: base(baseCommand)
{
this._baseCondition = baseCondition;
}
/// <summary>
/// 创建新的Sql Not条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="condition">条件语句</param>
/// <exception cref="ArgumentNullException">Sql条件语句不能为空</exception>
/// <returns>Sql Not条件语句</returns>
internal static SqlNotCondition Create(AbstractSqlCommandWithWhere cmd, ISqlCondition condition)
{
if (condition == null)
{
throw new ArgumentNullException("condition");
}
return new SqlNotCondition(cmd, condition);
}
/// <summary>
/// 创建新的Sql条件语句
/// </summary>
/// <typeparam name="T">实体类类型</typeparam>
/// <param name="sourceCommand">来源语句</param>
/// <param name="expr">Linq表达式</param>
/// <exception cref="LinqNotSupportedException">Linq操作不支持</exception>
/// <exception cref="NullAttributeException">没有设置特性</exception>
/// <returns>Sql条件语句</returns>
public static AbstractSqlCondition Create <T>(AbstractSqlCommandWithWhere sourceCommand, Expression <Func <T, Boolean> > expr)
{
return(SqlLinqCondition.ParseCondition(sourceCommand, expr.Body));
}
/// <summary>
/// 创建双参数新的Sql条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="columnName">字段名</param>
/// <param name="op">条件运算符</param>
/// <param name="columnNameTwo">字段名二</param>
/// <returns>Sql条件语句</returns>
internal static SqlBasicParameterCondition InternalCreateColumn(AbstractSqlCommandWithWhere cmd, String columnName, SqlOperator op, String columnNameTwo)
{
return new SqlBasicParameterCondition(cmd, cmd.CreateDataParameterCustomAction(columnName, GetFieldName(String.Empty, columnNameTwo)), op);
}
/// <summary>
/// 创建单参数新的Sql条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="columnName">字段名</param>
/// <param name="op">条件运算符</param>
/// <param name="action">赋值操作</param>
/// <returns>Sql条件语句</returns>
internal static SqlBasicParameterCondition InternalCreateAction(AbstractSqlCommandWithWhere cmd, String columnName, SqlOperator op, String action)
{
return new SqlBasicParameterCondition(cmd, cmd.CreateDataParameterCustomAction(columnName, action), op);
}
/// <summary>
/// 创建双参数新的Sql条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="columnName">字段名</param>
/// <param name="op">条件运算符</param>
/// <param name="dataType">数据类型</param>
/// <param name="valueOne">数据一</param>
/// <param name="valueTwo">数据二</param>
/// <returns>Sql条件语句</returns>
internal static SqlBasicParameterCondition InternalCreate(AbstractSqlCommandWithWhere cmd, String columnName, SqlOperator op, DataType dataType, Object valueOne, Object valueTwo)
{
return new SqlBasicParameterCondition(cmd, cmd.CreateDataParameter(columnName, dataType, valueOne), cmd.CreateDataParameter(columnName, dataType, valueTwo), op);
}
/// <summary>
/// 初始化Sql查询语句集合类
/// </summary>
/// <param name="baseCommand">源Sql语句</param>
/// <param name="concatType">连接类型</param>
private SqlConditionList(AbstractSqlCommandWithWhere baseCommand, SqlWhereConcatType concatType)
: base(baseCommand)
{
this._list = new List <ISqlCondition>();
this._concatType = concatType;
}
/// <summary>
/// 创建新的Sql IN条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="isNotIn">是否不在范围内</param>
/// <param name="columnName">字段名称</param>
/// <param name="action">设置选择语句的方法</param>
/// <exception cref="ArgumentNullException">设置语句的方法不能为空</exception>
/// <returns>Sql条件语句</returns>
internal static SqlInsideCommandCondition InternalCreate(AbstractSqlCommandWithWhere cmd, String columnName, Boolean isNotIn, Action<SelectCommand> action)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
return new SqlInsideCommandCondition(cmd, columnName, isNotIn, cmd.TableName, action);
}
/// <summary>
/// 创建新的Sql条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="columnName">字段名称</param>
/// <param name="op">条件运算符</param>
/// <param name="action">设置选择语句的方法</param>
/// <exception cref="ArgumentNullException">设置语句的方法不能为空</exception>
/// <returns>Sql条件语句</returns>
internal static SqlBasicCommandCondition InternalCreate(AbstractSqlCommandWithWhere cmd, String columnName, SqlOperator op, Action<SelectCommand> action)
{
if (action == null)
{
throw new ArgumentNullException("action");
}
return new SqlBasicCommandCondition(cmd, columnName, op, cmd.TableName, action);
}
/// <summary>
/// 创建双参数新的Sql条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="columnName">字段名</param>
/// <param name="op">条件运算符</param>
/// <param name="columnNameTwo">字段名二</param>
/// <returns>Sql条件语句</returns>
internal static SqlBasicParameterCondition InternalCreateColumn(AbstractSqlCommandWithWhere cmd, String columnName, SqlOperator op, String columnNameTwo)
{
return(new SqlBasicParameterCondition(cmd, cmd.CreateDataParameterCustomAction(columnName, GetFieldName(String.Empty, columnNameTwo)), op));
}
/// <summary>
/// 创建单参数新的Sql条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="columnName">字段名</param>
/// <param name="op">条件运算符</param>
/// <param name="action">赋值操作</param>
/// <returns>Sql条件语句</returns>
internal static SqlBasicParameterCondition InternalCreateAction(AbstractSqlCommandWithWhere cmd, String columnName, SqlOperator op, String action)
{
return(new SqlBasicParameterCondition(cmd, cmd.CreateDataParameterCustomAction(columnName, action), op));
}
/// <summary>
/// 创建双参数新的Sql条件语句
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="columnName">字段名</param>
/// <param name="op">条件运算符</param>
/// <param name="dataType">数据类型</param>
/// <param name="valueOne">数据一</param>
/// <param name="valueTwo">数据二</param>
/// <returns>Sql条件语句</returns>
internal static SqlBasicParameterCondition InternalCreate(AbstractSqlCommandWithWhere cmd, String columnName, SqlOperator op, DataType dataType, Object valueOne, Object valueTwo)
{
return(new SqlBasicParameterCondition(cmd, cmd.CreateDataParameter(columnName, dataType, valueOne), cmd.CreateDataParameter(columnName, dataType, valueTwo), op));
}
/// <summary>
/// 初始化新的Sql抽象条件语句
/// </summary>
/// <param name="baseCommand">源Sql语句</param>
internal AbstractSqlCondition(AbstractSqlCommandWithWhere baseCommand)
{
this._baseCommand = baseCommand;
}
/// <summary>
/// 初始化Sql Not条件语句类
/// </summary>
/// <param name="baseCommand">源Sql语句</param>
/// <param name="baseCondition">基础Sql条件语句</param>
private SqlNotCondition(AbstractSqlCommandWithWhere baseCommand, ISqlCondition baseCondition)
: base(baseCommand)
{
this._baseCondition = baseCondition;
}
/// <summary>
/// 初始化新的Sql抽象条件语句
/// </summary>
/// <param name="baseCommand">源Sql语句</param>
internal AbstractSqlCondition(AbstractSqlCommandWithWhere baseCommand)
{
this._baseCommand = baseCommand;
}
