Pobieranie wartości tożsamości lub autonumeruj

Artykuł
03/02/2024

Klucz podstawowy w relacyjnej bazie danych to kolumna lub kombinacja kolumn, które zawsze zawierają unikatowe wartości. Znajomość wartości klucza podstawowego pozwala zlokalizować wiersz, który go zawiera. Aparaty relacyjnych baz danych, takie jak SQL Server, Oracle i Microsoft Access/Jet, obsługują tworzenie automatycznie zwiększanych kolumn, które można wyznaczyć jako klucze podstawowe. Te wartości są generowane przez serwer w miarę dodawania wierszy do tabeli. W programie SQL Server ustawiasz właściwość tożsamości kolumny, w programie Oracle tworzysz sekwencję, a w programie Microsoft Access tworzysz kolumnę Autonumerowanie.

Można DataColumn również użyć elementu do automatycznego generowania wartości przyrostowych, ustawiając AutoIncrement właściwość na true. Można jednak umieścić zduplikowane wartości w oddzielnych wystąpieniach klasy , jeśli wiele aplikacji klienckich DataTableniezależnie generuje automatycznie wartości przyrostowe. Po wygenerowaniu automatycznie przyrostowych wartości serwera eliminuje potencjalne konflikty, umożliwiając każdemu użytkownikowi pobranie wygenerowanej wartości dla każdego wstawionego wiersza.

Podczas wywołania Update metody DataAdapterbazy danych baza danych może wysyłać dane z powrotem do aplikacji ADO.NET jako parametry wyjściowe lub jako pierwszy zwrócony rekord zestawu wyników instrukcji SELECT wykonanej w tej samej partii co instrukcja INSERT. ADO.NET można pobrać te wartości i zaktualizować odpowiednie kolumny w aktualizowaniu DataRow .

Niektóre aparaty bazy danych, takie jak aparat bazy danych Microsoft Access Jet, nie obsługują parametrów wyjściowych i nie mogą przetwarzać wielu instrukcji w jednej partii. Podczas pracy z aparatem bazy danych Jet można pobrać nową wartość autonumerowania wygenerowaną dla wstawionego wiersza, wykonując oddzielne polecenie SELECT w procedurze obsługi zdarzeń dla RowUpdated zdarzenia DataAdapter.

Uwaga

Alternatywą dla użycia wartości automatycznego zwiększania jest użycie NewGuid metody Guid obiektu do wygenerowania identyfikatora GUID lub globalnie unikatowego identyfikatora na komputerze klienckim, który można skopiować na serwer podczas wstawiania każdego nowego wiersza. Metoda NewGuid generuje 16-bajtową wartość binarną utworzoną przy użyciu algorytmu, który zapewnia wysokie prawdopodobieństwo, że żadna wartość nie zostanie zduplikowana. W bazie danych programu SQL Server identyfikator GUID jest przechowywany w uniqueidentifier kolumnie, którą program SQL Server może automatycznie wygenerować przy użyciu funkcji Transact-SQL NEWID() . Użycie identyfikatora GUID jako klucza podstawowego może niekorzystnie wpłynąć na wydajność. Program SQL Server zapewnia obsługę NEWSEQUENTIALID() funkcji, która generuje sekwencyjny identyfikator GUID, który nie jest gwarantowany globalnie unikatowy, ale może być indeksowany wydajniej.

Pobieranie wartości kolumn tożsamości programu SQL Server

Podczas pracy z programem Microsoft SQL Server można utworzyć procedurę składowaną z parametrem wyjściowym, aby zwrócić wartość tożsamości dla wstawionego wiersza. W poniższej tabeli opisano trzy funkcje języka Transact-SQL w programie SQL Server, które mogą służyć do pobierania wartości kolumn tożsamości.

Function	opis
SCOPE_IDENTITY	Zwraca ostatnią wartość tożsamości w bieżącym zakresie wykonywania. SCOPE_IDENTITY jest zalecana w większości scenariuszy.
@@IDENTITY	Zawiera ostatnią wartość tożsamości wygenerowaną w dowolnej tabeli w bieżącej sesji. @@IDENTITY mogą mieć wpływ wyzwalacze i mogą nie zwracać oczekiwanej wartości tożsamości.
IDENT_CURRENT	Zwraca ostatnią wartość tożsamości wygenerowaną dla określonej tabeli w dowolnej sesji i dowolnym zakresie.

Poniższa procedura składowana pokazuje, jak wstawić wiersz do tabeli Categories i użyć parametru wyjściowego, aby zwrócić nową wartość tożsamości wygenerowaną przez funkcję 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()

Następnie procedurę składowaną można określić jako źródło InsertCommand SqlDataAdapter obiektu. Właściwość CommandType InsertCommand musi być ustawiona na StoredProcedure. Dane wyjściowe tożsamości są pobierane przez utworzenie obiektu SqlParameter z wartością ParameterDirection Output. Po przetworzeniu InsertCommand obiektu zwracana jest automatycznie zwiększana wartość tożsamości i umieszczana w kolumnie CategoryID bieżącego wiersza, jeśli ustawisz UpdatedRowSource właściwość polecenia insert na UpdateRowSource.OutputParameters lub na UpdateRowSource.Both.

Jeśli polecenie insert wykonuje partię zawierającą zarówno instrukcję INSERT, jak i instrukcję SELECT zwracającą nową wartość tożsamości, możesz pobrać nową wartość, ustawiając UpdatedRowSource właściwość polecenia insert na UpdateRowSource.FirstReturnedRecordwartość .

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

Scalanie nowych wartości tożsamości

Typowym scenariuszem jest wywołanie GetChanges metody w DataTable celu utworzenia kopii zawierającej tylko zmienione wiersze i użycie nowej kopii podczas wywoływania Update metody .DataAdapter Jest to szczególnie przydatne, gdy konieczne jest przeprowadzenie marshalingu zmienionych wierszy do oddzielnego składnika wykonującego aktualizację. Po aktualizacji kopia może zawierać nowe wartości tożsamości, które należy następnie scalić z powrotem do oryginalnego DataTableelementu . Nowe wartości tożsamości mogą się różnić od oryginalnych wartości w pliku DataTable. Aby można było wykonać scalanie, oryginalne wartości kolumn AutoInkrement w kopii muszą być zachowywane, aby można było zlokalizować i zaktualizować istniejące wiersze w oryginalnym DataTableobiekcie, zamiast dołączać nowe wiersze zawierające nowe wartości tożsamości. Jednak domyślnie te oryginalne wartości są tracone po wywołaniu Update metody , ponieważ AcceptChanges jest niejawnie wywoływana dla każdego zaktualizowanego DataAdapterDataRowelementu .

Istnieją dwa sposoby zachowania oryginalnych DataColumn wartości elementu w DataRow aktualizacji DataAdapter :

Pierwszą metodą zachowania oryginalnych wartości jest ustawienie AcceptChangesDuringUpdate właściwości na DataAdapter falsewartość . Ma to wpływ na każdą DataRow aktualizację DataTable . Aby uzyskać więcej informacji i przykładowy kod, zobacz AcceptChangesDuringUpdate.
Drugą metodą jest napisanie kodu w procedurze RowUpdated obsługi zdarzeń obiektu , aby ustawić wartość Status SkipCurrentRow.DataAdapter Element DataRow jest aktualizowany, ale oryginalna wartość każdego z nich DataColumn jest zachowywana. Ta metoda umożliwia zachowanie oryginalnych wartości dla niektórych wierszy, a nie dla innych. Na przykład kod może zachować oryginalne wartości dla dodanych wierszy, a nie dla wierszy edytowanych lub usuniętych, sprawdzając StatementType najpierw ustawienie , a następnie ustawiając Status SkipCurrentRow wartość tylko dla wierszy z wartością StatementType Insert.

Jeśli którakolwiek z tych metod jest używana do zachowania oryginalnych wartości w DataRow trakcie DataAdapter aktualizacji, ADO.NET wykonuje serię akcji w celu ustawienia bieżących wartości DataRow wartości zwracanych przez parametry wyjściowe lub przez pierwszy zwrócony wiersz zestawu wyników, zachowując jednocześnie oryginalną wartość w każdym DataColumnobiekcie . Najpierw metoda DataRow metody jest wywoływana w AcceptChanges celu zachowania bieżących wartości jako oryginalnych wartości, a następnie przypisywane są nowe wartości. Po wykonaniu tych akcji właściwość DataRows ma RowState ustawioną Added RowState właściwość na Modifiedwartość , co może być nieoczekiwane.

Sposób stosowania wyników polecenia do każdej DataRow aktualizacji jest określany przez UpdatedRowSource właściwość każdego DbCommandelementu . Ta właściwość jest ustawiona na wartość z UpdateRowSource wyliczenia.

W poniższej tabeli opisano, jak UpdateRowSource wartości wyliczenia wpływają na RowState właściwość zaktualizowanych wierszy.

Nazwa elementu członkowskiego	opis
Both	`AcceptChanges` jest wywoływana, a wartości parametrów wyjściowych i/lub wartości w pierwszym wierszu dowolnego zwróconego zestawu wyników są umieszczane w `DataRow` aktualizowaniu. Jeśli nie ma żadnych wartości do zastosowania, `RowState` parametr będzie mieć Unchangedwartość .
FirstReturnedRecord	Jeśli wiersz został zwrócony, jest wywoływany, `AcceptChanges` a wiersz jest mapowany na zmieniony wiersz w elemecie `DataTable`, ustawiając wartość na `RowState` `Modified`. Jeśli żaden wiersz nie jest zwracany, `AcceptChanges` nie jest wywoływany i pozostaje `Added`.`RowState`
None	Wszystkie zwrócone parametry lub wiersze są ignorowane. Nie ma połączenia i `AcceptChanges` `RowState` pozostaje `Added`.
OutputParameters	`AcceptChanges` jest wywoływana, a wszystkie parametry wyjściowe są mapowane na zmieniony wiersz w `DataTable`obiekcie , ustawiając wartość `RowState` na `Modified`. Jeśli nie ma parametrów wyjściowych, `RowState` będzie to `Unchanged`.

Przykład

W tym przykładzie pokazano wyodrębnianie zmienionych wierszy z elementu DataTable i przy użyciu elementu SqlDataAdapter , aby zaktualizować źródło danych i pobrać nową wartość kolumny tożsamości. Wykonuje InsertCommand dwie instrukcje języka Transact-SQL; pierwsza jest instrukcją INSERT, a druga jest instrukcją SELECT, która używa funkcji SCOPE_IDENTITY w celu pobrania wartości tożsamości.

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

Właściwość UpdatedRowSource polecenia insert jest ustawiona na UpdateRowSource.FirstReturnedRow , a MissingSchemaAction właściwość DataAdapter właściwości jest ustawiona na MissingSchemaAction.AddWithKey. Element DataTable jest wypełniony, a kod dodaje nowy wiersz do elementu DataTable. Zmienione wiersze są następnie wyodrębniane do nowego DataTableelementu , który jest przekazywany do DataAdapterelementu , który następnie aktualizuje serwer.

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

Procedura OnRowUpdated obsługi zdarzeń sprawdza element StatementType , SqlRowUpdatedEventArgs aby określić, czy wiersz jest wstawiany. Jeśli tak jest, właściwość jest ustawiona Status na SkipCurrentRow. Wiersz jest aktualizowany, ale oryginalne wartości w wierszu są zachowywane. W głównej treści procedury metoda jest wywoływana w Merge celu scalenia nowej wartości tożsamości z oryginalną DataTablewartością , a na koniec AcceptChanges jest wywoływana.

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

Pobieranie wartości autonumerowania programu Microsoft Access

Ta sekcja zawiera przykład pokazujący sposób pobierania Autonumber wartości z bazy danych Jet 4.0. Aparat bazy danych Jet nie obsługuje wykonywania wielu instrukcji w partii ani użycia parametrów wyjściowych, więc nie można użyć żadnej z tych technik, aby zwrócić nową Autonumber wartość przypisaną do wstawionego wiersza. Można jednak dodać kod do RowUpdated procedury obsługi zdarzeń, która wykonuje oddzielną instrukcję SELECT @@IDENTITY w celu pobrania nowej Autonumber wartości.

Przykład

Zamiast dodawać informacje o schemacie przy użyciu metody MissingSchemaAction.AddWithKey, ten przykład konfiguruje DataTable element z poprawnym schematem przed wywołaniem OleDbDataAdapter elementu w celu wypełnienia elementu DataTable. W takim przypadku kolumna CategoryID jest skonfigurowana do dekrementacji wartości przypisanej do każdego wstawionego wiersza rozpoczynającego się od zera, ustawiając wartość AutoIncrement na true, AutoIncrementSeed na 0 i AutoIncrementStep na -1. Następnie kod dodaje dwa nowe wiersze i używa ich GetChanges do dodania zmienionych wierszy do nowej DataTable , która jest przekazywana Update do metody .

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

Program RowUpdated obsługi zdarzeń używa tego samego pliku otwartego OleDbConnection co Update instrukcja OleDbDataAdapter. Sprawdza liczbę StatementType OleDbRowUpdatedEventArgs wstawionych wierszy. Dla każdego wstawionego wiersza zostanie utworzony nowy OleDbCommand , aby wykonać instrukcję SELECT @@IDENTITY w połączeniu, zwracając nową Autonumber wartość, która jest umieszczana w kolumnie CategoryID obiektu DataRow. Właściwość jest następnie ustawiona Status na wartość , aby UpdateStatus.SkipCurrentRow pominąć ukryte wywołanie metody AcceptChanges. W głównej treści procedury metoda jest wywoływana w Merge celu scalenia dwóch DataTable obiektów, a na koniec AcceptChanges jest wywoływana.

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