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 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) { }