Langage de manipulation de données partitionné

Le langage de manipulation de données partitionné (LMD partitionné) est conçu pour les types de mises à jour et de suppressions groupées suivants:

  • Nettoyage périodique et récupération de mémoire. Il s'agit par exemple de supprimer d'anciennes lignes ou de définir des colonnes sur NULL.
  • Remplissage de nouvelles colonnes avec des valeurs par défaut. Cette opération consiste, par exemple, à utiliser une instruction UPDATE pour définir la valeur d'une nouvelle colonne sur False lorsqu'elle est actuellement à NULL.

Le LMD partitionné n'est pas adapté au traitement de transactions à petite échelle. Si vous souhaitez exécuter une instruction sur quelques lignes, utilisez des LMD transactionnels avec des clés primaires identifiables. Pour en savoir plus, consultez la page Utiliser le langage LMD.

Si vous devez effectuer un commit d'un grand nombre d'écritures à l'aveugle sans avoir besoin d'une transaction atomique, vous pouvez modifier vos tables Spanner de manière groupée à l'aide d'une écriture par lot. Pour en savoir plus, consultez la section Modifier des données à l'aide d'écritures par lot.

Vous pouvez obtenir des insights sur les requêtes LMD partitionnées actives et leur progression à partir des tables de statistiques de votre base de données Spanner. Pour en savoir plus, consultez la section Statistiques LMD partitionnées actives.

LMD et LMD partitionné

Spanner accepte deux modes d'exécution pour les instructions LMD:

  • LMD, qui convient au traitement des transactions. Pour plus d'informations, consultez la section Utiliser LMD.

  • LMD partitionné, qui permet des opérations à grande échelle à l'échelle de la base de données avec un impact minimal sur le traitement des transactions simultanées en partitionnant l'espace de clés et en exécutant l'instruction sur des partitions dans des transactions distinctes de plus petite portée. Pour en savoir plus, consultez la page Utiliser le LMD partitionné.

Le tableau suivant met en évidence certaines des différences entre les deux modes d'exécution.

LMD LMD partitionné
Les lignes qui ne correspondent pas à la clause WHERE peuvent être verrouillées. Seules les lignes correspondant à la clause WHERE sont verrouillées.
Les limites de taille de transaction s'appliquent. Spanner gère les limites de transaction et les limites de simultanéité par transaction.
Les instructions n'ont pas besoin d'être idempotentes. Une instruction LMD doit être idempotente pour garantir des résultats cohérents.
Une transaction peut inclure plusieurs instructions LMD et SQL. Une transaction partitionnée ne peut inclure qu'une seule instruction LMD.
Il n'y a aucune restriction sur la complexité des instructions. Les instructions doivent être entièrement partitionnables.
Vous créez des transactions en lecture-écriture dans votre code client. Spanner crée les transactions.

Partitionnable et idempotent

Lorsqu'une instruction LMD partitionnée s'exécute, les lignes d'une partition n'ont pas accès à celles des autres partitions. De plus, vous ne pouvez pas choisir la manière dont Spanner crée les partitions. Le partitionnement garantit l'évolutivité, mais signifie également que les instructions LMD partitionnées doivent être entièrement partitionnables. Autrement dit, l'instruction LMD partitionnée doit pouvoir être exprimée en tant que l'union d'un ensemble d'instructions, où chaque instruction accède à une seule ligne de la table, et chaque instruction n'accède à aucune autre table. Par exemple, une instruction LMD qui accède à plusieurs tables ou effectue une jointure automatique n'est pas partitionnable. Si l'instruction LMD ne peut pas être partitionnée, Spanner renvoie l'erreur BadUsage.

Ces instructions LMD sont entièrement partitionnables, car chaque instruction peut être appliquée à une seule ligne de la table :

UPDATE Singers SET LastName = NULL WHERE LastName = '';

DELETE FROM Albums WHERE MarketingBudget > 10000;

Cette instruction LMD n'est pas entièrement partitionnable, car elle accède à plusieurs tables :

# Not fully partitionable
DELETE FROM Singers WHERE
SingerId NOT IN (SELECT SingerId FROM Concerts);

Spanner peut exécuter plusieurs fois une instruction LMD partitionnée sur certaines partitions en raison de nouvelles tentatives au niveau du réseau. Par conséquent, une instruction peut être exécutée plusieurs fois sur une ligne. L'instruction doit donc être idempotente pour renvoyer des résultats cohérents. Une instruction est idempotente si elle renvoie le même résultat lorsqu'elle est exécutée plusieurs fois sur une même ligne.

Cette instruction LMD est idempotente :

UPDATE Singers SET MarketingBudget = 1000 WHERE true;

Cette instruction LMD n'est pas idempotente :

UPDATE Singers SET MarketingBudget = 1.5 * MarketingBudget WHERE true;

Verrouillage de ligne

Spanner n'acquiert un verrou que si une ligne peut être mise à jour ou supprimée. Ce comportement est différent de l'exécution en mode LMD, qui peut contenir des lignes verrouillées en lecture ne correspondant pas à la clause WHERE.

Exécution et transactions

Le fait qu'une instruction LMD soit partitionnée ou non dépend de la méthode de la bibliothèque cliente que vous choisissez pour l'exécution. Chaque bibliothèque cliente fournit des méthodes distinctes pour l'exécution en mode LMD et l'exécution en mode LMD partitionné.

Vous ne pouvez exécuter qu'une seule instruction LMD partitionnée dans un appel à la méthode de la bibliothèque cliente.

Spanner n'applique pas les instructions LMD partitionnées de manière atomique sur l'ensemble de la table. Toutefois, Spanner applique les instructions LMD partitionnées de manière atomique sur chaque partition.

Le LMD partitionné ne prend pas en charge le commit ou la restauration. Spanner exécute et applique immédiatement l'instruction LMD.

  • Si vous annulez l'opération, Spanner annule les partitions en cours d'exécution et ne démarre pas les partitions restantes. Spanner n'effectue pas le rollback des partitions déjà exécutées.
  • Si l'exécution de l'instruction provoque une erreur, l'exécution s'arrête sur toutes les partitions et Spanner renvoie cette erreur pour l'ensemble de l'opération. Voici quelques exemples d'erreurs : les cas de non-respect des contraintes de type de données, des cas de non-respect des UNIQUE INDEX et des cas de non-respect des ON DELETE NO ACTION. Selon le moment où l'exécution a échoué, il est possible que l'instruction s'est correctement exécutée sur certaines partitions, et qu'elle ne l'ait jamais été sur d'autres.

Si l'instruction LMD partitionnée réussit, Spanner l'a exécutée au moins une fois sur chaque partition de la plage de clés.

Nombre de lignes modifiées

Une instruction LMD partitionnée renvoie une limite inférieure sur le nombre de lignes modifiées. Il peut ne pas s'agir du nombre exact de lignes modifiées, car il n'y a aucune garantie que Spanner compte toutes les lignes modifiées.

Limites de transaction

Spanner crée les partitions et les transactions dont il a besoin pour exécuter une instruction LMD partitionnée. Les limites de transaction ou les limites de simultanéité par transaction s'appliquent, mais Spanner tente de maintenir les transactions dans les limites.

Spanner autorise un maximum de 20 000 instructions LMD partitionnées simultanées par base de données.

Fonctionnalités non compatibles

Spanner n'est pas compatible avec certaines fonctionnalités du LMD partitionné:

  • INSERT n'est pas compatible.
  • Console Google Cloud: vous ne pouvez pas exécuter d'instructions LMD partitionnées dans la console Google Cloud.
  • Plans de requête et profilage: la Google Cloud CLI et les bibliothèques clientes n'acceptent pas les plans de requête ni le profilage.
  • Sous-requêtes qui lisent à partir d'un autre tableau ou d'une ligne différente de la même table.

Pour les scénarios complexes, tels que le déplacement d'une table ou les transformations nécessitant des jointures entre les tables, envisagez d'utiliser le connecteur Dataflow.

Examples

L'exemple de code suivant met à jour la colonne MarketingBudget de la table Albums.

C++

Utilisez la fonction ExecutePartitionedDml() pour exécuter une instruction LMD partitionnée.

void DmlPartitionedUpdate(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;
  auto result = client.ExecutePartitionedDml(
      spanner::SqlStatement("UPDATE Albums SET MarketingBudget = 100000"
                            "  WHERE SingerId > 1"));
  if (!result) throw std::move(result).status();
  std::cout << "Updated at least " << result->row_count_lower_bound
            << " row(s) [spanner_dml_partitioned_update]\n";
}

C#

Utilisez la méthode ExecutePartitionedUpdateAsync() pour exécuter une instruction LMD partitionnée.


using Google.Cloud.Spanner.Data;
using System;
using System.Threading.Tasks;

public class UpdateUsingPartitionedDmlCoreAsyncSample
{
    public async Task<long> UpdateUsingPartitionedDmlCoreAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";

        using var connection = new SpannerConnection(connectionString);
        await connection.OpenAsync();

        using var cmd = connection.CreateDmlCommand("UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1");
        long rowCount = await cmd.ExecutePartitionedUpdateAsync();

        Console.WriteLine($"{rowCount} row(s) updated...");
        return rowCount;
    }
}

Go

Utilisez la méthode PartitionedUpdate() pour exécuter une instruction LMD partitionnée.


import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
)

func updateUsingPartitionedDML(w io.Writer, db string) error {
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return err
	}
	defer client.Close()

	stmt := spanner.Statement{SQL: "UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1"}
	rowCount, err := client.PartitionedUpdate(ctx, stmt)
	if err != nil {
		return err
	}
	fmt.Fprintf(w, "%d record(s) updated.\n", rowCount)
	return nil
}

Java

Utilisez la méthode executePartitionedUpdate() pour exécuter une instruction LMD partitionnée.

static void updateUsingPartitionedDml(DatabaseClient dbClient) {
  String sql = "UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1";
  long rowCount = dbClient.executePartitionedUpdate(Statement.of(sql));
  System.out.printf("%d records updated.\n", rowCount);
}

Node.js

Utilisez la méthode runPartitionedUpdate() pour exécuter une instruction LMD partitionnée.

// Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Gets a reference to a Cloud Spanner instance and database
const instance = spanner.instance(instanceId);
const database = instance.database(databaseId);

try {
  const [rowCount] = await database.runPartitionedUpdate({
    sql: 'UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1',
  });
  console.log(`Successfully updated ${rowCount} records.`);
} catch (err) {
  console.error('ERROR:', err);
} finally {
  // Close the database when finished.
  database.close();
}

PHP

Utilisez la méthode executePartitionedUpdate() pour exécuter une instruction LMD partitionnée.

use Google\Cloud\Spanner\SpannerClient;

/**
 * Updates sample data in the database by partition with a DML statement.
 *
 * This updates the `MarketingBudget` column which must be created before
 * running this sample. You can add the column by running the `add_column`
 * sample or by running this DDL statement against your database:
 *
 *     ALTER TABLE Albums ADD COLUMN MarketingBudget INT64
 *
 * Example:
 * ```
 * update_data($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function update_data_with_partitioned_dml(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $rowCount = $database->executePartitionedUpdate(
        'UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1'
    );

    printf('Updated %d row(s).' . PHP_EOL, $rowCount);
}

Python

Utilisez la méthode execute_partitioned_dml() pour exécuter une instruction LMD partitionnée.

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"

spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

row_ct = database.execute_partitioned_dml(
    "UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1"
)

print("{} records updated.".format(row_ct))

Ruby

Utilisez la méthode execute_partitioned_update() pour exécuter une instruction LMD partitionnée.

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

row_count = client.execute_partition_update(
  "UPDATE Albums SET MarketingBudget = 100000 WHERE SingerId > 1"
)

puts "#{row_count} records updated."

L'exemple de code suivant supprime les lignes de la table Singers, en fonction de la colonne SingerId.

C++

void DmlPartitionedDelete(google::cloud::spanner::Client client) {
  namespace spanner = ::google::cloud::spanner;
  auto result = client.ExecutePartitionedDml(
      spanner::SqlStatement("DELETE FROM Singers WHERE SingerId > 10"));
  if (!result) throw std::move(result).status();
  std::cout << "Deleted at least " << result->row_count_lower_bound
            << " row(s) [spanner_dml_partitioned_delete]\n";
}

C#


using Google.Cloud.Spanner.Data;
using System;
using System.Threading.Tasks;

public class DeleteUsingPartitionedDmlCoreAsyncSample
{
    public async Task<long> DeleteUsingPartitionedDmlCoreAsync(string projectId, string instanceId, string databaseId)
    {
        string connectionString = $"Data Source=projects/{projectId}/instances/{instanceId}/databases/{databaseId}";

        using var connection = new SpannerConnection(connectionString);
        await connection.OpenAsync();

        using var cmd = connection.CreateDmlCommand("DELETE FROM Singers WHERE SingerId > 10");
        long rowCount = await cmd.ExecutePartitionedUpdateAsync();

        Console.WriteLine($"{rowCount} row(s) deleted...");
        return rowCount;
    }
}

Go


import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/spanner"
)

func deleteUsingPartitionedDML(w io.Writer, db string) error {
	ctx := context.Background()
	client, err := spanner.NewClient(ctx, db)
	if err != nil {
		return err
	}
	defer client.Close()

	stmt := spanner.Statement{SQL: "DELETE FROM Singers WHERE SingerId > 10"}
	rowCount, err := client.PartitionedUpdate(ctx, stmt)
	if err != nil {
		return err

	}
	fmt.Fprintf(w, "%d record(s) deleted.", rowCount)
	return nil
}

Java

static void deleteUsingPartitionedDml(DatabaseClient dbClient) {
  String sql = "DELETE FROM Singers WHERE SingerId > 10";
  long rowCount = dbClient.executePartitionedUpdate(Statement.of(sql));
  System.out.printf("%d records deleted.\n", rowCount);
}

Node.js

// Imports the Google Cloud client library
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance';
// const databaseId = 'my-database';

// Creates a client
const spanner = new Spanner({
  projectId: projectId,
});

// Gets a reference to a Cloud Spanner instance and database
const instance = spanner.instance(instanceId);
const database = instance.database(databaseId);

try {
  const [rowCount] = await database.runPartitionedUpdate({
    sql: 'DELETE FROM Singers WHERE SingerId > 10',
  });
  console.log(`Successfully deleted ${rowCount} records.`);
} catch (err) {
  console.error('ERROR:', err);
} finally {
  // Close the database when finished.
  database.close();
}

PHP

use Google\Cloud\Spanner\SpannerClient;

/**
 * Delete sample data in the database by partition with a DML statement.
 *
 * This updates the `MarketingBudget` column which must be created before
 * running this sample. You can add the column by running the `add_column`
 * sample or by running this DDL statement against your database:
 *
 *     ALTER TABLE Albums ADD COLUMN MarketingBudget INT64
 *
 * Example:
 * ```
 * update_data($instanceId, $databaseId);
 * ```
 *
 * @param string $instanceId The Spanner instance ID.
 * @param string $databaseId The Spanner database ID.
 */
function delete_data_with_partitioned_dml(string $instanceId, string $databaseId): void
{
    $spanner = new SpannerClient();
    $instance = $spanner->instance($instanceId);
    $database = $instance->database($databaseId);

    $rowCount = $database->executePartitionedUpdate(
        'DELETE FROM Singers WHERE SingerId > 10'
    );

    printf('Deleted %d row(s).' . PHP_EOL, $rowCount);
}

Python

# instance_id = "your-spanner-instance"
# database_id = "your-spanner-db-id"
spanner_client = spanner.Client()
instance = spanner_client.instance(instance_id)
database = instance.database(database_id)

row_ct = database.execute_partitioned_dml("DELETE FROM Singers WHERE SingerId > 10")

print("{} record(s) deleted.".format(row_ct))

Ruby

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

row_count = client.execute_partition_update(
  "DELETE FROM Singers WHERE SingerId > 10"
)

puts "#{row_count} records deleted."

Étape suivante