public static ISqlProvider Create(string provider)
{
//ISqlConverter Factory
switch (provider)
{
case DbSetting.Provider_Oracle:
if (_oracleConverter == null)
{
_oracleConverter = new OracleProvider();
}
return(_oracleConverter);
case DbSetting.Provider_Odbc:
if (_odbcConverter == null)
{
_odbcConverter = new ODBCProvider();
}
return(_odbcConverter);
case DbSetting.Provider_SqlClient:
case DbSetting.Provider_SqlCe:
default:
if (_sqlConverter == null)
{
_sqlConverter = new SqlServerProvider();
}
return(_sqlConverter);
//throw new NotSupportedException("This type of database is not supportted now:" + provider);
}
}
public static ISqlProvider Create(string provider)
{
//ISqlConverter Factory
switch (provider)
{
case DbSetting.Provider_Odbc:
if (_odbcConverter == null) _odbcConverter = new ODBCProvider();
return _odbcConverter;
case DbSetting.Provider_SqlClient:
case DbSetting.Provider_SqlCe:
if (_sqlConverter == null) _sqlConverter = new SqlServerProvider();
return _sqlConverter;
default:
if (DbSetting.IsOracleProvider(provider))
{
if (_oracleConverter == null) _oracleConverter = new OracleProvider();
return _oracleConverter;
}
if (_sqlConverter == null) _sqlConverter = new SqlServerProvider();
return _sqlConverter;
}
}
public TrackableDictionarySqlMapper(ISqlProvider sqlProvider,
string tableName,
ColumnDefinition keyColumnDef,
ColumnDefinition[] headKeyColumnDefs = null)
: this(sqlProvider, tableName, keyColumnDef, null, headKeyColumnDefs)
{
}
public static DbConnection GetConnection(ISqlProvider sqlProvider, string key, ShuffledModel shuffle)
{
var connStr = Configuration.GetConnectionString(string.Format(key, shuffle.DBId));
if (string.IsNullOrEmpty(connStr))
{
connStr = Configuration.GetConnectionString(string.Format(key, ""));
}
connStr = string.Format(connStr, shuffle.DBId);
var connLst = GetRequestConnLst().ConnLst;
DbConnection conn;
connLst.TryGetValue(connStr, out conn);
if (conn == null)
{
conn = sqlProvider.GetConnection(connStr);
connLst.Add(connStr, conn);
}
try
{
if (conn.State != ConnectionState.Open)
{
conn.Open();
}
}
catch
{
conn.Close();
throw;
}
return(conn);
}
public TrackableContainerTest(IDbConnectionProvider dbConnectionProvider, ISqlProvider sqlProvider)
: base(useList: false, useSet: true, useDuplicateCheck: true)
{
_db = dbConnectionProvider;
_mapper = new TrackableContainerSqlMapper <ITestContainer>(
sqlProvider,
new[]
{
Tuple.Create("Person", new object[]
{
"TrackableContainerPerson",
new[] { new ColumnDefinition("ContainerId", typeof(int)) }
}),
Tuple.Create("Missions", new object[]
{
"TrackableContainerMission",
new ColumnDefinition("MissionId"),
new[] { new ColumnDefinition("ContainerId", typeof(int)) },
}),
Tuple.Create("Aliases", new object[]
{
"TrackableContainerAlias",
new ColumnDefinition("Value", typeof(string), 64),
new[] { new ColumnDefinition("ContainerId", typeof(int)) }
}),
});
_mapper.ResetTableAsync(_db.Connection, true).Wait();
}
///<summary>Creates a TableSynchronizer for the specified table.</summary>
public TableSynchronizer(Table table, SchemaMapping mapping, ISqlProvider sqlProvider)
{
if (table == null)
{
throw new ArgumentNullException("table");
}
if (mapping == null)
{
throw new ArgumentNullException("mapping");
}
if (sqlProvider == null)
{
throw new ArgumentNullException("sqlProvider");
}
if (table.Schema != mapping.Schema)
{
throw new ArgumentException("Table and mapping must have the same schema", "mapping");
}
Table = table;
Mapping = mapping;
SqlProvider = sqlProvider;
Table.RowAdded += Table_RowAdded;
Table.ValueChanged += Table_ValueChanged;
Table.RowRemoved += Table_RowRemoved;
Changes = new ReadOnlyCollection <RowChange>(changes);
}
public static SqlQueryBuilder With
(this ISqlProvider sqlProvider,
String name,
Object?value = null,
DbType?dbType = null,
Int32?size = null) =>
sqlProvider.Exec().With(name, value, dbType, size);
protected TrackablePocoTest(IDbConnectionProvider dbConnectionProvider, ISqlProvider sqlProvider)
: base(useDuplicateCheck: true)
{
_db = dbConnectionProvider;
_mapper = new TrackablePocoSqlMapper <ITestPoco>(sqlProvider, nameof(TrackablePocoTest));
_mapper.ResetTableAsync(_db.Connection).Wait();
}
public Connection(Action <AfonsoftADOOptions> options)
{
_options = Build(options);
_sqlProvider = GetProvider(_options.Provider);
DbConnection = _sqlProvider.Connection;
ExistConnection();
}
public void Fill(ISqlProvider sqlProvider, IMappingProvider mappingProvider, IDataReader reader, object entity, ObjectFiller objectFiller)
{
foreach (PropertyFiller propertyFiller in objectFiller.PropertyFillers)
{
//Console.WriteLine(propertyFiller.Column.ColumnName + ":" + propertyFiller.OutputColumnIndex + ":" + propertyFiller.Column.PropertyAdapter.PropertyName + ":" + propertyFiller.Column.PropertyAdapter.PropertyType);
//propertyFiller.Column.FillPropertyValue(entityObject, dataReader, propertyFiller.OutputColumnIndex);
//propertyFiller.getPropertyAdapter().setPropertyValue(object, resultSet.getObject(propertyFiller.getOutputColumnIndex()));
//为值类型赋值null会出问题
object value = sqlProvider.ConvertDbValue(reader[propertyFiller.ColumnIndex], propertyFiller.PropertyType);
if (!(propertyFiller.PropertyType.IsValueType && value == null))
{
Set(entity, propertyFiller.PropertyName, value);
}
}
foreach (ObjectFiller f in objectFiller.ObjectFillers)
{
//如果已经有实例，则不需要实例化
object existsInstance = Get(entity, f.PropertyName);
if (existsInstance == null)
{
existsInstance = CreateInstance(f.EntityType);
Set(entity, f.PropertyName, existsInstance);
}
Fill(sqlProvider, mappingProvider, reader, existsInstance, f);
}
}
/// <summary>
/// 添加 <see cref="ISqlProvider"/>.
/// </summary>
/// <param name="provider"> <see cref="ISqlProvider"/>.</param>
public void AddProvider(ISqlProvider provider)
{
lock (_sync)
{
_provider.Add(provider);
}
}
/// <summary>
/// Sets the value by querying the data base (through the given provider)
/// </summary>
/// <param name="appendableSelectStatement"></param>
/// <param name="provider"></param>
public void SetValue(string appendableSelectStatement, ISqlProvider provider)
{
string sql = string.Format(appendableSelectStatement, ColumnName);
var result = provider.ExecuteQuery(sql, SelectOptions.Single)[0];
Value = result.GetSingleResult();
}
internal void DoDelete(ISqlProvider provider)
{
for (int i = rows.Count - 1; i >= 0; i--)
{
rows[i].DoDelete(provider);
}
}
internal void DoWrite(ISqlProvider provider)
{
foreach (var row in rows)
{
row.DoWrite(provider);
}
}
/// <summary>
/// Deletes the row from the database if it has been marked as
/// deletable through DeleteFirst()
/// </summary>
public void DoDelete(ISqlProvider provider)
{
if (deleteFirst)
{
Delete(provider);
}
}
public BaseDataContext(
IConnectionProvider connectionProvider,
ISqlBuilder sqlBuilder,
ISqlCache sqlCache)
{
this.connectionProvider = connectionProvider;
this.sqlProvider = new SqlProvider(sqlBuilder, sqlCache);
}
public void Init()
{
InternalGrammarService = FerOmegaInjections.InternalGrammarService;
TokenizationService = FerOmegaInjections.TokenizationService;
AstService = FerOmegaInjections.AstService;
SqlGrammarService = FerOmegaInjections.SqlGrammarService;
SqlProvider = FerOmegaInjections.SqlProvider;
}
public QuestionRepository(ISqlProvider sqlProvider)
{
if (sqlProvider == null)
{
throw new ArgumentNullException("sqlProvider");
}
_sqlProvider = sqlProvider;
}
private static void BuildTrackableDictionaryProperty <TKey, TValue>(ISqlProvider sqlProvider,
PropertyItem item,
object[] mapperParameters)
{
if (mapperParameters.Length != 3 && mapperParameters.Length != 4)
{
throw new ArgumentException("The length of mapperParameters should be 3 or 4");
}
var mapper = mapperParameters.Length == 3
? new TrackableDictionarySqlMapper <TKey, TValue>(
sqlProvider,
(string)mapperParameters[0],
(ColumnDefinition)mapperParameters[1],
(ColumnDefinition[])mapperParameters[2])
: new TrackableDictionarySqlMapper <TKey, TValue>(
sqlProvider,
(string)mapperParameters[0],
(ColumnDefinition)mapperParameters[1],
(ColumnDefinition)mapperParameters[2],
(ColumnDefinition[])mapperParameters[3]);
item.Mapper = mapper;
item.BuildCreateTableSql = (dropIfExists) =>
{
return(mapper.BuildCreateTableSql(dropIfExists));
};
item.BuildSqlForCreate = (container, keyValues) =>
{
var value = (IDictionary <TKey, TValue>)item.PropertyInfo.GetValue(container);
return(value != null
? mapper.BuildSqlForCreate(value, keyValues)
: string.Empty);
};
item.BuildSqlForDelete = (keyValues) =>
{
return(mapper.BuildSqlForDelete(keyValues));
};
item.BuildSqlForLoad = (keyValues) =>
{
return(mapper.BuildSqlForLoad(keyValues));
};
item.LoadAndSetAsync = async(reader, container) =>
{
var value = await mapper.LoadAsync(reader);
item.PropertyInfo.SetValue(container, value);
return(value != null);
};
item.BuildSqlForSave = (tracker, keyValues) =>
{
var valueTracker = (TrackableDictionaryTracker <TKey, TValue>)item.TrackerPropertyInfo.GetValue(tracker);
return(valueTracker.HasChange
? mapper.BuildSqlForSave(valueTracker, keyValues)
: string.Empty);
};
}
public SqlTable(ISqlProvider provider, string name)
: base(name)
{
this.provider = provider;
using (DbCommand cmd = this.provider.SelectTop(this.Name, "", 0))
this.CreateColumns(cmd);
this.constructor = Serializable.GetIDataConstructor(typeof(T));
}
public TrackableSetValueTest(IDbConnectionProvider dbConnectionProvider, ISqlProvider sqlProvider)
: base(useDuplicateCheck: true)
{
_db = dbConnectionProvider;
_mapper = new TrackableSetSqlMapper<int>(
sqlProvider,
nameof(TrackableSetValueTest),
new ColumnDefinition("Value", typeof(int)),
null);
_mapper.ResetTableAsync(_db.Connection).Wait();
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="sqlProvider">需要传入类型，考虑到动态生成DbSession，不能用泛型</param>
/// <param name="connectionString">数据库连接字符串</param>
/// <param name="sqlTracers">可以指定多个sql语句跟踪器，如果为null则不会有任何追踪</param>
public DbHelper(ISqlProvider sqlProvider, string connectionString, ISqlTracer[] sqlTracers)
{
if (sqlProvider == null)
{
throw new ArgumentNullException("sqlProvider");
}
SqlProvider = sqlProvider;
Connection = SqlProvider.CreateConnection();
Connection.ConnectionString = connectionString;
SqlTracers = sqlTracers;
}
public TrackableSetValueTest(IDbConnectionProvider dbConnectionProvider, ISqlProvider sqlProvider)
: base(useDuplicateCheck: true)
{
_db = dbConnectionProvider;
_mapper = new TrackableSetSqlMapper <int>(
sqlProvider,
nameof(TrackableSetValueTest),
new ColumnDefinition("Value", typeof(int)),
null);
_mapper.ResetTableAsync(_db.Connection).Wait();
}
public TrackableContainerSqlMapper(ISqlProvider sqlProvider, Tuple <string, object[]>[] mapperParameters)
{
_sqlProvider = sqlProvider;
_trackableType = TrackableResolver.GetContainerTrackerType(typeof(T));
if (_trackableType == null)
{
throw new ArgumentException($"Cannot find tracker type of '{nameof(T)}'");
}
_items = ConstructPropertyItems(sqlProvider, mapperParameters);
}
public static T SelectSingle <T>(ISqlProvider provider, string name, string where) where T : ISerializable
{
using (SqlTable <T> table = new SqlTable <T>(provider, name))
{
T[] res = table.Select(where);
if (res.Length > 0)
{
return(res[0]);
}
}
return(default(T));
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (this._connectionCreatedBySelf && this._connection != null)
{
this._connection.Dispose();
}
this._connection = null;
this._converter = null;
this._factory = null;
}
}
public void BootstrapDb()
{
Config.Global.DbConfigProvider = new TestDbConfigProvider();
Config.Global.DefaultSqlProvider = new DefaultSqlProvider();
provider = Config.Global.DefaultSqlProvider;
using (ScribeContext con = new ScribeContext())
{
var tableAttribute = TableAttribute.GetFor <Employee>();
var meta = ColumnMetadata.GetColumnMetadata <Employee>().Where(x => !x.IsNotMapped).ToList();
bool employeeTableExists =
con.Connection.Query <int>("SELECT COUNT(*) FROM sys.tables where name like 'Employee'").First() == 1;
if (!employeeTableExists)
{
var employeeTable = provider.FormulateCreateTableStatement <Employee>(tableAttribute,
meta
);
con.Connection.Execute(employeeTable);
string alterStatement = @"
ALTER TABLE [dbo].[Employee]
DROP COLUMN XmlData;
ALTER TABLE [dbo].[Employee]
ADD [XmlData] XML NOT NULL;
ALTER TABLE [dbo].[Employee]
DROP COLUMN [Id];
ALTER TABLE [dbo].[Employee]
ADD [Id] INT NOT NULL IDENTITY(1,1);
ALTER TABLE [dbo].[Employee]
ADD CONSTRAINT PK_Employee PRIMARY KEY ([Id]);" ;
con.Connection.Execute(alterStatement);
}
string truncateStatement = @"
TRUNCATE TABLE [dbo].[Employee]
";
con.Connection.Execute(truncateStatement);
con.Commit();
}
}
public TrackableSetSqlMapper(ISqlProvider sqlProvider,
string tableName,
ColumnDefinition valueColumnDef,
ColumnDefinition[] headKeyColumnDefs = null)
{
_sqlProvider = sqlProvider;
_tableName = tableName;
_tableEscapedName = _sqlProvider.EscapeName(tableName);
var allColumns = new List <ColumnProperty>();
var headKeyColumns = new List <ColumnProperty>();
var primaryKeyColumns = new List <ColumnProperty>();
// add head key columns
if (headKeyColumnDefs != null)
{
foreach (var headKeyColumnDef in headKeyColumnDefs)
{
var column = new ColumnProperty(
name: headKeyColumnDef.Name,
escapedName: _sqlProvider.EscapeName(headKeyColumnDef.Name),
type: headKeyColumnDef.Type,
length: headKeyColumnDef.Length,
convertToSqlValue: _sqlProvider.GetConvertToSqlValueFunc(headKeyColumnDef.Type));
headKeyColumns.Add(column);
primaryKeyColumns.Add(column);
allColumns.Add(column);
}
}
// add value column
_valueColumn = new ColumnProperty(
name: valueColumnDef.Name,
escapedName: _sqlProvider.EscapeName(valueColumnDef.Name),
type: typeof(T),
length: valueColumnDef.Length,
convertToSqlValue: _sqlProvider.GetConvertToSqlValueFunc(typeof(T)),
convertFromDbValue: _sqlProvider.GetConvertFromDbValueFunc(typeof(T)));
primaryKeyColumns.Add(_valueColumn);
allColumns.Add(_valueColumn);
_allColumns = allColumns.ToArray();
_headKeyColumns = headKeyColumns.ToArray();
_allColumnString = string.Join(",", _allColumns.Select(c => c.EscapedName));
}
private static void BuildTrackablePocoProperty <TPoco>(ISqlProvider sqlProvider,
PropertyItem item,
object[] mapperParameters)
where TPoco : ITrackablePoco <TPoco>
{
if (mapperParameters.Length != 2)
{
throw new ArgumentException("The length of mapperParameters should be 2");
}
var mapper = new TrackablePocoSqlMapper <TPoco>(sqlProvider,
(string)mapperParameters[0],
(ColumnDefinition[])mapperParameters[1]);
item.Mapper = mapper;
item.BuildCreateTableSql = (dropIfExists) =>
{
return(mapper.BuildCreateTableSql(dropIfExists));
};
item.BuildSqlForCreate = (container, keyValues) =>
{
var value = (TPoco)item.PropertyInfo.GetValue(container);
return(value != null
? mapper.BuildSqlForCreate(value, keyValues)
: string.Empty);
};
item.BuildSqlForDelete = (keyValues) =>
{
return(mapper.BuildSqlForDelete(keyValues));
};
item.BuildSqlForLoad = (keyValues) =>
{
return(mapper.BuildSqlForLoad(keyValues));
};
item.LoadAndSetAsync = async(reader, container) =>
{
var value = await mapper.LoadAsync(reader);
item.PropertyInfo.SetValue(container, value);
return(value != null);
};
item.BuildSqlForSave = (tracker, keyValues) =>
{
var valueTracker = (TrackablePocoTracker <TPoco>)item.TrackerPropertyInfo.GetValue(tracker);
return(valueTracker.HasChange
? mapper.BuildSqlForSave(valueTracker, keyValues)
: string.Empty);
};
}
public TrackableSetValueWithHeadKeysTest(IDbConnectionProvider dbConnectionProvider, ISqlProvider sqlProvider)
: base(useDuplicateCheck: true)
{
_db = dbConnectionProvider;
_mapper = new TrackableSetSqlMapper<int>(
sqlProvider,
nameof(TrackableSetValueWithHeadKeysTest),
new ColumnDefinition("Value", typeof(int)),
new[]
{
new ColumnDefinition("Head1", typeof(int)),
new ColumnDefinition("Head2", typeof(string), 100)
});
_mapper.ResetTableAsync(_db.Connection).Wait();
}
public TrackableContainerIgnoreTest(IDbConnectionProvider dbConnectionProvider, ISqlProvider sqlProvider)
{
_db = dbConnectionProvider;
_mapper = new TrackableContainerSqlMapper<ITestContainerWithIgnore>(
sqlProvider,
new[]
{
Tuple.Create("Person", new object[]
{
"TrackableContainerIgnoreTestPerson",
new[] { new ColumnDefinition("ContainerId", typeof(int)) }
}),
});
_mapper.ResetTableAsync(_db.Connection, true).Wait();
}
///<summary>Creates a new DataSyncContext for the given DataContext.</summary>
public DataSyncContext(DataContext context, ISqlProvider sqlProvider)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (sqlProvider == null)
{
throw new ArgumentNullException("sqlProvider");
}
DataContext = context;
SqlProvider = sqlProvider;
Tables = new TableSynchronizerCollection(this);
}
private void Init(DbConnectionSchema schema, IDbConnection connection = null)
{
this._connectionSchema = schema;
this._factory = DbConnectorFactory.GetFactory(schema.ProviderName);
this._converter = DbConnectorFactory.Create(schema.ProviderName);
if (connection == null)
{
this._connection = this._factory.CreateConnection();
this._connection.ConnectionString = schema.ConnectionString;
this._connectionCreatedBySelf = true;
}
else
{
this._connection = connection;
}
}
/// <summary>
/// 创建指定的链接字符串的转换器
/// </summary>
/// <param name="provider">指定的数据库的提供程序</param>
/// <returns>返回针对指定数据库的 ISqlProvider 类型的具体对象实例</returns>
public static ISqlProvider Create(string provider)
{
//ISqlConverter Factory
switch (provider)
{
case DbSetting.Provider_Odbc:
if (_odbcConverter == null)
{
_odbcConverter = new ODBCProvider();
}
return(_odbcConverter);
case DbSetting.Provider_SqlClient:
case DbSetting.Provider_SqlCe:
case DbSetting.Provider_SQLite:
if (_sqlConverter == null)
{
_sqlConverter = new SqlServerProvider();
}
return(_sqlConverter);
//PatrickLiu 增加的有关 MySql 的代码
case DbSetting.Provider_MySql:
if (_mySqlConverter == null)
{
_mySqlConverter = new MySqlServerProvider();
}
return(_mySqlConverter);
default:
if (DbSetting.IsOracleProvider(provider))
{
if (_oracleConverter == null)
{
_oracleConverter = new OracleProvider();
}
return(_oracleConverter);
}
if (_sqlConverter == null)
{
_sqlConverter = new SqlServerProvider();
}
return(_sqlConverter);
}
}
public static ISqlProvider Create(string provider)
{
//ISqlConverter Factory
switch (provider)
{
case DbSetting.Provider_Oracle:
if (_oracleConverter == null) _oracleConverter = new OracleProvider();
return _oracleConverter;
case DbSetting.Provider_Odbc:
if (_odbcConverter == null) _odbcConverter = new ODBCProvider();
return _odbcConverter;
case DbSetting.Provider_SqlClient:
case DbSetting.Provider_SqlCe:
default:
if (_sqlConverter == null) _sqlConverter = new SqlServerProvider();
return _sqlConverter;
//throw new NotSupportedException("This type of database is not supportted now:" + provider);
}
}
internal void DoDelete(ISqlProvider provider)
{
for (int i = rows.Count - 1; i >= 0; i--)
{
rows[i].DoDelete(provider);
}
}
internal void DoWrite(ISqlProvider provider)
{
foreach (var row in rows)
{
row.DoWrite(provider);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AccumulativeAssertion"/> class.
/// </summary>
/// <param name="SqlProvider">The SQL provider.</param>
public AccumulativeAssertion(ISqlProvider SqlProvider)
{
this.sqlProvider = SqlProvider;
}
/// <summary>
/// Writes the data accumulated in this row to the database.
/// </summary>
public void DoWrite(ISqlProvider provider)
{
if (delete)
{
Delete(provider);
}
else
{
string statement = update ? GetUpdateStatement(provider.Vendor) : GetInsertStatement(provider.Vendor);
provider.ExecuteNonQuery(statement);
}
string appendableSql = GetSelectStatementForReturnValueCommand();
foreach (var command in _returnValueCommands)
{
command.SetValue(appendableSql, provider);
}
}
public SqlDriver(ISqlProvider sqlProvider, DbConnection connection)
{
var HeadKeyColumnDefs = new[] { new ColumnDefinition("Uid", typeof(int)) };
_userMapper = new TrackableContainerSqlMapper<IUser>(
MsSqlProvider.Instance,
new[]
{
Tuple.Create("Data", new object[]
{
"tblUser",
HeadKeyColumnDefs
}),
Tuple.Create("Items", new object[]
{
"tblItem",
new ColumnDefinition("ItemId"),
HeadKeyColumnDefs
}),
Tuple.Create("Teams", new object[]
{
"tblTeam",
new ColumnDefinition("TeamId"),
HeadKeyColumnDefs
}),
Tuple.Create("Tanks", new object[]
{
"tblTank",
new ColumnDefinition("TankId"),
HeadKeyColumnDefs
}),
Tuple.Create("Cards", new object[]
{
"tblCard",
new ColumnDefinition("GroupNo"),
new ColumnDefinition("States"),
HeadKeyColumnDefs
}),
Tuple.Create("Friends", new object[]
{
"tblFriend",
new ColumnDefinition("FriendUid"),
HeadKeyColumnDefs
}),
Tuple.Create("Missions", new object[]
{
"tblMission",
new ColumnDefinition("MissionId"),
HeadKeyColumnDefs
}),
Tuple.Create("StageGrades", new object[]
{
"tblStageGrade",
new ColumnDefinition("GroupNo"),
new ColumnDefinition("Grades"),
HeadKeyColumnDefs
}),
Tuple.Create("Posts", new object[]
{
"tblPost",
new ColumnDefinition("PostId"),
HeadKeyColumnDefs
}),
});
_connection = connection;
}
/// <summary>
/// Initializes a new instance of the <see cref="SqlBasedAccumulativeAssertion"/> class.
/// </summary>
/// <param name="SqlProvider">The SQL provider.</param>
public SqlBasedAccumulativeAssertion(ISqlProvider SqlProvider)
: base(SqlProvider)
{
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
//if (this._transaction != null)
//{
// this._transaction.Dispose();
//}
if (this._connectionCreatedBySelf && this._connection != null)
{
this._connection.Dispose();
}
this._connection = null;
this._converter = null;
this._factory = null;
//this._transaction = null;
}
}
private static SqlStatement BuildExpression(ISqlProvider sqlProvider, InputParameterExpression inputParameterExpression)
{
var alias = inputParameterExpression.Alias;
if (inputParameterExpression.IsMutiple)
{
var parameterss = ((IEnumerable) inputParameterExpression.GetValue()).Cast<object>();
var statements = parameterss.Select((p, id) =>
{
var nameBase = string.Format("{0}{1}", alias, id);
return new SqlStatement(new SqlParameterPart(sqlProvider.GetParameterName(nameBase), nameBase));
}).ToArray();
return new SqlStatement(sqlProvider.GetLiteral(statements));
}
return new SqlStatement(new SqlParameterPart(sqlProvider.GetParameterName(alias), alias));
}
/// <summary>
/// Initializes a new instance of the <see cref="ExecutableAdversary"/> class.
/// </summary>
/// <param name="SqlProvider">The SQL provider.</param>
/// <param name="tableName">Name of the table.</param>
public ExecutableAdversary(ISqlProvider SqlProvider, string tableName)
{
this.SqlProvider = SqlProvider;
this.tableName = tableName;
}
/// <summary>
/// Sets the value by querying the data base (through the given provider)
/// </summary>
/// <param name="appendableSelectStatement"></param>
/// <param name="provider"></param>
public void SetValue(string appendableSelectStatement, ISqlProvider provider)
{
string sql = string.Format(appendableSelectStatement, ColumnName);
var result = provider.ExecuteQuery(sql, SelectOptions.Single)[0];
Value = result.GetSingleResult();
}
private void Delete(ISqlProvider provider)
{
provider.ExecuteNonQuery(GetDeleteStatement());
}
/// <summary>
/// Initializes a new instance of the <see cref="AccumulativeAssertion"/> class.
/// </summary>
/// <param name="SqlProvider">The SQL provider.</param>
/// <param name="tableName">Name of the table.</param>
public AccumulativeAssertion(ISqlProvider SqlProvider, string tableName)
: this(SqlProvider)
{
TableName = tableName;
}
/// <summary>
/// Deletes the row from the database if it has been marked as
/// deletable through DeleteFirst()
/// </summary>
public void DoDelete(ISqlProvider provider)
{
if (deleteFirst)
{
Delete(provider);
}
}
private void Init(DbConnectionSchema schema, IDbConnection connection = null)
{
this._connectionSchema = schema;
this._factory = ConverterFactory.GetFactory(schema.ProviderName);
this._converter = ConverterFactory.Create(schema.ProviderName);
if (connection == null)
{
this._connection = this._factory.CreateConnection();
this._connection.ConnectionString = schema.ConnectionString;
this._connectionCreatedBySelf = true;
}
else
{
this._connection = connection;
}
}
protected TypeNullableTest(IDbConnectionProvider dbConnectionProvider, ISqlProvider sqlProvider)
{
_db = dbConnectionProvider;
_mapper = new TrackablePocoSqlMapper<ITypeNullableTestPoco>(sqlProvider, nameof(TypeNullableTest));
_mapper.ResetTableAsync(_db.Connection).Wait();
}
