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 ini, tinjau Ringkasan migrasi kunci utama.

Sebelum memulai

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

  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:

1. Di Spanner, replikasi struktur tabel dari database sumber Anda, menggunakan kunci utama 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 tersebut.
3. Migrasikan data yang ada dengan kunci asli dari database sumber ke Spanner. Pertimbangkan untuk menggunakan alat migrasi Spanner atau template Dataflow.
   1. Secara opsional, Anda dapat menetapkan kunci asing batasan untuk tabel dependen.
4. Sebelum Anda menyisipkan data baru, sesuaikan urutan Spanner untuk melewati rentang nilai kunci yang ada.
5. Sisipkan data baru, sehingga urutan dapat membuat kunci unik secara otomatis.

Contoh alur kerja migrasi

Kode berikut menentukan struktur tabel dan urutan terkait di Spanner menggunakan SEQUENCE objek dan menetapkan objek sebagai nilai utama default 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 tersebut berjenis INT64, lebih besar dari nol, dan tidak berurutan.

Saat Anda memigrasikan baris yang ada dari database sumber ke Spanner, kunci utama akan 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 mungkin terjadi 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 utama singer_id berjenis SERIAL. PostgreSQL berikut menunjukkan 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]. Tambahan 1.000 berfungsi sebagai buffer untuk mengakomodasi penulisan ke database sumber setelah migrasi awal. Kunci baru yang dibuat di Spanner tidak akan berkonflik dengan rentang kunci utama yang dibuat 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 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 pengalihan.

Setelah memperbarui dan menguji aplikasi di Spanner, Anda dapat berhenti menggunakan database PostgreSQL sumber dan menggunakan Spanner, sehingga menjadikannya sistem rekaman untuk update 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 231-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, 231-1]

Gunakan kode berikut di Spanner:

GoogleSQL

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

PostgreSQL

ALTER SEQUENCE SingerIdSequence SKIP RANGE 1 2147483648;

Database PostgreSQL sumber Anda selalu membuat kunci di ruang bilangan bulat 32-bit, sedangkan kunci Spanner dibatasi ke 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 berkonflik.

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:

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

Berikut 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 default-nya. Migrasikan semua data dari database sumber ke Spanner. Setelah migrasi, saat baris baru disisipkan, Spanner akan 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 tersebut atau untuk mengurutkan data yang baru dibuat. Untuk menggunakan kunci berurutan yang dibuat secara eksternal di Spanner, Anda dapat membuat kunci gabungan 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 hotspot 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:

MySQL

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

Di Spanner, Anda dapat menambahkan kolom yang dibuat StudentIdHash 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 Anda membuat nilai berurutan untuk kolom kunci, Anda dapat menggunakan urutan positif yang dibalik bitnya (GoogleSQL, PostgreSQL) dalam skema Spanner untuk membuat nilai yang didistribusikan secara merata di seluruh ruang angka bilangan bulat 64-bit positif. Untuk mencegah urutan Spanner membuat 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 membuat 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 Anda menggunakan IDENTITY kolom untuk membuat nilai bilangan bulat secara otomatis untuk kolom kunci, Anda dapat menetapkan rentang lewati:

GoogleSQL

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

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 GENERATED BY DEFAULT AS IDENTITY perintah:

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 sudah membalik bit nilai kunci untuk menghindari masalah hotspot di database sumber, Anda juga dapat menggunakan urutan positif yang dibalik bitnya di Spanner (GoogleSQL, PostgreSQL) untuk terus membuat 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 1000 untuk membuat nilai kunci utama, urutan Spanner dapat memulai penghitungnya dari angka yang lebih besar dari 10.000. Secara opsional, 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:

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 Anda menggunakan IDENTITY kolom untuk membuat nilai bilangan bulat secara otomatis untuk kolom kunci, Anda dapat menetapkan penghitung awal:

GoogleSQL

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

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 GENERATED BY DEFAULT AS IDENTITY perintah:

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