public virtual DbCommand Build([NotNull] RelationalConnection connection)
{
Check.NotNull(connection, "connection");
// TODO: Cache command...
var command = connection.DbConnection.CreateCommand();
if (connection.Transaction != null)
{
command.Transaction = connection.Transaction.DbTransaction;
}
var sqlGenerator = _relationalQueryCompilationContext.CreateSqlQueryGenerator();
command.CommandText = sqlGenerator.GenerateSql(_selectExpression);
foreach (var commandParameter in sqlGenerator.Parameters)
{
var parameter = command.CreateParameter();
parameter.ParameterName = commandParameter.Name;
parameter.Value = commandParameter.Value;
// TODO: Parameter facets
command.Parameters.Add(parameter);
}
return(command);
}
public Migrator(
[NotNull] HistoryRepository historyRepository,
[NotNull] MigrationAssembly migrationAssembly,
[NotNull] ModelDiffer modelDiffer,
[NotNull] IMigrationOperationSqlGeneratorFactory ddlSqlGeneratorFactory,
[NotNull] SqlGenerator dmlSqlGenerator,
[NotNull] SqlStatementExecutor sqlExecutor,
[NotNull] RelationalDataStoreCreator storeCreator,
[NotNull] RelationalConnection connection,
[NotNull] ILoggerFactory loggerFactory)
{
Check.NotNull(historyRepository, "historyRepository");
Check.NotNull(migrationAssembly, "migrationAssembly");
Check.NotNull(modelDiffer, "modelDiffer");
Check.NotNull(ddlSqlGeneratorFactory, "ddlSqlGeneratorFactory");
Check.NotNull(dmlSqlGenerator, "dmlSqlGenerator");
Check.NotNull(sqlExecutor, "sqlExecutor");
Check.NotNull(storeCreator, "storeCreator");
Check.NotNull(connection, "connection");
Check.NotNull(loggerFactory, "loggerFactory");
_historyRepository = historyRepository;
_migrationAssembly = migrationAssembly;
_modelDiffer = modelDiffer;
_ddlSqlGeneratorFactory = ddlSqlGeneratorFactory;
_dmlSqlGenerator = dmlSqlGenerator;
_sqlExecutor = sqlExecutor;
_storeCreator = storeCreator;
_connection = connection;
_logger = new DbContextService <ILogger>(loggerFactory.Create <Migrator>);
}
public FakeRelationalDataStore(
DbContextConfiguration configuration,
RelationalConnection connection,
CommandBatchPreparer batchPreparer,
BatchExecutor batchExecutor)
: base(configuration, connection, batchPreparer, batchExecutor)
{
}
protected virtual void ExecuteStatementsWithoutTransaction(
[NotNull] IEnumerable <SqlBatch> sqlStatements, [NotNull] RelationalConnection connection)
{
Check.NotNull(sqlStatements, "sqlStatements");
Check.NotNull(connection, "connection");
SqlExecutor.ExecuteNonQuery(connection, null, sqlStatements);
}
private Tuple <RelationalConnection, string> PrepareCommand(RelationalConnection connection)
{
// TODO: Parameterize query and/or delimit identifier without using SqlServerMigrationOperationSqlGenerator
var sql = string.Format(
CultureInfo.InvariantCulture,
"SELECT NEXT VALUE FOR {0}", SequenceName);
return(Tuple.Create(connection, sql));
}
public virtual async Task <int> ExecuteAsync(
[NotNull] IEnumerable <ModificationCommandBatch> commandBatches,
[NotNull] RelationalConnection connection,
CancellationToken cancellationToken = default(CancellationToken))
{
Check.NotNull(commandBatches, "commandBatches");
Check.NotNull(connection, "connection");
var rowsAffected = 0;
await connection.OpenAsync(cancellationToken).ConfigureAwait(false);
RelationalTransaction startedTransaction = null;
try
{
if (connection.Transaction == null)
{
startedTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
rowsAffected += await commandbatch.ExecuteAsync(
connection.Transaction,
_typeMapper,
_context,
Logger,
cancellationToken : cancellationToken)
.ConfigureAwait(false);
}
if (startedTransaction != null)
{
startedTransaction.Commit();
}
}
catch
{
if (connection.Transaction != null)
{
connection.Transaction.Rollback();
}
throw;
}
finally
{
if (startedTransaction != null)
{
startedTransaction.Dispose();
}
connection.Close();
}
return(rowsAffected);
}
public AsyncEnumerable(
RelationalConnection connection,
CommandBuilder commandBuilder,
Func <DbDataReader, T> shaper,
ILogger logger)
{
_connection = connection;
_commandBuilder = commandBuilder;
_shaper = shaper;
_logger = logger;
}
public AsyncEnumerable(
RelationalConnection connection,
string sql,
Func <DbDataReader, T> shaper,
ILogger logger)
{
_connection = connection;
_sql = sql;
_shaper = shaper;
_logger = logger;
}
public virtual int Execute(
[NotNull] IEnumerable <ModificationCommandBatch> commandBatches,
[NotNull] RelationalConnection connection)
{
Check.NotNull(commandBatches, "commandBatches");
Check.NotNull(connection, "connection");
var rowsAffected = 0;
connection.Open();
RelationalTransaction startedTransaction = null;
try
{
if (connection.Transaction == null)
{
startedTransaction = connection.BeginTransaction();
}
foreach (var commandbatch in commandBatches)
{
rowsAffected += commandbatch.Execute(
connection.Transaction,
_typeMapper,
_context,
Logger);
}
if (startedTransaction != null)
{
startedTransaction.Commit();
}
}
catch
{
if (connection.Transaction != null)
{
connection.Transaction.Rollback();
}
throw;
}
finally
{
if (startedTransaction != null)
{
startedTransaction.Dispose();
}
connection.Close();
}
return(rowsAffected);
}
public BatchExecutor(
[NotNull] SqlGenerator sqlGenerator,
[NotNull] RelationalConnection connection,
[NotNull] RelationalTypeMapper typeMapper)
{
Check.NotNull(sqlGenerator, "sqlGenerator");
Check.NotNull(connection, "connection");
Check.NotNull(typeMapper, "typeMapper");
_sqlGenerator = sqlGenerator;
_connection = connection;
_typeMapper = typeMapper;
}
public RelationalTransaction([NotNull] RelationalConnection connection, [NotNull] DbTransaction dbTransaction, bool transactionOwned)
{
Check.NotNull(connection, "connection");
Check.NotNull(dbTransaction, "dbTransaction");
if (connection.DbConnection != dbTransaction.Connection)
{
throw new InvalidOperationException(Strings.FormatTransactionAssociatedWithDifferentConnection());
}
_connection = connection;
_dbTransaction = dbTransaction;
_transactionOwned = transactionOwned;
}
public RelationalQueryContext(
[NotNull] IModel model,
[NotNull] ILogger logger,
[NotNull] StateManager stateManager,
[NotNull] RelationalConnection connection,
[NotNull] RelationalValueReaderFactory valueReaderFactory)
: base(model, logger, stateManager)
{
Check.NotNull(connection, "connection");
Check.NotNull(valueReaderFactory, "valueReaderFactory");
_connection = connection;
_valueReaderFactory = valueReaderFactory;
}
public RelationalQueryContext(
[NotNull] IModel model,
[NotNull] ILogger logger,
[NotNull] StateManager stateManager,
[NotNull] RelationalConnection connection,
[NotNull] RelationalValueReaderFactory valueReaderFactory)
: base(model, logger, stateManager)
{
Check.NotNull(connection, "connection");
Check.NotNull(valueReaderFactory, "valueReaderFactory");
_connection = connection;
_valueReaderFactory = valueReaderFactory;
}
public FakeRelationalDataStore(
StateManager stateManager,
DbContextService <IModel> model,
EntityKeyFactorySource entityKeyFactorySource,
EntityMaterializerSource entityMaterializerSource,
ClrCollectionAccessorSource collectionAccessorSource,
ClrPropertySetterSource propertySetterSource,
RelationalConnection connection,
CommandBatchPreparer batchPreparer,
BatchExecutor batchExecutor,
ILoggerFactory loggerFactory)
: base(stateManager, model, entityKeyFactorySource, entityMaterializerSource,
collectionAccessorSource, propertySetterSource, connection, batchPreparer, batchExecutor, loggerFactory)
{
}
public RelationalQueryContext(
[NotNull] ILogger logger,
[NotNull] IQueryBuffer queryBuffer,
[NotNull] RelationalConnection connection,
[NotNull] RelationalValueReaderFactory valueReaderFactory)
: base(
Check.NotNull(logger, "logger"),
Check.NotNull(queryBuffer, "queryBuffer"))
{
Check.NotNull(connection, "connection");
Check.NotNull(valueReaderFactory, "valueReaderFactory");
Connection = connection;
ValueReaderFactory = valueReaderFactory;
}
public QueryingEnumerable(
[NotNull] RelationalConnection connection,
[NotNull] CommandBuilder commandBuilder,
[NotNull] Func <DbDataReader, T> shaper,
[NotNull] ILogger logger)
{
Check.NotNull(connection, "connection");
Check.NotNull(connection, "commandBuilder");
Check.NotNull(connection, "shaper");
Check.NotNull(connection, "logger");
_connection = connection;
_commandBuilder = commandBuilder;
_shaper = shaper;
_logger = logger;
}
private static void CreateDatabaseSequence(BronieContext context, RelationalConnection storeConnection)
{
var executor = new SqlStatementExecutor();
var operations = new SqlServerSequenceValueGeneratorFactory(executor)
.GetUpMigrationOperations(context.Model.GetEntityType(typeof(Pegasus))
.GetProperty("Identifier"));
var sql = new SqlServerMigrationOperationSqlGenerator(new SqlServerTypeMapper())
.Generate(operations, generateIdempotentSql: false);
// TODO: Should be able to get relational connection without cast
var connection = storeConnection.DbConnection;
executor.ExecuteNonQuery(connection, sql);
}
protected virtual void ExecuteStatementsWithinTransaction(
[NotNull] IEnumerable <SqlBatch> sqlStatements, [NotNull] RelationalConnection connection)
{
Check.NotNull(sqlStatements, "sqlStatements");
Check.NotNull(connection, "connection");
RelationalTransaction transaction = null;
try
{
transaction = connection.BeginTransaction(IsolationLevel.Serializable);
SqlExecutor.ExecuteNonQuery(connection, transaction.DbTransaction, sqlStatements);
transaction.Commit();
}
finally
{
if (transaction != null)
{
transaction.Dispose();
}
}
}
public override Task ExecuteNonQueryAsync(RelationalConnection connection, DbTransaction transaction, IEnumerable <SqlBatch> sqlBatches, CancellationToken cancellationToken = new CancellationToken())
{
return(Task.FromResult(0));
}
public override Task <object> ExecuteScalarAsync(
RelationalConnection connection, DbTransaction transaction, string sql, CancellationToken cancellationToken = new CancellationToken())
{
return(Task.FromResult <object>(Interlocked.Add(ref _current, _blockSize)));
}
public override void ExecuteNonQuery(RelationalConnection connection, DbTransaction transaction, IEnumerable <SqlBatch> statements)
{
_nonQueries.Add(Tuple.Create(connection, transaction, statements.Select(s => s.Sql).ToArray()));
base.ExecuteNonQuery(connection, transaction, statements);
}
public override object ExecuteScalar(RelationalConnection connection, DbTransaction transaction, string sql)
{
return(Interlocked.Add(ref _current, _blockSize));
}
public override void ExecuteNonQuery(RelationalConnection connection, DbTransaction transaction, IEnumerable <SqlBatch> sqlBatches)
{
}
