Načítání hodnot identity nebo automatického číslování

Článek
03/05/2024

Primární klíč v relační databázi je sloupec nebo kombinace sloupců, které vždy obsahují jedinečné hodnoty. Znalost hodnoty primárního klíče umožňuje vyhledat řádek, který ho obsahuje. Relační databázové stroje, jako je SQL Server, Oracle a Microsoft Access/Jet, podporují vytváření automaticky navyšovacích sloupců, které lze určit jako primární klíče. Tyto hodnoty jsou generovány serverem při přidání řádků do tabulky. Na SQL Serveru nastavíte vlastnost identity sloupce, v Oracle vytvoříte posloupnost a v Microsoft Accessu vytvoříte sloupec Automatické číslo.

A DataColumn lze také použít k vygenerování automaticky inkrementace hodnot nastavením AutoIncrement vlastnosti na true. Pokud však více klientských aplikací nezávisle generuje automaticky přírůstkové hodnoty, můžete skončit s duplicitními hodnotami v samostatných instancích.DataTable Když server vygeneruje automaticky přírůstkové hodnoty, eliminuje potenciální konflikty tím, že každému uživateli umožníte načíst vygenerovanou hodnotu pro každý vložený řádek.

Během volání Update metody metody DataAdaptermůže databáze odesílat data zpět do vaší ADO.NET aplikace jako výstupní parametry nebo jako první vrácený záznam sady výsledků příkazu SELECT spuštěné ve stejné dávce jako příkaz INSERT. ADO.NET může tyto hodnoty načíst a aktualizovat odpovídající sloupce v DataRow aktualizaci.

Některé databázové stroje, jako je databázový stroj Microsoft Access Jet, nepodporují výstupní parametry a nemohou zpracovat více příkazů v jedné dávce. Při práci s databázovým strojem Jet můžete načíst novou hodnotu automatického čísla vygenerovanou pro vložený řádek spuštěním samostatného příkazu SELECT v obslužné rutině události pro RowUpdated událost události DataAdapter.

Poznámka:

Alternativou k použití hodnoty automatického přírůstku je použití NewGuid metody objektu Guid k vygenerování identifikátoru GUID nebo globálně jedinečného identifikátoru v klientském počítači, který lze zkopírovat na server při vložení každého nového řádku. Metoda NewGuid vygeneruje binární hodnotu 16 bajtů, která je vytvořená pomocí algoritmu, který poskytuje vysokou pravděpodobnost, že žádná hodnota nebude duplikována. V databázi SQL Serveru je identifikátor GUID uložen ve uniqueidentifier sloupci, který SQL Server může automaticky generovat pomocí funkce Transact-SQL NEWID() . Použití identifikátoru GUID jako primárního klíče může nepříznivě ovlivnit výkon. SQL Server poskytuje podporu pro NEWSEQUENTIALID() funkci, která generuje sekvenční identifikátor GUID, který není zaručen, že je globálně jedinečný, ale dá se indexovat efektivněji.

Načítání hodnot sloupců identity SQL Serveru

Při práci s Microsoft SQL Serverem můžete vytvořit uloženou proceduru s výstupním parametrem pro vrácení hodnoty identity pro vložený řádek. Následující tabulka popisuje tři funkce Jazyka Transact-SQL v SQL Serveru, které lze použít k načtení hodnot sloupců identity.

Function	Popis
SCOPE_IDENTITY	Vrátí poslední hodnotu identity v aktuálním rozsahu provádění. SCOPE_IDENTITY se doporučuje pro většinu scénářů.
@@IDENTITY	Obsahuje poslední hodnotu identity vygenerovanou v libovolné tabulce v aktuální relaci. @@IDENTITY mohou být ovlivněny triggery a nemusí vrátit hodnotu identity, kterou očekáváte.
IDENT_CURRENT	Vrátí poslední hodnotu identity vygenerovanou pro konkrétní tabulku v libovolné relaci a libovolném oboru.

Následující uložená procedura ukazuje, jak vložit řádek do tabulky Categories a pomocí výstupního parametru vrátit novou hodnotu identity vygenerovanou funkcí 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()

Uložená procedura se pak dá zadat jako zdroj InsertCommand objektu SqlDataAdapter . Vlastnost CommandType musí být nastavena InsertCommand na StoredProcedurehodnotu . Výstup identity se načte vytvořením objektu SqlParameter , který má ParameterDirection hodnotu Output. InsertCommand Při zpracování se vrátí hodnota automaticky inkrementované identity a umístí se do sloupce CategoryID aktuálního řádku, pokud nastavíte UpdatedRowSource vlastnost příkazu insert na UpdateRowSource.OutputParameters hodnotu nebo na UpdateRowSource.Bothhodnotu .

Pokud příkaz insert spustí dávku, která obsahuje příkaz INSERT i příkaz SELECT, který vrátí novou hodnotu identity, můžete novou hodnotu načíst nastavením UpdatedRowSource vlastnosti příkazu insert na UpdateRowSource.FirstReturnedRecordhodnotu .

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

Sloučení nových hodnot identit

Běžným scénářem je volání GetChanges metody DataTable vytvoření kopie, která obsahuje pouze změněné řádky, a použití nové kopie při volání Update metody DataAdaptermetody . To je užitečné zejména v případě, že potřebujete zařadit změněné řádky do samostatné komponenty, která provádí aktualizaci. Po aktualizaci může kopie obsahovat nové hodnoty identity, které se pak musí sloučit zpět do původní DataTable. Nové hodnoty identity se pravděpodobně liší od původních hodnot v objektu DataTable. Aby bylo možné provést sloučení, musí být zachovány původní hodnoty sloupců automatického přírůstku v kopii, aby bylo možné vyhledat a aktualizovat existující řádky v původním DataTabletextu, a nikoli přidávat nové řádky obsahující nové hodnoty identity. Ve výchozím nastavení však tyto původní hodnoty jsou ztraceny po volání Update metody , protože AcceptChanges je implicitně volána pro každou aktualizaci DataRowDataAdapter.

Existují dva způsoby, jak zachovat původní hodnoty DataColumn v DataRow průběhu DataAdapter aktualizace:

První metodou zachování původních hodnot je nastavit AcceptChangesDuringUpdate vlastnost DataAdapter na falsehodnotu . To má vliv na DataTable všechny DataRow aktualizace. Další informace a příklad kódu najdete v tématu AcceptChangesDuringUpdate.
Druhá metoda je napsat kód v RowUpdated obslužné rutině DataAdapter události nastavit na Status SkipCurrentRow. Aktualizuje se DataRow , ale původní hodnota každého z nich DataColumn se zachová. Tato metoda umožňuje zachovat původní hodnoty pro některé řádky, nikoli pro jiné. Kód může například zachovat původní hodnoty pro přidané řádky, nikoli pro upravené nebo odstraněné řádky tím, že nejprve zaškrtne StatementType a pak nastaví Status SkipCurrentRow pouze řádky s StatementType hodnotou Insert.

Pokud se jedna z těchto metod používá k zachování původních hodnot v DataRow průběhu DataAdapter aktualizace, ADO.NET provede řadu akcí k nastavení aktuálních DataRow hodnot na nové hodnoty vrácené výstupními parametry nebo prvním vráceným řádkem sady výsledků a přitom zachová původní hodnotu v každém DataColumn. Nejprve je volána metoda DataRow zachování AcceptChanges aktuálních hodnot jako původních hodnot a pak jsou přiřazeny nové hodnoty. Po provedení těchto akcí, DataRows které měly nastavenou RowState vlastnost Added , bude mít jejich RowState vlastnost nastavena na Modified, což může být neočekávané.

Způsob použití výsledků příkazu pro každou DataRow aktualizaci je určen UpdatedRowSource vlastností každého DbCommand. Tato vlastnost je nastavena na hodnotu z výčtu UpdateRowSource .

Následující tabulka popisuje, jak hodnoty výčtu UpdateRowSource ovlivňují RowState vlastnost aktualizovaných řádků.

Název členu	Popis
Both	`AcceptChanges` je volána a hodnoty výstupních parametrů a/nebo hodnoty v prvním řádku všech vrácených sad výsledků se umístí do `DataRow` aktualizace. Pokud neexistují žádné hodnoty, které `RowState` by bylo možné použít, bude Unchanged.
FirstReturnedRecord	Pokud byl vrácen řádek, `AcceptChanges` je volána a řádek je namapován na změněný řádek v nastavení `DataTableRowState` na `Modified`. Pokud není vrácen žádný řádek, pak `AcceptChanges` není volána a `RowState` zůstává `Added`.
None	Všechny vrácené parametry nebo řádky se ignorují. Neexistuje žádný hovor `AcceptChanges` a `RowState` zbývá `Added`.
OutputParameters	`AcceptChanges`je volána a všechny výstupní parametry jsou namapovány na změněný řádek v nastavení `DataTableRowState` na `Modified`. Pokud neexistují žádné výstupní parametry, bude `Unchanged`.`RowState`

Příklad

Tento příklad ukazuje extrakci změněného řádku z DataTable a použití k SqlDataAdapter aktualizaci zdroje dat a načtení nové hodnoty sloupce identity. Provede InsertCommand dva příkazy Jazyka Transact-SQL. První příkaz je příkaz INSERT a druhý příkaz SELECT, který používá funkci SCOPE_IDENTITY k načtení hodnoty identity.

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

Vlastnost UpdatedRowSource příkazu insert je nastavena UpdateRowSource.FirstReturnedRow a MissingSchemaAction vlastnost DataAdapter je nastavena na MissingSchemaAction.AddWithKey. Vyplní se DataTable a kód přidá nový řádek do znaku DataTable. Změněné řádky se pak extrahují do nového DataTable, který se předá DataAdapterdo souboru , který pak aktualizuje server.

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

Obslužná rutina OnRowUpdated události zkontroluje StatementType , SqlRowUpdatedEventArgs jestli je řádek vložením. Pokud ano, Status vlastnost je nastavena na SkipCurrentRowhodnotu . Řádek se aktualizuje, ale původní hodnoty v řádku se zachovají. V hlavním těle procedury je Merge volána metoda pro sloučení nové hodnoty identity do původního DataTablea nakonec AcceptChanges je volána.

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

Načítání hodnot automatického číslování aplikace Microsoft Access

Tato část obsahuje ukázku, která ukazuje, jak načíst Autonumber hodnoty z databáze Jet 4.0. Databázový stroj Jet nepodporuje provádění více příkazů v dávce nebo použití výstupních parametrů, takže není možné použít některou z těchto technik k vrácení nové Autonumber hodnoty přiřazené k vloženého řádku. Do obslužné rutiny události však můžete přidat kód RowUpdated , který spustí samostatný příkaz SELECT @@IDENTITY, který načte novou Autonumber hodnotu.

Příklad

Místo přidání informací o schématu pomocí MissingSchemaAction.AddWithKeytohoto příkladu nakonfigurujete DataTable správné schéma před voláním OleDbDataAdapter k vyplnění DataTable. V tomto případě je sloupec CategoryID nakonfigurovaný tak, aby dekrementoval hodnotu přiřazenou každému vloženého řádku od nuly nastavením AutoIncrement na truehodnotu , AutoIncrementSeed na 0 a AutoIncrementStep na -1. Kód pak přidá dva nové řádky a použije GetChanges k přidání změněné řádky do nového DataTable , který se předá metodě Update .

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

Obslužná rutina RowUpdated události používá stejný otevřený OleDbConnection jako Update příkaz OleDbDataAdapter. Kontroluje vložené StatementTypeOleDbRowUpdatedEventArgs řádky. Pro každý vložený řádek se vytvoří nový OleDbCommand pro spuštění příkazu SELECT @@IDENTITY na připojení, který vrátí novou Autonumber hodnotu, která je umístěna ve sloupci DataRowCategoryID sloupce . Vlastnost Status je poté nastavena tak, aby UpdateStatus.SkipCurrentRow potlačovala skryté volání AcceptChanges. V hlavním těle procedury je Merge volána metoda pro sloučení dvou DataTable objektů a nakonec AcceptChanges je volána.

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