Halaman ini diterjemahkan oleh Cloud Translation API.

Memigrasikan kunci utama

Halaman ini menjelaskan cara memigrasikan kunci utama dari tabel database sumber ke database dialek GoogleSQL Spanner dan database dialek PostgreSQL. Sebelum melakukan prosedur di halaman, tinjau Ringkasan migrasi kunci utama.

Sebelum memulai

Untuk mendapatkan izin yang diperlukan guna memigrasikan kunci utama ke Spanner, minta administrator untuk memberi Anda peran IAM Cloud Spanner Database Admin (roles/spanner.databaseAdmin) di instance.

Catatan: Peran dasar IAM mungkin juga berisi izin untuk memigrasikan kunci utama ke Spanner. Anda tidak boleh memberikan peran dasar dalam lingkungan produksi, tetapi Anda dapat memberikannya dalam lingkungan pengembangan atau pengujian.

Memigrasikan kunci berurutan yang dibuat otomatis

Jika Anda bermigrasi dari database yang menggunakan kunci monoton berurutan, seperti AUTO_INCREMENT di MySQL, SERIAL di PostgreSQL, atau jenis IDENTITY standar di SQL Server atau Oracle, pertimbangkan strategi migrasi tingkat tinggi berikut:

Di Spanner, replikasi struktur tabel dari database sumber Anda, menggunakan kunci utama bilangan bulat.
Untuk setiap kolom di Spanner yang berisi nilai berurutan, buat urutan dan tetapkan fungsi GET_NEXT_SEQUENCE_VALUE ( GoogleSQL, PostgreSQL) sebagai nilai default untuk kolom.
Migrasikan data yang ada dengan kunci asli dari database sumber ke Spanner. Sebaiknya gunakan alat migrasi Spanner atau template Dataflow.
1. Secara opsional, Anda dapat menetapkan batasan kunci asing untuk tabel dependen apa pun.
Sebelum menyisipkan data baru, sesuaikan urutan Spanner untuk melewati rentang nilai kunci yang ada.
Sisipkan data baru, sehingga urutan dapat menghasilkan kunci unik secara otomatis.

Contoh alur kerja migrasi

Kode berikut menentukan struktur tabel dan urutan terkait di Spanner menggunakan objek SEQUENCE dan menetapkan objek sebagai nilai utama default dari tabel tujuan:

GoogleSQL

CREATE SEQUENCE singer_id_sequence OPTIONS (
     SequenceKind = 'bit_reversed_positive'
  );

CREATE TABLE Singers (
     SingerId INT64 DEFAULT
     (GET_NEXT_SEQUENCE_VALUE(SEQUENCE SingerIdSequence)),
     Name STRING(1024),
     Biography STRING(MAX),
  ) PRIMARY KEY (SingerId);

CREATE TABLE Albums (
     AlbumId INT64,
     SingerId INT64,
     AlbumName STRING(1024),
     SongList STRING(MAX),
     CONSTRAINT FK_singer_album
     FOREIGN KEY (SingerId)
       REFERENCES Singers (SingerId)
  ) PRIMARY KEY (AlbumId);

PostgreSQL

CREATE SEQUENCE SingerIdSequence BIT_REVERSED_POSITIVE;

CREATE TABLE Singers (
  SingerId BIGINT DEFAULT nextval('SingerIdSequence') PRIMARY KEY,
  Name VARCHAR(1024) NOT NULL,
  Biography TEXT
);

CREATE TABLE Albums (
  AlbumId BIGINT PRIMARY KEY,
  SingerId BIGINT,
  AlbumName VARCHAR(1024),
  SongList TEXT,
  CONSTRAINT FK_singer_album FOREIGN KEY (SingerId) REFERENCES Singers (SingerId)
);

Opsi bit_reversed_positive menunjukkan bahwa nilai yang dihasilkan oleh urutan adalah jenis INT64, lebih besar dari nol, dan tidak berurutan.

Saat Anda memigrasikan baris yang ada dari database sumber ke Spanner, kunci utama tetap tidak berubah.

Untuk penyisipan baru yang tidak menentukan kunci utama, Spanner akan otomatis mengambil nilai baru dengan memanggil fungsi GET_NEXT_SEQUENCE_VALUE(GoogleSQL atau PostgreSQL).

Nilai ini didistribusikan secara merata di seluruh rentang [1, 2⁶³] dan mungkin ada kemungkinan konflik dengan kunci yang ada. Untuk mencegah hal ini, Anda dapat mengonfigurasi urutan menggunakan ALTER_SEQUENCE (GoogleSQL atau PostgreSQL) untuk melewati rentang nilai yang tercakup oleh kunci yang ada.

Asumsikan tabel singers dimigrasikan dari PostgreSQL, dengan kunci utamanya singer_id adalah jenis SERIAL. PostgreSQL berikut menampilkan DDL database sumber Anda:

PostgreSQL

CREATE TABLE Singers (
SingerId SERIAL PRIMARY KEY,
Name varchar(1024),
Biography varchar
);

Nilai kunci utama meningkat secara monoton. Setelah migrasi, Anda dapat mengambil nilai maksimum kunci utama singer_id di Spanner. Gunakan kode berikut di Spanner:

GoogleSQL

SELECT MAX(SingerId) FROM Singers;

PostgreSQL

SELECT MAX(SingerId) FROM Singers;

Asumsikan nilai yang ditampilkan adalah 20.000. Anda dapat mengonfigurasi urutan Spanner untuk melewati rentang [1, 21000]. 1.000 tambahan berfungsi sebagai buffering untuk mengakomodasi penulisan ke database sumber setelah migrasi awal. Kunci baru yang dihasilkan di Spanner tidak bertentangan dengan rentang kunci utama yang dihasilkan di database PostgreSQL sumber. Gunakan kode berikut di Spanner:

GoogleSQL

ALTER SEQUENCE SingerIdSequence SET OPTIONS (
skip_range_min = 1,
skip_range_max = 21000
);

PostgreSQL

ALTER SEQUENCE SingerIdSequence SKIP RANGE 1 21000;

Menggunakan Spanner dan database sumber Anda

Anda dapat menggunakan konsep rentang lewati untuk mendukung skenario saat Spanner atau database sumber Anda menghasilkan kunci utama, misalnya, untuk mengaktifkan replikasi di kedua arah untuk pemulihan dari bencana selama penghentian migrasi.

Untuk mendukung hal ini, kedua database menghasilkan kunci utama dan data disinkronkan di antara keduanya. Anda dapat mengonfigurasi setiap database untuk membuat kunci utama dalam rentang kunci yang tidak tumpang-tindih. Saat menentukan rentang untuk database sumber, Anda dapat mengonfigurasi urutan Spanner untuk melewati rentang tersebut.

Misalnya, setelah migrasi aplikasi trek musik, replikasi data dari PostgreSQL ke Spanner untuk mengurangi waktu yang diperlukan untuk melakukan pengalihan.

Setelah memperbarui dan menguji aplikasi di Spanner, Anda dapat berhenti menggunakan database PostgreSQL sumber dan menggunakan Spanner, sehingga menjadikannya sistem data untuk pembaruan dan kunci utama baru. Saat Spanner mengambil alih, Anda dapat membalikkan aliran data antara database ke instance PostgreSQL.

Asumsikan database PostgreSQL sumber Anda menggunakan kunci utama SERIAL, yang merupakan bilangan bulat bertanda 32-bit. Kunci utama Spanner adalah angka 64-bit yang lebih besar. Di PostgreSQL, ubah kolom kunci utama menjadi kolom 64-bit, atau bigint. Gunakan kode berikut di database PostgreSQL sumber Anda:

PostgreSQL

ALTER TABLE Singers ALTER COLUMN SingerId TYPE bigint;

Anda dapat menetapkan batasan CHECK ke tabel di database PostgreSQL sumber untuk memastikan nilai kunci utama SingerId selalu lebih kecil dari atau sama dengan 2³¹-1.

Gunakan kode berikut di database PostgreSQL sumber Anda:

PostgreSQL

ALTER TABLE Singers ADD CHECK (SingerId <= 2147483647);

Di Spanner, kita dapat mengubah urutan untuk melewati rentang [1, 2³¹-1].

Gunakan kode berikut di Spanner:

GoogleSQL

ALTER SEQUENCE SingerIdSequence SET OPTIONS (
skip_range_min = 1,
skip_range_max = 2147483647 -- 2³¹-1
);

PostgreSQL

ALTER SEQUENCE SingerIdSequence SKIP RANGE 1 2147483648;

Database PostgreSQL sumber Anda selalu menghasilkan kunci dalam ruang bilangan bulat 32-bit, sedangkan kunci Spanner dibatasi pada ruang bilangan bulat 64-bit, yang lebih besar dari semua nilai bilangan bulat 32-bit. Hal ini memastikan kedua database Anda dapat membuat kunci utama secara independen yang tidak bertentangan.

Memigrasikan kolom kunci UUID

Kunci UUIDv4 secara efektif unik, terlepas dari tempat kunci tersebut dibuat. Kunci UUID yang dibuat di tempat lain terintegrasi dengan kunci UUID baru yang dibuat di Spanner.

Pertimbangkan strategi tingkat tinggi berikut untuk memigrasikan kunci UUID ke Spanner:

Tentukan kunci UUID Anda di Spanner menggunakan kolom string dengan ekspresi default. Gunakan fungsi GENERATE_UUID() (GoogleSQL, PostgreSQL).
Mengekspor data dari sistem sumber, yang melakukan serialisasi kunci UUID sebagai string.
Impor kunci utama ke Spanner.
Opsional: Aktifkan kunci asing.

Berikut adalah contoh alur kerja migrasi:

Di Spanner, tentukan kolom kunci utama UUID sebagai jenis STRING atau TEXT dan tetapkan GENERATE_UUID() (GoogleSQL atau PostgreSQL) sebagai nilai defaultnya. Migrasikan semua data dari database sumber ke Spanner. Setelah migrasi, saat baris baru disisipkan, Spanner memanggil GENERATE_UUID() untuk membuat nilai UUID baru untuk kunci utama. Misalnya, kunci utama FanClubId mendapatkan nilai UUIDv4 saat baris baru disisipkan dalam tabel FanClubs. Gunakan kode berikut di Spanner:

GoogleSQL

CREATE TABLE Fanclubs (
FanClubId STRING(36) DEFAULT (GENERATE_UUID()),
ClubName STRING(1024),
) PRIMARY KEY (FanClubId);

INSERT INTO FanClubs (ClubName) VALUES ("SwiftFanClub");

PostgreSQL

CREATE TABLE FanClubs (
  FanClubId TEXT DEFAULT spanner.generate_uuid() PRIMARY KEY,
  ClubName VARCHAR(1024)
);

INSERT INTO FanClubs (ClubName) VALUES ('SwiftFanClub');

Memigrasikan kunci utama Anda sendiri

Aplikasi Anda mungkin mengandalkan urutan kunci utama untuk menentukan seberapa baru data atau untuk mengurutkan data yang baru dibuat. Untuk menggunakan kunci berurutan yang dihasilkan secara eksternal di Spanner, Anda dapat membuat kunci komposit yang menggabungkan nilai yang didistribusikan secara merata, seperti hash, sebagai komponen pertama dan kunci berurutan sebagai komponen kedua. Dengan cara ini, Anda dapat mempertahankan nilai kunci berurutan, tanpa membuat hot spot dalam skala besar. Pertimbangkan alur kerja migrasi berikut:

Anggap Anda perlu memigrasikan tabel MySQL students dengan kunci utama AUTO_INCREMENT ke Spanner. Gunakan kode berikut di database MySQL sumber Anda:

MySQL

CREATE TABLE Students (
StudentId INT NOT NULL AUTO_INCREMENT,
Info VARCHAR(2048),
PRIMARY KEY (StudentId)
);

Di Spanner, Anda dapat menambahkan kolom StudentIdHash yang dihasilkan dengan membuat hash kolom StudentId. Contoh:

StudentIdHash = FARM_FINGERPRINT(CAST(StudentId AS STRING))

Anda dapat menggunakan kode berikut di Spanner:

GoogleSQL

CREATE TABLE student (
  StudentIdHash INT64 AS (FARM_FINGERPRINT(cast(StudentId as string))) STORED,
  StudentId INT64 NOT NULL,
  Info STRING(2048),
) PRIMARY KEY(StudentIdHash, StudentId);

PostgreSQL

CREATE TABLE Student (
  StudentIdHash bigint GENERATED ALWAYS AS
  (FARM_FINGERPRINT(cast(StudentId AS varchar))) STORED,
  StudentId bigint NOT NULL,
  Info varchar(2048),
  PRIMARY KEY (StudentIdHash, StudentId)
);

Memigrasikan kolom kunci berurutan

Jika sistem database sumber menghasilkan nilai berurutan untuk kolom kunci, Anda dapat menggunakan urutan positif yang dibalik bitnya (GoogleSQL, PostgreSQL) dalam skema Spanner untuk menghasilkan nilai yang didistribusikan secara merata di seluruh ruang bilangan bilangan bulat 64-bit positif. Untuk mencegah urutan Spanner menghasilkan nilai yang tumpang-tindih dengan nilai yang dimigrasikan, Anda dapat menentukan rentang yang dilewati untuknya.

Misalnya, Anda dapat melewati rentang dari 1 hingga 4.294.967.296 (2^32) untuk dua urutan berikut, jika Anda mengetahui bahwa database sumber hanya menghasilkan bilangan bulat 32-bit:

GoogleSQL

CREATE SEQUENCE MyFirstSequence OPTIONS (
  sequence_kind = "bit_reversed_positive",
  skip_range_min = 1,
  skip_range_max = 4294967296
);

ALTER SEQUENCE MySecondSequence SET OPTIONS (
  skip_range_min = 1,
  skip_range_max = 4294967296
);

PostgreSQL

CREATE SEQUENCE MyFirstSequence BIT_REVERSED_POSITIVE
  SKIP RANGE 1 4294967296;

ALTER SEQUENCE MySecondSequence SKIP RANGE 1 4294967296;

Jika menggunakan kolom IDENTITY untuk membuat nilai bilangan bulat secara otomatis untuk kolom kunci, Anda dapat menetapkan rentang lewati:

GoogleSQL

Untuk menetapkan rentang lewati, gunakan perintah GENERATED BY DEFAULT AS IDENTITY:

ALTER DATABASE db SET OPTIONS (
  default_sequence_kind = 'bit_reversed_positive',
);

CREATE TABLE MyFirstTable (
  Id INT64 GENERATED BY DEFAULT AS IDENTITY (SKIP RANGE 1, 4294967296),
  Name STRING(MAX),
) PRIMARY KEY (Id);

ALTER TABLE MyFirstTable ALTER COLUMN Id ALTER IDENTITY SET SKIP RANGE 1, 4294967296;

PostgreSQL

Untuk menetapkan rentang lewati, gunakan perintah GENERATED BY DEFAULT AS IDENTITY:

ALTER DATABASE db
    SET spanner.default_sequence_kind = 'bit_reversed_positive';

CREATE TABLE MyFirstTable (
  Id bigint GENERATED BY DEFAULT AS IDENTITY (SKIP RANGE 1 4294967296),
  Name text,
  PRIMARY KEY (Id)
);

ALTER TABLE MyFirstTable ALTER COLUMN Id SET SKIP RANGE 1 4294967296;

Memigrasikan kolom kunci yang dibalik bitnya

Jika telah melakukan bit-reverse pada nilai kunci untuk menghindari masalah hot spot di database sumber, Anda juga dapat menggunakan urutan positif bit-reverse Spanner (GoogleSQL, PostgreSQL) untuk terus menghasilkan nilai tersebut. Untuk menghindari pembuatan nilai duplikat, Anda dapat mengonfigurasi urutan untuk memulai penghitungnya dari angka kustom.

Misalnya, jika Anda membalik angka dari 1 hingga 1.000 untuk menghasilkan nilai kunci utama, urutan Spanner dapat memulai penghitungnya dari angka apa pun yang lebih besar dari 10.000. Secara opsional, Anda dapat memilih angka yang tinggi untuk meninggalkan buffer untuk penulisan baru yang terjadi di database sumber setelah migrasi data. Dalam contoh berikut, penghitung dimulai dari 11.000:

GoogleSQL

CREATE SEQUENCE MyFirstSequence OPTIONS (
  sequence_kind = "bit_reversed_positive",
  start_with_counter = 11000
);

ALTER SEQUENCE MySecondSequence SET OPTIONS (
  start_with_counter = 11000
);

PostgreSQL

CREATE SEQUENCE MyFirstSequence BIT_REVERSED_POSITIVE
  START COUNTER 11000;

ALTER SEQUENCE MySecondSequence RESTART COUNTER 11000;

Jika menggunakan kolom IDENTITY untuk secara otomatis menghasilkan nilai bilangan bulat untuk kolom kunci, Anda dapat menetapkan penghitung awal:

GoogleSQL

Untuk menetapkan penghitung awal, gunakan perintah GENERATED BY DEFAULT AS IDENTITY:

ALTER DATABASE db SET OPTIONS (
  default_sequence_kind = 'bit_reversed_positive',
);

CREATE TABLE MyFirstTable (
  Id INT64 GENERATED BY DEFAULT AS IDENTITY (START COUNTER WITH 11000),
  Name STRING(MAX),
) PRIMARY KEY (Id);

ALTER TABLE MyFirstTable ALTER COLUMN Id ALTER IDENTITY RESTART COUNTER WITH 11000;

PostgreSQL

Untuk menetapkan penghitung awal, gunakan perintah GENERATED BY DEFAULT AS IDENTITY:

ALTER DATABASE db
    SET spanner.default_sequence_kind = 'bit_reversed_positive';

CREATE TABLE MyFirstTable (
  Id bigint GENERATED BY DEFAULT AS IDENTITY (START COUNTER WITH 11000),
  Name text,
  PRIMARY KEY (Id)
);

ALTER TABLE MyFirstTable ALTER COLUMN Id RESTART COUNTER WITH 11000;

Langkah selanjutnya

Ringkasan migrasi kunci utama