Vergleich von DML und Mutationen

Datenmanipulation Sprache (DML) und Mutationen sind zwei APIs in Spanner, die Sie verwenden können Daten zu ändern. Sie bieten ähnliche Features zur Datenbearbeitung. Auf dieser Seite werden die Ansätze verglichen.

Was ist die Datenbearbeitungssprache (DML)?

Mit der Datenbearbeitungssprache (Data Manipulation Language, DML) in Spanner können Sie Daten in Ihren Datenbanktabellen mit INSERT, UPDATE und DELETE bearbeiten Aussagen. Sie können DML-Anweisungen mit der Clientbibliotheken, die Google Cloud Console und gcloud spanner.

Spanner bietet die folgenden beiden Implementierungen der DML-Ausführung mit jeweils unterschiedlichen Eigenschaften.

  • Standard-DML: Geeignet für standardmäßige OLTP-Arbeitslasten (Online Transaction Processing).

    Weitere Informationen und Codebeispiele finden sich unter DML verwenden.

  • Partitionierte DML: Wurde für Bulk-Aktualisierungen und -Löschvorgänge konzipiert, wie in folgenden Beispielen beschrieben.

    • Regelmäßige und automatische Speicherbereinigungsvorgänge. Beispiele: Alte Zeilen löschen oder Spalten auf NULL setzen.

    • Backfilling neuer Spalten mit Standardwerten. Ein Beispiel ist die Verwendung eines , um den Wert einer neuen Spalte auf False zu setzen, wo er NULL ist.

    Weitere Informationen und Codebeispiele finden sich unter Partitionierte DML verwenden.

    Sie können Batchschreibvorgänge für eine große Anzahl von Schreibvorgängen ohne Lesevorgänge verwenden für Vorgänge, die keine atomaren Transaktionen erfordern. Weitere Informationen Siehe Daten mit Batchschreibvorgängen ändern.

Was sind Mutationen?

Eine Mutation stellt eine Folge von Einfügungs-, Aktualisierungs- und Löschvorgängen dar, die Spanner in kleinstmöglichen Schritten auf verschiedene Zeilen und Tabellen in einer Datenbank anwendet. Sie können Vorgänge aufnehmen, die auf verschiedene Zeilen oder Tabellen in einer Mutation angewendet werden. Nachdem Sie eine oder mehrere Mutationen definiert haben, die je einen oder mehrere Schreibvorgänge enthalten, müssen Sie die Mutation anwenden, um einen Commit für die Schreibvorgänge auszuführen. Änderungen werden in der Reihenfolge angewendet, in der sie der Mutation hinzugefügt wurden.

Weitere Informationen und Codebeispiele finden Sie unter Daten mit Mutationen einfügen, aktualisieren und löschen.

Featurevergleich zwischen DML und Mutationen

In folgender Tabelle sind DML- und Mutationsunterstützung für häufige Datenbankoperationen und -funktionen zusammengefasst.

Vorgänge DML Mutationen
Daten einfügen Unterstützt Unterstützt
Daten löschen Unterstützt Unterstützt
Daten aktualisieren Unterstützt Unterstützt
Daten einfügen oder ignorieren Unterstützt Nicht unterstützt
Schreibvorgänge lesen (RYW, Read Your Writes) Unterstützt Nicht unterstützt
Daten einfügen oder aktualisieren (Upsert) Unterstützt Unterstützt
SQL-Syntax Unterstützt Nicht unterstützt
Einschränkung prüfen Nach jeder Anweisung Beim Commit

DML und Mutationen unterstützen die folgenden Funktionen unterschiedlich:

  • Read Your Writes: Lesen Sie Ergebnisse ohne Commit innerhalb eines aktiven Transaktion. Änderungen, die Sie mit DML-Anweisungen vornehmen, sind sichtbar für weitere Anweisungen in derselben Transaktion. Dies unterscheidet sich von Mutationen, bei denen Änderungen in Lesevorgängen (einschließlich Lesevorgängen in derselben Transaktion) erst beim Commit der Transaktion sichtbar werden. Grund dafür ist, dass Mutationen in einer Transaktion clientseitig (lokal) gepuffert und als Teil des Commit-Vorgangs an den Server gesendet werden. Folglich sind Mutationen in der Commit-Anfrage für SQL- oder DML-Anweisungen in derselben Transaktion nicht sichtbar.

  • Einschränkungsüberprüfung: Spanner prüft Einschränkungen nach jedem DML-Anweisung. Dies unterscheidet sich von der Verwendung von Mutationen, bei der Spanner puffert Mutationen im Client bis zum Commit und überprüft Einschränkungen beim Commit . Das Auswerten von Einschränkungen nach jeder DML-Anweisung ermöglicht Spanner, damit die von einer nachfolgenden Abfrage zurückgegebenen Daten Transaktion gibt Daten zurück, die mit dem Schema übereinstimmen.

  • SQL-Syntax: DML bietet eine konventionelle Möglichkeit, Daten zu bearbeiten. Sie können SQL-Kompetenzen nutzen, um die Daten mit der DML API zu ändern.

Best Practice: Kombinieren Sie DML und Mutationen nicht in derselben Transaktion

Wenn eine Transaktion sowohl DML-Anweisungen als auch Mutationen im Commit enthält -Anfrage verwendet, führt Spanner die DML-Anweisungen vor den Mutationen aus. Sie sollten entweder DML-Anweisungen oder Mutationen in einer einzelnen Transaktion verwenden, nicht jedoch beide, damit Sie die Reihenfolge der Ausführung in Ihrem Client-Bibliothekscode nicht berücksichtigen müssen.

Folgendes Java-Beispiel veranschaulicht ein potenziell überraschendes Verhalten. Der Code fügt per Mutation API zwei Zeilen in Alben ein. Das Snippet ruft dann executeUpdate() auf, um die neu eingefügten Zeilen zu aktualisieren und executeQuery() aufzurufen, um die aktualisierten Alben zu lesen.

static void updateMarketingBudget(DatabaseClient dbClient) {
  dbClient
      .readWriteTransaction()
      .run(
          new TransactionCallable<Void>() {
            @Override
            public Void run(TransactionContext transaction) throws Exception {
               transaction.buffer(
                    Mutation.newInsertBuilder("Albums")
                        .set("SingerId")
                        .to(1)
                        .set("AlbumId")
                        .to(1)
                        .set("AlbumTitle")
                        .to("Total Junk")
                        .set("MarketingBudget")
                        .to(800)
                        .build());
               transaction.buffer(
                    Mutation.newInsertBuilder("Albums")
                        .set("SingerId")
                        .to(1)
                        .set("AlbumId")
                        .to(2)
                        .set("AlbumTitle")
                        .to("Go Go Go")
                        .set("MarketingBudget")
                        .to(200)
                        .build());

                // This UPDATE will not include the Albums inserted above.
                String sql =
                  "UPDATE Albums SET MarketingBudget = MarketingBudget * 2"
                      + " WHERE SingerId = 1";
                long rowCount = transaction.executeUpdate(Statement.of(sql));
                System.out.printf("%d records updated.\n", rowCount);

                // Read a newly updated record.
                sql =
                  "SELECT SingerId, AlbumId, AlbumTitle FROM Albums"
                      + " WHERE SingerId = 1 AND MarketingBudget < 1000";
                ResultSet resultSet =
                                 transaction.executeQuery(Statement.of(sql));
                while (resultSet.next()) {
                   System.out.printf(
                        "%s %s\n",
                        resultSet.getString("FirstName"),
                        resultSet.getString("LastName"));
                }
                return null;
              }
            });
}

Bei der Ausführung dieses Codes würde 0 Datensätze aktualisiert angezeigt. Warum? Grund ist, dass die mit Mutationen vorgenommenen Änderungen für nachfolgende Anweisungen erst nach dem Commit der Transaktion sichtbar sind. Idealerweise sollten am Ende der Transaktion nur noch gepufferte Schreibvorgänge existieren.

Nächste Schritte