Esta página se ha traducido con Cloud Translation API.

Introducción a Spanner en Ruby
Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Objetivos

Este tutorial lo guiará a través de los siguientes pasos utilizando la biblioteca cliente Spanner para Ruby:

Cree una instancia y una base de datos de Spanner.
Escribir, leer y ejecutar consultas SQL sobre datos de la base de datos.
Actualizar el esquema de la base de datos.
Actualizar datos mediante una transacción de lectura y escritura.
Agregar un índice secundario a la base de datos.
Utilice el índice para leer y ejecutar consultas SQL sobre los datos.
Recupere datos mediante una transacción de solo lectura.

Costos

Este tutorial utiliza Spanner, que es un componente facturable deGoogle CloudPara obtener información sobre el costo de usar Spanner, consulte Precios .

Antes de empezar

Complete los pasos descritos en Configuración , que cubren la creación y configuración de un valor predeterminado. Google Cloud proyecto, habilitar la facturación, habilitar la API de Cloud Spanner y configurar OAuth 2.0 para obtener credenciales de autenticación para usar la API de Cloud Spanner.

En particular, asegúrese de ejecutar gcloud auth application-default login para configurar su entorno de desarrollo local con credenciales de autenticación.

Nota: Si no planea conservar los recursos que cree en este tutorial, considere crear uno nuevo. Google Cloud proyecto en lugar de seleccionar uno existente. Tras finalizar el tutorial, puede eliminar el proyecto y así eliminar todos los recursos asociados.

Prepare su entorno Ruby local

Instale lo siguiente en su máquina de desarrollo si aún no está instalado:
- Rubí
- Empaquetador
Clone el repositorio de aplicaciones de muestra en su máquina local:
```
git clone https://github.com/GoogleCloudPlatform/ruby-docs-samples
```
Alternativamente, puede descargar la muestra como un archivo zip y extraerlo.
Cambie al directorio que contiene el código de muestra de Spanner:
```
cd ruby-docs-samples/spanner/
```
Instalar dependencias:
```
bundle install
```
Establezca la variable de entorno GOOGLE_CLOUD_PROJECT en su Google CloudID del proyecto:
```
export GOOGLE_CLOUD_PROJECT=[MY_PROJECT_ID]
```

Crear una instancia

Al usar Spanner por primera vez, debe crear una instancia, que consiste en una asignación de recursos que utilizan las bases de datos de Spanner. Al crear una instancia, se elige una configuración que determina dónde se almacenan los datos y el número de nodos a usar, lo que determina la cantidad de recursos de servicio y almacenamiento en la instancia.

Ejecute el siguiente comando para crear una instancia de Spanner en la región us-central1 con 1 nodo:

gcloud spanner instances create test-instance --config=regional-us-central1 \
    --description="Test Instance" --nodes=1

Tenga en cuenta que esto crea una instancia con las siguientes características:

ID de instancia test-instance
Nombre para mostrar Test Instance
Configuración de instancia regional-us-central1 (las configuraciones regionales almacenan datos en una región, mientras que las configuraciones multirregionales distribuyen datos entre varias regiones. Para obtener más información, consulte Acerca de las instancias ).
Cantidad de nodos de 1 ( node_count corresponde a la cantidad de recursos de servicio y almacenamiento disponibles para las bases de datos en la instancia. Obtenga más información en Nodos y unidades de procesamiento ).

Deberías ver:

Creating instance...done.

Mirar archivos de muestra

El repositorio de muestras contiene un ejemplo que muestra cómo utilizar Spanner con Ruby.

Revise el archivo spanner_samples.rb , que muestra cómo usar Spanner. El código muestra cómo crear y usar una nueva base de datos. Los datos utilizan el esquema de ejemplo que se muestra en la página Esquema y modelo de datos .

Crear una base de datos

Google SQL

bundle exec ruby spanner_samples.rb create_database test-instance example-db

PostgreSQL

bundle exec ruby spanner_postgresql_create_database.rb postgresql_create_database MY_PROJECT_ID test-instance example-db

Deberías ver:

Created database example-db on instance test-instance

El siguiente código crea una base de datos y dos tablas en la base de datos.

Google SQL

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"
require "google/cloud/spanner/admin/database"

database_admin_client = Google::Cloud::Spanner::Admin::Database.database_admin

instance_path = database_admin_client.instance_path project: project_id, instance: instance_id

job = database_admin_client.create_database parent: instance_path,
                                            create_statement: "CREATE DATABASE `#{database_id}`",
                                            extra_statements: [
                                              "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"
                                            ]

puts "Waiting for create database operation to complete"

job.wait_until_done!

puts "Created database #{database_id} on instance #{instance_id}"

PostgreSQL

require "google/cloud/spanner"
require "google/cloud/spanner/admin/database"

def postgresql_create_database project_id:, instance_id:, database_id:
  # project_id  = "Your Google Cloud project ID"
  # instance_id = "Your Spanner instance ID"
  # database_id = "Your Spanner database ID"

  database_admin_client = Google::Cloud::Spanner::Admin::Database.database_admin project: project_id

  instance_path = database_admin_client.instance_path project: project_id, instance: instance_id

  job = database_admin_client.create_database parent: instance_path,
                                              create_statement: "CREATE DATABASE \"#{database_id}\"",
                                              database_dialect: :POSTGRESQL

  puts "Waiting for create database operation to complete"

  job.wait_until_done!

  puts "Created database #{database_id} on instance #{instance_id}"
end

El siguiente paso es escribir datos en su base de datos.

Crear un cliente de base de datos

Antes de poder realizar operaciones de lectura o escritura, debe crear un Client . Un Client es como una conexión a una base de datos: todas sus interacciones con Spanner deben pasar por Client . Normalmente, se crea un Client al iniciar la aplicación y luego se Client para leer, escribir y ejecutar transacciones. El siguiente código muestra cómo crear un cliente.

# Imports the Google Cloud client library
require "google/cloud/spanner"

# Your Google Cloud Platform project ID
project_id = "YOUR_PROJECT_ID"

# Instantiates a client
spanner = Google::Cloud::Spanner.new project: project_id

# Your Cloud Spanner instance ID
instance_id = "my-instance"

# Your Cloud Spanner database ID
database_id = "my-database"

# Gets a reference to a Cloud Spanner instance database
database_client = spanner.client instance_id, database_id

# Execute a simple SQL statement
results = database_client.execute_query "SELECT 1"
results.rows.each do |row|
  puts row
end

Lea más en la referencia Client .

Escribir datos con DML

Puede insertar datos utilizando el lenguaje de manipulación de datos (DML) en una transacción de lectura y escritura.

Utilice el método execute_update() para ejecutar una declaración DML.

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id
row_count = 0

client.transaction do |transaction|
  row_count = transaction.execute_update(
    "INSERT INTO Singers (SingerId, FirstName, LastName) VALUES
     (12, 'Melissa', 'Garcia'),
     (13, 'Russell', 'Morales'),
     (14, 'Jacqueline', 'Long'),
     (15, 'Dylan', 'Shaw'),
     (16, 'Billie', 'Eillish'),
     (17, 'Judy', 'Garland'),
     (18, 'Taylor', 'Swift'),
     (19, 'Miley', 'Cyrus'),
     (20, 'Michael', 'Jackson'),
     (21, 'Ariana', 'Grande'),
     (22, 'Elvis', 'Presley'),
     (23, 'Kanye', 'West'),
     (24, 'Lady', 'Gaga'),
     (25, 'Nick', 'Jonas')"
  )
end

puts "#{row_count} records inserted."

Ejecute la muestra utilizando el argumento write_using_dml .

bundle exec ruby spanner_samples.rb write_using_dml test-instance example-db

Deberías ver:

 4 records inserted.

Escribir datos con mutaciones

También puedes insertar datos usando mutaciones .

Los datos se escriben mediante un objeto Client . El método Client#commit crea y confirma una transacción para escrituras que se ejecutan de forma automática en un único punto lógico en las columnas, filas y tablas de una base de datos.

Este código muestra cómo escribir los datos usando mutaciones:

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

client.commit do |c|
  c.insert "Singers", [
    { SingerId: 1, FirstName: "Marc",     LastName: "Richards" },
    { SingerId: 2, FirstName: "Catalina", LastName: "Smith"    },
    { SingerId: 3, FirstName: "Alice",    LastName: "Trentor"  },
    { SingerId: 4, FirstName: "Lea",      LastName: "Martin"   },
    { SingerId: 5, FirstName: "David",    LastName: "Lomond"   }
  ]
  c.insert "Albums", [
    { SingerId: 1, AlbumId: 1, AlbumTitle: "Total Junk" },
    { SingerId: 1, AlbumId: 2, AlbumTitle: "Go, Go, Go" },
    { SingerId: 2, AlbumId: 1, AlbumTitle: "Green" },
    { SingerId: 2, AlbumId: 2, AlbumTitle: "Forever Hold Your Peace" },
    { SingerId: 2, AlbumId: 3, AlbumTitle: "Terrified" }
  ]
end

puts "Inserted data"

Ejecute la muestra utilizando el argumento insert_data .

bundle exec ruby spanner_samples.rb insert_data test-instance example-db

Deberías ver:

Inserted data

Consultar datos mediante SQL

Spanner admite una interfaz SQL para leer datos, a la que puedes acceder en la línea de comandos mediante la CLI de Google Cloud o mediante programación mediante la biblioteca cliente Spanner para Ruby.

En la línea de comandos

Ejecute la siguiente declaración SQL para leer los valores de todas las columnas de la tabla Albums :

gcloud spanner databases execute-sql example-db --instance=test-instance \
    --sql='SELECT SingerId, AlbumId, AlbumTitle FROM Albums'

El resultado debería ser:

SingerId AlbumId AlbumTitle
1        1       Total Junk
1        2       Go, Go, Go
2        1       Green
2        2       Forever Hold Your Peace
2        3       Terrified

Utilice la biblioteca cliente Spanner para Ruby

Además de ejecutar una declaración SQL en la línea de comandos, puede emitir la misma declaración SQL mediante programación utilizando la biblioteca cliente Spanner para Ruby.

Utilice el método Client#execute para ejecutar la consulta SQL. Utilice el símbolo Ruby :ColumnName para acceder a los datos de una columna específica desde una fila.

A continuación se explica cómo emitir la consulta y acceder a los datos:

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

client.execute("SELECT SingerId, AlbumId, AlbumTitle FROM Albums").rows.each do |row|
  puts "#{row[:SingerId]} #{row[:AlbumId]} #{row[:AlbumTitle]}"
end

Ejecute la muestra utilizando el argumento query_data .

bundle exec ruby spanner_samples.rb query_data test-instance example-db

Deberías ver el siguiente resultado:

1 1 Total Junk
1 2 Go, Go, Go
2 1 Green
2 2 Forever Hold Your Peace
2 3 Terrified

Consulta utilizando un parámetro SQL

Si su aplicación tiene una consulta que se ejecuta con frecuencia, puede mejorar su rendimiento parametrizándola. La consulta paramétrica resultante puede almacenarse en caché y reutilizarse, lo que reduce los costos de compilación. Para obtener más información, consulte Usar parámetros de consulta para acelerar las consultas que se ejecutan con frecuencia .

A continuación se muestra un ejemplo del uso de un parámetro en la cláusula WHERE para consultar registros que contienen un valor específico para LastName .

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

sql_query = "SELECT SingerId, FirstName, LastName
             FROM Singers
             WHERE LastName = @lastName"

params      = { lastName: "Garcia" }
param_types = { lastName: :STRING }

client.execute(sql_query, params: params, types: param_types).rows.each do |row|
  puts "#{row[:SingerId]} #{row[:FirstName]} #{row[:LastName]}"
end

Ejecute la muestra utilizando el argumento query_with_parameter.

bundle exec ruby spanner_samples.rb query_with_parameter test-instance example-db

Deberías ver el siguiente resultado:

12 Melissa Garcia

Leer datos usando la API de lectura

Además de la interfaz SQL de Spanner, Spanner también admite una interfaz de lectura.

Utilice el método Client#read de la clase Client para leer filas de la base de datos.

Aquí se explica cómo leer los datos:

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

client.read("Albums", [:SingerId, :AlbumId, :AlbumTitle]).rows.each do |row|
  puts "#{row[:SingerId]} #{row[:AlbumId]} #{row[:AlbumTitle]}"
end

Ejecute la muestra utilizando el argumento read_data .

bundle exec ruby spanner_samples.rb read_data test-instance example-db

Debería ver un resultado similar a este:

1 1 Total Junk
1 2 Go, Go, Go
2 1 Green
2 2 Forever Hold Your Peace
2 3 Terrified

Actualizar el esquema de la base de datos

Supongamos que necesita agregar una nueva columna llamada MarketingBudget a la tabla Albums . Agregar una nueva columna a una tabla existente requiere actualizar el esquema de su base de datos. Spanner admite actualizaciones de esquema en una base de datos mientras esta continúa gestionando el tráfico. Las actualizaciones de esquema no requieren desconectar la base de datos ni bloquean tablas o columnas completas; puede seguir escribiendo datos en la base de datos durante la actualización del esquema. Obtenga más información sobre las actualizaciones de esquema admitidas y el rendimiento de los cambios de esquema en Realizar actualizaciones de esquema .

Agregar una columna

Puede agregar una columna en la línea de comando mediante la CLI de Google Cloud o mediante programación utilizando la biblioteca cliente Spanner para Ruby.

En la línea de comandos

Utilice el siguiente comando ALTER TABLE para agregar la nueva columna a la tabla:

Google SQL

gcloud spanner databases ddl update example-db --instance=test-instance \
    --ddl='ALTER TABLE Albums ADD COLUMN MarketingBudget INT64'

PostgreSQL

gcloud spanner databases ddl update example-db --instance=test-instance \
    --ddl='ALTER TABLE Albums ADD COLUMN MarketingBudget BIGINT'

Deberías ver:

Schema updating...done.

Utilice la biblioteca cliente Spanner para Ruby

Utilice el método Database#update de la clase Database para modificar el esquema:

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"
require "google/cloud/spanner/admin/database"

database_admin_client = Google::Cloud::Spanner::Admin::Database.database_admin

db_path = database_admin_client.database_path project: project_id,
                                              instance: instance_id,
                                              database: database_id

job = database_admin_client.update_database_ddl database: db_path,
                                                statements: [
                                                  "ALTER TABLE Albums ADD COLUMN MarketingBudget INT64"
                                                ]

puts "Waiting for database update to complete"

job.wait_until_done!

puts "Added the MarketingBudget column"

Ejecute la muestra utilizando el argumento add_column .

bundle exec ruby spanner_samples.rb add_column test-instance example-db

Deberías ver:

Added the MarketingBudget column

Escribir datos en la nueva columna

El siguiente código escribe datos en la nueva columna. Establece MarketingBudget en 100000 para la fila especificada por Albums(1, 1) y en 500000 para la fila especificada por Albums(2, 2) .

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

client.commit do |c|
  c.update "Albums", [
    { SingerId: 1, AlbumId: 1, MarketingBudget: 100_000 },
    { SingerId: 2, AlbumId: 2, MarketingBudget: 500_000 }
  ]
end

puts "Updated data"

Ejecute la muestra utilizando el argumento update_data .

bundle exec ruby spanner_samples.rb update_data test-instance example-db

Deberías ver:

Updated data

También puede ejecutar una consulta SQL o una llamada de lectura para obtener los valores que acaba de escribir.

Aquí está el código para ejecutar la consulta:

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

client.execute("SELECT SingerId, AlbumId, MarketingBudget FROM Albums").rows.each do |row|
  puts "#{row[:SingerId]} #{row[:AlbumId]} #{row[:MarketingBudget]}"
end

Para ejecutar esta consulta, ejecute el ejemplo utilizando el argumento query_data_with_new_column .

bundle exec ruby spanner_samples.rb query_data_with_new_column test-instance example-db

Deberías ver:

Actualizar datos

Puede actualizar datos utilizando DML en una transacción de lectura y escritura.

Utilice el método execute_update() para ejecutar una declaración DML.

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner         = Google::Cloud::Spanner.new project: project_id
client          = spanner.client instance_id, database_id
transfer_amount = 200_000

client.transaction do |transaction|
  first_album = transaction.execute(
    "SELECT MarketingBudget from Albums
     WHERE SingerId = 1 and AlbumId = 1"
  ).rows.first
  second_album = transaction.execute(
    "SELECT MarketingBudget from Albums
    WHERE SingerId = 2 and AlbumId = 2"
  ).rows.first
  raise "The second album does not have enough funds to transfer" if second_album[:MarketingBudget] < transfer_amount

  new_first_album_budget  = first_album[:MarketingBudget] + transfer_amount
  new_second_album_budget = second_album[:MarketingBudget] - transfer_amount

  transaction.execute_update(
    "UPDATE Albums SET MarketingBudget = @albumBudget WHERE SingerId = 1 and AlbumId = 1",
    params: { albumBudget: new_first_album_budget }
  )
  transaction.execute_update(
    "UPDATE Albums SET MarketingBudget = @albumBudget WHERE SingerId = 2 and AlbumId = 2",
    params: { albumBudget: new_second_album_budget }
  )
end

puts "Transaction complete"

Ejecute el ejemplo utilizando el argumento write_with_transaction_using_dml .

bundle exec ruby spanner_samples.rb write_with_transaction_using_dml test-instance example-db

Deberías ver:

Transaction complete

Utilice un índice secundario

Supongamos que desea obtener todas las filas de Albums con valores AlbumTitle dentro de un rango determinado. Podría leer todos los valores de la columna AlbumTitle mediante una sentencia SQL o una llamada de lectura y luego descartar las filas que no cumplan los criterios. Sin embargo, realizar este análisis completo de la tabla es costoso, especialmente en tablas con muchas filas. En su lugar, puede acelerar la recuperación de filas al buscar por columnas que no sean de clave principal creando un índice secundario en la tabla.

Añadir un índice secundario a una tabla existente requiere una actualización del esquema. Al igual que otras actualizaciones de esquema, Spanner permite añadir un índice mientras la base de datos sigue gestionando el tráfico. Spanner rellena automáticamente el índice con los datos existentes. El proceso de rellenado puede tardar unos minutos, pero no es necesario desconectar la base de datos ni evitar escribir en la tabla indexada durante el proceso. Para más información, consulte "Añadir un índice secundario" .

Tras agregar un índice secundario, Spanner lo usa automáticamente para las consultas SQL que probablemente se ejecuten más rápido con él. Si usa la interfaz de lectura, debe especificar el índice que desea usar.

Agregar un índice secundario

Puede agregar un índice en la línea de comando usando la CLI de gcloud o programáticamente usando la biblioteca cliente Spanner para Ruby.

En la línea de comandos

Utilice el siguiente comando CREATE INDEX para agregar un índice a la base de datos:

gcloud spanner databases ddl update example-db --instance=test-instance \
    --ddl='CREATE INDEX AlbumsByAlbumTitle ON Albums(AlbumTitle)'

Deberías ver:

Schema updating...done.

Uso de la biblioteca cliente Spanner para Ruby

Utilice el método Database#update de la clase Database para agregar un índice:

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"
require "google/cloud/spanner/admin/database"

database_admin_client = Google::Cloud::Spanner::Admin::Database.database_admin

db_path = database_admin_client.database_path project: project_id,
                                              instance: instance_id,
                                              database: database_id

job = database_admin_client.update_database_ddl database: db_path,
                                                statements: [
                                                  "CREATE INDEX AlbumsByAlbumTitle ON Albums(AlbumTitle)"
                                                ]

puts "Waiting for database update to complete"

job.wait_until_done!

puts "Added the AlbumsByAlbumTitle index"

Ejecute la muestra utilizando el argumento create_index .

bundle exec ruby spanner_samples.rb create_index test-instance example-db

Añadir un índice puede tardar unos minutos. Una vez añadido, debería ver lo siguiente:

Added the AlbumsByAlbumTitle index

Leer utilizando el índice

Para las consultas SQL, Spanner utiliza automáticamente un índice apropiado. En la interfaz de lectura, debe especificar el índice en su solicitud.

Para utilizar el índice en la interfaz de lectura, proporcione un parámetro index al método read de la clase Client .

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

result = client.read "Albums", [:AlbumId, :AlbumTitle],
                     index: "AlbumsByAlbumTitle"

result.rows.each do |row|
  puts "#{row[:AlbumId]} #{row[:AlbumTitle]}"
end

Ejecute la muestra utilizando el argumento read_data_with_index .

bundle exec ruby spanner_samples.rb read_data_with_index test-instance example-db

Deberías ver:

2 Forever Hold Your Peace
2 Go, Go, Go
1 Green
3 Terrified
1 Total Junk

Agregar un índice para lecturas de solo índice

Quizás haya notado que el ejemplo de lectura anterior no incluye la lectura de la columna MarketingBudget . Esto se debe a que la interfaz de lectura de Spanner no permite unir un índice con una tabla de datos para buscar valores que no están almacenados en el índice.

Cree una definición alternativa de AlbumsByAlbumTitle que almacene una copia de MarketingBudget en el índice.

En la línea de comandos

Google SQL

gcloud spanner databases ddl update example-db --instance=test-instance \
    --ddl='CREATE INDEX AlbumsByAlbumTitle2 ON Albums(AlbumTitle) STORING (MarketingBudget)

PostgreSQL

gcloud spanner databases ddl update example-db --instance=test-instance \
    --ddl='CREATE INDEX AlbumsByAlbumTitle2 ON Albums(AlbumTitle) INCLUDE (MarketingBudget)

Añadir un índice puede tardar unos minutos. Una vez añadido, debería ver lo siguiente:

Schema updating...done.

Uso de la biblioteca cliente Spanner para Ruby

Utilice el método Database#update de la clase Database para agregar un índice con una cláusula STORING :

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"
require "google/cloud/spanner/admin/database"

database_admin_client = Google::Cloud::Spanner::Admin::Database.database_admin

db_path = database_admin_client.database_path project: project_id,
                                              instance: instance_id,
                                              database: database_id

job = database_admin_client.update_database_ddl database: db_path,
                                                statements: [
                                                  "CREATE INDEX AlbumsByAlbumTitle2 ON Albums(AlbumTitle)
   STORING (MarketingBudget)"
                                                ]

puts "Waiting for database update to complete"

job.wait_until_done!

puts "Added the AlbumsByAlbumTitle2 storing index"

Ejecute la muestra utilizando el argumento create_storing_index .

bundle exec ruby spanner_samples.rb create_storing_index test-instance example-db

Deberías ver:

Added the AlbumsByAlbumTitle2 index

Ahora puede ejecutar una lectura que obtenga todas las columnas AlbumId , AlbumTitle y MarketingBudget del índice AlbumsByAlbumTitle2 :

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

result = client.read "Albums", [:AlbumId, :AlbumTitle, :MarketingBudget],
                     index: "AlbumsByAlbumTitle2"

result.rows.each do |row|
  puts "#{row[:AlbumId]} #{row[:AlbumTitle]} #{row[:MarketingBudget]}"
end

Ejecute la muestra utilizando el argumento read_data_with_storing_index .

bundle exec ruby spanner_samples.rb read_data_with_storing_index test-instance example-db

Debería ver un resultado similar a este:

2 Forever Hold Your Peace 300000
2 Go, Go, Go
1 Green
3 Terrified
1 Total Junk 300000

Recuperar datos mediante transacciones de solo lectura

Supongamos que desea ejecutar más de una lectura en la misma marca de tiempo. Las transacciones de solo lectura siguen un prefijo consistente del historial de confirmación de transacciones, por lo que su aplicación siempre recibe datos consistentes.

Utilice un objeto Snapshot para ejecutar transacciones de solo lectura. Utilice el método snapshot de la clase Client para obtener un objeto Snapshot .

A continuación se muestra cómo ejecutar una consulta y realizar una lectura en la misma transacción de solo lectura:

# project_id  = "Your Google Cloud project ID"
# instance_id = "Your Spanner instance ID"
# database_id = "Your Spanner database ID"

require "google/cloud/spanner"

spanner = Google::Cloud::Spanner.new project: project_id
client  = spanner.client instance_id, database_id

client.snapshot do |snapshot|
  snapshot.execute("SELECT SingerId, AlbumId, AlbumTitle FROM Albums").rows.each do |row|
    puts "#{row[:AlbumId]} #{row[:AlbumTitle]} #{row[:SingerId]}"
  end

  # Even if changes occur in-between the reads, the transaction ensures that
  # both return the same data.
  snapshot.read("Albums", [:AlbumId, :AlbumTitle, :SingerId]).rows.each do |row|
    puts "#{row[:AlbumId]} #{row[:AlbumTitle]} #{row[:SingerId]}"
  end
end

Ejecute la muestra utilizando el argumento read_only_transaction .

bundle exec ruby spanner_samples.rb read_only_transaction test-instance example-db

Debería ver un resultado similar a este:

2 Forever Hold Your Peace 2
2 Go, Go, Go 1
1 Green 2
3 Terrified 2
1 Total Junk 1
1 Total Junk 1
2 Go, Go, Go 1
1 Green 2
2 Forever Hold Your Peace 2
3 Terrified 2

Limpieza

Para evitar incurrir en cargos adicionales en su cuenta de facturación de Cloud por los recursos utilizados en este tutorial, elimine la base de datos y borre la instancia que creó.

Eliminar la base de datos

Si elimina una instancia, todas sus bases de datos se eliminan automáticamente. Este paso muestra cómo eliminar una base de datos sin eliminar una instancia (aunque se le cobrarán cargos por la instancia).

En la línea de comandos

gcloud spanner databases delete example-db --instance=test-instance

Usando el Google Cloud consola

Vaya a la página Instancias de Spanner en el Google Cloud consola.
Ir a la página de Instancias
Haga clic en la instancia.
Haga clic en la base de datos que desea eliminar.
En la página de detalles de la base de datos , haga clic en Eliminar .
Confirme que desea eliminar la base de datos y haga clic en Eliminar .

Eliminar la instancia

Al eliminar una instancia se eliminan automáticamente todas las bases de datos creadas en esa instancia.

En la línea de comandos

gcloud spanner instances delete test-instance

Usando el Google Cloud consola

Vaya a la página Instancias de Spanner en el Google Cloud consola.
Ir a la página de Instancias
Haga clic en su instancia.
Haga clic en Eliminar .
Confirme que desea eliminar la instancia y haga clic en Eliminar .

¿Qué sigue?

Aprenda cómo acceder a Spanner con una instancia de máquina virtual .
Obtenga información sobre las credenciales de autorización y autenticación en Autenticarse en servicios en la nube mediante bibliotecas de cliente .
Obtenga más información sobre las mejores prácticas de diseño de esquemas Spanner.

Introducción a Spanner en Ruby Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Objetivos

Costos

Antes de empezar

Limpieza

Eliminar la base de datos

En la línea de comandos

Usando el Google Cloud consola

Eliminar la instancia

En la línea de comandos

Usando el Google Cloud consola

¿Qué sigue?

Introducción a Spanner en Ruby
Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.