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. Seguirai la procedura per creare un database e uno schema da utilizzare per una classifica dei giochi. Inizierai creando una tabella dei giocatori per le informazioni sui giocatori e una tabella dei punteggi per memorizzare i punteggi dei giocatori.
Successivamente, completerai le tabelle con dati di esempio. Quindi concluderai il lab eseguendo alcune query di esempio principali e infine eliminando l'istanza per liberare risorse.
Cosa imparerai a fare
- Come configurare un'istanza Cloud Spanner.
- Come creare un database e le tabelle.
- Come utilizzare una colonna del timestamp di commit.
- Come caricare dati nella tabella di database Cloud Spanner con timestamp.
- Come eseguire query sul database Cloud Spanner.
- Come eliminare l'istanza Cloud Spanner.
Che cosa ti serve
Come utilizzerai questo tutorial?
Come valuteresti la tua esperienza con la piattaforma Google Cloud?
2. Configurazione e requisiti
Configurazione dell'ambiente da seguire in modo autonomo
Se non disponi già di un account Google (Gmail o Google Apps), devi crearne uno. Accedi alla console della piattaforma Google Cloud ( console.cloud.google.com) e crea un nuovo progetto.
Se hai già un progetto, fai clic sul menu a discesa per la selezione del progetto in alto a sinistra nella console:
e fai clic su "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 crearne uno:
La finestra di dialogo di creazione del progetto successiva 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 precedente è già in uso e non funzionerà per te). Verrà indicato più avanti in questo codelab come PROJECT_ID.
Successivamente, se non l'hai ancora fatto, dovrai 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 costare più di qualche euro, ma potrebbe essere più costoso se decidi di utilizzare più risorse o se le lasci in esecuzione (consulta la sezione relativa alla pulizia alla fine di questo documento). I prezzi di Google Cloud Spanner sono documentati qui.
I nuovi utenti di Google Cloud Platform hanno diritto a una prova senza costi di 300$, che dovrebbe rendere questo codelab completamente senza costi.
Configurazione di Google Cloud Shell
Mentre 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 necessari. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Ciò significa che per questo codelab sarà sufficiente un browser (sì, funziona su Chromebook).
- Per attivare Cloud Shell dalla console Cloud, fai clic su Attiva Cloud Shell
(il provisioning e la connessione all'ambiente dovrebbero richiedere solo pochi minuti).
Una volta stabilita la connessione a Cloud Shell, dovresti vedere che hai già eseguito l'autenticazione e che il progetto è già impostato su 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, invia semplicemente il seguente comando:
gcloud config set project <PROJECT_ID>
Stai cercando il tuo PROJECT_ID? Controlla l'ID utilizzato nei passaggi di configurazione o cercalo nella dashboard della console Cloud:
Cloud Shell imposta anche alcune variabili di ambiente per impostazione predefinita, cosa che può essere utile quando eseguirai 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 zone diverse. Per ulteriori informazioni, consulta la sezione Regioni e zone.
Riepilogo
In questo passaggio devi configurare il tuo ambiente.
A seguire
Ora devi configurare un'istanza Cloud Spanner.
3. Configura un'istanza Cloud Spanner
In questo passaggio configuriamo la nostra istanza Cloud Spanner per il codelab. Cerca la voce Spanner 
nel menu a tre linee in alto a sinistra 
o cerca Spanner premendo "/" e digita "Spanner"
Quindi, fai clic su 
e compila il modulo inserendo il nome dell'istanza cloudspanner-leaderboard per la tua istanza, scegliendo una configurazione (seleziona un'istanza a livello di regione) e imposta il numero di nodi. Per questo codelab avremo bisogno di un solo nodo. Per le istanze di produzione e per l'idoneità allo SLA (accordo sul livello del servizio) di Cloud Spanner, devi eseguire 3 o più nodi nella tua istanza Cloud Spanner.
Infine, fai clic su "Crea" e in pochi secondi hai a disposizione un'istanza Cloud Spanner.
Nel passaggio successivo utilizzeremo la libreria client Java per creare un database e uno schema nella nostra nuova istanza.
4. Crea un database e uno schema
In questo passaggio creeremo il database e lo schema di esempio.
Usiamo la libreria client Java per creare due tabelle; una tabella dei giocatori per le informazioni sui giocatori e una tabella dei punteggi per memorizzare i punteggi dei giocatori. Per farlo, seguiamo i passaggi per creare un'applicazione console Java in Cloud Shell.
Per prima cosa, clona il codice campione per questo codelab da GitHub digitando il seguente comando in Cloud Shell:
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
Poi cambia la directory con "applications" in cui creerai l'applicazione.
cd java-docs-samples/spanner/leaderboard
Tutto il codice necessario per questo codelab si trova nella directory java-docs-samples/spanner/leaderboard/complete esistente come applicazione C# eseguibile denominata Leaderboard, che fungerà da riferimento man mano che procedi nel codelab. Creeremo una nuova directory e creeremo una copia dell'applicazione Leaderboard gradualmente.
Crea una nuova directory denominata "codelab" dell'applicazione e passare alla directory al suo interno con il seguente comando:
mkdir codelab && cd $_
Crea una nuova applicazione Java di base denominata "Leaderboard" utilizzando il seguente comando Maven (mvn):
mvn -B archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DgroupId=com.google.codelabs -DartifactId=leaderboard -DarchetypeVersion=1.4
Questo comando crea una semplice applicazione console composta da due file principali: il file di configurazione dell'app Maven pom.xml e il file dell'app Java App.java.
Passa quindi alla directory leaderboard appena creata e elencane il contenuto:
cd leaderboard && ls
Dovresti vedere il file pom.xml e la directory src:
pom.xml src
Ora aggiorniamo questa app della console modificando App.java in modo che utilizzi la libreria client Java Spanner per creare una classifica composta da due tabelle. Giocatori e punteggi. Puoi farlo direttamente nell'editor di Cloud Shell:
Apri l'editor di Cloud Shell facendo clic sull'icona evidenziata di seguito:
Apri il file pom.xml nella cartella leaderboard. Apri il file pom.xml che si trova nella cartella java-docs-samples\ spanner\leaderboard\codelab\leaderboard.Questo file configura il sistema di build Maven per creare la nostra applicazione in un jar, incluse tutte le nostre dipendenze.
Aggiungi la seguente nuova sezione per la gestione delle dipendenze direttamente sotto le proprietà </properties> esistenti :
<dependencyManagement>
<dependencies>
<dependency>
<groupId>com.google.cloud</groupId>
<artifactId>google-cloud-bom</artifactId>
<version>0.83.0-alpha</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
Aggiungi anche una nuova dipendenza nel campo <dependencies> esistente che aggiungerà la libreria client Java di Cloud Spanner all'applicazione.
<dependency>
<!-- Version auto-managed by BOM -->
<groupId>com.google.cloud</groupId>
<artifactId>google-cloud-spanner</artifactId>
</dependency>
Quindi sostituisci la parte <build> esistente del file pom.xml con la seguente sezione <build> sezione:
<build>
<plugins>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.5.5</version>
<configuration>
<finalName>leaderboard</finalName>
<descriptorRefs>
<descriptorRef>jar-with-dependencies</descriptorRef>
</descriptorRefs>
<archive>
<manifest>
<mainClass>com.google.codelabs.App</mainClass>
</manifest>
</archive>
<appendAssemblyId>false</appendAssemblyId>
<attach>false</attach>
</configuration>
<executions>
<execution>
<id>make-assembly</id>
<phase>package</phase>
<goals>
<goal>single</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-failsafe-plugin</artifactId>
<version>3.0.0-M3</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.0.0-M3</version>
<configuration>
<useSystemClassLoader>false</useSystemClassLoader>
</configuration>
</plugin>
</plugins>
</build>
Salva le modifiche apportate al file pom.xml selezionando "Salva" nel campo "File" dell'editor di Cloud Shell o premendo il tasto "Ctrl" e "S" insieme i tasti della tastiera.
A questo punto, apri il file App.java nell'editor di Cloud Shell che si trova nella cartella src/main/java/com/google/codelabs/. Sostituisci il codice esistente del file con il codice necessario per creare il database leaderboard e le tabelle Players e Scores incollando il seguente codice Java nel file App.java:
package com.google.codelabs;
import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.spanner.Database;
import com.google.cloud.spanner.DatabaseAdminClient;
import com.google.cloud.spanner.DatabaseClient;
import com.google.cloud.spanner.DatabaseId;
import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerException;
import com.google.cloud.spanner.SpannerExceptionFactory;
import com.google.cloud.spanner.SpannerOptions;
import com.google.spanner.admin.database.v1.CreateDatabaseMetadata;
import java.util.Arrays;
import java.util.concurrent.ExecutionException;
/**
* Example code for using the Cloud Spanner API with the Google Cloud Java client library
* to create a simple leaderboard.
*
* This example demonstrates:
*
* <p>
*
* <ul>
* <li>Creating a Cloud Spanner database.
* </ul>
*/
public class App {
static void create(DatabaseAdminClient dbAdminClient, DatabaseId db) {
OperationFuture<Database, CreateDatabaseMetadata> op =
dbAdminClient.createDatabase(
db.getInstanceId().getInstance(),
db.getDatabase(),
Arrays.asList(
"CREATE TABLE Players(\n"
+ " PlayerId INT64 NOT NULL,\n"
+ " PlayerName STRING(2048) NOT NULL\n"
+ ") PRIMARY KEY(PlayerId)",
"CREATE TABLE Scores(\n"
+ " PlayerId INT64 NOT NULL,\n"
+ " Score INT64 NOT NULL,\n"
+ " Timestamp TIMESTAMP NOT NULL\n"
+ " OPTIONS(allow_commit_timestamp=true)\n"
+ ") PRIMARY KEY(PlayerId, Timestamp),\n"
+ "INTERLEAVE IN PARENT Players ON DELETE NO ACTION"));
try {
// Initiate the request which returns an OperationFuture.
Database dbOperation = op.get();
System.out.println("Created database [" + dbOperation.getId() + "]");
} catch (ExecutionException e) {
// If the operation failed during execution, expose the cause.
throw (SpannerException) e.getCause();
} catch (InterruptedException e) {
// Throw when a thread is waiting, sleeping, or otherwise occupied,
// and the thread is interrupted, either before or during the activity.
throw SpannerExceptionFactory.propagateInterrupt(e);
}
}
static void printUsageAndExit() {
System.out.println("Leaderboard 1.0.0");
System.out.println("Usage:");
System.out.println(" java -jar leaderboard.jar "
+ "<command> <instance_id> <database_id> [command_option]");
System.out.println("");
System.out.println("Examples:");
System.out.println(" java -jar leaderboard.jar create my-instance example-db");
System.out.println(" - Create a sample Cloud Spanner database along with "
+ "sample tables in your project.\n");
System.exit(1);
}
public static void main(String[] args) throws Exception {
if (!(args.length == 3 || args.length == 4)) {
printUsageAndExit();
}
SpannerOptions options = SpannerOptions.newBuilder().build();
Spanner spanner = options.getService();
try {
String command = args[0];
DatabaseId db = DatabaseId.of(options.getProjectId(), args[1], args[2]);
DatabaseClient dbClient = spanner.getDatabaseClient(db);
DatabaseAdminClient dbAdminClient = spanner.getDatabaseAdminClient();
switch (command) {
case "create":
create(dbAdminClient, db);
break;
default:
printUsageAndExit();
}
} finally {
spanner.close();
}
System.out.println("Closed client");
}
}
Salva le modifiche apportate al file App.java selezionando "Salva" nel campo "File" dell'editor di Cloud Shell o dal menu Fogli Google.
Puoi utilizzare il file App.java nella directory java-docs-samples/spanner/leaderboard/step4/src per vedere un esempio dell'aspetto del file App.java dopo aver aggiunto il codice per abilitare il comando create.
Per creare la tua app, esegui il pacchetto mvn dalla directory in cui si trova pom.xml:
mvn package
Dopo aver creato correttamente il file jar Java, esegui l'applicazione risultante in Cloud Shell inserendo questo comando:
java -jar target/leaderboard.jar
Dovresti vedere un output simile al seguente:
Leaderboard 1.0.0
Usage:
java -jar leaderboard.jar <command> <instance_id> <database_id> [command_option]
Examples:
java -jar leaderboard.jar create my-instance example-db
- Create a sample Cloud Spanner database along with sample tables in your project.
Da questa risposta possiamo vedere che questa è l'applicazione Leaderboard che al momento ha un possibile comando: create. Possiamo vedere che gli argomenti previsti per il comando create sono ID istanza e ID database.
Ora esegui questo comando.
java -jar target/leaderboard.jar create cloudspanner-leaderboard leaderboard
Dopo un paio di secondi, dovresti visualizzare una risposta come la seguente:
Created database [projects/your-project/instances/cloudspanner-leaderboard/databases/leaderboard]
Nella sezione Cloud Spanner della console Cloud 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 Java per popolare 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:
Quindi, modifica il file App.java nell'editor di Cloud Shell per aggiungere un comando insert che possa essere utilizzato per inserire 100 giocatori nella tabella Players o che possa 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 dell'app, sostituendo il file attualmente presente, in modo che una volta finito dovrebbe avere il seguente aspetto:
package com.google.codelabs;
import static com.google.cloud.spanner.TransactionRunner.TransactionCallable;
import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.spanner.Database;
import com.google.cloud.spanner.DatabaseAdminClient;
import com.google.cloud.spanner.DatabaseClient;
import com.google.cloud.spanner.DatabaseId;
import com.google.cloud.spanner.Mutation;
import com.google.cloud.spanner.ResultSet;
import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerException;
import com.google.cloud.spanner.SpannerExceptionFactory;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.Statement;
import com.google.cloud.spanner.TransactionContext;
import com.google.spanner.admin.database.v1.CreateDatabaseMetadata;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadLocalRandom;
Poi aggiungi i seguenti metodi insert, insertPlayers e insertScores sotto il metodo create() esistente e sopra il metodo printUsageAndExit() esistente:
static void insert(DatabaseClient dbClient, String insertType) {
try {
insertType = insertType.toLowerCase();
} catch (Exception e) {
// Invalid input received, set insertType to empty string.
insertType = "";
}
if (insertType.equals("players")) {
// Insert players.
insertPlayers(dbClient);
} else if (insertType.equals("scores")) {
// Insert scores.
insertScores(dbClient);
} else {
// Invalid input.
System.out.println("Invalid value for 'type of insert'. "
+ "Specify a valid value: 'players' or 'scores'.");
System.exit(1);
}
}
static void insertPlayers(DatabaseClient dbClient) {
dbClient
.readWriteTransaction()
.run(
new TransactionCallable<Void>() {
@Override
public Void run(TransactionContext transaction) throws Exception {
// Get the number of players.
String sql = "SELECT Count(PlayerId) as PlayerCount FROM Players";
ResultSet resultSet = transaction.executeQuery(Statement.of(sql));
long numberOfPlayers = 0;
if (resultSet.next()) {
numberOfPlayers = resultSet.getLong("PlayerCount");
}
// Insert 100 player records into the Players table.
List<Statement> stmts = new ArrayList<Statement>();
long randomId;
for (int x = 1; x <= 100; x++) {
numberOfPlayers++;
randomId = (long) Math.floor(Math.random() * 9_000_000_000L) + 1_000_000_000L;
Statement statement =
Statement
.newBuilder(
"INSERT INTO Players (PlayerId, PlayerName) "
+ "VALUES (@PlayerId, @PlayerName) ")
.bind("PlayerId")
.to(randomId)
.bind("PlayerName")
.to("Player " + numberOfPlayers)
.build();
stmts.add(statement);
}
transaction.batchUpdate(stmts);
return null;
}
});
System.out.println("Done inserting player records...");
}
static void insertScores(DatabaseClient dbClient) {
boolean playerRecordsFound = false;
ResultSet resultSet =
dbClient
.singleUse()
.executeQuery(Statement.of("SELECT * FROM Players"));
while (resultSet.next()) {
playerRecordsFound = true;
final long playerId = resultSet.getLong("PlayerId");
dbClient
.readWriteTransaction()
.run(
new TransactionCallable<Void>() {
@Override
public Void run(TransactionContext transaction) throws Exception {
// Initialize objects for random Score and random Timestamp.
LocalDate endDate = LocalDate.now();
long end = endDate.toEpochDay();
int startYear = endDate.getYear() - 2;
int startMonth = endDate.getMonthValue();
int startDay = endDate.getDayOfMonth();
LocalDate startDate = LocalDate.of(startYear, startMonth, startDay);
long start = startDate.toEpochDay();
Random r = new Random();
List<Statement> stmts = new ArrayList<Statement>();
// Insert 4 score records into the Scores table
// for each player in the Players table.
for (int x = 1; x <= 4; x++) {
// Generate random score between 1,000,000 and 1,000
long randomScore = r.nextInt(1000000 - 1000) + 1000;
// Get random day within the past two years.
long randomDay = ThreadLocalRandom.current().nextLong(start, end);
LocalDate randomDayDate = LocalDate.ofEpochDay(randomDay);
LocalTime randomTime = LocalTime.of(
r.nextInt(23), r.nextInt(59), r.nextInt(59), r.nextInt(9999));
LocalDateTime randomDate = LocalDateTime.of(randomDayDate, randomTime);
Instant randomInstant = randomDate.toInstant(ZoneOffset.UTC);
Statement statement =
Statement
.newBuilder(
"INSERT INTO Scores (PlayerId, Score, Timestamp) "
+ "VALUES (@PlayerId, @Score, @Timestamp) ")
.bind("PlayerId")
.to(playerId)
.bind("Score")
.to(randomScore)
.bind("Timestamp")
.to(randomInstant.toString())
.build();
stmts.add(statement);
}
transaction.batchUpdate(stmts);
return null;
}
});
}
if (!playerRecordsFound) {
System.out.println("Parameter 'scores' is invalid since "
+ "no player records currently exist. First insert players "
+ "then insert scores.");
System.exit(1);
} else {
System.out.println("Done inserting score records...");
}
}
Quindi, per rendere funzionale il comando insert, aggiungi il seguente codice al campo "main" dell'app nell'istruzione switch (command) :
case "insert":
String insertType;
try {
insertType = args[3];
} catch (ArrayIndexOutOfBoundsException exception) {
insertType = "";
}
insert(dbClient, insertType);
break;
Al termine, l'istruzione switch (command) dovrebbe avere il seguente aspetto:
switch (command) {
case "create":
create(dbAdminClient, db);
break;
case "insert":
String insertType;
try {
insertType = args[3];
} catch (ArrayIndexOutOfBoundsException exception) {
insertType = "";
}
insert(dbClient, insertType);
break;
default:
printUsageAndExit();
}
Il passaggio finale per completare l'aggiunta di "Inserisci" della tua app è l'aggiunta del testo della guida per "insert" al metodo printUsageAndExit(). Aggiungi le seguenti righe di codice al metodo printUsageAndExit()per includere il testo della guida per il comando di inserimento:
System.out.println(" java -jar leaderboard.jar insert my-instance example-db players");
System.out.println(" - Insert 100 sample Player records into the database.\n");
System.out.println(" java -jar leaderboard.jar insert my-instance example-db scores");
System.out.println(" - Insert sample score data into Scores sample Cloud Spanner "
+ "database table.\n");
Salva le modifiche apportate al file App.java selezionando "Salva" nel campo "File" dell'editor di Cloud Shell o dal menu Fogli Google.
Puoi utilizzare il file App.java nella directory java-docs-samples/spanner/leaderboard/step5/src per vedere un esempio dell'aspetto del file App.java dopo aver aggiunto il codice per abilitare il comando insert.
Ora ricrea ed eseguiamo l'app per confermare che il nuovo comando insert sia incluso nell'elenco dei possibili comandi dell'app.
Per creare la tua app, esegui mvn package dalla directory in cui si trova il file pom.xml:
mvn package
Dopo aver creato correttamente il file jar Java, esegui questo comando:
java -jar target/leaderboard.jar
Ora il comando insert dovrebbe essere incluso nell'output predefinito dell'app:
Leaderboard 1.0.0
Usage:
java -jar leaderboard.jar <command> <instance_id> <database_id> [command_option]
Examples:
java -jar leaderboard.jar create my-instance example-db
- Create a sample Cloud Spanner database along with sample tables in your project.
java -jar leaderboard.jar insert my-instance example-db players
- Insert 100 sample Player records into the database.
java -jar leaderboard.jar insert my-instance example-db scores
- Insert sample score data into Scores sample Cloud Spanner database table.
Puoi notare dalla risposta che oltre all'ID istanza e all'ID database c'è un altro argomento che può avere un valore di "players". o "punteggi".
Ora eseguiamo il comando insert con gli stessi valori di argomento che abbiamo utilizzato quando abbiamo chiamato il comando create, aggiungendo "players" come "tipo di inserto" aggiuntivo .
java -jar target/leaderboard.jar insert cloudspanner-leaderboard leaderboard players
Dopo un paio di secondi, dovresti visualizzare una risposta come la seguente:
Done inserting player records...
Ora utilizziamo la libreria client Java per popolare la tabella Scores con quattro punteggi casuali e i timestamp per ogni giocatore nella tabella Players.
La colonna Timestamp della tabella Scores è stata definita come "timestamp di impegno" tramite la seguente istruzione SQL eseguita quando in precedenza abbiamo eseguito 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
Osserva l'attributo OPTIONS(allow_commit_timestamp=true). Timestamp diventa un "timestamp di commit" e consente di compilarla 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 un "timestamp di commit" devi inserire un timestamp con un valore nel passato, che è ciò che faremo in questo codelab.
Ora eseguiamo il comando insert con gli stessi valori di argomento che abbiamo utilizzato quando abbiamo chiamato il comando create aggiungendo "scores" come "tipo di inserto" aggiuntivo .
java -jar target/leaderboard.jar insert cloudspanner-leaderboard leaderboard scores
Dopo un paio di secondi, dovresti visualizzare una risposta come la seguente:
Done inserting score records...
insert in esecuzione con il "tipo di inserto" specificato come scores chiama il metodo insertScores, che utilizza i seguenti snippet di codice per inserire un timestamp generato in modo casuale con data e ora del passato:
LocalDate endDate = LocalDate.now();
long end = endDate.toEpochDay();
int startYear = endDate.getYear() - 2;
int startMonth = endDate.getMonthValue();
int startDay = endDate.getDayOfMonth();
LocalDate startDate = LocalDate.of(startYear, startMonth, startDay);
long start = startDate.toEpochDay();
...
long randomDay = ThreadLocalRandom.current().nextLong(start, end);
LocalDate randomDayDate = LocalDate.ofEpochDay(randomDay);
LocalTime randomTime = LocalTime.of(
r.nextInt(23), r.nextInt(59), r.nextInt(59), r.nextInt(9999));
LocalDateTime randomDate = LocalDateTime.of(randomDayDate, randomTime);
Instant randomInstant = randomDate.toInstant(ZoneOffset.UTC);
...
.bind("Timestamp")
.to(randomInstant.toString())
Per compilare automaticamente la colonna Timestamp con il timestamp corrispondente al momento esatto in cui "Inserisci" avviene la transazione, puoi inserire la costante Java Value.COMMIT_TIMESTAMP come nel seguente snippet di codice:
.bind("Timestamp")
.to(Value.COMMIT_TIMESTAMP)
Ora che il caricamento dei dati è stato completato, verifichiamo i valori che abbiamo appena scritto nelle nuove tabelle. Seleziona prima il database leaderboard, quindi seleziona la tabella Players. Fai clic sulla scheda Data. Dovresti vedere che sono presenti dati nelle colonne PlayerId e PlayerName della tabella.
Verifica che anche la tabella dei punteggi contenga dei dati facendo clic sulla tabella Scores e selezionando la scheda Data. Dovresti vedere che sono presenti dati nelle colonne PlayerId, Timestamp e Score della tabella.
Ben fatto! Aggiorniamo l'app in modo che esegua alcune query da usare per creare una classifica dei giochi.
6. Eseguire query sulla classifica
Ora che abbiamo impostato il database e caricato le informazioni nelle nostre tabelle, possiamo creare un leaderboard utilizzando questi dati. Per farlo, dobbiamo rispondere alle seguenti quattro domande:
- Quali giocatori sono i "primi dieci" di tutti i tempi?
- Quali giocatori sono i "primi dieci" dell'anno?
- Quali giocatori sono i "primi dieci" del mese?
- Quali giocatori sono i "primi dieci" della settimana?
Aggiorna l'app in modo che esegua le query SQL che rispondono a queste domande.
Aggiungeremo un comando query che fornirà un modo per eseguire le query e rispondere alle domande che produrranno le informazioni richieste per la nostra classifica.
Modifica il file App.java nell'editor di Cloud Shell per aggiornare l'app e aggiungere un comando query. Il comando query è composto da due metodi query, uno che accetta solo un argomento DatabaseClient e uno che richiede un argomento timespan aggiuntivo per facilitare il filtro dei risultati in base a un intervallo di tempo specificato in ore.
Aggiungi i seguenti due metodi query sotto il metodo insertScores() esistente e sopra il metodo printUsageAndExit() esistente:
static void query(DatabaseClient dbClient) {
String scoreDate;
String score;
ResultSet resultSet =
dbClient
.singleUse()
.executeQuery(
Statement.of(
"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"));
while (resultSet.next()) {
scoreDate = String.valueOf(resultSet.getTimestamp("Timestamp"));
score = String.format("%,d", resultSet.getLong("Score"));
System.out.printf(
"PlayerId: %d PlayerName: %s Score: %s Timestamp: %s\n",
resultSet.getLong("PlayerId"), resultSet.getString("PlayerName"), score,
scoreDate.substring(0,10));
}
}
static void query(DatabaseClient dbClient, int timespan) {
String scoreDate;
String score;
Statement statement =
Statement
.newBuilder(
"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")
.bind("Timespan")
.to(timespan)
.build();
ResultSet resultSet =
dbClient
.singleUse()
.executeQuery(statement);
while (resultSet.next()) {
scoreDate = String.valueOf(resultSet.getTimestamp("Timestamp"));
score = String.format("%,d", resultSet.getLong("Score"));
System.out.printf(
"PlayerId: %d PlayerName: %s Score: %s Timestamp: %s\n",
resultSet.getLong("PlayerId"), resultSet.getString("PlayerName"), score,
scoreDate.substring(0,10));
}
}
Successivamente, per rendere funzionale il comando query, aggiungi il seguente codice all'istruzione switch(command) nella sezione "main" dell'app :
case "query":
if (args.length == 4) {
int timespan = 0;
try {
timespan = Integer.parseInt(args[3]);
} catch (NumberFormatException e) {
System.err.println("query command's 'timespan' parameter must be a valid integer.");
System.exit(1);
}
query(dbClient, timespan);
} else {
query(dbClient);
}
break;
Il passaggio finale per completare l'aggiunta della "query" alla tua app è l'aggiunta di testo di aiuto per la "query" al metodo printUsageAndExit(). Aggiungi le seguenti righe di codice al metodo printUsageAndExit()per includere il testo della guida per "query" :
System.out.println(" java -jar leaderboard.jar query my-instance example-db");
System.out.println(" - Query players with top ten scores of all time.\n");
System.out.println(" java -jar leaderboard.jar query my-instance example-db 168");
System.out.println(" - Query players with top ten scores within a timespan "
+ "specified in hours.\n");
Salva le modifiche apportate al file App.java selezionando "Salva" nel campo "File" dell'editor di Cloud Shell o dal menu Fogli Google.
Puoi utilizzare il file App.java nella directory dotnet-docs-samples/applications/leaderboard/step6/src per vedere un esempio dell'aspetto del file App.java dopo aver aggiunto il codice per abilitare il comando query.
Per creare la tua app, esegui mvn package dalla directory in cui si trova il file pom.xml:
mvn package
Ora eseguiamo l'app per confermare che il nuovo comando query sia incluso nell'elenco di possibili comandi dell'app. Esegui questo comando:
java -jar target/leaderboard.jar
Ora il comando query dovrebbe essere incluso nell'output predefinito dell'app come nuova opzione di comando:
Leaderboard 1.0.0
Usage:
java -jar leaderboard.jar <command> <instance_id> <database_id> [command_option]
Examples:
java -jar leaderboard.jar create my-instance example-db
- Create a sample Cloud Spanner database along with sample tables in your project.
java -jar leaderboard.jar insert my-instance example-db players
- Insert 100 sample Player records into the database.
java -jar leaderboard.jar insert my-instance example-db scores
- Insert sample score data into Scores sample Cloud Spanner database table.
java -jar leaderboard.jar query my-instance example-db
- Query players with top ten scores of all time.
java -jar leaderboard.jar query my-instance example-db 168
- Query players with top ten scores within a timespan specified in hours.
Dalla risposta puoi notare che, oltre agli argomenti ID istanza e ID database, il comando query consente di specificare un intervallo di tempo facoltativo in numero di ore da utilizzare per filtrare i record in base al relativo valore nella colonna Timestamp della tabella Scores. Poiché l'argomento timespan è facoltativo, significa che se non è incluso un argomento timespan, nessun record sarà filtrato in base ai timestamp. Quindi possiamo usare il comando query senza "timespan" per ottenere un elenco dei "primi dieci" giocatori di tutti i tempi.
Eseguiamo il comando query senza specificare un valore "timespan", utilizzando gli stessi valori di argomento che abbiamo utilizzato quando abbiamo eseguito il comando create.
java -jar target/leaderboard.jar query cloudspanner-leaderboard leaderboard
Dovresti vedere una risposta che include i "primi dieci" giocatori di tutti i tempi, come i seguenti:
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 query con gli argomenti necessari per eseguire una query sui "primi dieci" giocatori dell'anno specificando un "periodo" equivale al numero di ore in un anno che è 8760.
java -jar target/leaderboard.jar query cloudspanner-leaderboard leaderboard 8760
Dovresti vedere una risposta che include i "primi dieci" giocatori dell'anno come i seguenti:
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 query per interrogare i "primi dieci" giocatori del mese specificando un "intervallo di tempo" equivale al numero di ore di un mese, che è 730.
java -jar target/leaderboard.jar query cloudspanner-leaderboard leaderboard 730
Dovresti vedere una risposta che include i "primi dieci" giocatori del mese, come i seguenti:
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 query per interrogare i "primi dieci" giocatori della settimana specificando un "intervallo di tempo" equivale al numero di ore di una settimana che è 168.
java -jar target/leaderboard.jar query cloudspanner-leaderboard leaderboard 168
Dovresti vedere una risposta che include i "primi dieci" giocatori della settimana come i seguenti:
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 che aggiungi i record, Cloud Spanner scala il tuo database in base alle tue esigenze. Indipendentemente dalla crescita del tuo database, la classifica del tuo gioco può continuare a scalare con precisione con Cloud Spanner e la sua tecnologia Truetime.
7. Esegui la pulizia
Dopo il divertimento con Spanner dobbiamo ripulire il nostro parco giochi, risparmiando risorse e denaro preziosi. Fortunatamente, questo è un passaggio semplice. Basta accedere alla sezione Cloud Spanner della console Cloud ed eliminare l'istanza creata nel codelab denominato "Configura un'istanza Cloud Spanner".
8. Complimenti!
Argomenti trattati:
- Schema delle tabelle, dei database e delle istanze di Google Cloud Spanner per una classifica
- Creare un'applicazione console Java
- Creare un database e tabelle Spanner utilizzando la libreria client Java
- Caricare dati in un database Spanner utilizzando la libreria client Java
- Come eseguire una query nella sezione "Top dieci" Risultati dai dati utilizzando i timestamp di commit di Spanner e la libreria client Java.
Passaggi successivi:
- Leggi il white paper su Spanner sui CAP
- Scopri di più sulle best practice per la progettazione di schemi e le query
- Scopri di più sui timestamp di commit di Cloud Spanner
Inviaci il tuo feedback
- Dedica qualche istante a completare il nostro breve sondaggio