public DbMetaReader(DbSetting dbSetting)
{
if (dbSetting == null) throw new ArgumentNullException("dbSetting");
this._dbSetting = dbSetting;
this._db = new DbAccesser(dbSetting);
}
public override void QueryList(IDbAccesser dba, ISqlSelectArgs args)
{
var pagingInfo = args.PagingInfo;
if (PagingInfo.IsNullOrEmpty(pagingInfo) || this.GetPagingLocation(pagingInfo) == PagingLocation.Memory)
{
base.QueryList(dba, args);
}
else
{
//转换为分页查询 SQL
var parts = ParsePagingSqlParts(args.FormattedSql);
CreatePagingSql(ref parts, pagingInfo);
//读取分页的实体
using (var reader = dba.QueryDataReader(parts.PagingSql, args.Parameters))
{
this.FillDataIntoList(
reader, ReadDataType.ByName,
args.List, args.FetchingFirst, PagingInfo.Empty, args.MarkTreeFullLoaded
);
}
QueryTotalCountIf(dba, pagingInfo, parts, args.Parameters);
}
}
protected override void RunCore(IDbAccesser db)
{
var sqlCeCon = db.Connection as SqlCeConnection;
if (sqlCeCon == null) throw new InvalidOperationException("需要使用 SqlCe 的连接，才能正确创建数据库。");
File.Delete(db.Connection.Database);
}
public GenerateSql(DbSetting dbSetting)
{
if (dbSetting == null) throw new ArgumentNullException("dbSetting");
this._dbSetting = dbSetting;
this._db = new DbAccesser(dbSetting);
datatype = new INIFile();
}
public override void Insert(IDbAccesser dba, Entity item)
{
var idColumn = this.IdentityColumn;
if (idColumn != null)
{
if (_selectSEQSql == null)
{
var seqName = new StringWriter();
seqName.Write("SEQ_");
this.AppendPrepare(seqName, this.Name);
seqName.Write('_');
this.AppendPrepare(seqName, idColumn.Name);
var seqNameValue = Rafy.DbMigration.Oracle.OracleMigrationProvider.LimitOracleIdentifier(seqName.ToString());
//此序列是由 DbMigration 中自动生成的。
_selectSEQSql = string.Format(@"SELECT {0}.NEXTVAL FROM DUAL", seqNameValue);
}
//由于默认可能不是 int 类型，所以需要类型转换。
var value = dba.RawAccesser.QueryValue(_selectSEQSql);
value = TypeHelper.CoerceValue(item.KeyProvider.KeyType, value);
idColumn.LoadValue(item, value);
//如果实体的 Id 是在插入的过程中生成的，
//那么需要在插入组合子对象前，先把新生成的父对象 Id 都同步到子列表中。
item.SyncIdToChildren();
}
base.Insert(dba, item);
}
public SQLCompactCacheProvider(string dbFile)
{
if (string.IsNullOrWhiteSpace(dbFile)) throw new ArgumentNullException("dbFile");
this._cacheDir = @"CacheItems\";
//this._cacheDir = Path.Combine(Path.GetDirectoryName(dbFile), @"CacheItems\");
this._db = new DbAccesser("Case Sensitive=True;DataSource=" + dbFile, DbSetting.Provider_SqlCe);
}
//protected override void RunCore(IDBAccesser db)
//{
// //连接到 MASTER 数据库
// var master = new SqlConnectionStringBuilder(db.Connection.ConnectionString) { InitialCatalog = "MASTER" };
// ////手动打开连接，并不关闭，让连接一直处于打开的状态，否则不能立刻连接到新的数据库上
// //db.Connection.ConnectionString = master.ConnectionString;
// //db.Connection.Open();
// //db.ExecuteTextNormal(string.Format("CREATE DATABASE [{0}]", this.Database));
// //db.ExecuteTextNormal("USE " + this.Database);
// using (var db2 = new DBAccesser(master.ConnectionString, "System.Data.SqlClient"))
// {
// db2.ExecuteText(string.Format("CREATE DATABASE [{0}]", this.Database));
// SqlConnection.ClearPool(db2.Connection as SqlConnection);
// }
//}
protected override void RunCore(IDbAccesser db)
{
//连接到 MASTER 数据库
var builder = new SqlConnectionStringBuilder(db.ConnectionSchema.ConnectionString) { InitialCatalog = "MASTER" };
//手动打开连接，并不关闭，让连接一直处于打开的状态，否则不能立刻连接到新的数据库上
db.Connection.ConnectionString = builder.ConnectionString;
db.Connection.Open();
db.RawAccesser.ExecuteText(string.Format("CREATE DATABASE [{0}]", this.Database));
db.RawAccesser.ExecuteText("USE " + this.Database);
//另外，为了保证其它的连接能够连接上数据库而不会报错，最好等待 5 s。（具体原因未知。）
Thread.Sleep(5000);
}
protected override void RunCore(IDbAccesser db)
{
//db.Connection.Close();
//连接到 MASTER 数据库
var master = new SqlConnectionStringBuilder(db.Connection.ConnectionString) { InitialCatalog = "MASTER" };
//参考 EntityFramework SqlProviderServices.DbDeleteDatabase()
SqlConnection.ClearPool(db.Connection as SqlConnection);
using (var db2 = new DbAccesser(master.ConnectionString, DbSetting.Provider_SqlClient))
{
db2.ExecuteText(string.Format("DROP DATABASE [{0}]", this.Database));
}
}
public override void QueryList(IDbAccesser dba, IEntitySelectArgs args)
{
/*********************** 代码块解释 *********************************
*
* 以下代码用于支持数据库分页
*
**********************************************************************/
//检查分页条件。（如果是树状实体，也不支持在数据库中进行分页。）
var pagingInfo = args.PagingInfo;
bool isPaging = !PagingInfo.IsNullOrEmpty(pagingInfo) &&
this.GetPagingLocation(pagingInfo) == PagingLocation.Database &&
!Repository.SupportTree;
if (isPaging)
{
var query = args.Query;
if (!(query as TableQuery).HasOrdered()) { throw new InvalidProgramException("分页查询的同时，必须指定排序属性。"); }
var autoSelection = AutoSelectionForLOB(query);
//生成分页 Sql
var pk = query.From.FindTable(Repository).Column(Entity.IdProperty);
var generator = this.CreateSqlGenerator();
var pagedSelect = generator.ModifyToPagingTree(query as SqlSelect, pk as SqlColumn, pagingInfo);
generator.Generate(pagedSelect);
var pagingSql = generator.Sql;
//查询数据库
using (var reader = dba.QueryDataReader(pagingSql, pagingSql.Parameters))
{
//填充到列表中。
this.FillDataIntoList(
reader, autoSelection ? ReadDataType.ByIndex : ReadDataType.ByName,
args.List, false, pagingInfo, args.MarkTreeFullLoaded
);
}
//最后，如果需要，则统计一下总行数。
if (pagingInfo.IsNeedCount)
{
pagingInfo.TotalCount = this.Count(dba, query);
}
}
else
{
base.QueryList(dba, args);
}
}
public override void Insert(IDbAccesser dba, Entity item)
{
base.Insert(dba, item);
var idColumn = this.IdentityColumn;
if (idColumn != null)
{
//由于默认是 decimal 类型，所以需要类型转换。
var value = dba.RawAccesser.QueryValue("SELECT @@IDENTITY;");
value = TypeHelper.CoerceValue(item.KeyProvider.KeyType, value);
idColumn.LoadValue(item, value);
//如果实体的 Id 是在插入的过程中生成的，
//那么需要在插入组合子对象前，先把新生成的父对象 Id 都同步到子列表中。
item.SyncIdToChildren();
}
}
/// <summary>
/// 使用 IQuery 条件进行查询。
/// 分页默认实现为使用内存进行分页。
/// </summary>
/// <param name="dba">The dba.</param>
/// <param name="args">The arguments.</param>
public virtual void QueryList(IDbAccesser dba, IEntitySelectArgs args)
{
var query = args.Query;
var autoSelection = AutoSelectionForLOB(query);
var generator = this.CreateSqlGenerator();
QueryFactory.Instance.Generate(generator, query);
var sql = generator.Sql;
//查询数据库
var reader = dba.QueryDataReader(sql, sql.Parameters);
//填充到列表中。
this.FillDataIntoList(
reader, autoSelection ? ReadDataType.ByIndex : ReadDataType.ByName,
args.List, args.FetchingFirst, args.PagingInfo, args.MarkTreeFullLoaded
);
}
internal long Count(IDbAccesser dba, IQuery query)
{
var oldCounting = query.IsCounting;
try
{
query.IsCounting = true;
var generator = this.CreateSqlGenerator();
QueryFactory.Instance.Generate(generator, query);
var sql = generator.Sql;
var value = dba.QueryValue(sql, sql.Parameters);
return(ConvertCount(value));
}
finally
{
query.IsCounting = oldCounting;
}
}
public override int Insert(IDbAccesser dba, Entity item)
{
var result = base.Insert(dba, item);
var idColumn = this.IdentityColumn;
if (idColumn != null)
{
//由于默认是 decimal 类型，所以需要类型转换。
var value = dba.RawAccesser.QueryValue("SELECT @@IDENTITY;");
value = TypeHelper.CoerceValue(item.KeyProvider.KeyType, value);
idColumn.LoadValue(item, value);
//如果实体的 Id 是在插入的过程中生成的，
//那么需要在插入组合子对象前，先把新生成的父对象 Id 都同步到子列表中。
item.SyncIdToChildren();
}
return(result);
}
public override void Insert(IDbAccesser dba, Entity item)
{
var idColumn = this.IdentityColumn;
if (idColumn != null)
{
var isIdentityHasValue = (item as IEntityWithId).IdProvider.IsAvailable(item.Id);
string insertSql = isIdentityHasValue ? _withIdInsertSql ?? (_withIdInsertSql = $"{this.GenerateInsertSQL(true)}") :
_insertSql ?? (_insertSql = $"{this.GenerateInsertSQL()} ");
var parameters = Columns.Where(c => c.CanInsert || (c.Info.IsIdentity && isIdentityHasValue))
.Select(c => c.ReadParameterValue(item))
.ToArray();
if (isIdentityHasValue)
{
//打开 Identity 列可以手动插入
dba.RawAccesser.ExecuteText($"SET IDENTITY_INSERT {Name} ON ");
}
dba.ExecuteText(insertSql, parameters);
if (!isIdentityHasValue)
{
var idValue = dba.RawAccesser.QueryValue("SELECT @@IDENTITY;");
idValue = TypeHelper.CoerceValue((item as IEntityWithId).IdProvider.KeyType, idValue);
idColumn.LoadValue(item, idValue);
}
else
{
//关闭 Identity 列可以手动插入
dba.RawAccesser.ExecuteText($"SET IDENTITY_INSERT {Name} OFF ");
}
//如果实体的 Id 是在插入的过程中生成的，
//那么需要在插入组合子对象前，先把新生成的父对象 Id 都同步到子列表中。
item.SyncIdToChildren();
}
else
{
base.Insert(dba, item);
}
}
public override void Insert(IDbAccesser dba, Entity item)
{
var idColumn = this.IdentityColumn;
if (idColumn != null)
{
var idProvider = (item as IEntityWithId).IdProvider;
var hasId = idProvider.IsAvailable(item.Id);
string insertSql = hasId ? _insertSqlWithId.Value : _insertSql.Value;
object[] parameters = this.GenerateInsertSqlParameters(item, hasId);
if (hasId)
{
//打开 Identity 列可以手动插入
dba.RawAccesser.ExecuteText($"SET IDENTITY_INSERT {Name} ON ");
}
dba.ExecuteText(insertSql, parameters);
if (!hasId)
{
var idValue = dba.RawAccesser.QueryValue("SELECT @@IDENTITY;");
idValue = TypeHelper.CoerceValue(idProvider.KeyType, idValue);
idColumn.WritePropertyValue(item, idValue);
//如果实体的 Id 是在插入的过程中生成的，
//那么需要在插入组合子对象前，先把新生成的父对象 Id 都同步到子列表中。
item.SyncIdToChildren();
}
else
{
//关闭 Identity 列可以手动插入
dba.RawAccesser.ExecuteText($"SET IDENTITY_INSERT {Name} OFF ");
}
}
else
{
base.Insert(dba, item);
}
}
public virtual void Insert(IDbAccesser dba, Entity item)
{
EnsureMappingTable();
if (this._insertSQL == null)
{
this._insertSQL = this.GenerateInsertSQL();
}
var parameters = new List <object>();
foreach (RdbColumn column in _columns)
{
if (this.CanInsert(column))
{
var value = column.ReadParameterValue(item);
parameters.Add(value);
}
}
dba.ExecuteText(this._insertSQL, parameters.ToArray());
}
public override void Insert(IDbAccesser dba, Entity item)
{
//如果有 Id 列，那么需要在执行 Insert 的同时，执行 SELECT @@IDENTITY。
//在为 SQL Server 插入数据时，执行 Insert 的同时，必须同时执行 SELECT @@IDENTITY。否则会有多线程问题。
var idColumn = this.IdentityColumn;
if (idColumn != null)
{
if (_insertSQL == null)
{
_insertSQL = this.GenerateInsertSQL();
_insertSQL += Environment.NewLine;
_insertSQL += "SELECT @@IDENTITY;";
}
var parameters = new List <object>();
foreach (RdbColumn column in this.Columns)
{
if (column.CanInsert)
{
var value = column.ReadParameterValue(item);
parameters.Add(value);
}
}
//由于默认是 decimal 类型，所以需要类型转换。
var idValue = dba.QueryValue(this._insertSQL, parameters.ToArray());
idValue = TypeHelper.CoerceValue((item as IEntityWithId).IdProvider.KeyType, idValue);
idColumn.LoadValue(item, idValue);
//如果实体的 Id 是在插入的过程中生成的，
//那么需要在插入组合子对象前，先把新生成的父对象 Id 都同步到子列表中。
item.SyncIdToChildren();
}
else
{
base.Insert(dba, item);
}
}
protected override void RunCore(IDbAccesser db)
{
var sqlCeCon = db.Connection as SqlCeConnection;
if (sqlCeCon == null) throw new InvalidOperationException("需要使用 SqlCe 的连接，才能正确创建数据库。");
//保存目录存在。
var csb = new SqlCeConnectionStringBuilder(db.Connection.ConnectionString);
var path = CommonUtils.ReplaceDataDirectory(csb.DataSource);
var dir = Path.GetDirectoryName(path);
if (!string.IsNullOrWhiteSpace(dir))
{
Directory.CreateDirectory(dir);
}
else
{
Directory.CreateDirectory("\\");
}
//调用引擎创建数据库
var engine = new SqlCeEngine(db.Connection.ConnectionString);
engine.CreateDatabase();
}
public override void Insert(IDbAccesser dba, Entity item)
{
//如果有 Id 列，那么需要在执行 Insert 的同时，执行 SELECT @@IDENTITY。
//在为 SQL Server 插入数据时，执行 Insert 的同时，必须同时执行 SELECT @@IDENTITY。否则会有多线程问题。
var idColumn = this.IdentityColumn;
if (idColumn != null)
{
if (_insertSQL == null)
{
_insertSQL = this.GenerateInsertSQL();
_insertSQL += Environment.NewLine;
_insertSQL += "SELECT @@IDENTITY;";
}
var parameters = new List<object>();
foreach (RdbColumn column in this.Columns)
{
if (column.CanInsert)
{
var value = column.ReadParameterValue(item);
parameters.Add(value);
}
}
//由于默认是 decimal 类型，所以需要类型转换。
var idValue = dba.QueryValue(this._insertSQL, parameters.ToArray());
idValue = TypeHelper.CoerceValue(item.KeyProvider.KeyType, idValue);
idColumn.LoadValue(item, idValue);
//如果实体的 Id 是在插入的过程中生成的，
//那么需要在插入组合子对象前，先把新生成的父对象 Id 都同步到子列表中。
item.SyncIdToChildren();
}
else
{
base.Insert(dba, item);
}
}
/// <summary>
/// 获取指定大小批量的连续的 Id 号。返回第一个 Id 号的值。
/// </summary>
/// <param name="dba">The dba.</param>
/// <param name="table">The table.</param>
/// <param name="size">需要连续的多少个 Id 号。</param>
/// <returns></returns>
private static long GetBatchIDs(IDbAccesser dba, RdbTable table, int size)
{
/*********************** 代码块解释 *********************************
* 算法解释：
* 1.先查出当前最大的 ID 值；
* 2.计算出所需要使用的区间的起始、终止值 [start,end]；
* 3.然后设置 IDENTITY 的种子值为终止值；
* 4.由于上两步 SQL 执行过程中有可能其它线程使用了这个 IDENTITY 而造成 [start,end] 中的值被使用，
* 所以需要对表中的数据进行检测，如果没有被使用，才把这些 ID 值返回。
* 如果被使用了，则上述过程重来一次即可。
*
* IDENTITY 的操作方法：http://www.cnblogs.com/gaizai/archive/2013/04/23/3038318.html
**********************************************************************/
var tableName = table.Name;
lock (_identityLock)
{
while (true)
{
var currentValue = Convert.ToInt64(dba.QueryValue(string.Format("SELECT IDENT_CURRENT('{0}')", tableName)));
var start = currentValue + 1;
var end = start + size - 1;
dba.ExecuteText(string.Format("DBCC CHECKIDENT('{0}', RESEED, {1})", tableName, end));
var concurrency = dba.QueryValue(string.Format(
"SELECT 1 WHERE EXISTS (SELECT 1 FROM {0} WHERE {1} >= {2} AND {1} <= {3})",
tableName, table.IdentityColumn.Name, start, end
));
if (concurrency == null)
{
return(start);
}
}
}
throw new InvalidOperationException("生成 Id 时，发生未知错误。");
}
/// <summary>
/// 执行数据库的创建操作
/// </summary>
/// <param name="db">数据库访问对象</param>
protected override void RunCore(IDbAccesser db)
{
//https://blog.csdn.net/weixin_45694790/article/details/116030231
var dbFile = this.Database.Replace("/main", string.Empty);
var dir = Path.GetDirectoryName(dbFile);
Directory.CreateDirectory(dir);
var connectionType = Type.GetType("System.Data.SQLite.SQLiteConnection, System.Data.SQLite");
var createFileMethod = connectionType.GetMethod("CreateFile", new Type[] { typeof(string) });
createFileMethod.Invoke(null, new object[] { dbFile });
//string dbConnString = db.ConnectionSchema.ConnectionString;
//db.Connection.ConnectionString = dbConnString.Replace(db.Connection.Database, "SQLite");
////手动打开连接，并不关闭，让连接一直处于打开的状态，否则不能立刻连接到新的数据库上
//db.Connection.Open();
//db.RawAccesser.ExecuteText(string.Format("CREATE DATABASE IF NOT EXISTS {0} CHARACTER SET UTF8;", this.Database));
//db.RawAccesser.ExecuteText("USE " + this.Database + ";");
//db.Connection.Close();
//db.Connection.ConnectionString = dbConnString;
}
/// <summary>
/// 执行 sql 插入一个实体到数据库中。
/// 基类的默认实现中，只是简单地实现了 sql 语句的生成和执行。
/// </summary>
/// <param name="dba"></param>
/// <param name="item"></param>
public virtual void Insert(IDbAccesser dba, Entity item)
{
EnsureMappingTable();
if (this._insertSQL == null)
{
this._insertSQL = this.GenerateInsertSQL();
}
var parameters = new List <object>(10);
for (int i = 0, c = _columns.Count; i < c; i++)
{
var column = _columns[i];
if (column.CanInsert)
{
var value = column.ReadParameterValue(item);
parameters.Add(value);
}
}
dba.ExecuteText(this._insertSQL, parameters.ToArray());
}
public override void QueryList(IDbAccesser dba, ISqlSelectArgs args)
{
var pagingInfo = args.PagingInfo;
if (PagingInfo.IsNullOrEmpty(pagingInfo) || this.GetPagingLocation(pagingInfo) == PagingLocation.Memory)
{
base.QueryList(dba, args);
}
else
{
//转换为分页查询 SQL
var parts = ParsePagingSqlParts(args.FormattedSql);
CreatePagingSql(ref parts, pagingInfo);
//读取分页的实体
var reader = dba.QueryDataReader(parts.PagingSql, args.Parameters);
this.FillDataIntoList(
reader, ReadDataType.ByName,
args.List, args.FetchingFirst, PagingInfo.Empty, args.MarkTreeFullLoaded
);
QueryTotalCountIf(dba, pagingInfo, parts, args.Parameters);
}
}
protected override void RunCore(IDbAccesser db)
{
var count = Convert.ToInt32(db.QueryValue(
"SELECT COUNT(0) FROM ALL_SEQUENCES WHERE SEQUENCE_NAME = {0} AND SEQUENCE_OWNER = {1}",
this.SequenceName,
DbConnectionSchema.GetOracleUserId(db.ConnectionSchema).ToUpper()
));
if (count <= 0)
{
db.ExecuteText(string.Format(
@"CREATE SEQUENCE {0}
MINVALUE 1
MAXVALUE 99999999999999999
START WITH 1
INCREMENT BY 1
NOCACHE
ORDER", this.SequenceName));
}
// var sql = string.Format(@"DECLARE T_COUNT NUMBER;
//BEGIN
// SELECT COUNT(*) INTO T_COUNT FROM DUAL WHERE EXISTS(SELECT * FROM ALL_SEQUENCES WHERE SEQUENCE_NAME='{0}');
// IF T_COUNT = 0 THEN
// EXECUTE IMMEDIATE '
// CREATE SEQUENCE {0}
// MINVALUE 1
// MAXVALUE 99999999999999999
// START WITH 1
// INCREMENT BY 1
// NOCACHE
// ORDER
// ';
// END IF;
//END;", this.SEQName(op));
}
internal int Delete(IDbAccesser dba, IConstraint where)
{
if (where == null)
{
throw new ArgumentNullException("where");
}
EnsureMappingTable();
var sql = new StringWriter();
sql.Write("DELETE FROM ");
sql.AppendQuoteName(this);
sql.Write(" WHERE ");
var generator = this.CreateSqlGenerator();
generator.Generate(where as SqlNode);
var whereSql = generator.Sql;
sql.Write(whereSql.ToString());
return(dba.ExecuteText(sql.ToString(), whereSql.Parameters));
}
public override void Insert(IDbAccesser dba, Entity item)
{
var idColumn = this.IdentityColumn;
if (idColumn != null)
{
// identity 是 int 或者long 型
var isIdColumnHasValue = (item as IEntityWithId).IdProvider.IsAvailable(item.Id);
if (!isIdColumnHasValue)
{
if (_selectSEQSql == null)
{
var seqName = new StringWriter();
seqName.Write("SEQ_");
this.AppendPrepare(seqName, this.Name);
seqName.Write('_');
this.AppendPrepare(seqName, idColumn.Name);
var seqNameValue =
Rafy.DbMigration.Oracle.OracleMigrationProvider.LimitOracleIdentifier(seqName.ToString());
//此序列是由 DbMigration 中自动生成的。
_selectSEQSql = string.Format(@"SELECT {0}.NEXTVAL FROM DUAL", seqNameValue);
}
//由于默认可能不是 int 类型，所以需要类型转换。
var value = dba.RawAccesser.QueryValue(_selectSEQSql);
value = TypeHelper.CoerceValue((item as IEntityWithId).IdProvider.KeyType, value);
idColumn.LoadValue(item, value);
}
//如果实体的 Id 是在插入的过程中生成的，
//那么需要在插入组合子对象前，先把新生成的父对象 Id 都同步到子列表中。
item.SyncIdToChildren();
}
base.Insert(dba, item);
}
public override void QueryTable(IDbAccesser dba, ITableQueryArgs args)
{
var pagingInfo = args.PagingInfo;
if (PagingInfo.IsNullOrEmpty(pagingInfo) || this.GetPagingLocation(pagingInfo) == PagingLocation.Memory)
{
base.QueryTable(dba, args);
}
else
{
//转换为分页查询 SQL
var parts = ParsePagingSqlParts(args.FormattedSql);
CreatePagingSql(ref parts, pagingInfo);
//读取分页的数据
var table = args.ResultTable;
using (var reader = dba.QueryDataReader(parts.PagingSql, args.Parameters))
{
LiteDataTableAdapter.Fill(table, reader);
}
QueryTotalCountIf(dba, pagingInfo, parts, args.Parameters);
}
}
public void Run(IDbAccesser db)
{
this.RunCore(db);
}
public void Run(IDbAccesser db)
{
this.RunCore(db);
}
internal int Update(IDbAccesser dba, Entity item)
{
EnsureMappingTable();
var parameters = new List<object>(10);
string updateSql = null;
//是否有需要更新的 lob 字段。
bool hasUpdatedLOBColumns = false;
List<RdbColumn> lobColumns = null;
if (_hasLOB)
{
lobColumns = new List<RdbColumn>();
for (int i = 0, c = _columns.Count; i < c; i++)
{
var column = _columns[i];
//如果一个 lob 属性的值存在，则表示需要更新。
//（可能被设置了，也可能只是简单地读取了一下，没有变更值。这时也简单地处理。）
if (column.IsLOB && item.FieldExists(column.Info.Property))
{
lobColumns.Add(column);
hasUpdatedLOBColumns = true;
}
}
}
if (!hasUpdatedLOBColumns)
{
//如果没有 LOB，则直接缓存上更新语句。
if (_updateSQL == null) { _updateSQL = this.GenerateUpdateSQL(null); }
updateSql = _updateSQL;
}
else
{
updateSql = this.GenerateUpdateSQL(lobColumns);
}
//更新所有非 lob 的字段
for (int i = 0, c = _columns.Count; i < c; i++)
{
var column = _columns[i];
if (!column.Info.IsPrimaryKey && !column.IsLOB)
{
var value = column.ReadParameterValue(item);
parameters.Add(value);
}
}
//更新需要更新的 lob 字段
if (hasUpdatedLOBColumns)
{
for (int i = 0, c = lobColumns.Count; i < c; i++)
{
var column = lobColumns[i];
if (!column.Info.IsPrimaryKey)
{
var value = column.ReadParameterValue(item);
parameters.Add(value);
}
}
}
//Id 最后加入
parameters.Add(item.Id);
int res = dba.ExecuteText(updateSql, parameters.ToArray());
return res;
}
internal int Delete(IDbAccesser dba, Entity item)
{
EnsureMappingTable();
if (this._deleteSQL == null) { this._deleteSQL = this.GenerateDeleteSQL(); }
var result = dba.ExecuteText(this._deleteSQL, item.Id);
return result;
}
/// <summary>
/// 使用 Sql 进行查询。
/// 分页默认实现为使用内存进行分页。
/// </summary>
/// <param name="dba">The dba.</param>
/// <param name="args">The arguments.</param>
public virtual void QueryTable(IDbAccesser dba, ITableQueryArgs args)
{
if (_hasLOB)
{
args.FormattedSql = this.ReplaceLOBColumns(args.FormattedSql);
}
using (var reader = dba.QueryDataReader(args.FormattedSql, args.Parameters))
{
var table = args.ResultTable;
if (table.Columns.Count == 0)
{
LiteDataTableAdapter.AddColumns(table, reader);
}
var columnsCount = table.Columns.Count;
PagingHelper.MemoryPaging(reader, r =>
{
var row = table.NewRow();
for (int i = 0; i < columnsCount; i++)
{
var value = reader[i];
if (value != DBNull.Value)
{
row[i] = value;
}
}
table.Rows.Add(row);
}, args.PagingInfo);
}
}
/// <summary>
/// 使用 IQuery 条件进行查询。
/// 分页默认实现为使用内存进行分页。
/// </summary>
/// <param name="dba">The dba.</param>
/// <param name="args">The arguments.</param>
public virtual void QueryList(IDbAccesser dba, IEntitySelectArgs args)
{
var query = args.Query;
var autoSelection = AutoSelectionForLOB(query);
var generator = this.CreateSqlGenerator();
QueryFactory.Instance.Generate(generator, query);
var sql = generator.Sql;
this.QueryDataReader(dba, args, autoSelection ? ReadDataType.ByIndex : ReadDataType.ByName, sql);
}
protected override void RunCore(IDbAccesser db)
{
this.Action(db);
}
protected override void RunCore(IDbAccesser db)
{
db.ExecuteText(this.Sql, this.Sql.Parameters);
}
protected override void RunCore(IDbAccesser db)
{
throw new DbMigrationException(this.Message);
}
protected override void RunCore(IDbAccesser db)
{
db.RawAccesser.ExecuteText(this.Sql);
}
protected override void RunCore(IDbAccesser db)
{
db.RawAccesser.ExecuteText(this.Sql);
}
/// <summary>
/// 运行修改当前运行的数据库操作
/// </summary>
/// <param name="db">数据库访问对象</param>
protected override void RunCore(IDbAccesser db)
{
db.RawAccesser.ExecuteText("USE " + this.Database + ";");
}
protected abstract void RunCore(IDbAccesser db);
protected override void RunCore(IDbAccesser db)
{
throw new DbMigrationException(this.Message);
}
/// <summary>
/// 执行 sql 插入一个实体到数据库中。
/// 基类的默认实现中，只是简单地实现了 sql 语句的生成和执行。
/// </summary>
/// <param name="dba"></param>
/// <param name="item"></param>
public virtual void Insert(IDbAccesser dba, Entity item)
{
EnsureMappingTable();
if (this._insertSQL == null) { this._insertSQL = this.GenerateInsertSQL(); }
var parameters = new List<object>(10);
for (int i = 0, c = _columns.Count; i < c; i++)
{
var column = _columns[i];
if (column.CanInsert)
{
var value = column.ReadParameterValue(item);
parameters.Add(value);
}
}
dba.ExecuteText(this._insertSQL, parameters.ToArray());
}
public virtual int Update(IDbAccesser dba, Entity item)
{
EnsureMappingTable();
var parameters = new List <object>(10);
string updateSql = null;
//是否有需要更新的 lob 字段。
bool hasUpdatedLOBColumns = false;
List <RdbColumn> lobColumns = null;
if (_hasLOB)
{
lobColumns = new List <RdbColumn>();
for (int i = 0, c = _columns.Count; i < c; i++)
{
var column = _columns[i];
//如果一个 lob 属性的值存在，则表示需要更新。
//（可能被设置了，也可能只是简单地读取了一下，没有变更值。这时也简单地处理。）
if (column.IsLOB && item.FieldExists(column.Info.Property))
{
lobColumns.Add(column);
hasUpdatedLOBColumns = true;
}
}
}
if (!hasUpdatedLOBColumns)
{
//如果没有 LOB，则直接缓存上更新语句。
updateSql = _updateSQL.Value;
}
else
{
updateSql = this.GenerateUpdateSQL(lobColumns);
}
//更新所有非 lob 的字段
for (int i = 0, c = _columns.Count; i < c; i++)
{
var column = _columns[i];
if (!column.Info.IsPrimaryKey && !column.IsLOB)
{
var value = column.ReadDbParameterValue(item);
parameters.Add(value);
}
}
//更新需要更新的 lob 字段
if (hasUpdatedLOBColumns)
{
for (int i = 0, c = lobColumns.Count; i < c; i++)
{
var column = lobColumns[i];
if (!column.Info.IsPrimaryKey)
{
var value = column.ReadDbParameterValue(item);
parameters.Add(value);
}
}
}
//Id 最后加入
parameters.Add(item.Id);
int res = dba.ExecuteText(updateSql, parameters.ToArray());
return(res);
}
/// <summary>
/// 使用 Sql 进行查询。
/// 分页默认实现为使用内存进行分页。
/// </summary>
/// <param name="dba">The dba.</param>
/// <param name="args">The arguments.</param>
public virtual void QueryList(IDbAccesser dba, ISqlSelectArgs args)
{
if (_hasLOB)
{
args.FormattedSql = this.ReplaceLOBColumns(args.FormattedSql);
}
using (var reader = dba.QueryDataReader(args.FormattedSql, args.Parameters))
{
this.FillDataIntoList(
reader, ReadDataType.ByName,
args.List, args.FetchingFirst, args.PagingInfo, args.MarkTreeFullLoaded
);
}
}
internal static bool IsSqlceConnection(IDbAccesser db)
{
return(db.Connection.GetType().AssemblyQualifiedName.Contains(DbSetting.Provider_SqlCe));
}
internal int Count(IDbAccesser dba, IQuery query)
{
var oldCounting = query.IsCounting;
try
{
query.IsCounting = true;
var generator = this.CreateSqlGenerator();
QueryFactory.Instance.Generate(generator, query);
var sql = generator.Sql;
var value = dba.QueryValue(sql, sql.Parameters);
return ConvertCount(value);
}
finally
{
query.IsCounting = oldCounting;
}
}
protected abstract void RunCore(IDbAccesser db);
internal int Delete(IDbAccesser dba, IConstraint where)
{
if (where == null) throw new ArgumentNullException("where");
EnsureMappingTable();
var sql = new StringWriter();
sql.Write("DELETE FROM ");
sql.AppendQuoteName(this);
sql.Write(" WHERE ");
var generator = this.CreateSqlGenerator();
generator.Generate(where as SqlNode);
var whereSql = generator.Sql;
sql.Write(whereSql.ToString());
return dba.ExecuteText(sql.ToString(), whereSql.Parameters);
}
public SqlServer2008Backuper(IDbAccesser masterDBAccesser)
: base(masterDBAccesser)
{
}
/// <summary>
/// 执行 Sql 并读取 DataReader 中的值到实体。
/// </summary>
/// <param name="dba">The dba.</param>
/// <param name="args">The arguments.</param>
/// <param name="readType">Type of the read.</param>
/// <param name="sql">The SQL.</param>
protected void QueryDataReader(IDbAccesser dba, IEntitySelectArgs args, ReadDataType readType, FormattedSql sql)
{
//查询数据库
using (var reader = dba.QueryDataReader(sql, sql.Parameters))
{
//填充到列表中。
this.FillDataIntoList(
reader,
readType,
args.List,
args.FetchingFirst,
args.PagingInfo,
args.MarkTreeFullLoaded
);
}
}
public override void QueryTable(IDbAccesser dba, ITableQueryArgs args)
{
var pagingInfo = args.PagingInfo;
if (PagingInfo.IsNullOrEmpty(pagingInfo) || this.GetPagingLocation(pagingInfo) == PagingLocation.Memory)
{
base.QueryTable(dba, args);
}
else
{
//转换为分页查询 SQL
var parts = ParsePagingSqlParts(args.FormattedSql);
CreatePagingSql(ref parts, pagingInfo);
//读取分页的数据
var table = args.ResultTable;
using (var reader = dba.QueryDataReader(parts.PagingSql, args.Parameters))
{
LiteDataTableAdapter.Fill(table, reader);
}
QueryTotalCountIf(dba, pagingInfo, parts, args.Parameters);
}
}
public SqlServer2008Backuper(IDbAccesser masterDBAccesser)
: base(masterDBAccesser)
{
}
/// <summary>
/// 如果需要统计，则生成统计语句进行查询。
/// </summary>
/// <param name="dba"></param>
/// <param name="pagingInfo"></param>
/// <param name="parts"></param>
/// <param name="parameters"></param>
/// <returns></returns>
private static void QueryTotalCountIf(IDbAccesser dba, PagingInfo pagingInfo, PagingSqlParts parts, object[] parameters)
{
if (pagingInfo.IsNeedCount)
{
var pagingCountSql = "SELECT COUNT(0) " + parts.FromWhere;
//查询值。（由于所有参数都不会在 OrderBy、Select 语句中，所以把所有参数都传入。
var value = dba.QueryValue(pagingCountSql, parameters);
pagingInfo.TotalCount = Convert.ToInt32(value);
}
}
/// <summary>
/// 获取指定大小批量的连续的 Id 号。返回第一个 Id 号的值。
/// </summary>
/// <param name="dba">The dba.</param>
/// <param name="table">The table.</param>
/// <param name="size">需要连续的多少个 Id 号。</param>
/// <returns></returns>
private static int GetBatchIDs(IDbAccesser dba, RdbTable table, int size)
{
/*********************** 代码块解释 *********************************
* 算法解释：
* 1.先查出当前最大的 ID 值；
* 2.计算出所需要使用的区间的起始、终止值 [start,end]；
* 3.然后设置 IDENTITY 的种子值为终止值；
* 4.由于上两步 SQL 执行过程中有可能其它线程使用了这个 IDENTITY 而造成 [start,end] 中的值被使用，
* 所以需要对表中的数据进行检测，如果没有被使用，才把这些 ID 值返回。
* 如果被使用了，则上述过程重来一次即可。
*
* IDENTITY 的操作方法：http://www.cnblogs.com/gaizai/archive/2013/04/23/3038318.html
**********************************************************************/
var tableName = table.Name;
lock (_identityLock)
{
while (true)
{
var currentValue = Convert.ToInt32(dba.QueryValue(string.Format("SELECT IDENT_CURRENT('{0}')", tableName)));
var start = currentValue + 1;
var end = start + size - 1;
dba.ExecuteText(string.Format("DBCC CHECKIDENT('{0}', RESEED, {1})", tableName, end));
var concurrency = dba.QueryValue(string.Format(
"SELECT 1 WHERE EXISTS (SELECT 1 FROM {0} WHERE {1} >= {2} AND {1} <= {3})",
tableName, table.IdentityColumn.Name, start, end
));
if (concurrency == null) return start;
}
}
throw new InvalidOperationException("");
}
public SqlServerBackuper(IDbAccesser masterDBAccesser)
{
if (masterDBAccesser == null) throw new ArgumentNullException("masterDBAccesser");
this._db = masterDBAccesser;
}
