public bool CommandExecuting(DbCommand command, DbInterceptionContext interceptionContext) { if (interceptionContext.DbContexts.Contains(_context, ReferenceEquals)) { _commands.Add(command); return false; // cancel execution } return true; }
internal override DbCommandDefinition CreateDbCommandDefinition( DbProviderManifest providerManifest, DbCommandTree commandTree, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(providerManifest); DebugCheck.NotNull(commandTree); DebugCheck.NotNull(interceptionContext); var storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace); return CreateCommandDefinition(storeMetadata.ProviderFactory, commandTree, interceptionContext); }
internal static EntityCommandDefinition CreateCommandDefinition( DbProviderFactory storeProviderFactory, DbCommandTree commandTree, DbInterceptionContext interceptionContext, IDbDependencyResolver resolver = null) { DebugCheck.NotNull(storeProviderFactory); DebugCheck.NotNull(interceptionContext); DebugCheck.NotNull(commandTree); return new EntityCommandDefinition(storeProviderFactory, commandTree, interceptionContext, resolver); }
/// <inheritdoc /> public string ResolveManifestToken(DbConnection connection) { Check.NotNull(connection, "connection"); var interceptionContext = new DbInterceptionContext(); var key = Tuple.Create(connection.GetType(), DbInterception.Dispatch.Connection.GetDataSource(connection, interceptionContext), DbInterception.Dispatch.Connection.GetDatabase(connection, interceptionContext)); return _cachedTokens.GetOrAdd( key, k => DbProviderServices.GetProviderServices(connection).GetProviderManifestTokenChecked(connection)); }
public void ExecuteScalar_should_dispatch_to_interceptor_and_optionally_execute() { var mockCommand = new Mock <DbCommand>(); mockCommand.Setup(m => m.ExecuteScalar()).Returns(11); var mockCancelable = new Mock <ICancelableDbCommandInterceptor>(); var mockPublicInterceptor = new Mock <DbInterceptor> { CallBase = true }; var dispatchers = new Dispatchers(); dispatchers.AddInterceptor(mockCancelable.Object); dispatchers.AddInterceptor(mockPublicInterceptor.Object); var interceptionContext = new DbInterceptionContext(); var interceptableDbCommand = new InterceptableDbCommand(mockCommand.Object, interceptionContext, dispatchers); mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, interceptionContext)).Returns(false); interceptableDbCommand.ExecuteScalar(); mockCommand.Verify(m => m.ExecuteScalar(), Times.Never()); mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Once()); mockPublicInterceptor.Verify( m => m.ScalarExecuting(It.IsAny <DbCommand>(), It.IsAny <DbInterceptionContext>()), Times.Never()); mockPublicInterceptor.Verify( m => m.ScalarExecuted(It.IsAny <DbCommand>(), It.IsAny <int>(), It.IsAny <DbInterceptionContext>()), Times.Never()); mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, interceptionContext)).Returns(true); Assert.Equal(11, interceptableDbCommand.ExecuteScalar()); mockCommand.Verify(m => m.ExecuteScalar(), Times.Once()); mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Exactly(2)); mockPublicInterceptor.Verify( m => m.ScalarExecuting(mockCommand.Object, interceptionContext), Times.Once()); mockPublicInterceptor.Verify( m => m.ScalarExecuted(mockCommand.Object, 11, interceptionContext), Times.Once()); }
private InterceptableDbCommand ConfigureCommand(DbCommand command, string commandText) { command.CommandText = commandText; if (_configuration.CommandTimeout.HasValue) { command.CommandTimeout = _configuration.CommandTimeout.Value; } var interceptionContext = new DbInterceptionContext(); if (_contextForInterception != null) { interceptionContext = interceptionContext.WithDbContext(_contextForInterception); } return(new InterceptableDbCommand(command, interceptionContext)); }
private static void setBaseInfo(DbInterceptionContext interceptionContext, DbContextBase info) { if (interceptionContext.ObjectContexts == null || !interceptionContext.ObjectContexts.Any()) { return; } var context = interceptionContext.ObjectContexts.First(); //todo: ?? info.ObjectContextId = UniqueIdExtensions <ObjectContext> .GetUniqueId(context).ToInt(); info.ObjectContextName = context.DefaultContainerName; if (context.TransactionHandler != null && context.TransactionHandler.Connection != null) { info.ConnectionId = UniqueIdExtensions <DbConnection> .GetUniqueId(context.TransactionHandler.Connection).ToInt(); } }
internal EntityCommand(DbInterceptionContext interceptionContext, EntityDataReaderFactory factory) { DebugCheck.NotNull(interceptionContext); // Initalize the member field with proper default values _designTimeVisible = true; _commandType = CommandType.Text; _updatedRowSource = UpdateRowSource.Both; _parameters = new EntityParameterCollection(); _interceptionContext = interceptionContext; // Future Enhancement: (See SQLPT #300004256) At some point it would be // really nice to read defaults from a global configuration, but we're not // doing that today. _enableQueryPlanCaching = true; _entityDataReaderFactory = factory ?? new EntityDataReaderFactory(); }
private void UpdateToSlave(DbCommand command, DbInterceptionContext interceptionContext) { var isDistributedTran = null != Transaction.Current && Transaction.Current.TransactionInformation.Status != TransactionStatus.Committed; foreach (var context in interceptionContext.DbContexts) { var isDbTran = null != context.Database.CurrentTransaction; var isCommandTran = null != command.Transaction; var isTrans = isDistributedTran || isDbTran || isCommandTran; var connectionString = isTrans ? MasterConnectionString : SlaveConnectionString; UpdateConnectionStringIfNeed(context.Database.Connection, connectionString); } }
internal override void ExecuteSql( MigrationStatement migrationStatement, DbConnection connection, DbTransaction transaction, DbInterceptionContext interceptionContext) { this._logger.Verbose(migrationStatement.Sql); DbProviderServices.GetProviderServices(connection)?.RegisterInfoMessageHandler(connection, (Action <string>)(message => { if (string.Equals(message, this._lastInfoMessage, StringComparison.OrdinalIgnoreCase)) { return; } this._logger.Warning(message); this._lastInfoMessage = message; })); base.ExecuteSql(migrationStatement, connection, transaction, interceptionContext); }
internal override void ExecuteSql( MigrationStatement migrationStatement, DbConnection connection, DbTransaction transaction, DbInterceptionContext interceptionContext) { if (string.IsNullOrWhiteSpace(migrationStatement.Sql)) { return; } using (InterceptableDbCommand interceptableDbCommand = this.ConfigureCommand(connection.CreateCommand(), migrationStatement.Sql, interceptionContext)) { if (transaction != null) { interceptableDbCommand.Transaction = transaction; } interceptableDbCommand.ExecuteNonQuery(); } }
/// <summary> /// Executes the future queries. /// </summary> /// <param name="context">The <see cref="ObjectContext" /> to run the queries against.</param> /// <param name="futureQueries">The future queries list.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns></returns> public async Task ExecuteFutureQueriesAsync(ObjectContext context, IList <IFutureQuery> futureQueries, CancellationToken cancellationToken = default(CancellationToken)) { if (context == null) { throw new ArgumentNullException("context"); } if (futureQueries == null) { throw new ArgumentNullException("futureQueries"); } // used to call internal methods dynamic contextProxy = new DynamicProxy(context); contextProxy.EnsureConnection(false); //the (internal) InterceptionContext contains the registered loggers DbInterceptionContext interceptionContext = contextProxy.InterceptionContext; try { using (var command = CreateFutureCommand(context, futureQueries)) using (var reader = await DbInterception.Dispatch.Command.ReaderAsync( command, new DbCommandInterceptionContext(interceptionContext), cancellationToken ) .ConfigureAwait(false) ) { foreach (var futureQuery in futureQueries) { await futureQuery.SetResultAsync(context, reader, cancellationToken).ConfigureAwait(false); await reader.NextResultAsync(cancellationToken).ConfigureAwait(false); } } } finally { contextProxy.ReleaseConnection(); // once all queries processed, clear from queue futureQueries.Clear(); } }
// <summary> // Internal constructor used by EntityCommandDefinition // </summary> // <param name="commandDefinition"> The prepared command definition that can be executed using this EntityCommand </param> internal EntityCommand(EntityCommandDefinition commandDefinition, DbInterceptionContext context, EntityDataReaderFactory factory = null) : this(context, factory) { // Assign other member fields from the parameters _commandDefinition = commandDefinition; _parameters = new EntityParameterCollection(); // Make copies of the parameters foreach (var parameter in commandDefinition.Parameters) { _parameters.Add(parameter.Clone()); } // Reset the dirty flag that was set to true when the parameters were added so that it won't say // it's dirty to start with _parameters.ResetIsDirty(); // Track the fact that this command was created from and represents an already prepared command definition _isCommandDefinitionBased = true; }
/// <summary> /// Executes the future queries. /// </summary> /// <param name="context">The <see cref="ObjectContext" /> to run the queries against.</param> /// <param name="futureQueries">The future queries list.</param> public void ExecuteFutureQueries(ObjectContext context, IList <IFutureQuery> futureQueries) { if (context == null) { throw new ArgumentNullException("context"); } if (futureQueries == null) { throw new ArgumentNullException("futureQueries"); } // used to call internal methods dynamic contextProxy = new DynamicProxy(context); contextProxy.EnsureConnection(false); //the (internal) InterceptionContext contains the registered loggers DbInterceptionContext interceptionContext = contextProxy.InterceptionContext; try { using (var command = CreateFutureCommand(context, futureQueries)) using ( var reader = DbInterception.Dispatch.Command.Reader(command, new DbCommandInterceptionContext(interceptionContext))) { foreach (var futureQuery in futureQueries) { futureQuery.SetResult(context, reader); reader.NextResult(); } } } finally { contextProxy.ReleaseConnection(); // once all queries processed, clear from queue futureQueries.Clear(); } }
internal void Create(DatabaseExistenceState existenceState) { using (var clonedObjectContext = _internalContext.CreateObjectContextForDdlOps()) { if (existenceState == DatabaseExistenceState.Unknown) { if (_internalContext.DatabaseOperations.Exists(clonedObjectContext.ObjectContext)) { var interceptionContext = new DbInterceptionContext(); interceptionContext = interceptionContext.WithDbContext(_internalContext.Owner); interceptionContext = interceptionContext.WithObjectContext(clonedObjectContext.ObjectContext); throw Error.Database_DatabaseAlreadyExists( DbInterception.Dispatch.Connection.GetDatabase(_internalContext.Connection, interceptionContext)); } existenceState = DatabaseExistenceState.DoesNotExist; } _internalContext.CreateDatabase(clonedObjectContext.ObjectContext, existenceState); } }
private void ExecuteStatementsInternal( IEnumerable <MigrationStatement> migrationStatements, DbConnection connection) { DbContext context = this._usersContext ?? this._usersContextInfo.CreateInstance(); DbInterceptionContext interceptionContext = new DbInterceptionContext().WithDbContext(context); TransactionHandler transactionHandler = (TransactionHandler)null; try { if (DbInterception.Dispatch.Connection.GetState(connection, interceptionContext) == ConnectionState.Broken) { DbInterception.Dispatch.Connection.Close(connection, interceptionContext); } if (DbInterception.Dispatch.Connection.GetState(connection, interceptionContext) == ConnectionState.Closed) { DbInterception.Dispatch.Connection.Open(connection, interceptionContext); } if (!(context is TransactionContext)) { Func <TransactionHandler> service = DbConfiguration.DependencyResolver.GetService <Func <TransactionHandler> >((object)new ExecutionStrategyKey(DbConfiguration.DependencyResolver.GetService <IProviderInvariantName>((object)DbProviderServices.GetProviderFactory(connection)).Name, DbInterception.Dispatch.Connection.GetDataSource(connection, interceptionContext))); if (service != null) { transactionHandler = service(); transactionHandler.Initialize(context, connection); } } this.ExecuteStatementsInternal(migrationStatements, connection, interceptionContext); this._committedStatements = true; } finally { transactionHandler?.Dispose(); if (this._usersContext == null) { context.Dispose(); } } }
private void ExecuteStatementsWithinNewTransaction( IEnumerable <MigrationStatement> migrationStatements, DbConnection connection, DbInterceptionContext interceptionContext) { BeginTransactionInterceptionContext interceptionContext1 = new BeginTransactionInterceptionContext(interceptionContext).WithIsolationLevel(IsolationLevel.Serializable); DbTransaction transaction = (DbTransaction)null; try { transaction = DbInterception.Dispatch.Connection.BeginTransaction(connection, interceptionContext1); this.ExecuteStatementsWithinTransaction(migrationStatements, transaction, interceptionContext); DbInterception.Dispatch.Transaction.Commit(transaction, interceptionContext); } finally { if (transaction != null) { DbInterception.Dispatch.Transaction.Dispose(transaction, interceptionContext); } } }
public void InterceptionContext_can_be_set_in_constructors() { var interceptionContext = new DbInterceptionContext(); Assert.Same(interceptionContext, new EntityCommand(interceptionContext).InterceptionContext); Assert.Same( interceptionContext, new EntityCommand(interceptionContext, new EntityCommand.EntityDataReaderFactory()).InterceptionContext); var mockCommandDef = new Mock <EntityCommandDefinition>(); mockCommandDef.Setup(m => m.Parameters).Returns(Enumerable.Empty <EntityParameter>); Assert.Same( interceptionContext, new EntityCommand( mockCommandDef.Object, interceptionContext, new EntityCommand.EntityDataReaderFactory()).InterceptionContext); Assert.Same( interceptionContext, new EntityCommand("12", interceptionContext, new EntityCommand.EntityDataReaderFactory()).InterceptionContext); }
private void ExecuteStatementsWithinNewTransaction( IEnumerable<MigrationStatement> migrationStatements, DbConnection connection, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(migrationStatements); DebugCheck.NotNull(connection); var beginTransactionInterceptionContext = new BeginTransactionInterceptionContext(interceptionContext) .WithIsolationLevel(IsolationLevel.Serializable); DbTransaction transaction = null; try { transaction = DbInterception.Dispatch.Connection.BeginTransaction( connection, beginTransactionInterceptionContext); ExecuteStatementsWithinTransaction(migrationStatements, transaction, interceptionContext); DbInterception.Dispatch.Transaction.Commit(transaction, interceptionContext); } finally { if (transaction != null) { DbInterception.Dispatch.Transaction.Dispose(transaction, interceptionContext); } } }
private void ExecuteStatementsInternal( IEnumerable<MigrationStatement> migrationStatements, DbConnection connection, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(migrationStatements); DebugCheck.NotNull(connection); var pendingStatements = new List<MigrationStatement>(); foreach (var statement in migrationStatements.Where(s => !string.IsNullOrEmpty(s.Sql))) { if (!statement.SuppressTransaction) { pendingStatements.Add(statement); continue; } if (pendingStatements.Any()) { ExecuteStatementsWithinNewTransaction(pendingStatements, connection, interceptionContext); pendingStatements.Clear(); } base.ExecuteSql(statement, connection, null, interceptionContext); } if (pendingStatements.Any()) { ExecuteStatementsWithinNewTransaction(pendingStatements, connection, interceptionContext); } }
internal DbMigrator(DbMigrationsConfiguration configuration, DbContext usersContext, DatabaseExistenceState existenceState, bool calledByCreateDatabase) : base(null) { Check.NotNull(configuration, "configuration"); Check.NotNull(configuration.ContextType, "configuration.ContextType"); _configuration = configuration; _calledByCreateDatabase = calledByCreateDatabase; _existenceState = existenceState; if (usersContext != null) { _usersContextInfo = new DbContextInfo(usersContext); } else { _usersContextInfo = configuration.TargetDatabase == null ? new DbContextInfo(configuration.ContextType) : new DbContextInfo(configuration.ContextType, configuration.TargetDatabase); if (!_usersContextInfo.IsConstructible) { throw Error.ContextNotConstructible(configuration.ContextType); } } _modelDiffer = _configuration.ModelDiffer; var context = usersContext ?? _usersContextInfo.CreateInstance(); _usersContext = context; try { _migrationAssembly = new MigrationAssembly( _configuration.MigrationsAssembly, _configuration.MigrationsNamespace); _currentModel = context.GetModel(); _connection = context.Database.Connection; _providerFactory = DbProviderServices.GetProviderFactory(_connection); _defaultSchema = context.InternalContext.DefaultSchema ?? EdmModelExtensions.DefaultSchema; _historyContextFactory = _configuration .GetHistoryContextFactory(_usersContextInfo.ConnectionProviderName); _historyRepository = new HistoryRepository( context.InternalContext, _usersContextInfo.ConnectionString, _providerFactory, _configuration.ContextKey, _configuration.CommandTimeout, _historyContextFactory, schemas: new[] { _defaultSchema }.Concat(GetHistorySchemas()), contextForInterception: _usersContext, initialExistence: _existenceState); _providerManifestToken = context.InternalContext.ModelProviderInfo != null ? context.InternalContext.ModelProviderInfo.ProviderManifestToken : DbConfiguration .DependencyResolver .GetService<IManifestTokenResolver>() .ResolveManifestToken(_connection); var modelBuilder = context.InternalContext.CodeFirstModel.CachedModelBuilder; _modificationCommandTreeGenerator = new Lazy<ModificationCommandTreeGenerator>( () => new ModificationCommandTreeGenerator( modelBuilder.BuildDynamicUpdateModel( new DbProviderInfo( _usersContextInfo.ConnectionProviderName, _providerManifestToken)), CreateConnection())); var interceptionContext = new DbInterceptionContext(); interceptionContext = interceptionContext.WithDbContext(_usersContext); _targetDatabase = Strings.LoggingTargetDatabaseFormat( DbInterception.Dispatch.Connection.GetDataSource(_connection, interceptionContext), DbInterception.Dispatch.Connection.GetDatabase(_connection, interceptionContext), _usersContextInfo.ConnectionProviderName, _usersContextInfo.ConnectionStringOrigin == DbConnectionStringOrigin.DbContextInfo ? Strings.LoggingExplicit : _usersContextInfo.ConnectionStringOrigin.ToString()); _legacyContextKey = context.InternalContext.DefaultContextKey; _emptyModel = GetEmptyModel(); } finally { if (usersContext == null) { _usersContext = null; context.Dispose(); } } }
public InternalConnection(DbInterceptionContext interceptionContext) { InterceptionContext = interceptionContext ?? new DbInterceptionContext(); }
public bool ConnectionOpening(EntityConnection connection, DbInterceptionContext interceptionContext) { return(!interceptionContext.DbContexts.Contains(_context, ReferenceEquals)); }
protected override void DbCreateDatabase(DbConnection connection, int? timeOut, StoreItemCollection storeItemCollection) { Check.NotNull(connection, "connection"); Check.NotNull(storeItemCollection, "storeItemCollection"); // Validate that connection is a SqlCeConnection. ValidateConnection(connection); // We don't support create/delete database operations inside a transaction as they can't be rolled back. if (InTransactionScope()) { throw ADP1.CreateDatabaseNotAllowedWithinTransaction(); } if (_isLocalProvider) { var engine = new SqlCeEngine(DbInterception.Dispatch.Connection.GetConnectionString(connection, new DbInterceptionContext())); engine.CreateDatabase(); engine.Dispose(); } else { try { Type rdpType; // If we are working with RDP, then we will need to invoke the APIs through reflection. var engine = RemoteProviderHelper.GetRemoteSqlCeEngine( DbInterception.Dispatch.Connection.GetConnectionString(connection, new DbInterceptionContext()), out rdpType); Debug.Assert(engine != null); // Invoke the required method on SqlCeEngine. var mi = rdpType.GetMethod("CreateDatabase", new[] { typeof(int?) }); Debug.Assert(mi != null); // We will pass 'timeout' to RDP, this will be used as timeout period for connecting and executing on TDSServer. mi.Invoke(engine, new object[] { timeOut }); } catch (Exception e) { throw e.GetBaseException(); } } // Create the command object depending on provider. var command = connection.CreateCommand(); // Create the command texts from StoreItemCollection. var commandTextCollection = SqlDdlBuilder.CreateObjectsScript(storeItemCollection, false); DbTransaction transaction = null; var interceptionContext = new DbInterceptionContext(); try { // Open the connection. DbInterception.Dispatch.Connection.Open(connection, interceptionContext); // Open a transaction and attach to the command. transaction = DbInterception.Dispatch.Connection.BeginTransaction(connection, new BeginTransactionInterceptionContext()); command.Transaction = transaction; // Execute each statement. foreach (var text in commandTextCollection) { command.CommandText = text; DbInterception.Dispatch.Command.NonQuery(command, new DbCommandInterceptionContext()); } // Commit the transaction. DbInterception.Dispatch.Transaction.Commit(transaction, interceptionContext); } catch (Exception e) { if (transaction != null) { // Rollback the transaction. DbInterception.Dispatch.Transaction.Rollback(transaction, interceptionContext); } // Throw IOE with SqlCeException embedded as inner exception. throw new InvalidOperationException(EntityRes.GetString(EntityRes.IncompleteDatabaseCreation), e); } finally { // Close connection and cleanup objects. if (command != null) { command.Dispose(); } if (transaction != null) { DbInterception.Dispatch.Transaction.Dispose(transaction, interceptionContext); } if (connection != null) { DbInterception.Dispatch.Connection.Close(connection, interceptionContext); } } }
public void ExecuteReaderAsync_should_dispatch_to_interceptor_and_optionally_execute() { var result = Task.FromResult(new Mock <DbDataReader>().Object); var mockCommand = new Mock <DbCommand>(); mockCommand.Protected() .Setup <Task <DbDataReader> >( "ExecuteDbDataReaderAsync", CommandBehavior.SingleRow, ItExpr.IsAny <CancellationToken>()) .Returns(result); var mockCancelable = new Mock <ICancelableDbCommandInterceptor>(); var mockPublicInterceptor = new Mock <DbCommandInterceptor> { CallBase = true }; var dispatchers = new Dispatchers(); dispatchers.AddInterceptor(mockCancelable.Object); dispatchers.AddInterceptor(mockPublicInterceptor.Object); var interceptionContext = new DbInterceptionContext(); var interceptableDbCommand = new InterceptableDbCommand(mockCommand.Object, interceptionContext, dispatchers); mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, It.IsAny <DbInterceptionContext>())).Returns(false); Assert.NotSame(result, interceptableDbCommand.ExecuteReaderAsync(CommandBehavior.SingleRow)); mockCommand.Protected().Verify( "ExecuteDbDataReaderAsync", Times.Never(), CommandBehavior.SingleRow, ItExpr.IsAny <CancellationToken>()); mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Once()); mockPublicInterceptor.Verify( m => m.ReaderExecuting( It.IsAny <DbCommand>(), It.IsAny <DbCommandInterceptionContext <DbDataReader> >()), Times.Never()); mockPublicInterceptor.Verify( m => m.ReaderExecuted( It.IsAny <DbCommand>(), It.IsAny <DbCommandInterceptionContext <DbDataReader> >()), Times.Never()); mockCancelable.Setup(m => m.CommandExecuting(mockCommand.Object, It.IsAny <DbInterceptionContext>())).Returns(true); var interceptResult = interceptableDbCommand.ExecuteReaderAsync(CommandBehavior.SingleRow); interceptResult.Wait(); Assert.Same(result.Result, interceptResult.Result); mockCommand.Protected().Verify( "ExecuteDbDataReaderAsync", Times.Once(), CommandBehavior.SingleRow, ItExpr.IsAny <CancellationToken>()); mockCancelable.Verify(m => m.CommandExecuting(mockCommand.Object, interceptionContext), Times.Exactly(2)); mockPublicInterceptor.Verify( m => m.ReaderExecuting( mockCommand.Object, It.Is <DbCommandInterceptionContext <DbDataReader> >(c => c.IsAsync && c.CommandBehavior == CommandBehavior.SingleRow)), Times.Once()); mockPublicInterceptor.Verify( m => m.ReaderExecuted( mockCommand.Object, It.Is <DbCommandInterceptionContext <DbDataReader> >( c => c.IsAsync && c.CommandBehavior == CommandBehavior.SingleRow && c.Result == result.Result)), Times.Once()); }
internal virtual DbCommand CreateCommand(DbCommandTree commandTree, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(commandTree); DebugCheck.NotNull(interceptionContext); var commandDefinition = CreateCommandDefinition(commandTree, interceptionContext); var command = commandDefinition.CreateCommand(); return command; }
protected override void DbCreateDatabase(DbConnection connection, int?timeOut, StoreItemCollection storeItemCollection) { Check.NotNull(connection, "connection"); Check.NotNull(storeItemCollection, "storeItemCollection"); // Validate that connection is a SqlCeConnection. ValidateConnection(connection); // We don't support create/delete database operations inside a transaction as they can't be rolled back. if (InTransactionScope()) { throw ADP1.CreateDatabaseNotAllowedWithinTransaction(); } if (_isLocalProvider) { var engine = new SqlCeEngine(DbInterception.Dispatch.Connection.GetConnectionString(connection, new DbInterceptionContext())); engine.CreateDatabase(); engine.Dispose(); } else { try { Type rdpType; // If we are working with RDP, then we will need to invoke the APIs through reflection. var engine = RemoteProviderHelper.GetRemoteSqlCeEngine( DbInterception.Dispatch.Connection.GetConnectionString(connection, new DbInterceptionContext()), out rdpType); Debug.Assert(engine != null); // Invoke the required method on SqlCeEngine. var mi = rdpType.GetMethod("CreateDatabase", new[] { typeof(int?) }); Debug.Assert(mi != null); // We will pass 'timeout' to RDP, this will be used as timeout period for connecting and executing on TDSServer. mi.Invoke(engine, new object[] { timeOut }); } catch (Exception e) { throw e.GetBaseException(); } } // Create the command object depending on provider. var command = connection.CreateCommand(); // Create the command texts from StoreItemCollection. var commandTextCollection = SqlDdlBuilder.CreateObjectsScript(storeItemCollection, false); DbTransaction transaction = null; var interceptionContext = new DbInterceptionContext(); try { // Open the connection. DbInterception.Dispatch.Connection.Open(connection, interceptionContext); // Open a transaction and attach to the command. transaction = DbInterception.Dispatch.Connection.BeginTransaction(connection, new BeginTransactionInterceptionContext()); command.Transaction = transaction; // Execute each statement. foreach (var text in commandTextCollection) { command.CommandText = text; DbInterception.Dispatch.Command.NonQuery(command, new DbCommandInterceptionContext()); } // Commit the transaction. DbInterception.Dispatch.Transaction.Commit(transaction, interceptionContext); } catch (Exception e) { if (transaction != null) { // Rollback the transaction. DbInterception.Dispatch.Transaction.Rollback(transaction, interceptionContext); } // Throw IOE with SqlCeException embedded as inner exception. throw new InvalidOperationException(EntityRes.GetString(EntityRes.IncompleteDatabaseCreation), e); } finally { // Close connection and cleanup objects. if (command != null) { command.Dispose(); } if (transaction != null) { DbInterception.Dispatch.Transaction.Dispose(transaction, interceptionContext); } if (connection != null) { DbInterception.Dispatch.Connection.Close(connection, interceptionContext); } } }
internal virtual void ExecuteSql(DbTransaction transaction, MigrationStatement migrationStatement, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(transaction); DebugCheck.NotNull(migrationStatement); _this.ExecuteSql(transaction, migrationStatement, interceptionContext); }
public override void OnDeleted(DbCommand command, DbInterceptionContext interceptionContext) { DeletedCalled = true; DeletedCommand = command; DeletedContext = interceptionContext; }
public override void OnUpdated(DbCommand command, DbInterceptionContext interceptionContext) { UpdatedCalled = true; UpdatedCommand = command; UpdatedContext = interceptionContext; }
public override void OnInserted(DbCommand command, DbInterceptionContext interceptionContext) { InsertedCalled = true; InsertedCommand = command; InsertedContext = interceptionContext; }
private InterceptableDbCommand ConfigureCommand(DbCommand command, string commandText, DbInterceptionContext interceptionContext) { command.CommandText = commandText; if (_configuration.CommandTimeout.HasValue) { command.CommandTimeout = _configuration.CommandTimeout.Value; } return new InterceptableDbCommand(command, interceptionContext); }
public override void OnNonQueryExecuted(DbCommand command, DbInterceptionContext interceptionContext) { NonQueryExecutedCalled = true; NonQueryExecutedCommand = command; NonQueryExecutedContext = interceptionContext; }
internal override void ExecuteSql( DbTransaction transaction, MigrationStatement migrationStatement, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(transaction); DebugCheck.NotNull(migrationStatement); if (string.IsNullOrWhiteSpace(migrationStatement.Sql)) { return; } if (!migrationStatement.SuppressTransaction) { var dbCommand = DbInterception.Dispatch.Transaction.GetConnection(transaction, interceptionContext).CreateCommand(); using (var command = ConfigureCommand(dbCommand, migrationStatement.Sql, interceptionContext)) { command.Transaction = transaction; command.ExecuteNonQuery(); } } else { DbConnection connection = null; try { connection = CreateConnection(); var dbCommand = connection.CreateCommand(); using (var command = ConfigureCommand(dbCommand, migrationStatement.Sql, interceptionContext)) { DbInterception.Dispatch.Connection.Open(connection, interceptionContext); command.ExecuteNonQuery(); } } finally { if (connection != null) { DbInterception.Dispatch.Connection.Dispose(connection, interceptionContext); } } } }
internal DbCommandDefinition CreateCommandDefinition(DbCommandTree commandTree, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(commandTree); DebugCheck.NotNull(interceptionContext); ValidateDataSpace(commandTree); var storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace); Debug.Assert( storeMetadata.StoreProviderManifest != null, "StoreItemCollection has null StoreProviderManifest?"); commandTree = _treeDispatcher.Created(commandTree, interceptionContext); return(CreateDbCommandDefinition(storeMetadata.StoreProviderManifest, commandTree)); }
internal virtual DbCommandDefinition CreateDbCommandDefinition( DbProviderManifest providerManifest, DbCommandTree commandTree, DbInterceptionContext interceptionContext) { return CreateDbCommandDefinition(providerManifest, commandTree); }
private bool ShouldLog(DbInterceptionContext interceptionContext) { return(_context == null || interceptionContext.DbContexts.Contains(_context)); }
internal EntityCommandDefinition( DbProviderFactory storeProviderFactory, DbCommandTree commandTree, DbInterceptionContext interceptionContext, IDbDependencyResolver resolver = null, BridgeDataReaderFactory bridgeDataReaderFactory = null, ColumnMapFactory columnMapFactory = null) { DebugCheck.NotNull(storeProviderFactory); DebugCheck.NotNull(commandTree); DebugCheck.NotNull(interceptionContext); _bridgeDataReaderFactory = bridgeDataReaderFactory ?? new BridgeDataReaderFactory(); _columnMapFactory = columnMapFactory ?? new ColumnMapFactory(); _storeProviderServices = (resolver != null ? resolver.GetService <DbProviderServices>(storeProviderFactory.GetProviderInvariantName()) : null) ?? storeProviderFactory.GetProviderServices(); try { if (DbCommandTreeKind.Query == commandTree.CommandTreeKind) { // Next compile the plan for the command tree var mappedCommandList = new List <ProviderCommandInfo>(); ColumnMap columnMap; int columnCount; PlanCompiler.Compile(commandTree, out mappedCommandList, out columnMap, out columnCount, out _entitySets); _columnMapGenerators = new IColumnMapGenerator[] { new ConstantColumnMapGenerator(columnMap, columnCount) }; // Note: we presume that the first item in the ProviderCommandInfo is the root node; Debug.Assert(mappedCommandList.Count > 0, "empty providerCommandInfo collection and no exception?"); // this shouldn't ever happen. // Then, generate the store commands from the resulting command tree(s) _mappedCommandDefinitions = new List <DbCommandDefinition>(mappedCommandList.Count); _mappedCommandReturnTypes = new List <RowType>(); foreach (var providerCommandInfo in mappedCommandList) { var providerCommandDefinition = _storeProviderServices.CreateCommandDefinition( providerCommandInfo.CommandTree, interceptionContext); _mappedCommandReturnTypes.Add(this.GetRowTypeFromCommandTree(providerCommandInfo.CommandTree)); if (null == providerCommandDefinition) { throw new ProviderIncompatibleException(Strings.ProviderReturnedNullForCreateCommandDefinition); } _mappedCommandDefinitions.Add(providerCommandDefinition); } } else { Debug.Assert( DbCommandTreeKind.Function == commandTree.CommandTreeKind, "only query and function command trees are supported"); var entityCommandTree = (DbFunctionCommandTree)commandTree; // Retrieve mapping and metadata information for the function import. var mapping = GetTargetFunctionMapping(entityCommandTree); IList <FunctionParameter> returnParameters = entityCommandTree.EdmFunction.ReturnParameters; var resultSetCount = returnParameters.Count > 1 ? returnParameters.Count : 1; _columnMapGenerators = new IColumnMapGenerator[resultSetCount]; var storeResultType = DetermineStoreResultType(mapping, 0, out _columnMapGenerators[0]); for (var i = 1; i < resultSetCount; i++) { DetermineStoreResultType(mapping, i, out _columnMapGenerators[i]); } // Copy over parameters (this happens through a more indirect route in the plan compiler, but // it happens nonetheless) var providerParameters = new List <KeyValuePair <string, TypeUsage> >(); foreach (var parameter in entityCommandTree.Parameters) { providerParameters.Add(parameter); } // Construct store command tree usage. var providerCommandTree = new DbFunctionCommandTree( entityCommandTree.MetadataWorkspace, DataSpace.SSpace, mapping.TargetFunction, storeResultType, providerParameters); var storeCommandDefinition = _storeProviderServices.CreateCommandDefinition(providerCommandTree); _mappedCommandDefinitions = new List <DbCommandDefinition>(1) { storeCommandDefinition }; var firstResultEntitySet = mapping.FunctionImport.EntitySets.FirstOrDefault(); if (firstResultEntitySet != null) { _entitySets = new Set <EntitySet>(); _entitySets.Add(mapping.FunctionImport.EntitySets.FirstOrDefault()); _entitySets.MakeReadOnly(); } } // Finally, build a list of the parameters that the resulting command should have; var parameterList = new List <EntityParameter>(); foreach (var queryParameter in commandTree.Parameters) { var parameter = CreateEntityParameterFromQueryParameter(queryParameter); parameterList.Add(parameter); } _parameters = new ReadOnlyCollection <EntityParameter>(parameterList); } catch (EntityCommandCompilationException) { // No need to re-wrap EntityCommandCompilationException throw; } catch (Exception e) { // we should not be wrapping all exceptions if (e.IsCatchableExceptionType()) { // we don't wan't folks to have to know all the various types of exceptions that can // occur, so we just rethrow a CommandDefinitionException and make whatever we caught // the inner exception of it. throw new EntityCommandCompilationException(Strings.EntityClient_CommandDefinitionPreparationFailed, e); } throw; } }
public override void ReaderExecuting(DbCommand command, CommandBehavior behavior, DbInterceptionContext interceptionContext) { Commands.Add(command); Assert.Empty(interceptionContext.DbContexts); Assert.Empty(interceptionContext.ObjectContexts); }
private bool ShouldLog(DbInterceptionContext interceptionContext) { return _context == null || interceptionContext.DbContexts.Contains(_context); }
private void ExecuteStatementsInternal(IEnumerable<MigrationStatement> migrationStatements, DbConnection connection) { DebugCheck.NotNull(migrationStatements); DebugCheck.NotNull(connection); var context = _usersContext ?? _usersContextInfo.CreateInstance(); var interceptionContext = new DbInterceptionContext(); interceptionContext = interceptionContext.WithDbContext(context); TransactionHandler transactionHandler = null; try { if (DbInterception.Dispatch.Connection.GetState(connection, interceptionContext) == ConnectionState.Broken) { DbInterception.Dispatch.Connection.Close(connection, interceptionContext); } if (DbInterception.Dispatch.Connection.GetState(connection, interceptionContext) == ConnectionState.Closed) { DbInterception.Dispatch.Connection.Open(connection, interceptionContext); } if (!(context is TransactionContext)) { var providerInvariantName = DbConfiguration.DependencyResolver.GetService<IProviderInvariantName>( DbProviderServices.GetProviderFactory(connection)) .Name; var dataSource = DbInterception.Dispatch.Connection.GetDataSource(connection, interceptionContext); var transactionHandlerFactory = DbConfiguration.DependencyResolver.GetService<Func<TransactionHandler>>( new ExecutionStrategyKey(providerInvariantName, dataSource)); if (transactionHandlerFactory != null) { transactionHandler = transactionHandlerFactory(); transactionHandler.Initialize(context, connection); } } ExecuteStatementsInternal(migrationStatements, connection, interceptionContext); _committedStatements = true; } finally { if (transactionHandler != null) { transactionHandler.Dispose(); } if (_usersContext == null) { context.Dispose(); } } }
// <summary> // Constructs a new EntityCommand given a EntityConnection and an EntityCommandDefition. This // constructor is used by ObjectQueryExecution plan to execute an ObjectQuery. // </summary> // <param name="connection"> The connection against which this EntityCommand should execute </param> // <param name="entityCommandDefinition"> The prepared command definition that can be executed using this EntityCommand </param> internal EntityCommand( EntityConnection connection, EntityCommandDefinition entityCommandDefinition, DbInterceptionContext context, EntityDataReaderFactory factory = null) : this(entityCommandDefinition, context, factory) { _connection = connection; }
private void ExecuteStatementsInternal( IEnumerable<MigrationStatement> migrationStatements, DbConnection connection, DbTransaction transaction, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(migrationStatements); DebugCheck.NotNull(connection); foreach (var migrationStatement in migrationStatements) { base.ExecuteSql(migrationStatement, connection, transaction, interceptionContext); } }
internal EntityCommand(DbInterceptionContext interceptionContext) : this(interceptionContext, new EntityDataReaderFactory()) { }
private void ExecuteStatementsWithinTransaction( IEnumerable<MigrationStatement> migrationStatements, DbTransaction transaction, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(migrationStatements); DebugCheck.NotNull(transaction); var connection = DbInterception.Dispatch.Transaction.GetConnection(transaction, interceptionContext); ExecuteStatementsInternal(migrationStatements, connection, transaction, interceptionContext); }
private static void UsingConnection(DbConnection sqlConnection, Action<DbConnection> act) { var interceptionContext = new DbInterceptionContext(); // remember the connection string so that we can reset if credentials are wiped var holdConnectionString = DbInterception.Dispatch.Connection.GetConnectionString(sqlConnection, interceptionContext); GetExecutionStrategy(sqlConnection, ProviderInvariantName).Execute( () => { var openingConnection = DbInterception.Dispatch.Connection.GetState(sqlConnection, interceptionContext) == ConnectionState.Closed; if (openingConnection) { // If Open() fails the original credentials need to be restored before retrying if (DbInterception.Dispatch.Connection.GetState(sqlConnection, new DbInterceptionContext()) == ConnectionState.Closed && !DbInterception.Dispatch.Connection.GetConnectionString(sqlConnection, interceptionContext) .Equals(holdConnectionString, StringComparison.Ordinal)) { DbInterception.Dispatch.Connection.SetConnectionString( sqlConnection, new DbConnectionPropertyInterceptionContext<string>().WithValue(holdConnectionString)); } DbInterception.Dispatch.Connection.Open(sqlConnection, interceptionContext); } try { act(sqlConnection); } finally { if (openingConnection && DbInterception.Dispatch.Connection.GetState(sqlConnection, interceptionContext) == ConnectionState.Open) { // if we opened the connection, we should close it DbInterception.Dispatch.Connection.Close(sqlConnection, interceptionContext); // Can only change the connection string if the connection is closed if (!DbInterception.Dispatch.Connection.GetConnectionString(sqlConnection, interceptionContext) .Equals(holdConnectionString, StringComparison.Ordinal)) { DbInterception.Dispatch.Connection.SetConnectionString( sqlConnection, new DbConnectionPropertyInterceptionContext<string>().WithValue(holdConnectionString)); } } } }); }
internal override void ExecuteSql( MigrationStatement migrationStatement, DbConnection connection, DbTransaction transaction, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(migrationStatement); DebugCheck.NotNull(connection); if (string.IsNullOrWhiteSpace(migrationStatement.Sql)) { return; } var dbCommand = connection.CreateCommand(); using (var command = ConfigureCommand(dbCommand, migrationStatement.Sql, interceptionContext)) { if (transaction != null) { command.Transaction = transaction; } command.ExecuteNonQuery(); } }
internal EntityCommand(string statement, DbInterceptionContext context, EntityDataReaderFactory factory) : this(context, factory) { _esqlCommandText = statement; }
internal void ExecuteStatements(IEnumerable<MigrationStatement> migrationStatements, DbTransaction existingTransaction) { DebugCheck.NotNull(migrationStatements); DbConnection connection = null; try { if (existingTransaction != null) { var interceptionContext = new DbInterceptionContext(); interceptionContext = interceptionContext.WithDbContext(_usersContext); ExecuteStatementsWithinTransaction(migrationStatements, existingTransaction, interceptionContext); } else { connection = CreateConnection(); DbProviderServices.GetExecutionStrategy(connection).Execute( () => ExecuteStatementsInternal(migrationStatements, connection)); } } finally { if (connection != null) { DbInterception.Dispatch.Connection.Dispose(connection, new DbInterceptionContext()); } } }
internal DbCommandDefinition CreateCommandDefinition(DbCommandTree commandTree, DbInterceptionContext interceptionContext) { DebugCheck.NotNull(commandTree); DebugCheck.NotNull(interceptionContext); ValidateDataSpace(commandTree); var storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace); Debug.Assert( storeMetadata.ProviderManifest != null, "StoreItemCollection has null ProviderManifest?"); commandTree = _treeDispatcher.Value.Created(commandTree, interceptionContext); return CreateDbCommandDefinition(storeMetadata.ProviderManifest, commandTree, interceptionContext); }
public bool ConnectionOpening(EntityConnection connection, DbInterceptionContext interceptionContext) { return !interceptionContext.DbContexts.Contains(_context, ReferenceEquals); }
/// <summary> /// Checks whether the supplied interception context contains the target context /// or the supplied connection is the same as the one used by the target context. /// </summary> /// <param name="connection">A connection.</param> /// <param name="interceptionContext">An interception context.</param> /// <returns> /// <c>true</c> if the supplied interception context contains the target context or /// the supplied connection is the same as the one used by the target context if /// the supplied interception context doesn't contain any contexts; <c>false</c> otherwise. /// </returns> /// <remarks> /// Note that calling this method will trigger initialization of any DbContext referenced from the <paramref name="interceptionContext"/> /// </remarks> protected internal virtual bool MatchesParentContext(DbConnection connection, DbInterceptionContext interceptionContext) { Check.NotNull(connection, "connection"); Check.NotNull(interceptionContext, "interceptionContext"); if (DbContext != null && interceptionContext.DbContexts.Contains(DbContext, ReferenceEquals)) { return true; } if (ObjectContext != null && interceptionContext.ObjectContexts.Contains(ObjectContext, ReferenceEquals)) { return true; } if (Connection != null && !interceptionContext.ObjectContexts.Any() && !interceptionContext.DbContexts.Any()) { return ReferenceEquals(connection, Connection); } return false; }