/// <summary>
/// Review .NET Framework documentation.
/// </summary>
protected override int Update(DataRow[] dataRows, DataTableMapping tableMapping)
{
var updated = 0;
IDbCommand command = null;
var statementType = StatementType.Insert;
ICollection <IDbConnection> connections = new List <IDbConnection>();
RowUpdatingEventArgs updatingArgs = null;
Exception updateException = null;
foreach (var row in dataRows)
{
updateException = null;
if (row.RowState == DataRowState.Detached ||
row.RowState == DataRowState.Unchanged)
{
continue;
}
switch (row.RowState)
{
case DataRowState.Unchanged:
case DataRowState.Detached:
continue;
case DataRowState.Added:
command = InsertCommand;
statementType = StatementType.Insert;
break;
case DataRowState.Modified:
command = UpdateCommand;
statementType = StatementType.Update;
break;
case DataRowState.Deleted:
command = DeleteCommand;
statementType = StatementType.Delete;
break;
}
/* The order of execution can be reviewed in the .NET 1.1 documentation
*
* 1. The values in the DataRow are moved to the parameter values.
* 2. The OnRowUpdating event is raised.
* 3. The command executes.
* 4. If the command is set to FirstReturnedRecord, then the first returned result is placed in the DataRow.
* 5. If there are output parameters, they are placed in the DataRow.
* 6. The OnRowUpdated event is raised.
* 7 AcceptChanges is called.
*/
try
{
updatingArgs = CreateRowUpdatingEvent(row, command, statementType, tableMapping);
/* 1. Update Parameter values (It's very similar to what we
* are doing in the FbCommandBuilder class).
*
* Only input parameters should be updated.
*/
if (command != null && command.Parameters.Count > 0)
{
try
{
UpdateParameterValues(command, statementType, row, tableMapping);
}
catch (Exception ex)
{
updatingArgs.Errors = ex;
updatingArgs.Status = UpdateStatus.ErrorsOccurred;
}
}
// 2. Raise RowUpdating event
OnRowUpdating(updatingArgs);
if (updatingArgs.Status == UpdateStatus.SkipAllRemainingRows)
{
break;
}
else if (updatingArgs.Status == UpdateStatus.ErrorsOccurred)
{
if (updatingArgs.Errors == null)
{
throw new InvalidOperationException("RowUpdatingEvent: Errors occurred; no additional information is available.");
}
throw updatingArgs.Errors;
}
else if (updatingArgs.Status == UpdateStatus.SkipCurrentRow)
{
updated++;
continue;
}
else if (updatingArgs.Status == UpdateStatus.Continue)
{
if (command != updatingArgs.Command)
{
command = updatingArgs.Command;
}
if (command == null)
{
/* Samples of exceptions thrown by DbDataAdapter class
*
* Update requires a valid InsertCommand when passed DataRow collection with new rows
* Update requires a valid UpdateCommand when passed DataRow collection with modified rows.
* Update requires a valid DeleteCommand when passed DataRow collection with deleted rows.
*/
throw new InvalidOperationException(CreateExceptionMessage(statementType));
}
// 3. Execute the command
if (command.Connection.State == ConnectionState.Closed)
{
command.Connection.Open();
// Track command connection
connections.Add(command.Connection);
}
var rowsAffected = command.ExecuteNonQuery();
if (rowsAffected == 0)
{
throw new DBConcurrencyException(new DBConcurrencyException().Message, null, new DataRow[] { row });
}
updated++;
// http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=933212&SiteID=1
if (statementType == StatementType.Insert)
{
row.AcceptChanges();
}
/* 4. If the command is set to FirstReturnedRecord, then the
* first returned result is placed in the DataRow.
*
* We have nothing to do in this case as there are no
* support for batch commands.
*/
/* 5. Check if we have output parameters and they should
* be updated.
*
* Only output parameters should be updated
*/
if (command.UpdatedRowSource == UpdateRowSource.OutputParameters ||
command.UpdatedRowSource == UpdateRowSource.Both)
{
// Process output parameters
foreach (IDataParameter parameter in command.Parameters)
{
if ((parameter.Direction == ParameterDirection.Output ||
parameter.Direction == ParameterDirection.ReturnValue ||
parameter.Direction == ParameterDirection.InputOutput) &&
!string.IsNullOrEmpty(parameter.SourceColumn))
{
DataColumn column = null;
var columnMapping = tableMapping.GetColumnMappingBySchemaAction(
parameter.SourceColumn,
MissingMappingAction);
if (columnMapping != null)
{
column = columnMapping.GetDataColumnBySchemaAction(
row.Table,
null,
MissingSchemaAction);
if (column != null)
{
row[column] = parameter.Value;
}
}
}
}
}
}
}
catch (Exception ex)
{
row.RowError = ex.Message;
updateException = ex;
}
if (updatingArgs != null && updatingArgs.Status == UpdateStatus.Continue)
{
// 6. Raise RowUpdated event
var updatedArgs = CreateRowUpdatedEvent(row, command, statementType, tableMapping);
OnRowUpdated(updatedArgs);
if (updatedArgs.Status == UpdateStatus.SkipAllRemainingRows)
{
break;
}
else if (updatedArgs.Status == UpdateStatus.ErrorsOccurred)
{
if (updatingArgs.Errors == null)
{
throw new InvalidOperationException("RowUpdatedEvent: Errors occurred; no additional information available.");
}
throw updatedArgs.Errors;
}
else if (updatedArgs.Status == UpdateStatus.SkipCurrentRow)
{
}
else if (updatingArgs.Status == UpdateStatus.Continue)
{
// If the update result is an exception throw it
if (!ContinueUpdateOnError && updateException != null)
{
CloseConnections(connections);
throw updateException;
}
// 7. Call AcceptChanges
if (AcceptChangesDuringUpdate && !row.HasErrors)
{
row.AcceptChanges();
}
}
}
else
{
// If the update result is an exception throw it
if (!ContinueUpdateOnError && updateException != null)
{
CloseConnections(connections);
throw updateException;
}
}
}
CloseConnections(connections);
return(updated);
}
void DbDataAdapter.\u206A(RowUpdatingEventArgs _param1)
{
// ISSUE: unable to decompile the method.
}
private void OnRowUpdating(object sender, RowUpdatingEventArgs e)
{
RowUpdatingHandler(e);
}
protected override void OnRowUpdating(RowUpdatingEventArgs value)
{
throw new NotSupportedException();
}
void CrmCommandBuilder_RowUpdating(object sender, RowUpdatingEventArgs e)
{
base.RowUpdatingHandler(e);
}
private void RowUpdatingEventHandler(object sender, RowUpdatingEventArgs e)
{
base.RowUpdatingHandler(e);
}
private void RowUpdating(object sender, RowUpdatingEventArgs ruevent)
{
if (ruevent == null)
{
return;
}
if (ruevent.Command != null)
{
StatementType statementType = ruevent.StatementType;
switch (statementType)
{
case StatementType.Insert:
if (insertCommand != ruevent.Command)
{
return;
}
break;
case StatementType.Update:
if (updateCommand != ruevent.Command)
{
return;
}
break;
case StatementType.Delete:
if (deleteCommand != ruevent.Command)
{
return;
}
break;
default:
return;
}
}
try
{
BuildCache(false);
StatementType statementType = ruevent.StatementType;
switch (statementType)
{
case StatementType.Insert:
ruevent.Command = BuildInsertCommand(ruevent.TableMapping, ruevent.Row);
break;
case StatementType.Update:
ruevent.Command = BuildUpdateCommand(ruevent.TableMapping, ruevent.Row);
break;
case StatementType.Delete:
ruevent.Command = BuildDeleteCommand(ruevent.TableMapping, ruevent.Row);
break;
}
if (ruevent.Command == null)
{
if (ruevent.Row != null)
{
ruevent.Row.AcceptChanges();
}
ruevent.Status = UpdateStatus.SkipCurrentRow;
}
}
catch (Exception e)
{
ruevent.Errors = e;
ruevent.Status = UpdateStatus.ErrorsOccurred;
}
}
