Recuperando valores de identidade ou numeração automática

Artigo
03/02/2024

Uma chave primária em um banco de dados relacional é uma coluna ou combinação de colunas que sempre contêm valores exclusivos. Conhecer o valor da chave primária permite localizar a linha que a contém. Os mecanismos de banco de dados relacional, como SQL Server, Oracle e Microsoft Access/Jet, oferecem suporte à criação de colunas de incremento automático que podem ser designadas como chaves primárias. Esses valores são gerados pelo servidor à medida que as linhas são adicionadas a uma tabela. No SQL Server, você define a propriedade identity de uma coluna, no Oracle você cria uma sequência e no Microsoft Access você cria uma coluna AutoNumeração.

A DataColumn também pode ser usado para gerar valores de incremento automático definindo a AutoIncrement propriedade como true. No entanto, você pode acabar com valores duplicados em instâncias separadas de um DataTable, se vários aplicativos cliente estiverem gerando valores de incremento automático de forma independente. Fazer com que o servidor gere automaticamente valores incrementais elimina potenciais conflitos, permitindo que cada usuário recupere o valor gerado para cada linha inserida.

Durante uma chamada para o Update método de um DataAdapter, o banco de dados pode enviar dados de volta para seu aplicativo ADO.NET como parâmetros de saída ou como o primeiro registro retornado do conjunto de resultados de uma instrução SELECT executada no mesmo lote que a instrução INSERT. ADO.NET pode recuperar esses valores e atualizar as colunas correspondentes na que está sendo DataRow atualizada.

Alguns mecanismos de banco de dados, como o mecanismo de banco de dados Microsoft Access Jet, não oferecem suporte a parâmetros de saída e não podem processar várias instruções em um único lote. Ao trabalhar com o mecanismo de banco de dados Jet, você pode recuperar o novo valor AutoNumber gerado para uma linha inserida executando um comando SELECT separado em um manipulador de eventos para o RowUpdated evento do DataAdapter.

Nota

Uma alternativa ao uso de um valor de incremento automático é usar o NewGuid método de um Guid objeto para gerar um GUID, ou identificador global exclusivo, no computador cliente que pode ser copiado para o servidor à medida que cada nova linha é inserida. O NewGuid método gera um valor binário de 16 bytes que é criado usando um algoritmo que fornece uma alta probabilidade de que nenhum valor será duplicado. Em um banco de dados do SQL Server, um GUID é armazenado em uma uniqueidentifier coluna que o SQL Server pode gerar automaticamente usando a função Transact-SQL NEWID() . Usar um GUID como chave primária pode afetar negativamente o desempenho. O SQL Server fornece suporte para a NEWSEQUENTIALID() função, que gera um GUID sequencial que não tem garantia de ser globalmente exclusivo, mas que pode ser indexado de forma mais eficiente.

Recuperando valores de coluna de identidade do SQL Server

Ao trabalhar com o Microsoft SQL Server, você pode criar um procedimento armazenado com um parâmetro de saída para retornar o valor de identidade para uma linha inserida. A tabela a seguir descreve as três funções Transact-SQL no SQL Server que podem ser usadas para recuperar valores de coluna de identidade.

Function	Description
SCOPE_IDENTITY	Retorna o último valor de identidade dentro do escopo de execução atual. SCOPE_IDENTITY é recomendado para a maioria dos cenários.
@@IDENTITY	Contém o último valor de identidade gerado em qualquer tabela na sessão atual. @@IDENTITY pode ser afetada por gatilhos e pode não retornar o valor de identidade esperado.
IDENT_CURRENT	Retorna o último valor de identidade gerado para uma tabela específica em qualquer sessão e escopo.

O procedimento armazenado a seguir demonstra como inserir uma linha na tabela Categorias e usar um parâmetro de saída para retornar o novo valor de identidade gerado pela função Transact-SQL SCOPE_IDENTITY().

CREATE PROCEDURE dbo.InsertCategory
  @CategoryName nvarchar(15),
  @Identity int OUT
AS
INSERT INTO Categories (CategoryName) VALUES(@CategoryName)
SET @Identity = SCOPE_IDENTITY()

O procedimento armazenado pode então ser especificado como a origem do InsertCommand de um SqlDataAdapter objeto. A CommandType propriedade do InsertCommand deve ser definida como StoredProcedure. A saída de identidade é recuperada criando um SqlParameter que tem um ParameterDirection de Output. Quando o InsertCommand é processado, o valor de identidade incrementado automaticamente é retornado e colocado na coluna CategoryID da linha atual se você definir a UpdatedRowSource propriedade do comando insert como UpdateRowSource.OutputParameters ou como UpdateRowSource.Both.

Se o comando insert executar um lote que inclui uma instrução INSERT e uma instrução SELECT que retorna o novo valor de identidade, você poderá recuperar o novo valor definindo a UpdatedRowSource propriedade do comando insert como UpdateRowSource.FirstReturnedRecord.

static void RetrieveIdentity(string connectionString)
{
    using (SqlConnection connection =
               new(connectionString))
    {
        // Create a SqlDataAdapter based on a SELECT query.
        SqlDataAdapter adapter =
            new(
            "SELECT CategoryID, CategoryName FROM dbo.Categories",
            connection)
            {
                //Create the SqlCommand to execute the stored procedure.
                InsertCommand = new SqlCommand("dbo.InsertCategory",
            connection)
                {
                    CommandType = CommandType.StoredProcedure
                }
            };

        // Add the parameter for the CategoryName. Specifying the
        // ParameterDirection for an input parameter is not required.
        adapter.InsertCommand.Parameters.Add(
           new SqlParameter("@CategoryName", SqlDbType.NVarChar, 15,
           "CategoryName"));

        // Add the SqlParameter to retrieve the new identity value.
        // Specify the ParameterDirection as Output.
        SqlParameter parameter =
            adapter.InsertCommand.Parameters.Add(
            "@Identity", SqlDbType.Int, 0, "CategoryID");
        parameter.Direction = ParameterDirection.Output;

        // Create a DataTable and fill it.
        DataTable categories = new();
        adapter.Fill(categories);

        // Add a new row.
        DataRow newRow = categories.NewRow();
        newRow["CategoryName"] = "New Category";
        categories.Rows.Add(newRow);

        adapter.Update(categories);

        Console.WriteLine("List All Rows:");
        foreach (DataRow row in categories.Rows)
        {
            {
                Console.WriteLine("{0}: {1}", row[0], row[1]);
            }
        }
    }
}

Private Sub RetrieveIdentity(ByVal connectionString As String)
    Using connection As SqlConnection = New SqlConnection( _
       connectionString)

        ' Create a SqlDataAdapter based on a SELECT query.
        Dim adapter As SqlDataAdapter = New SqlDataAdapter( _
           "SELECT CategoryID, CategoryName FROM dbo.Categories", _
           connection)

        ' Create the SqlCommand to execute the stored procedure. 
        adapter.InsertCommand = New SqlCommand("dbo.InsertCategory", _
           connection)
        adapter.InsertCommand.CommandType = CommandType.StoredProcedure

        ' Add the parameter for the CategoryName. Specifying the
        ' ParameterDirection for an input parameter is not required.
        adapter.InsertCommand.Parameters.Add( _
          "@CategoryName", SqlDbType.NVarChar, 15, "CategoryName")

        ' Add the SqlParameter to retrieve the new identity value.
        ' Specify the ParameterDirection as Output.
        Dim parameter As SqlParameter = _
           adapter.InsertCommand.Parameters.Add( _
          "@Identity", SqlDbType.Int, 0, "CategoryID")
        parameter.Direction = ParameterDirection.Output

        ' Create a DataTable and fill it.
        Dim categories As DataTable = New DataTable
        adapter.Fill(categories)

        ' Add a new row.
        Dim newRow As DataRow = categories.NewRow()
        newRow("CategoryName") = "New Category"
        categories.Rows.Add(newRow)

        ' Update the database.
        adapter.Update(categories)

        Console.WriteLine("List All Rows:")
        Dim row As DataRow
        For Each row In categories.Rows
            Console.WriteLine("{0}: {1}", row(0), row(1))
        Next
    End Using
End Sub

Mesclando novos valores de identidade

Um cenário comum é chamar o GetChanges método de a DataTable para criar uma cópia que contenha apenas linhas alteradas e usar a nova cópia ao chamar o Update método de um DataAdapter. Isso é especialmente útil quando você precisa organizar as linhas alteradas para um componente separado que executa a atualização. Após a atualização, a cópia pode conter novos valores de identidade que devem ser mesclados de volta ao original DataTable. É provável que os novos valores de identidade sejam diferentes dos valores originais no DataTable. Para realizar a mesclagem, os valores originais das colunas AutoIncrement na cópia devem ser preservados, a fim de poder localizar e atualizar linhas existentes no originalDataTable, em vez de acrescentar novas linhas contendo os novos valores de identidade. No entanto, por padrão, esses valores originais são perdidos após uma chamada para o Update método de um DataAdapter, porque AcceptChanges é implicitamente chamado para cada atualização DataRow.

Há duas maneiras de preservar os valores originais de a DataColumn em um DataRow durante uma DataAdapter atualização:

O primeiro método de preservar os valores originais é definir a AcceptChangesDuringUpdate propriedade do DataAdapter para false. Isso afeta todos DataRow os que estão sendo DataTable atualizados. Para obter mais informações e um exemplo de código, consulte AcceptChangesDuringUpdate.
O segundo método é escrever código no RowUpdated manipulador de eventos do DataAdapter para definir o Status como SkipCurrentRow. O DataRow é atualizado, mas o valor original de cada DataColumn um é preservado. Esse método permite que você preserve os valores originais para algumas linhas e não para outras. Por exemplo, seu código pode preservar os valores originais para linhas adicionadas e não para linhas editadas ou excluídas marcando primeiro o e, em StatementType seguida, definindo Status como SkipCurrentRow somente para linhas com um StatementType de Insert.

Quando um desses métodos é usado para preservar valores originais em um DataRow durante uma DataAdapter atualização, ADO.NET executa uma série de ações para definir os valores atuais do para novos valores retornados DataRow por parâmetros de saída ou pela primeira linha retornada de um conjunto de resultados, preservando ainda o valor original em cada DataColumn. Primeiro, o AcceptChanges método do DataRow é chamado para preservar os valores atuais como valores originais e, em seguida, os novos valores são atribuídos. Após essas ações, DataRows quem teve sua RowState propriedade definida terá Added sua RowState propriedade definida como , o Modifiedque pode ser inesperado.

A forma como os resultados do comando são aplicados a cada DataRow um que está sendo atualizado é determinada pela UpdatedRowSource propriedade de cada DbCommand. Esta propriedade é definida como um valor da UpdateRowSource enumeração.

A tabela a seguir descreve como os UpdateRowSource valores de enumeração afetam a RowState propriedade de linhas atualizadas.

Nome do membro	Description
Both	`AcceptChanges` é chamado e os valores dos parâmetros de saída e/ou os valores na primeira linha de qualquer conjunto de resultados retornado são colocados na `DataRow` atualização. Caso não haja valores a aplicar, o `RowState` será Unchanged.
FirstReturnedRecord	Se uma linha foi retornada, `AcceptChanges` é chamada e a linha é mapeada para a linha alterada no `DataTable`, definindo como `ModifiedRowState` . Se nenhuma linha é retornada, então `AcceptChanges` não é chamado e os `RowState` restantes `Added`.
None	Todos os parâmetros ou linhas retornados são ignorados. Não há chamada para `AcceptChanges` e os `RowState` restos mortais `Added`.
OutputParameters	`AcceptChanges` é chamado e todos os parâmetros de saída são mapeados para a linha alterada no `DataTable`, definindo o `RowState` para `Modified`. Se não houver parâmetros de saída, o `RowState` será `Unchanged`.

Exemplo

Este exemplo demonstra extrair linhas alteradas de a DataTable e usar a SqlDataAdapter para atualizar a fonte de dados e recuperar um novo valor de coluna de identidade. O InsertCommand executa duas instruções Transact-SQL: a primeira é a instrução INSERT e a segunda é uma instrução SELECT que usa a função SCOPE_IDENTITY para recuperar o valor de identidade.

INSERT INTO dbo.Shippers (CompanyName)
VALUES (@CompanyName);
SELECT ShipperID, CompanyName FROM dbo.Shippers
WHERE ShipperID = SCOPE_IDENTITY();

A UpdatedRowSource propriedade do comando insert é definida como UpdateRowSource.FirstReturnedRow e a MissingSchemaActionDataAdapter propriedade do é definida como MissingSchemaAction.AddWithKey. O DataTable é preenchido e o código adiciona uma nova linha ao DataTable. As linhas alteradas são então extraídas para um novo DataTable, que é passado para o DataAdapter, que então atualiza o servidor.

static void MergeIdentityColumns(string connectionString)
{
    using (SqlConnection connection =
               new(connectionString))
    {
        // Create the DataAdapter
        SqlDataAdapter adapter =
            new(
            "SELECT ShipperID, CompanyName FROM dbo.Shippers",
            connection)
            {
                //Add the InsertCommand to retrieve new identity value.
                InsertCommand = new SqlCommand(
            "INSERT INTO dbo.Shippers (CompanyName) " +
            "VALUES (@CompanyName); " +
            "SELECT ShipperID, CompanyName FROM dbo.Shippers " +
            "WHERE ShipperID = SCOPE_IDENTITY();", connection)
            };

        // Add the parameter for the inserted value.
        adapter.InsertCommand.Parameters.Add(
           new SqlParameter("@CompanyName", SqlDbType.NVarChar, 40,
           "CompanyName"));
        adapter.InsertCommand.UpdatedRowSource = UpdateRowSource.Both;

        // MissingSchemaAction adds any missing schema to
        // the DataTable, including identity columns
        adapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;

        // Fill the DataTable.
        DataTable shipper = new();
        adapter.Fill(shipper);

        // Add a new shipper.
        DataRow newRow = shipper.NewRow();
        newRow["CompanyName"] = "New Shipper";
        shipper.Rows.Add(newRow);

        // Add changed rows to a new DataTable. This
        // DataTable will be used by the DataAdapter.
        DataTable dataChanges = shipper.GetChanges()!;

        // Add the event handler.
        adapter.RowUpdated +=
             OnRowUpdated;

        adapter.Update(dataChanges);
        connection.Close();

        // Merge the updates.
        shipper.Merge(dataChanges);

        // Commit the changes.
        shipper.AcceptChanges();

        Console.WriteLine("Rows after merge.");
        foreach (DataRow row in shipper.Rows)
        {
            {
                Console.WriteLine("{0}: {1}", row[0], row[1]);
            }
        }
    }
}

Private Sub MergeIdentityColumns(ByVal connectionString As String)

    Using connection As SqlConnection = New SqlConnection( _
       connectionString)

        ' Create the DataAdapter
        Dim adapter As SqlDataAdapter = New SqlDataAdapter( _
          "SELECT ShipperID, CompanyName FROM dbo.Shippers", connection)

        ' Add the InsertCommand to retrieve new identity value.
        adapter.InsertCommand = New SqlCommand( _
            "INSERT INTO dbo.Shippers (CompanyName) " & _
            "VALUES (@CompanyName); " & _
            "SELECT ShipperID, CompanyName FROM dbo.Shippers " & _
            "WHERE ShipperID = SCOPE_IDENTITY();", _
            connection)

        ' Add the parameter for the inserted value.
        adapter.InsertCommand.Parameters.Add( _
           New SqlParameter("@CompanyName", SqlDbType.NVarChar, 40, _
           "CompanyName"))
        adapter.InsertCommand.UpdatedRowSource = UpdateRowSource.Both

        ' MissingSchemaAction adds any missing schema to 
        ' the DataTable, including identity columns
        adapter.MissingSchemaAction = MissingSchemaAction.AddWithKey

        ' Fill the DataTable.
        Dim shipper As New DataTable
        adapter.Fill(shipper)

        ' Add a new shipper. 
        Dim newRow As DataRow = shipper.NewRow()
        newRow("CompanyName") = "New Shipper"
        shipper.Rows.Add(newRow)

        ' Add changed rows to a new DataTable. This
        ' DataTable will be used by the DataAdapter.
        Dim dataChanges As DataTable = shipper.GetChanges()

        ' Add the event handler. 
        AddHandler adapter.RowUpdated, New _
           SqlRowUpdatedEventHandler(AddressOf OnRowUpdated)

        ' Update the datasource with the modified records.
        adapter.Update(dataChanges)

        ' Merge the two DataTables.
        shipper.Merge(dataChanges)

        ' Commit the changes.
        shipper.AcceptChanges()

        Console.WriteLine("Rows after merge.")
        Dim row As DataRow
        For Each row In shipper.Rows
            Console.WriteLine("{0}: {1}", row(0), row(1))
        Next
    End Using
End Sub

O OnRowUpdated manipulador de eventos verifica o StatementType SqlRowUpdatedEventArgs do para determinar se a linha é uma inserção. Se for, então a Status propriedade é definida como SkipCurrentRow. A linha é atualizada, mas os valores originais na linha são preservados. No corpo principal do procedimento, o Merge método é chamado para mesclar o novo valor de identidade no original DataTablee, finalmente AcceptChanges , é chamado.

protected static void OnRowUpdated(
    object sender, SqlRowUpdatedEventArgs e)
{
    // If this is an insert, then skip this row.
    if (e.StatementType == StatementType.Insert)
    {
        e.Status = UpdateStatus.SkipCurrentRow;
    }
}

Private Sub OnRowUpdated( _
    ByVal sender As Object, ByVal e As SqlRowUpdatedEventArgs)
    ' If this is an insert, then skip this row.
    If e.StatementType = StatementType.Insert Then
        e.Status = UpdateStatus.SkipCurrentRow
    End If
End Sub

Recuperando valores de numeração automática do Microsoft Access

Esta seção inclui um exemplo que mostra como recuperar Autonumber valores de um banco de dados Jet 4.0. O mecanismo de banco de dados Jet não suporta a execução de várias instruções em um lote ou o uso de parâmetros de saída, portanto, não é possível usar qualquer uma dessas técnicas para retornar o novo Autonumber valor atribuído a uma linha inserida. No entanto, você pode adicionar código ao RowUpdated manipulador de eventos que executa uma instrução SELECT @@IDENTITY separada para recuperar o novo Autonumber valor.

Exemplo

Em vez de adicionar informações de esquema usando MissingSchemaAction.AddWithKey, este exemplo configura um DataTable com o esquema correto antes de chamar o para preencher o OleDbDataAdapterDataTable. Nesse caso, a coluna CategoryID é configurada para diminuir o valor atribuído a cada linha inserida a partir de zero, definindo AutoIncrement como true, AutoIncrementSeed para 0 e AutoIncrementStep para -1. Em seguida, o código adiciona duas novas linhas e usa GetChanges para adicionar as linhas alteradas a uma nova DataTable que é passada para o Update método.

static OleDbConnection s_connection = default!;

static void MergeIdentityColumns(OleDbConnection connection)
{
    using (connection)
    {
        // Create a DataAdapter based on a SELECT query.
        OleDbDataAdapter adapter = new(
         "SELECT CategoryID, CategoryName FROM Categories",
         connection)
        {
            // Create the INSERT command for the new category.
            InsertCommand = new OleDbCommand(
          "INSERT INTO Categories (CategoryName) Values(?)", connection)
            {
                CommandType = CommandType.Text
            }
        };

        // Add the parameter for the CategoryName.
        adapter.InsertCommand.Parameters.Add(
          "@CategoryName", OleDbType.VarWChar, 15, "CategoryName");
        adapter.InsertCommand.UpdatedRowSource = UpdateRowSource.Both;

        // Create a DataTable
        DataTable categories = new();

        // Create the CategoryID column and set its auto
        // incrementing properties to decrement from zero.
        DataColumn catId = new()
        {
            DataType = Type.GetType("System.Int32"),
            ColumnName = "CategoryID",
            AutoIncrement = true,
            AutoIncrementSeed = 0,
            AutoIncrementStep = -1
        };
        categories.Columns.Add(catId);

        // Create the CategoryName column.
        categories.Columns.Add(new DataColumn
        {
            DataType = Type.GetType("System.String"),
            ColumnName = "CategoryName"
        });

        // Set the primary key on CategoryID.
        var pKey = new DataColumn[] { catId };
        categories.PrimaryKey = pKey;

        // Fetch the data and fill the DataTable
        adapter.Fill(categories);

        // Add a new row.
        DataRow newRow = categories.NewRow();
        newRow["CategoryName"] = "New Category";
        categories.Rows.Add(newRow);

        // Add another new row.
        DataRow newRow2 = categories.NewRow();
        newRow2["CategoryName"] = "Another New Category";
        categories.Rows.Add(newRow2);

        // Add changed rows to a new DataTable that will be
        // used to post the inserts to the database.
        DataTable dataChanges = categories.GetChanges()!;

        // Include an event to fill in the Autonumber value.
        adapter.RowUpdated +=
             OnRowUpdated;

        // Update the database, inserting the new rows.
        adapter.Update(dataChanges);

        Console.WriteLine("Rows before merge:");
        foreach (DataRow row in categories.Rows)
        {
            {
                Console.WriteLine("  {0}: {1}", row[0], row[1]);
            }
        }

        // Merge the two DataTables.
        categories.Merge(dataChanges);

        // Commit the changes.
        categories.AcceptChanges();

        Console.WriteLine("Rows after merge:");
        foreach (DataRow row in categories.Rows)
        {
            {
                Console.WriteLine("  {0}: {1}", row[0], row[1]);
            }
        }
    }
}

Shared connection As OleDbConnection = Nothing

Private Shared Sub MergeIdentityColumns(ByVal connection As OleDbConnection)
    Using connection

        ' Create a DataAdapter based on a SELECT query.
        Dim adapter As OleDbDataAdapter = New OleDbDataAdapter( _
          "SELECT CategoryID, CategoryName FROM Categories", _
          connection)

        ' Create the INSERT command for the new category.
        adapter.InsertCommand = New OleDbCommand( _
          "INSERT INTO Categories (CategoryName) Values(?)", connection)
        adapter.InsertCommand.CommandType = CommandType.Text

        ' Add the parameter for the CategoryName.
        adapter.InsertCommand.Parameters.Add( _
          "@CategoryName", OleDbType.VarWChar, 15, "CategoryName")
        adapter.InsertCommand.UpdatedRowSource = UpdateRowSource.Both

        ' Create a DataTable.
        Dim categories As DataTable = New DataTable

        ' Create the CategoryID column and set its auto
        ' incrementing properties to decrement from zero.
        Dim column As New DataColumn()
        column.DataType = System.Type.GetType("System.Int32")
        column.ColumnName = "CategoryID"
        column.AutoIncrement = True
        column.AutoIncrementSeed = 0
        column.AutoIncrementStep = -1
        categories.Columns.Add(column)

        ' Create the CategoryName column.
        column = New DataColumn()
        column.DataType = System.Type.GetType("System.String")
        column.ColumnName = "CategoryName"
        categories.Columns.Add(column)

        ' Set the primary key on CategoryID.
        Dim pKey(0) As DataColumn
        pKey(0) = categories.Columns("CategoryID")
        categories.PrimaryKey = pKey

        ' Fetch the data and fill the DataTable.
        adapter.Fill(categories)

        ' Add a new row.
        Dim newRow As DataRow = categories.NewRow()
        newRow("CategoryName") = "New Category"
        categories.Rows.Add(newRow)

        ' Add another new row.
        Dim newRow2 As DataRow = categories.NewRow()
        newRow2("CategoryName") = "Another New Category"
        categories.Rows.Add(newRow2)

        ' Add changed rows to a new DataTable that will be
        ' used to post the inserts to the database.
        Dim dataChanges As DataTable = categories.GetChanges()

        ' Include an event to fill in the Autonumber value.
        AddHandler adapter.RowUpdated, _
          New OleDbRowUpdatedEventHandler(AddressOf OnRowUpdated)

        ' Update the database, inserting the new rows.
        adapter.Update(dataChanges)

        Console.WriteLine("Rows before merge:")
        Dim row1 As DataRow
        For Each row1 In categories.Rows
            Console.WriteLine("  {0}: {1}", row1(0), row1(1))
        Next

        ' Merge the two DataTables.
        categories.Merge(dataChanges)

        ' Commit the changes.
        categories.AcceptChanges()

        Console.WriteLine("Rows after merge:")
        Dim row As DataRow
        For Each row In categories.Rows
            Console.WriteLine("  {0}: {1}", row(0), row(1))
        Next
    End Using
End Sub

O RowUpdated manipulador de OleDbDataAdaptereventos usa o mesmo open OleDbConnection que a Update instrução do . Ele verifica o StatementTypeOleDbRowUpdatedEventArgs das linhas inseridas. Para cada linha inserida, uma nova OleDbCommand é criada para executar a instrução SELECT @@IDENTITY na conexão, retornando o novo Autonumber valor, que é colocado na coluna CategoryID do DataRow. A Status propriedade é definida como UpdateStatus.SkipCurrentRow para suprimir a chamada oculta para AcceptChanges. No corpo principal do procedimento, o Merge método é chamado para mesclar os dois DataTable objetos e, finalmente AcceptChanges , é chamado.

static void OnRowUpdated(
  object sender, OleDbRowUpdatedEventArgs e)
{
    // Conditionally execute this code block on inserts only.
    if (e.StatementType == StatementType.Insert)
    {
        OleDbCommand cmdNewID = new("SELECT @@IDENTITY",
            s_connection);
        // Retrieve the Autonumber and store it in the CategoryID column.
        e.Row["CategoryID"] = (int)cmdNewID.ExecuteScalar()!;
        e.Status = UpdateStatus.SkipCurrentRow;
    }
}

Private Shared Sub OnRowUpdated( _
    ByVal sender As Object, ByVal e As OleDbRowUpdatedEventArgs)
    ' Conditionally execute this code block on inserts only.
    If e.StatementType = StatementType.Insert Then
        ' Retrieve the Autonumber and store it in the CategoryID column.
        Dim cmdNewID As New OleDbCommand("SELECT @@IDENTITY", _
           connection)
        e.Row("CategoryID") = CInt(cmdNewID.ExecuteScalar)
        e.Status = UpdateStatus.SkipCurrentRow
    End If
End Sub