public virtual DbCommand CreateDbCommand(
RelationalCommandParameterObject parameterObject,
Guid commandId,
DbCommandMethod commandMethod)
{
var(connection, context, logger) = (parameterObject.Connection, parameterObject.Context, parameterObject.Logger);
var connectionId = connection.ConnectionId;
var startTime = DateTimeOffset.UtcNow;
var stopwatch = Stopwatch.StartNew();
var interceptionResult = logger?.CommandCreating(connection, commandMethod, context, commandId, connectionId, startTime)
?? default;
var command = interceptionResult.HasResult
? interceptionResult.Result
: connection.DbConnection.CreateCommand();
if (logger != null)
{
command = logger.CommandCreated(
connection, command, commandMethod, context, commandId, connectionId, startTime, stopwatch.Elapsed);
}
command.CommandText = CommandText;
if (connection.CurrentTransaction != null)
{
command.Transaction = connection.CurrentTransaction.GetDbTransaction();
}
if (connection.CommandTimeout != null)
{
command.CommandTimeout = (int)connection.CommandTimeout;
}
if (Parameters.Count > 0)
{
var parameterValues = parameterObject.ParameterValues;
if (parameterValues == null)
{
throw new InvalidOperationException(
RelationalStrings.MissingParameterValue(
Parameters[0].InvariantName));
}
for (var i = 0; i < Parameters.Count; i++)
{
Parameters[i].AddDbParameter(command, parameterValues);
}
}
return(command);
}
public DbCommand CommandCreated(
IRelationalConnection connection,
DbCommand command,
DbCommandMethod commandMethod,
DbContext?context,
Guid commandId,
Guid connectionId,
DateTimeOffset startTime,
TimeSpan duration,
CommandSource commandSource)
=> command;
public async Task Reports_command_diagnostic(
Delegate commandDelegate,
DbCommandMethod diagnosticName,
bool async)
{
var options = CreateOptions();
var fakeConnection = new FakeRelationalConnection(options);
var diagnostic = new List <Tuple <string, object> >();
var logger = new DiagnosticsLogger <DbLoggerCategory.Database.Command>(
new ListLoggerFactory(),
new FakeLoggingOptions(false),
new ListDiagnosticSource(diagnostic),
new TestRelationalLoggingDefinitions());
var relationalCommand = CreateRelationalCommand(
parameters: new[]
{
new TypeMappedRelationalParameter("FirstInvariant", "FirstParameter", new IntTypeMapping("int", DbType.Int32), false)
});
var parameterValues = new Dictionary <string, object>
{
{ "FirstInvariant", 17 }
};
if (async)
{
await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues, logger);
}
else
{
((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues, logger);
}
Assert.Equal(2, diagnostic.Count);
Assert.Equal(RelationalEventId.CommandExecuting.Name, diagnostic[0].Item1);
Assert.Equal(RelationalEventId.CommandExecuted.Name, diagnostic[1].Item1);
var beforeData = (CommandEventData)diagnostic[0].Item2;
var afterData = (CommandExecutedEventData)diagnostic[1].Item2;
Assert.Equal(fakeConnection.DbConnections[0].DbCommands[0], beforeData.Command);
Assert.Equal(fakeConnection.DbConnections[0].DbCommands[0], afterData.Command);
Assert.Equal(diagnosticName, beforeData.ExecuteMethod);
Assert.Equal(diagnosticName, afterData.ExecuteMethod);
Assert.Equal(async, beforeData.IsAsync);
Assert.Equal(async, afterData.IsAsync);
}
public void OnCommandExecuting(DbCommand command, DbCommandMethod executeMethod, Guid commandId, Guid connectionId, bool async, DateTimeOffset startTime)
{
if (command.CommandType != CommandType.Text || !(command is SqlCommand))
{
return;
}
if (command.CommandText.Contains("ProductInventories") && !command.CommandText.Contains("option(recompile)"))
{
command.CommandText = command.CommandText + " option(recompile)";
}
}
public void OnCommandExecuting(DbCommand command, DbCommandMethod executeMethod, Guid commandId, Guid connectionId, bool async, DateTimeOffset startTime)
{
// Section to catch create table queries
// Append ENGINE=INNODB so constraints work properly
var dbString = new Regex(@"^CREATE TABLE");
var cmdString = command.CommandText;
if (dbString.IsMatch(cmdString))
{
int place = cmdString.LastIndexOf(";", StringComparison.Ordinal);
command.CommandText = cmdString.Remove(place, ";".Length).Insert(place, " ENGINE=INNODB;");
}
}
/// <summary>
/// Constructs the event payload.
/// </summary>
/// <param name="eventDefinition"> The event definition. </param>
/// <param name="messageGenerator"> A delegate that generates a log message for this event. </param>
/// <param name="command">
/// The <see cref="DbCommand" />.
/// </param>
/// <param name="executeMethod">
/// The <see cref="DbCommand" /> method.
/// </param>
/// <param name="commandId">
/// A correlation ID that identifies the <see cref="DbCommand" /> instance being used.
/// </param>
/// <param name="connectionId">
/// A correlation ID that identifies the <see cref="DbConnection" /> instance being used.
/// </param>
/// <param name="async">
/// Indicates whether or not the command was executed asynchronously.
/// </param>
/// <param name="logParameterValues">
/// Indicates whether or not the application allows logging of parameter values.
/// </param>
/// <param name="startTime">
/// The start time of this event.
/// </param>
/// <param name="duration">
/// The duration this event.
/// </param>
public CommandEndEventData(
[NotNull] EventDefinitionBase eventDefinition,
[NotNull] Func <EventDefinitionBase, EventData, string> messageGenerator,
[NotNull] DbCommand command,
DbCommandMethod executeMethod,
Guid commandId,
Guid connectionId,
bool async,
bool logParameterValues,
DateTimeOffset startTime,
TimeSpan duration)
: base(eventDefinition, messageGenerator, command, executeMethod, commandId, connectionId, async, logParameterValues, startTime)
=> Duration = duration;
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public static void CommandError(
[NotNull] this IDiagnosticsLogger <DbLoggerCategory.Database.Command> diagnostics,
[NotNull] DbCommand command,
DbCommandMethod executeMethod,
Guid commandId,
Guid connectionId,
[NotNull] Exception exception,
bool async,
DateTimeOffset startTime,
TimeSpan duration)
{
var definition = RelationalStrings.LogRelationalLoggerCommandFailed;
// Checking for enabled here to avoid string formatting if not needed.
if (diagnostics.GetLogBehavior(definition.EventId, definition.Level) != WarningBehavior.Ignore)
{
definition.Log(
diagnostics,
string.Format(CultureInfo.InvariantCulture, "{0:N0}", duration.TotalMilliseconds),
command.Parameters.FormatParameters(ShouldLogParameterValues(diagnostics, command)),
command.CommandType,
command.CommandTimeout,
Environment.NewLine,
command.CommandText.TrimEnd(),
exception);
}
if (diagnostics.DiagnosticSource.IsEnabled(definition.EventId.Name))
{
diagnostics.DiagnosticSource.Write(
definition.EventId.Name,
new CommandErrorEventData(
definition,
CommandError,
command,
executeMethod,
commandId,
connectionId,
exception,
async,
ShouldLogParameterValues(diagnostics, command),
startTime,
duration));
}
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual InterceptionResult <DbCommand> CommandCreating(
IRelationalConnection connection,
DbCommandMethod commandMethod,
DbContext?context,
Guid commandId,
Guid connectionId,
DateTimeOffset startTime,
CommandSource commandSource)
{
_suppressCommandCreateExpiration = startTime + _loggingCacheTime;
var definition = RelationalResources.LogCommandCreating(this);
if (ShouldLog(definition))
{
_suppressCommandCreateExpiration = default;
definition.Log(this, commandMethod.ToString());
}
if (NeedsEventData <IDbCommandInterceptor>(
definition, out var interceptor, out var diagnosticSourceEnabled, out var simpleLogEnabled))
{
_suppressCommandCreateExpiration = default;
var eventData = BroadcastCommandCreating(
connection.DbConnection,
context,
commandMethod,
commandId,
connectionId,
async: false,
startTime,
definition,
diagnosticSourceEnabled,
simpleLogEnabled,
commandSource);
if (interceptor != null)
{
return(interceptor.CommandCreating(eventData, default));
}
}
return(default);
/// <summary>
/// Constructs the event payload.
/// </summary>
/// <param name="eventDefinition"> The event definition. </param>
/// <param name="messageGenerator"> A delegate that generates a log message for this event. </param>
/// <param name="connection"> The <see cref="DbConnection"/> being used. </param>
/// <param name="context"> The <see cref="DbContext" /> currently being used, to null if not known. </param>
/// <param name="executeMethod"> The <see cref="DbCommand" /> method. </param>
/// <param name="commandId"> A correlation ID that identifies the <see cref="DbCommand" /> instance being used. </param>
/// <param name="connectionId"> A correlation ID that identifies the <see cref="DbConnection" /> instance being used. </param>
/// <param name="async"> Indicates whether or not the command was executed asynchronously. </param>
/// <param name="startTime"> The start time of this event. </param>
public CommandCorrelatedEventData(
[NotNull] EventDefinitionBase eventDefinition,
[NotNull] Func <EventDefinitionBase, EventData, string> messageGenerator,
[NotNull] DbConnection connection,
[CanBeNull] DbContext context,
DbCommandMethod executeMethod,
Guid commandId,
Guid connectionId,
bool async,
DateTimeOffset startTime)
: base(eventDefinition, messageGenerator, context)
{
Connection = connection;
CommandId = commandId;
ConnectionId = connectionId;
ExecuteMethod = executeMethod;
IsAsync = async;
StartTime = startTime;
}
/// <summary>
/// Constructs the event payload.
/// </summary>
/// <param name="eventDefinition"> The event definition. </param>
/// <param name="messageGenerator"> A delegate that generates a log message for this event. </param>
/// <param name="command">
/// The <see cref="DbCommand" />.
/// </param>
/// <param name="executeMethod">
/// The <see cref="DbCommand" /> method.
/// </param>
/// <param name="commandId">
/// A correlation ID that identifies the <see cref="DbCommand" /> instance being used.
/// </param>
/// <param name="connectionId">
/// A correlation ID that identifies the <see cref="DbConnection" /> instance being used.
/// </param>
/// <param name="async">
/// Indicates whether or not the command was executed asynchronously.
/// </param>
/// <param name="logParameterValues">
/// Indicates whether or not the application allows logging of parameter values.
/// </param>
/// <param name="startTime">
/// The start time of this event.
/// </param>
public CommandEventData(
[NotNull] EventDefinitionBase eventDefinition,
[NotNull] Func <EventDefinitionBase, EventData, string> messageGenerator,
[NotNull] DbCommand command,
DbCommandMethod executeMethod,
Guid commandId,
Guid connectionId,
bool async,
bool logParameterValues,
DateTimeOffset startTime)
: base(eventDefinition, messageGenerator)
{
Command = command;
CommandId = commandId;
ConnectionId = connectionId;
ExecuteMethod = executeMethod;
IsAsync = async;
LogParameterValues = logParameterValues;
StartTime = startTime;
}
/// <summary>
/// Constructs the event payload.
/// </summary>
/// <param name="eventDefinition">The event definition.</param>
/// <param name="messageGenerator">A delegate that generates a log message for this event.</param>
/// <param name="connection">The <see cref="DbConnection" /> being used.</param>
/// <param name="context">The <see cref="DbContext" /> currently being used, to null if not known.</param>
/// <param name="executeMethod">The <see cref="DbCommand" /> method.</param>
/// <param name="commandId">A correlation ID that identifies the <see cref="DbCommand" /> instance being used.</param>
/// <param name="connectionId">A correlation ID that identifies the <see cref="DbConnection" /> instance being used.</param>
/// <param name="async">Indicates whether or not the command was executed asynchronously.</param>
/// <param name="startTime">The start time of this event.</param>
/// <param name="commandSource">Source of the command.</param>
public CommandCorrelatedEventData(
EventDefinitionBase eventDefinition,
Func <EventDefinitionBase, EventData, string> messageGenerator,
DbConnection connection,
DbContext?context,
DbCommandMethod executeMethod,
Guid commandId,
Guid connectionId,
bool async,
DateTimeOffset startTime,
CommandSource commandSource)
: base(eventDefinition, messageGenerator, context)
{
Connection = connection;
CommandId = commandId;
ConnectionId = connectionId;
ExecuteMethod = executeMethod;
IsAsync = async;
StartTime = startTime;
CommandSource = commandSource;
}
/// <summary>
/// This API supports the Entity Framework Core infrastructure and is not intended to be used
/// directly from your code. This API may change or be removed in future releases.
/// </summary>
public static void CommandExecuting(
[NotNull] this IDiagnosticsLogger <DbLoggerCategory.Database.Command> diagnostics,
[NotNull] DbCommand command,
DbCommandMethod executeMethod,
Guid commandId,
Guid connectionId,
bool async,
DateTimeOffset startTime)
{
var definition = RelationalStrings.LogRelationalLoggerExecutingCommand;
// Checking for enabled here to avoid string formatting if not needed.
if (diagnostics.GetLogBehavior(definition.EventId, definition.Level) != WarningBehavior.Ignore)
{
definition.Log(
diagnostics,
command.Parameters.FormatParameters(ShouldLogParameterValues(diagnostics, command)),
command.CommandType,
command.CommandTimeout,
Environment.NewLine,
command.CommandText.TrimEnd());
}
if (diagnostics.DiagnosticSource.IsEnabled(definition.EventId.Name))
{
diagnostics.DiagnosticSource.Write(
definition.EventId.Name,
new CommandEventData(
definition,
CommandExecuting,
command,
executeMethod,
commandId,
connectionId,
async,
ShouldLogParameterValues(diagnostics, command),
startTime));
}
}
public CommandCorrelatedEventData(
EventDefinitionBase eventDefinition,
Func <EventDefinitionBase, EventData, string> messageGenerator,
DbConnection connection,
DbContext?context,
DbCommandMethod executeMethod,
Guid commandId,
Guid connectionId,
bool async,
DateTimeOffset startTime)
: this(
eventDefinition,
messageGenerator,
connection,
context,
executeMethod,
commandId,
connectionId,
async,
startTime,
CommandSource.Unknown)
{
}
public async Task Reports_command_diagnostic_on_exception(
Delegate commandDelegate,
DbCommandMethod diagnosticName,
bool async)
{
var exception = new InvalidOperationException();
var fakeDbConnection = new FakeDbConnection(
ConnectionString,
new FakeCommandExecutor(
c => throw exception,
c => throw exception,
(c, cb) => throw exception,
(c, ct) => throw exception,
(c, ct) => throw exception,
(c, cb, ct) => throw exception));
var optionsExtension = new FakeRelationalOptionsExtension().WithConnection(fakeDbConnection);
var options = CreateOptions(optionsExtension);
var diagnostic = new List <Tuple <string, object> >();
var fakeConnection = new FakeRelationalConnection(options);
var relationalCommand = CreateRelationalCommand(
new DiagnosticsLogger <DbLoggerCategory.Database.Command>(
new ListLoggerFactory(new List <(LogLevel, EventId, string)>()),
new FakeLoggingOptions(false),
new ListDiagnosticSource(diagnostic)),
parameters: new[]
{ new TypeMappedRelationalParameter("FirstInvariant", "FirstParameter", new IntTypeMapping("int", DbType.Int32), false) });
var parameterValues = new Dictionary <string, object>
{
{ "FirstInvariant", 17 }
};
if (async)
{
await Assert.ThrowsAsync <InvalidOperationException>(
async()
=> await((CommandFunc)commandDelegate)(fakeConnection, relationalCommand, parameterValues));
}
else
{
Assert.Throws <InvalidOperationException>(
()
=> ((CommandAction)commandDelegate)(fakeConnection, relationalCommand, parameterValues));
}
Assert.Equal(2, diagnostic.Count);
Assert.Equal(RelationalEventId.CommandExecuting.Name, diagnostic[0].Item1);
Assert.Equal(RelationalEventId.CommandError.Name, diagnostic[1].Item1);
var beforeData = (CommandEventData)diagnostic[0].Item2;
var afterData = (CommandErrorEventData)diagnostic[1].Item2;
Assert.Equal(fakeDbConnection.DbCommands[0], beforeData.Command);
Assert.Equal(fakeDbConnection.DbCommands[0], afterData.Command);
Assert.Equal(diagnosticName, beforeData.ExecuteMethod);
Assert.Equal(diagnosticName, afterData.ExecuteMethod);
Assert.Equal(async, beforeData.IsAsync);
Assert.Equal(async, afterData.IsAsync);
Assert.Equal(exception, afterData.Exception);
}
/// <summary>
/// 异步执行
/// </summary>
/// <param name="connection"></param>
/// <param name="executeMethod"></param>
/// <param name="parameterValues"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
protected override async Task <object> ExecuteAsync(IRelationalConnection connection, DbCommandMethod executeMethod, IReadOnlyDictionary <string, object> parameterValues, CancellationToken cancellationToken = default(CancellationToken))
{
if (Check.IsTraceEnabled(Logger?.Logger))
{
Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Trace, OracleTraceTag.Entry, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.ExecuteAsync);
}
Check.NotNull(connection, nameof(connection));
// 创建命令并打开连接
DbCommand dbCommand = CreateCommand(connection, parameterValues);
await connection.OpenAsync(cancellationToken);
Guid commandId = Guid.NewGuid();
DateTimeOffset startTime = DateTimeOffset.UtcNow;
Stopwatch stopwatch = Stopwatch.StartNew();
// 执行命令
Logger.CommandExecuting(dbCommand, executeMethod, commandId, connection.ConnectionId, async: true, startTime);
// 读取数据
bool readerOpen = false;
try
{
object obj;
switch (executeMethod)
{
case DbCommandMethod.ExecuteNonQuery:
obj = await dbCommand.ExecuteNonQueryAsync(cancellationToken);
break;
case DbCommandMethod.ExecuteScalar:
obj = await dbCommand.ExecuteScalarAsync(cancellationToken);
break;
case DbCommandMethod.ExecuteReader:
{
DbCommand command = dbCommand;
obj = new RelationalDataReader(connection, command, await dbCommand.ExecuteReaderAsync(cancellationToken), commandId, Logger);
readerOpen = true;
break;
}
default:
throw new NotSupportedException();
}
Logger.CommandExecuted(dbCommand, executeMethod, commandId, connection.ConnectionId, obj, async: true, startTime, stopwatch.Elapsed);
return(obj);
}
catch (Exception ex)
{
if (Check.IsErrorEnabled(Logger?.Logger))
{
Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Error, OracleTraceTag.Error, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.ExecuteAsync, ex.ToString());
}
Logger.CommandError(dbCommand, executeMethod, commandId, connection.ConnectionId, ex, async: true, startTime, stopwatch.Elapsed);
throw;
}
finally
{
if (!readerOpen)
{
dbCommand.Dispose();
connection.Close();
}
dbCommand.Parameters.Clear();
if (Check.IsTraceEnabled(Logger?.Logger))
{
Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Trace, OracleTraceTag.Exit, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.ExecuteAsync);
}
}
}
public DbCommand CreateDbCommand(RelationalCommandParameterObject parameterObject, Guid commandId, DbCommandMethod commandMethod) => throw new NotImplementedException();
/// <summary>
/// 执行 denglf
/// </summary>
/// <param name="connection"></param>
/// <param name="executeMethod"></param>
/// <param name="parameterValues"></param>
/// <returns></returns>
protected override object Execute(IRelationalConnection connection, DbCommandMethod executeMethod, IReadOnlyDictionary <string, object> parameterValues)
{
try
{
if (Check.IsTraceEnabled(base.Logger?.Logger))
{
Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Trace, OracleTraceTag.Entry, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.Execute);
}
Check.NotNull(connection, nameof(connection));
// 创建命令并打开连接
DbCommand dbCommand = CreateCommand(connection, parameterValues);
connection.Open();
Guid commandId = Guid.NewGuid();
DateTimeOffset utcNow = DateTimeOffset.UtcNow;
Stopwatch stopwatch = Stopwatch.StartNew();
if (Check.IsTraceEnabled(base.Logger?.Logger))
{
Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Trace, OracleTraceTag.SQL, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.Execute, dbCommand.CommandText);
}
// 执行命令
Logger.CommandExecuting(dbCommand, executeMethod, commandId, connection.ConnectionId, async: false, utcNow);
// 读取数据
bool readerOpen = false;
object value;
try
{
switch (executeMethod)
{
case DbCommandMethod.ExecuteNonQuery:
value = dbCommand.ExecuteNonQuery();
break;
case DbCommandMethod.ExecuteScalar:
value = dbCommand.ExecuteScalar();
break;
case DbCommandMethod.ExecuteReader:
value = new RelationalDataReader(connection, dbCommand, dbCommand.ExecuteReader(), commandId, Logger);
readerOpen = true;
break;
default:
throw new NotSupportedException();
}
Logger.CommandExecuted(dbCommand, executeMethod, commandId, connection.ConnectionId, value, async: false, utcNow, stopwatch.Elapsed);
}
catch (Exception ex)
{
if (Check.IsErrorEnabled(Logger?.Logger))
{
Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Error, OracleTraceTag.Error, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.Execute, ex.ToString());
}
Logger.CommandError(dbCommand, executeMethod, commandId, connection.ConnectionId, ex, async: false, utcNow, stopwatch.Elapsed);
throw;
}
finally
{
if (!readerOpen)
{
dbCommand.Dispose();
connection.Close();
}
dbCommand.Parameters.Clear();
if (Check.IsTraceEnabled(Logger?.Logger))
{
Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Trace, OracleTraceTag.Exit, OracleTraceClassName.OracleRelationalCommandBuilderFactory, OracleTraceFuncName.Execute);
}
}
return(value);
}
catch (Exception ex)
{
if (Check.IsErrorEnabled(Logger?.Logger))
{
Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Error, OracleTraceTag.Error, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.Execute, ex.ToString());
}
throw;
}
finally
{
if (Check.IsTraceEnabled(Logger?.Logger))
{
Trace <DbLoggerCategory.Database.Command> .Write(Logger, LogLevel.Trace, OracleTraceTag.Exit, OracleTraceClassName.OracleRelationalCommand, OracleTraceFuncName.Execute);
}
}
}
/// <summary>
/// The method called by other methods on this type to execute synchronously.
/// </summary>
/// <param name="connection"> The connection to use. </param>
/// <param name="executeMethod"> The method type. </param>
/// <param name="parameterValues"> The parameter values. </param>
/// <param name="logger"> The command logger. </param>
/// <param name="cancellationToken"> The cancellation token. </param>
/// <returns> The result of the execution. </returns>
protected virtual async Task <object> ExecuteAsync(
[NotNull] IRelationalConnection connection,
DbCommandMethod executeMethod,
[CanBeNull] IReadOnlyDictionary <string, object> parameterValues,
[CanBeNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> logger,
CancellationToken cancellationToken = default)
{
Check.NotNull(connection, nameof(connection));
var dbCommand = CreateCommand(connection, parameterValues);
await connection.OpenAsync(cancellationToken);
var commandId = Guid.NewGuid();
var startTime = DateTimeOffset.UtcNow;
var stopwatch = Stopwatch.StartNew();
object result;
var readerOpen = false;
try
{
switch (executeMethod)
{
case DbCommandMethod.ExecuteNonQuery:
var nonQueryResult = logger == null
? null
: await logger.CommandNonQueryExecutingAsync(
dbCommand,
commandId,
connection.ConnectionId,
startTime : startTime,
cancellationToken);
var nonQueryValue = nonQueryResult.HasValue
? nonQueryResult.Value.Result
: await dbCommand.ExecuteNonQueryAsync(cancellationToken);
if (logger != null)
{
nonQueryValue = await logger.CommandNonQueryExecutedAsync(
dbCommand,
commandId,
connection.ConnectionId,
nonQueryValue,
startTime,
stopwatch.Elapsed,
cancellationToken);
}
result = nonQueryValue;
break;
case DbCommandMethod.ExecuteScalar:
var scalarResult = logger == null
? null
: await logger.CommandScalarExecutingAsync(
dbCommand,
commandId,
connection.ConnectionId,
startTime : startTime,
cancellationToken);
var scalarValue = scalarResult.HasValue
? scalarResult.Value.Result
: await dbCommand.ExecuteScalarAsync(cancellationToken);
if (logger != null)
{
scalarValue = await logger.CommandScalarExecutedAsync(
dbCommand,
commandId,
connection.ConnectionId,
scalarValue,
startTime,
stopwatch.Elapsed,
cancellationToken);
}
result = scalarValue;
break;
case DbCommandMethod.ExecuteReader:
var readerResult = logger == null
? null
: await logger.CommandReaderExecutingAsync(
dbCommand,
commandId,
connection.ConnectionId,
startTime : startTime,
cancellationToken);
var reader = readerResult.HasValue
? readerResult.Value.Result
: await dbCommand.ExecuteReaderAsync(cancellationToken);
if (logger != null)
{
reader = await logger.CommandReaderExecutedAsync(
dbCommand,
commandId,
connection.ConnectionId,
reader,
startTime,
stopwatch.Elapsed,
cancellationToken);
}
readerOpen = true;
result = new RelationalDataReader(
connection,
dbCommand,
reader,
commandId,
logger);
break;
default:
throw new NotSupportedException();
}
}
catch (Exception exception)
{
logger?.CommandError(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
exception,
true,
startTime,
stopwatch.Elapsed);
throw;
}
finally
{
if (!readerOpen)
{
dbCommand.Parameters.Clear();
dbCommand.Dispose();
connection.Close();
}
}
return(result);
}
public void OnCommandExecuting(DbCommand command, DbCommandMethod executeMethod, Guid commandId, Guid connectionId, bool async, DateTimeOffset startTime)
{
command.CommandText = command.CommandText.Replace(" [Stock]", " [dbo].[Stock]")
.Replace(" [dbo].[Stock]", " [dbname].[dbo].[Stock]");
}
protected override object Execute(IRelationalConnection connection, DbCommandMethod executeMethod, IReadOnlyDictionary <string, object> parameterValues)
{
return(ExecuteAsync(connection, executeMethod, parameterValues)
.GetAwaiter()
.GetResult());
}
private async Task <object> ExecuteAsync(
IOBehavior ioBehavior,
[NotNull] IRelationalConnection connection,
DbCommandMethod executeMethod,
[CanBeNull] IReadOnlyDictionary <string, object> parameterValues,
CancellationToken cancellationToken = default(CancellationToken))
{
Check.NotNull(connection, nameof(connection));
/*using (DbCommand */
_dbCommand = CreateCommand(connection, parameterValues); /*)*/
{
var fbConnection = connection as FbRelationalConnection;
object result;
var opened = false;
var commandId = Guid.NewGuid();
var startTime = DateTimeOffset.UtcNow;
var stopwatch = Stopwatch.StartNew();
try
{
if (ioBehavior == IOBehavior.Asynchronous)
{
// ReSharper disable once PossibleNullReferenceException
await fbConnection.OpenAsync(cancellationToken).ConfigureAwait(false);
}
else
{
// ReSharper disable once PossibleNullReferenceException
fbConnection.Open();
}
opened = true;
if (_dbCommand.CommandText.ToUpper().Contains("INSERT ") && _dbCommand.CommandText.ToUpper().Contains(" RETURNING "))
{
executeMethod = DbCommandMethod.ExecuteScalar;
}
switch (executeMethod)
{
case DbCommandMethod.ExecuteNonQuery:
{
result = ioBehavior == IOBehavior.Asynchronous ?
await _dbCommand.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false) :
_dbCommand.ExecuteNonQuery();
break;
}
case DbCommandMethod.ExecuteScalar:
{
result = ioBehavior == IOBehavior.Asynchronous ?
await _dbCommand.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false) :
_dbCommand.ExecuteScalar();
break;
}
case DbCommandMethod.ExecuteReader:
{
var dataReader = ioBehavior == IOBehavior.Asynchronous ?
await _dbCommand.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false) :
_dbCommand.ExecuteReader();
_wrp = new WrappedFirebirdDataReader(dataReader);
_rdr = new RelationalDataReader(connection, _dbCommand, _wrp, commandId, Logger);
result = _rdr;
break;
}
default:
{
throw new NotSupportedException();
}
}
Logger.CommandExecuted(
_dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
result,
ioBehavior == IOBehavior.Asynchronous,
startTime,
stopwatch.Elapsed);
}
catch (Exception exception)
{
Logger.CommandError(
_dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
exception,
ioBehavior == IOBehavior.Asynchronous,
startTime,
stopwatch.Elapsed);
if (opened)
{
connection.Close();
}
throw;
}
finally
{
_dbCommand.Parameters.Clear();
}
return(result);
}
}
protected override object Execute(
IRelationalConnection connection,
DbCommandMethod executeMethod,
IReadOnlyDictionary <string, object> parameterValues)
{
GaxPreconditions.CheckNotNull(connection, nameof(connection));
var dbCommand = CreateCommand(connection, parameterValues);
connection.Open();
var commandId = Guid.NewGuid();
var startTime = DateTimeOffset.UtcNow;
var stopwatch = Stopwatch.StartNew();
Logger.CommandExecuting(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
false,
startTime);
object result;
var readerOpen = false;
try
{
//Note that adds/updates/deletes get intercepted at the
//modificationcommandbatch level and normally do not get translated
//into ADO.NET commands here. However, there are features in EF that
//allow raw DML to be sent to the database which end up here and we need
//to create the proper command and throw a useful exception.
//TODO(benwu): there may be a way we can accept a non-DML text version of updates
// but we'll need to send it thru detailed design review.
switch (executeMethod)
{
case DbCommandMethod.ExecuteNonQuery:
{
result = dbCommand.ExecuteNonQuery();
break;
}
case DbCommandMethod.ExecuteScalar:
{
result = dbCommand.ExecuteScalar();
break;
}
case DbCommandMethod.ExecuteReader:
{
result
= new RelationalDataReader(
connection,
dbCommand,
dbCommand.ExecuteReader(),
commandId,
Logger);
readerOpen = true;
break;
}
default:
{
throw new NotSupportedException();
}
}
Logger.CommandExecuted(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
result,
false,
startTime,
stopwatch.Elapsed);
}
catch (Exception exception)
{
Logger.CommandError(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
exception,
false,
startTime,
stopwatch.Elapsed);
throw;
}
finally
{
if (!readerOpen)
{
dbCommand.Dispose();
connection.Close();
}
dbCommand.Parameters.Clear();
}
return(result);
}
private async Task <object> ExecuteAsync(
IOBehavior ioBehavior,
[NotNull] IRelationalConnection connection,
DbCommandMethod executeMethod,
[CanBeNull] IReadOnlyDictionary <string, object> parameterValues,
bool closeConnection = true,
CancellationToken cancellationToken = default(CancellationToken))
{
Check.NotNull(connection, nameof(connection));
using (var dbCommand = CreateCommand(connection, parameterValues))
{
var mySqlConnection = connection as MySqlRelationalConnection;
object result;
var opened = false;
var commandId = Guid.NewGuid();
var startTime = DateTimeOffset.UtcNow;
var stopwatch = Stopwatch.StartNew();
try
{
if (ioBehavior == IOBehavior.Asynchronous)
{
// ReSharper disable once PossibleNullReferenceException
await mySqlConnection.OpenAsync(false, cancellationToken).ConfigureAwait(false);
}
else
{
// ReSharper disable once PossibleNullReferenceException
mySqlConnection.Open();
}
opened = true;
switch (executeMethod)
{
case DbCommandMethod.ExecuteNonQuery:
{
result = ioBehavior == IOBehavior.Asynchronous ?
await dbCommand.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false) :
dbCommand.ExecuteNonQuery();
break;
}
case DbCommandMethod.ExecuteScalar:
{
result = ioBehavior == IOBehavior.Asynchronous ?
await dbCommand.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false) :
dbCommand.ExecuteScalar();
break;
}
case DbCommandMethod.ExecuteReader:
{
var dataReader = ioBehavior == IOBehavior.Asynchronous ?
await dbCommand.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false) :
dbCommand.ExecuteReader();
result = new RelationalDataReader(connection, dbCommand, new WrappedMySqlDataReader(dataReader), commandId, Logger);
break;
}
default:
{
throw new NotSupportedException();
}
}
Logger.CommandExecuted(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
result,
ioBehavior == IOBehavior.Asynchronous,
startTime,
stopwatch.Elapsed);
if (closeConnection)
{
connection.Close();
}
}
catch (Exception exception)
{
Logger.CommandError(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
exception,
ioBehavior == IOBehavior.Asynchronous,
startTime,
stopwatch.Elapsed);
if (opened)
{
connection.Close();
}
throw;
}
finally
{
dbCommand.Parameters.Clear();
}
return(result);
}
}
public void OnCommandExecuting(DbCommand command, DbCommandMethod executeMethod, Guid commandId, Guid connectionId, bool async, DateTimeOffset startTime)
{
}
/// <summary>
/// The method called by other methods on this type to execute synchronously.
/// </summary>
/// <param name="connection"> The connection to use. </param>
/// <param name="executeMethod"> The method type. </param>
/// <param name="parameterValues"> The parameter values. </param>
/// <param name="cancellationToken"> The cancellation token. </param>
/// <returns> The result of the execution. </returns>
protected virtual async Task <object> ExecuteAsync(
[NotNull] IRelationalConnection connection,
DbCommandMethod executeMethod,
[CanBeNull] IReadOnlyDictionary <string, object> parameterValues,
CancellationToken cancellationToken = default)
{
Check.NotNull(connection, nameof(connection));
var dbCommand = CreateCommand(connection, parameterValues);
await connection.OpenAsync(cancellationToken);
var commandId = Guid.NewGuid();
var startTime = DateTimeOffset.UtcNow;
var stopwatch = Stopwatch.StartNew();
Logger.CommandExecuting(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
async: true,
startTime: startTime);
object result;
var readerOpen = false;
try
{
switch (executeMethod)
{
case DbCommandMethod.ExecuteNonQuery:
{
result = await dbCommand.ExecuteNonQueryAsync(cancellationToken);
break;
}
case DbCommandMethod.ExecuteScalar:
{
result = await dbCommand.ExecuteScalarAsync(cancellationToken);
break;
}
case DbCommandMethod.ExecuteReader:
{
result = new RelationalDataReader(
connection,
dbCommand,
await dbCommand.ExecuteReaderAsync(cancellationToken),
commandId,
Logger);
readerOpen = true;
break;
}
default:
{
throw new NotSupportedException();
}
}
Logger.CommandExecuted(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
result,
true,
startTime,
stopwatch.Elapsed);
}
catch (Exception exception)
{
Logger.CommandError(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
exception,
true,
startTime,
stopwatch.Elapsed);
throw;
}
finally
{
if (!readerOpen)
{
dbCommand.Parameters.Clear();
dbCommand.Dispose();
connection.Close();
}
}
return(result);
}
/// <summary>
/// The method called by other methods on this type to execute synchronously.
/// </summary>
/// <param name="connection"> The connection to use. </param>
/// <param name="executeMethod"> The method type. </param>
/// <param name="parameterValues"> The parameter values. </param>
/// <param name="logger"> The command logger. </param>
/// <returns> The result of the execution. </returns>
protected virtual object Execute(
[NotNull] IRelationalConnection connection,
DbCommandMethod executeMethod,
[CanBeNull] IReadOnlyDictionary <string, object> parameterValues,
[CanBeNull] IDiagnosticsLogger <DbLoggerCategory.Database.Command> logger)
{
Check.NotNull(connection, nameof(connection));
var dbCommand = CreateCommand(connection, parameterValues);
connection.Open();
var commandId = Guid.NewGuid();
var startTime = DateTimeOffset.UtcNow;
var stopwatch = Stopwatch.StartNew();
logger?.CommandExecuting(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
async: false,
startTime: startTime);
object result;
var readerOpen = false;
try
{
switch (executeMethod)
{
case DbCommandMethod.ExecuteNonQuery:
{
result = dbCommand.ExecuteNonQuery();
break;
}
case DbCommandMethod.ExecuteScalar:
{
result = dbCommand.ExecuteScalar();
break;
}
case DbCommandMethod.ExecuteReader:
{
result
= new RelationalDataReader(
connection,
dbCommand,
dbCommand.ExecuteReader(),
commandId,
logger);
readerOpen = true;
break;
}
default:
{
throw new NotSupportedException();
}
}
logger?.CommandExecuted(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
result,
false,
startTime,
stopwatch.Elapsed);
}
catch (Exception exception)
{
logger?.CommandError(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
exception,
false,
startTime,
stopwatch.Elapsed);
throw;
}
finally
{
if (!readerOpen)
{
dbCommand.Parameters.Clear();
dbCommand.Dispose();
connection.Close();
}
}
return(result);
}
// TODO: Copy and paste base code again in 3.0.
// Then replace "RelationalDataReader" with "MySqlConverterRelationalDataReader".
// TODO: Remove entire method in 3.1.
// Replace with overridden implementation of "CreateRelationalDataReader".
/// <summary>
/// Uses the same code as in it's base class, except for returning a
/// ConverterRelationalDataReader instead of a RelationalDataReader.
/// </summary>
protected override object Execute(
IRelationalConnection connection,
DbCommandMethod executeMethod,
IReadOnlyDictionary <string, object> parameterValues)
{
if (connection == null)
{
throw new ArgumentNullException(nameof(connection));
}
var dbCommand = CreateCommand(connection, parameterValues);
connection.Open();
var commandId = Guid.NewGuid();
var startTime = DateTimeOffset.UtcNow;
var stopwatch = Stopwatch.StartNew();
Logger.CommandExecuting(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
async: false,
startTime: startTime);
object result;
var readerOpen = false;
try
{
switch (executeMethod)
{
case DbCommandMethod.ExecuteNonQuery:
{
result = dbCommand.ExecuteNonQuery();
break;
}
case DbCommandMethod.ExecuteScalar:
{
result = dbCommand.ExecuteScalar();
break;
}
case DbCommandMethod.ExecuteReader:
{
result
= new MySqlConverterRelationalDataReader(
connection,
dbCommand,
dbCommand.ExecuteReader(),
commandId,
Logger);
readerOpen = true;
break;
}
default:
{
throw new NotSupportedException();
}
}
Logger.CommandExecuted(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
result,
false,
startTime,
stopwatch.Elapsed);
}
catch (Exception exception)
{
Logger.CommandError(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
exception,
false,
startTime,
stopwatch.Elapsed);
throw;
}
finally
{
if (!readerOpen)
{
dbCommand.Parameters.Clear();
dbCommand.Dispose();
connection.Close();
}
}
return(result);
}
private async Task <object> ExecuteAsync(
IOBehavior ioBehavior,
[NotNull] IRelationalConnection connection,
DbCommandMethod executeMethod,
[CanBeNull] IReadOnlyDictionary <string, object> parameterValues,
CancellationToken cancellationToken = default(CancellationToken))
{
Check.NotNull(connection, nameof(connection));
var dbCommand = CreateCommand(connection, parameterValues);
var OracleConnection = connection as OracleRelationalConnection;
if (ioBehavior == IOBehavior.Asynchronous)
{
await OracleConnection.OpenAsync(cancellationToken, false).ConfigureAwait(false);
}
else
{
OracleConnection.Open();
}
var commandId = Guid.NewGuid();
var startTime = DateTimeOffset.UtcNow;
var stopwatch = Stopwatch.StartNew();
Logger.CommandExecuting(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
async: ioBehavior == IOBehavior.Asynchronous,
startTime: startTime);
object result;
var readerOpen = false;
try
{
switch (executeMethod)
{
case DbCommandMethod.ExecuteNonQuery:
{
result = ioBehavior == IOBehavior.Asynchronous ?
await dbCommand.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false) :
dbCommand.ExecuteNonQuery();
break;
}
case DbCommandMethod.ExecuteScalar:
{
result = ioBehavior == IOBehavior.Asynchronous ?
await dbCommand.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false) :
dbCommand.ExecuteScalar();
break;
}
case DbCommandMethod.ExecuteReader:
{
var dataReader = ioBehavior == IOBehavior.Asynchronous ?
await dbCommand.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false) :
dbCommand.ExecuteReader();
result = new RelationalDataReader(connection, dbCommand, new WrappedOracleDataReader(dataReader), commandId, Logger);
readerOpen = true;
break;
}
default:
{
throw new NotSupportedException();
}
}
Logger.CommandExecuted(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
result,
async: ioBehavior == IOBehavior.Asynchronous,
startTime: startTime,
duration: stopwatch.Elapsed);
}
catch (Exception exception)
{
Logger.CommandError(
dbCommand,
executeMethod,
commandId,
connection.ConnectionId,
exception,
async: ioBehavior == IOBehavior.Asynchronous,
startTime: startTime,
duration: stopwatch.Elapsed);
throw;
}
finally
{
dbCommand.Parameters.Clear();
if (!readerOpen)
{
dbCommand.Dispose();
connection.Close();
}
}
return(result);
}
