/// <summary> 解释与字符串类型相关的方法,并将方法分配给指定的方法
/// </summary>
private string ParseStringMethod(MethodInfo method, ISawDust target, ISawDust[] args)
{
switch (method.Name)
{
case "Trim":
return(StringTrim(target.ToSql(), GetTrimArg(args, 0)));
case "TrimEnd":
return(StringTrimEnd(target.ToSql(), GetTrimArg(args, 0)));
case "TrimStart":
return(StringTrimStart(target.ToSql(), GetTrimArg(args, 0)));
case "IsNullOrWhiteSpace":
return(StringIsNullOrWhiteSpace(args[0].ToSql()));
case "IsNullOrEmpty":
return(StringIsNullOrEmpty(args[0].ToSql()));
case "ToString":
return(target.ToSql());
default:
break;
}
return(null);
}
/// <summary> 解释与字符类型相关的方法,并将方法分配给指定的方法
/// </summary>
private string ParseCharMethod(MethodInfo method, ISawDust target, ISawDust[] args)
{
switch (method.Name)
{
case "Parse":
return(args[0].ToSql());
case "ToString":
return(target.ToSql());
default:
break;
}
return(null);
}
public string ParseProperty(PropertyInfo property, ISawDust target)
{
AreNull(property, "property");
if (property.ReflectedType == typeof(DateTime))
{
switch (property.Name)
{
case "Year":
return(DateTimeToField(target.ToSql(), DateTimeField.Year));
case "Month":
return(DateTimeToField(target.ToSql(), DateTimeField.Month));
case "Day":
return(DateTimeToField(target.ToSql(), DateTimeField.Day));
case "Hour":
return(DateTimeToField(target.ToSql(), DateTimeField.Hour));
case "Minute":
return(DateTimeToField(target.ToSql(), DateTimeField.Minute));
case "Second":
return(DateTimeToField(target.ToSql(), DateTimeField.Second));
case "DayOfWeek":
return(DateTimeToField(target.ToSql(), DateTimeField.Week));
default:
break;
}
return(null);
}
else if (property.ReflectedType == typeof(string))
{
if (property.Name == "Length")
{
return(StringLength(target.ToSql()));
}
}
return(ParseMember(property, target, new ISawDust[0]));
}
/// <summary> 将.NET中的方法解释为sql表达式
/// </summary>
/// <param name="method">需解释的方法</param>
/// <param name="target">方法调用者</param>
/// <param name="args">方法参数</param>
/// <returns></returns>
public string ParseMethod(MethodInfo method, ISawDust target, ISawDust[] args)
{
AreNull(method, "method");
string sql = null;
switch (Type.GetTypeCode(Nullable.GetUnderlyingType(method.ReflectedType) ?? method.ReflectedType))
{
case TypeCode.Char:
sql = ParseCharMethod(method, target, args);
break;
case TypeCode.String:
sql = ParseStringMethod(method, target, args);
break;
case TypeCode.DateTime:
sql = ParseDateTimeMethod(method, target, args);
break;
case TypeCode.Byte:
case TypeCode.Decimal:
case TypeCode.Double:
case TypeCode.Int16:
case TypeCode.Int32:
case TypeCode.Int64:
case TypeCode.SByte:
case TypeCode.Single:
case TypeCode.UInt16:
case TypeCode.UInt32:
case TypeCode.UInt64:
sql = ParseNumberMethod(method, target, args);
break;
default:
break;
}
return(sql ?? ParseMember(method, target, args));
}
/// <summary> 解释与时间类型相关的方法,并将方法分配给指定的方法
/// </summary>
private string ParseDateTimeMethod(MethodInfo method, ISawDust target, ISawDust[] args)
{
switch (method.Name)
{
case "Parse":
return(ObjectToString(DustType.DateTime, target.ToSql(), null));
case "ParseExact":
var format = args[0].Value as string;
if (format != null && format.Contains("'"))
{
format = format.Replace("'", "''");
}
return(ObjectToString(DustType.DateTime, args[0].ToSql(), "'" + format + "'"));
case "ToString":
if (args.Length == 0)
{
return(ObjectToString(DustType.DateTime, target.ToSql(), null));
}
format = args[0].Value as string;
if (format != null && format.Contains("'"))
{
format = format.Replace("'", "''");
}
return(ObjectToString(DustType.DateTime, target.ToSql(), "'" + format + "'"));
case "ToShortTimeString":
return(ObjectToString(DustType.DateTime, target.ToSql(), "'HH:mm'"));
case "ToShortDateString":
return(ObjectToString(DustType.DateTime, target.ToSql(), "'yyyy-MM-dd'"));
default:
break;
}
return(null);
}
/// <summary> 解释与数字类型相关的方法,并将方法分配给指定的方法
/// </summary>
private string ParseNumberMethod(MethodInfo method, ISawDust target, ISawDust[] args)
{
switch (method.Name)
{
case "Parse":
return(SrtingToNumber(args[0].ToSql()));
case "ToString":
if (args.Length == 0)
{
return(ObjectToString(DustType.Number, target.ToSql(), null));
}
var format = args[0].Value as string;
if (format != null && format.Contains("'"))
{
format = format.Replace("'", "''");
}
return(ObjectToString(DustType.Number, target.ToSql(), "'" + format + "'"));
default:
break;
}
return(null);
}
/// <summary> 解释其他方法,可重写
/// </summary>
/// <param name="method">需解释的方法</param>
/// <param name="target">方法调用者</param>
/// <param name="args">方法参数</param>
protected virtual string ParseMember(MemberInfo member, ISawDust target, ISawDust[] args)
{
throw new NotSupportedException("无法解释方法:" + member.ToString());
}
public string ParseField(FieldInfo field, ISawDust target)
{
return(ParseMember(field, target, new ISawDust[0]));
}
private void Parse(NewExpression expr)
{
var length = expr.Arguments.Count;
var arr = new ISawDust[length];
for (int i = 0; i < length; i++)
{
var column = expr.Arguments[i];
var member = column as MemberExpression;
var alias = expr.Members[i];
Parse(column);
if (member == null || member.Member.Name != alias.Name)
{
_state.Sql = _saw.GetColumn(GetSql(), alias.Name);
}
arr[i] = GetSawDust();
}
_state.Array = arr;
}
private void Parse(NewArrayExpression expr)
{
var exps = expr.Expressions;
var length = expr.Expressions.Count;
var arr = Array.CreateInstance(expr.Type.GetElementType(), length);
for (int i = 0; i < length; i++)
{
Parse(exps[i]);
if (_state.DustType != DustType.Sql)
{
arr.SetValue(_state.Object, i);
}
else
{
var arr1 = new ISawDust[length];
var dust = GetSawDust();
if (i > 0)
{
_state.Object = arr.GetValue(0);
arr1[0] = new SawDust(this, _state.DustType, arr.GetValue(0));
for (int j = 1; j < i; j++)
{
arr1[j] = new SawDust(this, _state.DustType, arr.GetValue(j));
}
}
for (; i < length; i++)
{
Parse(exps[i]);
arr1[i] = GetSawDust();
}
_state.Array = arr1;
return;
}
}
_state.Array = arr;
}
/// <summary> 解析方法,如果全部是常量,则直接执行
/// </summary>
/// <param name="expr">方法表达式</param>
/// <param name="target">方法的调用实例</param>
/// <param name="args">方法参数</param>
/// <returns></returns>
private bool TryInvoke(MethodCallExpression expr, out ISawDust target, out ISawDust[] args)
{
ISubExpression subexpr = null;
//判断方法调用实例,如果是null为静态方法,反之为实例方法
if (expr.Object == null)
{
target = new SawDust(this, DustType.Object, null);
}
else
{
Parse(expr.Object);
if (_state.DustType == DustType.SubExpression) subexpr = _state.SubExpression;
target = GetSawDust();
}
var exprArgs = expr.Arguments;
var length = exprArgs.Count;
args = new ISawDust[length];
var call = target.Type != DustType.Sql;
for (int i = 0; i < length; i++)
{
Parse(exprArgs[i]);
if (_state.DustType == DustType.Sql)
{
if (call) call = false;
args[i] = new SawDust(this, DustType.Sql, _state.Sql);
}
else if (_state.DustType == DustType.Array && _state.Array is ISawDust[])
{
if (call) call = false;
args[i] = new SawDust(this, DustType.Array, _state.Array);
}
else
{
args[i] = new SawDust(this, _state.DustType, _state.Object);
}
}
if (call)
{
var method = expr.Method;
if (subexpr != null && !TypesHelper.IsChild(typeof(ISubExpression), method.ReturnType))
{
_state.Sql = subexpr.GetSqlString(args);
}
else
{
_state.Object = method.Invoke(target.Value, args.Select(it => it.Value).ToArray());
}
return true;
}
else
{
return false;
}
}
private bool ParseStringMethod(MethodInfo method, ISawDust target, ISawDust[] args)
{
if (args.Length >= 1)
{
BinaryOperator opt;
switch (method.Name)
{
case "StartsWith":
opt = _state.UnaryNot ? BinaryOperator.NotStartWith : BinaryOperator.StartWith;
break;
case "EndsWith":
opt = _state.UnaryNot ? BinaryOperator.NotEndWith : BinaryOperator.EndWith;
break;
case "Contains":
opt = _state.UnaryNot ? BinaryOperator.NotContains : BinaryOperator.Contains;
break;
default:
return false;
}
_state.Sql = _saw.BinaryOperation(target.ToSql(), opt, args[0].ToSql());
return true;
}
return false;
}
