// Copyright ?2004, 2014, Oracle and/or its affiliates. All rights reserved. // // MySQL Connector/NET is licensed under the terms of the GPLv2 // , like most // MySQL Connectors. There are special exceptions to the terms and // conditions of the GPLv2 as it is applied to this software, see the // FLOSS License Exception // . // // This program is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published // by the Free Software Foundation; version 2 of the License. // // This program is distributed in the hope that it will be useful, but // WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY // or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License // for more details. // // You should have received a copy of the GNU General Public License along // with this program; if not, write to the Free Software Foundation, Inc., // 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA #if MYSQL_6_9 using System; using System.Data; using System.Data.Common; using System.ComponentModel; using System.Collections.Generic; #if MYSQL_6_9 using System.Threading.Tasks; using System.Threading; #endif namespace Externals.MySql.Data.MySqlClient { [System.Drawing.ToolboxBitmap(typeof(MySqlDataAdapter), "MySqlClient.resources.dataadapter.bmp")] [System.ComponentModel.DesignerCategory("Code")] [Designer("Externals.MySql.Data.MySqlClient.Design.MySqlDataAdapterDesigner,MySqlClient.Design")] internal sealed class MySqlDataAdapter : DbDataAdapter, IDbDataAdapter, IDataAdapter, ICloneable { private bool loadingDefaults; private int updateBatchSize; List commandBatch; /// /// Occurs during Update before a command is executed against the data source. The attempt to update is made, so the event fires. /// public event MySqlRowUpdatingEventHandler RowUpdating; /// /// Occurs during Update after a command is executed against the data source. The attempt to update is made, so the event fires. /// public event MySqlRowUpdatedEventHandler RowUpdated; public MySqlDataAdapter() { loadingDefaults = true; updateBatchSize = 1; } public MySqlDataAdapter(MySqlCommand selectCommand) : this() { SelectCommand = selectCommand; } public MySqlDataAdapter(string selectCommandText, MySqlConnection connection) : this() { SelectCommand = new MySqlCommand(selectCommandText, connection); } public MySqlDataAdapter(string selectCommandText, string selectConnString) : this() { SelectCommand = new MySqlCommand(selectCommandText, new MySqlConnection(selectConnString)); } #region Properties [Description("Used during Update for deleted rows in Dataset.")] public new MySqlCommand DeleteCommand { get { return (MySqlCommand)base.DeleteCommand; } set { base.DeleteCommand = value; } } [Description("Used during Update for new rows in Dataset.")] public new MySqlCommand InsertCommand { get { return (MySqlCommand)base.InsertCommand; } set { base.InsertCommand = value; } } [Description("Used during Fill/FillSchema")] [Category("Fill")] public new MySqlCommand SelectCommand { get { return (MySqlCommand)base.SelectCommand; } set { base.SelectCommand = value; } } [Description("Used during Update for modified rows in Dataset.")] public new MySqlCommand UpdateCommand { get { return (MySqlCommand)base.UpdateCommand; } set { base.UpdateCommand = value; } } internal bool LoadDefaults { get { return loadingDefaults; } set { loadingDefaults = value; } } #endregion /// /// Open connection if it was closed. /// Necessary to workaround "connection must be open and valid" error /// with batched updates. /// /// Row state /// list of opened connections /// If connection is opened by this function, the list is updated /// /// true if connection was opened private void OpenConnectionIfClosed(DataRowState state, List openedConnections) { MySqlCommand cmd = null; switch (state) { case DataRowState.Added: cmd = InsertCommand; break; case DataRowState.Deleted: cmd = DeleteCommand; break; case DataRowState.Modified: cmd = UpdateCommand; break; default: return; } if (cmd != null && cmd.Connection != null && cmd.Connection.connectionState == ConnectionState.Closed) { cmd.Connection.Open(); openedConnections.Add(cmd.Connection); } } protected override int Update(DataRow[] dataRows, DataTableMapping tableMapping) { List connectionsOpened = new List(); try { // Open connections for insert/update/update commands, if // connections are closed. foreach (DataRow row in dataRows) { OpenConnectionIfClosed(row.RowState, connectionsOpened); } int ret = base.Update(dataRows, tableMapping); return ret; } finally { foreach (MySqlConnection c in connectionsOpened) c.Close(); } } #region Batching Support public override int UpdateBatchSize { get { return updateBatchSize; } set { updateBatchSize = value; } } protected override void InitializeBatching() { commandBatch = new List(); } protected override int AddToBatch(IDbCommand command) { // the first time each command is asked to be batched, we ask // that command to prepare its batchable command text. We only want // to do this one time for each command MySqlCommand commandToBatch = (MySqlCommand)command; if (commandToBatch.BatchableCommandText == null) commandToBatch.GetCommandTextForBatching(); IDbCommand cloneCommand = (IDbCommand)((ICloneable)command).Clone(); commandBatch.Add(cloneCommand); return commandBatch.Count - 1; } protected override int ExecuteBatch() { int recordsAffected = 0; int index = 0; while (index < commandBatch.Count) { MySqlCommand cmd = (MySqlCommand)commandBatch[index++]; for (int index2 = index; index2 < commandBatch.Count; index2++, index++) { MySqlCommand cmd2 = (MySqlCommand)commandBatch[index2]; if (cmd2.BatchableCommandText == null || cmd2.CommandText != cmd.CommandText) break; cmd.AddToBatch(cmd2); } recordsAffected += cmd.ExecuteNonQuery(); } return recordsAffected; } protected override void ClearBatch() { if (commandBatch.Count > 0) { MySqlCommand cmd = (MySqlCommand)commandBatch[0]; if (cmd.Batch != null) cmd.Batch.Clear(); } commandBatch.Clear(); } protected override void TerminateBatching() { ClearBatch(); commandBatch = null; } protected override IDataParameter GetBatchedParameter(int commandIdentifier, int parameterIndex) { return (IDataParameter)commandBatch[commandIdentifier].Parameters[parameterIndex]; } #endregion /// /// Overridden. See . /// /// /// /// /// /// override protected RowUpdatedEventArgs CreateRowUpdatedEvent(DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping) { return new MySqlRowUpdatedEventArgs(dataRow, command, statementType, tableMapping); } /// /// Overridden. See . /// /// /// /// /// /// override protected RowUpdatingEventArgs CreateRowUpdatingEvent(DataRow dataRow, IDbCommand command, StatementType statementType, DataTableMapping tableMapping) { return new MySqlRowUpdatingEventArgs(dataRow, command, statementType, tableMapping); } /// /// Overridden. Raises the RowUpdating event. /// /// A MySqlRowUpdatingEventArgs that contains the event data. override protected void OnRowUpdating(RowUpdatingEventArgs value) { if (RowUpdating != null) RowUpdating(this, (value as MySqlRowUpdatingEventArgs)); } /// /// Overridden. Raises the RowUpdated event. /// /// A MySqlRowUpdatedEventArgs that contains the event data. override protected void OnRowUpdated(RowUpdatedEventArgs value) { if (RowUpdated != null) RowUpdated(this, (value as MySqlRowUpdatedEventArgs)); } #if MYSQL_6_9 #region Async #region Fill /// /// Async version of Fill /// /// Dataset to use /// int public Task FillAsync(DataSet dataSet) { return FillAsync(dataSet, CancellationToken.None); } public Task FillAsync(DataSet dataSet, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var fillResult = base.Fill(dataSet); result.SetResult(fillResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of Fill /// /// Datatable to use /// int public Task FillAsync(DataTable dataTable) { return FillAsync(dataTable, CancellationToken.None); } public Task FillAsync(DataTable dataTable, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var fillResult = base.Fill(dataTable); result.SetResult(fillResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of Fill /// /// DataSet to use /// Source table /// int public Task FillAsync(DataSet dataSet, string srcTable) { return FillAsync(dataSet, srcTable, CancellationToken.None); } public Task FillAsync(DataSet dataSet, string srcTable, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var fillResult = base.Fill(dataSet, srcTable); result.SetResult(fillResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of Fill /// /// Datatable to use /// DataReader to use /// int public Task FillAsync(DataTable dataTable, IDataReader dataReader) { return FillAsync(dataTable, dataReader, CancellationToken.None); } public Task FillAsync(DataTable dataTable, IDataReader dataReader, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var fillResult = base.Fill(dataTable, dataReader); result.SetResult(fillResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of Fill /// /// DataTable to use /// DbCommand to use /// Command Behavior /// int public Task FillAsync(DataTable dataTable, IDbCommand command, CommandBehavior behavior) { return FillAsync(dataTable, command, behavior, CancellationToken.None); } public Task FillAsync(DataTable dataTable, IDbCommand command, CommandBehavior behavior, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var fillResult = base.Fill(dataTable, command, behavior); result.SetResult(fillResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of Fill /// /// Start record /// Max records /// DataTable[] to use /// int public Task FillAsync(int startRecord, int maxRecords, params DataTable[] dataTables) { return FillAsync(startRecord, maxRecords, CancellationToken.None, dataTables); } public Task FillAsync(int startRecord, int maxRecords, CancellationToken cancellationToken, params DataTable[] dataTables) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var fillResult = base.Fill(startRecord, maxRecords, dataTables); result.SetResult(fillResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of Fill /// /// DataSet to use /// Start record /// Max records /// Source table /// int public Task FillAsync(DataSet dataSet, int startRecord, int maxRecords, string srcTable) { return FillAsync(dataSet, startRecord, maxRecords, srcTable, CancellationToken.None); } public Task FillAsync(DataSet dataSet, int startRecord, int maxRecords, string srcTable, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var fillResult = base.Fill(dataSet, startRecord, maxRecords, srcTable); result.SetResult(fillResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of Fill /// /// DataSet to use /// Source table /// DataReader to use /// Start record /// Max records /// public Task FillAsync(DataSet dataSet, string srcTable, IDataReader dataReader, int startRecord, int maxRecords) { return FillAsync(dataSet, srcTable, dataReader, startRecord, maxRecords, CancellationToken.None); } public Task FillAsync(DataSet dataSet, string srcTable, IDataReader dataReader, int startRecord, int maxRecords, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var fillResult = base.Fill(dataSet, srcTable, dataReader, startRecord, maxRecords); result.SetResult(fillResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of Fill /// /// DataTable[] to use /// Start record /// Max records /// DbCommand to use /// Command Behavior /// public Task FillAsync(DataTable[] dataTables, int startRecord, int maxRecords, IDbCommand command, CommandBehavior behavior) { return FillAsync(dataTables, startRecord, maxRecords, command, behavior, CancellationToken.None); } public Task FillAsync(DataTable[] dataTables, int startRecord, int maxRecords, IDbCommand command, CommandBehavior behavior, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var fillResult = base.Fill(dataTables, startRecord, maxRecords, command, behavior); result.SetResult(fillResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of Fill /// /// DataSet to use /// Start record /// Max records /// Source table /// DbCommand to use /// Command Behavior /// public Task FillAsync(DataSet dataSet, int startRecord, int maxRecords, string srcTable, IDbCommand command, CommandBehavior behavior) { return FillAsync(dataSet, startRecord, maxRecords, srcTable, command, behavior, CancellationToken.None); } public Task FillAsync(DataSet dataSet, int startRecord, int maxRecords, string srcTable, IDbCommand command, CommandBehavior behavior, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var fillResult = base.Fill(dataSet, startRecord, maxRecords, srcTable, command, behavior); result.SetResult(fillResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } #endregion #region FillSchema /// /// Async version of FillSchema /// /// DataSet to use /// Schema Type /// DataTable[] public Task FillSchemaAsync(DataSet dataSet, SchemaType schemaType) { return FillSchemaAsync(dataSet, schemaType, CancellationToken.None); } public Task FillSchemaAsync(DataSet dataSet, SchemaType schemaType, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var schemaResult = base.FillSchema(dataSet, schemaType); result.SetResult(schemaResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of FillSchema /// /// DataSet to use /// Schema Type /// Source Table /// DataTable[] public Task FillSchemaAsync(DataSet dataSet, SchemaType schemaType, string srcTable) { return FillSchemaAsync(dataSet, schemaType, srcTable, CancellationToken.None); } public Task FillSchemaAsync(DataSet dataSet, SchemaType schemaType, string srcTable, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var schemaResult = base.FillSchema(dataSet, schemaType, srcTable); result.SetResult(schemaResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of FillSchema /// /// DataSet to use /// Schema Type /// Source Table /// DataReader to use /// DataTable[] public Task FillSchemaAsync(DataSet dataSet, SchemaType schemaType, string srcTable, IDataReader dataReader) { return FillSchemaAsync(dataSet, schemaType, srcTable, dataReader, CancellationToken.None); } public Task FillSchemaAsync(DataSet dataSet, SchemaType schemaType, string srcTable, IDataReader dataReader, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var schemaResult = base.FillSchema(dataSet, schemaType, srcTable, dataReader); result.SetResult(schemaResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of FillSchema /// /// DataSet to use /// Schema Type /// DBCommand to use /// Source Table /// Command Behavior /// DataTable[] public Task FillSchemaAsync(DataSet dataSet, SchemaType schemaType, IDbCommand command, string srcTable, CommandBehavior behavior) { return FillSchemaAsync(dataSet, schemaType, command, srcTable, behavior, CancellationToken.None); } public Task FillSchemaAsync(DataSet dataSet, SchemaType schemaType, IDbCommand command, string srcTable, CommandBehavior behavior, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var schemaResult = base.FillSchema(dataSet, schemaType, command, srcTable, behavior); result.SetResult(schemaResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of FillSchema /// /// DataTable to use /// Schema Type /// DataTable public Task FillSchemaAsync(DataTable dataTable, SchemaType schemaType) { return FillSchemaAsync(dataTable, schemaType, CancellationToken.None); } public Task FillSchemaAsync(DataTable dataTable, SchemaType schemaType, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var schemaResult = base.FillSchema(dataTable, schemaType); result.SetResult(schemaResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of FillSchema /// /// DataTable to use /// Schema Type /// DataReader to use /// DataTable public Task FillSchemaAsync(DataTable dataTable, SchemaType schemaType, IDataReader dataReader) { return FillSchemaAsync(dataTable, schemaType, dataReader, CancellationToken.None); } public Task FillSchemaAsync(DataTable dataTable, SchemaType schemaType, IDataReader dataReader, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var schemaResult = base.FillSchema(dataTable, schemaType, dataReader); result.SetResult(schemaResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of FillSchema /// /// DataTable to use /// Schema Type /// DBCommand to use /// Command Behavior /// DataTable public Task FillSchemaAsync(DataTable dataTable, SchemaType schemaType, IDbCommand command, CommandBehavior behavior) { return FillSchemaAsync(dataTable, schemaType, command, behavior, CancellationToken.None); } public Task FillSchemaAsync(DataTable dataTable, SchemaType schemaType, IDbCommand command, CommandBehavior behavior, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var schemaResult = base.FillSchema(dataTable, schemaType, command, behavior); result.SetResult(schemaResult); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } #endregion #region Update /// /// Async version of Update /// /// DataRow[] to use /// int public Task UpdateAsync(DataRow[] dataRows) { return UpdateAsync(dataRows, CancellationToken.None); } public Task UpdateAsync(DataRow[] dataRows, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var update = base.Update(dataRows); result.SetResult(update); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of Update /// /// DataSet to use /// int public Task UpdateAsync(DataSet dataSet) { return UpdateAsync(dataSet, CancellationToken.None); } public Task UpdateAsync(DataSet dataSet, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var update = base.Update(dataSet); result.SetResult(update); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of Update /// /// DataTable to use /// int public Task UpdateAsync(DataTable dataTable) { return UpdateAsync(dataTable, CancellationToken.None); } public Task UpdateAsync(DataTable dataTable, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var update = base.Update(dataTable); result.SetResult(update); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of Update /// /// DataRow[] to use /// Data Table Mapping /// int public Task UpdateAsync(DataRow[] dataRows, DataTableMapping tableMapping) { return UpdateAsync(dataRows, tableMapping, CancellationToken.None); } public Task UpdateAsync(DataRow[] dataRows, DataTableMapping tableMapping, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var update = base.Update(dataRows, tableMapping); result.SetResult(update); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } /// /// Async version of Update /// /// DataSet to use /// Source Table /// public Task UpdateAsync(DataSet dataSet, string srcTable) { return UpdateAsync(dataSet, srcTable, CancellationToken.None); } public Task UpdateAsync(DataSet dataSet, string srcTable, CancellationToken cancellationToken) { var result = new TaskCompletionSource(); if (cancellationToken == CancellationToken.None || !cancellationToken.IsCancellationRequested) { try { var update = base.Update(dataSet, srcTable); result.SetResult(update); } catch (Exception ex) { result.SetException(ex); } } else { result.SetCanceled(); } return result.Task; } #endregion #endregion #endif } /// /// Represents the method that will handle the event of a . /// internal delegate void MySqlRowUpdatingEventHandler(object sender, MySqlRowUpdatingEventArgs e); /// /// Represents the method that will handle the event of a . /// internal delegate void MySqlRowUpdatedEventHandler(object sender, MySqlRowUpdatedEventArgs e); /// /// Provides data for the RowUpdating event. This class cannot be inherited. /// internal sealed class MySqlRowUpdatingEventArgs : RowUpdatingEventArgs { /// /// Initializes a new instance of the MySqlRowUpdatingEventArgs class. /// /// The to /// . /// The to execute during . /// One of the values that specifies the type of query executed. /// The sent through an . public MySqlRowUpdatingEventArgs(DataRow row, IDbCommand command, StatementType statementType, DataTableMapping tableMapping) : base(row, command, statementType, tableMapping) { } /// /// Gets or sets the MySqlCommand to execute when performing the Update. /// new public MySqlCommand Command { get { return (MySqlCommand)base.Command; } set { base.Command = value; } } } /// /// Provides data for the RowUpdated event. This class cannot be inherited. /// internal sealed class MySqlRowUpdatedEventArgs : RowUpdatedEventArgs { /// /// Initializes a new instance of the MySqlRowUpdatedEventArgs class. /// /// The sent through an . /// The executed when is called. /// One of the values that specifies the type of query executed. /// The sent through an . public MySqlRowUpdatedEventArgs(DataRow row, IDbCommand command, StatementType statementType, DataTableMapping tableMapping) : base(row, command, statementType, tableMapping) { } /// /// Gets or sets the MySqlCommand executed when Update is called. /// new public MySqlCommand Command { get { return (MySqlCommand)base.Command; } } } } #endif