/// <summary>
/// 得到Sql语句
/// </summary>
/// <param name="obj"></param>
/// <param name="selectComplier"></param>
/// <param name="tableSql"></param>
/// <param name="whereComplier"></param>
/// <param name="havingComplier"></param>
/// <param name="orderbyComplier"></param>
/// <param name="groupbyComplier"></param>
/// <param name="query"></param>
/// <returns></returns>
protected virtual string GetSql(OrmObjectInfo obj, QueryCompilerInfo selectComplier, string tableSql,
WhereCompilerInfo whereComplier, QueryCompilerInfo groupbyComplier,
QueryCompilerInfo orderbyComplier, WhereCompilerInfo havingComplier,
QueryInfo query)
{
var sql = new StringBuilder();
var orderbyExp = query.PageSize != 0
? GetDefaultOrderby(obj, query, orderbyComplier)
: orderbyComplier.Builder.ToString();
if (query.PageSize == 0)
{
BuilderSql(sql, selectComplier.Builder.ToString(), tableSql, whereComplier.Builder.ToString(),
groupbyComplier.Builder.ToString(), havingComplier.Builder.ToString(), orderbyExp, query.IsDisinct);
}
else
{
BuilderPageSql(sql, selectComplier.Builder.ToString(), tableSql, whereComplier.Builder.ToString(),
groupbyComplier.Builder.ToString(), havingComplier.Builder.ToString(), orderbyExp, query);
}
if (query.IsReturnCount && query.PageSize > 0)
{
BuilderCountSql(sql, obj, selectComplier, tableSql, whereComplier.Builder.ToString(),
groupbyComplier.Builder.ToString(), havingComplier.Builder.ToString(), query.IsDisinct);
}
return(sql.ToString());
}
public QueryCompilerInfo(OrmObjectInfo obj, string exp, TableInfo table, StringBuilder builder)
{
Object = obj;
Exp = exp;
Table = table;
Builder = builder;
}
/// <summary>
/// 查询数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="obj"></param>
/// <returns></returns>
public virtual T GetInfos <T>(QueryInfo query, OrmObjectInfo obj = null)
{
obj = obj ?? Orm.GetOrm(query.FromExp);
var infos = ExecuteInfos <T>(obj, query);
return(infos);
}
/// <summary>
/// 设置公共缓存
/// </summary>
protected virtual void InsertCommonCache(OrmObjectInfo obj, object key, object entity)
{
SetCache(GetEntityCacheKey(obj, key), entity, obj.CacheTime);
var ormProperties =
obj.Properties.Where(it => it.Map != null && (it.Map.IsGreedyLoad || it.Map.IsLazyLoad));
foreach (var ormProperty in ormProperties)
{
var mapValue = entity.GetProperty(ormProperty.PropertyName);
if (ormProperty.Map.MapType == OrmMapType.OneToMany)
{
if (mapValue == null)
{
continue;
}
var values = mapValue as IEnumerable <EntityInfo>;
if (values == null)
{
continue;
}
foreach (var value in values)
{
InsertCommonCache(ormProperty.Map.GetMapObject(), value.GetProperty(ormProperty.Map.GetMapObject().PrimaryProperty.PropertyName), value);
}
}
else
{
InsertCommonCache(ormProperty.Map.GetMapObject(), mapValue.GetProperty(ormProperty.Map.GetMapObject().PrimaryProperty.PropertyName), mapValue);
}
}
}
/// <summary>
/// 选择返回方式
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="obj"></param>
/// <param name="sqlcmd"></param>
/// <returns></returns>
protected virtual T GetInfosByType <T>(QueryInfo query, OrmObjectInfo obj, SqlCommand sqlcmd)
{
if (typeof(T) == typeof(DataTable))
{
var da = new SqlDataAdapter(sqlcmd);
var ds = new DataSet();
da.Fill(ds);
return((T)(ds.Tables[0] as object));
}
if (query.IsAsParallel)
{
var da = new SqlDataAdapter(sqlcmd);
var ds = new DataSet();
da.Fill(ds);
var rev = SetProperty <T>(ds.Tables[0], obj);
if (query.PageSize != 0 && query.IsReturnCount)
{
query.DataCount = Convert.ToInt32(ds.Tables[1].Rows[0][0]);
}
return(rev);
}
else
{
SqlDataReader reader = sqlcmd.ExecuteReader(CommandBehavior.CloseConnection);
var rev = SetProperty <T>(reader, obj);
if (query.PageSize != 0 && query.IsReturnCount)
{
reader.NextResult();
reader.Read();
query.DataCount = Convert.ToInt32(reader[0]);
}
return(rev);
}
}
/// <summary>
/// 得到缓存的Key
/// </summary>
/// <param name="query"></param>
/// <param name="obj"></param>
/// <returns></returns>
protected virtual void SetQueryCustomCacheKey(QueryInfo query, OrmObjectInfo obj)
{
var sb = new StringBuilder();
sb.Append(query.SelectExp);
sb.Append(query.FromExp);
sb.Append(query.WhereExp);
sb.Append(query.GroupByExp);
sb.Append(query.HavingExp);
sb.Append(query.OrderByExp);
sb.Append(query.PageIndex);
sb.Append(query.PageSize);
if (query.Parameters != null)
{
foreach (var p in query.Parameters)
{
sb.Append(p.Key);
var keys = p.Value as Array;
if (keys != null)
{
foreach (var key in keys)
{
sb.Append(key);
}
}
else
{
sb.Append(p.Value);
}
}
}
var value = System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sb.ToString(), "MD5");
query.Cache.Key = string.Format("{0}{1}", string.Format(CacheTag, query.Cache.Name), value);
}
/// <summary>
/// 查询对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <param name="query"></param>
/// <param name="context"></param>
/// <param name="isLazyLoadExecute"></param>
/// <returns></returns>
public virtual T GetInfos <T>(OrmObjectInfo obj, QueryInfo query, IContext context, bool isLazyLoadExecute = false)
{
query.Object = obj;
query.GetDataBase = obj.GetDataBase;
if (!string.IsNullOrEmpty(obj.RouteName))
{
var result = new List <T>();
var queries = DbRoute.GetRouteQueries(query);
if (queries != null)
{
if (queries.Count == 1)
{
var infos = GetResult <T>(obj, queries[0], context, isLazyLoadExecute);
query.DataCount += queries[0].DataCount;
query.Sql = queries[0].Sql;
return(infos);
}
query.DataCount = 0;
BeginInvokeQuery(obj, query, context, isLazyLoadExecute, result, queries, 0);
query.Sql = queries[0].Sql;
return(MergeResult(result, obj, query));
}
}
return(GetResult <T>(obj, query, context, isLazyLoadExecute));
}
/// <summary>
/// 移除公共缓存
/// </summary>
/// <param name="obj"></param>
/// <param name="key"></param>
protected virtual void RemoveCommonCache(OrmObjectInfo obj, object key)
{
var cacheKey = GetEntityCacheKey(obj, key);
var cacheValue = Cacher.Get(cacheKey, Type.GetType(obj.ObjectName));
if (cacheValue == null)
{
return;
}
if (obj.IsCache)
{
Cacher.Remove(cacheKey);
}
var ormMaps =
obj.Properties.Where(it => it.Map != null && it.Map.IsRemoveCache)
.Select(it => it.Map).ToList();
if (ormMaps.Count == 0)
{
return;
}
foreach (var ormMap in ormMaps)
{
var value = cacheValue.GetProperty(ormMap.ObjectProperty.PropertyName);
if (!obj.IsCache)
{
Cacher.Remove(cacheKey);
}
RemoveCommonCache(ormMap.GetMapObject(), value);
}
}
/// <summary>
/// 得到缓存
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <param name="query"></param>
/// <returns></returns>
protected virtual QueryCacheInfo <T> GetQueryCache <T>(OrmObjectInfo obj, QueryInfo query)
{
if (query.Cache.Type == CacheType.None)
{
return(null);
}
if (query.Cache.Time == DateTime.MinValue && query.Cache.TimeSpan == 0)
{
return(null);
}
if (query.Cache.Dependencies != null && query.Cache.Dependencies.Count > 0)
{
foreach (var dependency in query.Cache.Dependencies)
{
string subVersionKey = GetVersionCacheKey(dependency);
var subLocalVersion = GetLocalCache <string>(subVersionKey);
var subRemoteVersion = GetRemoteCache <string>(subVersionKey);
if (string.IsNullOrWhiteSpace(subRemoteVersion) || subLocalVersion != subRemoteVersion)
{
return(null);
}
}
}
if (query.Cache.Type == CacheType.Local || query.Cache.Type == CacheType.LocalAndRemote)
{
return(GetLocalCache <QueryCacheInfo <T> >(query.Cache.Key));
}
if (query.Cache.Type == CacheType.Remote || query.Cache.Type == CacheType.LocalAndRemote)
{
return(GetRemoteCache <QueryCacheInfo <T> >(query.Cache.Key));
}
return(GetLocalCache <QueryCacheInfo <T> >(query.Cache.Key) ?? GetRemoteCache <QueryCacheInfo <T> >(query.Cache.Key));
}
/// <summary>
/// 加载缓存
/// </summary>
/// <param name="obj"></param>
protected virtual void LoadCache(OrmObjectInfo obj)
{
for (int i = 0;; i++)
{
var query = new QueryInfo {
IsGreedyLoad = true, IsLazyLoad = true
};
query.From(obj.ObjectName).SetPageSize(1000).SetPageIndex(i);
var entities = ExecuteInfos <IList <EntityInfo> >(obj, query, true);
if (entities == null || entities.Count == 0)
{
break;
}
foreach (var entity in entities)
{
var value = entity.GetType().GetProperty(obj.PrimaryProperty.PropertyName).GetValue(entity, null);
var cacheKey = GetEntityCacheKey(obj, value);
var dataEntity = GetCache <EntityInfo>(cacheKey);
if (dataEntity != null)
{
InsertCommonCache(obj, value, entity);
}
}
}
}
/// <summary>
/// from开始
/// </summary>
/// <param name="queryCompiler"></param>
/// <param name="ormObject"></param>
/// <param name="name"></param>
/// <param name="isfromload"></param>
protected virtual void AppendFromProperty(QueryCompilerInfo queryCompiler, OrmObjectInfo ormObject, string name, bool isfromload)
{
foreach (var p in ormObject.Properties)
{
var propertyName = string.IsNullOrEmpty(name) ? p.PropertyName : string.Format("{0}.{1}", name, p.PropertyName);
SelectFromRead(queryCompiler, p, propertyName, isfromload);
}
}
/// <summary>
/// 得到表名
/// </summary>
/// <param name="ormObject"></param>
/// <returns></returns>
public virtual string GetSetTableName(OrmObjectInfo ormObject)
{
if (!string.IsNullOrEmpty(TableIndex) && !string.IsNullOrEmpty(ormObject.RouteName))
{
return(string.Format("{0}{1}", ormObject.SetTableName, TableIndex));
}
return(ormObject.SetTableName);
}
/// <summary>
/// 设置公共缓存
/// </summary>
protected virtual void InsertCommonCache(OrmObjectInfo obj, object key, object entity)
{
if (obj.CacheType == CacheType.None || entity == null)
{
return;
}
var cacheKey = GetEntityCacheKey(obj, key);
if (obj.CacheType == CacheType.Local)
{
SetLocalCache(cacheKey, entity, obj.CacheTime);
}
else if (obj.CacheType == CacheType.Local)
{
SetRemoteCache(cacheKey, entity, obj.CacheTime);
}
else
{
var versionCacheKey = GetVersionCacheKey(cacheKey);
var version = GetRemoteCache <string>(versionCacheKey);
if (string.IsNullOrWhiteSpace(version))
{
version = DateTime.Now.ToString("yyyyMMddHHmmss");
SetRemoteCache(versionCacheKey, version, obj.CacheTime);
}
SetLocalCache(versionCacheKey, version, obj.CacheTime);
SetLocalCache(cacheKey, entity, obj.CacheTime);
}
var ormProperties =
obj.Properties.Where(it => it.Map != null && (it.Map.IsGreedyLoad || it.Map.IsLazyLoad));
foreach (var ormProperty in ormProperties)
{
var mapValue = entity.GetProperty(ormProperty.PropertyName);
if (ormProperty.Map.MapType == OrmMapType.OneToMany)
{
if (mapValue == null)
{
continue;
}
var values = mapValue as IEnumerable <EntityInfo>;
if (values == null)
{
continue;
}
foreach (var value in values)
{
InsertCommonCache(ormProperty.Map.GetMapObject(), value.GetProperty(ormProperty.Map.GetMapObject().PrimaryProperty.PropertyName), value);
}
}
else
{
InsertCommonCache(ormProperty.Map.GetMapObject(), mapValue.GetProperty(ormProperty.Map.GetMapObject().PrimaryProperty.PropertyName), mapValue);
}
}
}
/// <summary>
/// 加载数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <param name="query"></param>
/// <param name="isLazyLoadExecute"></param>
/// <returns></returns>
protected virtual T ExecuteInfos <T>(OrmObjectInfo obj, QueryInfo query, bool isLazyLoadExecute = false)
{
if (query.Cache != null)
{
return(GetInfosByCache <T>(query, obj));
}
var result = Executor.GetInfos <T>(obj, query, this, isLazyLoadExecute);
return(result);
}
/// <summary>
/// 得到key的值
/// </summary>
/// <param name="orm"></param>
/// <returns></returns>
protected virtual string GetKeyValue(OrmObjectInfo orm)
{
InitliazeKey(orm);
lock (KeyLockers[orm.ObjectName])
{
var key = Keys[orm.ObjectName];
key.Count++;
return(string.Format("{0}{1}", key.Flag, key.Count.ToString(CultureInfo.InvariantCulture).PadLeft(key.RightLength, '0')));
}
}
/// <summary>
/// 得到Key
/// </summary>
public object GetKey(string name)
{
OrmObjectInfo orm = Orm.GetOrm(name);
if (orm == null || orm.Key == null)
{
return(null);
}
return(GetKeyValue(orm));
}
/// <summary>
/// 获取对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public override T GetInfos <T>(OrmDataBaseInfo ormDataBase, OrmObjectInfo obj, QueryInfo query)
{
if (obj == null)
{
return(default(T));
}
var cmd = new SqlCommand();
Translate(cmd, obj, query);
return(GetInfosByCommand <T>(ormDataBase, obj, cmd, query));
}
/// <summary>
/// 得到属性类型
/// </summary>
/// <param name="obj"></param>
/// <param name="name"></param>
/// <returns></returns>
protected virtual Type GetPropertyTypeByName(OrmObjectInfo obj, string name)
{
var names = name.Split('.');
Type property = Type.GetType(obj.ObjectName).GetProperties().First(it => it.Name.Equals(names[0])).PropertyType;
for (int i = 1; i < names.Length; i++)
{
property = property.GetProperties().First(it => it.Name.Equals(names[i])).PropertyType;
}
return(property);
}
/// <summary>
/// 得到结果
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="obj"></param>
/// <param name="query"></param>
/// <param name="context"></param>
/// <param name="isLazyLoadExecute"></param>
/// <returns></returns>
protected virtual T GetResult <T>(OrmObjectInfo obj, QueryInfo query, IContext context, bool isLazyLoadExecute = false)
{
OrmDataBaseInfo db = DataBase.GetDataBase(query.GetDataBase).GetAllGetOrmDataBase().FirstOrDefault();
var result = ExecuteQuery <T>(query, obj, db);
if (query.IsLazyLoad)
{
LazyLoad(result, obj, context, isLazyLoadExecute);
}
RemoteLoad(result, query.RemoteQueries == null ? null : query.RemoteQueries.Values.ToList(), obj, isLazyLoadExecute);
return(result);
}
/// <summary>
/// 得到表名
/// </summary>
/// <param name="ormObject"></param>
/// <returns></returns>
public virtual string GetGetTableName(OrmObjectInfo ormObject)
{
if (ormObject.ObjectName != Object.ObjectName && DbRoute != null && !DbRoute.IsMapTableAutoSharding)
{
return(ormObject.GetTableName);
}
if (!string.IsNullOrEmpty(TableIndex) && !string.IsNullOrEmpty(ormObject.RouteName))
{
return(string.Format("{0}{1}", ormObject.GetTableName, TableIndex));
}
return(ormObject.GetTableName);
}
/// <summary>
/// CommandInfo得到返回结果
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="ormDataBase"></param>
/// <param name="obj"></param>
/// <param name="cmd"></param>
/// <param name="query"></param>
/// <returns></returns>
protected virtual T GetInfosByCommand <T>(OrmDataBaseInfo ormDataBase, OrmObjectInfo obj, SqlCommand cmd, QueryInfo query)
{
if (string.IsNullOrEmpty(cmd.CommandText))
{
return(default(T));
}
using (var sqlcon = GetConnnection <SqlConnection>(ormDataBase.GetAllGetOrmDataBase(), query))
{
cmd.Connection = sqlcon;
return(GetInfosByType <T>(query, obj, cmd));
}
}
/// <summary>
/// 解析查询
/// </summary>
/// <param name="command"></param>
/// <param name="obj"></param>
/// <param name="query"></param>
public virtual void Translate(DbCommand command, OrmObjectInfo obj, QueryInfo query)
{
TranslateQuery(obj, query);
command.CommandText = query.Sql;
if (query.Parameters == null)
{
return;
}
foreach (var paramter in query.SqlParameters)
{
AddParamter(command, paramter.Key, paramter.Value);
}
}
/// <summary>
/// 得到实体集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="obj"></param>
/// <returns></returns>
public IList <T> Gets <T>(QueryInfo query, OrmObjectInfo obj = null)
{
obj = obj ?? Orm.GetOrm(query.FromExp);
var infos = ExecuteInfos <IList <T> >(obj, query, obj.IsCache);
if (infos != null)
{
for (var i = 0; i < infos.Count; i++)
{
infos[i] = Attach(infos[i]);
}
}
return(infos);
}
/// <summary>
/// 得到实体键
/// </summary>
/// <param name="orm"></param>
/// <returns></returns>
protected virtual int GetEntityKey(OrmObjectInfo orm)
{
var key = OrmKeys.FirstOrDefault(it => it.Name.Equals(orm.Key));
if (key == null || string.IsNullOrEmpty(key.Recovery) || orm.PrimaryProperty.IsIdentityKey)
{
return(0);
}
var sql = key.Recovery.Replace("{Key}", orm.PrimaryProperty.PropertyName).Replace("{Table}", orm.SetTableName);
var dt = Executor.ExecuteQuery <DataTable>(orm.SetDataBase, sql, CommandType.Text);
return(dt != null && dt.Rows.Count > 0 ?
Convert.ToInt32(dt.Rows[0][0].ToString()) : 0);
}
/// <summary>
/// 设置默认查询
/// </summary>
/// <param name="where"></param>
/// <param name="obj"></param>
protected virtual void AppendDefaultWhere(StringBuilder where, OrmObjectInfo obj)
{
if (where.Length > 0)
{
where.Append(")");
}
if (string.IsNullOrEmpty(obj.SetDefaultWhere))//设置默认查询
{
return;
}
string key = where.Length > 0 ? "and" : "where";
where.AppendFormat(" {0} {1}", key, obj.SetDefaultWhere);
}
/// <summary>
/// 移除公共缓存
/// </summary>
/// <param name="obj"></param>
/// <param name="key"></param>
protected virtual void RemoveCommonCache(OrmObjectInfo obj, object key)
{
var cacheKey = GetEntityCacheKey(obj, key);
object cacheValue = null;
if (obj.CacheType == CacheType.Local)
{
cacheValue = GetLocalCache(cacheKey, Type.GetType(obj.ObjectName));
if (cacheValue == null)
{
return;
}
RemoveLocalCache(cacheKey);
}
else if (obj.CacheType == CacheType.Remote)
{
cacheValue = GetRemoteCache(cacheKey, Type.GetType(obj.ObjectName));
if (cacheValue == null)
{
return;
}
RemoveRemoteCache(cacheKey);
}
else if (obj.CacheType == CacheType.LocalAndRemote)
{
var varsionKey = GetVersionCacheKey(cacheKey);
cacheValue = GetLocalCache(cacheKey, Type.GetType(obj.ObjectName));
if (cacheValue == null)
{
return;
}
RemoveRemoteCache(varsionKey);
RemoveLocalCache(varsionKey);
RemoveLocalCache(cacheKey);
}
var ormMaps =
obj.Properties.Where(it => it.Map != null && it.Map.IsRemoveCache)
.Select(it => it.Map).ToList();
if (ormMaps.Count == 0)
{
return;
}
foreach (var ormMap in ormMaps)
{
var value = cacheValue.GetProperty(ormMap.ObjectProperty.PropertyName);
RemoveCommonCache(ormMap.GetMapObject(), value);
}
}
/// <summary>
/// 异步调用
/// </summary>
/// <param name="isLazyLoadExecute"></param>
/// <param name="result"></param>
/// <param name="queries"></param>
/// <param name="i"></param>
/// <param name="obj"></param>
/// <param name="query"></param>
/// <param name="context"></param>
protected virtual void BeginInvokeQuery <T>(OrmObjectInfo obj, QueryInfo query, IContext context, bool isLazyLoadExecute, IList <T> result, IList <QueryInfo> queries, int i)
{
if (i >= queries.Count)
{
return;
}
Func <OrmObjectInfo, QueryInfo, IContext, bool, T> func = GetResult <T>;
var asyncResult = func.BeginInvoke(obj, queries[i], context, isLazyLoadExecute, null, null);
BeginInvokeQuery(obj, query, context, isLazyLoadExecute, result, queries, i + 1);
var r = func.EndInvoke(asyncResult);
result.Add(r);
query.DataCount += queries[i].DataCount;
}
/// <summary>
/// 填充返回值
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="reader"></param>
/// <param name="obj"></param>
public virtual T Reverse <T>(IDataReader reader, OrmObjectInfo obj)
{
var type = Type.GetType(obj.ObjectName);
var rev = new ArrayList();
while (reader.Read())
{
var value = GetOrmObjectElement(type, reader, obj);
if (value != null)
{
rev.Add(value);
}
}
return((T)((object)rev.ToArray(type)));
}
/// <summary>
/// 填充对象
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="table"></param>
/// <param name="obj"></param>
/// <returns></returns>
public virtual T Reverse <T>(DataTable table, OrmObjectInfo obj)
{
var type = Type.GetType(obj.ObjectName);
var rev = new ArrayList();
foreach (DataRow row in table.Rows.AsParallel())
{
var value = GetOrmObjectElement(type, table, row, obj);
if (value != null)
{
rev.Add(value);
}
}
return((T)((object)rev.ToArray(type)));
}
/// <summary>
/// 填充对象返回
/// </summary>
/// <param name="elementType"></param>
/// <param name="reader"></param>
/// <param name="obj"></param>
/// <returns></returns>
protected virtual object FillOrmObject(Type elementType, IDataReader reader, OrmObjectInfo obj)
{
var type = Type.GetType(obj.ObjectName);
var rev = new ArrayList();
while (reader.Read())
{
var value = GetOrmObjectElement(type, reader, obj);
if (value != null)
{
rev.Add(value);
}
}
return(rev.ToArray(elementType));
}
