public void Query_ForPocoGivenSqlString_GivenSqlStartingWithDeclare__ShouldReturnValidPocoCollection()
{
AddOrders(12);
var pd = PocoData.ForType(typeof(Order), DB.DefaultMapper);
var sql = "DECLARE @@v INT;" +
"SET @@v = 1;" +
$"SELECT * FROM [{pd.TableInfo.TableName}] WHERE [{pd.Columns.Values.First(c => c.PropertyInfo.Name == "Status").ColumnName}] = @0";
var results = DB.Query <Order>(sql, OrderStatus.Pending).ToList();
results.Count.ShouldBe(3);
results.ForEach(o =>
{
o.PoNumber.ShouldStartWith("PO");
o.Status.ShouldBeOneOf(Enum.GetValues(typeof(OrderStatus)).Cast <OrderStatus>().ToArray());
o.PersonId.ShouldNotBe(Guid.Empty);
o.CreatedOn.ShouldBeLessThanOrEqualTo(new DateTime(1990, 1, 1, 0, 0, 0, DateTimeKind.Utc));
o.CreatedBy.ShouldStartWith("Harry");
});
}
public void Query_MultiResultsSet_SingleResultsSetSinglePoco__ShouldReturnValidPocoCollection()
{
AddPeople(1, 0);
var pd = PocoData.ForType(typeof(Person), DB.DefaultMapper);
var sql = "SET CONCAT_NULL_YIELDS_NULL ON;" +
$"SELECT * FROM [{pd.TableInfo.TableName}] WHERE [{pd.Columns.Values.First(c => c.PropertyInfo.Name == "Name").ColumnName}] LIKE @0 + '%'";
List <Person> result;
using (var multi = DB.QueryMultiple(sql, "Peta"))
{
result = multi.Read <Person>().ToList();
}
result.Count.ShouldBe(1);
var person = result.First();
person.Id.ShouldNotBe(Guid.Empty);
person.Name.ShouldStartWith("Peta");
person.Age.ShouldBe(18);
}
//mazq,2011-10-9,增加依据主键集合获取实体集合的方法
public IEnumerable <T> FetchByPrimaryKeys <T>(IEnumerable <object> primaryKeys)
{
if (primaryKeys == null || primaryKeys.Count() == 0)
{
return(new List <T>());
}
string primaryKeyName = _dbType.EscapeSqlIdentifier(PocoData.ForType(typeof(T)).TableInfo.PrimaryKey);
StringBuilder sqlBuilder = new StringBuilder("WHERE ");
int argIndex = 0;
foreach (var primaryKey in primaryKeys)
{
sqlBuilder.AppendFormat("{0} = @{1} or ", primaryKeyName, argIndex);
argIndex++;
}
sqlBuilder.Remove(sqlBuilder.Length - 4, 3);
return(Fetch <T>(sqlBuilder.ToString(), primaryKeys.ToArray()));
}
protected internal override string GetFromAndJoinOn()
{
var dp = DatabaseProvider.Resolve(_sqlhelper._sqlType);
var pd1 = PocoData.ForType(typeof(T1));
var pd2 = PocoData.ForType(typeof(T2));
var pd3 = PocoData.ForType(typeof(T3));
var pd4 = PocoData.ForType(typeof(T4));
StringBuilder sb = new StringBuilder();
sb.AppendFormat("FROM {0} AS t1 ", dp.GetTableName(pd1, _sqlhelper._tableNameManger));
if (string.IsNullOrEmpty(on2))
{
sb.AppendFormat(",{0} AS t2", dp.GetTableName(pd2, _sqlhelper._tableNameManger));
}
if (string.IsNullOrEmpty(on3))
{
sb.AppendFormat(",{0} AS t3", dp.GetTableName(pd3, _sqlhelper._tableNameManger));
}
if (string.IsNullOrEmpty(on4))
{
sb.AppendFormat(",{0} AS t4", dp.GetTableName(pd4, _sqlhelper._tableNameManger));
}
if (string.IsNullOrEmpty(on2) == false)
{
sb.AppendFormat(" {1} JOIN {0} AS t2 ON {2}", dp.GetTableName(pd2, _sqlhelper._tableNameManger), join2.ToString(), on2);
}
if (string.IsNullOrEmpty(on3) == false)
{
sb.AppendFormat(" {1} JOIN {0} AS t3 ON {2}", dp.GetTableName(pd3, _sqlhelper._tableNameManger), join3.ToString(), on3);
}
if (string.IsNullOrEmpty(on4) == false)
{
sb.AppendFormat(" {1} JOIN {0} AS t4 ON {2}", dp.GetTableName(pd4, _sqlhelper._tableNameManger), join4.ToString(), on4);
}
sb.Append(" ");
sb.Append(_joinOnString);
return(sb.ToString());
}
public void Query_ForDynamicTypeGivenSqlStringAndParameters_ShouldReturnValidDynamicTypeCollection()
{
AddOrders(12);
var pd = PocoData.ForType(typeof(Order), DB.DefaultMapper);
var sql =
$"SELECT * FROM {DB.Provider.EscapeTableName(pd.TableInfo.TableName)} " +
$"WHERE {DB.Provider.EscapeSqlIdentifier(pd.Columns.Values.First(c => c.PropertyInfo.Name == "Status").ColumnName)} = @0";
var results = DB.Query <dynamic>(sql, OrderStatus.Pending);
results.Count().ShouldBe(3);
var order = (IDictionary <string, object>)results.First();
((string)order[pd.Columns.Values.First(c => c.PropertyInfo.Name == "PoNumber").ColumnName]).ShouldStartWith("PO");
Convert.ToInt32(order[pd.Columns.Values.First(c => c.PropertyInfo.Name == "Status").ColumnName])
.ShouldBeOneOf(Enum.GetValues(typeof(OrderStatus)).Cast <int>().ToArray());
order[pd.Columns.Values.First(c => c.PropertyInfo.Name == "PersonId").ColumnName].ToString().ShouldNotBe(Guid.Empty.ToString());
ConvertToDateTime(order[pd.Columns.Values.First(c => c.PropertyInfo.Name == "CreatedOn").ColumnName])
.ShouldBeLessThanOrEqualTo(new DateTime(1990, 1, 1, 0, 0, 0, DateTimeKind.Utc));
((string)order[pd.Columns.Values.First(c => c.PropertyInfo.Name == "CreatedBy").ColumnName]).ShouldStartWith("Harry");
}
/// <summary>
/// 获取所有实体（仅用于数据量少的情况）
/// </summary>
/// <remarks>
/// 自动对进行缓存（缓存策略与实体配置的缓存策略相同）
/// </remarks>
/// <param name="orderBy">排序字段（多个字段用逗号分隔）</param>
/// <returns>返回按照orderBy排序的所有实体集合</returns>
public IEnumerable <TEntity> GetAll(string orderBy)
{
IEnumerable <object> entityIds = null;
string cacheKey = null;
if (RealTimeCacheHelper.EnableCache)
{
cacheKey = RealTimeCacheHelper.GetListCacheKeyPrefix(CacheVersionType.GlobalVersion);
if (!string.IsNullOrEmpty(orderBy))
{
cacheKey += "SB-" + orderBy;
}
entityIds = cacheService.Get <IEnumerable <object> >(cacheKey);
}
if (entityIds == null)
{
PocoData pocoData = PocoData.ForType(typeof(TEntity));
var sql = PetaPoco.Sql.Builder
.Select(pocoData.TableInfo.PrimaryKey)
.From(pocoData.TableInfo.TableName);
if (!string.IsNullOrEmpty(orderBy))
{
sql.OrderBy(orderBy);
}
entityIds = CreateDAO().FetchFirstColumn(sql);
if (RealTimeCacheHelper.EnableCache)
{
cacheService.Add(cacheKey, entityIds, RealTimeCacheHelper.CachingExpirationType);
}
}
IEnumerable <TEntity> entities = PopulateEntitiesByEntityIds(entityIds);
return(entities);
}
//mazq,2011-10-8
/// <summary>
/// 创建分页的SQL语句
/// </summary>
protected void BuildPagingPrimaryKeyQueries <T>(long maxRecords, long skip, long take, string sql, ref object[] args, out string sqlCount, out string sqlPage)
{
var pd = PocoData.ForType(typeof(T));
//libsh,2012-12-05
string primaryKey = string.Empty;
if (sql.Contains(pd.TableInfo.TableName))
{
primaryKey = pd.TableInfo.TableName + "." + pd.TableInfo.PrimaryKey;
}
else
{
primaryKey = pd.TableInfo.PrimaryKey;
}
if (EnableAutoSelect)
{
sql = AutoSelectHelper.AddSelectClause <T>(_dbType, sql, primaryKey);
}
BuildPagingPrimaryKeyQueries(maxRecords, skip, take, primaryKey /*libsh,2012-12-05*/, sql, ref args, out sqlCount, out sqlPage);
}
private static void CreateGetChangesMethod(MethodBuilder getChangesMethod, FieldBuilder fb)
{
var pd = PocoData.ForType(typeof(T));
var il = getChangesMethod.GetILGenerator();
il.Emit(OpCodes.Ldarg_0); // IL_0001: ldarg.0
il.Emit(OpCodes.Ldfld, fb); // IL_0002: ldfld class [mscorlib] System.Collections.Generic.Dictionary`2<string, object> ConsoleApplication1.UserProxy::dict
il.Emit(OpCodes.Callvirt, clearMethod); //IL_0007: callvirt instance void class [mscorlib] System.Collections.Generic.Dictionary`2<string, object>::Clear()
foreach (var item in pd.Columns)
{
var pi = item.PropertyInfo;
var piType = pi.PropertyType;
var m = getEqualsMethod(piType);
il.Emit(OpCodes.Ldarg_0); // IL_0054: ldarg.0
il.Emit(OpCodes.Call, pi.GetGetMethod()); // IL_0055: call instance class ConsoleApplication1.TestClass ConsoleApplication1.User::get_ss()
if (piType.IsEnum)
{
il.Emit(OpCodes.Box, piType);
}
il.Emit(OpCodes.Ldarg_1); // IL_005a: ldarg.1
il.Emit(OpCodes.Callvirt, pi.GetGetMethod()); // IL_005b: callvirt instance class ConsoleApplication1.TestClass ConsoleApplication1.User::get_ss()
if (piType.IsEnum)
{
il.Emit(OpCodes.Box, piType);
}
il.Emit(OpCodes.Ldstr, item.ColumnName); // IL_0060: ldstr "ss"
il.Emit(OpCodes.Ldarg_0); // IL_0065: ldarg.0
il.Emit(OpCodes.Ldfld, fb); // IL_0066: ldfld class [mscorlib] System.Collections.Generic.Dictionary`2<string, object> ConsoleApplication1.UserProxy::dict
il.Emit(OpCodes.Call, m); //IL_006b: call void ConsoleApplication1.UpdateChangeHelper::EqualsObject(object, object, string, class [mscorlib] System.Collections.Generic.Dictionary`2<string, object>)
}
il.Emit(OpCodes.Ldarg_0); // IL_0054: ldarg.0
il.Emit(OpCodes.Ldfld, fb); //IL_0055: ldfld class [mscorlib] System.Collections.Generic.Dictionary`2<string, object> ConsoleApplication1.UserProxy::dict
il.Emit(OpCodes.Ret);
}
public static string AddSelectClause <T>(IProvider provider, string sql, IMapper defaultMapper)
{
if (sql.StartsWith(";"))
{
return(sql.Substring(1));
}
if (!rxSelect.IsMatch(sql))
{
var pd = PocoData.ForType(typeof(T), defaultMapper);
var tableName = provider.EscapeTableName(pd.TableInfo.TableName);
string cols = pd.Columns.Count != 0 ? string.Join(", ", (from c in pd.QueryColumns select tableName + "." + provider.EscapeSqlIdentifier(c)).ToArray()) : "NULL";
if (!rxFrom.IsMatch(sql))
{
sql = string.Format("SELECT {0} FROM {1} {2}", cols, tableName, sql);
}
else
{
sql = string.Format("SELECT {0} {1}", cols, sql);
}
}
return(sql);
}
public static bool AddRange <T>(this Database db, IEnumerable <T> list) where T : IModel
{
if (list == null || list.Count() == 0)
{
return(false);
}
return(DbFactory.Default
.InTransaction(() =>
{
var flag = true;
var pd = PocoData.ForType(list.First().GetType());
foreach (var target in list)
{
var model = target as IModel;
flag = db.Insert(pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, pd.TableInfo.AutoIncrement, model).ToBool_();
model.ModifiedComplete();
if (!flag)
{
return flag;
}
}
return flag;
}));
}
/// <summary>
/// Get table name
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public string GetTableName(Type t)
{
return(_dbType.EscapeSqlIdentifier(PocoData.ForType(t).TableInfo.TableName));
}
/// <summary>
/// 把实体entiy更新到数据库
/// </summary>
/// <param name="entity">实体</param>
public virtual void Update(TEntity entity)
{
Database dao = CreateDAO();
int affectedRecords;
//处理可序列化属性
if (entity is ISerializableProperties)
{
ISerializableProperties extendedProperties = entity as ISerializableProperties;
if (extendedProperties != null)
{
extendedProperties.Serialize();
}
}
//设置实体正文缓存时如果未给实体正文赋值则不更新
if (RealTimeCacheHelper.PropertyNameOfBody != null && RealTimeCacheHelper.PropertyNameOfBody.GetValue(entity, null) == null)
{
var pd = PocoData.ForType(typeof(TEntity));
List <string> columns = new List <string>();
foreach (var column in pd.Columns)
{
//去掉主键
if (string.Compare(column.Key, pd.TableInfo.PrimaryKey, true) == 0)
{
continue;
}
//去掉不允许update的属性
if ((SqlBehaviorFlags.Update & column.Value.SqlBehavior) == 0)
{
continue;
}
//去掉实体正文
if (string.Compare(column.Key, RealTimeCacheHelper.PropertyNameOfBody.Name, true) == 0)
{
continue;
}
// Dont update result only columns
if (column.Value.ResultColumn)
{
continue;
}
columns.Add(column.Key);
}
affectedRecords = dao.Update(entity, columns);
}
else
{
affectedRecords = dao.Update(entity);
}
if (affectedRecords > 0)
{
OnUpdated(entity);
}
}
public PocoData GetPocoDataForType(Type t)
{
return(PocoData.ForType(t, DefaultMapper));
}
public void PD_IncludedResultColumn_InAutoSelect()
{
var pd = PocoData.ForType(typeof(PocoWithIncludedResultColumn), new ConventionMapper());
pd.QueryColumns.ShouldBe(new[] { "RegularProperty", "ResultProperty" });
}
public static void AppendSQLLog(string userid, Type modelType, params string[] sql)
{
var pd = PocoData.ForType(modelType);
LogDAL.AppendSQLLog(MTConfig.CurrentUserID, pd.TableInfo.TableName);
}
/// <summary>
/// 获取表名称
/// </summary>
/// <param name="db">数据库实例</param>
/// <param name="type">实体类型</param>
/// <returns>转码后的表名</returns>
public static string GetTableName(this Database db, Type type)
{
return(GetTableName(db, PocoData.ForType(type).TableInfo.TableName));
}
internal TableFix Get <T>()
{
var tag = PocoData.ForType(typeof(T)).TableInfo.FixTag;
return(Get(tag));
}
/// <summary>
/// Get Primary key name
/// </summary>
/// <param name="t"></param>
/// <returns></returns>
public string GetPrimaryKeyName(Type t)
{
return(_dbType.EscapeSqlIdentifier(PocoData.ForType(t).TableInfo.PrimaryKey));
}
public static string AddSelectClause <T>(DatabaseProvider DatabaseType, string sql, TableNameManger manger)
{
if (sql.StartsWith(";"))
{
return(sql.Substring(1));
}
if (rxSelect.IsMatch(sql))
{
return(sql);
}
var type = typeof(T);
var selectHeaders = selectClause.Get(Tuple.Create(type, DatabaseType), () => {
var pd = PocoData.ForType(typeof(T));
var tableName = DatabaseType.EscapeTableName(pd.TableInfo.TableName);
StringBuilder sb = new StringBuilder();
foreach (var col in pd.Columns)
{
if (sb.Length > 0)
{
sb.Append(",");
}
if (col.ResultColumn && string.IsNullOrEmpty(col.ResultSql) == false)
{
sb.AppendFormat(col.ResultSql, tableName + ".");
sb.Append(" AS '");
sb.Append(col.ColumnName);
sb.Append("'");
}
else
{
sb.Append(tableName);
sb.Append(".");
sb.Append(DatabaseType.EscapeSqlIdentifier(col.ColumnName));
}
}
if (sb.Length == 0)
{
sb.Append("NULL");
}
sb.Insert(0, "SELECT ");
return(sb.ToString());
});
StringBuilder s = new StringBuilder();
s.Append(selectHeaders);
if (!rxFrom.IsMatch(sql))
{
s.Append(" FROM ");
var tableName2 = DatabaseType.EscapeTableName(PocoData.ForType(typeof(T)).TableInfo.TableName);
s.Append(tableName2);
}
s.Append(" ");
s.Append(sql);
return(s.ToString());
}
private static Delegate CreateDefaultFunction <T>()
{
#region 初始时间
var pd = PocoData.ForType(typeof(T));
List <PropertyInfo> datetimes = new List <PropertyInfo>();
List <PropertyInfo> datetimeoffsets = new List <PropertyInfo>();
List <PropertyInfo> strings = new List <PropertyInfo>();
List <PropertyInfo> ansiStrings = new List <PropertyInfo>();
List <PropertyInfo> guids = new List <PropertyInfo>();
foreach (var item in pd.Columns)
{
if (item.Value.ResultColumn)
{
continue;
}
var pi = item.Value.PropertyInfo;
if (pi.PropertyType == typeof(DateTime))
{
datetimes.Add(pi);
}
else if (pi.PropertyType == typeof(DateTimeOffset))
{
datetimeoffsets.Add(pi);
}
else if (pi.PropertyType == typeof(string))
{
strings.Add(pi);
}
else if (pi.PropertyType == typeof(Guid))
{
guids.Add(pi);
}
else if (pi.PropertyType == typeof(AnsiString))
{
ansiStrings.Add(pi);
}
}
#endregion
#region dateTimeType dateTimeOffsetType AnsiString
var dateTimeType = typeof(DateTime);
//var getYear = dateTimeType.GetProperty("Year");
var getNow = dateTimeType.GetProperty("Now", BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic);
var getMinValue = dateTimeType.GetField("MinValue", BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic);
var getop_Equality = dateTimeType.GetMethod("op_Equality", BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic);
var dateTimeOffsetType = typeof(DateTimeOffset);
var getNow2 = dateTimeOffsetType.GetProperty("Now", BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic);
var getMinValue2 = dateTimeOffsetType.GetField("MinValue", BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic);
var getop_Equality2 = dateTimeOffsetType.GetMethod("op_Equality", BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic);
var guidType = typeof(Guid);
var getEmpty = guidType.GetField("Empty", BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic);
var getNewGuid = guidType.GetMethod("NewGuid", BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic);
var getop_Equality3 = guidType.GetMethod("op_Equality", BindingFlags.Public | BindingFlags.Static | BindingFlags.NonPublic);
var asctor = typeof(AnsiString).GetConstructor(new Type[] { typeof(string) });
#endregion
var m = new DynamicMethod("toolgood_default_" + Guid.NewGuid().ToString().Replace("-", ""), typeof(void), new Type[] { typeof(T), typeof(bool), typeof(bool), typeof(bool) }, true);
var il = m.GetILGenerator();
#region string
if (strings.Count > 0)
{
il.Emit(OpCodes.Ldarg_1);
var lab1 = il.DefineLabel();
if (strings.Count < 7)
{
il.Emit(OpCodes.Brfalse_S, lab1);
}
else
{
il.Emit(OpCodes.Brfalse, lab1);
}
for (int i = 0; i < strings.Count; i++)
{
var item = strings[i];
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, item.GetGetMethod());
var lab = il.DefineLabel();
il.Emit(OpCodes.Brtrue_S, lab);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldstr, "");
il.Emit(OpCodes.Callvirt, item.GetSetMethod());
il.MarkLabel(lab);
}
il.MarkLabel(lab1);
}
#endregion
#region AnsiString
if (ansiStrings.Count > 0)
{
il.Emit(OpCodes.Ldarg_1);
var lab1 = il.DefineLabel();
if (ansiStrings.Count < 7)
{
il.Emit(OpCodes.Brfalse_S, lab1);
}
else
{
il.Emit(OpCodes.Brfalse, lab1);
}
for (int i = 0; i < ansiStrings.Count; i++)
{
var item = ansiStrings[i];
var lab = il.DefineLabel();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, item.GetGetMethod());
il.Emit(OpCodes.Brtrue_S, lab);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldstr, "");
il.Emit(OpCodes.Newobj, asctor);
il.Emit(OpCodes.Callvirt, item.GetSetMethod());
il.MarkLabel(lab);
}
il.MarkLabel(lab1);
}
#endregion
#region date
if (datetimes.Count + datetimeoffsets.Count > 0)
{
il.Emit(OpCodes.Ldarg_2);
var lab2 = il.DefineLabel();
if (datetimes.Count + datetimeoffsets.Count < 5)
{
il.Emit(OpCodes.Brfalse_S, lab2);
}
else
{
il.Emit(OpCodes.Brfalse, lab2);
}
#region datetimes
foreach (var item in datetimes)
{
var lab = il.DefineLabel();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, item.GetGetMethod());
il.Emit(OpCodes.Ldsfld, getMinValue);
il.Emit(OpCodes.Call, getop_Equality);
il.Emit(OpCodes.Brfalse_S, lab);
il.Emit(OpCodes.Ldarg_0);
//il.Emit(OpCodes.Ldsfld, getMinValue);
il.Emit(OpCodes.Call, getNow.GetGetMethod());
il.Emit(OpCodes.Callvirt, item.GetSetMethod());
il.MarkLabel(lab);
}
#endregion
#region datetimeoffsets
foreach (var item in datetimeoffsets)
{
var lab = il.DefineLabel();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, item.GetGetMethod());
il.Emit(OpCodes.Ldsfld, getMinValue2);
il.Emit(OpCodes.Call, getop_Equality2);
il.Emit(OpCodes.Brfalse_S, lab);
il.Emit(OpCodes.Ldarg_0);
//il.Emit(OpCodes.Ldsfld, getMinValue);
il.Emit(OpCodes.Call, getNow2.GetGetMethod());
il.Emit(OpCodes.Callvirt, item.GetSetMethod());
il.MarkLabel(lab);
}
#endregion
il.MarkLabel(lab2);
}
#endregion
#region guid
if (guids.Count > 0)
{
il.Emit(OpCodes.Ldarg_3);
var lab3 = il.DefineLabel();
if (guids.Count < 5)
{
il.Emit(OpCodes.Brfalse_S, lab3);
}
else
{
il.Emit(OpCodes.Brfalse, lab3);
}
foreach (var item in guids)
{
var lab = il.DefineLabel();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, item.GetGetMethod());
il.Emit(OpCodes.Ldsfld, getEmpty);
il.Emit(OpCodes.Call, getop_Equality3);
il.Emit(OpCodes.Brfalse_S, lab);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, getNewGuid);
il.Emit(OpCodes.Callvirt, item.GetSetMethod());
il.MarkLabel(lab);
}
il.MarkLabel(lab3);
}
#endregion
il.Emit(OpCodes.Ret);
return(m.CreateDelegate(Expression.GetActionType(typeof(T), typeof(bool), typeof(bool), typeof(bool))));
}
/// <summary>
/// 获取表名称
/// </summary>
/// <param name="db">数据库实例</param>
/// <param name="type">实体类型</param>
/// <returns>转码后的表名</returns>
public static string GetTableName(this IDatabase db, Type type)
{
return(GetTableName(db, PocoData.ForType(type, db.DefaultMapper).TableInfo.TableName));
}
/// <summary>
/// 格式化列名为：[表名].[列名]
/// </summary>
/// <param name="entityType"></param>
/// <param name="name"></param>
/// <param name="fromTable"></param>
/// <returns></returns>
public static string FormatColumn(Type entityType, string name, out string fromTable)
{
//entitytype这里要替换为impletation type
entityType = DomainMapper.GetImplementType(entityType);
return(FormatColumn(PocoData.ForType(entityType, new DomainMapper()), name, out fromTable));
}
public int Count <T>()
{
var pd = PocoData.ForType(typeof(T));
return(Count(pd.TableInfo.TableName));
}
/// <summary>
/// 添加
/// </summary>
/// <typeparam name="T">实体类型</typeparam>
/// <param name="db">数据库实例</param>
/// <param name="entity">要添加的实体</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
public static bool Add <T>(this Database db, T entity) where T : new()
{
var pd = PocoData.ForType(entity.GetType());
return(db.Insert(pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, false, entity).ToBool_());
}
/// <summary>
/// 添加带自增 ID 的实体
/// </summary>
/// <typeparam name="T">返回的自增 ID 类型</typeparam>
/// <param name="db">数据库实例</param>
/// <param name="entity">要添加的实体</param>
/// <returns>自增 ID 的值</returns>
public static T Add <T>(this Database db, object entity)
{
var pd = PocoData.ForType(entity.GetType());
return((T)Convert.ChangeType(db.Insert(pd.TableInfo.TableName, pd.TableInfo.PrimaryKey, true, entity), typeof(T)));
}
protected BaseExecuteTests(DBTestProvider provider)
: base(provider)
{
_pd = PocoData.ForType(typeof(Note), DB.DefaultMapper);
}
private object VisitMemberAccess(MemberExpression m)
{
//if (IsNullableMember(m)) {
// m = m.Expression as MemberExpression;
//}
if (m.Expression != null &&
(m.Expression.NodeType == ExpressionType.Parameter || m.Expression.NodeType == ExpressionType.Convert))
{
var me = m;
if (m.Expression.NodeType == ExpressionType.Convert)
{
me = (m.Expression as UnaryExpression).Operand.Reduce() as MemberExpression;
}
var p = me.Expression as ParameterExpression;
var tableDef = PocoData.ForType(p.Type);
var colName = m.Member.Name;
var col = tableDef.Columns.Where(q => q.Value.PropertyName == colName).Select(q => q.Value).FirstOrDefault();
if (col != null)
{
colName = col.ColumnName;
}
return(new PartialSqlString(colName));
}
if (m.Member.DeclaringType == typeof(DateTime) || m.Member.DeclaringType == typeof(DateTime?))
{
var m1 = m.Expression as MemberExpression;
if (m1 != null)
{
var p = Expression.Convert(m1, typeof(object));
if (p.NodeType == ExpressionType.Convert)
{
var pp = m1.Expression as ParameterExpression;
if (pp == null)
{
m1 = m1.Expression as MemberExpression;
if (m1 != null)
{
pp = m1.Expression as ParameterExpression;
}
}
if (pp != null)
{
string sql = null;
switch (m.Member.Name)
{
case "Year": sql = provider.CreateFunction(SqlFunction.Year, Visit(m1)); break;
case "Month": sql = provider.CreateFunction(SqlFunction.Month, Visit(m1)); break;
case "Day": sql = provider.CreateFunction(SqlFunction.Day, Visit(m1)); break;
case "Hour": sql = provider.CreateFunction(SqlFunction.Hour, Visit(m1)); break;
case "Minute": sql = provider.CreateFunction(SqlFunction.Minute, Visit(m1)); break;
case "Second": sql = provider.CreateFunction(SqlFunction.Second, Visit(m1)); break;
case "Value": return(Visit(m1));
//case "HasValue": sql = Visit(m1).ToString() + " IS NOT NULL "; break;
default: throw new NotSupportedException("Not Supported " + m.Member.Name);
}
return(new PartialSqlString(sql));
}
}
}
}
var member = Expression.Convert(m, typeof(object));
var lambda = Expression.Lambda <Func <object> >(member);
var getter = lambda.Compile();
return(getter());
}
