Primärschlüssel migrieren

Auf dieser Seite wird beschrieben, wie Sie Primärschlüssel aus den Tabellen Ihrer Quelldatenbank in Spanner-Datenbanken mit GoogleSQL-Dialekt und PostgreSQL-Dialekt migrieren. Bevor Sie die Verfahren auf dieser Seite ausführen, sollten Sie sich die Übersicht zur Migration von Primärschlüsseln ansehen.

Hinweise

• Um die Berechtigungen zu erhalten, die Sie zum Migrieren von Primärschlüsseln zu Spanner benötigen, bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Cloud Spanner Database Admin (roles/spanner.databaseAdmin) für die Instanz zuzuweisen.

Automatisch generierte sequenzielle Schlüssel migrieren

Wenn Sie von einer Datenbank migrieren, in der sequenzielle monotone Schlüssel verwendet werden, z. B. AUTO_INCREMENT in MySQL, SERIAL in PostgreSQL oder der Standardtyp IDENTITY in SQL Server oder Oracle, sollten Sie die folgende allgemeine Migrationsstrategie in Betracht ziehen:

1. Replizieren Sie in Spanner die Tabellenstruktur aus Ihrer Quelldatenbank und verwenden Sie dabei einen primären Schlüssel vom Typ „Integer“.
2. Erstellen Sie für jede Spalte in Spanner, die sequenzielle Werte enthält, eine Sequenz und weisen Sie der Spalte die Funktion GET_NEXT_SEQUENCE_VALUE ( GoogleSQL, PostgreSQL) als Standardwert zu.
3. Migrieren Sie vorhandene Daten mit Originalschlüsseln aus der Quelldatenbank zu Spanner. Verwenden Sie das Spanner-Migrations-Tool oder eine Dataflow-Vorlage.
   1. Optional können Sie Fremdschlüsselbeschränkungen für alle abhängigen Tabellen festlegen.
4. Bevor Sie neue Daten einfügen, passen Sie die Spanner-Sequenz an, um den Bereich der vorhandenen Schlüsselwerte zu überspringen.
5. Fügen Sie neue Daten ein, damit die Sequenz automatisch eindeutige Schlüssel generieren kann.

Beispiel für einen Migrationsworkflow

Im folgenden Code werden die Tabellenstruktur und die zugehörige Sequenz in Spanner mit einem SEQUENCE-Objekt definiert und das Objekt als Standardprimärwert der Zieltabelle festgelegt:

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

Die Option bit_reversed_positive gibt an, dass die von der Sequenz generierten Werte vom Typ INT64 sind, größer als null sind und nicht sequenziell sind.

Wenn Sie vorhandene Zeilen aus Ihrer Quelldatenbank zu Spanner migrieren, bleiben die Primärschlüssel unverändert.

Bei neuen Einfügungen, für die kein Primärschlüssel angegeben ist, ruft Spanner automatisch einen neuen Wert ab, indem die Funktion GET_NEXT_SEQUENCE_VALUE(GoogleSQL oder PostgreSQL) aufgerufen wird.

Diese Werte sind gleichmäßig über den Bereich [1, 263] verteilt und es kann zu Kollisionen mit den vorhandenen Schlüsseln kommen. Um dies zu verhindern, können Sie die Sequenz mit ALTER_SEQUENCE (GoogleSQL oder PostgreSQL) so konfigurieren, dass der Bereich der Werte, die von den vorhandenen Schlüsseln abgedeckt werden, übersprungen wird.

Angenommen, die Tabelle singers wurde aus PostgreSQL migriert, wo ihr Primärschlüssel singer_id vom Typ SERIAL ist. Die folgende PostgreSQL-DDL zeigt die DDL Ihrer Quelldatenbank:

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

Die Primärschlüsselwerte steigen monoton an. Nach der Migration können Sie den Höchstwert des Primärschlüssels singer_id in Spanner abrufen. Verwenden Sie den folgenden Code in Spanner:

SELECT MAX(SingerId) FROM Singers;

SELECT MAX(SingerId) FROM Singers;

Angenommen,der zurückgegebene Wert ist 20.000. Sie können die Spanner-Sequenz so konfigurieren, dass der Bereich [1, 21000] übersprungen wird. Die zusätzlichen 1.000 dienen als Puffer für Schreibvorgänge in die Quelldatenbank nach der ersten Migration. Neue Schlüssel, die in Spanner generiert werden, stehen nicht im Konflikt mit dem Bereich der Primärschlüssel, die in der PostgreSQL-Quelldatenbank generiert werden. Verwenden Sie den folgenden Code in Spanner:

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

ALTER SEQUENCE SingerIdSequence SKIP RANGE 1 21000;

Spanner und Quelldatenbank verwenden

Sie können das Konzept des Überspringens von Bereichen verwenden, um Szenarien zu unterstützen, in denen entweder Spanner oder Ihre Quelldatenbank Primärschlüssel generiert, z. B. um die Replikation in beide Richtungen für die Notfallwiederherstellung während einer Migrationsumstellung zu ermöglichen.

Dazu werden in beiden Datenbanken Primärschlüssel generiert und die Daten werden zwischen ihnen synchronisiert. Sie können jede Datenbank so konfigurieren, dass Primärschlüssel in nicht überlappenden Schlüsselbereichen erstellt werden. Wenn Sie einen Bereich für Ihre Quelldatenbank definieren, können Sie die Spanner-Sequenz so konfigurieren, dass dieser Bereich übersprungen wird.

Nach der Migration der Anwendung für Musiktitel können Sie beispielsweise die Daten von PostgreSQL zu Spanner replizieren, um die Umstellungszeit zu verkürzen.

Nachdem Sie die Anwendung in Spanner aktualisiert und getestet haben, können Sie die Verwendung der PostgreSQL-Quelldatenbank einstellen und Spanner verwenden. Spanner wird dann zum System of Record für Aktualisierungen und neue Primärschlüssel. Wenn Spanner die Daten übernimmt, können Sie den Datenfluss zwischen den Datenbanken in die PostgreSQL-Instanz umkehren.

Angenommen, in Ihrer PostgreSQL-Quelldatenbank werden SERIAL-Primärschlüssel verwendet, die 32-Bit-Ganzzahlen mit Vorzeichen sind. Spanner-Primärschlüssel sind größere 64-Bit-Zahlen. Ändern Sie in PostgreSQL die Primärschlüsselspalte in eine 64-Bit-Spalte oder bigint. Verwenden Sie den folgenden Code in Ihrer PostgreSQL-Quelldatenbank:

ALTER TABLE Singers ALTER COLUMN SingerId TYPE bigint;

Sie können eine CHECK-Einschränkung für die Tabelle in der PostgreSQL-Quelldatenbank festlegen, um sicherzustellen, dass die Werte des Primärschlüssels SingerId immer kleiner oder gleich 231-1 sind.

Verwenden Sie den folgenden Code in Ihrer PostgreSQL-Quelldatenbank:

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

In Spanner können wir die Sequenz so ändern, dass der Bereich [1, 231-1] übersprungen wird.

Verwenden Sie den folgenden Code in Spanner:

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

ALTER SEQUENCE SingerIdSequence SKIP RANGE 1 2147483648;

In Ihrer PostgreSQL-Quelldatenbank werden immer Schlüssel im 32-Bit-Ganzzahlbereich generiert, während Spanner-Schlüssel auf den 64-Bit-Ganzzahlbereich beschränkt sind, der größer als alle 32-Bit-Ganzzahlwerte ist. So können beide Datenbanken unabhängig voneinander Primärschlüssel generieren, die nicht in Konflikt stehen.

UUID-Schlüsselspalten migrieren

UUIDv4-Schlüssel sind unabhängig davon, wo sie generiert werden, praktisch eindeutig. UUID-Schlüssel, die an anderer Stelle generiert wurden, lassen sich in neue UUID-Schlüssel einfügen, die in Spanner generiert wurden.

Berücksichtigen Sie die folgende allgemeine Strategie, um UUID-Schlüssel zu Spanner zu migrieren:

1. Definieren Sie Ihre UUID-Schlüssel in Spanner mit Stringspalten mit einem Standardausdruck. Verwenden Sie die GENERATE_UUID()-Funktion (GoogleSQL, PostgreSQL).
2. Exportieren Sie die Daten aus dem Quellsystem und serialisieren Sie die UUID-Schlüssel als Strings.
3. Importieren Sie die Primärschlüssel in Spanner.
4. Optional: Fremdschlüssel aktivieren.

Beispiel für einen Migrationsworkflow:

Definieren Sie in Spanner eine UUID-Primärschlüsselspalte als STRING- oder TEXT-Typ und weisen Sie ihr GENERATE_UUID() (GoogleSQL oder PostgreSQL) als Standardwert zu. Migrieren Sie alle Daten aus der Quelldatenbank zu Spanner. Nach der Migration ruft Spanner beim Einfügen neuer Zeilen GENERATE_UUID() auf, um neue UUID-Werte für die Primärschlüssel zu generieren. Der Primärschlüssel FanClubId erhält beispielsweise einen UUIDv4-Wert, wenn eine neue Zeile in die Tabelle FanClubs eingefügt wird. Verwenden Sie den folgenden Code in 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');

Eigene Primärschlüssel migrieren

Ihre Anwendung ist möglicherweise auf die Reihenfolge des Primärschlüssels angewiesen, um zu bestimmen, wie aktuell die Daten sind oder um neu erstellte Daten zu sequenzieren. Wenn Sie extern generierte sequenzielle Schlüssel in Spanner verwenden möchten, können Sie einen zusammengesetzten Schlüssel erstellen, der einen gleichmäßig verteilten Wert wie einen Hash als erste Komponente und Ihren sequenziellen Schlüssel als zweite Komponente kombiniert. So können Sie die sequenziellen Schlüsselwerte beibehalten, ohne Hotspots zu erstellen. Betrachten Sie den folgenden Migrationsworkflow:

Angenommen, Sie müssen eine MySQL-Tabelle students mit einem Primärschlüssel AUTO_INCREMENT zu Spanner migrieren. Verwenden Sie den folgenden Code in Ihrer MySQL-Quelldatenbank:

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

In Spanner können Sie eine generierte Spalte StudentIdHash hinzufügen, indem Sie einen Hash der Spalte StudentId erstellen. Beispiel:

StudentIdHash = FARM_FINGERPRINT(CAST(StudentId AS STRING))

Sie können den folgenden Code in Spanner verwenden:

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

Sequenzielle Schlüsselspalten migrieren

Wenn Ihr Quelldatenbanksystem sequenzielle Werte für eine Schlüsselspalte generiert, können Sie in Ihrem Spanner-Schema eine bitumgekehrte positive Sequenz (GoogleSQL, PostgreSQL) verwenden, um Werte zu generieren, die gleichmäßig über den positiven 64-Bit-Ganzzahlbereich verteilt sind. Um zu verhindern, dass die Spanner-Sequenz einen Wert generiert, der sich mit einem migrierten Wert überschneidet, können Sie einen übersprungenen Bereich dafür definieren.

Sie können beispielsweise den Bereich von 1 bis 4.294.967.296 (2^32) für die folgenden beiden Sequenzen überspringen, wenn Sie wissen, dass in der Quelldatenbank nur 32-Bit-Ganzzahlen generiert werden:

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;

Wenn Sie IDENTITY-Spalten verwenden, um automatisch Ganzzahlwerte für Ihre Schlüsselspalten zu generieren, können Sie Bereiche überspringen:

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;

Bit-reversed-Schlüsselspalten migrieren

Wenn Sie Ihre Schlüsselwerte bereits bitweise umgekehrt haben, um Hotspot-Probleme in Ihrer Quelldatenbank zu vermeiden, können Sie auch eine bitweise umgekehrte positive Sequenz in Spanner (GoogleSQL, PostgreSQL) verwenden, um solche Werte weiterhin zu generieren. Um doppelte Werte zu vermeiden, können Sie die Sequenz so konfigurieren, dass der Zähler mit einer benutzerdefinierten Zahl beginnt.

Wenn Sie beispielsweise die Zahlen von 1 bis 1.000 umgekehrt haben, um Primärschlüsselwerte zu generieren, kann die Spanner-Sequenz ihren Zähler mit einer beliebigen Zahl über 10.000 beginnen. Optional können Sie eine hohe Zahl auswählen, um einen Puffer für neue Schreibvorgänge zu schaffen, die nach der Datenmigration in der Quelldatenbank erfolgen. Im folgenden Beispiel beginnen die Zähler bei 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;

Wenn Sie IDENTITY-Spalten verwenden, um automatisch Ganzzahlwerte für Ihre Schlüsselspalten zu generieren, können Sie einen Startzähler festlegen:

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;

Nächste Schritte

• Übersicht über die Migration von Primärschlüsseln