/// <summary>
/// 获取实体类映射字段特性
/// </summary>
/// <param name="entityType">实体类型</param>
/// <param name="propertyName">实体属性名称</param>
/// <returns>字段特性</returns>
internal static DatabaseColumnAttribute InternalGetColumnAttribute(Type entityType, String propertyName)
{
PropertyInfo[] props = entityType.GetProperties();
foreach (PropertyInfo prop in props)
{
if (!String.Equals(prop.Name, propertyName))
{
continue;
}
DatabaseColumnAttribute attr = null;
Object[] objs = prop.GetCustomAttributes(TypeOfDatabaseColumnAttribute, true);
foreach (Object obj in objs)
{
if ((attr = obj as DatabaseColumnAttribute) != null)
{
return(attr);
}
}
}
return(null);
}
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>
/// 按指定列排序并返回当前语句
/// </summary>
/// <typeparam name="T">实体类类型</typeparam>
/// <param name="cmd">查询语句</param>
/// <param name="expr">实体类属性</param>
/// <param name="orderType">排序类型</param>
/// <exception cref="ExpressionInvalidException">表达式不正确</exception>
/// <exception cref="NullAttributeException">没有设置特性</exception>
/// <returns>当前语句</returns>
/// <example>
/// <code lang="C#">
/// <![CDATA[
/// public class UserRepository : DatabaseTable<User>
/// {
/// //other necessary code
///
/// public List<User> GetAllEntities()
/// {
/// return this.Select()
/// .Querys<User>(c => new { c.UserID, c.UserName })
/// .OrderBy<User>(c => c.UserID, SqlOrderType.Desc)
/// .ToEntityList<User>(this);
///
/// //SELECT UserID, UserName From tbl_Users ORDER BY UserID DESC
/// }
/// }
/// ]]>
/// </code>
/// </example>
public static SelectCommand OrderBy <T>(this SelectCommand cmd, Expression <Func <T, Object> > expr, SqlOrderType orderType)
{
DatabaseColumnAttribute attr = SelectCommandExtension.GetColumnAttribute(cmd, expr.Body);
String tableName = EntityHelper.InternalGetTableName(typeof(T));
return(cmd.OrderBy(tableName, attr.ColumnName, orderType));
}
/// <summary>
/// 获取表达式所指的列特性
/// </summary>
/// <param name="sourceCommand">来源Sql语句</param>
/// <param name="expr">表达式</param>
/// <returns>表达式所指的列特性</returns>
internal static DatabaseColumnAttribute GetColumnAttribute(AbstractSqlCommand sourceCommand, MemberExpression expr)
{
DatabaseColumnAttribute attr = (sourceCommand != null && sourceCommand.SourceDatabaseTable != null ? sourceCommand.SourceDatabaseTable[expr.Member.Name] : null);
if (attr == null)
{
attr = EntityHelper.InternalGetColumnAttribute(expr.Member.DeclaringType, expr.Member.Name);
}
return(attr);
}
/// <summary>
/// 获取一定包含数据类型的表达式所指的列特性
/// </summary>
/// <param name="sourceCommand">来源Sql语句</param>
/// <param name="expr">表达式</param>
/// <returns>表达式所指的列特性</returns>
internal static DatabaseColumnAttribute GetColumnAttributeWithDataType(AbstractSqlCommand sourceCommand, MemberExpression expr)
{
DatabaseColumnAttribute attr = ExpressionHelper.GetColumnAttribute(sourceCommand, expr);
if (attr != null && !attr.DataType.HasValue)
{
attr.DataType = DataTypeHelper.InternalGetDataType(expr.Type);
}
return(attr);
}
public FilterModelProvider(HyenaSqliteConnection conn, string table_name, string pk_column, PropertyInfo pk_info, string value_column, PropertyInfo value_info) : base(conn)
{
this.table_name = table_name;
PrimaryKey = pk_column;
DatabaseColumnAttribute pk_attr = new DatabaseColumnAttribute();
pk_attr.Constraints = DatabaseColumnConstraints.PrimaryKey;
AddColumn(new DatabaseColumn(pk_info, pk_attr), true);
AddColumn(new DatabaseColumn(value_info, new DatabaseColumnAttribute()), true);
select = String.Format("{0} as Value", value_column);
}
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);
}
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>
/// 更新指定参数并返回当前语句
/// </summary>
/// <typeparam name="T">实体类类型</typeparam>
/// <param name="cmd">更新语句</param>
/// <param name="expr">实体类属性</param>
/// <param name="value">内容</param>
/// <exception cref="ExpressionInvalidException">表达式不正确</exception>
/// <exception cref="NullAttributeException">没有设置特性</exception>
/// <returns>当前语句</returns>
/// <example>
/// <code lang="C#">
/// <![CDATA[
/// public class UserRepository : DatabaseTable<User>
/// {
/// //other necessary code
///
/// public Boolean UpdateEntity(User user)
/// {
/// return this.Update()
/// .Set<User>(c => c.UserName, user.UserName)
/// .Where<User>(c => c.UserID == user.UserID)
/// .Result() > 0;
///
/// //UPDATE tbl_Users SET UserName = @UserName WHERE UserID = @UserID
/// //@UserName = user.UserName
/// //@UserID = user.UserID
/// }
/// }
/// ]]>
/// </code>
/// </example>
public static UpdateCommand Set <T>(this UpdateCommand cmd, Expression <Func <T, Object> > expr, Object value)
{
MemberExpression left = ExpressionHelper.GetMemberExpression(expr.Body);
if (left == null)
{
throw new ExpressionInvalidException();
}
DatabaseColumnAttribute attr = ExpressionHelper.GetColumnAttributeWithDataType(cmd, left);
if (attr == null)
{
throw new NullAttributeException();
}
return(cmd.Set(attr.ColumnName, attr.DataType.Value, value));
}
/// <summary>
/// 指定字段名自减并返回当前语句
/// </summary>
/// <typeparam name="T">实体类类型</typeparam>
/// <param name="cmd">更新语句</param>
/// <param name="expr">实体类属性</param>
/// <exception cref="ExpressionInvalidException">表达式不正确</exception>
/// <exception cref="NullAttributeException">没有设置特性</exception>
/// <returns>当前语句</returns>
/// <example>
/// <code lang="C#">
/// <![CDATA[
/// public class UserRepository : DatabaseTable<User>
/// {
/// //other necessary code
///
/// public Boolean UpdateEntity(User user)
/// {
/// return this.Update()
/// .Decrease<User>(c => c.LoginTimes)
/// .Where<User>(c => c.UserID == user.UserID)
/// .Result() > 0;
///
/// //UPDATE tbl_Users SET LoginTimes = LoginTimes - 1 WHERE UserID = @UserID
/// //@UserID = user.UserID
/// }
/// }
/// ]]>
/// </code>
/// </example>
public static UpdateCommand Decrease <T>(this UpdateCommand cmd, Expression <Func <T, Object> > expr)
{
MemberExpression left = ExpressionHelper.GetMemberExpression(expr.Body);
if (left == null)
{
throw new ExpressionInvalidException();
}
DatabaseColumnAttribute attr = ExpressionHelper.GetColumnAttribute(cmd, left);
if (attr == null)
{
throw new NullAttributeException();
}
return(cmd.Decrease(attr.ColumnName));
}
private static DatabaseColumnAttribute GetColumnAttribute(SelectCommand cmd, Expression expr)
{
MemberExpression left = ExpressionHelper.GetMemberExpression(expr);
if (expr == null)
{
throw new ExpressionInvalidException();
}
DatabaseColumnAttribute attr = ExpressionHelper.GetColumnAttribute(cmd, left);
if (attr == null)
{
throw new NullAttributeException();
}
return(attr);
}
/// <summary>
/// 获取指定实体类的Sql语句参数集合
/// </summary>
/// <param name="cmd">Sql语句</param>
/// <param name="entity">实体类</param>
/// <returns>Sql语句参数集合</returns>
internal static DataParameter[] InternalGetSqlParameters(AbstractSqlCommand cmd, Object entity)
{
List <DataParameter> parameters = new List <DataParameter>();
if (entity == null)
{
return(parameters.ToArray());
}
Type entityType = entity.GetType();
PropertyInfo[] props = entityType.GetProperties();
foreach (PropertyInfo prop in props)
{
DatabaseColumnAttribute attr = null;
DataType?dataType = null;
Object[] objs = prop.GetCustomAttributes(TypeOfDatabaseColumnAttribute, true);
foreach (Object obj in objs)
{
if ((attr = obj as DatabaseColumnAttribute) != null)
{
break;
}
}
if (attr != null)
{
dataType = attr.DataType;
if (!dataType.HasValue)
{
dataType = DataTypeHelper.InternalGetDataType(prop.PropertyType);
}
DataParameter parameter = cmd.CreateDataParameter(attr.ColumnName, dataType.Value, prop.GetValue(entity, null));
parameters.Add(parameter);
}
}
return(parameters.ToArray());
}
/// <summary>
/// 连接语句并返回当前语句
/// </summary>
/// <typeparam name="T">实体类类型</typeparam>
/// <typeparam name="TAnother">另个表格的实体类类型</typeparam>
/// <param name="cmd">查询语句</param>
/// <param name="joinType">连接模式</param>
/// <param name="currentExpr">当前实体类主键属性</param>
/// <param name="anotherAction">设置选择语句的方法</param>
/// <param name="anotherExpr">另个实体类主键属性</param>
/// <exception cref="ExpressionInvalidException">表达式不正确</exception>
/// <exception cref="NullAttributeException">没有设置特性</exception>
/// <returns>当前语句</returns>
public static SelectCommand Join <T, TAnother>(this SelectCommand cmd, SqlJoinType joinType, Expression <Func <T, Object> > currentExpr, Action <SelectCommand> anotherAction, Expression <Func <TAnother, Object> > anotherExpr)
{
MemberExpression currentLeft = ExpressionHelper.GetMemberExpression(currentExpr.Body);
MemberExpression anotherLeft = ExpressionHelper.GetMemberExpression(anotherExpr.Body);
if (currentLeft == null || anotherLeft == null)
{
throw new ExpressionInvalidException();
}
DatabaseColumnAttribute currentAttr = ExpressionHelper.GetColumnAttribute(cmd, currentLeft);
DatabaseColumnAttribute anotherAttr = ExpressionHelper.GetColumnAttribute(cmd, anotherLeft);
if (currentAttr == null || anotherAttr == null)
{
throw new NullAttributeException();
}
String anotherTableName = EntityHelper.InternalGetTableName(typeof(TAnother));
return(cmd.Join(joinType, currentAttr.ColumnName, anotherTableName, anotherAttr.ColumnName, anotherAction));
}
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);
}
/// <summary>
/// 查询指定字段名并返回当前语句
/// </summary>
/// <typeparam name="T">实体类类型</typeparam>
/// <param name="cmd">查询语句</param>
/// <param name="expr">实体类属性</param>
/// <exception cref="ExpressionInvalidException">表达式不正确</exception>
/// <exception cref="NullAttributeException">没有设置特性</exception>
/// <returns>当前语句</returns>
/// <example>
/// <code lang="C#">
/// <![CDATA[
/// public class UserRepository : DatabaseTable<User>
/// {
/// //other necessary code
///
/// public User GetEntity(Int32 userID)
/// {
/// return this.Select()
/// .Querys<User>(c => new { c.UserID, c.UserName })
/// .Where<User>(c => c.UserID == userID)
/// .ToEntity<User>(this) > 0;
///
/// //SELECT UserID, UserName From tbl_Users WHERE UserID = @UserID
/// //@UserID = userID
/// }
/// }
/// ]]>
/// </code>
/// </example>
public static SelectCommand Querys <T>(this SelectCommand cmd, Expression <Func <T, Object> > expr)
{
NewExpression left = expr.Body as NewExpression;
if (left == null)
{
throw new ExpressionInvalidException();
}
foreach (MemberExpression member in left.Arguments)
{
DatabaseColumnAttribute attr = ExpressionHelper.GetColumnAttribute(cmd, member);
if (attr == null)
{
continue;
}
cmd.Query(attr.ColumnName);
}
return(cmd);
}
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);
}
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>
/// 获取实体列特性集合
/// </summary>
/// <param name="entityType">实体类型</param>
/// <returns>实体列特性集合</returns>
internal static Dictionary <String, DatabaseColumnAttribute> InternalGetTableColumns(Type entityType)
{
Dictionary <String, DatabaseColumnAttribute> dict = new Dictionary <String, DatabaseColumnAttribute>();
PropertyInfo[] props = entityType.GetProperties();
foreach (PropertyInfo prop in props)
{
Object[] objs = prop.GetCustomAttributes(TypeOfDatabaseColumnAttribute, true);
foreach (Object obj in objs)
{
DatabaseColumnAttribute attr = obj as DatabaseColumnAttribute;
if (attr != null)
{
dict[prop.Name] = attr;
break;
}
}
}
return(dict);
}
public DatabaseColumnContext(string name, DatabaseColumnAttribute column)
{
Name = name;
Column = column;
}
/// <summary>
/// 分组指定字段名并返回当前语句
/// </summary>
/// <typeparam name="T">实体类类型</typeparam>
/// <param name="cmd">查询语句</param>
/// <param name="expr">实体类属性</param>
/// <exception cref="ExpressionInvalidException">表达式不正确</exception>
/// <exception cref="NullAttributeException">没有设置特性</exception>
/// <returns>当前语句</returns>
/// <example>
/// <code lang="C#">
/// <![CDATA[
/// public class UserRepository : DatabaseTable<User>
/// {
/// //other necessary code
///
/// public DataTable GetAllEntities()
/// {
/// return this.Select()
/// .Querys<User>(c => new { c.UserType })
/// .GroupBy<User>(c => c.UserType)
/// .ToDataTable(this);
///
/// //SELECT UserType From tbl_Users GROUP BY UserType
/// }
/// }
/// ]]>
/// </code>
/// </example>
public static SelectCommand GroupBy <T>(this SelectCommand cmd, Expression <Func <T, Object> > expr)
{
DatabaseColumnAttribute attr = SelectCommandExtension.GetColumnAttribute(cmd, expr.Body);
return(cmd.GroupBy(attr.ColumnName));
}
/// <summary>
/// 查询指定字段名并返回当前语句
/// </summary>
/// <typeparam name="T">实体类类型</typeparam>
/// <param name="cmd">查询语句</param>
/// <param name="expr">实体类属性</param>
/// <param name="function">合计函数类型</param>
/// <param name="aliasesName">字段名的别名</param>
/// <exception cref="ExpressionInvalidException">表达式不正确</exception>
/// <exception cref="NullAttributeException">没有设置特性</exception>
/// <returns>当前语句</returns>
/// <example>
/// <code lang="C#">
/// <![CDATA[
/// public class UserRepository : DatabaseTable<User>
/// {
/// //other necessary code
///
/// public Int32 Count()
/// {
/// return this.Select()
/// .Query<User>(c => c.UserID, SqlAggregateFunction.Count, "UserCount")
/// .Result<Int32>();
///
/// //SELECT COUNT(UserID) AS UserCount From tbl_Users
/// }
/// }
/// ]]>
/// </code>
/// </example>
public static SelectCommand Query <T>(this SelectCommand cmd, Expression <Func <T, Object> > expr, SqlAggregateFunction function, String aliasesName)
{
DatabaseColumnAttribute attr = SelectCommandExtension.GetColumnAttribute(cmd, expr.Body);
return(cmd.Query(function, attr.ColumnName, aliasesName));
}
/// <summary>
/// 获取表达式所指的列名
/// </summary>
/// <param name="sourceCommand">来源Sql语句</param>
/// <param name="expr">表达式</param>
/// <returns>表达式所指的列名</returns>
internal static String GetColumnName(AbstractSqlCommand sourceCommand, MemberExpression expr)
{
DatabaseColumnAttribute attr = ExpressionHelper.GetColumnAttribute(sourceCommand, expr);
return(attr != null ? attr.ColumnName : String.Empty);
}
