Google menggunakan teknologi AI untuk menerjemahkan konten ke dalam bahasa pilihan Anda. Terjemahan AI mungkin mengandung kesalahan.

Bahasa Manipulasi Data Berpartisi

Bahasa Manipulasi Data yang Dipartisi (DML yang dipartisi ) dirancang untuk jenis update dan penghapusan massal berikut:

Pembersihan berkala dan pembersihan sampah memori. Contohnya adalah menghapus baris lama atau menetapkan kolom ke NULL.
Mengisi kolom baru dengan nilai default. Contohnya adalah menggunakan pernyataan UPDATE untuk menetapkan nilai kolom baru ke False jika saat ini NULL.

DML yang dipartisi tidak cocok untuk pemrosesan transaksi skala kecil. Jika Anda ingin menjalankan pernyataan pada beberapa baris, gunakan DML transaksional dengan kunci utama yang dapat diidentifikasi. Untuk mengetahui informasi selengkapnya, lihat Menggunakan DML.

Jika Anda perlu melakukan sejumlah besar penulisan tanpa melihat data, tetapi tidak memerlukan transaksi atomik, Anda dapat mengubah tabel Spanner secara massal menggunakan operasi tulis batch. Untuk mengetahui informasi selengkapnya, lihat Mengubah data menggunakan operasi tulis batch.

Anda bisa mendapatkan insight tentang kueri DML yang dipartisi aktif dan progresnya dari tabel statistik di database Spanner. Untuk mengetahui informasi selengkapnya, lihat Statistik DML yang dipartisi aktif.

DML dan DML yang dipartisi

Spanner mendukung dua mode eksekusi untuk pernyataan DML:

DML, yang cocok untuk pemrosesan transaksi. Untuk mengetahui informasi selengkapnya, lihat Menggunakan DML.
DML yang dipartisi, yang memungkinkan operasi skala besar di seluruh database dengan dampak minimal pada pemrosesan transaksi serentak dengan mempartisi ruang kunci dan menjalankan pernyataan di seluruh partisi dalam transaksi yang terpisah dan cakupannya lebih kecil. Untuk mengetahui informasi selengkapnya, lihat Menggunakan DML yang dipartisi.

Tabel berikut menyoroti beberapa perbedaan antara kedua mode eksekusi.

DML	DML yang dipartisi
Baris yang tidak cocok dengan klausa `WHERE` mungkin dikunci.	Hanya baris yang cocok dengan klausa `WHERE` yang dikunci.
Batas ukuran transaksi berlaku.	Spanner menangani batas transaksi dan batas konkurensi per transaksi.
Pernyataan tidak harus bersifat idempoten.	Pernyataan DML harus bersifat idempoten untuk memastikan hasil yang konsisten.
Transaksi dapat menyertakan beberapa pernyataan DML dan SQL.	Transaksi yang dipartisi hanya dapat menyertakan satu pernyataan DML.
Tidak ada batasan pada kompleksitas pernyataan.	Pernyataan harus dapat dipartisi sepenuhnya.
Anda membuat transaksi baca-tulis dalam kode klien.	Spanner membuat transaksi.

Dapat dipartisi dan idempoten

Saat pernyataan DML yang dipartisi berjalan, baris dalam satu partisi tidak memiliki akses ke baris di partisi lain, dan Anda tidak dapat memilih cara Spanner membuat partisi. Partisi memastikan skalabilitas, tetapi juga berarti bahwa pernyataan DML yang dipartisi harus dapat dipartisi sepenuhnya. Artinya, pernyataan DML yang dipartisi harus dapat dinyatakan sebagai gabungan dari sekumpulan pernyataan, dengan setiap pernyataan mengakses satu baris tabel dan setiap pernyataan tidak mengakses tabel lain. Misalnya, pernyataan DML yang mengakses beberapa tabel atau melakukan self-join tidak dapat dipartisi. Jika pernyataan DML tidak dapat dipartisi, Spanner akan menampilkan error BadUsage.

Pernyataan DML ini dapat dipartisi sepenuhnya, karena setiap pernyataan dapat diterapkan ke satu baris dalam tabel:

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

DELETE FROM Albums WHERE MarketingBudget > 10000;

Pernyataan DML ini tidak dapat dipartisi sepenuhnya, karena mengakses beberapa tabel:

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

Spanner mungkin menjalankan pernyataan DML yang dipartisi beberapa kali terhadap beberapa partisi karena percobaan ulang tingkat jaringan. Akibatnya, pernyataan mungkin dijalankan lebih dari satu kali terhadap sebuah baris. Oleh karena itu, pernyataan harus idempoten untuk menghasilkan hasil yang konsisten. Pernyataan bersifat idempoten jika menjalankannya beberapa kali terhadap satu baris akan menghasilkan hasil yang sama.

Pernyataan DML ini bersifat idempoten:

UPDATE Singers SET MarketingBudget = 1000 WHERE true;

Pernyataan DML ini tidak bersifat idempoten:

UPDATE Singers SET MarketingBudget = 1.5 * MarketingBudget WHERE true;

Menghapus baris dari tabel induk dengan tabel turunan yang diindeks

Saat Anda menggunakan pernyataan DML yang dipartisi untuk menghapus baris dalam tabel induk, operasi mungkin gagal dengan error: The transaction contains too many mutations. Hal ini terjadi jika tabel induk memiliki tabel turunan yang disisipkan yang berisi indeks global. Mutasi ke baris tabel turunan itu sendiri tidak dihitung terhadap batas mutasi transaksi. Namun, mutasi yang sesuai ke entri indeks akan dihitung. Jika sejumlah besar entri indeks tabel turunan terpengaruh, transaksi mungkin melebihi batas mutasi.

Untuk menghindari error ini, hapus baris dalam dua pernyataan DML yang dipartisi terpisah:

Jalankan penghapusan yang dipartisi pada tabel turunan.
Jalankan penghapusan yang dipartisi pada tabel induk.

Proses dua langkah ini membantu menjaga jumlah mutasi dalam batas yang diizinkan untuk setiap transaksi. Atau, Anda dapat menghapus indeks global pada tabel turunan sebelum menghapus baris induk.

Penguncian baris

Spanner hanya memperoleh kunci jika baris adalah kandidat untuk diupdate atau dihapus. Perilaku ini berbeda dengan eksekusi DML, yang mungkin mengunci baris baca yang tidak cocok dengan klausa WHERE.

Eksekusi dan transaksi

Apakah pernyataan DML dipartisi atau tidak bergantung pada metode library klien yang Anda pilih untuk eksekusi. Setiap library klien menyediakan metode terpisah untuk eksekusi DML dan eksekusi DML yang Dipartisi.

Anda hanya dapat menjalankan satu pernyataan DML yang dipartisi dalam panggilan ke metode library klien.

Spanner tidak menerapkan pernyataan DML yang dipartisi secara atomik di seluruh tabel. Namun, Spanner menerapkan pernyataan DML yang dipartisi secara atomik di setiap partisi.

DML yang dipartisi tidak mendukung commit atau rollback. Spanner segera menjalankan dan menerapkan pernyataan DML.

Jika Anda membatalkan operasi, Spanner akan membatalkan partisi yang sedang dieksekusi dan tidak memulai partisi yang tersisa. Spanner tidak melakukan rollback pada partisi yang telah dieksekusi.
Jika eksekusi pernyataan menyebabkan error, eksekusi akan berhenti di semua partisi dan Spanner akan menampilkan error tersebut untuk seluruh operasi. Beberapa contoh error adalah pelanggaran batasan jenis data kendala, pelanggaran UNIQUE INDEX, dan pelanggaran ON DELETE NO ACTION. Bergantung pada waktu saat eksekusi gagal, pernyataan mungkin berhasil dijalankan terhadap beberapa partisi, dan mungkin tidak pernah dijalankan terhadap partisi lain.

Jika pernyataan DML yang dipartisi berhasil, Spanner akan menjalankan pernyataan tersebut setidaknya satu kali terhadap setiap partisi rentang kunci.

Jumlah baris yang diubah

Pernyataan DML yang dipartisi menampilkan batas bawah pada jumlah baris yang diubah. Jumlah baris yang diubah mungkin tidak tepat, karena tidak ada jaminan bahwa Spanner menghitung semua baris yang diubah.

Batas transaksi

Spanner membuat partisi dan transaksi yang diperlukan untuk menjalankan pernyataan DML yang dipartisi. Batas transaksi atau batas konkurensi per transaksi berlaku, tetapi Spanner mencoba menjaga transaksi dalam batas.

Spanner mengizinkan maksimum 20.000 pernyataan DML yang dipartisi serentak per database.

Fitur yang tidak didukung

Spanner tidak mendukung beberapa fitur untuk DML yang dipartisi:

INSERT tidak didukung.
Google Cloud Konsol: Anda tidak dapat menjalankan pernyataan DML yang dipartisi di Google Cloud konsol.
Paket kueri dan pembuatan profil: Google Cloud CLI dan library klien tidak mendukung paket kueri dan pembuatan profil.
Subkueri yang dibaca dari tabel lain, atau baris lain dari tabel yang sama.

Untuk skenario yang kompleks, seperti memindahkan tabel atau transformasi yang memerlukan gabungan antar-tabel, pertimbangkan untuk menggunakan konektor Dataflow.

Praktik terbaik

Terapkan praktik terbaik berikut untuk meningkatkan performa pernyataan DML yang dipartisi:

Hindari konkurensi tinggi: Menjalankan sejumlah besar pernyataan DML yang dipartisi secara serentak (misalnya, lebih dari 100) dapat menyebabkan pertentangan kunci pada tabel sistem internal, sehingga menurunkan performa. Daripada menjalankan sejumlah besar pernyataan serentak, gunakan satu pernyataan DML yang dipartisi.
Gunakan PDML_MAX_PARALLELISM: Untuk meningkatkan throughput satu pernyataan DML yang dipartisi, terutama pada tabel dengan banyak pemisahan, tetapkan nilai yang lebih tinggi untuk PDML_MAX_PARALLELISM petunjuk pernyataan. Hal ini memungkinkan satu pernyataan menggunakan lebih banyak paralelisme secara internal. Menetapkan nilai yang lebih tinggi untuk PDML_MAX_PARALLELISM akan menghasilkan penggunaan komputasi yang lebih banyak, jadi Anda harus mencoba menyeimbangkan penggunaan komputasi dan peningkatan kecepatan pemrosesan.
Biarkan Spanner menangani partisi: Hindari sharding data secara manual (misalnya, menggunakan rentang kunci utama) dan menjalankan pernyataan DML yang dipartisi terpisah pada setiap shard. DML yang dipartisi dirancang untuk mempartisi pekerjaan secara efisien di seluruh tabel. Sharding kustom sering kali meningkatkan overhead dan dapat memperburuk pertentangan.
Memahami cakupan partisi: Operasi DML yang dipartisi diparalelkan di semua pemisahan di seluruh database, bukan hanya pemisahan yang berisi data untuk tabel yang diubah. Artinya, untuk database dengan sejumlah besar pemisahan, mungkin ada overhead meskipun tabel target kecil atau data yang diubah dilokalkan. DML yang dipartisi mungkin bukan pilihan yang paling efisien untuk mengubah sebagian kecil database besar.
Pertimbangkan alternatif untuk penghapusan kecil yang sering dilakukan: Untuk kasus penggunaan yang melibatkan penghapusan sejumlah kecil baris yang diketahui, penggunaan pernyataan DML dalam transaksi atau BatchWrite API mungkin menawarkan performa yang lebih baik dan overhead yang lebih rendah daripada menggunakan DML yang dipartisi.

Contoh

Contoh kode berikut mengupdate kolom MarketingBudget dari tabel Albums.

C++

Anda menggunakan fungsi ExecutePartitionedDml() untuk menjalankan pernyataan DML yang dipartisi.

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#

Anda menggunakan metode ExecutePartitionedUpdateAsync() untuk menjalankan pernyataan DML yang dipartisi.


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

Anda menggunakan metode PartitionedUpdate() untuk menjalankan pernyataan DML yang dipartisi.


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

Anda menggunakan metode executePartitionedUpdate() untuk menjalankan pernyataan DML yang dipartisi.

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

Anda menggunakan metode runPartitionedUpdate() untuk menjalankan pernyataan DML yang dipartisi.

// 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

Anda menggunakan metode executePartitionedUpdate() untuk menjalankan pernyataan DML yang dipartisi.

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

Anda menggunakan metode execute_partitioned_dml() untuk menjalankan pernyataan DML yang dipartisi.

# 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

Anda menggunakan metode execute_partitioned_update() untuk menjalankan pernyataan DML yang dipartisi.

# 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."

Contoh kode berikut menghapus baris dari tabel Singers, berdasarkan kolom 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."

Apa langkah selanjutnya?

Pelajari cara mengubah data Menggunakan DML.
Pelajari tentang praktik terbaik bahasa pengolahan data (DML).
Untuk mempelajari perbedaan antara DML dan mutasi, lihat Membandingkan DML dan Mutasi
Pertimbangkan untuk menggunakan konektor Dataflow untuk skenario transformasi data lainnya.

Bahasa Manipulasi Data Berpartisi Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

DML dan DML yang dipartisi

Dapat dipartisi dan idempoten

Menghapus baris dari tabel induk dengan tabel turunan yang diindeks

Penguncian baris

Eksekusi dan transaksi

Jumlah baris yang diubah

Batas transaksi

Fitur yang tidak didukung

Praktik terbaik

Contoh

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

C++

C#

Go

Java

Node.js

PHP

Python

Ruby

Apa langkah selanjutnya?

Bahasa Manipulasi Data Berpartisi