/// <summary>
/// 获取查询信息
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection"></param>
/// <param name="query">查询信息</param>
/// <param name="readValue"></param>
/// <returns>对象集合</returns>
internal override LeftArray <valueType> Select <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, ref SelectQuery <modelType> query, Func <DbDataReader, valueType> readValue)
{
try
{
if (query.Sql != null)
{
if (connection == null)
{
connection = GetConnection();
}
if (connection != null)
{
bool isFinally = false;
try
{
using (DbCommand command = getCommand(connection, query.Sql, CommandType.Text))
using (DbDataReader reader = command.ExecuteReader(CommandBehavior.SingleResult))
{
int skipCount = query.SkipCount;
while (skipCount != 0 && reader.Read())
{
--skipCount;
}
if (skipCount == 0)
{
LeftArray <valueType> array = new LeftArray <valueType>();
while (reader.Read())
{
valueType value = readValue(reader);
if (value != null)
{
array.Add(value);
}
}
isFinally = true;
return(array.NotNull());
}
}
isFinally = true;
}
finally
{
if (!isFinally)
{
sqlTool.Log.Add(AutoCSer.Log.LogType.Error, query.Sql);
}
}
}
}
}
finally { query.Free(); }
return(default(LeftArray <valueType>));
}
/// <summary>
/// 查询对象集合
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="createQuery"></param>
/// <param name="query">查询信息</param>
/// <param name="keyName">关键之名称</param>
/// <param name="sqlStream"></param>
private unsafe void selectKeys <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref CreateSelectQuery <modelType> createQuery, ref SelectQuery <modelType> query, string keyName, CharStream sqlStream)
where valueType : class, modelType
where modelType : class
{
sqlStream.SimpleWrite("select ");
if (query.MemberMap != null)
{
DataModel.Model <modelType> .GetNames(sqlStream, query.MemberMap, constantConverter);
}
else
{
sqlStream.Write('*');
}
sqlStream.SimpleWrite(" from[");
sqlStream.SimpleWrite(sqlTool.TableName);
sqlStream.Write("]with(nolock)where ");
sqlStream.SimpleWrite(keyName);
sqlStream.SimpleWrite(" in(select ");
sqlStream.SimpleWrite(keyName);
sqlStream.SimpleWrite(" from(select ");
sqlStream.SimpleWrite(keyName);
sqlStream.Write(",row_number()over(");
int startIndex = sqlStream.Length;
createQuery.WriteOrder(sqlTool, sqlStream, constantConverter, ref query);
string fieldName, fieldSqlName;
query.GetIndex(out fieldName, out fieldSqlName);
int count = sqlStream.Length - startIndex;
sqlStream.SimpleWrite(")as ");
sqlStream.SimpleWrite(orderOverName);
sqlStream.SimpleWrite(" from[");
sqlStream.SimpleWrite(sqlTool.TableName);
sqlStream.SimpleWrite("]with(nolock)");
sqlTool.Client.GetSql(createQuery.Where.Expression, sqlStream, ref query);
if (query.IndexFieldName == null)
{
query.SetIndex(fieldName, fieldSqlName);
}
sqlStream.SimpleWrite(")as T where ");
sqlStream.SimpleWrite(orderOverName);
sqlStream.SimpleWrite(" between ");
AutoCSer.Extensions.NumberExtension.ToString(query.SkipCount, sqlStream);
sqlStream.SimpleWrite(" and ");
AutoCSer.Extensions.NumberExtension.ToString(query.SkipCount + createQuery.GetCount - 1, sqlStream);
sqlStream.Write(')');
if (count != 0)
{
sqlStream.Write(sqlStream.Char + startIndex, count);
}
}
internal void GetSelectQuery <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, MemberMap <modelType> memberMap, ref CreateSelectQuery <modelType> createQuery, ref SelectQuery <modelType> query)
where valueType : class, modelType
where modelType : class
{
query.MemberMap = DataModel.Model <modelType> .CopyMemberMap;
if (memberMap != null && !memberMap.IsDefault)
{
query.MemberMap.And(memberMap);
}
GetSelectQuery(sqlTool, ref createQuery, ref query);
}
/// <summary>
/// 更新数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="value">匹配成员值</param>
/// <param name="memberMap">成员位图</param>
/// <param name="query">查询信息</param>
/// <returns>更新是否成功</returns>
internal override bool Update <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, valueType value, MemberMap <modelType> memberMap, ref UpdateQuery <modelType> query)
{
if (connection == null)
{
connection = GetConnection();
}
if (connection != null)
{
if (query.NotQuery)
{
if (executeNonQuery(connection, query.UpdateSql) > 0)
{
sqlTool.CallOnUpdated(value, null, memberMap);
return(true);
}
}
else
{
bool isFinally = false;
try
{
using (DbCommand command = getCommand(connection, query.Sql))
using (DbDataReader reader = command.ExecuteReader(CommandBehavior.SingleResult))
{
if (reader.Read())
{
valueType oldValue = AutoCSer.Emit.Constructor <valueType> .New();
DataModel.Model <modelType> .Setter.Set(reader, oldValue, query.MemberMap);
if (reader.NextResult() && reader.Read())
{
DataModel.Model <modelType> .Setter.Set(reader, value, query.MemberMap);
sqlTool.CallOnUpdated(value, oldValue, memberMap);
return(isFinally = true);
}
}
}
isFinally = true;
}
finally
{
if (!isFinally)
{
sqlTool.Log.Add(AutoCSer.Log.LogType.Error, query.Sql);
}
}
}
}
return(false);
}
/// <summary>
/// 获取查询信息
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="createQuery"></param>
/// <param name="query">查询信息</param>
/// <returns>对象集合</returns>
internal override void GetSelectQuery <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref CreateSelectQuery <modelType> createQuery, ref SelectQuery <modelType> query)
{
CharStream sqlStream = Interlocked.Exchange(ref this.sqlStream, null);
if (sqlStream == null)
{
sqlStream = new CharStream(null, 0);
}
byte *buffer = null;
try
{
sqlStream.Reset(buffer = AutoCSer.UnmanagedPool.Default.Get(), AutoCSer.UnmanagedPool.DefaultSize);
if ((createQuery.GetCount | query.SkipCount) != 0)
{
sqlStream.WriteNotNull("select * from(");
}
sqlStream.WriteNotNull("select ");
if (query.MemberMap != null)
{
DataModel.Model <modelType> .GetNames(sqlStream, query.MemberMap, constantConverter);
}
else
{
sqlStream.Write('*');
}
sqlStream.WriteNotNull(" from ");
sqlStream.WriteNotNull(sqlTool.TableName);
sqlStream.Write(' ');
createQuery.WriteWhere(sqlTool, sqlStream, ref query);
createQuery.WriteOrder(sqlTool, sqlStream, constantConverter, ref query);
if ((createQuery.GetCount | query.SkipCount) != 0)
{
sqlStream.WriteNotNull(")where rownum between ");
AutoCSer.Extension.Number.ToString(query.SkipCount, sqlStream);
sqlStream.WriteNotNull(" and ");
AutoCSer.Extension.Number.ToString(createQuery.GetCount, sqlStream);
sqlStream.WriteNotNull(" order by rownum asc");
}
query.Sql = sqlStream.ToString();
}
finally
{
if (buffer != null)
{
AutoCSer.UnmanagedPool.Default.Push(buffer);
}
sqlStream.Dispose();
Interlocked.Exchange(ref this.sqlStream, sqlStream);
}
}
/// <summary>
/// 删除数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="value">添加数据</param>
/// <param name="query">添加数据查询信息</param>
/// <returns></returns>
internal override bool Delete <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, valueType value, ref InsertQuery query)
{
GetQuery <modelType> getQuery = new GetQuery <modelType> {
MemberMap = sqlTool.SelectMemberMap, Sql = query.Sql
};
if (Get(sqlTool, ref connection, value, ref getQuery) && executeNonQuery(connection, query.InsertSql) > 0)
{
sqlTool.CallOnDeleted(value);
return(true);
}
return(false);
}
/// <summary>
/// 删除数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="transaction">事务操作</param>
/// <param name="value">添加数据</param>
/// <param name="query">添加数据查询信息</param>
/// <returns></returns>
internal override ReturnType Delete <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, Transaction transaction, valueType value, ref InsertQuery query)
{
if (sqlTool.CallOnDelete(value))
{
if (executeNonQuery(transaction, query.Sql) > 0)
{
sqlTool.CallOnDeleted(transaction, value);
return(ReturnType.Success);
}
return(ReturnType.NotFoundData);
}
return(ReturnType.EventCancel);
}
/// <summary>
/// 缓存计数
/// </summary>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="getKey">缓存关键字获取器</param>
/// <param name="group">数据分组</param>
protected Cache(Sql.Table <valueType, modelType> sqlTool, int group, Func <modelType, keyType> getKey)
: base(sqlTool, group)
{
if (getKey == null)
{
throw new ArgumentNullException();
}
GetKey = getKey;
dictionary = DictionaryCreator <RandomKey <keyType> > .Create <KeyValue <valueType, int> >();
sqlTool.OnUpdated += onUpdated;
sqlTool.OnDeleted += onDeleted;
}
/// <summary>
/// 执行任务
/// </summary>
/// <param name="connection"></param>
internal override Threading.LinkQueueTaskNode RunLinkQueueTask(ref DbConnection connection)
{
Threading.LinkQueueTaskNode next = LinkNext;
try
{
Sql.Table <valueType, modelType> table = countMember.table;
table.Client.Update(table, ref connection, countMember.updateValue, countMember.memberMap, ref Query, true);
}
finally { countMember.check(ref connection); }
LinkNext = null;
Push();
return(next);
}
/// <summary>
/// 更新数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="transaction">事务操作</param>
/// <param name="value">匹配成员值</param>
/// <param name="memberMap">成员位图</param>
/// <param name="query">查询信息</param>
/// <returns>更新是否成功</returns>
internal override ReturnType Update <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, Transaction transaction, valueType value, MemberMap <modelType> memberMap, ref UpdateQuery <modelType> query)
{
if (sqlTool.CallOnUpdate(value, memberMap))
{
if (executeNonQuery(transaction, query.Sql) > 0)
{
sqlTool.CallOnUpdated(transaction, value, memberMap);
return(ReturnType.Success);
}
return(ReturnType.NotFoundData);
}
return(ReturnType.EventCancel);
}
internal bool Insert <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, valueType value, MemberMap <modelType> memberMap, ref InsertQuery query)
where valueType : class, modelType
where modelType : class
{
if (memberMap == null)
{
memberMap = MemberMap <modelType> .Default;
}
if (DataModel.Model <modelType> .Verifyer.Verify(value, memberMap, sqlTool))
{
insert(sqlTool, value, memberMap, ref query);
return(true);
}
return(false);
}
/// <summary>
/// 更新数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="value">匹配成员值</param>
/// <param name="memberMap">成员位图</param>
/// <param name="query">查询信息</param>
/// <returns>更新是否成功</returns>
internal override bool Update <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, valueType value, MemberMap <modelType> memberMap, ref UpdateQuery <modelType> query)
{
GetQuery <modelType> getQuery = new GetQuery <modelType> {
MemberMap = query.MemberMap, Sql = query.Sql
};
valueType oldValue = AutoCSer.Emit.Constructor <valueType> .New();
if (Get(sqlTool, ref connection, oldValue, ref getQuery) && executeNonQuery(connection, query.UpdateSql) > 0 && Get(sqlTool, ref connection, value, ref getQuery))
{
sqlTool.CallOnUpdated(value, oldValue, memberMap);
return(true);
}
return(false);
}
/// <summary>
/// 自增ID整表数组缓存
/// </summary>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="memberCache"></param>
/// <param name="isValue">数据匹配器,必须保证更新数据的匹配一致性</param>
/// <param name="baseIdentity">基础ID</param>
/// <param name="group">数据分组</param>
public IdentityArrayWhere(Sql.Table <valueType, modelType> sqlTool, Expression <Func <valueType, memberCacheType> > memberCache
, Func <valueType, bool> isValue, int group = 0, int baseIdentity = 0)
: base(sqlTool, memberCache, group, baseIdentity, false)
{
if (isValue == null)
{
throw new ArgumentNullException();
}
this.isValue = isValue;
sqlTool.OnInserted += onInserted;
sqlTool.OnUpdated += onUpdated;
sqlTool.OnDeleted += onDeleted;
reset(null);
}
/// <summary>
/// 获取查询信息
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="createQuery"></param>
/// <param name="query">查询信息</param>
/// <returns>对象集合</returns>
internal override void GetSelectQuery <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref CreateSelectQuery <modelType> createQuery, ref SelectQuery <modelType> query)
{
CharStream sqlStream = Interlocked.Exchange(ref this.sqlStream, null);
if (sqlStream == null)
{
sqlStream = new CharStream(null, 0);
}
byte *buffer = null;
try
{
sqlStream.Reset(buffer = AutoCSer.UnmanagedPool.Default.Get(), AutoCSer.UnmanagedPool.DefaultSize);
sqlStream.SimpleWriteNotNull("select ");
int count = query.SkipCount + createQuery.GetCount;
if (count != 0)
{
sqlStream.SimpleWriteNotNull("top ");
AutoCSer.Extension.Number.ToString(count, sqlStream);
sqlStream.Write(' ');
}
if (query.MemberMap != null)
{
DataModel.Model <modelType> .GetNames(sqlStream, query.MemberMap);
}
else
{
sqlStream.Write('*');
}
sqlStream.SimpleWriteNotNull(" from [");
sqlStream.SimpleWriteNotNull(sqlTool.TableName);
sqlStream.Write(']');
createQuery.WriteWhere(sqlTool, sqlStream, ref query);
createQuery.WriteOrder(sqlTool, sqlStream, ref query);
query.Sql = sqlStream.ToString();
}
finally
{
if (buffer != null)
{
AutoCSer.UnmanagedPool.Default.Push(buffer);
}
sqlStream.Dispose();
Interlocked.Exchange(ref this.sqlStream, sqlStream);
}
}
/// <summary>
/// 获取查询信息
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="createQuery"></param>
/// <param name="query">查询信息</param>
/// <returns>对象集合</returns>
internal override void GetSelectQuery <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref CreateSelectQuery <modelType> createQuery, ref SelectQuery <modelType> query)
{
CharStream sqlStream = Interlocked.Exchange(ref this.sqlStream, null);
if (sqlStream == null)
{
sqlStream = new CharStream(null, 0);
}
byte *buffer = null;
try
{
sqlStream.Reset(buffer = AutoCSer.UnmanagedPool.Default.Get(), AutoCSer.UnmanagedPool.DefaultSize);
if (query.SkipCount != 0 && createQuery.IsOrder)
{
if (DataModel.Model <modelType> .PrimaryKeys.Length == 1)
{
selectKeys(sqlTool, ref createQuery, ref query, DataModel.Model <modelType> .PrimaryKeys[0].SqlFieldName, sqlStream);
}
else if (DataModel.Model <modelType> .Identity != null)
{
selectKeys(sqlTool, ref createQuery, ref query, DataModel.Model <modelType> .IdentitySqlName, sqlStream);
}
else
{
selectRows(sqlTool, ref createQuery, ref query, sqlStream);
}
}
else
{
selectNoOrder(sqlTool, ref createQuery, ref query, sqlStream);
}
query.Sql = sqlStream.ToString();
}
finally
{
if (buffer != null)
{
AutoCSer.UnmanagedPool.Default.Push(buffer);
}
sqlStream.Dispose();
Interlocked.Exchange(ref this.sqlStream, sqlStream);
}
}
/// <summary>
/// 设置真实成员位图
/// </summary>
/// <typeparam name="valueType"></typeparam>
/// <typeparam name="modelType"></typeparam>
/// <param name="sqlTool"></param>
/// <param name="memberMap"></param>
internal override void SetRealMemberMap <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, MemberMap <modelType> memberMap)
{
if (sqlTool.Attribute.IsSetRealMemberMap)
{
MemberMap <modelType> realMemberMap = MemberMap <modelType> .NewEmpty();
using (DbConnection connection = GetConnection())
using (DbCommand command = getCommand(connection, "select top 1 * from [" + sqlTool.TableName + "]", CommandType.Text))
using (DataSet dataSet = getDataSet(command))
{
foreach (DataColumn dataColumn in dataSet.Tables[0].Columns)
{
realMemberMap.SetMember(dataColumn.ColumnName);
}
}
memberMap.And(realMemberMap);
}
}
/// <summary>
/// 获取查询信息
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="createQuery"></param>
/// <param name="query">查询信息</param>
/// <returns>对象集合</returns>
internal override void GetSelectQuery <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref CreateSelectQuery <modelType> createQuery, ref SelectQuery <modelType> query)
{
CharStream sqlStream = Interlocked.Exchange(ref this.sqlStream, null);
if (sqlStream == null)
{
sqlStream = new CharStream(default(AutoCSer.Memory.Pointer));
}
AutoCSer.Memory.Pointer buffer = default(AutoCSer.Memory.Pointer);
try
{
buffer = UnmanagedPool.Default.GetPointer();
sqlStream.Reset(ref buffer);
sqlStream.SimpleWrite("select ");
int count = query.SkipCount + createQuery.GetCount;
if (count != 0)
{
sqlStream.SimpleWrite("top ");
AutoCSer.Extensions.NumberExtension.ToString(count, sqlStream);
sqlStream.Write(' ');
}
if (query.MemberMap != null)
{
AutoCSer.Sql.DataModel.Model <modelType> .GetNames(sqlStream, query.MemberMap, constantConverter);
}
else
{
sqlStream.Write('*');
}
sqlStream.SimpleWrite(" from [");
sqlStream.SimpleWrite(sqlTool.TableName);
sqlStream.Write(']');
createQuery.WriteWhere(sqlTool, sqlStream, ref query);
createQuery.WriteOrder(sqlTool, sqlStream, constantConverter, ref query);
query.Sql = sqlStream.ToString();
}
finally
{
UnmanagedPool.Default.Push(ref buffer);
sqlStream.Dispose();
Interlocked.Exchange(ref this.sqlStream, sqlStream);
}
}
/// <summary>
/// 添加数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="transaction">事务操作</param>
/// <param name="array">数据数组</param>
/// <returns></returns>
internal override SubArray <valueType> Insert <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, Transaction transaction, ref SubArray <valueType> array)
{
if (sqlTool.CallOnInsert(ref array))
{
MemberMap <modelType> memberMap = MemberMap <modelType> .Default;
InsertQuery query = new InsertQuery();
foreach (valueType value in array)
{
insert(sqlTool, value, memberMap, ref query);
if (executeNonQuery(transaction, query.InsertSql) <= 0)
{
return(default(SubArray <valueType>));
}
}
sqlTool.CallOnInserted(transaction, array);
return(array);
}
return(default(SubArray <valueType>));
}
/// <summary>
/// 添加数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="value">添加数据</param>
/// <param name="query">添加数据查询信息</param>
/// <returns></returns>
internal override bool Insert <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, valueType value, ref InsertQuery query)
{
if (executeNonQuery(ref connection, query.InsertSql) > 0)
{
if ((DataModel.Model <modelType> .Identity != null || DataModel.Model <modelType> .PrimaryKeys.Length != 0) && !query.NotQuery)
{
GetQuery <modelType> getQuery = new GetQuery <modelType> {
MemberMap = DataModel.Model <modelType> .MemberMap, Sql = query.Sql
};
if (!Get(sqlTool, ref connection, value, ref getQuery))
{
return(false);
}
}
sqlTool.CallOnInserted(value);
return(true);
}
return(false);
}
/// <summary>
/// 获取查询信息
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="createQuery"></param>
/// <param name="query">查询信息</param>
/// <returns>对象集合</returns>
internal override void GetSelectQuery <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref CreateSelectQuery <modelType> createQuery, ref SelectQuery <modelType> query)
{
CharStream sqlStream = Interlocked.Exchange(ref this.sqlStream, null);
if (sqlStream == null)
{
sqlStream = new CharStream(default(AutoCSer.Memory.Pointer));
}
AutoCSer.Memory.Pointer buffer = default(AutoCSer.Memory.Pointer);
try
{
buffer = UnmanagedPool.Default.GetPointer();
sqlStream.Reset(ref buffer);
if (query.SkipCount != 0 && createQuery.IsOrder)
{
if (DataModel.Model <modelType> .PrimaryKeys.Length == 1)
{
selectKeys(sqlTool, ref createQuery, ref query, constantConverter.ConvertName(DataModel.Model <modelType> .PrimaryKeys[0].FieldInfo.Name), sqlStream);
}
else if (DataModel.Model <modelType> .Identity != null)
{
selectKeys(sqlTool, ref createQuery, ref query, constantConverter.ConvertName(DataModel.Model <modelType> .Identity.FieldInfo.Name), sqlStream);
}
else
{
selectRows(sqlTool, ref createQuery, ref query, sqlStream);
}
}
else
{
selectNoOrder(sqlTool, ref createQuery, ref query, sqlStream);
}
query.Sql = sqlStream.ToString();
}
finally
{
UnmanagedPool.Default.Push(ref buffer);
sqlStream.Dispose();
Interlocked.Exchange(ref this.sqlStream, sqlStream);
}
}
/// <summary>
/// 获取查询信息
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection"></param>
/// <param name="sql"></param>
/// <param name="readValue"></param>
/// <returns>对象集合</returns>
internal virtual LeftArray <valueType> Select <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, string sql, Func <DbDataReader, valueType> readValue)
where valueType : class, modelType
where modelType : class
{
if (connection == null)
{
connection = GetConnection();
}
if (connection != null)
{
using (DbCommand command = getCommand(connection, sql))
{
DbDataReader reader = null;
try
{
reader = command.ExecuteReader(CommandBehavior.SingleResult);
}
catch (Exception error)
{
sqlTool.Log.Add(AutoCSer.Log.LogType.Error, error, sql);
}
if (reader != null)
{
using (reader)
{
LeftArray <valueType> array = new LeftArray <valueType>();
while (reader.Read())
{
valueType value = readValue(reader);
if (value != null)
{
array.Add(value);
}
}
return(array);
}
}
}
}
return(default(LeftArray <valueType>));
}
/// <summary>
/// 添加数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="array">数据数组</param>
/// <param name="isIgnoreTransaction">是否忽略应用程序事务</param>
/// <returns></returns>
internal SubArray <valueType> Insert <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, ref SubArray <valueType> array, bool isIgnoreTransaction)
where valueType : class, modelType
where modelType : class
{
if (sqlTool.CallOnInsert(ref array))
{
if (isIgnoreTransaction)
{
return(Insert(sqlTool, ref connection, ref array));
}
if (AutoCSer.DomainUnload.Unloader.TransactionStart(false))
{
try
{
return(Insert(sqlTool, ref connection, ref array));
}
finally { AutoCSer.DomainUnload.Unloader.TransactionEnd(); }
}
}
return(default(SubArray <valueType>));
}
/// <summary>
/// 添加数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="value">添加数据</param>
/// <param name="query">添加数据查询信息</param>
/// <param name="isIgnoreTransaction">是否忽略应用程序事务</param>
/// <returns></returns>
internal bool Insert <valueType, modelType>(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, valueType value, ref InsertQuery query, bool isIgnoreTransaction)
where valueType : class, modelType
where modelType : class
{
if (sqlTool.CallOnInsert(value))
{
if (isIgnoreTransaction)
{
return(Insert(sqlTool, ref connection, value, ref query));
}
if (AutoCSer.DomainUnload.Unloader.TransactionStart(false))
{
try
{
return(Insert(sqlTool, ref connection, value, ref query));
}
finally { AutoCSer.DomainUnload.Unloader.TransactionEnd(); }
}
}
return(false);
}
/// <summary>
/// 查询对象
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="value">匹配成员值</param>
/// <param name="memberMap">成员位图</param>
/// <param name="query">查询信息</param>
internal override void GetByIdentity <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, valueType value, MemberMap <modelType> memberMap, ref GetQuery <modelType> query)
{
query.MemberMap = DataModel.Model <modelType> .CopyMemberMap;
if (memberMap != null && !memberMap.IsDefault)
{
query.MemberMap.And(memberMap);
}
CharStream sqlStream = Interlocked.Exchange(ref this.sqlStream, null);
if (sqlStream == null)
{
sqlStream = new CharStream(null, 0);
}
byte *buffer = null;
try
{
sqlStream.Reset(buffer = AutoCSer.UnmanagedPool.Default.Get(), AutoCSer.UnmanagedPool.DefaultSize);
sqlStream.SimpleWriteNotNull("select top 1 ");
DataModel.Model <modelType> .GetNames(sqlStream, query.MemberMap);
sqlStream.SimpleWriteNotNull(" from ");
sqlStream.SimpleWriteNotNull(sqlTool.TableName);
sqlStream.WriteNotNull(" where ");
sqlStream.SimpleWriteNotNull(DataModel.Model <modelType> .IdentitySqlName);
sqlStream.Write('=');
AutoCSer.Extension.Number.ToString(DataModel.Model <modelType> .GetIdentity(value), sqlStream);
query.Sql = sqlStream.ToString();
}
finally
{
if (buffer != null)
{
AutoCSer.UnmanagedPool.Default.Push(buffer);
}
sqlStream.Dispose();
Interlocked.Exchange(ref this.sqlStream, sqlStream);
}
}
/// <summary>
/// 查询对象集合
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="createQuery"></param>
/// <param name="query">查询信息</param>
/// <param name="sqlStream"></param>
private unsafe void selectNoOrder <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref CreateSelectQuery <modelType> createQuery, ref SelectQuery <modelType> query, CharStream sqlStream)
where valueType : class, modelType
where modelType : class
{
sqlStream.SimpleWriteNotNull("select ");
int count = query.SkipCount + createQuery.GetCount;
if (count != 0)
{
sqlStream.SimpleWriteNotNull("top ");
AutoCSer.Extension.Number.ToString(count, sqlStream);
sqlStream.Write(' ');
}
DataModel.Model <modelType> .GetNames(sqlStream, query.MemberMap);
sqlStream.SimpleWriteNotNull(" from [");
sqlStream.SimpleWriteNotNull(sqlTool.TableName);
sqlStream.SimpleWriteNotNull("]with(nolock)");
createQuery.WriteWhere(sqlTool, sqlStream, ref query);
createQuery.WriteOrder(sqlTool, sqlStream, ref query);
}
/// <summary>
/// 更新数据
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="value">匹配成员值</param>
/// <param name="memberMap">成员位图</param>
/// <param name="query">查询信息</param>
/// <param name="isIgnoreTransaction">是否忽略应用程序事务</param>
/// <returns>更新是否成功</returns>
internal bool Update <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, valueType value, MemberMap <modelType> memberMap, ref UpdateQuery <modelType> query, bool isIgnoreTransaction)
where valueType : class, modelType
where modelType : class
{
if (sqlTool.CallOnUpdate(value, memberMap))
{
if (isIgnoreTransaction)
{
return(Update(sqlTool, ref connection, value, memberMap, ref query));
}
if (AutoCSer.DomainUnload.Unloader.TransactionStart(false))
{
try
{
return(Update(sqlTool, ref connection, value, memberMap, ref query));
}
finally { AutoCSer.DomainUnload.Unloader.TransactionEnd(); }
}
}
return(false);
}
/// <summary>
/// 查询对象
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="value">匹配成员值</param>
/// <param name="memberMap">成员位图</param>
/// <param name="query">查询信息</param>
internal override void GetByIdentity <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, valueType value, MemberMap <modelType> memberMap, ref GetQuery <modelType> query)
{
query.MemberMap = DataModel.Model <modelType> .CopyMemberMap;
if (memberMap != null && !memberMap.IsDefault)
{
query.MemberMap.And(memberMap);
}
CharStream sqlStream = Interlocked.Exchange(ref this.sqlStream, null);
if (sqlStream == null)
{
sqlStream = new CharStream(default(AutoCSer.Memory.Pointer));
}
AutoCSer.Memory.Pointer buffer = default(AutoCSer.Memory.Pointer);
try
{
buffer = UnmanagedPool.Default.GetPointer();
sqlStream.Reset(ref buffer);
sqlStream.SimpleWrite("select ");
DataModel.Model <modelType> .GetNames(sqlStream, query.MemberMap, constantConverter);
sqlStream.SimpleWrite(" from ");
sqlStream.SimpleWrite(sqlTool.TableName);
sqlStream.Write(" where ");
constantConverter.ConvertNameToSqlStream(sqlStream, DataModel.Model <modelType> .Identity.FieldInfo.Name);
sqlStream.Write('=');
AutoCSer.Extensions.NumberExtension.ToString(DataModel.Model <modelType> .GetIdentity(value), sqlStream);
query.Sql = sqlStream.ToString();
}
finally
{
UnmanagedPool.Default.Push(ref buffer);
sqlStream.Dispose();
Interlocked.Exchange(ref this.sqlStream, sqlStream);
}
}
/// <summary>
/// 查询对象集合
/// </summary>
/// <typeparam name="valueType">对象类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="createQuery"></param>
/// <param name="query">查询信息</param>
/// <param name="sqlStream"></param>
private unsafe void selectRows <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref CreateSelectQuery <modelType> createQuery, ref SelectQuery <modelType> query, CharStream sqlStream)
where valueType : class, modelType
where modelType : class
{
sqlStream.WriteNotNull("select * from(select ");
if (query.MemberMap != null)
{
DataModel.Model <modelType> .GetNames(sqlStream, query.MemberMap);
}
else
{
sqlStream.Write('*');
}
sqlStream.WriteNotNull(",row_number()over(");
createQuery.WriteOrder(sqlTool, sqlStream, ref query);
string fieldName, fieldSqlName;
query.GetIndex(out fieldName, out fieldSqlName);
sqlStream.SimpleWriteNotNull(")as ");
sqlStream.SimpleWriteNotNull(orderOverName);
sqlStream.SimpleWriteNotNull(" from[");
sqlStream.SimpleWriteNotNull(sqlTool.TableName);
sqlStream.SimpleWriteNotNull("]with(nolock)");
sqlTool.Client.GetSql(createQuery.Where, sqlStream, ref query);
if (query.IndexFieldName == null)
{
query.SetIndex(fieldName, fieldSqlName);
}
sqlStream.SimpleWriteNotNull(")as T where ");
sqlStream.SimpleWriteNotNull(orderOverName);
sqlStream.SimpleWriteNotNull(" between ");
AutoCSer.Extension.Number.ToString(query.SkipCount, sqlStream);
sqlStream.SimpleWriteNotNull(" and ");
AutoCSer.Extension.Number.ToString(query.SkipCount + createQuery.GetCount - 1, sqlStream);
}
/// <summary>
/// SQL操作缓存
/// </summary>
/// <param name="table">SQL操作工具</param>
/// <param name="group">数据分组</param>
protected Cache(Sql.Table<valueType, modelType> table, int group) : base(table, group)
{
table.IsOnlyQueue = true;
if (group == 0)
{
#if NOJIT
logProxyLoadedField = typeof(modelType).GetField(LogStream.Log.IsSqlLogProxyLoadedName, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
if (logProxyLoadedField != null) table.OnLogMemberLoaded += onLogMemberLoaded;
#else
FieldInfo logProxyLoadedField = typeof(modelType).GetField(LogStream.Log.IsSqlLogProxyLoadedName, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic);
if (logProxyLoadedField != null)
{
DynamicMethod dynamicMethod = new DynamicMethod("SetIsLogProxyLoaded", null, new System.Type[] { typeof(modelType) }, typeof(modelType), true);
ILGenerator generator = dynamicMethod.GetILGenerator();
generator.Emit(OpCodes.Ldarg_0);
generator.int32(1);
generator.Emit(OpCodes.Stfld, logProxyLoadedField);
generator.Emit(OpCodes.Ret);
setIsLogProxyLoaded = (Action<modelType>)dynamicMethod.CreateDelegate(typeof(Action<modelType>));
table.OnLogMemberLoaded += onLogMemberLoaded;
}
#endif
}
}
/// <summary>
/// 执行SQL语句并更新成员
/// </summary>
/// <typeparam name="valueType">数据类型</typeparam>
/// <typeparam name="modelType">模型类型</typeparam>
/// <param name="sqlTool">SQL操作工具</param>
/// <param name="connection">SQL连接</param>
/// <param name="value">目标对象</param>
/// <param name="query">查询信息</param>
/// <returns>更新是否成功</returns>
internal bool Get <valueType, modelType>
(Sql.Table <valueType, modelType> sqlTool, ref DbConnection connection, valueType value, ref GetQuery <modelType> query)
where valueType : class, modelType
where modelType : class
{
if (connection == null)
{
connection = GetConnection();
}
if (connection != null)
{
bool isFinally = false;
try
{
using (DbCommand command = getCommand(connection, query.Sql))
using (DbDataReader reader = command.ExecuteReader(CommandBehavior.SingleResult))
{
if (reader.Read())
{
DataModel.Model <modelType> .Setter.Set(reader, value, query.MemberMap);
return(isFinally = true);
}
}
isFinally = true;
}
finally
{
if (!isFinally)
{
sqlTool.Log.Add(AutoCSer.Log.LogType.Error, query.Sql);
}
}
}
return(false);
}
