/// <summary> /// Executes the specified operation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation that handles processing the result of the command.</param> /// <param name="state">User supplied state.</param> protected override int?Execute(CommandExecutionToken <OleDbCommand, OleDbParameter> executionToken, CommandImplementation <OleDbCommand> implementation, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); try { using (var cmd = new OleDbCommand()) { cmd.Connection = m_Connection; cmd.Transaction = m_Transaction; executionToken.PopulateCommand(cmd, DefaultCommandTimeout); var rows = implementation(cmd); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return(rows); } } catch (Exception ex) { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }
/// <summary> /// Executes the specified implementation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation.</param> /// <param name="state">The state.</param> /// <returns>The caller is expected to use the StreamingCommandCompletionToken to close any lingering connections and fire appropriate events.</returns> /// <exception cref="System.NotImplementedException"></exception> public override StreamingCommandCompletionToken ExecuteStream(CommandExecutionToken <OleDbCommand, OleDbParameter> executionToken, StreamingCommandImplementation <OleDbCommand> implementation, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); try { var cmd = new OleDbCommand(); cmd.Connection = m_Connection; cmd.Transaction = m_Transaction; executionToken.PopulateCommand(cmd, DefaultCommandTimeout); implementation(cmd); return(new StreamingCommandCompletionToken(this, executionToken, startTime, state, cmd)); } catch (Exception ex) { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }
/// <summary> /// Executes the specified operation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation that handles processing the result of the command.</param> /// <param name="state">User supplied state.</param> /// <returns>System.Nullable<System.Int32>.</returns> /// <exception cref="ArgumentNullException">executionToken;executionToken is null. /// or /// implementation;implementation is null.</exception> protected override int?Execute(CommandExecutionToken <NpgsqlCommand, NpgsqlParameter> executionToken, CommandImplementation <NpgsqlCommand> implementation, object state) { if (executionToken == null) { throw new ArgumentNullException("executionToken", "executionToken is null."); } if (implementation == null) { throw new ArgumentNullException("implementation", "implementation is null."); } var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); try { using (var con = CreateConnection()) { using (var cmd = new NpgsqlCommand()) { cmd.Connection = con; if (DefaultCommandTimeout.HasValue) { cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; } cmd.CommandText = executionToken.CommandText; cmd.CommandType = executionToken.CommandType; foreach (var param in executionToken.Parameters) { cmd.Parameters.Add(param); } executionToken.ApplyCommandOverrides(cmd); int?rows; if (((PostgreSqlCommandExecutionToken)executionToken).DereferenceCursors) { rows = DereferenceCursors(cmd, implementation); } else { rows = implementation(cmd); } executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return(rows); } } } catch (Exception ex) { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }
/// <summary> /// execute as an asynchronous operation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation that handles processing the result of the command.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="state">User supplied state.</param> /// <returns>Task.</returns> /// <exception cref="ArgumentNullException"> /// executionToken;executionToken is null. /// or /// implementation;implementation is null. /// </exception> protected override async Task <int?> ExecuteAsync(CommandExecutionToken <MySqlCommand, MySqlParameter> executionToken, CommandImplementationAsync <MySqlCommand> implementation, CancellationToken cancellationToken, object state) { if (executionToken == null) { throw new ArgumentNullException("executionToken", "executionToken is null."); } if (implementation == null) { throw new ArgumentNullException("implementation", "implementation is null."); } var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); try { using (var con = await CreateConnectionAsync(cancellationToken).ConfigureAwait(false)) { using (var cmd = new MySqlCommand()) { cmd.Connection = con; if (DefaultCommandTimeout.HasValue) { cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; } cmd.CommandText = executionToken.CommandText; cmd.CommandType = executionToken.CommandType; foreach (var param in executionToken.Parameters) { cmd.Parameters.Add(param); } executionToken.ApplyCommandOverrides(cmd); var rows = await implementation(cmd).ConfigureAwait(false); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return(rows); } } } catch (Exception ex) { if (cancellationToken.IsCancellationRequested) //convert Exception into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionCanceled(executionToken, startTime, DateTimeOffset.Now, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } }
/// <summary> /// execute as an asynchronous operation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="state">The state.</param> /// <returns>Task.</returns> /// <exception cref="ArgumentNullException"> /// executionToken;executionToken is null. /// or /// implementation;implementation is null. /// </exception> protected override async Task <int?> ExecuteAsync(CommandExecutionToken <SQLiteCommand, SQLiteParameter> executionToken, CommandImplementationAsync <SQLiteCommand> implementation, CancellationToken cancellationToken, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var mode = DisableLocks ? LockType.None : (executionToken as SQLiteCommandExecutionToken)?.LockType ?? LockType.Write; var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); try { using (var cmd = new SQLiteCommand()) { cmd.Connection = m_Connection; cmd.Transaction = m_Transaction; if (DefaultCommandTimeout.HasValue) { cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; } cmd.CommandText = executionToken.CommandText; cmd.CommandType = executionToken.CommandType; foreach (var param in executionToken.Parameters) { cmd.Parameters.Add(param); } executionToken.ApplyCommandOverrides(cmd); var rows = await implementation(cmd).ConfigureAwait(false); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return(rows); } } catch (Exception ex) { if (cancellationToken.IsCancellationRequested) //convert SQLiteException into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex2, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } }
static TObject CaptureOutputParameters(CommandExecutionToken <TCommand, TParameter> commandToken) { var result = AsOutputsMaterializer <TCommand, TParameter> .CaptureOutputParameters(commandToken); var objectResult = new TObject(); MaterializerUtilities.PopulateComplexObject(result, objectResult, null); return(objectResult); }
/// <summary> /// Executes the specified operation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation that handles processing the result of the command.</param> /// <param name="state">User supplied state.</param> /// <exception cref="ArgumentNullException"> /// executionToken;executionToken is null. /// or /// implementation;implementation is null. /// </exception> protected override int?Execute(CommandExecutionToken <SQLiteCommand, SQLiteParameter> executionToken, CommandImplementation <SQLiteCommand> implementation, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var mode = DisableLocks ? LockType.None : (executionToken as SQLiteCommandExecutionToken)?.LockType ?? LockType.Write; var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); IDisposable?lockToken = null; try { switch (mode) { case LockType.Read: lockToken = SyncLock.ReaderLock(); break; case LockType.Write: lockToken = SyncLock.WriterLock(); break; } using (var cmd = new SQLiteCommand()) { cmd.Connection = m_Connection; if (m_Transaction != null) { cmd.Transaction = m_Transaction; } executionToken.PopulateCommand(cmd, DefaultCommandTimeout); var rows = implementation(cmd); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return(rows); } } catch (Exception ex) { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } finally { if (lockToken != null) { lockToken.Dispose(); } } }
/// <summary> /// Executes the operation asynchronously. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation that handles processing the result of the command.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="state">User supplied state.</param> /// <returns>Task.</returns> protected async override Task <int?> ExecuteAsync(CommandExecutionToken <NpgsqlCommand, NpgsqlParameter> executionToken, CommandImplementationAsync <NpgsqlCommand> implementation, CancellationToken cancellationToken, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); try { using (var cmd = new NpgsqlCommand()) { cmd.Connection = m_Connection; if (m_Transaction != null) { cmd.Transaction = m_Transaction; } executionToken.PopulateCommand(cmd, DefaultCommandTimeout); int?rows; if (((PostgreSqlCommandExecutionToken)executionToken).DereferenceCursors) { rows = await DereferenceCursorsAsync(cmd, implementation).ConfigureAwait(false); } else { rows = await implementation(cmd).ConfigureAwait(false); } executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return(rows); } } catch (Exception ex) { if (cancellationToken.IsCancellationRequested) //convert Exception into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionCanceled(executionToken, startTime, DateTimeOffset.Now, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } }
/// <summary> /// Executes the specified implementation asynchronously. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="state">The state.</param> /// <returns>The caller is expected to use the StreamingCommandCompletionToken to close any lingering connections and fire appropriate events.</returns> /// <exception cref="System.NotImplementedException"></exception> public override async Task <StreamingCommandCompletionToken> ExecuteStreamAsync(CommandExecutionToken <SqlCommand, SqlParameter> executionToken, StreamingCommandImplementationAsync <SqlCommand> implementation, CancellationToken cancellationToken, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); SqlConnection?con = null; try { con = await CreateConnectionAsync(cancellationToken).ConfigureAwait(false); var cmd = new SqlCommand(); cmd.Connection = con; executionToken.PopulateCommand(cmd, DefaultCommandTimeout); await implementation(cmd).ConfigureAwait(false); return(new StreamingCommandCompletionToken(this, executionToken, startTime, state, cmd, con)); } catch (Exception ex) { #if NET6_0_OR_GREATER if (con != null) { await con.DisposeAsync().ConfigureAwait(false); } #else con?.Dispose(); #endif if (cancellationToken.IsCancellationRequested) //convert Exception into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionCanceled(executionToken, startTime, DateTimeOffset.Now, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } }
/// <summary> /// Executes the specified implementation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation.</param> /// <param name="state">The state.</param> /// <returns>The caller is expected to use the StreamingCommandCompletionToken to close any lingering connections and fire appropriate events.</returns> public override StreamingCommandCompletionToken ExecuteStream(CommandExecutionToken <SQLiteCommand, SQLiteParameter> executionToken, StreamingCommandImplementation <SQLiteCommand> implementation, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var mode = DisableLocks ? LockType.None : (executionToken as SQLiteCommandExecutionToken)?.LockType ?? LockType.Write; var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); IDisposable? lockToken = null; SQLiteConnection?con = null; try { switch (mode) { case LockType.Read: lockToken = SyncLock.ReaderLock(); break; case LockType.Write: lockToken = SyncLock.WriterLock(); break; } con = CreateConnection(); var cmd = new SQLiteCommand(); cmd.Connection = con; executionToken.PopulateCommand(cmd, DefaultCommandTimeout); implementation(cmd); return(new StreamingCommandCompletionToken(this, executionToken, startTime, state, cmd, con) { LockToken = lockToken }); } catch (Exception ex) { lockToken?.Dispose(); con?.Dispose(); OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }
/// <summary> /// Executes the specified operation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation that handles processing the result of the command.</param> /// <param name="state">User supplied state.</param> /// <returns>System.Nullable<System.Int32>.</returns> /// <exception cref="ArgumentNullException">executionToken;executionToken is null. /// or /// implementation;implementation is null.</exception> protected override int?Execute(CommandExecutionToken <MySqlCommand, MySqlParameter> executionToken, CommandImplementation <MySqlCommand> implementation, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); try { using (var con = CreateConnection()) { using (var cmd = new MySqlCommand()) { cmd.Connection = con; if (DefaultCommandTimeout.HasValue) { cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; } cmd.CommandText = executionToken.CommandText; cmd.CommandType = executionToken.CommandType; foreach (var param in executionToken.Parameters) { cmd.Parameters.Add(param); } executionToken.ApplyCommandOverrides(cmd); var rows = implementation(cmd); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return(rows); } } } catch (Exception ex) { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }
/// <summary> /// Executes the specified implementation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation.</param> /// <param name="state">The state.</param> /// <returns>The caller is expected to use the StreamingCommandCompletionToken to close any lingering connections and fire appropriate events.</returns> /// <exception cref="System.NotImplementedException"></exception> public override StreamingCommandCompletionToken ExecuteStream(CommandExecutionToken <NpgsqlCommand, NpgsqlParameter> executionToken, StreamingCommandImplementation <NpgsqlCommand> implementation, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); NpgsqlConnection?con = null; try { con = CreateConnection(); var cmd = new NpgsqlCommand(); NpgsqlTransaction?transactionToClose = null; cmd.Connection = con; executionToken.PopulateCommand(cmd, DefaultCommandTimeout); if (((PostgreSqlCommandExecutionToken)executionToken).DereferenceCursors) { transactionToClose = DereferenceCursors(cmd, implementation); } else { implementation(cmd); } return(new StreamingCommandCompletionToken(this, executionToken, startTime, state, cmd, con) { Transaction = transactionToClose }); } catch (Exception ex) { con?.Dispose(); OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }
/// <summary> /// Executes the specified operation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation that handles processing the result of the command.</param> /// <param name="state">User supplied state.</param> protected override int?Execute(CommandExecutionToken <NpgsqlCommand, NpgsqlParameter> executionToken, CommandImplementation <NpgsqlCommand> implementation, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); try { using (var cmd = new NpgsqlCommand()) { cmd.Connection = m_Connection; if (m_Transaction != null) { cmd.Transaction = m_Transaction; } executionToken.PopulateCommand(cmd, DefaultCommandTimeout); int?rows; if (((PostgreSqlCommandExecutionToken)executionToken).DereferenceCursors) { rows = DereferenceCursors(cmd, implementation); } else { rows = implementation(cmd); } executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return(rows); } } catch (Exception ex) { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }
/// <summary> /// Executes the specified operation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation that handles processing the result of the command.</param> /// <param name="state">User supplied state.</param> /// <exception cref="ArgumentNullException"> /// executionToken;executionToken is null. /// or /// implementation;implementation is null. /// </exception> protected override int?Execute(CommandExecutionToken <OleDbCommand, OleDbParameter> executionToken, CommandImplementation <OleDbCommand> implementation, object state) { if (executionToken == null) { throw new ArgumentNullException("executionToken", "executionToken is null."); } if (implementation == null) { throw new ArgumentNullException("implementation", "implementation is null."); } var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); try { using (var cmd = new OleDbCommand()) { cmd.Connection = m_Connection; if (m_Transaction != null) { cmd.Transaction = m_Transaction; } if (DefaultCommandTimeout.HasValue) { cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; } cmd.CommandText = executionToken.CommandText; cmd.CommandType = executionToken.CommandType; foreach (var param in executionToken.Parameters) { cmd.Parameters.Add(param); } var rows = implementation(cmd); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return(rows); } } catch (Exception ex) { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }
/// <summary> /// Execute the operation asynchronously. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation that handles processing the result of the command.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="state">User supplied state.</param> /// <returns>Task.</returns> protected override async Task <int?> ExecuteAsync(CommandExecutionToken <SqlCommand, SqlParameter> executionToken, CommandImplementationAsync <SqlCommand> implementation, CancellationToken cancellationToken, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); try { using (var con = await CreateConnectionAsync(cancellationToken).ConfigureAwait(false)) { using (var cmd = new SqlCommand()) { cmd.Connection = con; executionToken.PopulateCommand(cmd, DefaultCommandTimeout); var rows = await implementation(cmd).ConfigureAwait(false); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return(rows); } } } catch (Exception ex) { if (cancellationToken.IsCancellationRequested) //convert Exception into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionCanceled(executionToken, startTime, DateTimeOffset.Now, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } }
/// <summary> /// Executes the specified implementation asynchronously. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="state">The state.</param> /// <returns>The caller is expected to use the StreamingCommandCompletionToken to close any lingering connections and fire appropriate events.</returns> /// <exception cref="System.NotImplementedException"></exception> public override async Task <StreamingCommandCompletionToken> ExecuteStreamAsync(CommandExecutionToken <MySqlCommand, MySqlParameter> executionToken, StreamingCommandImplementationAsync <MySqlCommand> implementation, CancellationToken cancellationToken, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); try { var cmd = new MySqlCommand(); cmd.Connection = m_Connection; if (m_Transaction != null) { cmd.Transaction = m_Transaction; } executionToken.PopulateCommand(cmd, DefaultCommandTimeout); await implementation(cmd).ConfigureAwait(false); return(new StreamingCommandCompletionToken(this, executionToken, startTime, state, cmd)); } catch (Exception ex) { if (cancellationToken.IsCancellationRequested) //convert Exception into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionCanceled(executionToken, startTime, DateTimeOffset.Now, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } }
internal static Dictionary <string, object?> CaptureOutputParameters(CommandExecutionToken <TCommand, TParameter> commandToken) { var result = new Dictionary <string, object?>(); foreach (var param in commandToken.Parameters .Where(p => p.Direction == ParameterDirection.Output || p.Direction == ParameterDirection.InputOutput)) { var name = param.ParameterName.Replace("@", "", StringComparison.OrdinalIgnoreCase); //TODO: Generalize this for all databases. //var name = CommandBuilder.DataSource.DatabaseMetadata.CleanParameterName(param.ParameterName); var value = param.Value == DBNull.Value ? null : param.Value; result[name] = value; } if (result.Count == 0) { throw new MappingException("No output parameters found."); } return(result); }
/// <summary> /// Executes the specified implementation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation.</param> /// <param name="state">The state.</param> /// <returns>The caller is expected to use the StreamingCommandCompletionToken to close any lingering connections and fire appropriate events.</returns> /// <exception cref="System.NotImplementedException"></exception> public override StreamingCommandCompletionToken ExecuteStream(CommandExecutionToken <MySqlCommand, MySqlParameter> executionToken, StreamingCommandImplementation <MySqlCommand> implementation, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); MySqlConnection?con = null; try { con = CreateConnection(); var cmd = new MySqlCommand(); cmd.Connection = con; executionToken.PopulateCommand(cmd, DefaultCommandTimeout); implementation(cmd); return(new StreamingCommandCompletionToken(this, executionToken, startTime, state, cmd, con)); } catch (Exception ex) { con?.Dispose(); OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }
/// <summary> /// Executes the specified operation asynchronously. /// </summary> /// <param name="executionToken"></param> /// <param name="implementation"></param> /// <param name="cancellationToken"></param> /// <param name="state"></param> /// <returns></returns> protected override async Task<int?> ExecuteAsync(CommandExecutionToken<SQLiteCommand, SQLiteParameter> executionToken, CommandImplementationAsync<SQLiteCommand> implementation, CancellationToken cancellationToken, object state) { if (executionToken == null) throw new ArgumentNullException("executionToken", "executionToken is null."); if (implementation == null) throw new ArgumentNullException("implementation", "implementation is null."); var mode = DisableLocks ? LockType.None : (executionToken as SQLiteCommandExecutionToken)?.LockType ?? LockType.Write; var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); IDisposable lockToken = null; try { switch (mode) { case LockType.Read: lockToken = await SyncLock.ReaderLockAsync().ConfigureAwait(false); break; case LockType.Write: lockToken = await SyncLock.WriterLockAsync().ConfigureAwait(false); break; } using (var con = await CreateConnectionAsync(cancellationToken).ConfigureAwait(false)) { using (var cmd = new SQLiteCommand()) { cmd.Connection = con; if (DefaultCommandTimeout.HasValue) cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; cmd.CommandText = executionToken.CommandText; cmd.CommandType = executionToken.CommandType; foreach (var param in executionToken.Parameters) cmd.Parameters.Add(param); executionToken.ApplyCommandOverrides(cmd); var rows = await implementation(cmd).ConfigureAwait(false); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return rows; } } } catch (Exception ex) { if (cancellationToken.IsCancellationRequested) //convert SQLiteException into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex2, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } finally { if (lockToken != null) lockToken.Dispose(); } }
/// <summary> /// Executes the specified operation asynchronously. /// </summary> /// <param name="executionToken"></param> /// <param name="implementation"></param> /// <param name="cancellationToken"></param> /// <param name="state"></param> /// <returns></returns> protected override async Task <int?> ExecuteAsync(CommandExecutionToken <OleDbCommand, OleDbParameter> executionToken, CommandImplementationAsync <OleDbCommand> implementation, CancellationToken cancellationToken, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var currentToken = executionToken as AccessCommandExecutionToken; if (currentToken == null) { throw new ArgumentNullException(nameof(executionToken), "only AccessCommandExecutionToken is supported."); } var startTime = DateTimeOffset.Now; try { using (var con = await CreateConnectionAsync(cancellationToken).ConfigureAwait(false)) { int?rows = null; while (currentToken != null) { OnExecutionStarted(currentToken, startTime, state); using (var cmd = new OleDbCommand()) { cmd.Connection = con; currentToken.PopulateCommand(cmd, DefaultCommandTimeout); if (currentToken.ExecutionMode == AccessCommandExecutionMode.Materializer) { rows = await implementation(cmd).ConfigureAwait(false); } else if (currentToken.ExecutionMode == AccessCommandExecutionMode.ExecuteScalarAndForward) { if (currentToken.ForwardResult == null) { throw new InvalidOperationException("currentToken.ExecutionMode is ExecuteScalarAndForward, but currentToken.ForwardResult is null."); } currentToken.ForwardResult(await cmd.ExecuteScalarAsync().ConfigureAwait(false)); } else { rows = await cmd.ExecuteNonQueryAsync().ConfigureAwait(false); } executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(currentToken, startTime, DateTimeOffset.Now, rows, state); } currentToken = currentToken.NextCommand; } return(rows); } } catch (Exception ex) { if (cancellationToken.IsCancellationRequested) //convert Exception into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex2, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } }
/// <summary> /// Executes the specified implementation asynchronously. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="state">The state.</param> /// <returns>The caller is expected to use the StreamingCommandCompletionToken to close any lingering connections and fire appropriate events.</returns> public override async Task <StreamingCommandCompletionToken> ExecuteStreamAsync(CommandExecutionToken <SQLiteCommand, SQLiteParameter> executionToken, StreamingCommandImplementationAsync <SQLiteCommand> implementation, CancellationToken cancellationToken, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var mode = DisableLocks ? LockType.None : (executionToken as SQLiteCommandExecutionToken)?.LockType ?? LockType.Write; var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); IDisposable? lockToken = null; SQLiteConnection?con = null; try { switch (mode) { case LockType.Read: lockToken = await SyncLock.ReaderLockAsync().ConfigureAwait(false); break; case LockType.Write: lockToken = await SyncLock.WriterLockAsync().ConfigureAwait(false); break; } con = await CreateConnectionAsync(cancellationToken).ConfigureAwait(false); var cmd = new SQLiteCommand(); cmd.Connection = con; executionToken.PopulateCommand(cmd, DefaultCommandTimeout); await implementation(cmd).ConfigureAwait(false); return(new StreamingCommandCompletionToken(this, executionToken, startTime, state, cmd, con) { LockToken = lockToken }); } catch (Exception ex) { lockToken?.Dispose(); #if NET6_0_OR_GREATER if (con != null) { await con.DisposeAsync().ConfigureAwait(false); } #else con?.Dispose(); #endif if (cancellationToken.IsCancellationRequested) //convert SQLiteException into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex2, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } }
/// <summary> /// Execute stream as an asynchronous operation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation.</param> /// <param name="cancellationToken">The cancellation token that can be used by other objects or threads to receive notice of cancellation.</param> /// <param name="state">The state.</param> /// <returns>A Task<StreamingCommandCompletionToken> representing the asynchronous operation.</returns> /// <exception cref="System.ArgumentNullException">executionToken</exception> /// <exception cref="System.ArgumentNullException">implementation</exception> /// <exception cref="System.ArgumentNullException">executionToken - only AccessCommandExecutionToken is supported.</exception> /// <exception cref="System.InvalidOperationException">currentToken.ExecutionMode is ExecuteScalarAndForward, but currentToken.ForwardResult is null.</exception> public override async Task <StreamingCommandCompletionToken> ExecuteStreamAsync(CommandExecutionToken <OleDbCommand, OleDbParameter> executionToken, StreamingCommandImplementationAsync <OleDbCommand> implementation, CancellationToken cancellationToken, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var currentToken = executionToken as AccessCommandExecutionToken; if (currentToken == null) { throw new ArgumentNullException(nameof(executionToken), "only AccessCommandExecutionToken is supported."); } var startTime = DateTimeOffset.Now; OleDbConnection?con = null; try { con = await CreateConnectionAsync(cancellationToken).ConfigureAwait(false); OleDbCommand?cmdToReturn = null; while (currentToken != null) { OnExecutionStarted(currentToken, startTime, state); using (var cmd = new OleDbCommand()) { cmd.Connection = con; currentToken.PopulateCommand(cmd, DefaultCommandTimeout); if (currentToken.ExecutionMode == AccessCommandExecutionMode.Materializer) { await implementation(cmd).ConfigureAwait(false); cmdToReturn = cmd; } else if (currentToken.ExecutionMode == AccessCommandExecutionMode.ExecuteScalarAndForward) { if (currentToken.ForwardResult == null) { throw new InvalidOperationException("currentToken.ExecutionMode is ExecuteScalarAndForward, but currentToken.ForwardResult is null."); } currentToken.ForwardResult(await cmd.ExecuteScalarAsync().ConfigureAwait(false)); } else { await cmd.ExecuteNonQueryAsync().ConfigureAwait(false); } } currentToken = currentToken.NextCommand; } return(new StreamingCommandCompletionToken(this, executionToken, startTime, state, cmdToReturn, con)); } catch (Exception ex) { #if NET6_0_OR_GREATER if (con != null) { await con.DisposeAsync().ConfigureAwait(false); } #else con?.Dispose(); #endif if (cancellationToken.IsCancellationRequested) //convert Exception into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex2, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } }
protected override int?Execute(CommandExecutionToken <OleDbCommand, OleDbParameter> executionToken, CommandImplementation <OleDbCommand> implementation, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var currentToken = executionToken as AccessCommandExecutionToken; if (currentToken == null) { throw new ArgumentNullException(nameof(executionToken), "only AccessCommandExecutionToken is supported."); } var startTime = DateTimeOffset.Now; try { using (var con = CreateConnection()) { int?rows = null; while (currentToken != null) { OnExecutionStarted(currentToken, startTime, state); using (var cmd = new OleDbCommand()) { cmd.Connection = con; currentToken.PopulateCommand(cmd, DefaultCommandTimeout); if (currentToken.ExecutionMode == AccessCommandExecutionMode.Materializer) { rows = implementation(cmd); } else if (currentToken.ExecutionMode == AccessCommandExecutionMode.ExecuteScalarAndForward) { if (currentToken.ForwardResult == null) { throw new InvalidOperationException("currentToken.ExecutionMode is ExecuteScalarAndForward, but currentToken.ForwardResult is null."); } currentToken.ForwardResult(cmd.ExecuteScalar()); } else { rows = cmd.ExecuteNonQuery(); } currentToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(currentToken, startTime, DateTimeOffset.Now, rows, state); } currentToken = currentToken.NextCommand; } return(rows); } } catch (Exception ex) { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }
protected override int? Execute(CommandExecutionToken<OleDbCommand, OleDbParameter> executionToken, CommandImplementation<OleDbCommand> implementation, object state) { if (executionToken == null) throw new ArgumentNullException("executionToken", "executionToken is null."); if (implementation == null) throw new ArgumentNullException("implementation", "implementation is null."); var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); try { using (var con = CreateConnection()) { using (var cmd = new OleDbCommand()) { cmd.Connection = con; if (DefaultCommandTimeout.HasValue) cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; cmd.CommandText = executionToken.CommandText; cmd.CommandType = executionToken.CommandType; foreach (var param in executionToken.Parameters) cmd.Parameters.Add(param); executionToken.ApplyCommandOverrides(cmd); var rows = implementation(cmd); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return rows; } } } catch (Exception ex) { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }
/// <summary> /// Executes the stream. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation.</param> /// <param name="state">The state.</param> /// <returns>StreamingCommandCompletionToken.</returns> /// <exception cref="System.ArgumentNullException">executionToken</exception> /// <exception cref="System.ArgumentNullException">implementation</exception> /// <exception cref="System.ArgumentNullException">executionToken - only AccessCommandExecutionToken is supported.</exception> /// <exception cref="System.InvalidOperationException">currentToken.ExecutionMode is ExecuteScalarAndForward, but currentToken.ForwardResult is null.</exception> public override StreamingCommandCompletionToken ExecuteStream(CommandExecutionToken <OleDbCommand, OleDbParameter> executionToken, StreamingCommandImplementation <OleDbCommand> implementation, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var currentToken = executionToken as AccessCommandExecutionToken; if (currentToken == null) { throw new ArgumentNullException(nameof(executionToken), "only AccessCommandExecutionToken is supported."); } var startTime = DateTimeOffset.Now; OleDbConnection?con = null; try { con = CreateConnection(); OleDbCommand?cmdToReturn = null; while (currentToken != null) { OnExecutionStarted(currentToken, startTime, state); var cmd = new OleDbCommand(); cmd.Connection = con; currentToken.PopulateCommand(cmd, DefaultCommandTimeout); if (currentToken.ExecutionMode == AccessCommandExecutionMode.Materializer) { implementation(cmd); cmdToReturn = cmd; } else if (currentToken.ExecutionMode == AccessCommandExecutionMode.ExecuteScalarAndForward) { if (currentToken.ForwardResult == null) { throw new InvalidOperationException("currentToken.ExecutionMode is ExecuteScalarAndForward, but currentToken.ForwardResult is null."); } currentToken.ForwardResult(cmd.ExecuteScalar()); } else { cmd.ExecuteNonQuery(); } currentToken = currentToken.NextCommand; } return(new StreamingCommandCompletionToken(this, executionToken, startTime, state, cmdToReturn, con)); } catch (Exception ex) { con?.Dispose(); OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }
protected override int? Execute(CommandExecutionToken<SQLiteCommand, SQLiteParameter> executionToken, CommandImplementation<SQLiteCommand> implementation, object state) { if (executionToken == null) throw new ArgumentNullException("executionToken", "executionToken is null."); if (implementation == null) throw new ArgumentNullException("implementation", "implementation is null."); var mode = DisableLocks ? LockType.None : (executionToken as SQLiteCommandExecutionToken)?.LockType ?? LockType.Write; var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); IDisposable lockToken = null; try { switch (mode) { case LockType.Read: lockToken = SyncLock.ReaderLock(); break; case LockType.Write: lockToken = SyncLock.WriterLock(); break; } using (var con = CreateConnection()) { using (var cmd = new SQLiteCommand()) { cmd.Connection = con; if (DefaultCommandTimeout.HasValue) cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; cmd.CommandText = executionToken.CommandText; //TODO: add potential check for this type. cmd.CommandType = executionToken.CommandType; foreach (var param in executionToken.Parameters) cmd.Parameters.Add(param); executionToken.ApplyCommandOverrides(cmd); var rows = implementation(cmd); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return rows; } } } catch (Exception ex) { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } finally { if (lockToken != null) lockToken.Dispose(); } }
protected override int?Execute(CommandExecutionToken <OleDbCommand, OleDbParameter> executionToken, CommandImplementation <OleDbCommand> implementation, object state) { if (executionToken == null) { throw new ArgumentNullException("executionToken", "executionToken is null."); } if (implementation == null) { throw new ArgumentNullException("implementation", "implementation is null."); } var currentToken = executionToken as AccessCommandExecutionToken; if (currentToken == null) { throw new ArgumentNullException("executionToken", "only AccessCommandExecutionToken is supported."); } var startTime = DateTimeOffset.Now; try { using (var con = CreateConnection()) { int?rows = null; while (currentToken != null) { OnExecutionStarted(currentToken, startTime, state); using (var cmd = new OleDbCommand()) { cmd.Connection = con; if (DefaultCommandTimeout.HasValue) { cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; } cmd.CommandText = currentToken.CommandText; cmd.CommandType = currentToken.CommandType; foreach (var param in currentToken.Parameters) { cmd.Parameters.Add(param); } currentToken.ApplyCommandOverrides(cmd); if (currentToken.ExecutionMode == AccessCommandExecutionMode.Materializer) { rows = implementation(cmd); } else if (currentToken.ExecutionMode == AccessCommandExecutionMode.ExecuteScalarAndForward) { currentToken.ForwardResult(cmd.ExecuteScalar()); } else { rows = cmd.ExecuteNonQuery(); } executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(currentToken, startTime, DateTimeOffset.Now, rows, state); } currentToken = currentToken.NextCommand; } return(rows); } } catch (Exception ex) { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }
/// <summary> /// Executes the specified operation asynchronously. /// </summary> /// <param name="executionToken"></param> /// <param name="implementation"></param> /// <param name="cancellationToken"></param> /// <param name="state"></param> /// <returns></returns> protected override async Task <int?> ExecuteAsync(CommandExecutionToken <OleDbCommand, OleDbParameter> executionToken, CommandImplementationAsync <OleDbCommand> implementation, CancellationToken cancellationToken, object state) { if (executionToken == null) { throw new ArgumentNullException("executionToken", "executionToken is null."); } if (implementation == null) { throw new ArgumentNullException("implementation", "implementation is null."); } var currentToken = executionToken as AccessCommandExecutionToken; if (currentToken == null) { throw new ArgumentNullException("executionToken", "only AccessCommandExecutionToken is supported."); } var startTime = DateTimeOffset.Now; try { using (var con = await CreateConnectionAsync(cancellationToken).ConfigureAwait(false)) { int?rows = null; while (currentToken != null) { OnExecutionStarted(currentToken, startTime, state); using (var cmd = new OleDbCommand()) { cmd.Connection = con; if (DefaultCommandTimeout.HasValue) { cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; } cmd.CommandText = currentToken.CommandText; cmd.CommandType = currentToken.CommandType; foreach (var param in currentToken.Parameters) { cmd.Parameters.Add(param); } currentToken.ApplyCommandOverrides(cmd); if (currentToken.ExecutionMode == AccessCommandExecutionMode.Materializer) { rows = await implementation(cmd); } else if (currentToken.ExecutionMode == AccessCommandExecutionMode.ExecuteScalarAndForward) { currentToken.ForwardResult(await cmd.ExecuteScalarAsync()); } else { rows = await cmd.ExecuteNonQueryAsync(); } executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(currentToken, startTime, DateTimeOffset.Now, rows, state); } currentToken = currentToken.NextCommand; } return(rows); } } catch (Exception ex) { if (cancellationToken.IsCancellationRequested) //convert Exception into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex2, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } }
Task <int?> ICommandDataSource <TCommand, TParameter> .ExecuteAsync(CommandExecutionToken <TCommand, TParameter> executionToken, CommandImplementationAsync <TCommand> implementation, CancellationToken cancellationToken, object state) { return(ExecuteAsync(executionToken, implementation, cancellationToken, state)); }
/// <summary> /// Executes the operation asynchronously. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation that handles processing the result of the command.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="state">User supplied state.</param> /// <returns>Task.</returns> /// <exception cref="NotImplementedException"></exception> protected override async Task <int?> ExecuteAsync(CommandExecutionToken <SQLiteCommand, SQLiteParameter> executionToken, CommandImplementationAsync <SQLiteCommand> implementation, CancellationToken cancellationToken, object?state) { if (executionToken == null) { throw new ArgumentNullException(nameof(executionToken), $"{nameof(executionToken)} is null."); } if (implementation == null) { throw new ArgumentNullException(nameof(implementation), $"{nameof(implementation)} is null."); } var mode = DisableLocks ? LockType.None : (executionToken as SQLiteCommandExecutionToken)?.LockType ?? LockType.Write; var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); IDisposable?lockToken = null; try { switch (mode) { case LockType.Read: lockToken = await SyncLock.ReaderLockAsync().ConfigureAwait(false); break; case LockType.Write: lockToken = await SyncLock.WriterLockAsync().ConfigureAwait(false); break; } using (var cmd = new SQLiteCommand()) { cmd.Connection = m_Connection; if (m_Transaction != null) { cmd.Transaction = m_Transaction; } executionToken.PopulateCommand(cmd, DefaultCommandTimeout); var rows = await implementation(cmd).ConfigureAwait(false); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return(rows); } } catch (Exception ex) { if (cancellationToken.IsCancellationRequested) //convert SQLiteException into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex2, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } finally { if (lockToken != null) { lockToken.Dispose(); } } }
/// <summary> /// Executes the operation asynchronously. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation that handles processing the result of the command.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="state">User supplied state.</param> /// <returns>Task.</returns> protected internal abstract Task <int?> ExecuteAsync(CommandExecutionToken <TCommand, TParameter> executionToken, CommandImplementationAsync <TCommand> implementation, CancellationToken cancellationToken, object state);
/// <summary> /// Executes the specified operation asynchronously. /// </summary> /// <param name="executionToken"></param> /// <param name="implementation"></param> /// <param name="cancellationToken"></param> /// <param name="state"></param> /// <returns></returns> protected override async Task<int?> ExecuteAsync(CommandExecutionToken<OleDbCommand, OleDbParameter> executionToken, CommandImplementationAsync<OleDbCommand> implementation, CancellationToken cancellationToken, object state) { if (executionToken == null) throw new ArgumentNullException("executionToken", "executionToken is null."); if (implementation == null) throw new ArgumentNullException("implementation", "implementation is null."); var currentToken = executionToken as AccessCommandExecutionToken; if (currentToken == null) throw new ArgumentNullException("executionToken", "only AccessCommandExecutionToken is supported."); var startTime = DateTimeOffset.Now; try { using (var con = await CreateConnectionAsync(cancellationToken).ConfigureAwait(false)) { int? rows = null; while (currentToken != null) { OnExecutionStarted(currentToken, startTime, state); using (var cmd = new OleDbCommand()) { cmd.Connection = con; if (DefaultCommandTimeout.HasValue) cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; cmd.CommandText = currentToken.CommandText; cmd.CommandType = currentToken.CommandType; foreach (var param in currentToken.Parameters) cmd.Parameters.Add(param); currentToken.ApplyCommandOverrides(cmd); if (currentToken.ExecutionMode == AccessCommandExecutionMode.Materializer) rows = await implementation(cmd); else if (currentToken.ExecutionMode == AccessCommandExecutionMode.ExecuteScalarAndForward) currentToken.ForwardResult(await cmd.ExecuteScalarAsync()); else rows = await cmd.ExecuteNonQueryAsync(); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(currentToken, startTime, DateTimeOffset.Now, rows, state); } currentToken = currentToken.NextCommand; } return rows; } } catch (Exception ex) { if (cancellationToken.IsCancellationRequested) //convert Exception into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex2, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } }
int?ICommandDataSource <TCommand, TParameter> .Execute(CommandExecutionToken <TCommand, TParameter> executionToken, CommandImplementation <TCommand> implementation, object state) { return(Execute(executionToken, implementation, state)); }
/// <summary> /// Execute the operation asynchronously. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation that handles processing the result of the command.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="state">User supplied state.</param> /// <returns>Task.</returns> protected override async Task<int?> ExecuteAsync(CommandExecutionToken<OleDbCommand, OleDbParameter> executionToken, CommandImplementationAsync<OleDbCommand> implementation, CancellationToken cancellationToken, object state) { if (executionToken == null) throw new ArgumentNullException("executionToken", "executionToken is null."); if (implementation == null) throw new ArgumentNullException("implementation", "implementation is null."); var startTime = DateTimeOffset.Now; OnExecutionStarted(executionToken, startTime, state); try { using (var con = await CreateConnectionAsync(cancellationToken).ConfigureAwait(false)) { using (var cmd = new OleDbCommand()) { cmd.Connection = con; if (DefaultCommandTimeout.HasValue) cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; cmd.CommandText = executionToken.CommandText; cmd.CommandType = executionToken.CommandType; foreach (var param in executionToken.Parameters) cmd.Parameters.Add(param); executionToken.ApplyCommandOverrides(cmd); var rows = await implementation(cmd).ConfigureAwait(false); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(executionToken, startTime, DateTimeOffset.Now, rows, state); return rows; } } } catch (Exception ex) { if (cancellationToken.IsCancellationRequested) //convert Exception into a OperationCanceledException { var ex2 = new OperationCanceledException("Operation was canceled.", ex, cancellationToken); OnExecutionCanceled(executionToken, startTime, DateTimeOffset.Now, state); throw ex2; } else { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } } }
/// <summary> /// Executes the specified operation. /// </summary> /// <param name="executionToken">The execution token.</param> /// <param name="implementation">The implementation that handles processing the result of the command.</param> /// <param name="state">User supplied state.</param> protected internal abstract int?Execute(CommandExecutionToken <TCommand, TParameter> executionToken, CommandImplementation <TCommand> implementation, object state);
protected override int? Execute(CommandExecutionToken<OleDbCommand, OleDbParameter> executionToken, CommandImplementation<OleDbCommand> implementation, object state) { if (executionToken == null) throw new ArgumentNullException("executionToken", "executionToken is null."); if (implementation == null) throw new ArgumentNullException("implementation", "implementation is null."); var currentToken = executionToken as AccessCommandExecutionToken; if (currentToken == null) throw new ArgumentNullException("executionToken", "only AccessCommandExecutionToken is supported."); var startTime = DateTimeOffset.Now; try { using (var con = CreateConnection()) { int? rows = null; while (currentToken != null) { OnExecutionStarted(currentToken, startTime, state); using (var cmd = new OleDbCommand()) { cmd.Connection = con; if (DefaultCommandTimeout.HasValue) cmd.CommandTimeout = (int)DefaultCommandTimeout.Value.TotalSeconds; cmd.CommandText = currentToken.CommandText; cmd.CommandType = currentToken.CommandType; foreach (var param in currentToken.Parameters) cmd.Parameters.Add(param); currentToken.ApplyCommandOverrides(cmd); if (currentToken.ExecutionMode == AccessCommandExecutionMode.Materializer) rows = implementation(cmd); else if (currentToken.ExecutionMode == AccessCommandExecutionMode.ExecuteScalarAndForward) currentToken.ForwardResult(cmd.ExecuteScalar()); else rows = cmd.ExecuteNonQuery(); executionToken.RaiseCommandExecuted(cmd, rows); OnExecutionFinished(currentToken, startTime, DateTimeOffset.Now, rows, state); } currentToken = currentToken.NextCommand; } return rows; } } catch (Exception ex) { OnExecutionError(executionToken, startTime, DateTimeOffset.Now, ex, state); throw; } }