En una base de datos de Spanner, Spanner crea automáticamente un
índice para la clave primaria de cada tabla. Por ejemplo, no necesitas hacer nada para indexar la clave primaria de Singers, ya que se indexa automáticamente.
También puedes crear índices secundarios para otras columnas. Agregar un índice secundario a una columna hace que la búsqueda de datos en esa columna sea más eficiente. Por
ejemplo, si necesitas buscar rápidamente un álbum por título, debes
crear un índice secundario en AlbumTitle,
para que Spanner no necesite analizar toda la tabla.
Si la búsqueda del ejemplo anterior se realiza dentro de una transacción de lectura y escritura,
la búsqueda más eficiente también evita mantener bloqueos en toda la tabla,
lo que permite inserciones y actualizaciones simultáneas en la tabla para las filas fuera del
rango de búsqueda de AlbumTitle.
Además de los beneficios que aportan a las búsquedas, los índices secundarios también pueden ayudar a Spanner a ejecutar análisis de manera más eficiente, lo que permite análisis de índices en lugar de análisis de tablas completos.
Spanner almacena los siguientes datos en cada índice secundario:
- Todas las columnas de clave de la tabla base
- Todas las columnas que se incluyen en el índice
- Todas las columnas especificadas en la cláusula opcional
STORING(bases de datos de dialecto de GoogleSQL) oINCLUDE(bases de datos de dialecto de PostgreSQL) de la definición del índice.
Con el tiempo, Spanner analiza tus tablas para garantizar que tus índices secundarios se usen para las consultas adecuadas.
Agrega un índice secundario
El momento más eficaz para agregar un índice secundario es cuando creas la tabla. Para crear una tabla y sus índices al mismo tiempo, envía las sentencias de DDL de la tabla nueva y los índices nuevos en una sola solicitud a Spanner.
En Spanner, también puedes agregar un índice secundario nuevo a una tabla existente mientras la base de datos sigue entregando tráfico. Al igual que cualquier otro cambio de esquema en Spanner, agregar un índice a una base de datos existente no requiere que la base de datos esté sin conexión y no bloquea columnas ni tablas completas.
Cada vez que se agrega un índice nuevo a una tabla existente, Spanner rellena o completa automáticamente el índice para reflejar una vista actualizada de los datos que se indexan. Spanner administra este proceso de reabastecimiento por ti, y el proceso se ejecuta en segundo plano con recursos de nodo con prioridad baja. La velocidad de reabastecimiento de índices se adapta a los recursos de nodo cambiantes durante la creación de índices, y el reabastecimiento no afecta de forma significativa el rendimiento de la base de datos.
La creación del índice puede tardar desde varios minutos hasta muchas horas. Debido a que la creación de índices es una actualización de esquema, está sujeta a las mismas restricciones de rendimiento que cualquier otra actualización de esquema. El tiempo necesario para crear un índice secundario depende de varios factores:
- El tamaño del conjunto de datos
- La capacidad de procesamiento de la instancia
- La carga de la instancia
Para ver el progreso de un proceso de reabastecimiento de índices, consulta la sección de progreso.
Ten en cuenta que usar la columna confirmar marca de tiempo como la primera parte del índice secundario puede crear hotspots y reducir el rendimiento de la operación de escritura.
Usa la sentencia CREATE INDEX para definir un índice secundario
en tu esquema. Estos son algunos ejemplos:
Para indexar todos los Singers en la base de datos por su nombre y apellido, ejecuta el comando siguiente:
GoogleSQL
CREATE INDEX SingersByFirstLastName ON Singers(FirstName, LastName);
PostgreSQL
CREATE INDEX SingersByFirstLastName ON Singers(FirstName, LastName);
Para crear un índice de todas las Songs en la base de datos por el valor de SongName, ejecuta el comando siguiente:
GoogleSQL
CREATE INDEX SongsBySongName ON Songs(SongName);
PostgreSQL
CREATE INDEX SongsBySongName ON Songs(SongName);
Si deseas indexar solo las canciones de un cantante en particular, usa la cláusula INTERLEAVE IN para intercalar el índice en la tabla Singers:
GoogleSQL
CREATE INDEX SongsBySingerSongName ON Songs(SingerId, SongName),
INTERLEAVE IN Singers;
PostgreSQL
CREATE INDEX SongsBySingerSongName ON Songs(SingerId, SongName)
INTERLEAVE IN Singers;
Para indexar solo las canciones de un álbum en particular, haz lo siguiente:
GoogleSQL
CREATE INDEX SongsBySingerAlbumSongName ON Songs(SingerId, AlbumId, SongName),
INTERLEAVE IN Albums;
PostgreSQL
CREATE INDEX SongsBySingerAlbumSongName ON Songs(SingerId, AlbumId, SongName)
INTERLEAVE IN Albums;
Para indexar por orden descendente de SongName, ejecuta lo siguiente:
GoogleSQL
CREATE INDEX SongsBySingerAlbumSongNameDesc ON Songs(SingerId, AlbumId, SongName DESC),
INTERLEAVE IN Albums;
PostgreSQL
CREATE INDEX SongsBySingerAlbumSongNameDesc ON Songs(SingerId, AlbumId, SongName DESC)
INTERLEAVE IN Albums;
Ten en cuenta que la anotación DESC anterior solo se aplica a SongName. Para indexarlos por orden descendente de otras claves de índice, anótalas con DESC y SingerId DESC, AlbumId DESC.
También ten en cuenta que PRIMARY_KEY es una palabra reservada y no se puede usar como el nombre de un índice. Es el nombre asignado al seudo-índice que se crea cuando se crea una tabla con especificaciones de CLAVE PRIMARIA
Para obtener más detalles y prácticas recomendadas para elegir índices no intercalados y los intercalados, consulta Elige entre índices intercalados y globales, Opciones de índice y Usa un índice intercalado en una columna cuyo valor aumente o disminuya de forma monotónica.
Índices y entrelazado
Los índices de Spanner se pueden intercalar con otras tablas para colocar las filas de índice junto con las de otra tabla. Al igual que la intercalación de tablas de Spanner, las columnas de clave primaria del superior del índice deben ser un prefijo de las columnas indexadas, que coincidan en el tipo y el orden de clasificación. A diferencia de las tablas intercaladas, no es necesario que coincidan los nombres de las columnas. Cada fila de un índice intercalado se almacena físicamente junto con la fila superior asociada.
Por ejemplo, considera el siguiente esquema:
CREATE TABLE Singers (
SingerId INT64 NOT NULL,
FirstName STRING(1024),
LastName STRING(1024),
SingerInfo PROTO<Singer>(MAX)
) PRIMARY KEY (SingerId);
CREATE TABLE Albums (
SingerId INT64 NOT NULL,
AlbumId INT64 NOT NULL,
AlbumTitle STRING(MAX),
PublisherId INT64 NOT NULL
) 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,
PublisherId INT64 NOT NULL,
SongName STRING(MAX)
) PRIMARY KEY (SingerId, AlbumId, TrackId),
INTERLEAVE IN PARENT Albums ON DELETE CASCADE;
CREATE TABLE Publishers (
Id INT64 NOT NULL,
PublisherName STRING(MAX)
) PRIMARY KEY (Id);
Para indexar todos los Singers de la base de datos por su nombre y apellido, debes
crear un índice. A continuación, se muestra cómo definir el índice SingersByFirstLastName:
CREATE INDEX SingersByFirstLastName ON Singers(FirstName, LastName);
Si quieres crear un índice de Songs en (SingerId, AlbumId, SongName),
puedes hacer lo siguiente:
CREATE INDEX SongsBySingerAlbumSongName
ON Songs(SingerId, AlbumId, SongName);
También puedes crear un índice intercalado con un ancestro de Songs,
como el siguiente:
CREATE INDEX SongsBySingerAlbumSongName
ON Songs(SingerId, AlbumId, SongName),
INTERLEAVE IN Albums;
Además, también puedes crear un índice de Songs en
(PublisherId, SingerId, AlbumId, SongName) que se intercala con una tabla
que no es un ancestro de Songs, como Publishers. Ten en cuenta que la clave primaria
de la tabla Publishers (id) no es un prefijo de las columnas indexadas en el
siguiente ejemplo. Esto aún se permite porque Publishers.Id y Songs.PublisherId comparten el mismo tipo, orden de clasificación y nulabilidad.
CREATE INDEX SongsByPublisherSingerAlbumSongName
ON Songs(PublisherId, SingerId, AlbumId, SongName),
INTERLEAVE IN Publishers;
Elige entre índices intercalados y globales
Cuando creas un índice secundario en Spanner, lo defines como un índice global (el índice predeterminado no intercalado) o un índice intercalado. Elegir el tipo de índice óptimo es fundamental para el rendimiento de lectura y escritura.
Comparación de índices
| Función | Índice intercalado | Índice global |
|---|---|---|
| Ubicación de almacenamiento | Se ubican junto con la fila superior en la misma división (árbol de filas). | Se almacena en una tabla raíz independiente, que se puede dividir de forma independiente de la tabla base. |
| Requisitos clave | La clave primaria de la tabla superior debe ser un prefijo de las claves de índice. | No hay restricciones en las claves de índice. |
| Sobrecarga de escritura | Baja Cuando se intercala en un ancestro de la tabla base, las actualizaciones suelen ser locales para la división, lo que evita confirmaciones de dos fases entre divisiones. Si se intercala en una tabla que no es un ancestro, la sobrecarga de escritura es mayor porque las actualizaciones pueden requerir transacciones distribuidas. | Más alto. Las actualizaciones suelen abarcar diferentes divisiones, lo que requiere transacciones distribuidas. |
| Ideal para | Consultas con alcance limitado a una sola entidad principal, por ejemplo, "buscar fotos del usuario USER_NAME". | Consultas que buscan en toda la base de datos, por ejemplo, "buscar usuario por correo electrónico" |
Por qué suelen preferirse los índices intercalados
En una base de datos distribuida como Spanner, la localidad de los datos es clave para el rendimiento. Por lo general, se prefieren los índices intercalados porque conservan la localidad de los datos:
- Lecturas eficientes: Si tus consultas siempre filtran por el ID de una entidad principal, un índice intercalado permite que Spanner satisfaga la consulta analizando solo la división que contiene esa entidad principal, en lugar de consultar múltiples divisiones.
- Escrituras eficientes: Cuando actualizas una fila en una tabla, Spanner también debe actualizar sus índices secundarios. Si usas un índice global, es probable que la entrada de índice resida en una división diferente de la fila base. Esto obliga a Spanner a realizar una transacción distribuida (confirmación en dos fases) entre divisiones, lo que aumenta la latencia y el uso de CPU. Si un índice intercalado se intercala en un ancestro de la tabla base, la entrada del índice se almacena en la misma división que la fila base, lo que hace que la escritura sea una operación local.
Guía de decisiones
Usa los siguientes lineamientos para elegir el tipo de índice óptimo para tu caso de uso:
Cuándo usar un índice intercalado
Usa un índice intercalado cuando se cumpla una o más de las siguientes condiciones:
- Tus consultas siempre incluyen un filtro en la clave primaria de la tabla superior, por ejemplo,
WHERE UserId = @userId AND .... - Las columnas de clave primaria de la tabla superior se pueden usar de forma natural como prefijo para tus claves de índice.
- Quieres minimizar la latencia de escritura y la sobrecarga de CPU del mantenimiento de índices.
Ejemplo:
-- Indexing albums by title for a specific singer
CREATE INDEX AlbumsBySingerTitle ON Albums(SingerId, AlbumTitle),
INTERLEAVE IN Singers;
Cuándo usar un índice global
Usa un índice global cuando se cumpla una o más de las siguientes condiciones:
- Necesitas consultar datos en toda la base de datos sin filtrar por una entidad principal, por ejemplo, una búsqueda global.
- Las columnas que quieres indexar no comparten un prefijo con ninguna tabla superior.
Ejemplo:
-- Indexing all albums globally by title. For example, for a global search catalog.
CREATE INDEX AlbumsByTitle ON Albums(AlbumTitle);
Verifica el progreso del reabastecimiento del índice
Console
En el menú de navegación de Spanner, haz clic en la pestaña Operaciones. En la página Operaciones, se muestra una lista de las operaciones en ejecución.
Busca la operación de reabastecimiento en la lista. Si aún se está ejecutando, el indicador de progreso de la columna Hora de finalización muestra el porcentaje de la operación que se completó, como se muestra en la siguiente imagen:

gcloud
Usa gcloud spanner operations describe
para verificar el progreso de una operación.
Obtén el ID de la operación:
gcloud spanner operations list --instance=INSTANCE-NAME \ --database=DATABASE-NAME --type=DATABASE_UPDATE_DDL
Reemplaza lo siguiente:
- INSTANCE-NAME por el nombre de la instancia de Spanner.
- DATABASE-NAME por el nombre de la base de datos.
Notas de uso:
Para limitar la lista, especifica la marca
--filter. Por ejemplo:--filter="metadata.name:example-db"solo enumera las operaciones en una base de datos específica.--filter="error:*"solo enumera las operaciones de copia de seguridad que fallaron.
Para obtener información sobre la sintaxis de los filtros, consulta Filtros de temas de gcloud. Para obtener información sobre cómo filtrar las operaciones de copia de seguridad, consulta el campo
filteren ListBackupOperationsRequest.La marca
--typeno distingue mayúsculas de minúsculas.
El resultado es similar al siguiente:
OPERATION_ID STATEMENTS DONE @TYPE _auto_op_123456 CREATE INDEX SingersByFirstLastName ON Singers(FirstName, LastName) False UpdateDatabaseDdlMetadata CREATE INDEX SongsBySingerAlbumSongName ON Songs(SingerId, AlbumId, SongName), INTERLEAVE IN Albums _auto_op_234567 True CreateDatabaseMetadataEjecuta
gcloud spanner operations describe:gcloud spanner operations describe \ --instance=INSTANCE-NAME \ --database=DATABASE-NAME \ projects/PROJECT-NAME/instances/INSTANCE-NAME/databases/DATABASE-NAME/operations/OPERATION_ID
Reemplaza lo siguiente:
- INSTANCE-NAME: Es el nombre de la instancia de Spanner.
- DATABASE-NAME: Es el nombre de la base de datos de Spanner.
- PROJECT-NAME: Es el nombre del proyecto.
- OPERATION-ID: Es el ID de la operación que deseas verificar.
La sección
progressen el resultado muestra el porcentaje de la operación que se completó. El resultado es similar al siguiente:done: true ... progress: - endTime: '2021-01-22T21:58:42.912540Z' progressPercent: 100 startTime: '2021-01-22T21:58:11.053996Z' - progressPercent: 67 startTime: '2021-01-22T21:58:11.053996Z' ...
REST v1
Obtén el ID de la operación:
gcloud spanner operations list --instance=INSTANCE-NAME
--database=DATABASE-NAME --type=DATABASE_UPDATE_DDL
Reemplaza lo siguiente:
- INSTANCE-NAME por el nombre de la instancia de Spanner.
- DATABASE-NAME por el nombre de la base de datos.
Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:
- PROJECT-ID: El ID del proyecto.
- INSTANCE-ID: El ID de la instancia.
- DATABASE-ID: Es el ID de la base de datos.
- OPERATION-ID: Es el ID de la operación.
Método HTTP y URL:
GET https://spanner.googleapis.com/v1/projects/PROJECT-ID/instances/INSTANCE-ID/databases/DATABASE-ID/operations/OPERATION-ID
Para enviar tu solicitud, expande una de estas opciones:
Deberías recibir una respuesta JSON similar a la que se muestra a continuación:
{
...
"progress": [
{
"progressPercent": 100,
"startTime": "2023-05-27T00:52:27.366688Z",
"endTime": "2023-05-27T00:52:30.184845Z"
},
{
"progressPercent": 100,
"startTime": "2023-05-27T00:52:30.184845Z",
"endTime": "2023-05-27T00:52:40.750959Z"
}
],
...
"done": true,
"response": {
"@type": "type.googleapis.com/google.protobuf.Empty"
}
}
Para gcloud y REST, puedes encontrar el progreso de cada sentencia de reabastecimiento de índices
en la sección progress. Para cada sentencia en el array de sentencias,
hay un campo correspondiente en el array de progreso. Este orden del array de progreso
corresponde al orden del array de sentencias. Una vez que estén disponibles, los campos startTime, progressPercent y endTime se completarán según corresponda.
Ten en cuenta que el resultado no muestra un tiempo estimado para que se complete el progreso del reabastecimiento.
Si la operación tarda demasiado, puedes cancelarla. Para obtener más información, consulta Cancela la creación de índices.
Situaciones en las que se puede ver el progreso del reabastecimiento de índices
Existen diferentes situaciones que puedes encontrar cuando intentas verificar el progreso de un reabastecimiento de índices. Las declaraciones de creación de índices que requieren un reabastecimiento de índices forman parte de las operaciones de actualización de esquemas, y puede haber varias declaraciones que formen parte de una operación de actualización de esquemas.
La primera situación es la más sencilla, que es cuando la sentencia de creación del índice
es la primera sentencia en la operación de actualización del esquema. Dado que la declaración de creación de índice
es la primera, es la primera que se procesa y ejecuta debido
al orden de ejecución.
De inmediato, el campo startTime de la declaración de creación del índice se
completará con la hora de inicio de la operación de actualización del esquema. A continuación, el campo progressPercent de la declaración de creación del índice se propaga cuando el progreso del reabastecimiento del índice es superior al 0%. Por último, el campo endTime se propaga una vez
que se confirma la sentencia.
La segunda situación es cuando la sentencia de creación de índice no es la primera
sentencia en la operación de actualización del esquema. No se completará ningún campo relacionado con la sentencia de creación del índice hasta que se hayan confirmado las sentencias anteriores debido al orden de ejecución.
Al igual que en la situación anterior, una vez que se confirman las declaraciones anteriores, primero se propaga el campo startTime de la declaración de creación del índice, seguido del campo progressPercent. Por último, el campo endTime se completa una vez que
la sentencia termina de confirmarse.
Cancela la creación de índices
Puedes usar Google Cloud CLI para cancelar la creación de índices. Para recuperar una lista de
operaciones de actualización de esquemas de una base de datos de Spanner, usa el
comando gcloud spanner operations list y, además, incluye
la opción --filter:
gcloud spanner operations list \
--instance=INSTANCE \
--database=DATABASE \
--filter="@TYPE:UpdateDatabaseDdlMetadata"
Busca el OPERATION_ID de la operación que deseas cancelar y, luego, usa el comando gcloud spanner operations cancel con el fin de cancelarla:
gcloud spanner operations cancel OPERATION_ID \
--instance=INSTANCE \
--database=DATABASE
Visualiza los índices existentes
Para ver información sobre los índices existentes en una base de datos, puedes usar la consola deGoogle Cloud o Google Cloud CLI:
Console
Ve a la página Instancias de Spanner en la consola de Google Cloud .
Haz clic en el nombre de la instancia que deseas ver.
En el panel izquierdo, haz clic en la base de datos que desea ver y, luego, en la tabla que deseas visualizar.
Haz clic en la pestaña Índices. En la consola de Google Cloud , se muestra una lista de índices.
De manera opcional, para obtener detalles sobre un índice, como las columnas que incluye, haz clic en el nombre del índice.
gcloud
Usa el comando gcloud spanner databases ddl describe:
gcloud spanner databases ddl describe DATABASE \
--instance=INSTANCE
gcloud CLI imprime las declaraciones del lenguaje de definición de datos (DDL)
para crear las tablas y los índices de la base de datos. Las declaraciones CREATE
INDEX describen los índices existentes. Por ejemplo:
--- |-
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)
Realiza consultas con un índice específico
En las siguientes secciones, se explica cómo especificar un índice en una instrucción de SQL y
con la interfaz de lectura para Spanner. En los ejemplos de estas secciones, se supone que agregaste una columna MarketingBudget a la tabla Albums y que creaste un índice llamado AlbumsByAlbumTitle:
GoogleSQL
CREATE TABLE Albums (
SingerId INT64 NOT NULL,
AlbumId INT64 NOT NULL,
AlbumTitle STRING(MAX),
MarketingBudget INT64,
) PRIMARY KEY (SingerId, AlbumId),
INTERLEAVE IN PARENT Singers ON DELETE CASCADE;
CREATE INDEX AlbumsByAlbumTitle ON Albums(AlbumTitle);
PostgreSQL
CREATE TABLE Albums (
SingerId BIGINT NOT NULL,
AlbumId BIGINT NOT NULL,
AlbumTitle VARCHAR,
MarketingBudget BIGINT,
PRIMARY KEY (SingerId, AlbumId)
) INTERLEAVE IN PARENT Singers ON DELETE CASCADE;
CREATE INDEX AlbumsByAlbumTitle ON Albums(AlbumTitle);
Especifica un índice en una instrucción de SQL
Cuando usas SQL para consultar una tabla de Spanner, Spanner utiliza automáticamente
cualquier índice que pueda hacer que la consulta sea más eficaz. Por lo tanto,
no necesitas especificar un índice para las consultas en SQL. Sin embargo,
para las consultas que son esenciales en tu carga de trabajo, Google te aconseja que uses
directivas FORCE_INDEX en tus sentencias de SQL para obtener un rendimiento más coherente.
En algunos casos, Spanner puede elegir un índice que aumente la latencia de la consulta. Si sigues los [pasos para solucionar problemas de regresiones de rendimiento][troubleshooting-query-performance-regressions] y decides probar un índice diferente para la consulta, puedes especificar el índice como parte de tu consulta.
Para especificar un índice en una instrucción de SQL, usa la sugerencia FORCE_INDEX
para proporcionar una directiva de índice. Las directivas de índice usan la sintaxis que se menciona a continuación:
GoogleSQL
FROM MyTable@{FORCE_INDEX=MyTableIndex}
PostgreSQL
FROM MyTable /*@ FORCE_INDEX = MyTableIndex */
También puedes usar una directiva de índice para indicarle a Spanner que analice la tabla base en lugar de usar un índice:
GoogleSQL
FROM MyTable@{FORCE_INDEX=_BASE_TABLE}
PostgreSQL
FROM MyTable /*@ FORCE_INDEX = _BASE_TABLE */
Puedes usar una directiva de índice para indicarle a Spanner que analice un índice en una tabla con esquemas con nombre:
GoogleSQL
FROM NAMED_SCHEMA_NAME.TABLE_NAME@{FORCE_INDEX="NAMED_SCHEMA_NAME.TABLE_INDEX_NAME"}
PostgreSQL
FROM NAMED_SCHEMA_NAME.TABLE_NAME /*@ FORCE_INDEX = TABLE_INDEX_NAME */
En el siguiente ejemplo, se muestra una consulta en SQL que especifica un índice:
GoogleSQL
SELECT AlbumId, AlbumTitle, MarketingBudget
FROM Albums@{FORCE_INDEX=AlbumsByAlbumTitle}
WHERE AlbumTitle >= "Aardvark" AND AlbumTitle < "Goo";
PostgreSQL
SELECT AlbumId, AlbumTitle, MarketingBudget
FROM Albums /*@ FORCE_INDEX = AlbumsByAlbumTitle */
WHERE AlbumTitle >= 'Aardvark' AND AlbumTitle < 'Goo';
Una directiva de índice puede forzar al procesador de consultas de Spanner a leer
columnas adicionales que requiere la consulta, pero que no se almacenan en el índice.
El procesador de consultas recupera estas columnas mediante la unión del índice y la tabla base. Para evitar esta unión adicional, usa una
cláusula STORING (bases de datos de dialecto de GoogleSQL) o una cláusula INCLUDE (bases de datos de dialecto de PostgreSQL) para
almacenar las columnas adicionales en el índice.
En el ejemplo anterior, la columna MarketingBudget no se almacena en el índice, pero la consulta en SQL selecciona esta columna. Como resultado,
Spanner debe buscar la columna MarketingBudget en la tabla base
y, luego, unirla con los datos del índice para mostrar los resultados de la consulta.
Spanner genera un error si la directiva de índice tiene alguno de los siguientes problemas:
- El índice no existe.
- El índice está en una tabla base diferente.
- A la consulta le falta una expresión de filtrado
NULLobligatoria para un índiceNULL_FILTERED.
En los siguientes ejemplos, se muestra cómo escribir y ejecutar consultas que recuperan los valores de AlbumId, AlbumTitle y MarketingBudget mediante el índice AlbumsByAlbumTitle:
C++
C#
Go
Java
Node.js
PHP
Python
Ruby
Especifica un índice en la interfaz de lectura
Cuando usas la interfaz de lectura para Spanner y quieres que Spanner use un índice, debes especificarlo. La interfaz de lectura no selecciona el índice de forma automática.
Además, tu índice debe contener todos los datos que aparecen en los resultados de la consulta, sin incluir las columnas que forman parte de la clave primaria. Esta restricción existe porque la interfaz de lectura no es compatible con combinaciones entre el índice y la tabla base. Si necesitas incluir otras columnas en los resultados de la consulta, puedes elegir entre las siguientes opciones:
- Usa una cláusula
STORINGoINCLUDEpara almacenar las columnas adicionales en el índice. - Realiza consultas sin incluir las columnas adicionales y usa las claves primarias para enviar otra consulta que lea las columnas adicionales.
Spanner devuelve los valores del índice en orden ascendente por clave de índice. Para recuperar los valores en orden descendente, sigue estos pasos:
Anota la clave de índice con
DESC. Por ejemplo:CREATE INDEX AlbumsByAlbumTitle ON Albums(AlbumTitle DESC);La anotación
DESCse aplica a una sola clave de índice. Si el índice incluye más de una clave y quieres que los resultados de la consulta aparezcan en orden descendente según todas las claves, incluye una anotaciónDESCpara cada clave.Si la lectura especifica un rango de clave, asegúrate de que el rango de clave también esté en orden descendente. En otras palabras, el valor de la clave de inicio debe ser mayor que el valor de la clave de cierre.
En el siguiente ejemplo, se muestra cómo recuperar los valores de AlbumId y AlbumTitle con el índice AlbumsByAlbumTitle:
C++
C#
Go
Java
Node.js
PHP
Python
Ruby
Crea un índice para las operaciones de análisis solo de índices
De manera opcional, puedes usar la cláusula STORING (para bases de datos de dialecto de GoogleSQL) o la cláusula INCLUDE (para bases de datos de dialecto de PostgreSQL) para almacenar una copia de una columna en el
índice. Este tipo de índice proporciona ventajas para las consultas y las llamadas de operación lectura que usan el índice, a costa de usar almacenamiento adicional:
- Las consultas en SQL que usan el índice y seleccionan las columnas almacenadas en la cláusula
STORINGoINCLUDEno requieren una unión adicional a la tabla base. - Las llamadas
read()que usan el índice pueden leer las columnas almacenadas por la cláusulaSTORING/INCLUDE.
Por ejemplo, supongamos que creaste una versión alternativa de AlbumsByAlbumTitle
que almacena una copia de la columna MarketingBudget en el índice (observa la
cláusula STORING o INCLUDE en negrita):
GoogleSQL
CREATE INDEX AlbumsByAlbumTitle2 ON Albums(AlbumTitle) STORING (MarketingBudget);
PostgreSQL
CREATE INDEX AlbumsByAlbumTitle2 ON Albums(AlbumTitle) INCLUDE (MarketingBudget);
Con el índice AlbumsByAlbumTitle anterior, Spanner debe unir el índice
con la tabla base y, luego, recuperar la columna de la tabla base. Con el nuevo índice AlbumsByAlbumTitle2, Spanner lee la columna directamente desde el índice, lo que es más eficiente.
Si usas la interfaz de lectura, en lugar de SQL, el nuevo índice AlbumsByAlbumTitle2 también te permite leer directamente la columna MarketingBudget:
C++
C#
Go
Java
Node.js
PHP
Python
Ruby
Modifica un índice
Puedes usar la sentencia ALTER INDEX para agregar columnas adicionales
a un índice existente o descartar columnas. Esto
puede actualizar la lista de columnas definida por la cláusula STORING
(bases de datos de dialecto de GoogleSQL) o la cláusula INCLUDE (bases de datos de dialecto de PostgreSQL) cuando creas el
índice. No puedes usar esta sentencia para agregar columnas a la clave de índice ni para descartar columnas de ella. Por ejemplo, en lugar de crear un índice nuevo AlbumsByAlbumTitle2, puedes usar ALTER INDEX para agregar una columna a AlbumsByAlbumTitle, como se muestra en el siguiente ejemplo:
GoogleSQL
ALTER INDEX AlbumsByAlbumTitle ADD STORED COLUMN MarketingBudget
PostgreSQL
ALTER INDEX AlbumsByAlbumTitle ADD INCLUDE COLUMN MarketingBudget
Cuando agregas una columna nueva a un índice existente, Spanner
usa un proceso de reabastecimiento en segundo plano. Mientras se realiza el reabastecimiento,
la columna del índice no se puede leer, por lo que es posible que no obtengas el aumento de rendimiento
esperado. Puedes usar el comando gcloud spanner operations
para enumerar la operación de larga duración y ver su estado.
Para obtener más información, consulta describe operation.
También puedes usar cancel operation para cancelar una operación en ejecución.
Una vez que se completa el reabastecimiento, Spanner agrega la columna al índice. A medida que el índice crece, esto puede ralentizar las consultas que lo usan.
En el siguiente ejemplo, se muestra cómo quitar una columna de un índice:
GoogleSQL
ALTER INDEX AlbumsByAlbumTitle DROP STORED COLUMN MarketingBudget
PostgreSQL
ALTER INDEX AlbumsByAlbumTitle DROP INCLUDE COLUMN MarketingBudget
Índice de valores NULL
De forma predeterminada, Spanner indexa los valores NULL. Por ejemplo, recupera la definición del índice SingersByFirstLastName en la tabla Singers:
CREATE INDEX SingersByFirstLastName ON Singers(FirstName, LastName);
Todas las filas de Singers se indexan, incluso si FirstName o LastName, o ambos, sean NULL.
Cuando se indexan los valores NULL, puedes realizar consultas en SQL y lecturas eficientes
en los datos que incluyen valores NULL. Por ejemplo, usa esta sentencia de consulta en SQL
para encontrar todos los Singers con un NULL FirstName:
GoogleSQL
SELECT s.SingerId, s.FirstName, s.LastName
FROM Singers@{FORCE_INDEX=SingersByFirstLastName} AS s
WHERE s.FirstName IS NULL;
PostgreSQL
SELECT s.SingerId, s.FirstName, s.LastName
FROM Singers /* @ FORCE_INDEX = SingersByFirstLastName */ AS s
WHERE s.FirstName IS NULL;
Ordena por valores NULL
Spanner ordena NULL como el valor más pequeño para cualquier tipo determinado. Para una columna en orden ascendente (ASC), los valores NULL se ordenan primero. Para una columna en orden descendente (DESC), los valores NULL se ordenan por último.
Inhabilita la indexación de valores NULL
GoogleSQL
Para inhabilitar la indexación de valores nulos, agrega la palabra clave NULL_FILTERED a la definición del índice. Los índices NULL_FILTERED son muy útiles para indexar columnas dispersas, en la mayoría de las filas contienen un valor NULL. En estos casos, el índice NULL_FILTERED puede ser bastante más pequeño y más eficaz de mantener que un índice normal que incluya valores NULL.
Esta es una definición alternativa de SingersByFirstLastName que no indexa valores NULL:
CREATE NULL_FILTERED INDEX SingersByFirstLastNameNoNulls
ON Singers(FirstName, LastName);
La palabra clave NULL_FILTERED se aplica a todas las columnas de clave de índice. No puedes especificar el filtro NULL por columna.
PostgreSQL
Para filtrar las filas con valores nulos en una o más columnas indexadas, usa el
predicado WHERE COLUMN IS NOT NULL.
Los índices filtrados por valores nulos son especialmente útiles para indexar columnas dispersas, en las que la mayoría de las filas contienen un valor NULL. En estos casos, el índice filtrado por nulos puede ser mucho más pequeño y eficiente de mantener que un índice normal que incluya valores NULL.
Esta es una definición alternativa de SingersByFirstLastName que no indexa valores NULL:
CREATE INDEX SingersByFirstLastNameNoNulls
ON Singers(FirstName, LastName)
WHERE FirstName IS NOT NULL
AND LastName IS NOT NULL;
Filtrar los valores NULL evita que Spanner los use en algunas
consultas. Por ejemplo, Spanner no usa el índice para esta consulta,
ya que el índice omite las filas Singers para las que LastName es NULL. Como
resultado, el uso del índice evitaría que la consulta devuelva las filas correctas:
GoogleSQL
FROM Singers@{FORCE_INDEX=SingersByFirstLastNameNoNulls}
WHERE FirstName = "John";
PostgreSQL
FROM Singers /*@ FORCE_INDEX = SingersByFirstLastNameNoNulls */
WHERE FirstName = 'John';
Para habilitar Spanner para que use el índice, debes volver a escribir la consulta de modo que excluya las filas que también se excluyen del índice:
GoogleSQL
SELECT FirstName, LastName
FROM Singers@{FORCE_INDEX=SingersByFirstLastNameNoNulls}
WHERE FirstName = 'John' AND LastName IS NOT NULL;
PostgreSQL
SELECT FirstName, LastName
FROM Singers /*@ FORCE_INDEX = SingersByFirstLastNameNoNulls */
WHERE FirstName = 'John' AND LastName IS NOT NULL;
Indexa campos de proto
Usa columnas generadas para indexar
campos en búferes de protocolo almacenados en columnas PROTO, siempre que los campos
que se indexan usen los tipos de datos primitivos o ENUM.
Si defines un índice en un campo de mensaje de protocolo, no puedes modificar ni quitar ese campo del esquema de proto. Para obtener más información, consulta Actualizaciones de esquemas que contienen un índice en campos proto.
A continuación, se muestra un ejemplo de la tabla Singers con una columna de mensaje proto
SingerInfo. Para definir un índice en el campo nationality de PROTO,
debes crear una columna generada almacenada:
GoogleSQL
CREATE PROTO BUNDLE (googlesql.example.SingerInfo, googlesql.example.SingerInfo.Residence);
CREATE TABLE Singers (
SingerId INT64 NOT NULL,
...
SingerInfo googlesql.example.SingerInfo,
SingerNationality STRING(MAX) AS (SingerInfo.nationality) STORED
) PRIMARY KEY (SingerId);
Tiene la siguiente definición del tipo de proto googlesql.example.SingerInfo:
GoogleSQL
package googlesql.example;
message SingerInfo {
optional string nationality = 1;
repeated Residence residence = 2;
message Residence {
required int64 start_year = 1;
optional int64 end_year = 2;
optional string city = 3;
optional string country = 4;
}
}
Luego, define un índice en el campo nationality del proto:
GoogleSQL
CREATE INDEX SingersByNationality ON Singers(SingerNationality);
La siguiente consulta en SQL lee datos con el índice anterior:
GoogleSQL
SELECT s.SingerId, s.FirstName
FROM Singers AS s
WHERE s.SingerNationality = "English";
Notas:
- Usa una directiva de índice para acceder a los índices en los campos de las columnas de búfer de protocolo.
- No puedes crear un índice en campos de búfer de protocolo repetidos.
Actualizaciones de esquemas que contienen un índice en campos de proto
Si defines un índice en un campo de mensaje de protocolo, no puedes modificar ni quitar ese campo del esquema de proto. Esto se debe a que, después de definir el índice, se realiza una verificación de tipos cada vez que se actualiza el esquema. Spanner captura la información de tipo para todos los campos de la ruta de acceso que se usan en la definición del índice.
Índices únicos
Los índices se pueden declarar como UNIQUE. Los índices UNIQUE agregan una restricción a los datos que se indexan y que prohíben las entradas duplicadas para una clave de índice determinada.
Spanner aplica esta restricción en el momento de la confirmación de la transacción.
En particular, no se confirmarán las transacciones que harían que existan varias entradas de índice para la misma clave.
Si una tabla contiene datos que no son UNIQUE en ella, cuando intentes crear un índice UNIQUE en ella, fallará.
Una nota sobre los índices UNIQUE NULL_FILTERED
Un índice UNIQUE NULL_FILTERED no fuerza la unicidad de la clave de índice cuando una de las partes clave del índice, como mínimo, es NULL.
Por ejemplo, supongamos que creaste el siguiente índice y tabla:
GoogleSQL
CREATE TABLE ExampleTable (
Key1 INT64 NOT NULL,
Key2 INT64,
Key3 INT64,
Col1 INT64,
) PRIMARY KEY (Key1, Key2, Key3);
CREATE UNIQUE NULL_FILTERED INDEX ExampleIndex ON ExampleTable (Key1, Key2, Col1);
PostgreSQL
CREATE TABLE ExampleTable (
Key1 BIGINT NOT NULL,
Key2 BIGINT,
Key3 BIGINT,
Col1 BIGINT,
PRIMARY KEY (Key1, Key2, Key3)
);
CREATE UNIQUE INDEX ExampleIndex ON ExampleTable (Key1, Key2, Col1)
WHERE Key1 IS NOT NULL
AND Key2 IS NOT NULL
AND Col1 IS NOT NULL;
Las siguientes dos filas en ExampleTable tienen los mismos valores para las claves de índice secundarias Key1, Key2 y Col1:
1, NULL, 1, 1
1, NULL, 2, 1
Debido a que Key2 es NULL y el índice tiene un filtro nulo, las filas no estarán
presentes en el índice ExampleIndex. Como no se insertan en el índice, este no las rechazará por infringir la unicidad en (Key1, Key2,
Col1).
Si deseas que el índice aplique la unicidad de los valores de la tupla (Key1,
Key2, Col1), debes anotar Key2 con NOT NULL en la definición de la tabla
o crear el índice sin filtrar los valores nulos.
Crea un índice basado en una expresión escalar
Un índice de expresión te permite crear un índice basado en una expresión escalar que se aplica a una o más columnas de la tabla. Esto es beneficioso porque elimina la necesidad de crear y mantener una columna generada dedicada en tu tabla solo con fines de indexación.
Los índices en columnas generadas y los índices de expresión pueden ser útiles para indexar campos específicos dentro de una columna JSON. Puedes crear un índice en un valor extraído de un objeto JSON, lo que permite que el optimizador de consultas realice búsquedas de manera eficiente en función de ese valor.
En este ejemplo, se crea una columna generada llamada VenueCity, que se basa en el
campo city dentro del JSON, con el único propósito de colocarla en
un índice:
GoogleSQL
CREATE TABLE Venues (
Id INT64 NOT NULL,
VenueData JSON,
VenueCity STRING AS (JSON_VALUE(VenueData.address.city))
) PRIMARY KEY (Id);
CREATE INDEX VenuesByCity ON Venues(VenueCity);
PostgreSQL
CREATE TABLE Venues (
Id BIGINT NOT NULL PRIMARY KEY,
VenueData JSONB,
VenueCity VARCHAR GENERATED ALWAYS AS (VenueData -> 'address' ->> 'city')
);
CREATE INDEX VenuesByCity ON Venues(VenueCity);
Para lograr esto de manera más eficiente, puedes definir el índice directamente, y Spanner controla el mecanismo subyacente de forma implícita:
GoogleSQL
CREATE TABLE Venues (
Id INT64 NOT NULL,
VenueData JSON
) PRIMARY KEY (Id);
CREATE INDEX VenuesByCity ON Venues((JSON_VALUE(VenueData.address.city)));
PostgreSQL
CREATE TABLE Venues (
Id BIGINT NOT NULL PRIMARY KEY,
VenueData JSONB
);
CREATE INDEX VenuesByCity ON Venues((VenueData -> 'address' ->> 'city'));
En ambos casos, tu consulta puede usar el índice VenuesByCity para lograr una ejecución más rápida:
GoogleSQL
SELECT Id
FROM Venues
WHERE JSON_VALUE(VenueData.address.city) = 'Seattle';
PostgreSQL
SELECT Id
FROM Venues
WHERE VenueData -> 'address' ->> 'city' = 'Seattle';
Los índices de expresión pueden tener columnas que sean una combinación de expresiones y referencias directas a columnas. Esto permite que más consultas usen el índice para una ejecución más rápida.
GoogleSQL
CREATE TABLE Venues (
Id INT64 NOT NULL,
VenueName STRING(MAX),
VenueData JSON
) PRIMARY KEY (Id);
CREATE INDEX VenuesByCity ON Venues(
VenueName,
(JSON_VALUE(VenueData.address.city)),
(JSON_VALUE(VenueData.address.state))
);
PostgreSQL
CREATE TABLE Venues (
Id BIGINT NOT NULL PRIMARY KEY,
VenueName VARCHAR,
VenueData JSONB
);
CREATE INDEX VenuesIdx ON Venues(
VenueName,
(VenueData -> 'address' ->> 'city'),
(VenueData -> 'address' ->> 'state'),
);
Descarta un índice
Usa la sentencia DROP INDEX para descartar un índice secundario de
tu esquema.
Para descartar el índice llamado SingersByFirstLastName, usa la siguiente declaración:
DROP INDEX SingersByFirstLastName;
Indexa para realizar análisis más rápidos
Cuando Spanner necesita realizar un análisis de tabla (en lugar de una búsqueda indexada) para recuperar valores de una o más columnas, puedes recibir resultados más rápidos si existe un índice para esas columnas y en el orden especificado por la consulta. Si realizas consultas que requieren análisis con frecuencia, considera crear índices secundarios para que estos análisis se realicen de manera más eficiente.
En particular, si necesitas que Spanner analice con frecuencia la clave primaria de una tabla o algún otro índice en orden inverso, puedes aumentar su eficiencia con un índice secundario que haga explícito el orden elegido.
Por ejemplo, la siguiente consulta siempre muestra un resultado rápido, aunque
Spanner deba analizar Songs para encontrar el valor más bajo de
SongId:
SELECT SongId FROM Songs LIMIT 1;
SongId es la clave primaria de la tabla, almacenada (como con todas las claves primarias)
en orden ascendente. Spanner puede analizar el índice de esa clave y encontrar
el primer resultado con rapidez.
Sin embargo, sin la ayuda de un índice secundario, la siguiente consulta no se
devolvería tan rápido, en especial si Songs contiene muchos datos:
SELECT SongId FROM Songs ORDER BY SongId DESC LIMIT 1;
Aunque SongId es la clave primaria de la tabla, Spanner no tiene
forma de recuperar el valor más alto de la columna sin recurrir a un análisis completo
de la tabla.
Si agregas el siguiente índice, esta consulta devolverá resultados con mayor rapidez:
CREATE INDEX SongIdDesc On Songs(SongId DESC);
Con este índice, Spanner lo usaría para devolver un resultado de la segunda consulta mucho más rápido.
¿Qué sigue?
- Obtén más información sobre las prácticas recomendadas de SQL para Spanner.
- Comprende los planes de ejecución de consultas para Spanner.
- Obtén información para solucionar problemas de regresiones de rendimiento en consultas en SQL.