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 primer.

Sebelum memulai

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

Memigrasikan kunci berurutan yang dibuat otomatis

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

1. Di Spanner, replikasi struktur tabel dari database sumber Anda, menggunakan kunci primer bilangan bulat.
2. 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.
3. 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 membuat batasan kunci asing untuk tabel dependen.
4. Sebelum memasukkan data baru, sesuaikan urutan Spanner untuk melewati rentang nilai kunci yang ada.
5. Masukkan 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 tabel tujuan:

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

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 berjenis 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 seragam di seluruh rentang [1, 263] dan kemungkinan ada konflik dengan kunci yang ada. Untuk mencegah hal ini, Anda dapat mengonfigurasi urutan menggunakan ALTER_SEQUENCE (GoogleSQL atau PostgreSQL) untuk melewati rentang nilai yang dicakup oleh kunci yang ada.

Asumsikan tabel singers dimigrasikan dari PostgreSQL, dengan kunci primernya singer_id berjenis SERIAL. PostgreSQL berikut menunjukkan DDL database sumber Anda:

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:

SELECT MAX(SingerId) FROM Singers;

SELECT MAX(SingerId) FROM Singers;

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

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

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 membuat kunci utama, misalnya untuk mengaktifkan replikasi di kedua arah untuk pemulihan dari bencana selama pengalihan migrasi.

Untuk mendukung hal ini, kedua database membuat 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 peralihan.

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

Asumsikan database PostgreSQL sumber Anda menggunakan kunci primer 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:

ALTER TABLE Singers ALTER COLUMN SingerId TYPE bigint;

Anda dapat menetapkan batasan CHECK ke tabel di database PostgreSQL sumber untuk memastikan nilai kunci primer SingerId selalu lebih kecil atau sama dengan 231-1.

Gunakan kode berikut di database PostgreSQL sumber Anda:

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

Di Spanner, kita dapat mengubah urutan untuk melewati rentang [1, 231-1].

Gunakan kode berikut di Spanner:

ALTER SEQUENCE SingerIdSequence SET OPTIONS (
skip_range_min = 1,
skip_range_max = 2147483647 -- 231-1
);

ALTER SEQUENCE SingerIdSequence SKIP RANGE 1 2147483648;

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

Memigrasikan kolom kunci UUID

Kunci UUIDv4 secara efektif unik di mana pun 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:

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

Berikut adalah contoh alur kerja migrasi:

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

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

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

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 tersebut atau untuk mengurutkan data yang baru dibuat. Untuk menggunakan kunci berurutan yang dibuat secara eksternal di Spanner, Anda dapat membuat kunci komposit yang menggabungkan nilai yang didistribusikan secara seragam, seperti hash, sebagai komponen pertama dan kunci berurutan Anda sebagai komponen kedua. Dengan cara ini, Anda dapat mempertahankan nilai kunci berurutan, tanpa membuat hot spot dalam skala besar. Pertimbangkan alur kerja migrasi berikut:

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

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

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

StudentIdHash = FARM_FINGERPRINT(CAST(StudentId AS STRING))

Anda dapat menggunakan kode berikut di Spanner:

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

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 Anda 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 angka 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:

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

CREATE SEQUENCE MyFirstSequence BIT_REVERSED_POSITIVE
  SKIP RANGE 1 4294967296;

ALTER SEQUENCE MySecondSequence SKIP RANGE 1 4294967296;

Jika Anda menggunakan kolom IDENTITY untuk membuat nilai bilangan bulat secara otomatis untuk kolom utama, Anda dapat menetapkan rentang yang dilewati:

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;

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 Anda telah membalikkan bit nilai kunci untuk menghindari masalah hot spot di database sumber, Anda juga dapat menggunakan urutan positif yang dibalikkan bit Spanner (GoogleSQL, PostgreSQL) untuk terus membuat nilai tersebut. Untuk menghindari pembuatan nilai duplikat, Anda dapat mengonfigurasi urutan untuk memulai penghitungannya dari angka kustom.

Misalnya, jika Anda membalikkan angka dari 1 hingga 1000 untuk membuat nilai kunci primer, urutan Spanner dapat memulai penghitungannya dari angka yang lebih besar dari 10.000. Jika perlu, Anda dapat memilih angka yang tinggi untuk menyisakan buffer bagi penulisan baru yang terjadi di database sumber setelah migrasi data. Dalam contoh berikut, penghitung dimulai dari 11.000:

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

ALTER SEQUENCE MySecondSequence SET OPTIONS (
  start_with_counter = 11000
);

CREATE SEQUENCE MyFirstSequence BIT_REVERSED_POSITIVE
  START COUNTER 11000;

ALTER SEQUENCE MySecondSequence RESTART COUNTER 11000;

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

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;

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 berikutnya

• Ringkasan migrasi kunci utama