Crear y gestionar puntos de división

En esta página se describe cómo crear y gestionar puntos de división en tu base de datos. Puedes crear puntos de división para dividir previamente tu base de datos y prepararte para un aumento previsto del tráfico. Para obtener más información sobre la división previa, consulta el artículo Introducción a la división previa.

Antes de empezar

Crear puntos de división

Puedes crear puntos de división con Google Cloud CLI o las APIs REST.

gcloud

Si quieres crear puntos de división con la CLI de Google Cloud, debes crear un archivo que contenga todas las divisiones y proporcionar la ruta en el comando de la CLI de gcloud. El archivo no debe superar el límite de la API de 100 puntos por solicitud de API. Para obtener más información, consulta Cuotas y límites.

El archivo debe usar el siguiente formato para especificar los puntos de división:

  ObjectType ObjectName (SplitValue1)
  ObjectType ObjectName (SplitValue2)
  ObjectType ObjectName (SplitValueN)

Sustituye las siguientes variables al crear el archivo:

  • ObjectType: el tipo de objeto en el que quieres añadir divisiones. Los valores válidos son TABLE y INDEX.
  • ObjectName: el nombre de la tabla o el índice de la base de datos.
  • SplitValue1..N: los valores de los puntos de división en los que quieras introducir las divisiones.

Siga estas reglas al crear los valores de punto de división en el archivo:

  • Los valores de cadena deben ir entre comillas simples. Por ejemplo, 'splitKeyPart'
  • Los valores booleanos deben ser true o false.
  • Los valores de los tipos de datos INT64 y NUMERIC de Spanner deben ir entre comillas simples. Por ejemplo, '123' o '99.99'.
  • El resto de los valores numéricos deben escribirse sin comillas simples. Por ejemplo, 1.287.
  • Los valores de marca de tiempo deben proporcionarse en el '2020-06-18T17:24:53Z' formato entre comillas simples.
  • Los valores divididos deben estar entre paréntesis.
  • El orden de los valores de las claves de división debe ser el mismo que el de las claves principales.
  • Si el valor de división debe incluir una coma, debes usar el carácter `\` para escapar la coma.
  • Para dividir índices, puede proporcionar la clave de índice o el índice completo y la clave de tabla completa.
  • Siempre debes usar la clave completa al especificar el punto de división.

A continuación, se muestra un archivo de ejemplo que indica cómo se especifican los puntos de división:

  TABLE Singers ('c32ca57a-786c-2268-09d4-95182a9930be')
  TABLE Singers ('bb98c7e2-8240-b780-346d-c5d63886594a')
  INDEX Order ('5b8bac71-0cb2-95e9-e1b0-89a027525460')
  TABLE Payment ('6cf41f21-2d77-318f-c504-816f0068db8b')
  INDEX Indx_A (2152120141932780000)
  TABLE TableD  (0,'7ef9d̦b22-d0e5-6041-8937-4bc6a7ef9db2')
  INDEX IndexXYZ ('8762203435012030000',NULL,NULL)
  INDEX IndexABC  (0, '2020-06-18T17:24:53Z', '2020-06-18T17:24:53Z') TableKey
  (123,'ab\,c')

Antes de usar los datos de los comandos que se indican a continuación, haz los siguientes cambios:

  • SPLITS_FILE: la ruta al archivo de divisiones.
  • INSTANCE_ID: el ID de instancia.
  • DATABASE_ID: el ID de la base de datos.
  • EXPIRATION_DATE: (opcional) la fecha de vencimiento de los puntos divididos. Acepta una marca de tiempo en formato '2020-06-18T17:24:53Z'.
  • INITIATOR: (opcional) el iniciador de los puntos de división.

Ejecuta el siguiente comando:

Linux, macOS o Cloud Shell

gcloud spanner databases splits add DATABASE_ID \
--splits-file=SPLITS_FILE \
--instance=INSTANCE_ID \
--split-expiration-date=EXPIRATION_DATE \
--initiator=INITIATOR

Windows (PowerShell)

gcloud spanner databases splits add DATABASE_ID `
--splits-file=SPLITS_FILE `
--instance=INSTANCE_ID `
--split-expiration-date=EXPIRATION_DATE `
--initiator=INITIATOR

Windows (cmd.exe)

gcloud spanner databases splits add DATABASE_ID ^
--splits-file=SPLITS_FILE ^
--instance=INSTANCE_ID ^
--split-expiration-date=EXPIRATION_DATE ^
--initiator=INITIATOR

REST v1

Puedes usar el método projects.instances.databases.addSplitPoints para crear puntos de división.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

  • PROJECT_ID: el ID del proyecto.
  • INSTANCE_ID: el ID de instancia.
  • DATABASE_ID: el ID de la base de datos.

Método HTTP y URL: 

POST https://spanner.googleapis.com/v1/projects//instances//databases/:addSplitPoints

Cuerpo JSON de la solicitud: 

{
  "split_points": [
    {
      "table": "T1",
      "index": "T1_IDX",
      "expire_time": "2023-04-22T10:00:20.021Z",
      "keys": [
        {
          "key_parts": {
            "values": [
              3
            ]
          }
        },
        {
          "key_parts": {
            "values": [
              10
            ]
          }
        }
      ]
    },
    {
      "table": "T2",
      "expire_time": "2023-04-22T10:00:20.021Z",
      "keys": [
        {
          "key_parts": {
            "values": [
              50
            ]
          }
        }
      ]
    }
  ]
}

Para enviar tu solicitud, despliega una de estas opciones:

Deberías recibir un código de estado que indique que la operación se ha realizado correctamente (2xx) y una respuesta vacía.

Bibliotecas de cliente

Go


import (
	"context"
	"fmt"
	"io"
	"time"

	database "cloud.google.com/go/spanner/admin/database/apiv1"
	"cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
	adminpb "cloud.google.com/go/spanner/admin/database/apiv1/databasepb"
	"google.golang.org/protobuf/types/known/structpb"
	"google.golang.org/protobuf/types/known/timestamppb"
)

// Adds split points to table and index
// AddSplitPoins API - https://pkg.go.dev/cloud.google.com/go/spanner/admin/database/apiv1#DatabaseAdminClient.AddSplitPoints
func addSplitpoints(w io.Writer, dbName string) error {
	ctx := context.Background()

	dbAdminClient, err := database.NewDatabaseAdminClient(ctx)
	if err != nil {
		return err
	}
	defer dbAdminClient.Close()

	// Database is assumed to exist - https://cloud.google.com/spanner/docs/getting-started/go#create_a_database
	// Singers table is assumed to be present
	ddl := []string{
		"CREATE INDEX IF NOT EXISTS SingersByFirstLastName ON Singers(FirstName, LastName)",
	}
	op, err := dbAdminClient.UpdateDatabaseDdl(ctx, &adminpb.UpdateDatabaseDdlRequest{
		Database:   dbName,
		Statements: ddl,
	})

	if err != nil {
		return fmt.Errorf("addSplitPoints: waiting for UpdateDatabaseDdlRequest failed: %w", err)
	}

	// Wait for the UpdateDatabaseDdl operation to finish.
	if err := op.Wait(ctx); err != nil {
		return fmt.Errorf("addSplitPoints: waiting for UpdateDatabaseDdlRequest to finish failed: %w", err)
	}
	fmt.Fprintf(w, "Added indexes for Split testing\n")

	splitTableKey := databasepb.SplitPoints_Key{
		KeyParts: &structpb.ListValue{
			Values: []*structpb.Value{
				structpb.NewStringValue("42"),
			},
		},
	}

	splitForTable := databasepb.SplitPoints{
		Table: "Singers",
		Keys:  []*databasepb.SplitPoints_Key{&splitTableKey},
	}

	splitIndexKey := databasepb.SplitPoints_Key{
		KeyParts: &structpb.ListValue{
			Values: []*structpb.Value{
				structpb.NewStringValue("John"),
				structpb.NewStringValue("Doe"),
			},
		},
	}

	splitForindex := databasepb.SplitPoints{
		Index: "SingersByFirstLastName",
		Keys:  []*databasepb.SplitPoints_Key{&splitIndexKey},
	}

	splitIndexKeyWithTableKeyPart := databasepb.SplitPoints_Key{
		KeyParts: &structpb.ListValue{
			Values: []*structpb.Value{
				structpb.NewStringValue("38"),
			},
		},
	}

	splitIndexKeyWithIndexKeyPart := databasepb.SplitPoints_Key{
		KeyParts: &structpb.ListValue{
			Values: []*structpb.Value{
				structpb.NewStringValue("Jane"),
				structpb.NewStringValue("Doe"),
			},
		},
	}

	// the index key part is first and table keypart is second in the split definition
	splitForindexWithTableKey := databasepb.SplitPoints{
		Index: "SingersByFirstLastName",
		Keys:  []*databasepb.SplitPoints_Key{&splitIndexKeyWithIndexKeyPart, &splitIndexKeyWithTableKeyPart},
	}

	splitTableKeyWithExpire := databasepb.SplitPoints_Key{
		KeyParts: &structpb.ListValue{
			Values: []*structpb.Value{
				structpb.NewStringValue("30"),
			},
		},
	}

	splitForTableWithExpire := databasepb.SplitPoints{
		Table: "Singers",
		Keys:  []*databasepb.SplitPoints_Key{&splitTableKeyWithExpire},
		// A timestamp in the past means immediate expiration.
		// The maximum value can be 30 days in the future.
		// Defaults to 10 days in the future if not specified.
		//
		// Setting the expiration time to next day
		ExpireTime: timestamppb.New(time.Now().Add(24 * time.Hour)),
	}

	// Add split points to table and index
	req := databasepb.AddSplitPointsRequest{
		Database:    dbName,
		SplitPoints: []*databasepb.SplitPoints{&splitForTable, &splitForindex, &splitForindexWithTableKey, &splitForTableWithExpire},
	}

	res, err := dbAdminClient.AddSplitPoints(ctx, &req)
	if err != nil {
		return fmt.Errorf("addSplitpoints: failed to add split points: %w", err)
	}

	fmt.Fprintf(w, "Added split points %s", res)
	return nil
}

Java


import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerException;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.admin.database.v1.DatabaseAdminClient;
import com.google.protobuf.ListValue;
import com.google.protobuf.Value;
import com.google.spanner.admin.database.v1.DatabaseName;
import com.google.spanner.admin.database.v1.SplitPoints;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class DatabaseAddSplitPointsSample {

  /***
   * Assume DDL for the underlying database:
   * <pre>{@code
   * CREATE TABLE Singers (
   * SingerId INT64 NOT NULL,
   * FirstName STRING(1024),
   * LastName STRING(1024),
   *  SingerInfo BYTES(MAX),
   * ) PRIMARY KEY(SingerId);
   *
   *
   * CREATE INDEX SingersByFirstLastName ON Singers(FirstName, LastName);
   * }</pre>
   */

  static void addSplitPoints() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "my-project";
    String instanceId = "my-instance";
    String databaseId = "my-database";
    addSplitPoints(projectId, instanceId, databaseId);
  }

  static void addSplitPoints(String projectId, String instanceId, String databaseId)
      throws IOException {
    try (Spanner spanner =
            SpannerOptions.newBuilder().setProjectId(projectId).build().getService();
        DatabaseAdminClient databaseAdminClient = spanner.createDatabaseAdminClient()) {
      List<com.google.spanner.admin.database.v1.SplitPoints> splitPoints = new ArrayList<>();

      // table key
      com.google.spanner.admin.database.v1.SplitPoints splitPointForTable =
          SplitPoints.newBuilder()
              .setTable("Singers")
              .addKeys(
                  com.google.spanner.admin.database.v1.SplitPoints.Key.newBuilder()
                      .setKeyParts(
                          ListValue.newBuilder()
                              .addValues(Value.newBuilder().setStringValue("42").build())
                              .build()))
              .build();

      // index key without table key part
      com.google.spanner.admin.database.v1.SplitPoints splitPointForIndex =
          SplitPoints.newBuilder()
              .setIndex("SingersByFirstLastName")
              .addKeys(
                  com.google.spanner.admin.database.v1.SplitPoints.Key.newBuilder()
                      .setKeyParts(
                          ListValue.newBuilder()
                              .addValues(Value.newBuilder().setStringValue("John").build())
                              .addValues(Value.newBuilder().setStringValue("Doe").build())
                              .build()))
              .build();

      // index key with table key part, first key is the index key and second is the table key
      com.google.spanner.admin.database.v1.SplitPoints splitPointForIndexWitTableKey =
          SplitPoints.newBuilder()
              .setIndex("SingersByFirstLastName")
              .addKeys(
                  com.google.spanner.admin.database.v1.SplitPoints.Key.newBuilder()
                      .setKeyParts(
                          ListValue.newBuilder()
                              .addValues(Value.newBuilder().setStringValue("Jane").build())
                              .addValues(Value.newBuilder().setStringValue("Doe").build())
                              .build()))
              .addKeys(
                  com.google.spanner.admin.database.v1.SplitPoints.Key.newBuilder()
                      .setKeyParts(
                          ListValue.newBuilder()
                              .addValues(Value.newBuilder().setStringValue("38").build())
                              .build()))
              .build();

      splitPoints.add(splitPointForTable);
      splitPoints.add(splitPointForIndex);
      splitPoints.add(splitPointForIndexWitTableKey);
      databaseAdminClient.addSplitPoints(
          DatabaseName.of(projectId, instanceId, databaseId), splitPoints);

    } catch (Exception e) {
      // If the operation failed during execution, expose the cause.
      throw (SpannerException) e.getCause();
    }
  }
}

Node.js

// Import the Google Cloud client library for Spanner.
const {Spanner} = require('@google-cloud/spanner');

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'my-project-id';
// const instanceId = 'my-instance-id';
// const databaseId = 'my-database-id';

// Create a Spanner database admin client.
const spanner = new Spanner({projectId});
const databaseAdminClient = spanner.getDatabaseAdminClient();

try {
  // Add split points to table and index
  // first is a table level split that takes table primary key value
  // second is index level split with index key parts
  // third is index level split having index key part and table key part
  // Assume the following table and index structure
  // CREATE TABLE Singers (
  // SingerId INT64 NOT NULL,
  // FirstName STRING(1024),
  // LastName STRING(1024),
  // SingerInfo BYTES(MAX),
  // ) PRIMARY KEY(SingerId);
  //
  // CREATE INDEX SingersByFirstLastName ON Singers(FirstName, LastName);
  const request = [
    'CREATE INDEX IF NOT EXISTS SingersByFirstLastName ON Singers(FirstName, LastName)',
  ];

  const [operation] = await databaseAdminClient.updateDatabaseDdl({
    database: databaseAdminClient.databasePath(
      projectId,
      instanceId,
      databaseId,
    ),
    statements: request,
  });

  console.log('Waiting for operation to complete...');
  await operation.promise();

  console.log('Added the SingersByFirstLastName index.');

  databaseAdminClient.addSplitPoints({
    database: databaseAdminClient.databasePath(
      projectId,
      instanceId,
      databaseId,
    ),
    splitPoints: [
      {
        table: 'Singers',
        keys: [{keyParts: {values: [{stringValue: '42'}]}}],
      },
      {
        index: 'SingersByFirstLastName',
        keys: [
          {
            keyParts: {
              values: [{stringValue: 'John'}, {stringValue: 'Doe'}],
            },
          },
        ],
      },
      {
        index: 'SingersByFirstLastName',
        keys: [
          {
            keyParts: {
              values: [{stringValue: 'Jane'}, {stringValue: 'Doe'}],
            },
          },
          {keyParts: {values: [{stringValue: '38'}]}},
        ],
      },
    ],
  });
  console.log('Added Split Points');
} catch (err) {
  console.error('ERROR:', err);
}

Python

def add_split_points(instance_id, database_id):
    """Adds split points to table and index."""

    from google.cloud.spanner_admin_database_v1.types import spanner_database_admin

    spanner_client = spanner.Client()
    database_admin_api = spanner_client.database_admin_api

    request = spanner_database_admin.UpdateDatabaseDdlRequest(
        database=database_admin_api.database_path(
            spanner_client.project, instance_id, database_id
        ),
        statements=["CREATE INDEX IF NOT EXISTS SingersByFirstLastName ON Singers(FirstName, LastName)"],
    )

    operation = database_admin_api.update_database_ddl(request)

    print("Waiting for operation to complete...")
    operation.result(OPERATION_TIMEOUT_SECONDS)

    print("Added the SingersByFirstLastName index.")

    addSplitPointRequest = spanner_database_admin.AddSplitPointsRequest(
        database=database_admin_api.database_path(
            spanner_client.project, instance_id, database_id
        ),
        # Table split
        # Index split without table key part
        # Index split with table key part: first key is the index key and second the table key
        split_points=[
            spanner_database_admin.SplitPoints(
                table="Singers",
                keys=[
                    spanner_database_admin.SplitPoints.Key(
                        key_parts=struct_pb2.ListValue(
                            values=[struct_pb2.Value(string_value="42")]
                        )
                    )
                ],
            ),
            spanner_database_admin.SplitPoints(
                index="SingersByFirstLastName",
                keys=[
                    spanner_database_admin.SplitPoints.Key(
                        key_parts=struct_pb2.ListValue(
                            values=[
                                struct_pb2.Value(string_value="John"),
                                struct_pb2.Value(string_value="Doe"),
                            ]
                        )
                    )
                ],
            ),
            spanner_database_admin.SplitPoints(
                index="SingersByFirstLastName",
                keys=[
                    spanner_database_admin.SplitPoints.Key(
                        key_parts=struct_pb2.ListValue(
                            values=[
                                struct_pb2.Value(string_value="Jane"),
                                struct_pb2.Value(string_value="Doe"),
                            ]
                        )
                    ),
                    spanner_database_admin.SplitPoints.Key(
                        key_parts=struct_pb2.ListValue(
                            values=[struct_pb2.Value(string_value="38")]
                        )
                    ),

                ],
            ),
        ],
    )

    operation = database_admin_api.add_split_points(addSplitPointRequest)

    print("Added split points.")

Posibles situaciones de error

En los siguientes casos, se puede producir un error al crear puntos de división:

  • La división de nivel de índice tiene un nombre de tabla incorrecto en la entrada.
  • El punto de división del nivel de la tabla tiene más de una clave.
  • El punto de división del nivel de índice tiene más de dos claves.
  • Los puntos de división se definen en tablas o índices que no están definidos en el esquema de la base de datos.
  • La solicitud contiene puntos de división duplicados.

Para obtener información sobre las cuotas y los límites, consulta Cuotas y límites.

Ver puntos divididos

Puedes ver todos los puntos de división creados en tu base de datos con laGoogle Cloud consola o la CLI de gcloud:

Consola

Para obtener el recuento de puntos de división consultando la vista SPANNER_SYS.USER_SPLIT_POINTS de la consola, Google Cloud haz lo siguiente:

  1. Abre la página Instancias de Spanner.

    Ir a instancias de Spanner

  2. Selecciona los nombres de la instancia de Spanner y de la base de datos que quieras consultar.

  3. En el panel de navegación de la izquierda, haga clic en Spanner Studio.

  4. Escribe la siguiente consulta en el campo de texto:

        SELECT * FROM SPANNER_SYS.USER_SPLIT_POINTS

  5. Haz clic en Realizar una consulta.

Aparecerá un resultado similar al siguiente:

TABLE_NAME INDEX_NAME INITIATOR SPLIT_KEY EXPIRE_TIME
B CloudAddSplitPointsAPI T(90,153,4,2024-04-30T17:00:00-07:00,1,2024-05-01,a) 2025-03-06T09:58:58.007201Z
B T_IDX CloudAddSplitPointsAPI Índice: T_IDX en T, clave de índice: (10), clave de tabla principal: (<begin>,<begin>,<begin>,<begin>,<begin>,<begin>,<begin>) 2025-03-08T07:33:23.861682Z
B T_IDX CloudAddSplitPointsAPI Índice: T_IDX en T, clave de índice: (9091), clave de tabla principal: (4567,123,4.2,2024-04-30T17:00:00-07:00,1,2024-05-01,a) 2025-03-08T07:35:25.990007Z

gcloud

Ejecuta el siguiente comando de la CLI de gcloud para ver los puntos de división de tu base de datos:

  gcloud spanner databases splits list DATABASE_ID \
  --instance INSTANCE_ID

Sustituye las siguientes variables al ejecutar este comando:

  • INSTANCE_ID: el ID de la instancia de Spanner.
  • DATABASE_ID: el ID de la base de datos de Spanner.

Aparecerá una respuesta similar a la siguiente:

  TABLE_NAME: T
  INDEX_NAME:
  INITIATOR: CloudAddSplitPointsAPI
  SPLIT_KEY: T(90,153,4,2024-04-30T17:00:00-07:00,1,2024-05-01,a)
  EXPIRE_TIME: 2025-03-06T09:58:58.007201Z

  TABLE_NAME: T
  INDEX_NAME: T_IDX
  INITIATOR: CloudAddSplitPointsAPI
  SPLIT_KEY: Index: T_IDX on T, Index Key: (10), Primary Table Key: (<begin>,<begin>,<begin>,<begin>,<begin>,<begin>,<begin>)
  EXPIRE_TIME: 2025-03-08T07:33:23.861682Z

  TABLE_NAME: T
  INDEX_NAME: T_IDX
  INITIATOR: CloudAddSplitPointsAPI
  SPLIT_KEY: Index: T_IDX on T, Index Key: (9091), Primary Table Key: (4567,123,4.2,2024-04-30T17:00:00-07:00,1,2024-05-01,a)
  EXPIRE_TIME: 2025-03-08T07:35:25.990007Z

Cómo caducar un punto de división

Puedes definir un tiempo de vencimiento para cada punto de división que crees. Para obtener más información, consulta Vencimiento de los puntos de división. Puedes hacer que los puntos de división caduquen mediante la CLI de Google Cloud o las APIs REST.

gcloud

Si quieres que los puntos de división caduquen con la CLI de Google Cloud, debes crear un archivo que contenga todas las divisiones que quieras que caduquen y proporcionar su ruta mediante el parámetro splits-file en el comando de la CLI de gcloud. El archivo no debe superar el límite de la API de 100 puntos por solicitud de API. Para obtener más información, consulta Cuotas y límites.

El archivo debe usar el siguiente formato para especificar los puntos de división:

  ObjectType ObjectName (SplitValue)
  ObjectType ObjectName (SplitValue)
  ObjectType ObjectName (SplitValue)

Sustituye las siguientes variables al crear el archivo:

  • ObjectType: el tipo de objeto de la división que quieres que caduque. Los valores válidos son TABLE y INDEX.
  • ObjectName: el nombre de la tabla o el índice de la base de datos.
  • SplitValue: el valor del punto de división que quieres que caduque.

Siga estas reglas al crear los valores de punto de división en el archivo:

  • Los valores de cadena deben ir entre comillas simples. Por ejemplo, 'splitKeyPart'
  • Los valores booleanos pueden ser true o false.
  • Los valores de los tipos de datos INT64 y NUMERIC de Spanner deben ir entre comillas simples. Por ejemplo, '123' o '99.99'.
  • El resto de los valores numéricos deben escribirse sin comillas simples. Por ejemplo, 1.287.
  • Los valores de marca de tiempo deben proporcionarse en el '2020-06-18T17:24:53Z' formato entre comillas simples.
  • Los valores divididos deben estar entre paréntesis.
  • El orden de los valores de las claves de división debe ser el mismo que el de las claves principales.
  • Si el valor de división debe incluir una coma, debes usar el carácter `\` para escapar la coma.
  • Para dividir índices, puede proporcionar la clave de índice o el índice completo y la clave de tabla completa.
  • Siempre debes usar la clave completa al especificar el punto de división.

A continuación, se muestra un archivo de ejemplo que indica cómo se especifican los puntos de división:

  TABLE Singers ('c32ca57a-786c-2268-09d4-95182a9930be')
  TABLE Singers ('bb98c7e2-8240-b780-346d-c5d63886594a')
  INDEX Order ('5b8bac71-0cb2-95e9-e1b0-89a027525460')
  TABLE Payment ('6cf41f21-2d77-318f-c504-816f0068db8b')
  INDEX Indx_A (2152120141932780000)
  TABLE TableD  (0,'7ef9db22-d0e5-6041-8937-4bc6a7ef9db2')
  INDEX IndexXYZ ('8762203435012030000',NULL,NULL)
  INDEX IndexABC  (0, '2020-06-18T17:24:53Z', '2020-06-18T17:24:53Z') TableKey
  (123,'ab\,c')

Antes de usar los datos de los comandos que se indican a continuación, haz los siguientes cambios:

  • SPLITS_FILE: la ruta al archivo de divisiones.
  • INSTANCE_ID: el ID de instancia.
  • DATABASE_ID: el ID de la base de datos.
  • EXPIRATION_DATE: (opcional) la fecha de vencimiento de los puntos divididos. Acepta una marca de tiempo en formato '2020-06-18T17:24:53Z'.
  • INITIATOR: (opcional) el iniciador de los puntos de división.

Ejecuta el siguiente comando:

Linux, macOS o Cloud Shell

gcloud spanner databases splits add DATABASE_ID \
--splits-file=SPLITS_FILE \
--instance=INSTANCE_ID \
--split-expiration-date=EXPIRATION_DATE \
--initiator=INITIATOR

Windows (PowerShell)

gcloud spanner databases splits add DATABASE_ID `
--splits-file=SPLITS_FILE `
--instance=INSTANCE_ID `
--split-expiration-date=EXPIRATION_DATE `
--initiator=INITIATOR

Windows (cmd.exe)

gcloud spanner databases splits add DATABASE_ID ^
--splits-file=SPLITS_FILE ^
--instance=INSTANCE_ID ^
--split-expiration-date=EXPIRATION_DATE ^
--initiator=INITIATOR

REST v1

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

  • PROJECT_ID: el ID del proyecto.
  • INSTANCE_ID: el ID de instancia.
  • DATABASE_ID: el ID de la base de datos.

Método HTTP y URL: 

POST https://spanner.googleapis.com/v1/projects//instances//databases/:addSplitPoints

Cuerpo JSON de la solicitud: 

{
  "split_points": [
    {
      "table": "T1",
      "index": "T1_IDX",
      "expire_time": "2023-04-22T10:00:20.021Z",
      "keys": [
        {
          "key_parts": {
            "values": [
              3
            ]
          }
        },
        {
          "key_parts": {
            "values": [
              10
            ]
          }
        }
      ]
    },
    {
      "table": "T2",
      "expire_time": "2023-04-22T10:00:20.021Z",
      "keys": [
        {
          "key_parts": {
            "values": [
              50
            ]
          }
        }
      ]
    }
  ]
}

Para enviar tu solicitud, despliega una de estas opciones:

Deberías recibir un código de estado que indique que la operación se ha realizado correctamente (2xx) y una respuesta vacía.

Siguientes pasos