1. Przegląd
Google Cloud Spanner to w pełni zarządzana, skalowana w poziomie, globalnie rozproszona relacyjna baza danych, która zapewnia transakcje ACID i semantykę SQL bez utraty wydajności i wysokiej dostępności.
Z tego modułu dowiesz się, jak skonfigurować instancję Cloud Spanner. Poznasz kolejne etapy tworzenia bazy danych i schematu, które można wykorzystać w tabeli wyników w grze. Zacznij od utworzenia tabeli Players do przechowywania informacji o graczach i tabeli Scores do przechowywania wyników graczy.
Następnie wypełnisz tabele przykładowymi danymi. Następnie zakończysz laboratorium, uruchamiając kilka przykładowych zapytań z listy Top Ten i usuwając instancję, aby zwolnić zasoby.
Czego się nauczysz
- Jak skonfigurować instancję Cloud Spanner.
- Jak utworzyć bazę danych i tabele.
- Jak korzystać z kolumny sygnatury czasowej zatwierdzenia.
- Jak wczytać dane do tabeli bazy danych Cloud Spanner ze znacznikami czasu.
- Jak wysyłać zapytania do bazy danych Cloud Spanner.
- Jak usunąć instancję Cloud Spanner.
Czego potrzebujesz
Jak zamierzasz korzystać z tego samouczka?
Jak oceniasz korzystanie z Google Cloud Platform?
2. Konfiguracja i wymagania
Samodzielne konfigurowanie środowiska
Jeśli nie masz jeszcze konta Google (Gmail lub Google Apps), musisz je utworzyć. Zaloguj się w konsoli Google Cloud Platform ( console.cloud.google.com) i utwórz nowy projekt.
Jeśli masz już projekt, kliknij menu wyboru projektu w lewym górnym rogu konsoli:
i w wyświetlonym oknie kliknij przycisk „NOWY PROJEKT”, aby utworzyć nowy projekt:
Jeśli nie masz jeszcze projektu, powinien wyświetlić się taki dialog, w którym możesz utworzyć pierwszy projekt:
W kolejnym oknie dialogowym tworzenia projektu możesz wpisać szczegóły nowego projektu:
Zapamiętaj identyfikator projektu, który jest unikalną nazwą we wszystkich projektach Google Cloud (podana powyżej nazwa jest już zajęta i nie będzie działać w Twoim przypadku). W dalszej części tego laboratorium będzie on nazywany PROJECT_ID.
Następnie, jeśli nie zostało to jeszcze zrobione, musisz włączyć płatności w Konsoli deweloperów, aby korzystać z zasobów Google Cloud i włączyć interfejs Cloud Spanner API.
Wykonanie tego samouczka nie powinno kosztować więcej niż kilka dolarów, ale może okazać się droższe, jeśli zdecydujesz się wykorzystać więcej zasobów lub pozostawisz je uruchomione (patrz sekcja „Czyszczenie” na końcu tego dokumentu). Ceny Google Cloud Spanner są opisane tutaj.
Nowi użytkownicy Google Cloud Platform mogą skorzystać z bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD, co powinno sprawić, że ten samouczek będzie całkowicie bezpłatny.
Konfiguracja Google Cloud Shell
Z Google Cloud i Spanner można korzystać zdalnie na laptopie, ale w tym ćwiczeniu programistycznym będziemy używać Google Cloud Shell, czyli środowiska wiersza poleceń działającego w chmurze.
Ta maszyna wirtualna oparta na Debianie zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera również stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i usprawnia proces uwierzytelniania. Oznacza to, że do ukończenia tego ćwiczenia potrzebujesz tylko przeglądarki (działa ona na Chromebooku).
- Aby aktywować Cloud Shell w konsoli Cloud, kliknij Aktywuj Cloud Shell
(udostępnienie środowiska i połączenie się z nim powinno zająć tylko kilka chwil).
Po połączeniu z Cloud Shell zobaczysz, że uwierzytelnianie zostało już przeprowadzone, a projekt jest już ustawiony na Twój identyfikator projektu PROJECT_ID.
gcloud auth list
Wynik polecenia
Credentialed accounts: - <myaccount>@<mydomain>.com (active)
gcloud config list project
Wynik polecenia
[core] project = <PROJECT_ID>
Jeśli z jakiegoś powodu projekt nie jest ustawiony, po prostu wydaj to polecenie:
gcloud config set project <PROJECT_ID>
Szukasz urządzenia PROJECT_ID? Sprawdź, jakiego identyfikatora użyto w krokach konfiguracji, lub wyszukaj go w panelu konsoli Cloud:
Cloud Shell domyślnie ustawia też niektóre zmienne środowiskowe, które mogą być przydatne podczas wykonywania kolejnych poleceń.
echo $GOOGLE_CLOUD_PROJECT
Wynik polecenia
<PROJECT_ID>
- Na koniec ustaw domyślną strefę i konfigurację projektu.
gcloud config set compute/zone us-central1-f
Możesz wybrać różne strefy. Więcej informacji znajdziesz w artykule Regiony i strefy.
Podsumowanie
W tym kroku skonfigurujesz środowisko.
Dalsze czynności
Następnie skonfigurujesz instancję Cloud Spanner.
3. Konfigurowanie instancji Cloud Spanner
W tym kroku skonfigurujemy instancję Cloud Spanner na potrzeby tych ćwiczeń z programowania. Wyszukaj wpis Spanner 
w menu hamburger po lewej stronie u góry 
lub wyszukaj Spanner, naciskając „/” i wpisując „Spanner”.
Następnie kliknij 
i wypełnij formularz, wpisując nazwę instancji cloudspanner-leaderboard, wybierając konfigurację (wybierz instancję regionalną) i ustawiając liczbę węzłów. W tym laboratorium potrzebny będzie tylko 1 węzeł. W przypadku instancji produkcyjnych i aby kwalifikować się do gwarancji jakości usług Cloud Spanner, musisz uruchomić co najmniej 3 węzły w instancji Cloud Spanner.
Na koniec kliknij „Utwórz”. W ciągu kilku sekund będziesz mieć do dyspozycji instancję Cloud Spanner.
W następnym kroku użyjemy biblioteki klienta Java, aby utworzyć bazę danych i schemat w nowej instancji.
4. Tworzenie bazy danych i schematu
W tym kroku utworzymy przykładową bazę danych i schemat.
Użyjemy biblioteki klienta Java, aby utworzyć 2 tabele: Players (zawierającą informacje o graczach) i Scores (przechowującą wyniki graczy). W tym celu pokażemy, jak utworzyć aplikację konsolową w Javie w Cloud Shell.
Najpierw sklonuj przykładowy kod do tego ćwiczenia z GitHuba, wpisując w Cloud Shell to polecenie:
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
Następnie przejdź do katalogu „applications”, w którym utworzysz aplikację.
cd java-docs-samples/spanner/leaderboard
Cały kod wymagany w tym ćwiczeniu znajduje się w katalogu java-docs-samples/spanner/leaderboard/complete jako uruchamiana aplikacja w języku C# o nazwie Leaderboard. Będzie ona służyć jako punkt odniesienia w trakcie wykonywania ćwiczenia. Utworzymy nowy katalog i stopniowo skopiujemy aplikację Tabele wyników.
Utwórz nowy katalog o nazwie „codelab” na potrzeby aplikacji i przejdź do niego za pomocą tego polecenia:
mkdir codelab && cd $_
Utwórz nową podstawową aplikację w języku Java o nazwie „Leaderboard” za pomocą tego polecenia Maven (mvn):
mvn -B archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DgroupId=com.google.codelabs -DartifactId=leaderboard -DarchetypeVersion=1.4
To polecenie tworzy prostą aplikację konsolową składającą się z 2 plików głównych: pliku konfiguracji aplikacji Maven pom.xml i pliku aplikacji Java App.java.
Następnie przejdź do utworzonego katalogu tablicy wyników i wyświetl jego zawartość:
cd leaderboard && ls
Powinny być widoczne plik pom.xml i katalog src:
pom.xml src
Teraz zmodyfikujmy tę aplikację konsolową, edytując App.java, aby używać biblioteki klienta Spanner w języku Java do utworzenia tabeli wyników składającej się z 2 tabel: Players (Gracze) i Scores (Wyniki). Możesz to zrobić bezpośrednio w edytorze Cloud Shell:
Otwórz edytor Cloud Shell, klikając ikonę wyróżnioną poniżej:
Otwórz plik pom.xml w folderze leaderboard. Otwórz plik pom.xml znajdujący się w folderze java-docs-samples\ spanner\leaderboard\codelab\leaderboard.Ten plik konfiguruje system kompilacji Maven, aby skompilować aplikację do pliku JAR, w tym wszystkie zależności.
Dodaj tę nową sekcję zarządzania zależnościami bezpośrednio pod istniejącym elementem </properties>:
<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>
Dodaj też 1 nową zależność w sekcji <dependencies>, która doda do aplikacji bibliotekę klienta Cloud Spanner Java.
<dependency>
<!-- Version auto-managed by BOM -->
<groupId>com.google.cloud</groupId>
<artifactId>google-cloud-spanner</artifactId>
</dependency>
Następnie zastąp istniejącą sekcję <build> w pliku pom.xml tą sekcją <build>:
<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>
Zapisz zmiany wprowadzone w pliku pom.xml, wybierając „Zapisz” w menu „Plik” w Edytorze Cloud Shell lub naciskając jednocześnie klawisze „Ctrl” i „S”.
Następnie otwórz plik App.java w edytorze Cloud Shell znajdującym się w folderze src/main/java/com/google/codelabs/. Zastąp dotychczasowy kod w pliku kodem wymaganym do utworzenia bazy danych leaderboard oraz tabel Players i Scores, wklejając do pliku App.java ten kod w języku 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");
}
}
Zapisz zmiany wprowadzone w pliku App.java, wybierając „Zapisz” w menu „Plik” w edytorze Cloud Shell.
W pliku App.java w katalogu java-docs-samples/spanner/leaderboard/step4/src możesz zobaczyć przykład tego, jak powinien wyglądać plik App.java po dodaniu kodu umożliwiającego działanie polecenia create.
Aby skompilować aplikację, uruchom polecenie mvn package w katalogu, w którym znajduje się plik pom.xml:
mvn package
Po utworzeniu pliku JAR w języku Java uruchom powstałą aplikację w Cloud Shell, wpisując to polecenie:
java -jar target/leaderboard.jar
Powinny pojawić się dane wyjściowe podobne do tych:
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.
Z tej odpowiedzi wynika, że jest to aplikacja Leaderboard, która ma obecnie 1 możliwe polecenie: create. Widzimy, że oczekiwane argumenty polecenia create to identyfikator instancji i identyfikator bazy danych.
Teraz uruchom to polecenie.
java -jar target/leaderboard.jar create cloudspanner-leaderboard leaderboard
Po kilku sekundach powinna pojawić się odpowiedź podobna do tej:
Created database [projects/your-project/instances/cloudspanner-leaderboard/databases/leaderboard]
W sekcji Cloud Spanner w Cloud Console w menu po lewej stronie powinna być widoczna nowa baza danych i tabele.
W następnym kroku zaktualizujemy aplikację, aby wczytać dane do nowej bazy danych.
5. Wczytaj dane
Mamy teraz bazę danych o nazwie leaderboard zawierającą 2 tabele: Players i Scores. Teraz użyjemy biblioteki klienta Java, aby wypełnić tabelę Players graczami, a tabelę Scores losowymi wynikami każdego gracza.
Jeśli edytor Cloud Shell nie jest jeszcze otwarty, otwórz go, klikając ikonę wyróżnioną poniżej:
Następnie w edytorze Cloud Shell zmodyfikuj plik App.java, aby dodać polecenie insert, które można wykorzystać do wstawienia 100 graczy do tabeli Players lub do wstawienia 4 losowych wyników do tabeli Scores dla każdego gracza w tabeli Players.
Najpierw zaktualizuj sekcję imports u góry pliku aplikacji, zastępując obecną zawartość. Po zakończeniu powinna ona wyglądać tak:
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;
Następnie dodaj poniżej istniejącej metody create() i powyżej istniejącej metody printUsageAndExit() te metody: insert, insertPlayers i insertScores:
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...");
}
}
Aby polecenie insert działało, dodaj ten kod do metody „main” w aplikacji w instrukcji switch (command) :
case "insert":
String insertType;
try {
insertType = args[3];
} catch (ArrayIndexOutOfBoundsException exception) {
insertType = "";
}
insert(dbClient, insertType);
break;
Po zakończeniu switch (command) powinno wyglądać tak:
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();
}
Ostatnim krokiem, który musisz wykonać, aby dodać do aplikacji funkcję „wstaw”, jest dodanie tekstu pomocy do polecenia „wstaw” w metodzie printUsageAndExit(). Dodaj do metody printUsageAndExit() te wiersze kodu, aby uwzględnić tekst pomocy dotyczący polecenia wstawiania:
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");
Zapisz zmiany wprowadzone w pliku App.java, wybierając „Zapisz” w menu „Plik” w edytorze Cloud Shell.
W pliku App.java w katalogu java-docs-samples/spanner/leaderboard/step5/src możesz zobaczyć przykład tego, jak powinien wyglądać plik App.java po dodaniu kodu umożliwiającego działanie polecenia insert.
Teraz ponownie skompiluj i uruchom aplikację, aby sprawdzić, czy nowe polecenie insert znajduje się na liście możliwych poleceń.
Aby skompilować aplikację, uruchom mvn package w katalogu, w którym znajduje się plik pom.xml:
mvn package
Po utworzeniu pliku JAR w języku Java uruchom to polecenie:
java -jar target/leaderboard.jar
W domyślnych danych wyjściowych aplikacji powinno się teraz pojawić polecenie insert:
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.
Z odpowiedzi wynika, że oprócz identyfikatora instancji i identyfikatora bazy danych jest jeszcze jeden argument, który może mieć wartość „players” lub „scores”.
Teraz uruchom polecenie insert z tymi samymi wartościami argumentów, których użyliśmy podczas wywoływania polecenia create, dodając „players” jako dodatkowy argument „type of insert”.
java -jar target/leaderboard.jar insert cloudspanner-leaderboard leaderboard players
Po kilku sekundach powinna pojawić się odpowiedź podobna do tej:
Done inserting player records...
Teraz użyjemy biblioteki klienta Java, aby wypełnić tabelę Scores czterema losowymi wynikami wraz ze znacznikami czasu dla każdego gracza w tabeli Players.
Kolumna Timestamp tabeli Scores została zdefiniowana jako kolumna „sygnatura czasowa zatwierdzenia” za pomocą następującej instrukcji SQL, która została wykonana, gdy wcześniej uruchomiliśmy polecenie 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
Zwróć uwagę na atrybut OPTIONS(allow_commit_timestamp=true). Dzięki temu kolumna Timestamp staje się „sygnaturą czasową zatwierdzenia” i może być automatycznie wypełniana dokładną sygnaturą czasową transakcji w przypadku operacji INSERT i UPDATE w danym wierszu tabeli.
Możesz też wstawiać własne wartości sygnatury czasowej do kolumny „commit timestamp”, o ile wstawisz sygnaturę czasową z wartością z przeszłości. Tak właśnie zrobimy na potrzeby tego kursu.
Teraz uruchom polecenie insert z tymi samymi wartościami argumentów, których użyliśmy podczas wywoływania polecenia create, dodając „scores” jako dodatkowy argument „type of insert” (typ wstawienia).
java -jar target/leaderboard.jar insert cloudspanner-leaderboard leaderboard scores
Po kilku sekundach powinna pojawić się odpowiedź podobna do tej:
Done inserting score records...
Uruchomienie insert z określonym „typem wstawienia” jako scores wywołuje metodę insertScores, która używa tych fragmentów kodu do wstawiania losowo wygenerowanej sygnatury czasowej z datą i godziną z przeszłości:
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())
Aby automatycznie wypełnić kolumnę Timestamp sygnaturą czasową dokładnie w momencie wystąpienia transakcji „Wstaw”, możesz zamiast tego wstawić stałą Java Value.COMMIT_TIMESTAMP, jak w tym fragmencie kodu:
.bind("Timestamp")
.to(Value.COMMIT_TIMESTAMP)
Załadowaliśmy już dane, więc sprawdźmy teraz wartości, które właśnie zapisaliśmy w nowych tabelach. Najpierw wybierz bazę danych leaderboard, a potem tabelę Players. Kliknij kartę Data. W kolumnach PlayerId i PlayerName tabeli powinny być widoczne dane.
Następnie sprawdź, czy tabela Wyniki też zawiera dane. Aby to zrobić, kliknij tabelę Scores i wybierz kartę Data. Powinny być widoczne dane w kolumnach PlayerId, Timestamp i Score tabeli.
Brawo! Zaktualizujmy aplikację, aby wykonywała zapytania, które możemy wykorzystać do utworzenia tabeli wyników w grze.
6. Uruchamianie zapytań dotyczących tabeli wyników
Skonfigurowaliśmy już bazę danych i wczytaliśmy informacje do tabel. Teraz utwórzmy na podstawie tych danych tabelę wyników. Aby to zrobić, musimy odpowiedzieć na te 4 pytania:
- Którzy gracze należą do „Top Ten” wszech czasów?
- Którzy gracze są w „Top 10” roku?
- Którzy gracze należą do „Top 10” miesiąca?
- Którzy gracze znaleźli się w „Top 10” tygodnia?
Zaktualizujmy aplikację, aby uruchamiać zapytania SQL, które pozwolą odpowiedzieć na te pytania.
Dodamy polecenie query, które umożliwi uruchamianie zapytań w celu uzyskania odpowiedzi na pytania, które dostarczą informacji potrzebnych do utworzenia naszej tabeli wyników.
Edytuj plik App.java w edytorze Cloud Shell, aby zaktualizować aplikację i dodać polecenie query. Polecenie query składa się z 2 metod query. Jedna z nich przyjmuje tylko argument DatabaseClient, a druga dodatkowy argument timespan, który umożliwia filtrowanie wyników według przedziału czasu określonego w godzinach.
Dodaj te 2 metody query poniżej istniejącej metody insertScores() i powyżej istniejącej metody printUsageAndExit():
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));
}
}
Aby polecenie query działało, dodaj ten kod do instrukcji switch(command) w metodzie „main” aplikacji:
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;
Ostatnim krokiem dodawania do aplikacji funkcji „query” jest dodanie tekstu pomocy do polecenia „query” w metodzie printUsageAndExit(). Dodaj te wiersze kodu do metody printUsageAndExit(), aby uwzględnić tekst pomocy dotyczący polecenia „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");
Zapisz zmiany wprowadzone w pliku App.java, wybierając „Zapisz” w menu „Plik” w edytorze Cloud Shell.
W pliku App.java w katalogu dotnet-docs-samples/applications/leaderboard/step6/src możesz zobaczyć przykład tego, jak powinien wyglądać plik App.java po dodaniu kodu umożliwiającego działanie polecenia query.
Aby skompilować aplikację, uruchom mvn package w katalogu, w którym znajduje się plik pom.xml:
mvn package
Teraz uruchomimy aplikację, aby sprawdzić, czy nowe polecenie query znajduje się na liście możliwych poleceń. Uruchom to polecenie:
java -jar target/leaderboard.jar
Polecenie query powinno być teraz uwzględnione w domyślnych danych wyjściowych aplikacji jako nowa opcja polecenia:
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.
Z odpowiedzi wynika, że oprócz argumentów Instance ID i Database ID polecenie query umożliwia określenie opcjonalnego przedziału czasu w godzinach, który będzie używany do filtrowania rekordów na podstawie ich wartości w kolumnie Timestamp tabeli Scores. Argument przedziału czasu jest opcjonalny, co oznacza, że jeśli nie zostanie uwzględniony, żadne rekordy nie będą filtrowane według sygnatur czasowych. Możemy więc użyć polecenia query bez wartości „timespan”, aby uzyskać listę 10 najlepszych graczy wszech czasów.
Uruchommy polecenie query bez określania „timespan”, używając tych samych wartości argumentów, których użyliśmy podczas uruchamiania polecenia create.
java -jar target/leaderboard.jar query cloudspanner-leaderboard leaderboard
Powinna pojawić się odpowiedź zawierająca 10 najlepszych graczy wszech czasów, np. taka:
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
Teraz uruchom polecenie query z odpowiednimi argumentami, aby wyszukać 10 najlepszych graczy w danym roku. W tym celu określ „timespan” (okres) równy liczbie godzin w roku, czyli 8760.
java -jar target/leaderboard.jar query cloudspanner-leaderboard leaderboard 8760
Powinna pojawić się odpowiedź zawierająca 10 najlepszych graczy roku, np. taka:
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
Teraz uruchom polecenie query, aby wyszukać 10 najlepszych graczy w danym miesiącu, określając „timespan” (okres) równy liczbie godzin w miesiącu, czyli 730.
java -jar target/leaderboard.jar query cloudspanner-leaderboard leaderboard 730
Powinna pojawić się odpowiedź zawierająca „10 najlepszych” graczy w danym miesiącu, np. taka:
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
Teraz uruchom polecenie query, aby wysłać zapytanie o „Najlepszą dziesiątkę” graczy tygodnia, określając „timespan” równy liczbie godzin w tygodniu, czyli 168.
java -jar target/leaderboard.jar query cloudspanner-leaderboard leaderboard 168
Powinna się wyświetlić odpowiedź zawierająca „10 najlepszych” graczy tygodnia, np. taka:
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
Doskonale!
Teraz, gdy dodajesz rekordy, Cloud Spanner będzie skalować bazę danych do dowolnego rozmiaru. Niezależnie od tego, jak bardzo rozrośnie się Twoja baza danych, tablica wyników w grze może być nadal skalowana z dokładnością dzięki Cloud Spanner i technologii Truetime.
7. Czyszczenie
Po zabawie z usługą Spanner musimy posprzątać nasz plac zabaw, aby zaoszczędzić cenne zasoby i pieniądze. Na szczęście to łatwy krok. Wystarczy przejść do sekcji Cloud Spanner w konsoli Cloud i usunąć instancję utworzoną w kroku z samouczka o nazwie „Konfigurowanie instancji Cloud Spanner”.
8. Gratulacje!
Omówione zagadnienia:
- Instancje, bazy danych i schemat tabeli Google Cloud Spanner dla tablicy wyników
- Jak utworzyć aplikację konsolową w Javie
- Jak utworzyć bazę danych i tabele Spanner za pomocą biblioteki klienta w Javie
- Wczytywanie danych do bazy danych Spanner za pomocą biblioteki klienta w Javie
- Tworzenie zapytań o „10 najlepszych” wyników z danych za pomocą znaczników czasu zatwierdzenia Spanner i biblioteki klienta Java
Dalsze kroki:
- Przeczytaj dokument dotyczący spójności w Spannerze.
- Dowiedz się więcej o projektowaniu schematu i sprawdzonych metodach dotyczących zapytań.
- Dowiedz się więcej o sygnaturach czasu zatwierdzenia w Cloud Spanner.
Prześlij nam swoją opinię
- Poświęć chwilę na wypełnienie naszej krótkiej ankiety.