public SqlConnection CreateConnection(Session session) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXCreatingConnection, session.ToStringSafely()); } SqlConnection connection; try { connection = underlyingDriver.CreateConnection(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } var sessionConfiguration = GetConfiguration(session); if (sessionConfiguration.ConnectionInfo != null) { connection.ConnectionInfo = sessionConfiguration.ConnectionInfo; } connection.CommandTimeout = sessionConfiguration.DefaultCommandTimeout; if (!string.IsNullOrEmpty(configuration.ConnectionInitializationSql)) { SetInitializationSql(connection, configuration.ConnectionInitializationSql); } return(connection); }
public void OpenConnection(Session session, SqlConnection connection) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXOpeningConnectionY, session.ToStringSafely(), connection.ConnectionInfo); } var extension = connection.Extensions.Get <InitializationSqlExtension>(); var script = extension?.Script; try { if (!string.IsNullOrEmpty(script)) { connection.OpenAndInitialize(extension.Script); } else { connection.Open(); } } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
private async Task <TResult> ExecuteCommandAsync <TResult>(Session session, DbCommand command, CancellationToken cancellationToken, Func <DbCommand, CancellationToken, Task <TResult> > action) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXQueryY, session.ToStringSafely(), command.ToHumanReadableString()); } cancellationToken.ThrowIfCancellationRequested(); session?.Events.NotifyDbCommandExecuting(command); TResult result; try { result = await action(command, cancellationToken).ConfigureAwait(false); } catch (OperationCanceledException) { throw; } catch (Exception exception) { var wrapped = ExceptionBuilder.BuildException(exception, command.ToHumanReadableString()); session?.Events.NotifyDbCommandExecuted(command, wrapped); throw wrapped; } session?.Events.NotifyDbCommandExecuted(command); return(result); }
public async Task OpenConnectionAsync(Session session, SqlConnection connection, CancellationToken cancellationToken) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXOpeningConnectionY, session.ToStringSafely(), connection.ConnectionInfo); } var extension = connection.Extensions.Get <InitializationSqlExtension>(); try { if (!string.IsNullOrEmpty(extension?.Script)) { await connection.OpenAndInitializeAsync(extension.Script, cancellationToken).ConfigureAwait(false); } else { await connection.OpenAsync(cancellationToken).ConfigureAwait(false); } } catch (OperationCanceledException) { throw; } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
private void LogStatements(IEnumerable <string> statements) { SqlLog.Info( Strings.LogSessionXSchemaUpgradeScriptY, session.ToStringSafely(), driver.BuildBatch(statements.ToArray()).Trim()); }
private TResult ExecuteCommand <TResult>( Session session, DbCommand command, CommandBehavior commandBehavior, Func <DbCommand, CommandBehavior, TResult> action) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXQueryY, session.ToStringSafely(), command.ToHumanReadableString()); } session?.Events.NotifyDbCommandExecuting(command); TResult result; try { result = action.Invoke(command, commandBehavior); } catch (Exception exception) { var wrapped = ExceptionBuilder.BuildException(exception, command.ToHumanReadableString()); session?.Events.NotifyDbCommandExecuted(command, wrapped); throw wrapped; } session?.Events.NotifyDbCommandExecuted(command); return(result); }
private void EnsureConnectionIsAlive(ref SqlServerConnection connection, string query) { try { using (var command = connection.CreateCommand()) { command.CommandText = query; command.ExecuteNonQuery(); } } catch (Exception exception) { if (SqlHelper.ShouldRetryOn(exception)) { SqlLog.Warning(exception, Strings.LogGivenConnectionIsCorruptedTryingToRestoreTheConnection); if (!TryReconnect(ref connection, query)) { SqlLog.Error(exception, Strings.LogConnectionRestoreFailed); throw; } SqlLog.Info(Strings.LogConnectionSuccessfullyRestored); } else { throw; } } }
public void DisposeConnection(Session session, SqlConnection connection) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXDisposingConnection, session.ToStringSafely()); } try { connection.Dispose(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public void RollbackTransaction(Session session, SqlConnection connection) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXRollbackTransaction, session.ToStringSafely()); } try { connection.Rollback(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public void ReleaseSavepoint(Session session, SqlConnection connection, string name) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXReleaseSavepointY, session.ToStringSafely(), name); } try { connection.ReleaseSavepoint(name); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public async Task DisposeConnectionAsync(Session session, SqlConnection connection) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXDisposingConnection, session.ToStringSafely()); } try { await connection.DisposeAsync().ConfigureAwait(false); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public void SqlLogTest() { if (File.Exists(filePath)) { File.Delete(filePath); } SqlLog.Debug("Test message", null); SqlLog.Debug("Test message with parameter {0}", new object[] { 1 }); SqlLog.Debug(new Exception("Some exception"), "Test message with parameter {0}", new object[] { 1 }); SqlLog.Debug("Test message", new object[] { 1 }); SqlLog.Debug("Test message {0}", null); SqlLog.Debug(new Exception("Some exeption")); SqlLog.Debug(null, new object[] { 1 }); SqlLog.Info("Test message", null); SqlLog.Info("Test message with parameter {0}", new object[] { 1 }); SqlLog.Info(new Exception("Some exception"), "Test message with parameter {0}", new object[] { 1 }); SqlLog.Info("Test message", new object[] { 1 }); SqlLog.Info("Test message {0}", null); SqlLog.Info(new Exception("Some exeption")); SqlLog.Info(null, new object[] { 1 }); SqlLog.Warning("Test message", null); SqlLog.Warning("Test message with parameter {0}", new object[] { 1 }); SqlLog.Warning(new Exception("Some exception"), "Test message with parameter {0}", new object[] { 1 }); SqlLog.Warning("Test message", new object[] { 1 }); SqlLog.Warning("Test message {0}", null); SqlLog.Warning(new Exception("Some exeption")); SqlLog.Warning(null, new object[] { 1 }); SqlLog.Error("Test message", null); SqlLog.Error("Test message with parameter {0}", new object[] { 1 }); SqlLog.Error(new Exception("Some exception"), "Test message with parameter {0}", new object[] { 1 }); SqlLog.Error("Test message", new object[] { 1 }); SqlLog.Error("Test message {0}", null); SqlLog.Error(new Exception("Some exeption")); SqlLog.Error(null, new object[] { 1 }); SqlLog.FatalError("Test message", null); SqlLog.FatalError("Test message with parameter {0}", new object[] { 1 }); SqlLog.FatalError(new Exception("Some exception"), "Test message with parameter {0}", new object[] { 1 }); SqlLog.FatalError("Test message", new object[] { 1 }); SqlLog.FatalError("Test message {0}", null); SqlLog.FatalError(new Exception("Some exeption")); SqlLog.FatalError(null, new object[] { 1 }); Assert.IsTrue(File.Exists(filePath)); Assert.AreEqual(File.ReadAllLines(filePath).Count(), 35); }
public async ValueTask ReleaseSavepointAsync( Session session, SqlConnection connection, string name, CancellationToken token = default) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXReleaseSavepointY, session.ToStringSafely(), name); } try { await connection.ReleaseSavepointAsync(name, token).ConfigureAwait(false); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public async ValueTask RollbackTransactionAsync( Session session, SqlConnection connection, CancellationToken token = default) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXRollbackTransaction, session.ToStringSafely()); } try { await connection.RollbackAsync(token).ConfigureAwait(false); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public void BeginTransaction(Session session, SqlConnection connection, IsolationLevel?isolationLevel) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXBeginningTransactionWithYIsolationLevel, session.ToStringSafely(), isolationLevel); } isolationLevel ??= IsolationLevelConverter.Convert(GetConfiguration(session).DefaultIsolationLevel); try { connection.BeginTransaction(isolationLevel.Value); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public async ValueTask BeginTransactionAsync( Session session, SqlConnection connection, IsolationLevel?isolationLevel, CancellationToken token = default) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXBeginningTransactionWithYIsolationLevel, session.ToStringSafely(), isolationLevel); } isolationLevel ??= IsolationLevelConverter.Convert(GetConfiguration(session).DefaultIsolationLevel); try { await connection.BeginTransactionAsync(isolationLevel.Value, token).ConfigureAwait(false); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public void MakeSavepoint(Session session, SqlConnection connection, string name) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXMakeSavepointY, session.ToStringSafely(), name); } if (!hasSavepoints) { return; // Driver does not support savepoints, so let's fail later (on rollback) } try { connection.MakeSavepoint(name); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public void CloseConnection(Session session, SqlConnection connection) { if (connection.State != ConnectionState.Open) { return; } if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXClosingConnectionY, session.ToStringSafely(), connection.ConnectionInfo); } try { connection.Close(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public async Task CloseConnectionAsync(Session session, SqlConnection connection) { if (connection.State != ConnectionState.Open) { return; } if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXClosingConnectionY, session.ToStringSafely(), connection.ConnectionInfo); } try { await connection.CloseAsync().ConfigureAwait(false); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public void RollbackToSavepoint(Session session, SqlConnection connection, string name) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXRollbackToSavepointY, session.ToStringSafely(), name); } if (!hasSavepoints) { throw new NotSupportedException(Strings.ExCurrentStorageProviderDoesNotSupportSavepoints); } try { connection.RollbackToSavepoint(name); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public async ValueTask MakeSavepointAsync( Session session, SqlConnection connection, string name, CancellationToken token = default) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXMakeSavepointY, session.ToStringSafely(), name); } if (!hasSavepoints) { return; // Driver does not support save points, so let's fail later (on rollback) } try { await connection.MakeSavepointAsync(name, token).ConfigureAwait(false); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public async ValueTask RollbackToSavepointAsync( Session session, SqlConnection connection, string name, CancellationToken token = default) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXRollbackToSavepointY, session.ToStringSafely(), name); } if (!hasSavepoints) { throw new NotSupportedException(Strings.ExCurrentStorageProviderDoesNotSupportSavepoints); } try { await connection.RollbackToSavepointAsync(name, token).ConfigureAwait(false); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } }
public SqlConnection CreateConnection(Session session) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXCreatingConnection, session.ToStringSafely()); } SqlConnection connection; try { connection = underlyingDriver.CreateConnection(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } if (connectionAccessorFactories != null) { connection.AssignConnectionAccessors( CreateConnectionAccessorsFast(configuration.Types.DbConnectionAccessors)); } var sessionConfiguration = GetConfiguration(session); connection.CommandTimeout = sessionConfiguration.DefaultCommandTimeout; var connectionInfo = GetConnectionInfo(session) ?? sessionConfiguration.ConnectionInfo; if (connectionInfo != null) { connection.ConnectionInfo = connectionInfo; } var connectionInitializationSql = GetInitializationSql(session) ?? configuration.ConnectionInitializationSql; if (!string.IsNullOrEmpty(connectionInitializationSql)) { SetInitializationSql(connection, connectionInitializationSql); } return(connection); }
public void OpenConnection(Session session, SqlConnection connection) { if (isLoggingEnabled) { SqlLog.Info(Strings.LogSessionXOpeningConnectionY, session.ToStringSafely(), connection.ConnectionInfo); } try { connection.Open(); } catch (Exception exception) { throw ExceptionBuilder.BuildException(exception); } var extension = connection.Extensions.Get <InitializationSqlExtension>(); if (!string.IsNullOrEmpty(extension?.Script)) { using (var command = connection.CreateCommand(extension.Script)) ExecuteNonQuery(session, command); } }