1. Panoramica
Google Cloud Spanner è un servizio di database relazionale completamente gestito, scalabile orizzontalmente e distribuito a livello globale che fornisce transazioni ACID e semantica SQL senza rinunciare a prestazioni e alta disponibilità.
In questo lab imparerai a configurare un'istanza Cloud Spanner. Vedrai i passaggi per creare un database e uno schema che possono essere utilizzati per una classifica di gioco. Inizierai creando una tabella Players per archiviare le informazioni sui giocatori e una tabella Scores per archiviare i loro punteggi.
Poi compilerai le tabelle con i dati di esempio. Concluderai il lab eseguendo alcune query di esempio Top Ten ed eliminando infine l'istanza per liberare risorse.
Cosa imparerai a fare
- Come configurare un'istanza Cloud Spanner.
- Come creare un database e delle tabelle.
- Come utilizzare una colonna con timestamp di commit.
- Come caricare i dati nella tabella del database Cloud Spanner con i timestamp.
- Come eseguire query sul database Cloud Spanner.
- Come eliminare l'istanza Cloud Spanner.
Cosa occorre
Come utilizzerai questo tutorial?
Come valuteresti la tua esperienza con Google Cloud Platform?
2. Configurazione e requisiti
Configurazione dell'ambiente autonomo
Se non hai ancora un Account Google (Gmail o Google Apps), devi crearne uno. Accedi alla console di Google Cloud Platform ( console.cloud.google.com) e crea un nuovo progetto.
Se hai già un progetto, fai clic sul menu a discesa per la selezione dei progetti in alto a sinistra nella console:
e fai clic sul pulsante "NUOVO PROGETTO" nella finestra di dialogo risultante per creare un nuovo progetto:
Se non hai ancora un progetto, dovresti visualizzare una finestra di dialogo come questa per creare il primo:
La finestra di dialogo successiva per la creazione del progetto ti consente di inserire i dettagli del nuovo progetto:
Ricorda l'ID progetto, che è un nome univoco tra tutti i progetti Google Cloud (il nome riportato sopra è già stato utilizzato e non funzionerà per te, ci dispiace). In questo codelab verrà chiamato PROJECT_ID.
Successivamente, se non l'hai ancora fatto, devi abilitare la fatturazione in Developers Console per utilizzare le risorse Google Cloud e abilitare l'API Cloud Spanner.
L'esecuzione di questo codelab non dovrebbe costarti più di qualche dollaro, ma potrebbe essere più cara se decidi di utilizzare più risorse o se le lasci in esecuzione (vedi la sezione "Pulizia" alla fine di questo documento). I prezzi di Google Cloud Spanner sono documentati qui.
I nuovi utenti di Google Cloud Platform possono beneficiare di una prova senza costi di 300$, che dovrebbe rendere questo codelab completamente senza costi.
Configurazione di Google Cloud Shell
Anche se Google Cloud e Spanner possono essere gestiti da remoto dal tuo laptop, in questo codelab utilizzeremo Google Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.
Questa macchina virtuale basata su Debian viene caricata con tutti gli strumenti di sviluppo di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Ciò significa che per questo codelab ti servirà solo un browser (sì, funziona su Chromebook).
- Per attivare Cloud Shell dalla console Cloud, fai clic su Attiva Cloud Shell
(bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente).
Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è già autenticato e il progetto è già impostato sul tuo PROJECT_ID.
gcloud auth list
Output comando
Credentialed accounts: - <myaccount>@<mydomain>.com (active)
gcloud config list project
Output comando
[core] project = <PROJECT_ID>
Se per qualche motivo il progetto non è impostato, esegui questo comando:
gcloud config set project <PROJECT_ID>
Stai cercando PROJECT_ID? Controlla l'ID che hai utilizzato nei passaggi di configurazione o cercalo nella dashboard della console Cloud:
Cloud Shell imposta anche alcune variabili di ambiente per impostazione predefinita, che potrebbero essere utili quando esegui i comandi futuri.
echo $GOOGLE_CLOUD_PROJECT
Output comando
<PROJECT_ID>
- Infine, imposta la zona e la configurazione del progetto predefinite.
gcloud config set compute/zone us-central1-f
Puoi scegliere una serie di zone diverse. Per saperne di più, consulta Regioni e zone.
Riepilogo
In questo passaggio, configurerai l'ambiente.
Avanti
Successivamente, configurerai un'istanza Cloud Spanner.
3. Configura un'istanza Cloud Spanner
In questo passaggio configuriamo l'istanza Cloud Spanner per questo codelab. Cerca la voce Spanner 
nel menu a tre linee in alto a sinistra 
o cerca Spanner premendo "/" e digitando "Spanner".
Poi fai clic su 
e compila il modulo inserendo il nome dell'istanza cloudspanner-leaderboard, scegliendo una configurazione (seleziona un'istanza regionale) e impostando il numero di nodi. Per questo codelab avrai bisogno di un solo nodo. Per le istanze di produzione e per avere diritto allo SLA di Cloud Spanner, devi eseguire almeno 3 nodi nell'istanza Cloud Spanner.
Infine, fai clic su "Crea" e in pochi secondi avrai a disposizione un'istanza Cloud Spanner.
Nel passaggio successivo utilizzeremo la libreria client Go per creare un database e uno schema nella nuova istanza.
4. Crea un database e uno schema
In questo passaggio creeremo il database di esempio e lo schema.
Utilizziamo la libreria client Go per creare due tabelle: una tabella Players per le informazioni sui giocatori e una tabella Scores per memorizzare i punteggi dei giocatori. Per farlo, esamineremo i passaggi per creare un'applicazione console Go in Cloud Shell.
Per prima cosa, clona il codice campione per questo codelab da GitHub digitando il seguente comando in Cloud Shell:
export GO111MODULE=auto
go get -u github.com/GoogleCloudPlatform/golang-samples/spanner/...
Poi, passa alla directory "leaderboard" in cui creerai l'applicazione.
cd gopath/src/github.com/GoogleCloudPlatform/golang-samples/spanner/spanner_leaderboard
Tutto il codice necessario per questo codelab si trova nella directory golang-samples/spanner/spanner_leaderboard/ esistente come applicazione Go eseguibile denominata leaderboard, che funge da riferimento man mano che avanzi nel codelab. Creeremo una nuova directory e creeremo una copia dell'applicazione Leaderboard in più fasi.
Crea una nuova directory denominata "codelab" per l'applicazione e passa alla directory con il seguente comando:
mkdir codelab && cd $_
Ora creiamo un'applicazione Go di base denominata "Leaderboard" che utilizza la libreria client Spanner per creare una classifica composta da due tabelle: Players e Scores. Puoi farlo direttamente nell'editor di Cloud Shell:
Apri l'editor di Cloud Shell facendo clic sull'icona "Apri editor" evidenziata di seguito:
Crea un file denominato "leaderboard.go" nella cartella ~/gopath/src/github.com/GoogleCloudPlatform/golang-samples/spanner/codelab.
- Innanzitutto, assicurati di aver selezionato la cartella "codelab " nell'elenco delle cartelle dell'editor di Cloud Shell.
- Quindi seleziona "Nuovo file" nel menu "File " dell'editor di Cloud Shell.
- Inserisci "leaderboard.go" come nome del nuovo file.
Questo è il file principale dell'applicazione che conterrà il codice dell'applicazione e i riferimenti per includere eventuali dipendenze.
Per creare il database leaderboard e le tabelle Players e Scores, copia (Ctrl + P) e incolla (Ctrl + V) il seguente codice Go nel file leaderboard.go:
package main
import (
"context"
"flag"
"fmt"
"io"
"log"
"os"
"regexp"
"time"
"cloud.google.com/go/spanner"
database "cloud.google.com/go/spanner/admin/database/apiv1"
adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
)
type adminCommand func(ctx context.Context, w io.Writer, adminClient *database.DatabaseAdminClient, database string) error
func createDatabase(ctx context.Context, w io.Writer, adminClient *database.DatabaseAdminClient, db string) error {
matches := regexp.MustCompile("^(.*)/databases/(.*)$").FindStringSubmatch(db)
if matches == nil || len(matches) != 3 {
return fmt.Errorf("Invalid database id %s", db)
}
op, err := adminClient.CreateDatabase(ctx, &adminpb.CreateDatabaseRequest{
Parent: matches[1],
CreateStatement: "CREATE DATABASE `" + matches[2] + "`",
ExtraStatements: []string{
`CREATE TABLE Players(
PlayerId INT64 NOT NULL,
PlayerName STRING(2048) NOT NULL
) PRIMARY KEY(PlayerId)`,
`CREATE TABLE Scores(
PlayerId INT64 NOT NULL,
Score INT64 NOT NULL,
Timestamp TIMESTAMP NOT NULL
OPTIONS(allow_commit_timestamp=true)
) PRIMARY KEY(PlayerId, Timestamp),
INTERLEAVE IN PARENT Players ON DELETE NO ACTION`,
},
})
if err != nil {
return err
}
if _, err := op.Wait(ctx); err != nil {
return err
}
fmt.Fprintf(w, "Created database [%s]\n", db)
return nil
}
func createClients(ctx context.Context, db string) (*database.DatabaseAdminClient, *spanner.Client) {
adminClient, err := database.NewDatabaseAdminClient(ctx)
if err != nil {
log.Fatal(err)
}
dataClient, err := spanner.NewClient(ctx, db)
if err != nil {
log.Fatal(err)
}
return adminClient, dataClient
}
func run(ctx context.Context, adminClient *database.DatabaseAdminClient, dataClient *spanner.Client, w io.Writer,
cmd string, db string, timespan int) error {
// createdatabase command
if cmd == "createdatabase" {
err := createDatabase(ctx, w, adminClient, db)
if err != nil {
fmt.Fprintf(w, "%s failed with %v", cmd, err)
}
return err
}
return nil
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, `Usage: leaderboard <command> <database_name> [command_option]
Command can be one of: createdatabase
Examples:
leaderboard createdatabase projects/my-project/instances/my-instance/databases/example-db
- Create a sample Cloud Spanner database along with sample tables in your project.
`)
}
flag.Parse()
flagCount := len(flag.Args())
if flagCount != 2 {
flag.Usage()
os.Exit(2)
}
cmd, db := flag.Arg(0), flag.Arg(1)
// Set timespan to zero, as it's not currently being used
var timespan int = 0
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
defer cancel()
adminClient, dataClient := createClients(ctx, db)
if err := run(ctx, adminClient, dataClient, os.Stdout, cmd, db, timespan); err != nil {
os.Exit(1)
}
}
Salva le modifiche apportate al file leaderboard.go selezionando "Salva" nel menu "File " dell'editor Cloud Shell.
Puoi utilizzare il file leaderboard.go nella directory golang-samples/spanner/spanner_leaderboard per vedere un esempio di come dovrebbe apparire il file leaderboard.go dopo aver aggiunto il codice per attivare il comando createdatabase.
Per creare l'app in Cloud Shell, esegui "go build" dalla directory codelab in cui si trova il file leaderboard.go:
go build leaderboard.go
Una volta creata correttamente l'applicazione, esegui l'applicazione risultante in Cloud Shell inserendo questo comando:
./leaderboard
Dovresti vedere un output simile al seguente:
Usage: leaderboard <command> <database_name> [command_option]
Command can be one of: createdatabase
Examples:
leaderboard createdatabase projects/my-project/instances/my-instance/databases/example-db
- Create a sample Cloud Spanner database along with sample tables in your project.
Da questa risposta possiamo vedere che si tratta dell'applicazione Leaderboard che attualmente ha un possibile comando: createdatabase. Possiamo vedere che l'argomento previsto del comando createdatabase è una stringa contenente un ID istanza e un ID database specifici.
Ora esegui il comando seguente. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.
./leaderboard createdatabase projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard
Dopo un paio di secondi dovresti visualizzare una risposta simile alla seguente:
Created database [projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard]
Nella sezione Panoramica dei database Cloud Spanner di Cloud Console dovresti vedere il nuovo database e le nuove tabelle nel menu a sinistra.
Nel passaggio successivo aggiorneremo la nostra applicazione per caricare alcuni dati nel nuovo database.
5. Carica dati
Ora abbiamo un database chiamato leaderboard contenente due tabelle: Players e Scores. Ora utilizziamo la libreria client Go per compilare la tabella Players con i giocatori e la tabella Scores con punteggi casuali per ogni giocatore.
Se non è già aperto, apri l'editor di Cloud Shell facendo clic sull'icona evidenziata di seguito:
Successivamente, modifica il file leaderboard.go nell'editor di Cloud Shell per aggiungere un comando insertplayers che può essere utilizzato per inserire 100 giocatori nella tabella Players. Aggiungeremo anche un comando insertscores che può essere utilizzato per inserire 4 punteggi casuali nella tabella Scores per ogni giocatore nella tabella Players.
Innanzitutto, aggiorna la sezione imports nella parte superiore del file leaderboard.go, sostituendo i contenuti attuali in modo che, al termine, la sezione sia simile alla seguente:
import (
"context"
"flag"
"fmt"
"io"
"log"
"math/rand"
"os"
"regexp"
"time"
"cloud.google.com/go/spanner"
database "cloud.google.com/go/spanner/admin/database/apiv1"
"google.golang.org/api/iterator"
adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
)
Poi aggiungi un nuovo tipo di comando insieme a un elenco di comandi nella parte superiore del file, appena sotto la riga che inizia con "type adminCommand ...", in modo che una volta terminato il file dovrebbe avere il seguente aspetto:
type adminCommand func(ctx context.Context, w io.Writer, adminClient *database.DatabaseAdminClient, database string) error
type command func(ctx context.Context, w io.Writer, client *spanner.Client) error
var (
commands = map[string]command{
"insertplayers": insertPlayers,
"insertscores": insertScores,
}
)
Aggiungi poi le seguenti funzioni insertPlayers e insertScores sotto la funzione createdatabase() esistente:
func insertPlayers(ctx context.Context, w io.Writer, client *spanner.Client) error {
// Get number of players to use as an incrementing value for each PlayerName to be inserted
stmt := spanner.Statement{
SQL: `SELECT Count(PlayerId) as PlayerCount FROM Players`,
}
iter := client.Single().Query(ctx, stmt)
defer iter.Stop()
row, err := iter.Next()
if err != nil {
return err
}
var numberOfPlayers int64 = 0
if err := row.Columns(&numberOfPlayers); err != nil {
return err
}
// Initialize values for random PlayerId
rand.Seed(time.Now().UnixNano())
min := 1000000000
max := 9000000000
// Insert 100 player records into the Players table
_, err = client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
stmts := []spanner.Statement{}
for i := 1; i <= 100; i++ {
numberOfPlayers++
playerID := rand.Intn(max-min) + min
playerName := fmt.Sprintf("Player %d", numberOfPlayers)
stmts = append(stmts, spanner.Statement{
SQL: `INSERT INTO Players
(PlayerId, PlayerName)
VALUES (@playerID, @playerName)`,
Params: map[string]interface{}{
"playerID": playerID,
"playerName": playerName,
},
})
}
_, err := txn.BatchUpdate(ctx, stmts)
if err != nil {
return err
}
return nil
})
fmt.Fprintf(w, "Inserted players \n")
return nil
}
func insertScores(ctx context.Context, w io.Writer, client *spanner.Client) error {
playerRecordsFound := false
// Create slice for insert statements
stmts := []spanner.Statement{}
// Select all player records
stmt := spanner.Statement{SQL: `SELECT PlayerId FROM Players`}
iter := client.Single().Query(ctx, stmt)
defer iter.Stop()
// Insert 4 score records into the Scores table for each player in the Players table
for {
row, err := iter.Next()
if err == iterator.Done {
break
}
if err != nil {
return err
}
playerRecordsFound = true
var playerID int64
if err := row.ColumnByName("PlayerId", &playerID); err != nil {
return err
}
// Initialize values for random score and date
rand.Seed(time.Now().UnixNano())
min := 1000
max := 1000000
for i := 0; i < 4; i++ {
// Generate random score between 1,000 and 1,000,000
score := rand.Intn(max-min) + min
// Generate random day within the past two years
now := time.Now()
endDate := now.Unix()
past := now.AddDate(0, -24, 0)
startDate := past.Unix()
randomDateInSeconds := rand.Int63n(endDate-startDate) + startDate
randomDate := time.Unix(randomDateInSeconds, 0)
// Add insert statement to stmts slice
stmts = append(stmts, spanner.Statement{
SQL: `INSERT INTO Scores
(PlayerId, Score, Timestamp)
VALUES (@playerID, @score, @timestamp)`,
Params: map[string]interface{}{
"playerID": playerID,
"score": score,
"timestamp": randomDate,
},
})
}
}
if !playerRecordsFound {
fmt.Fprintln(w, "No player records currently exist. First insert players then insert scores.")
} else {
_, err := client.ReadWriteTransaction(ctx, func(ctx context.Context, txn *spanner.ReadWriteTransaction) error {
// Commit insert statements for all scores to be inserted as a single transaction
_, err := txn.BatchUpdate(ctx, stmts)
return err
})
if err != nil {
return err
}
fmt.Fprintln(w, "Inserted scores")
}
return nil
}
Poi, per rendere funzionante il comando insert, aggiungi il seguente codice alla funzione "run" dell'applicazione sotto l'istruzione di gestione createdatabase, sostituendo l'istruzione return nil :
// insert and query commands
cmdFn := commands[cmd]
if cmdFn == nil {
flag.Usage()
os.Exit(2)
}
err := cmdFn(ctx, w, dataClient)
if err != nil {
fmt.Fprintf(w, "%s failed with %v", cmd, err)
}
return err
Al termine, la funzione run dovrebbe avere il seguente aspetto:
func run(ctx context.Context, adminClient *database.DatabaseAdminClient, dataClient *spanner.Client, w io.Writer,
cmd string, db string, timespan int) error {
// createdatabase command
if cmd == "createdatabase" {
err := createDatabase(ctx, w, adminClient, db)
if err != nil {
fmt.Fprintf(w, "%s failed with %v", cmd, err)
}
return err
}
// insert and query commands
cmdFn := commands[cmd]
if cmdFn == nil {
flag.Usage()
os.Exit(2)
}
err := cmdFn(ctx, w, dataClient)
if err != nil {
fmt.Fprintf(w, "%s failed with %v", cmd, err)
}
return err
}
L'ultimo passaggio per completare l'aggiunta della funzionalità "inserisci" all'applicazione consiste nell'aggiunta del testo della guida per i comandi "insertplayers" e "insertscores" alla funzione flag.Usage(). Aggiungi il seguente testo di assistenza alla funzione flag.Usage() per includere il testo di assistenza per i comandi di inserimento:
Aggiungi i due comandi all'elenco dei comandi possibili:
Command can be one of: createdatabase, insertplayers, insertscores
Aggiungi questo testo guida aggiuntivo sotto il testo guida per il comando createdatabase.
leaderboard insertplayers projects/my-project/instances/my-instance/databases/example-db
- Insert 100 sample Player records into the database.
leaderboard insertscores projects/my-project/instances/my-instance/databases/example-db
- Insert sample score data into Scores sample Cloud Spanner database table.
Salva le modifiche apportate al file leaderboard.go selezionando "Salva" nel menu "File " dell'editor Cloud Shell.
Puoi utilizzare il file leaderboard.go nella directory golang-samples/spanner/spanner_leaderboard per vedere un esempio di come dovrebbe apparire il file leaderboard.go dopo aver aggiunto il codice per attivare i comandi insertplayers e insertscores.
Ora creiamo ed eseguiamo l'applicazione per verificare che i nuovi comandi insertplayers e insertscores siano inclusi nell'elenco dei possibili comandi dell'applicazione. Esegui questo comando per creare l'applicazione:
go build leaderboard.go
Esegui l'applicazione risultante in Cloud Shell inserendo questo comando:
./leaderboard
Ora dovresti vedere i comandi insertplayers e insertscores inclusi nell'output predefinito dell'applicazione:
Usage: leaderboard <command> <database_name> [command_option]
Command can be one of: createdatabase, insertplayers, insertscores
Examples:
leaderboard createdatabase projects/my-project/instances/my-instance/databases/example-db
- Create a sample Cloud Spanner database along with sample tables in your project.
leaderboard insertplayers projects/my-project/instances/my-instance/databases/example-db
- Insert 100 sample Player records into the database.
leaderboard insertscores projects/my-project/instances/my-instance/databases/example-db
- Insert sample score data into Scores sample Cloud Spanner database table.
Ora eseguiamo il comando insertplayers con gli stessi valori degli argomenti che abbiamo utilizzato quando abbiamo chiamato il comando createdatabase. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.
./leaderboard insertplayers projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard
Dopo un paio di secondi dovresti visualizzare una risposta simile alla seguente:
Inserted players
Ora utilizziamo la libreria client Go per compilare la tabella Scores con quattro punteggi casuali insieme ai timestamp per ogni giocatore nella tabella Players.
La colonna Timestamp della tabella Scores è stata definita come colonna "timestamp di commit" tramite la seguente istruzione SQL eseguita quando abbiamo eseguito in precedenza il comando create:
CREATE TABLE Scores(
PlayerId INT64 NOT NULL,
Score INT64 NOT NULL,
Timestamp TIMESTAMP NOT NULL OPTIONS(allow_commit_timestamp=true)
) PRIMARY KEY(PlayerId, Timestamp),
INTERLEAVE IN PARENT Players ON DELETE NO ACTION
Nota l'attributo OPTIONS(allow_commit_timestamp=true). In questo modo, Timestamp diventa una colonna "timestamp di commit" e può essere compilata automaticamente con il timestamp esatto della transazione per le operazioni INSERT e UPDATE su una determinata riga della tabella.
Puoi anche inserire i tuoi valori di timestamp in una colonna "Timestamp commit", purché inserisci un timestamp con un valore nel passato, che è quello che faremo ai fini di questo codelab.
Ora eseguiamo il comando insertscores con gli stessi valori degli argomenti che abbiamo utilizzato quando abbiamo chiamato il comando insertplayers. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.
./leaderboard insertscores projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard
Dopo un paio di secondi dovresti visualizzare una risposta simile alla seguente:
Inserted scores
L'esecuzione della funzione insertScores utilizza il seguente snippet di codice per inserire un timestamp generato in modo casuale con una data e ora nel passato:
now := time.Now()
endDate := now.Unix()
past := now.AddDate(0, -24, 0)
startDate := past.Unix()
randomDateInSeconds := rand.Int63n(endDate-startDate) + startDate
randomDate := time.Unix(randomDateInSeconds, 0)
stmts = append(stmts, spanner.Statement{
SQL: `INSERT INTO Scores
(PlayerId, Score, Timestamp)
VALUES (@playerID, @score, @timestamp)`,
Params: map[string]interface{}{
"playerID": playerID,
"score": score,
"timestamp": randomDate,
},
})
Per compilare automaticamente la colonna Timestamp con il timestamp del momento esatto in cui viene eseguita la transazione "Inserisci", puoi invece inserire la costante Go spanner.CommitTimestamp come nel seguente snippet di codice:
...
stmts = append(stmts, spanner.Statement{
SQL: `INSERT INTO Scores
(PlayerId, Score, Timestamp)
VALUES (@playerID, @score, @timestamp)`,
Params: map[string]interface{}{
"playerID": playerID,
"score": score,
"timestamp": spanner.CommitTimestamp,
},
})
Ora che abbiamo completato il caricamento dei dati, verifichiamo i valori che abbiamo appena scritto nelle nuove tabelle nella sezione Cloud Spanner di Cloud Console. Seleziona prima il database leaderboard e poi la tabella Players. Fai clic sulla scheda Data. Dovresti vedere che ci sono dati nelle colonne PlayerId e PlayerName della tabella.
Ora verifichiamo che anche la tabella Punteggi contenga dati facendo clic sulla tabella Scores e selezionando la scheda Data. Dovresti vedere che hai dati nelle colonne PlayerId, Timestamp e Score della tabella.
Ben fatto! Aggiorniamo la nostra app per eseguire alcune query che possiamo utilizzare per creare una classifica di gioco.
6. Esegui query sulla classifica
Ora che abbiamo configurato il database e caricato le informazioni nelle tabelle, creiamo una classifica utilizzando questi dati. A questo scopo, dobbiamo rispondere alle seguenti quattro domande:
- Quali giocatori fanno parte della "Top 10" di tutti i tempi?
- Quali giocatori fanno parte della "Top 10" dell'anno?
- Quali giocatori fanno parte della "Top 10" del mese?
- Quali giocatori fanno parte della "Top 10" della settimana?
Aggiorniamo la nostra applicazione per eseguire le query SQL che risponderanno a queste domande.
Aggiungeremo un comando query e un comando queryWithTimespan che forniranno un modo per eseguire le query per rispondere alle domande che produrranno le informazioni necessarie per la nostra classifica.
Modifica il file leaderboard.go nell'editor di Cloud Shell per aggiornare l'applicazione in modo da aggiungere un comando query e un comando queryWithTimespan. Aggiungeremo anche una funzione helper formatWithCommas per formattare i punteggi con le virgole.
Innanzitutto, aggiorna la sezione imports nella parte superiore del file leaderboard.go, sostituendo i contenuti attuali in modo che, al termine, la sezione sia simile alla seguente:
import (
"bytes"
"context"
"flag"
"fmt"
"io"
"log"
"math/rand"
"os"
"regexp"
"strconv"
"time"
"cloud.google.com/go/spanner"
database "cloud.google.com/go/spanner/admin/database/apiv1"
"google.golang.org/api/iterator"
adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
)
Aggiungi quindi le due funzioni seguenti e la funzione helper sotto il metodo insertScores esistente:
func query(ctx context.Context, w io.Writer, client *spanner.Client) error {
stmt := spanner.Statement{
SQL: `SELECT p.PlayerId, p.PlayerName, s.Score, s.Timestamp
FROM Players p
JOIN Scores s ON p.PlayerId = s.PlayerId
ORDER BY s.Score DESC LIMIT 10`}
iter := client.Single().Query(ctx, stmt)
defer iter.Stop()
for {
row, err := iter.Next()
if err == iterator.Done {
return nil
}
if err != nil {
return err
}
var playerID, score int64
var playerName string
var timestamp time.Time
if err := row.Columns(&playerID, &playerName, &score, ×tamp); err != nil {
return err
}
fmt.Fprintf(w, "PlayerId: %d PlayerName: %s Score: %s Timestamp: %s\n",
playerID, playerName, formatWithCommas(score), timestamp.String()[0:10])
}
}
func queryWithTimespan(ctx context.Context, w io.Writer, client *spanner.Client, timespan int) error {
stmt := spanner.Statement{
SQL: `SELECT p.PlayerId, p.PlayerName, s.Score, s.Timestamp
FROM Players p
JOIN Scores s ON p.PlayerId = s.PlayerId
WHERE s.Timestamp > TIMESTAMP_SUB(CURRENT_TIMESTAMP(), INTERVAL @Timespan HOUR)
ORDER BY s.Score DESC LIMIT 10`,
Params: map[string]interface{}{"Timespan": timespan},
}
iter := client.Single().Query(ctx, stmt)
defer iter.Stop()
for {
row, err := iter.Next()
if err == iterator.Done {
return nil
}
if err != nil {
return err
}
var playerID, score int64
var playerName string
var timestamp time.Time
if err := row.Columns(&playerID, &playerName, &score, ×tamp); err != nil {
return err
}
fmt.Fprintf(w, "PlayerId: %d PlayerName: %s Score: %s Timestamp: %s\n",
playerID, playerName, formatWithCommas(score), timestamp.String()[0:10])
}
}
func formatWithCommas(n int64) string {
numberAsString := strconv.FormatInt(n, 10)
numberLength := len(numberAsString)
if numberLength < 4 {
return numberAsString
}
var buffer bytes.Buffer
comma := []rune(",")
bufferPosition := numberLength % 3
if (bufferPosition) > 0 {
bufferPosition = 3 - bufferPosition
}
for i := 0; i < numberLength; i++ {
if bufferPosition == 3 {
buffer.WriteRune(comma[0])
bufferPosition = 0
}
bufferPosition++
buffer.WriteByte(numberAsString[i])
}
return buffer.String()
}
Successivamente, nella parte superiore del file leaderboard.go, aggiungi "query" come una delle opzioni di comando nella variabile commands, appena sotto l'opzione "insertscores": insertScores", in modo che la variabile commands sia simile a questa:
var (
commands = map[string]command{
"insertplayers": insertPlayers,
"insertscores": insertScores,
"query": query,
}
)
Aggiungi poi "queryWithTimespan" come opzione di comando all'interno della funzione run, sotto la sezione del comando "createdatabase" e sopra la sezione di gestione dei comandi "insert and query":
// querywithtimespan command
if cmd == "querywithtimespan" {
err := queryWithTimespan(ctx, w, dataClient, timespan)
if err != nil {
fmt.Fprintf(w, "%s failed with %v", cmd, err)
}
return err
}
Al termine, la funzione run dovrebbe avere il seguente aspetto:
func run(ctx context.Context, adminClient *database.DatabaseAdminClient, dataClient *spanner.Client, w io.Writer,
cmd string, db string, timespan int) error {
// createdatabase command
if cmd == "createdatabase" {
err := createDatabase(ctx, w, adminClient, db)
if err != nil {
fmt.Fprintf(w, "%s failed with %v", cmd, err)
}
return err
}
// querywithtimespan command
if cmd == "querywithtimespan" {
if timespan == 0 {
flag.Usage()
os.Exit(2)
}
err := queryWithTimespan(ctx, w, dataClient, timespan)
if err != nil {
fmt.Fprintf(w, "%s failed with %v", cmd, err)
}
return err
}
// insert and query commands
cmdFn := commands[cmd]
if cmdFn == nil {
flag.Usage()
os.Exit(2)
}
err := cmdFn(ctx, w, dataClient)
if err != nil {
fmt.Fprintf(w, "%s failed with %v", cmd, err)
}
return err
}
Poi, per rendere funzionale il comando queryWithTimespan, aggiorna il blocco di codice flag.Parse() nel metodo "main" della tua applicazione in modo che abbia il seguente aspetto:
flag.Parse()
flagCount := len(flag.Args())
if flagCount < 2 || flagCount > 3 {
flag.Usage()
os.Exit(2)
}
cmd, db := flag.Arg(0), flag.Arg(1)
// If query timespan flag is specified, parse to int
var timespan int = 0
if flagCount == 3 {
parsedTimespan, err := strconv.Atoi(flag.Arg(2))
if err != nil {
fmt.Println(err)
os.Exit(2)
}
timespan = parsedTimespan
}
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
defer cancel()
adminClient, dataClient := createClients(ctx, db)
if err := run(ctx, adminClient, dataClient, os.Stdout, cmd, db, timespan); err != nil {
os.Exit(1)
}
L'ultimo passaggio per completare l'aggiunta della funzionalità "query" all'applicazione consiste nell'aggiunta del testo della guida per i comandi "query" e "querywithtimespan" alla funzione flag.Usage(). Aggiungi le seguenti righe di codice alla funzione flag.Usage() per includere il testo della guida per i comandi della query:
Aggiungi i due comandi "query" all'elenco dei comandi possibili:
Command can be one of: createdatabase, insertplayers, insertscores, query, querywithtimespan
Aggiungi questo testo guida aggiuntivo sotto il testo guida per il comando insertscores.
leaderboard query projects/my-project/instances/my-instance/databases/example-db
- Query players with top ten scores of all time.
leaderboard querywithtimespan projects/my-project/instances/my-instance/databases/example-db 168
- Query players with top ten scores within a timespan specified in hours.
Salva le modifiche apportate al file leaderboard.go selezionando "Salva" nel menu "File " dell'editor Cloud Shell.
Puoi utilizzare il file leaderboard.go nella directory golang-samples/spanner/spanner_leaderboard per vedere un esempio di come dovrebbe apparire il file leaderboard.go dopo aver aggiunto il codice per attivare i comandi query e querywithtimespan.
Ora creiamo ed eseguiamo l'applicazione per verificare che i nuovi comandi query e querywithtimespan siano inclusi nell'elenco dei possibili comandi dell'applicazione.
Esegui questo comando in Cloud Shell per creare l'applicazione:
go build leaderboard.go
Esegui l'applicazione risultante in Cloud Shell inserendo questo comando:
./leaderboard
Ora dovresti vedere i comandi query e querywithtimespan inclusi nell'output predefinito dell'app come nuova opzione di comando:
Usage: leaderboard <command> <database_name> [command_option]
Command can be one of: createdatabase, insertplayers, insertscores, query, querywithtimespan
Examples:
leaderboard createdatabase projects/my-project/instances/my-instance/databases/example-db
- Create a sample Cloud Spanner database along with sample tables in your project.
leaderboard insertplayers projects/my-project/instances/my-instance/databases/example-db
- Insert 100 sample Player records into the database.
leaderboard insertscores projects/my-project/instances/my-instance/databases/example-db
- Insert sample score data into Scores sample Cloud Spanner database table.
leaderboard query projects/my-project/instances/my-instance/databases/example-db
- Query players with top ten scores of all time.
leaderboard querywithtimespan projects/my-project/instances/my-instance/databases/example-db 168
- Query players with top ten scores within a timespan specified in hours.
Dalla risposta puoi notare che possiamo utilizzare il comando query per ottenere un elenco dei nostri "Top 10" giocatori di tutti i tempi. Possiamo anche notare che il comando querywithtimespan ci consente di specificare un intervallo di tempo in ore da utilizzare per filtrare i record in base al loro valore nella colonna Timestamp della tabella Scores.
Eseguiamo il comando query utilizzando gli stessi valori degli argomenti che abbiamo utilizzato quando abbiamo eseguito il comando create. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.
./leaderboard query projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard
Dovresti visualizzare una risposta che include i "Top 10" giocatori di tutti i tempi, come la seguente:
PlayerId: 4018687297 PlayerName: Player 83 Score: 999,618 Timestamp: 2017-07-01
PlayerId: 4018687297 PlayerName: Player 83 Score: 998,956 Timestamp: 2017-09-02
PlayerId: 4285713246 PlayerName: Player 51 Score: 998,648 Timestamp: 2017-12-01
PlayerId: 5267931774 PlayerName: Player 49 Score: 997,733 Timestamp: 2017-11-09
PlayerId: 1981654448 PlayerName: Player 35 Score: 997,480 Timestamp: 2018-12-06
PlayerId: 4953940705 PlayerName: Player 87 Score: 995,184 Timestamp: 2018-09-14
PlayerId: 2456736905 PlayerName: Player 84 Score: 992,881 Timestamp: 2017-04-14
PlayerId: 8234617611 PlayerName: Player 19 Score: 992,399 Timestamp: 2017-12-27
PlayerId: 1788051688 PlayerName: Player 76 Score: 992,265 Timestamp: 2018-11-22
PlayerId: 7127686505 PlayerName: Player 97 Score: 992,038 Timestamp: 2017-12-02
Ora eseguiamo il comando querywithtimespan con gli argomenti necessari per eseguire una query sui primi 10 giocatori dell'anno specificando un "intervallo di tempo" pari al numero di ore in un anno, ovvero 8760. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.
./leaderboard querywithtimespan projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard 8760
Dovresti visualizzare una risposta che include i "Top 10" giocatori dell'anno, come la seguente:
PlayerId: 1981654448 PlayerName: Player 35 Score: 997,480 Timestamp: 2018-12-06
PlayerId: 4953940705 PlayerName: Player 87 Score: 995,184 Timestamp: 2018-09-14
PlayerId: 1788051688 PlayerName: Player 76 Score: 992,265 Timestamp: 2018-11-22
PlayerId: 6862349579 PlayerName: Player 30 Score: 990,877 Timestamp: 2018-09-14
PlayerId: 5529627211 PlayerName: Player 16 Score: 989,142 Timestamp: 2018-03-30
PlayerId: 9743904155 PlayerName: Player 1 Score: 988,765 Timestamp: 2018-05-30
PlayerId: 6809119884 PlayerName: Player 7 Score: 986,673 Timestamp: 2018-05-16
PlayerId: 2132710638 PlayerName: Player 54 Score: 983,108 Timestamp: 2018-09-11
PlayerId: 2320093590 PlayerName: Player 79 Score: 981,373 Timestamp: 2018-05-07
PlayerId: 9554181430 PlayerName: Player 80 Score: 981,087 Timestamp: 2018-06-21
Ora eseguiamo il comando querywithtimespan per interrogare i primi 10 giocatori del mese specificando un "intervallo di tempo" pari al numero di ore in un mese, ovvero 730. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.
./leaderboard querywithtimespan projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard 730
Dovresti visualizzare una risposta che include i "Top 10" giocatori del mese, come la seguente:
PlayerId: 3869829195 PlayerName: Player 69 Score: 949,686 Timestamp: 2019-02-19
PlayerId: 7448359883 PlayerName: Player 20 Score: 938,998 Timestamp: 2019-02-07
PlayerId: 1981654448 PlayerName: Player 35 Score: 929,003 Timestamp: 2019-02-22
PlayerId: 9336678658 PlayerName: Player 44 Score: 914,106 Timestamp: 2019-01-27
PlayerId: 6968576389 PlayerName: Player 40 Score: 898,041 Timestamp: 2019-02-21
PlayerId: 5529627211 PlayerName: Player 16 Score: 896,433 Timestamp: 2019-01-29
PlayerId: 9395039625 PlayerName: Player 59 Score: 879,495 Timestamp: 2019-02-09
PlayerId: 2094604854 PlayerName: Player 39 Score: 860,434 Timestamp: 2019-02-01
PlayerId: 9395039625 PlayerName: Player 59 Score: 849,955 Timestamp: 2019-02-21
PlayerId: 4285713246 PlayerName: Player 51 Score: 805,654 Timestamp: 2019-02-02
Ora eseguiamo il comando querywithtimespan per eseguire una query sui primi 10 giocatori della settimana specificando un "intervallo di tempo" pari al numero di ore in una settimana, ovvero 168. Assicurati di sostituire my-project con l'ID progetto che hai creato all'inizio di questo codelab.
./leaderboard querywithtimespan projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard 168
Dovresti visualizzare una risposta che include i "Top 10" giocatori della settimana, come la seguente:
PlayerId: 3869829195 PlayerName: Player 69 Score: 949,686 Timestamp: 2019-02-19
PlayerId: 1981654448 PlayerName: Player 35 Score: 929,003 Timestamp: 2019-02-22
PlayerId: 6968576389 PlayerName: Player 40 Score: 898,041 Timestamp: 2019-02-21
PlayerId: 9395039625 PlayerName: Player 59 Score: 849,955 Timestamp: 2019-02-21
PlayerId: 5954045812 PlayerName: Player 8 Score: 795,639 Timestamp: 2019-02-22
PlayerId: 3889939638 PlayerName: Player 71 Score: 775,252 Timestamp: 2019-02-21
PlayerId: 5529627211 PlayerName: Player 16 Score: 604,695 Timestamp: 2019-02-19
PlayerId: 9006728426 PlayerName: Player 3 Score: 457,208 Timestamp: 2019-02-22
PlayerId: 8289497066 PlayerName: Player 58 Score: 227,697 Timestamp: 2019-02-20
PlayerId: 8065482904 PlayerName: Player 99 Score: 198,429 Timestamp: 2019-02-24
Eccellente.
Ora, man mano che aggiungi record, Cloud Spanner ridimensiona il database in base alle tue esigenze. Indipendentemente dalle dimensioni del database, la classifica del tuo gioco può continuare a scalare con precisione grazie a Cloud Spanner e alla sua tecnologia Truetime.
7. Esegui la pulizia
Dopo tutto il divertimento con Spanner, dobbiamo fare pulizia nel nostro ambiente di prova, risparmiando risorse e denaro preziosi. Fortunatamente, questo è un passaggio semplice: basta andare alla sezione Cloud Spanner di Cloud Console ed eliminare l'istanza creata nel passaggio del codelab denominato "Configura un'istanza Cloud Spanner".
8. Complimenti!
Argomenti trattati:
- Istanze, database e schema di tabella di Google Cloud Spanner per una classifica
- Come creare un'applicazione console Go
- Come creare un database e tabelle Spanner utilizzando la libreria client Go
- Come caricare dati in un database Spanner utilizzando la libreria client Go
- Come eseguire query sui risultati "Top 10" dai tuoi dati utilizzando i timestamp di commit di Spanner e la libreria client Go
Passaggi successivi:
- Leggi il white paper su Spanner CAP
- Scopri di più sulla progettazione dello schema e sulle best practice per le query
- Scopri di più sui timestamp di commit di Cloud Spanner
Inviaci il tuo feedback
- Ti invitiamo a dedicare qualche istante per completare il nostro brevissimo sondaggio.