bool IsDatePart(DbMemberExpression exp)
{
MemberInfo member = exp.Member;
if (member == UtilConstants.PropertyInfo_DateTime_Year)
{
DbFunction_DATEPART(this, "YEAR", exp.Expression);
return(true);
}
if (member == UtilConstants.PropertyInfo_DateTime_Month)
{
DbFunction_DATEPART(this, "MONTH", exp.Expression);
return(true);
}
if (member == UtilConstants.PropertyInfo_DateTime_Day)
{
DbFunction_DATEPART(this, "DAY", exp.Expression);
return(true);
}
if (member == UtilConstants.PropertyInfo_DateTime_Hour)
{
DbFunction_DATEPART(this, "HOUR", exp.Expression);
return(true);
}
if (member == UtilConstants.PropertyInfo_DateTime_Minute)
{
DbFunction_DATEPART(this, "MINUTE", exp.Expression);
return(true);
}
if (member == UtilConstants.PropertyInfo_DateTime_Second)
{
DbFunction_DATEPART(this, "SECOND", exp.Expression);
return(true);
}
if (member == UtilConstants.PropertyInfo_DateTime_Millisecond)
{
DbFunction_DATEPART(this, "MILLISECOND", exp.Expression);
return(true);
}
if (member == UtilConstants.PropertyInfo_DateTime_DayOfWeek)
{
this._sqlBuilder.Append("(");
DbFunction_DATEPART(this, "WEEKDAY", exp.Expression);
this._sqlBuilder.Append(" - 1)");
return(true);
}
return(false);
}
public override bool Visit(DbMemberExpression exp)
{
if (exp.Expression != null)
{
return(this.VisitCore(exp.Expression));
}
return(true);
}
/// <summary>
/// 对 memberExpression 进行求值
/// </summary>
/// <param name="exp"></param>
/// <returns>返回 DbParameterExpression</returns>
public static DbParameterExpression ConvertToParameterExpression(this DbMemberExpression memberExpression)
{
DbParameterExpression ret = null;
//求值
object val = Evaluate(memberExpression);
ret = DbExpression.Parameter(val, memberExpression.Type);
return(ret);
}
/// <summary>
/// 对 memberExpression 进行求值
/// </summary>
/// <param name="exp"></param>
/// <returns>返回 DbParameterExpression</returns>
public static DbParameterExpression ParseToParameterExpression(this DbMemberExpression memberExpression)
{
DbParameterExpression ret = null;
//求值
object val = DbExpressionExtensions.GetExpressionValue(memberExpression);
ret = DbExpression.Parameter(val, memberExpression.Type);
return(ret);
}
bool IsDatePart(DbMemberExpression exp)
{
MemberInfo member = exp.Member;
if (member == PublicConstants.PropertyInfo_DateTime_Year)
{
DbFunction_DATEPART(this, "YEAR", exp.Expression);
return(true);
}
if (member == PublicConstants.PropertyInfo_DateTime_Month)
{
DbFunction_DATEPART(this, "MONTH", exp.Expression);
return(true);
}
if (member == PublicConstants.PropertyInfo_DateTime_Day)
{
DbFunction_DATEPART(this, "DAY", exp.Expression);
return(true);
}
if (member == PublicConstants.PropertyInfo_DateTime_Hour)
{
DbFunction_DATEPART(this, "HOUR", exp.Expression);
return(true);
}
if (member == PublicConstants.PropertyInfo_DateTime_Minute)
{
DbFunction_DATEPART(this, "MINUTE", exp.Expression);
return(true);
}
if (member == PublicConstants.PropertyInfo_DateTime_Second)
{
DbFunction_DATEPART(this, "SECOND", exp.Expression);
return(true);
}
if (member == PublicConstants.PropertyInfo_DateTime_Millisecond)
{
DbFunction_DATEPART(this, "MILLISECOND", exp.Expression);
return(true);
}
if (member == PublicConstants.PropertyInfo_DateTime_DayOfWeek)
{
DbFunction_DATEPART(this, "DOW", exp.Expression);
return(true);
}
return(false);
}
static DbExpression Trim_Nullable_Value(DbExpression exp)
{
DbMemberExpression memberExp = exp as DbMemberExpression;
if (memberExp == null)
return exp;
if (memberExp.Member.Name == "Value" && ReflectionExtension.IsNullable(memberExp.Expression.Type))
return memberExp.Expression;
return exp;
}
public override DbExpression Visit(DbMemberExpression exp)
{
MemberInfo member = exp.Member;
if (member.DeclaringType == UtilConstants.TypeOfDateTime)
{
if (member == UtilConstants.PropertyInfo_DateTime_Now)
{
this._sqlBuilder.Append("DATETIME('NOW','LOCALTIME')");
return(exp);
}
if (member == UtilConstants.PropertyInfo_DateTime_UtcNow)
{
this._sqlBuilder.Append("DATETIME()");
return(exp);
}
if (member == UtilConstants.PropertyInfo_DateTime_Today || member == UtilConstants.PropertyInfo_DateTime_Date)
{
this._sqlBuilder.Append("DATE('NOW','LOCALTIME')");
return(exp);
}
if (IsDbFunction_DATEPART(exp))
{
return(exp);
}
}
DbParameterExpression newExp;
if (DbExpressionExtensions.TryParseToParameterExpression(exp, out newExp))
{
return(newExp.Accept(this));
}
if (member.Name == "Length" && member.DeclaringType == UtilConstants.TypeOfString)
{
this._sqlBuilder.Append("LENGTH(");
exp.Expression.Accept(this);
this._sqlBuilder.Append(")");
return(exp);
}
else if (member.Name == "Value" && Utils.IsNullable(exp.Expression.Type))
{
exp.Expression.Accept(this);
return(exp);
}
throw new NotSupportedException(string.Format("'{0}.{1}' is not supported.", member.DeclaringType.FullName, member.Name));
}
/// <summary>
/// 尝试将 exp 转换成 DbParameterExpression。
/// </summary>
/// <param name="exp"></param>
/// <param name="val"></param>
/// <returns></returns>
public static bool TryConvertToParameterExpression(this DbMemberExpression exp, out DbParameterExpression val)
{
val = null;
if (!exp.IsEvaluable())
{
return(false);
}
//求值
val = exp.ConvertToParameterExpression();
return(true);
}
/// <summary>
/// 尝试将 exp 转换成 DbParameterExpression。
/// </summary>
/// <param name="exp"></param>
/// <param name="val"></param>
/// <returns></returns>
public static bool TryParseToParameterExpression(this DbMemberExpression exp, out DbParameterExpression val)
{
val = null;
if (!exp.CanEvaluate())
{
return(false);
}
//求值
val = exp.ParseToParameterExpression();
return(true);
}
bool IsDatePart(DbMemberExpression exp)
{
MemberInfo member = exp.Member;
if (member == PublicConstants.PropertyInfo_DateTime_Year)
{
DbFunction_DATEPART(this, "Y", exp.Expression);
return(true);
}
if (member == PublicConstants.PropertyInfo_DateTime_Month)
{
DbFunction_DATEPART(this, "m", exp.Expression);
return(true);
}
if (member == PublicConstants.PropertyInfo_DateTime_Day)
{
DbFunction_DATEPART(this, "d", exp.Expression);
return(true);
}
if (member == PublicConstants.PropertyInfo_DateTime_Hour)
{
DbFunction_DATEPART(this, "H", exp.Expression);
return(true);
}
if (member == PublicConstants.PropertyInfo_DateTime_Minute)
{
DbFunction_DATEPART(this, "M", exp.Expression);
return(true);
}
if (member == PublicConstants.PropertyInfo_DateTime_Second)
{
DbFunction_DATEPART(this, "S", exp.Expression);
return(true);
}
/* SQLite is not supports MILLISECOND */
if (member == PublicConstants.PropertyInfo_DateTime_DayOfWeek)
{
DbFunction_DATEPART(this, "w", exp.Expression);
return(true);
}
return(false);
}
public static bool ExistDateTime_NowOrDateTime_UtcNow(this DbMemberExpression exp)
{
while (exp != null)
{
if (exp.Member == UtilConstants.PropertyInfo_DateTime_Now || exp.Member == UtilConstants.PropertyInfo_DateTime_UtcNow)
{
return(true);
}
exp = exp.Expression as DbMemberExpression;
}
return(false);
}
public static object GetMemberAccessExpressionValue(this DbMemberExpression exp, object instance)
{
if (exp.Member.MemberType
== MemberTypes.Field)
{
return(((FieldInfo)exp.Member).GetValue(instance));
}
else if (exp.Member.MemberType
== MemberTypes.Property)
{
return(((PropertyInfo)exp.Member).GetValue(instance, null));
}
throw new NotSupportedException();
}
protected override DbExpression VisitMemberAccess(MemberExpression exp)
{
if (ExpressionExtension.IsDerivedFromParameter(exp))
{
Stack <MemberExpression> reversedExps = ExpressionExtension.Reverse(exp);
DbExpression dbExp = null;
bool first = true;
foreach (var me in reversedExps)
{
if (first)
{
DbColumnAccessExpression dbColumnAccessExpression = this._typeDescriptor.TryGetColumnAccessExpression(me.Member);
if (this._explicitDbTable != null)
{
dbColumnAccessExpression = new DbColumnAccessExpression(this._explicitDbTable, dbColumnAccessExpression.Column);
}
if (dbColumnAccessExpression == null)
{
throw new SZORMException(string.Format("The member '{0}' does not map any column.", me.Member.Name));
}
dbExp = dbColumnAccessExpression;
first = false;
}
else
{
DbMemberExpression dbMe = new DbMemberExpression(me.Member, dbExp);
dbExp = dbMe;
}
}
if (dbExp != null)
{
return(dbExp);
}
else
{
throw new Exception();
}
}
else
{
return(base.VisitMemberAccess(exp));
}
}
protected override DbExpression VisitMemberAccess(MemberExpression exp)
{
if (ExpressionExtensions.IsDerivedFromParameter(exp))
{
Stack <MemberExpression> reversedExps = ExpressionExtensions.Reverse(exp);
Dictionary <MemberInfo, DbColumnAccessExpression> memberColumnMap = this._typeDescriptor.MemberColumnMap;
DbExpression dbExp = null;
bool first = true;
foreach (var me in reversedExps)
{
if (first)
{
DbColumnAccessExpression dbColumnAccessExpression;
if (!memberColumnMap.TryGetValue(me.Member, out dbColumnAccessExpression))
{
throw new Exception(string.Format("成员 {0} 未映射任何列", me.Member.Name));
}
dbExp = dbColumnAccessExpression;
first = false;
}
else
{
DbMemberExpression dbMe = new DbMemberExpression(me.Member, dbExp);
dbExp = dbMe;
}
}
if (dbExp != null)
{
return(dbExp);
}
else
{
throw new Exception();
}
}
else
{
return(base.VisitMemberAccess(exp));
}
}
public static object GetExpressionValue(this DbExpression exp)
{
if (exp.NodeType == DbExpressionType.Constant)
{
return(((DbConstantExpression)exp).Value);
}
if (exp.NodeType == DbExpressionType.MemberAccess)
{
DbMemberExpression m = (DbMemberExpression)exp;
object instance = null;
if (m.Expression != null)
{
instance = DbExpressionExtensions.GetExpressionValue(m.Expression);
}
return(GetMemberAccessExpressionValue(m, instance));
}
throw new NotSupportedException();
}
public override object Visit(DbMemberExpression exp)
{
object instance = null;
if (exp.Expression != null)
{
instance = exp.Expression.Accept(this);
if (instance == null)
{
if (exp.Member.Name == "HasValue" && exp.Member.DeclaringType.IsNullable())
{
return(false);
}
throw new NullReferenceException(string.Format("There is an object reference not set to an instance in expression tree. The type of null object is '{0}'.", exp.Expression.Type.FullName));
}
}
return(exp.Member.GetMemberValue(instance));
}
private DbExpression CreateMemberExpression(TranslationContext context, PropertyInfo property, DbExpression subaccess)
{
Type type = property.PropertyType;
return(subaccess.GetOrSetChildren(property, () =>
{
DbExpression item = null;
if (type.IsPrimary())
{
item = new DbMemberExpression(property, subaccess);
}
else if (type.IsComplexCollection())
{
item = new DbCollectionMemberExpression(context, property, subaccess);
}
else
{
item = new DbObjectMemberExpression(context, property, subaccess);
}
return item;
}));
}
public abstract T Visit(DbMemberExpression exp);
public void Process(DbMethodCallExpression exp, SqlGenerator generator)
{
MethodInfo method = exp.Method;
if (exp.Method == UtilConstants.MethodInfo_String_Contains)
{
Method_String_Contains(exp, generator);
return;
}
List <DbExpression> exps = new List <DbExpression>();
IEnumerable values = null;
DbExpression operand = null;
Type declaringType = method.DeclaringType;
if (typeof(IList).IsAssignableFrom(declaringType) || (declaringType.IsGenericType && typeof(ICollection <>).MakeGenericType(declaringType.GetGenericArguments()).IsAssignableFrom(declaringType)))
{
if (exp.Object.NodeType == DbExpressionType.SqlQuery)
{
/* where Id in(select id from T) */
operand = exp.Arguments[0];
In(generator, (DbSqlQueryExpression)exp.Object, operand);
return;
}
if (!exp.Object.IsEvaluable())
{
throw new NotSupportedException(exp.ToString());
}
values = DbExpressionExtension.Evaluate(exp.Object) as IEnumerable; //Enumerable
operand = exp.Arguments[0];
goto constructInState;
}
if (method.IsStatic && declaringType == typeof(Enumerable) && exp.Arguments.Count == 2)
{
DbExpression arg0 = exp.Arguments[0];
if (arg0.NodeType == DbExpressionType.SqlQuery)
{
/* where Id in(select id from T) */
operand = exp.Arguments[1];
In(generator, (DbSqlQueryExpression)arg0, operand);
return;
}
DbMemberExpression memberExp = arg0 as DbMemberExpression;
if (memberExp == null || !memberExp.IsEvaluable())
{
throw UtilExceptions.NotSupportedMethod(exp.Method);
}
values = DbExpressionExtension.Evaluate(memberExp) as IEnumerable;
operand = exp.Arguments[1];
goto constructInState;
}
throw UtilExceptions.NotSupportedMethod(exp.Method);
constructInState:
foreach (object value in values)
{
if (value == null)
{
exps.Add(DbExpression.Constant(null, operand.Type));
}
else
{
Type valueType = value.GetType();
if (valueType.IsEnum)
{
valueType = Enum.GetUnderlyingType(valueType);
}
if (Utils.IsToStringableNumericType(valueType))
{
exps.Add(DbExpression.Constant(value));
}
else
{
exps.Add(DbExpression.Parameter(value));
}
}
}
In(generator, exps, operand);
}
/// <summary>
/// 是否可以将 exp.Member 翻译成数据库对应的语法
/// </summary>
/// <param name="exp"></param>
/// <returns></returns>
public virtual bool CanTranslateToSql(DbMemberExpression exp)
{
return(false);
}
public override DbExpression Visit(DbMemberExpression exp)
{
MemberInfo member = exp.Member;
if (member.DeclaringType == UtilConstants.TypeOfDateTime)
{
if (member == UtilConstants.PropertyInfo_DateTime_Now)
{
this._sqlBuilder.Append("NOW()");
return(exp);
}
//not supported
//if (member == UtilConstants.PropertyInfo_DateTime_UtcNow)
//{
// this._sqlBuilder.Append("GETUTCDATE()");
// return exp;
//}
if (member == UtilConstants.PropertyInfo_DateTime_Today)
{
this.BuildCastState("NOW()", "DATE");
return(exp);
}
if (member == UtilConstants.PropertyInfo_DateTime_Date)
{
this.BuildCastState(exp.Expression, "DATE");
return(exp);
}
if (this.IsDatePart(exp))
{
return(exp);
}
}
if (member.Name == "Length" && member.DeclaringType == UtilConstants.TypeOfString)
{
this._sqlBuilder.Append("LENGTH(");
exp.Expression.Accept(this);
this._sqlBuilder.Append(")");
return(exp);
}
if (member.Name == "Value" && ReflectionExtension.IsNullable(exp.Expression.Type))
{
exp.Expression.Accept(this);
return(exp);
}
DbParameterExpression newExp;
if (DbExpressionExtension.TryConvertToParameterExpression(exp, out newExp))
{
return(newExp.Accept(this));
}
throw new NotSupportedException(string.Format("'{0}.{1}' is not supported.", member.DeclaringType.FullName, member.Name));
}
public static bool ExpressionEquals(DbMemberExpression exp1, DbMemberExpression exp2)
{
if (exp1.Member != exp2.Member)
return false;
return EqualsCompare(exp1.Expression, exp2.Expression);
}
public override ISqlPart Visit(DbMemberExpression dbExpression)
{
throw new NotImplementedException();
}
public override DbExpression Visit(DbMemberExpression exp)
{
return(exp);
}
public override DbExpression Visit(DbMemberExpression exp)
{
MemberInfo member = exp.Member;
if (member == OracleSemantics.PropertyInfo_ROWNUM)
{
this.SqlBuilder.Append("ROWNUM");
return(exp);
}
if (member.DeclaringType == PublicConstants.TypeOfDateTime)
{
if (member == PublicConstants.PropertyInfo_DateTime_Now)
{
this.SqlBuilder.Append("SYSTIMESTAMP");
return(exp);
}
if (member == PublicConstants.PropertyInfo_DateTime_UtcNow)
{
this.SqlBuilder.Append("SYS_EXTRACT_UTC(SYSTIMESTAMP)");
return(exp);
}
if (member == PublicConstants.PropertyInfo_DateTime_Today)
{
//other way: this.SqlBuilder.Append("TO_DATE(TO_CHAR(SYSDATE,'yyyy-mm-dd'),'yyyy-mm-dd')");
this.SqlBuilder.Append("TRUNC(SYSDATE,'DD')");
return(exp);
}
if (member == PublicConstants.PropertyInfo_DateTime_Date)
{
this.SqlBuilder.Append("TRUNC(");
exp.Expression.Accept(this);
this.SqlBuilder.Append(",'DD')");
return(exp);
}
if (this.IsDatePart(exp))
{
return(exp);
}
}
if (this.IsDateSubtract(exp))
{
return(exp);
}
if (member.Name == "Length" && member.DeclaringType == PublicConstants.TypeOfString)
{
this.SqlBuilder.Append("LENGTH(");
exp.Expression.Accept(this);
this.SqlBuilder.Append(")");
return(exp);
}
if (member.Name == "Value" && ReflectionExtension.IsNullable(exp.Expression.Type))
{
exp.Expression.Accept(this);
return(exp);
}
DbParameterExpression newExp;
if (DbExpressionExtension.TryConvertToParameterExpression(exp, out newExp))
{
return(newExp.Accept(this));
}
throw new NotSupportedException(string.Format("'{0}.{1}' is not supported.", member.DeclaringType.FullName, member.Name));
}
public override DbExpression Visit(DbMemberExpression exp)
{
return(exp.Accept(this._generator));
}
bool IsDateSubtract(DbMemberExpression exp)
{
MemberInfo member = exp.Member;
if (member.DeclaringType == PublicConstants.TypeOfTimeSpan)
{
if (exp.Expression.NodeType == DbExpressionType.Call)
{
DbMethodCallExpression dbMethodExp = (DbMethodCallExpression)exp.Expression;
if (dbMethodExp.Method == PublicConstants.MethodInfo_DateTime_Subtract_DateTime)
{
int?intervalDivisor = null;
if (member == UtilConstants.PropertyInfo_TimeSpan_TotalDays)
{
intervalDivisor = 24 * 60 * 60 * 1000;
goto appendIntervalTime;
}
if (member == UtilConstants.PropertyInfo_TimeSpan_TotalHours)
{
intervalDivisor = 60 * 60 * 1000;
goto appendIntervalTime;
}
if (member == UtilConstants.PropertyInfo_TimeSpan_TotalMinutes)
{
intervalDivisor = 60 * 1000;
goto appendIntervalTime;
}
if (member == UtilConstants.PropertyInfo_TimeSpan_TotalSeconds)
{
intervalDivisor = 1000;
goto appendIntervalTime;
}
if (member == UtilConstants.PropertyInfo_TimeSpan_TotalMilliseconds)
{
intervalDivisor = 1;
goto appendIntervalTime;
}
return(false);
appendIntervalTime:
this.CalcDateDiffPrecise(dbMethodExp.Object, dbMethodExp.Arguments[0], intervalDivisor.Value);
return(true);
}
}
else
{
DbSubtractExpression dbSubtractExp = exp.Expression as DbSubtractExpression;
if (dbSubtractExp != null && dbSubtractExp.Left.Type == PublicConstants.TypeOfDateTime && dbSubtractExp.Right.Type == PublicConstants.TypeOfDateTime)
{
DbMethodCallExpression dbMethodExp = new DbMethodCallExpression(dbSubtractExp.Left, PublicConstants.MethodInfo_DateTime_Subtract_DateTime, new List <DbExpression>(1)
{
dbSubtractExp.Right
});
DbMemberExpression dbMemberExp = DbExpression.MemberAccess(member, dbMethodExp);
dbMemberExp.Accept(this);
return(true);
}
}
}
return(false);
}
public override bool CanTranslateToSql(DbMemberExpression exp)
{
return(_toTranslateMembers.Contains(exp.Member));
}
/// <summary>
/// 使用指定的引用成员，创建一个单元值内容表达式。
/// </summary>
/// <param name="member">引用成员表达式。</param>
public DbUnitValueContentExpression(DbMemberExpression member)
: base(((System.Reflection.PropertyInfo)member.Member).PropertyType)
{
Content = member;
}
