Compara el DML y las mutaciones

Manipulación de datos Language (DML) y las mutaciones son dos APIs de Spanner que puedes usar para modificar los datos. Cada uno ofrece funciones similares de manipulación de datos. Esta página compara ambos enfoques.

¿Qué es el lenguaje de manipulación de datos (DML)?

El lenguaje de manipulación de datos (DML) en Spanner te permite manipular datos en las tablas de tu base de datos con INSERT, UPDATE y DELETE declaraciones. Puedes ejecutar declaraciones DML con el bibliotecas cliente la consola de Google Cloud y gcloud spanner.

Spanner ofrece las siguientes dos implementaciones de ejecución de DML, cada una con diferentes propiedades.

  • DML estándar: adecuado para el procesamiento de transacciones en línea (OLTP) estándar de las cargas de trabajo.

    Para obtener más información, incluidas muestras de código, consulta Cómo usar DML.

  • DML particionado: diseñado para actualizaciones y eliminaciones masivas, como se muestra a continuación ejemplos.

    • Recolección de elementos no usados y limpieza periódicos. Por ejemplo, la eliminación de filas antiguas o la configuración de columnas como NULL.

    • El restablecimiento de columnas nuevas con valores predeterminados. Un ejemplo es usar UPDATE para configurar el valor de una columna nueva como False, en la que es NULL.

    Para obtener más información, incluidas muestras de código, consulta Usa DML particionado.

    Puedes usar escrituras por lotes para una gran cantidad de operaciones de escritura sin lectura que no requieren transacciones atómicas. Para obtener más información, consulta Modifica datos con escrituras por lotes.

¿Qué son las mutaciones?

Una mutación representa una secuencia de inserciones, actualizaciones y eliminaciones que Spanner aplica de forma atómica a diferentes filas y tablas en una base de datos. Puedes incluir operaciones que se apliquen a distintas filas, o diferentes tablas, en una mutación. Después de definir una o más mutaciones que contienen una o más de escritura, debes aplicar la mutación para confirmarlas. Cada cambio es en el orden en que se agregaron a la mutación.

Para obtener más información, incluidas muestras de código, consulta Inserta, actualiza y borra datos mediante mutaciones.

Comparación de atributos entre el DML y las mutaciones

En la siguiente tabla, se resume la compatibilidad con DML y mutaciones de bases de datos comunes la operación y las funciones.

Operaciones DML Mutaciones
Inserta datos Admitido Admitido
Borrar datos Admitido Admitido
Actualizar datos Admitido Admitido
Insertar o ignorar datos Admitido No compatible
Lecturas (RYW) Admitido No compatible
Insertar o actualizar datos (Upsert) Admitido Admitido
Sintaxis de SQL Admitido No compatible
Verificación de restricciones Después de cada instrucción En el momento de la confirmación

El DML y las mutaciones difieren en la compatibilidad con las siguientes funciones:

  • Read Your Writes: Lee los resultados no confirmados dentro de una actividad transacción. Los cambios que realices con las declaraciones DML serán visibles para declaraciones posteriores en la misma transacción. Este es es diferente del uso de mutaciones, en el que los cambios no son visibles en ninguna (incluidas las lecturas realizadas en la misma transacción) hasta que se confirme la transacción. Esto se debe a que las mutaciones de una transacción se almacenan en búfer del cliente (de forma local). y se envían al servidor como parte de la operación de confirmación. Como resultado, las mutaciones de la solicitud de confirmación no son visibles para las declaraciones SQL o DML de la misma transacción.

  • Verificación de restricciones: Spanner verifica las restricciones después de cada Declaración DML. Esto es diferente del uso de mutaciones, en las que Spanner almacena en búfer las mutaciones del cliente hasta la confirmación y comprueba las restricciones en la confirmación tiempo. La evaluación de restricciones después de cada declaración DML permite que Spanner para garantizar que los datos devueltos por una consulta posterior en la misma muestra datos coherentes con el esquema.

  • Sintaxis de SQL: DML proporciona una forma convencional de manipular datos. Puedes reutilizar habilidades de SQL para modificar los datos usando la API de DML.

Práctica recomendada: Evita combinar DML y mutación en la misma transacción

Si una transacción contiene declaraciones DML y mutaciones en la confirmación por solicitud, Spanner ejecuta las declaraciones DML antes de las mutaciones. Para evitar tener que dar cuenta del orden de ejecución en el código de tu biblioteca cliente, debes usar las declaraciones DML o las mutaciones en una sola transacción, pero no en ambas.

En el siguiente ejemplo de Java, se ilustra un comportamiento que puede resultar sorprendente. El código inserta dos filas en álbumes con la API de mutación. El fragmento, luego, llama executeUpdate() para actualizar las filas insertadas recientemente y llama a executeQuery() para leer los álbumes actualizados.

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

Si ejecutaras este código, verías 0 registros actualizados. ¿Por qué? Esta ocurre porque los cambios que hicimos con las mutaciones no son visibles para sentencias posteriores hasta que la transacción se confirme. Idealmente, deberíamos tener escrituras almacenadas en búfer solo al final de la transacción.

Próximos pasos