En este documento, se describe cómo usar las tablas integradas de estadísticas de bloqueo de Spanner
para identificar las claves de fila y las columnas de tabla que causaron conflictos de bloqueo de transacciones
en tu base de datos durante un período específico. Puedes recuperar
estadísticas de estas tablas de SPANNER_SYS.LOCK_STATS* con sentencias de SQL.
Las transacciones que usan el control de simultaneidad optimista no adquieren bloqueos mientras ejecutan lecturas y consultas. En cambio, adquieren bloqueos en el momento de la confirmación, por lo que las estadísticas de bloqueo de estas transacciones solo incluyen los conflictos que se producen durante la confirmación.
Accede a las estadísticas de bloqueo
Spanner proporciona las estadísticas de bloqueo en el esquema SPANNER_SYS.
Puedes usar las siguientes formas para acceder a los datos de SPANNER_SYS:
La página de Spanner Studio de una base de datos en la consola de Google Cloud
El comando
gcloud spanner databases execute-sqlEl panel Estadísticas de bloqueo.
El método
executeSqloexecuteStreamingSqlLos 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 bloqueo por clave de fila
En las siguientes tablas, se hace un seguimiento de la clave de fila con el tiempo de espera más alto:
SPANNER_SYS.LOCK_STATS_TOP_MINUTE: Son las claves de fila con los tiempos de espera de bloqueo más altos durante intervalos de 1 minuto.SPANNER_SYS.LOCK_STATS_TOP_10MINUTE: Son las claves de fila con los tiempos de espera de bloqueo más altos durante intervalos de 10 minutos.SPANNER_SYS.LOCK_STATS_TOP_HOUR: Claves de fila con los tiempos de espera de bloqueo más altos durante intervalos de 1 hora
Estas tablas tienen las siguientes propiedades:
Cada tabla contiene datos de intervalos de tiempo que no se superponen y que tienen la duración que especifica el nombre de la tabla.
Los intervalos se basan en tiempos de reloj. Los intervalos de 1 minuto finalizan en el minuto, los intervalos de 10 minutos finalizan cada 10 minutos a partir de la hora y 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 tablas 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 11:58:59 a.m.
- 10 minutos: de 11:40:00 a 11:49:59 a.m.
- 1 hora: de 10:00:00 a 10:59:59 a.m.
Spanner agrupa las estadísticas por rango de clave de fila inicial.
Cada fila contiene estadísticas sobre los tiempos de espera de bloqueo totales de un rango de clave de fila inicial en particular para el que Spanner captura estadísticas durante el intervalo especificado.
Si Spanner no puede almacenar información sobre cada rango de clave de fila para las esperas de bloqueo durante el intervalo, el sistema prioriza el rango de clave de fila con el tiempo de espera de bloqueo más alto durante el intervalo especificado.
Todas las columnas de las tablas admiten valores nulos.
Esquema de la tabla
| Nombre de la columna | Tipo | Descripción |
|---|---|---|
INTERVAL_END |
TIMESTAMP |
Es el final del intervalo de tiempo en el que se produjeron los conflictos de bloqueo incluidos. |
ROW_RANGE_START_KEY |
BYTES(MAX) |
Es la clave de fila en la que se produjo el conflicto de bloqueo. Cuando el conflicto
involucra un rango de filas, este valor representa la clave de inicio
de ese rango. Un signo más, +, indica un rango.
Para obtener más información,
consulta ¿Qué es una clave de inicio del rango de filas?.
|
LOCK_WAIT_SECONDS |
FLOAT64 |
Es el tiempo de espera de bloqueo acumulado de los conflictos de bloqueo registrados para todas las columnas en el rango de clave de fila, en segundos. |
SAMPLE_LOCK_REQUESTS |
ARRAY<STRUCT<
|
Cada entrada de este array corresponde a una solicitud de bloqueo de muestra que
contribuyó al conflicto de bloqueo, ya sea esperando un bloqueo o
impidiendo que otras transacciones tomen el bloqueo, en la clave de fila (rango) determinada. La cantidad máxima de muestras en este array es 20.
Cada muestra contiene los siguientes tres campos:
|
SAMPLE_LOCK_REQUESTS_JSON_STRING |
STRING |
Es una representación de cadena compatible con JSON de la columna SAMPLE_LOCK_REQUESTS. La
cadena JSON es un objeto
JSON con la misma estructura que el STRUCT definido en
la columna SAMPLE_LOCK_REQUESTS.
Esta columna es compatible con las bases de datos de dialecto de GoogleSQL y PostgreSQL. |
LOCK_WAIT_DISTRIBUTION |
ARRAY<STRUCT> |
Un histograma de los tiempos de espera de bloqueo individuales para los conflictos de bloqueo registrados en el rango de clave de fila. A diferencia de las otras columnas de latencia de estas tablas, los valores de esta columna se expresan en microsegundos. Para convertirlos en segundos, divídelos por 1,000,000.
El array contiene un solo elemento y tiene el siguiente tipo:
Para obtener más información sobre los valores, consulta Distribución y Exponencial. Para calcular los percentiles del tiempo de espera de bloqueo a partir de la distribución, usa
la función
|
LOCK_WAIT_DISTRIBUTION_JSON_STRING |
STRING |
Es una representación de cadena compatible con JSON de la columna
Esta columna es compatible con las bases de datos de dialecto de GoogleSQL y PostgreSQL. |
Modos de bloqueo
Las operaciones de Spanner adquieren bloqueos cuando forman parte de una transacción de lectura y escritura. Las transacciones de solo lectura no adquieren bloqueos. Spanner usa diferentes modos de bloqueo para maximizar la cantidad de transacciones que tienen acceso a una celda de datos en particular en un momento determinado. Los diferentes bloqueos tienen características diferentes. Por ejemplo, algunos bloqueos se pueden compartir entre varias transacciones, mientras que otros no.
Se puede producir un conflicto de bloqueo cuando intentas adquirir uno de los siguientes modos de bloqueo en una transacción.
Bloqueo
ReaderShared: Es un bloqueo que permite que otras lecturas sigan accediendo a los datos hasta que la transacción esté lista para confirmarse. Este bloqueo compartido se adquiere cuando una transacción de lectura y escritura lee datos.Bloqueo
WriterShared: Este bloqueo se adquiere cuando una transacción de lectura y escritura intenta confirmar una escritura.Bloqueo
Exclusive: Se adquiere un bloqueo exclusivo cuando una transacción de lectura y escritura, que ya adquirió un bloqueo ReaderShared, intenta escribir datos después de que se completa la lectura. Un bloqueo exclusivo es una actualización de un bloqueoReaderShared. Un bloqueo exclusivo es un caso especial de una transacción que contiene el bloqueoReaderSharedy el bloqueoWriterSharedal mismo tiempo. Ninguna otra transacción puede adquirir ningún bloqueo en la misma celda.Bloqueo
WriterSharedTimestamp: Es un tipo especial de bloqueoWriterSharedque se adquiere cuando se insertan filas nuevas en una tabla que tiene una marca de tiempo de confirmación como parte de la clave primaria. Este tipo de bloqueo impide que los participantes de la transacción creen exactamente la misma fila y, por lo tanto, entren en conflicto entre sí. Spanner actualiza la clave de la fila insertada para que coincida con la marca de tiempo de confirmación de la transacción que realizó la inserción.
Para obtener más información sobre los tipos de transacciones y los tipos de bloqueos disponibles, consulta Transacciones.
Conflictos de modo de bloqueo
En la siguiente tabla, se muestran los posibles conflictos entre los diferentes modos de bloqueo.
| Modos de bloqueo | ReaderShared |
WriterShared |
Exclusive |
WriterSharedTimestamp |
|---|---|---|---|---|
ReaderShared |
No | Sí | Sí | Sí |
WriterShared |
Sí | No | Sí | No aplicable |
Exclusive |
Sí | Sí | Sí | No aplicable |
WriterSharedTimestamp |
Sí | No aplicable | No aplicable | Sí |
Los bloqueos WriterSharedTimestamp solo se usan cuando se insertan filas nuevas con una
marca de tiempo como parte de su clave primaria. Los bloqueos WriterShared y Exclusive se usan
cuando se escribe en celdas existentes o se insertan filas nuevas sin marcas de tiempo. Como
resultado, WriterSharedTimestamp no puede entrar en conflicto con otros tipos de bloqueos, y
esas situaciones se muestran como No aplicable en la tabla anterior.
La única excepción es ReaderShared, que se puede aplicar a filas inexistentes
y, por lo tanto, podría entrar en conflicto con WriterSharedTimestamp. Por
ejemplo, un análisis completo de la tabla bloquea toda la tabla, incluso para las filas que no se crearon,
por lo que es posible que ReaderShared entre en conflicto con
WriterSharedTimestamp.
¿Qué es una clave de inicio del rango de filas?
La columna ROW_RANGE_START_KEY identifica la clave primaria compuesta o la clave primaria inicial de un rango de filas que tiene conflictos de bloqueo. El siguiente
esquema se usa para ilustrar un ejemplo.
CREATE TABLE Singers (
SingerId INT64 NOT NULL,
FirstName STRING(1024),
LastName STRING(1024),
SingerInfo BYTES(MAX),
) PRIMARY KEY (SingerId);
CREATE TABLE Albums (
SingerId INT64 NOT NULL,
AlbumId INT64 NOT NULL,
AlbumTitle STRING(MAX),
) PRIMARY KEY (SingerId, AlbumId),
INTERLEAVE IN PARENT Singers ON DELETE CASCADE;
CREATE TABLE Songs (
SingerId INT64 NOT NULL,
AlbumId INT64 NOT NULL,
TrackId INT64 NOT NULL,
SongName STRING(MAX),
) PRIMARY KEY (SingerId, AlbumId, TrackId),
INTERLEAVE IN PARENT Albums ON DELETE CASCADE;
CREATE TABLE Users (
UserId INT64 NOT NULL,
LastAccess TIMESTAMP NOT NULL OPTIONS (allow_commit_timestamp=true),
...
) PRIMARY KEY (UserId, LastAccess);
Como se muestra en la siguiente tabla de clave de fila y rangos de clave de fila, un rango se representa con un signo más, "+", en la clave. En esos casos, la clave representa la clave inicial de un rango de claves en el que se produjo un conflicto de bloqueo.
| ROW_RANGE_START_KEY | Explicación |
|---|---|
| cantantes(2) | Tabla Singers en la clave SingerId=2 |
| cantantes(2,1) | Tabla de álbumes en la clave SingerId=2,AlbumId=1 |
| canciones(2,1,5) | Tabla de canciones en la clave SingerId=2,AlbumId=1,TrackId=5 |
| canciones(2,1,5+) | Rango de claves de la tabla de canciones a partir de SingerId=2,AlbumId=1,TrackId=5 |
| albums(2,1+) | Rango de claves de la tabla de álbumes a partir de SingerId=2,AlbumId=1 |
| usuarios(3, 2020-11-01 12:34:56.426426+00:00) | Tabla Users en la clave UserId=3, LastAccess=commit_timestamp |
Estadísticas agregadas
SPANNER_SYS también contiene tablas para almacenar datos agregados de las estadísticas de bloqueo
capturadas por Spanner en un período específico:
SPANNER_SYS.LOCK_STATS_TOTAL_MINUTE: Estadísticas agregadas para todas las esperas de bloqueo durante intervalos de 1 minuto.SPANNER_SYS.LOCK_STATS_TOTAL_10MINUTE: Son estadísticas agregadas para todas las esperas de bloqueo durante intervalos de 10 minutos.SPANNER_SYS.LOCK_STATS_TOTAL_HOUR: Son estadísticas agregadas para todas las esperas de bloqueo durante intervalos de 1 hora.
Las tablas conjuntas de estadísticas tienen las siguientes propiedades:
Cada tabla contiene datos de intervalos de tiempo que no se superponen y que tienen la duración que especifica el nombre de la tabla.
Los intervalos se basan en tiempos de reloj. Los intervalos de 1 minuto finalizan en el minuto, los intervalos de 10 minutos finalizan cada 10 minutos a partir de la hora y los intervalos de 1 hora finalizan en la hora.
Por ejemplo, a las 11:59:30 a.m., los intervalos más recientes disponibles para las consultas de SQL en las estadísticas de bloqueo agregadas son los siguientes:
- 1 minuto: de 11:58:00 a 11:58:59 a.m.
- 10 minutos: de 11:40:00 a 11:49:59 a.m.
- 1 hora: de 10:00:00 a 10:59:59 a.m.
Cada fila contiene estadísticas de todas las esperas de bloqueo en la base de datos durante el intervalo especificado, agregadas juntas. Solo hay una fila por intervalo de tiempo.
Las estadísticas capturadas en las tablas
SPANNER_SYS.LOCK_STATS_TOTAL_*incluyen esperas de bloqueo que Spanner no capturó en las tablasSPANNER_SYS.LOCK_STATS_TOP_*.Algunas columnas de estas tablas se exponen como métricas en Cloud Monitoring. Las métricas expuestas son las siguientes:
- Tiempo de espera de bloqueo
Para obtener más información, consulta Métricas de Spanner.
Esquema de la tabla
| Nombre de la columna | Tipo | Descripción |
|---|---|---|
INTERVAL_END |
TIMESTAMP |
Es el final del intervalo de tiempo en el que se produjo el conflicto de bloqueo. |
TOTAL_LOCK_WAIT_SECONDS |
FLOAT64 |
Es el tiempo de espera de bloqueo total para los conflictos de bloqueo registrados en toda la base de datos, en segundos. |
LOCK_WAIT_DISTRIBUTION |
ARRAY<STRUCT> |
Un histograma de los tiempos de espera de bloqueo individuales para los conflictos de bloqueo registrados en toda la base de datos, en microsegundos, no en segundos. La estructura es la misma que la de la columna LOCK_WAIT_DISTRIBUTION en las tablas SPANNER_SYS.LOCK_STATS_TOP_*. Las bases de datos de dialecto de PostgreSQL no admiten esta columna. En su lugar, usa la columna LOCK_WAIT_DISTRIBUTION_JSON_STRING. |
LOCK_WAIT_DISTRIBUTION_JSON_STRING |
STRING |
Es una representación de cadena compatible con JSON de la columna LOCK_WAIT_DISTRIBUTION. Sus valores se expresan en microsegundos. Esta columna es compatible con las bases de datos de dialecto de GoogleSQL y PostgreSQL. |
Consultas de ejemplo
El siguiente es un ejemplo de una instrucción de SQL que puedes usar para recuperar estadísticas de bloqueo. Puedes ejecutar estas sentencias de SQL con las bibliotecas cliente, gcloud spanner o la consola deGoogle Cloud .
Enumera las estadísticas de bloqueo del intervalo de 1 minuto anterior
La siguiente consulta muestra la información de espera de bloqueo para cada clave de fila con un conflicto de bloqueo, incluida la fracción del total de conflictos de bloqueo, durante el intervalo de tiempo de 1 minuto más reciente.
La función CAST() convierte el campo BYTES
row_range_start_key en una STRING.
SELECT CAST(s.row_range_start_key AS STRING) AS row_range_start_key,
t.total_lock_wait_seconds,
s.lock_wait_seconds,
s.lock_wait_seconds/t.total_lock_wait_seconds frac_of_total,
s.sample_lock_requests
FROM spanner_sys.lock_stats_total_minute t, spanner_sys.lock_stats_top_minute s
WHERE t.interval_end =
(SELECT MAX(interval_end)
FROM spanner_sys.lock_stats_total_minute)
AND s.interval_end = t.interval_end
ORDER BY s.lock_wait_seconds DESC;
Resultado de la consulta
| row_range_start_key | total_lock_wait_seconds | lock_wait_seconds | frac_of_total | sample_lock_requests |
|---|---|---|---|---|
| canciones(2,1,1) | 2.37 | 1.76 | 0.7426 | LOCK_MODE: ReaderShared COLUMN: Singers.SingerInfo LOCK_MODE: WriterShared COLUMN: Singers.SingerInfo |
| Usuarios(3, 2020-11-01 12:34:56.426426+00:00) | 2.37 | 0.61 | 0.2573 | LOCK_MODE: ReaderShared COLUMN: users._exists1 LOCK_MODE: WriterShared COLUMN: users._exists1 |
1 _exists es un campo interno que se usa para verificar si existe o no una fila determinada.
Retención de datos
Como mínimo, Spanner conserva los datos de cada tabla durante los siguientes períodos:
SPANNER_SYS.LOCK_STATS_TOP_MINUTEySPANNER_SYS.LOCK_STATS_TOTAL_MINUTE: Intervalos que abarcan las 6 horas anteriores.SPANNER_SYS.LOCK_STATS_TOP_10MINUTEySPANNER_SYS.LOCK_STATS_TOTAL_10MINUTE: Intervalos que abarcan los 4 días anteriores.SPANNER_SYS.LOCK_STATS_TOP_HOURySPANNER_SYS.LOCK_STATS_TOTAL_HOUR: Son intervalos que abarcan los 30 días anteriores.
Soluciona problemas de conflictos de bloqueo en tu base de datos con las estadísticas de bloqueo
Puedes usar SQL o el panel Estadísticas de bloqueos para ver los conflictos de bloqueo en tu base de datos.
En los siguientes temas, se muestra cómo puedes investigar esos conflictos de bloqueo con código SQL.
Selecciona un período para investigar
Examinas las métricas de latencia de tu base de datos de Spanner y descubres un período en el que tu app experimenta una latencia y un uso de CPU altos. Por ejemplo, el problema comenzó a ocurrir alrededor de las 10:50 p.m. del 12 de noviembre de 2020.
Determina si la latencia de confirmación de la transacción aumentó junto con el tiempo de espera de bloqueo durante el período seleccionado
Las transacciones adquieren bloqueos, por lo que, si los conflictos de bloqueo causan tiempos de espera prolongados, deberíamos poder ver el aumento en la latencia de confirmación de la transacción junto con el aumento en el tiempo de espera del bloqueo.
Después de seleccionar un período para comenzar nuestra investigación, uniremos las
estadísticas de transacciones TXN_STATS_TOTAL_10MINUTE
con las estadísticas de bloqueo LOCK_STATS_TOTAL_10MINUTE de ese momento para ayudarnos a
comprender si el aumento de la latencia de confirmación promedio se debe al
aumento del tiempo de espera del bloqueo.
SELECT t.interval_end, t.avg_commit_latency_seconds, l.total_lock_wait_seconds
FROM spanner_sys.txn_stats_total_10minute t
LEFT JOIN spanner_sys.lock_stats_total_10minute l
ON t.interval_end = l.interval_end
WHERE
t.interval_end >= "2020-11-12T21:50:00Z"
AND t.interval_end <= "2020-11-12T23:50:00Z"
ORDER BY interval_end;
Toma los siguientes datos como ejemplo de los resultados que obtenemos de nuestra consulta.
| interval_end | avg_commit_latency_seconds | total_lock_wait_seconds |
|---|---|---|
| 2020-11-12 21:40:00-07:00 | 0.002 | 0.090 |
| 2020-11-12 21:50:00-07:00 | 0.003 | 0.110 |
| 2020-11-12 22:00:00-07:00 | 0.002 | 0.100 |
| 2020-11-12 22:10:00-07:00 | 0.002 | 0.080 |
| 2020-11-12 22:20:00-07:00 | 0.030 | 0.240 |
| 2020-11-12 22:30:00-07:00 | 0.034 | 0.220 |
| 2020-11-12 22:40:00-07:00 | 0.034 | 0.218 |
| 2020-11-12 22:50:00-07:00 | 3.741 | 780.193 |
| 2020-11-12 23:00:00-07:00 | 0.042 | 0.240 |
| 2020-11-12 23:10:00-07:00 | 0.038 | 0.129 |
| 2020-11-12 23:20:00-07:00 | 0.021 | 0.128 |
| 2020-11-12 23:30:00-07:00 | 0.038 | 0.231 |
Estos resultados anteriores muestran un aumento drástico en avg_commit_latency_seconds
y total_lock_wait_seconds durante el mismo período, desde el 12 de noviembre de 2020 a las
22:40:00 hasta el 12 de noviembre de 2020 a las 22:50:00, y disminuyeron después de eso. Ten en cuenta que el avg_commit_latency_seconds es el tiempo promedio que se dedica solo al paso de confirmación. Por otro lado, total_lock_wait_seconds es el tiempo de bloqueo agregado para el período, por lo que el tiempo parece mucho más largo que el tiempo de confirmación de la transacción.
Ahora que confirmamos que el tiempo de espera del bloqueo está estrechamente relacionado con el aumento en la latencia de escritura, investigaremos en el siguiente paso qué filas y columnas causan la espera prolongada.
Descubre qué claves de fila y columnas tuvieron tiempos de espera de bloqueo prolongados durante el período seleccionado
Para averiguar qué claves de fila y columnas experimentaron los tiempos de espera de bloqueo altos
durante el período que estamos investigando, consultamos la tabla LOCK_STAT_TOP_10MINUTE,
que enumera las claves de fila y las columnas que más contribuyen a la espera de
bloqueo.
La función CAST() de la siguiente consulta convierte el campo BYTES row_range_start_key en una STRING.
SELECT CAST(s.row_range_start_key AS STRING) AS row_range_start_key,
t.total_lock_wait_seconds,
s.lock_wait_seconds,
s.lock_wait_seconds/t.total_lock_wait_seconds frac_of_total,
s.sample_lock_requests
FROM spanner_sys.lock_stats_total_10minute t, spanner_sys.lock_stats_top_10minute s
WHERE
t.interval_end = "2020-11-12T22:50:00Z" and s.interval_end = t.interval_end;
| row_range_start_key | total_lock_wait_seconds | lock_wait_seconds | frac_of_total | sample_lock_requests |
|---|---|---|---|---|
| Cantantes(32) | 780.193 | 780.193 | 1 | LOCK_MODE: WriterShared COLUMN: Singers.SingerInfo LOCK_MODE: ReaderShared COLUMN: Singers.SingerInfo |
En esta tabla de resultados, podemos ver que el conflicto ocurrió en la tabla Singers
en la clave SingerId=32. Singers.SingerInfo es la columna en la que se produjo el conflicto de bloqueo entre ReaderShared y WriterShared.
Este es un tipo común de conflicto cuando hay una transacción que intenta leer una celda determinada y la otra transacción intenta escribir en la misma celda. Ahora conocemos la celda de datos exacta por la que las transacciones compiten por el bloqueo, por lo que, en el siguiente paso, identificaremos las transacciones que compiten por los bloqueos.
Encuentra qué transacciones acceden a las columnas involucradas en el conflicto de bloqueo
Para identificar las transacciones que experimentan una latencia de confirmación significativa
dentro de un intervalo de tiempo específico debido a conflictos de bloqueo, debes consultar las
siguientes columnas de la
tabla SPANNER_SYS.TXN_STATS_TOTAL_10MINUTE:
fprintread_columnswrite_constructive_columnsavg_commit_latency_seconds
Debes filtrar las columnas bloqueadas identificadas en la tabla
SPANNER_SYS.LOCK_STATS_TOP_10MINUTE:
Son las transacciones que leen cualquier columna que haya generado un conflicto de bloqueo cuando se intentó adquirir el bloqueo
ReaderShared.Transacciones que escriben en cualquier columna que haya generado un conflicto de bloqueo cuando se intentó adquirir un bloqueo
WriterShared.
SELECT
fprint,
read_columns,
write_constructive_columns,
avg_commit_latency_seconds
FROM spanner_sys.txn_stats_top_10minute t2
WHERE (
EXISTS (
SELECT * FROM t2.read_columns columns WHERE columns IN (
SELECT DISTINCT(req.COLUMN)
FROM spanner_sys.lock_stats_top_10minute t, t.SAMPLE_LOCK_REQUESTS req
WHERE req.LOCK_MODE = "ReaderShared" AND t.interval_end ="2020-11-12T23:50:00Z"))
OR
EXISTS (
SELECT * FROM t2.write_constructive_columns columns WHERE columns IN (
SELECT DISTINCT(req.COLUMN)
FROM spanner_sys.lock_stats_top_10minute t, t.SAMPLE_LOCK_REQUESTS req
WHERE req.LOCK_MODE = "WriterShared" AND t.interval_end ="2020-11-12T23:50:00Z"))
)
AND t2.interval_end ="2020-11-12T23:50:00Z"
ORDER BY avg_commit_latency_seconds DESC;
El resultado de la consulta se ordena por la columna avg_commit_latency_seconds para que
veas primero la transacción que experimenta la latencia de confirmación más alta.
| fprint | read_columns | write_constructive_columns | avg_commit_latency_seconds |
|---|---|---|---|
| 1866043996151916800 |
['Singers.SingerInfo', 'Singers.FirstName', 'Singers.LastName', 'Singers._exists'] |
['Singers.SingerInfo'] | 4.89 |
| 4168578515815911936 | [] | ['Singers.SingerInfo'] | 3.65 |
Los resultados de la consulta muestran que dos transacciones intentaron acceder a la
columna Singers.SingerInfo, que es la columna que tuvo conflictos de bloqueo durante
el período. Una vez que identifiques las transacciones que causan los conflictos de bloqueo,
puedes analizarlas con su huella digital, fprint, para identificar
los posibles problemas que contribuyeron al conflicto de bloqueo.
Después de revisar la transacción con fprint=1866043996151916800, puedes usar las
columnas read_columns y write_constructive_columns para identificar qué parte
del código de la aplicación activó la transacción. Luego, puedes ver el
DML subyacente que no filtra por la clave primaria, SingerId. Esto provocó
un análisis completo de la tabla y la bloqueó hasta que se confirmó la transacción.
Para resolver el conflicto de bloqueo, puedes hacer lo siguiente:
- Usa una transacción de solo lectura para identificar los valores
SingerIdrequeridos. - Usa una transacción de lectura y escritura independiente para actualizar las filas de los valores
SingerIdrequeridos.
Aplica las prácticas recomendadas para reducir la contención de bloqueos
En nuestro ejemplo, usamos las estadísticas de bloqueos y de transacciones para reducir el problema a una transacción que no usaba la clave primaria de nuestra tabla cuando realizaba actualizaciones. Se nos ocurrieron ideas para mejorar la transacción en función de si conocíamos de antemano las claves de las filas que queríamos actualizar o no.
Cuando analices posibles problemas en tu solución o incluso cuando la diseñes, considera estas prácticas recomendadas para reducir la cantidad de conflictos de bloqueo en tu base de datos.
Evita lecturas extensas en las transacciones de lectura y escritura
Usa transacciones de solo lectura siempre que sea posible, ya que no adquieren ningún bloqueo.
Evita los análisis completos de tablas en una transacción de lectura y escritura. Esto incluye escribir un DML condicional en la clave primaria o asignar un rango de claves específico cuando se usa la API de lectura.
Mantén el período de bloqueo breve confirmando el cambio lo antes posible después de leer los datos en una transacción de lectura y escritura. Una transacción de lectura y escritura garantiza que los datos permanezcan sin cambios después de que los leas hasta que confirmes el cambio correctamente. Para lograrlo, la transacción requiere bloquear las celdas de datos durante la lectura y durante la confirmación. Como resultado, si puedes mantener un período de bloqueo breve, es menos probable que las transacciones tengan conflictos de bloqueo.
Favorece las transacciones pequeñas sobre las grandes o considera el DML particionado para las transacciones de DML de larga duración. Una transacción de larga duración adquiere un bloqueo durante mucho tiempo, por lo que, siempre que sea posible, considera dividir una transacción que afecte a miles de filas en varias transacciones más pequeñas que actualicen cientos de filas.
Si no necesitas la garantía que proporciona una transacción de lectura y escritura, evita leer datos en la transacción de lectura y escritura antes de confirmar el cambio, por ejemplo, leyendo los datos en una transacción de solo lectura independiente. La mayoría de los conflictos de bloqueo se producen debido a la garantía sólida, para garantizar que los datos no se modifiquen entre la lectura y la confirmación. Por lo tanto, si la transacción de lectura y escritura no lee ningún dato, no necesita bloquear las celdas durante mucho tiempo.
Especifica solo el conjunto mínimo de columnas que se requieren en una transacción de lectura y escritura. Como los bloqueos de Spanner son por celda de datos, cuando una transacción de lectura y escritura lee demasiadas columnas, adquiere un bloqueo
ReaderShareden estas celdas. Esto puede causar conflictos de bloqueo cuando otras transacciones adquieren un bloqueoWriterShareden las escrituras en las columnas excesivas. Por ejemplo, considera especificar un conjunto de columnas en lugar de*en la lectura.Minimiza las llamadas a la API en una transacción de lectura y escritura. La latencia de las llamadas a la API puede generar una contención de bloqueo en Spanner, ya que las llamadas a la API están sujetas a retrasos de red y del servicio. Te recomendamos que realices llamadas a la API fuera de las transacciones de lectura y escritura siempre que sea posible. Si debes ejecutar llamadas a la API dentro de una transacción de lectura y escritura, asegúrate de supervisar la latencia de tus llamadas a la API para minimizar el impacto en el período de adquisición del bloqueo.
Sigue las prácticas recomendadas para el diseño de esquemas.
Si la posibilidad de que se produzca un sesgo de escritura no es un problema para tu aplicación, considera usar el aislamiento de lectura repetible con su simultaneidad optimista predeterminada para evitar las contenciones de lectura y escritura. Para obtener más información, consulta Aislamiento de lectura repetible.
Para las cargas de trabajo que tienen una baja contención de lectura y escritura, considera usar el aislamiento serializable con el control de simultaneidad optimista para evitar adquirir bloqueos en las transacciones hasta el momento de la confirmación, mientras se aplica que todas las lecturas de la transacción sean válidas en el momento de la confirmación. Para obtener más información sobre la idoneidad de esta opción, consulta Control de simultaneidad optimista.
¿Qué sigue?
- Obtén más información sobre otras herramientas de introspección.
- Obtén más información sobre otros datos que Spanner almacena para cada base de datos en la tabla esquema de información de las bases de datos.
- Obtén más información sobre las prácticas recomendadas de SQL para Spanner.