public ReturningMember(FieldIdentifier field, ReturningMode mode)
{
this.Field = field;
this.Mode = mode;
}
public ParameterExpression(FieldIdentifier field, object value) : this(field, null, value)
{
}
/// <summary>
/// 创建一个参数表达式，参数名将由所属参数集合自动命名。
/// </summary>
/// <param name="field">指定参数关联的字段标识。</param>
/// <param name="schema">指定的参数对应的模式。</param>
/// <param name="value">指定的参数值。</param>
/// <returns>返回新建的参数表达式。</returns>
public static ParameterExpression Parameter(FieldIdentifier field, SchemaMember schema, object value)
{
return(new ParameterExpression(field, schema, value));
}
/// <summary>
/// 创建一个参数表达式，参数名将由所属参数集合自动命名。
/// </summary>
/// <param name="field">指定参数关联的字段标识。</param>
/// <param name="value">指定的参数值。</param>
/// <returns>返回新建的参数表达式。</returns>
public static ParameterExpression Parameter(FieldIdentifier field, object value)
{
return(new ParameterExpression(field, value));
}
private static IExpression GetConditionValue(Condition condition, FieldIdentifier field, Action <ParameterExpression> append = null)
{
if (append == null)
{
throw new ArgumentNullException(nameof(append));
}
if (condition.Value == null)
{
if (condition.Operator == ConditionOperator.Equal || condition.Operator == ConditionOperator.NotEqual || condition.Operator == ConditionOperator.Like)
{
return(ConstantExpression.Null);
}
throw new DataException($"The specified '{condition.Name}' parameter value of the type {condition.Operator.ToString()} condition is null.");
}
if (condition.Operator == ConditionOperator.Equal && Range.IsRange(condition.Value))
{
condition.Operator = ConditionOperator.Between;
}
switch (condition.Operator)
{
case ConditionOperator.Between:
if (Range.IsRange(condition.Value, out var minimum, out var maximum))
{
ParameterExpression minimumParameter;
if (object.Equals(minimum, maximum))
{
condition.Operator = ConditionOperator.Equal;
append(minimumParameter = Expression.Parameter(field, minimum));
return(minimumParameter);
}
ParameterExpression maximumParameter;
if (minimum == null)
{
if (maximum == null)
{
return(null);
}
condition.Operator = ConditionOperator.LessThanEqual;
append(maximumParameter = Expression.Parameter(field, maximum));
return(maximumParameter);
}
else
{
if (maximum == null)
{
condition.Operator = ConditionOperator.GreaterThanEqual;
append(minimumParameter = Expression.Parameter(field, minimum));
return(minimumParameter);
}
else
{
append(minimumParameter = Expression.Parameter(field, minimum));
append(maximumParameter = Expression.Parameter(field, maximum));
return(new RangeExpression(minimumParameter, maximumParameter));
}
}
}
throw new DataException($"The specified '{condition.Name}' parameter value of the type Between condition is invalid.");
case ConditionOperator.Exists:
case ConditionOperator.NotExists:
return(condition.Value as IExpression ??
throw new DataException($"Unable to build a subquery corresponding to the specified '{condition.Name}' parameter({condition.Operator})."));
case ConditionOperator.In:
case ConditionOperator.NotIn:
if (condition.Value != null && condition.Value is IEnumerable iterator)
{
var collection = new ExpressionCollection();
foreach (var item in iterator)
{
if (item != null)
{
collection.Add(Expression.Constant(item));
}
}
if (collection.Count > 0)
{
return(collection);
}
}
throw new DataException($"The specified '{condition.Name}' parameter value of the type In condition is null or empty set.");
}
var parameter = Expression.Parameter(field, condition.Value);
append(parameter);
return(parameter);
}
public FieldValue(FieldIdentifier field, IExpression value)
{
this.Field = field;
this.Value = value;
}
