Estadísticas de división

En este documento, se describe cómo detectar y depurar los puntos críticos de tu base de datos. Puedes acceder a estadísticas sobre los puntos calientes en las divisiones con GoogleSQL y PostgreSQL.

Spanner almacena tus datos como un espacio de claves contiguo, ordenado por las claves principales de tus tablas e índices. Una división es un rango de filas de un conjunto de tablas o un índice. El inicio de la división se denomina inicio de la división. El límite de división establece el final de la división. La división incluye el inicio de la división, pero no el límite de la división.

En Spanner, los hotspots son situaciones en las que se envían demasiadas solicitudes al mismo servidor, lo que satura los recursos del servidor y puede causar latencias altas. Las divisiones afectadas por los hotspots se conocen como divisiones activas o cálidas.

La estadística de hotspot de una división (identificada en el sistema como CPU_USAGE_SCORE) es una medición de la carga en una división que está restringida por los recursos disponibles en el servidor. Esta medición se expresa como un porcentaje. Si más del 50% de la carga en una división está restringida por los recursos disponibles, se considera que la división está activa. Si el 100% de la carga en una división está restringida, se considera que la división está activa. Estas divisiones activas también pueden afectar la latencia de las solicitudes que atienden.

El CPU_USAGE_SCORE de una división puede permanecer constante o variar con el tiempo según la carga de trabajo que accede a la división y los cambios en los límites de la división.

Según las restricciones de recursos de las divisiones activas y muy activas, es posible que Spanner use la división basada en la carga para distribuir de manera uniforme la carga en el espacio de claves. Las divisiones cálidas y calientes se pueden mover entre los servidores de la instancia para el balanceo de cargas. Spanner realiza la división basada en la carga en segundo plano, lo que minimiza el impacto en la latencia. Sin embargo, es posible que Spanner no pueda balancear la carga, incluso después de varios intentos de división, debido a antipatrones en la aplicación. La columna UNSPLITTABLE_REASONS en las vistas de estadísticas proporciona motivos específicos por los que una división activa o cálida no se pudo dividir más. Por lo tanto, es posible que las divisiones persistentes cálidas o calientes que duran al menos 10 minutos requieran una solución de problemas adicional y posibles cambios en la aplicación, en especial cuando hay UNSPLITTABLE_REASONS.

Las estadísticas de divisiones activas de Spanner te ayudan a identificar las divisiones en las que se producen hotspots y a comprender por qué pueden persistir. Estas estadísticas, combinadas con los códigos UNSPLITTABLE_REASONS, pueden ayudarte a diagnosticar qué acciones debes realizar para resolver los puntos críticos. Luego, puedes realizar los cambios necesarios en tu aplicación o esquema.

Cómo acceder a las estadísticas de división de canciones

Spanner proporciona las estadísticas de división activa en el esquema SPANNER_SYS. Los datos de SPANNER_SYS están disponibles a través de las interfaces de GoogleSQL y PostgreSQL. Puedes acceder a estos datos de las siguientes maneras:

La página de Spanner Studio de una base de datos en la consola de Google Cloud
El comando gcloud spanner databases execute-sql
El método executeSql o el método executeStreamingSql.

Los siguientes métodos de lectura única que proporciona Spanner no admiten SPANNER_SYS:

Realizar una lectura sólida desde una o varias filas de una tabla
Realizar una lectura inactiva desde una o varias filas en una tabla
Leer desde una o varias filas en un índice secundario

Estadísticas de divisiones con mayor actividad

Usa las siguientes vistas para hacer un seguimiento de las divisiones más populares:

SPANNER_SYS.SPLIT_STATS_TOP_MINUTE: Muestra los tramos que son populares durante intervalos de 1 minuto.
SPANNER_SYS.SPLIT_STATS_TOP_10MINUTE: Muestra los tramos que son populares durante cualquier parte de un intervalo de 10 minutos.
SPANNER_SYS.SPLIT_STATS_TOP_HOUR: Muestra los cortes que son populares durante cualquier parte de un intervalo de 1 hora.

Estas vistas tienen las siguientes propiedades:

Cada vista contiene datos de intervalos de tiempo no superpuestos de la duración que se especifica en el nombre de la vista.
Los intervalos se basan en tiempos de reloj:
- Los intervalos de 1 minuto finalizan en el minuto.
- Los intervalos de 10 minutos finalizan en el décimo minuto de la hora, por ejemplo, 11:10:00, 11:20:00.
- Los intervalos de 1 hora finalizan en la hora.
Después de cada intervalo, Spanner recopila datos de todos los servidores y, luego, los pone a disposición en las vistas de SPANNER_SYS poco después. Por ejemplo, a las 11:59:30 a.m., los intervalos más recientes disponibles para las consultas de SQL son los siguientes:
- 1 minuto: de 11:58:00 a.m. a 11:58:59 a.m.
- 10 minutos: de 11:40:00 a.m. a 11:49:59 a.m.
- 1 hora: 10:00:00 a.m. a 10:59:59 a.m.
Spanner agrupa las estadísticas por divisiones.
Cada fila contiene estadísticas, incluido el porcentaje de CPU_USAGE_SCORE, que indica qué tan caliente o tibia es una división, para cada división de la que Spanner captura estadísticas durante el intervalo especificado.
La vista SPANNER_SYS.SPLIT_STATS_TOP_MINUTE ofrece las estadísticas de división detalladas para cada minuto. Usa esta vista para depurar en detalle los eventos recientes.
Las vistas SPANNER_SYS.SPLIT_STATS_TOP_10MINUTE y SPANNER_SYS.SPLIT_STATS_TOP_HOUR proporcionan una vista agregada en intervalos de 10 minutos y de una hora, respectivamente. Usa estas vistas para analizar tendencias o investigar problemas de los últimos días o semanas. Para obtener más información sobre la agregación, consulta Cómo ver la agregación de eventos.
Si Spanner no puede almacenar todas las divisiones activas durante el intervalo, el sistema prioriza las divisiones con el porcentaje de CPU_USAGE_SCORE más alto durante el intervalo especificado. Si no se devuelven divisiones, es un indicador de la ausencia de divisiones activas.

Retención de datos

La cantidad máxima de datos que Spanner conserva para cada vista, en cualquier momento, es la siguiente:

SPANNER_SYS.SPLIT_STATS_TOP_MINUTE: Intervalos que abarcan las 24 horas anteriores.
SPANNER_SYS.SPLIT_STATS_TOP_10MINUTE: Intervalos que abarcan los 4 días anteriores.
SPANNER_SYS.SPLIT_STATS_TOP_HOUR: Intervalos que abarcan los 30 días anteriores.

Estos períodos de retención no se pueden aumentar ni disminuir, y no puedes evitar que Spanner recopile estadísticas de divisiones activas.

Para borrar los datos de estadísticas, debes borrar la base de datos que se está haciendo un seguimiento o esperar hasta que los datos de estadísticas se quiten de la retención.
Para conservar los datos de estadísticas durante períodos más largos, copia periódicamente los datos de las vistas de estadísticas de división activa.

Ver esquema

En la siguiente tabla, se muestra el esquema de las estadísticas de división activa:

Nombre de la columna	Tipo	Descripción
`INTERVAL_END`	`TIMESTAMP`	Es el final del intervalo de tiempo durante el cual la división estuvo activa o caliente.
`SPLIT_START`	`STRING`	Clave inicial del rango de filas en la división. El inicio de la división también puede ser <begin>, lo que indica el inicio del espacio de claves.
`SPLIT_LIMIT`	`STRING`	Es la clave de límite del rango de filas en la división. La clave de límite también puede ser <end>, lo que indica el final del espacio de claves.
`CPU_USAGE_SCORE`	`INT64`	Es el porcentaje de `CPU_USAGE_SCORE` de las divisiones. Un porcentaje de `CPU_USAGE_SCORE` del 50% indica la presencia de divisiones activas o muy activas.
`AFFECTED_TABLES`	`STRING ARRAY`	Son las tablas cuyas filas podrían estar en la división.
`UNSPLITTABLE_REASONS`	`STRING ARRAY`	Identifica el tipo de hotspots presentes que la división basada en la carga no puede mitigar, a menudo debido a antipatrones. La presencia de cualquier motivo indica que es probable que se necesite la intervención del usuario, como ajustes del esquema o de la carga de trabajo. Un array vacío significa que no se detectaron condiciones no divisibles durante este intervalo o que la carga alta fue demasiado breve para que Spanner determinara si era indivisible. Consulta los tipos de `UNSPLITTABLE_REASONS` para obtener más detalles.

Claves de inicio y límite de división

Una división es un rango de filas contiguas de una base de datos y se define por sus claves de inicio y límite. Una división puede ser una sola fila, un rango de filas estrecho o un rango de filas amplio, y puede incluir varias tablas o índices.

Las columnas SPLIT_START y SPLIT_LIMIT identifican las claves primarias de una división activa o inactiva.

Esquema de ejemplo

El siguiente esquema es una tabla de ejemplo para los temas de esta página.

GoogleSQL

CREATE TABLE Users (
  UserId INT64 NOT NULL,
  FirstName STRING(MAX),
  LastName STRING(MAX),
) PRIMARY KEY(UserId);

CREATE INDEX UsersByFirstName ON Users(FirstName DESC);

CREATE TABLE Threads (
  UserId INT64 NOT NULL,
  ThreadId INT64 NOT NULL,
  Starred BOOL,
) PRIMARY KEY(UserId, ThreadId),
  INTERLEAVE IN PARENT Users ON DELETE CASCADE;

CREATE TABLE Messages (
  UserId INT64 NOT NULL,
  ThreadId INT64 NOT NULL,
  MessageId INT64 NOT NULL,
  Subject STRING(MAX),
  Body STRING(MAX),
) PRIMARY KEY(UserId, ThreadId, MessageId),
  INTERLEAVE IN PARENT Threads ON DELETE CASCADE;

CREATE INDEX MessagesIdx ON Messages(UserId, ThreadId, Subject),
INTERLEAVE IN Threads;

PostgreSQL

CREATE TABLE users
(
   userid    BIGINT NOT NULL PRIMARY KEY,-- INT64 to BIGINT
   firstname VARCHAR(max),-- STRING(MAX) to VARCHAR(MAX)
   lastname  VARCHAR(max)
);

CREATE INDEX usersbyfirstname
  ON users(firstname DESC);

CREATE TABLE threads
  (
    userid   BIGINT NOT NULL,
    threadid BIGINT NOT NULL,
    starred  BOOLEAN, -- BOOL to BOOLEAN
    PRIMARY KEY (userid, threadid),
    CONSTRAINT fk_threads_user FOREIGN KEY (userid) REFERENCES users(userid) ON
    DELETE CASCADE -- Interleave to Foreign Key constraint
  );

CREATE TABLE messages
  (
    userid    BIGINT NOT NULL,
    threadid  BIGINT NOT NULL,
    messageid BIGINT NOT NULL PRIMARY KEY,
    subject   VARCHAR(max),
    body      VARCHAR(max),
    CONSTRAINT fk_messages_thread FOREIGN KEY (userid, threadid) REFERENCES
    threads(userid, threadid) ON DELETE CASCADE
  -- Interleave to Foreign Key constraint
  );

CREATE INDEX messagesidx ON messages(userid, threadid, subject), REFERENCES
threads(userid, threadid);

Imagina que tu espacio de claves se ve de la siguiente manera:

PRIMARY KEY
`<begin>`
`Users()`
`Threads()`
`Users(2)`
`Users(3)`
`Threads(3)`
`Threads(3,"a")`
`Messages(3,"a",1)`
`Messages(3,"a",2)`
`Threads(3, "aa")`
`Users(9)`
`Users(10)`
`Threads(10)`
`UsersByFirstName("abc")`
`UsersByFirstName("abcd")`
`<end>`

Ejemplo de divisiones

A continuación, se muestran algunos ejemplos de divisiones para ayudarte a comprender cómo se ven.

SPLIT_START y SPLIT_LIMIT pueden indicar la fila de una tabla o un índice, o bien pueden ser <begin> y <end>, que representan los límites del espacio de claves de la base de datos. SPLIT_START y SPLIT_LIMIT también pueden contener claves truncadas, que son claves que preceden a cualquier clave completa en la tabla. Por ejemplo, Threads(10) es un prefijo para cualquier fila Threads intercalada en Users(10).

SPLIT_START	SPLIT_LIMIT	AFFECTED_TABLES	EXPLICACIÓN
`Users(3)`	`Users(10)`	`UsersByFirstName`, `Users`, `Threads`, `Messages`, `MessagesIdx`	La división comienza en la fila con `UserId=3` y termina en la fila anterior a la fila con `UserId = 10`. La división contiene las filas de la tabla `Users` y todas las filas de sus tablas intercaladas para `UserId=3` de 1 a 10.
`Messages(3,"a",1)`	`Threads(3,"aa")`	`Threads`, `Messages`, `MessagesIdx`	La división comienza en la fila con `UserId=3`, `ThreadId="a"` y `MessageId=1`, y termina en la fila anterior a la fila con la clave de `UserId=3` y `ThreadsId = "aa"`. La división contiene todas las tablas entre `Messages(3,"a",1)` y `Threads(3,"aa")`. Como `split_start` y `split_limit` están intercalados en la misma fila de la tabla de nivel superior, la división contiene las filas de las tablas intercaladas entre el inicio y el límite. Consulta schemas-overview para comprender cómo se ubican las tablas intercaladas.
`Messages(3,"a",1)`	`<end>`	`UsersByFirstName`, `Users`, `Threads`, `Messages`, `MessagesIdx`	La división comienza en la tabla de mensajes en la fila con la clave `UserId=3`, `ThreadId="a"` y `MessageId=1`. La división aloja todas las filas desde `split_start` hasta `<end>`, el final del espacio de claves de la base de datos. Todas las filas de las tablas que siguen a `split_start`, como `Users(4)`, se incluyen en la división.
`<begin>`	`Users(9)`	`UsersByFirstName`, `Users`, `Threads`, `Messages`, `MessagesIdx`	La división comienza en `<begin>`, el inicio del espacio de claves de la base de datos, y termina en la fila anterior a la fila `Users` con `UserId=9`. Por lo tanto, la división tiene todas las filas de la tabla que preceden a `Users` y todas las filas de la tabla `Users` que preceden a `UserId=9` y las filas de sus tablas intercaladas.
`Messages(3,"a",1)`	`Threads(10)`	`UsersByFirstName`, `Users`, `Threads`, `Messages`, `MessagesIdx`	La división comienza en `Messages(3,"a", 1)` intercalada en `Users(3)` y termina en la fila anterior a `Threads(10)`. `Threads(10)` es una clave de división truncada que es un prefijo de cualquier clave de la tabla de hilos intercalada en `Users(10)`.
`Users()`	`<end>`	`UsersByFirstName`, `Users`, `Threads`, `Messages`, `MessagesIdx`	La división comienza en la clave de división truncada de `Users()`, que precede a cualquier clave completa de la tabla `Users`. La división se extiende hasta el final del espacio de claves posible en la base de datos. Por lo tanto, affected_tables abarca la tabla `Users`, sus tablas y sus índices intercalados, y todas las tablas que podrían aparecer después de los usuarios.
`Threads(10)`	`UsersByFirstName("abc")`	`UsersByFirstName`, `Users`, `Threads`, `Messages`, `MessagesIdx`	La división comienza en la fila `Threads` con `UserId = 10` y termina en el índice `UsersByFirstName` en la clave que precede a `"abc"`.

`UNSPLITTABLE_REASONS` tipos

Cuando Spanner no puede mitigar un punto de acceso a través de la división basada en la carga, la columna UNSPLITTABLE_REASONS en las vistas de SPLIT_STATS_TOP_* cita uno o más de los siguientes motivos:

`HOT_ROW`

Descripción: La carga alta se concentra en una sola fila. Spanner no puede agregar puntos de división dentro de una fila individual.

Causas comunes:

Operaciones frecuentes de gran volumen (lecturas, escrituras o actualizaciones) en una sola clave
Diseños de esquemas que centralizan el acceso a una sola fila.