Langage de manipulation de données partitionné

Langage de manipulation de données partitionné (partitionné) LMD) 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 mode LMD partitionné n'est pas adapté au traitement des transactions à petite échelle. Si vous exécuter une instruction sur quelques lignes, utilisez des LMD transactionnels avec des variables clés primaires. Pour en savoir plus, consultez la section Utiliser le langage de manipulation de données (LMD).

Si vous devez valider un grand nombre d'écritures à l'aveugle, mais que vous n'avez pas besoin atomique, vous pouvez modifier vos tables Spanner de façon groupée à l'aide de l'écriture par lot. Pour en savoir plus, consultez la page Modifier des données à l'aide d'écritures par lot.

Vous pouvez obtenir des insights sur les requêtes LMD partitionnées actives et sur leur progression à partir de de statistiques de votre base de données Spanner. Pour plus d'informations, consultez la page Statistiques concernant les LMD partitionnés actifs.

LMD et LMD partitionné

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

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

  • Le LMD partitionné permet d'effectuer des opérations à grande échelle à l'échelle de la base de données avec impact minimal sur le traitement des transactions simultanées grâce au partitionnement de la clé et en exécutant l'instruction sur des partitions dans des partitions distinctes, de plus petite les transactions. Pour en savoir plus, consultez la page Utiliser 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 en mode LMD partitionné est exécutée, les lignes d'une partition n'ont pas accès aux lignes des autres partitions. En outre, vous ne pouvez pas choisir la manière dont Spanner crée les partitions. Le partitionnement garantit l'évolutivité, Les instructions LMD partitionnées doivent être entièrement partitionnables. En d'autres termes, l'instruction en mode LMD partitionné doit pouvoir être exprimée comme l'union d'un ensemble d'instructions, chaque instruction accédant à une seule ligne de la table et à 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 une instruction LMD partitionnée plusieurs fois sur certaines partitions en raison de nouvelles tentatives au niveau du réseau. Par conséquent, une déclaration peut s'exécuter 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 des lignes

Spanner n'acquiert un verrouillage que si une ligne est susceptible d'être mise à jour ou supprimée. Ce comportement est différent de Exécution en mode LMD, qui peut être verrouillée en lecture les lignes qui ne correspondent 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 au client .

Spanner n'applique pas les instructions en mode LMD partitionné de manière atomique sur l'ensemble de la table. Toutefois, Spanner applique des règles Instructions LMD 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 ne restaure aucune partition ayant déjà exécuté.
  • Si l'exécution de l'instruction provoque une erreur, l'exécution s'arrête. sur l'ensemble des partitions. Spanner renvoie cette erreur l'intégralité de l'opération. Exemples d'erreurs : non-respect du type de données les contraintes, les cas de non-respect de UNIQUE INDEX et les cas de non-respect de ON DELETE NO ACTION. Selon le moment où l'exécution a échoué, le peut avoir été correctement exécutée sur certaines partitions, qui n'ont jamais été exécutées sur d'autres partitions.

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

Nombre de lignes modifiées

Une instruction LMD partitionnée renvoie la limite inférieure du nombre d'instances lignes. Il se peut que le nombre de lignes modifiées ne soit pas exact, car rien ne garantit que Spanner compte toutes les lignes modifiées.

Limites de transaction

Spanner crée les partitions et les transactions nécessaires 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 console Google Cloud.
  • Plans de requête et profilage: Google Cloud CLI et le client ne prennent pas en charge les plans de requête ni le profilage.
  • Sous-requêtes qui lisent les données d’une autre table ou d’une ligne différente de la même table.

Pour des scénarios complexes, comme le déplacement d'une table ou de transformations nécessitant 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 en mode LMD partitionné.


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 en mode LMD partitionné.

// 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 en mode LMD partitionné.

# 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 en mode LMD partitionné.

# 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