Confronta DML e mutazioni

manipolazione di dati Il linguaggio (DML) e le mutazioni sono due API in Spanner che puoi usare per modificare i dati. Ciascuno di essi offre funzionalità di manipolazione dei dati simili. Questa pagina i due approcci.

Che cos'è il Data Manipulation Language (DML)?

Il Data Manipulation Language (DML) in Spanner ti consente manipola i dati nelle tabelle del database utilizzando INSERT, UPDATE e DELETE istruzioni. Puoi eseguire istruzioni DML utilizzando librerie client, Console Google Cloud e gcloud spanner.

Spanner offre le seguenti due implementazioni di esecuzione DML, ciascuna con diverse proprietà.

  • DML standard: adatto all'elaborazione delle transazioni online (OLTP) standard carichi di lavoro con scale out impegnativi.

    Per maggiori informazioni, inclusi esempi di codice, consulta Utilizzo di DML

  • DML partizionato: progettato per gli aggiornamenti e le eliminazioni collettive, come illustrato di seguito. esempi.

    • Pulizia periodica e garbage collection. Alcuni esempi sono l'eliminazione di righe precedenti o impostando le colonne su NULL.

    • Backfill di nuove colonne con valori predefiniti. Un esempio è l'utilizzo di un comando UPDATE per impostare il valore di una nuova colonna su False, dove è NULL.

    Per ulteriori informazioni, inclusi esempi di codice, consulta Utilizzare il DML partizionato.

    Puoi utilizzare le scritture batch per un numero elevato di operazioni di scrittura senza che non richiedono transazioni atomiche. Per ulteriori informazioni, consulta Modificare i dati utilizzando le scritture in batch.

Cosa sono le mutazioni?

Una mutazione rappresenta una sequenza di inserimenti, aggiornamenti ed eliminazioni che Spanner applica atomicamente a righe e tabelle diverse di un database. Puoi includere operazioni che si applicano a righe o tabelle diverse in una mutazione. Dopo aver definito una o più mutazioni che contengono una o più devi applicare la mutazione per eseguire il commit delle scritture. Ogni modifica viene applicati nell'ordine in cui sono stati aggiunti alla mutazione.

Per ulteriori informazioni, inclusi esempi di codice, vedi Inserimento, aggiornamento ed eliminazione di dati tramite mutazioni.

Confronto delle caratteristiche tra DML e mutazioni

La tabella seguente riassume il supporto di DML e mutazioni del database comune il funzionamento e le caratteristiche del prodotto.

Operazioni DML Mutazioni
Inserisci dati Supportato Supportato
Elimina dati Supportato Supportato
Aggiorna dati Supportato Supportato
Inserisci o ignora dati Supportato Non supportato
Lettura delle scritture (RYW) Supportato Non supportato
Inserire o aggiornare i dati (upsert) Supportato Supportato
Sintassi SQL Supportato Non supportato
Controllo dei vincoli Dopo ogni dichiarazione Al momento del commit

Il supporto di DML e mutazioni divergono per le seguenti funzionalità:

  • Leggi le tue scritture: lettura dei risultati non impegnati in un'istanza transazione. Le modifiche apportate utilizzando le istruzioni DML sono visibili a gli estratti conto successivi nella stessa transazione. Questo è diverso dall'uso delle mutazioni, in cui le modifiche non sono visibili in nessuna lettura (incluse le letture eseguite nella stessa transazione) fino a quando la transazione non si impegna. Questo perché le mutazioni in una transazione vengono memorizzate nel buffer sul lato client (localmente) e inviati al server come parte dell'operazione di commit. Di conseguenza, le mutazioni nella richiesta di commit non sono visibili alle istruzioni SQL o DML all'interno della stessa transazione.

  • Controllo dei vincoli: Spanner controlla i vincoli dopo ogni istruzione DML. È diverso dall'uso delle mutazioni, in cui Spanner bufferizza le mutazioni nel client fino al commit e controlla i vincoli in fase di commit nel tempo. La valutazione dei vincoli dopo ogni istruzione DML consente a Spanner per garantire che i dati restituiti da una query successiva nello stesso la transazione restituisce dati coerenti con lo schema.

  • Sintassi SQL: DML offre un modo convenzionale per manipolare i dati. Puoi riutilizzare le competenze SQL per modificare i dati con l'API DML.

Best practice: evita di combinare DML e mutazione nella stessa transazione

Se una transazione contiene sia istruzioni DML sia mutazioni nel commit Spanner esegue le istruzioni DML prima delle mutazioni. Da evitare tenendo conto dell'ordine di esecuzione nel codice della libreria client, dovrebbe utilizzare istruzioni DML o le mutazioni in una singola transazione, ma non entrambe.

Il seguente esempio Java illustra un comportamento potenzialmente sorprendente. Il codice inserisce due righe negli album utilizzando l'API Mutation. Lo snippet, quindi, chiama executeUpdate() per aggiornare le righe e le chiamate appena inserite executeQuery() per leggere gli album aggiornati.

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;
              }
            });
}

Se eseguissi questo codice, vedrai 0 record aggiornati. Perché? Questo perché le modifiche apportate utilizzando le mutazioni non sono visibili le istruzioni successive fino al commit della transazione. Idealmente, dovremmo avere scritture memorizzate nel buffer solo alla fine della transazione.

Passaggi successivi