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.
W****ymagania
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 Go, 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.
Za pomocą biblioteki klienta Go utworzymy 2 tabele: Players (informacje o graczach) i Scores (wyniki graczy). W tym celu pokażemy, jak utworzyć aplikację konsolową w Go w Cloud Shell.
Najpierw sklonuj przykładowy kod do tego ćwiczenia z GitHuba, wpisując w Cloud Shell to polecenie:
export GO111MODULE=auto
go get -u github.com/GoogleCloudPlatform/golang-samples/spanner/...
Następnie przejdź do katalogu „leaderboard”, w którym utworzysz aplikację.
cd gopath/src/github.com/GoogleCloudPlatform/golang-samples/spanner/spanner_leaderboard
Cały kod wymagany w tym ćwiczeniu znajduje się w istniejącym golang-samples/spanner/spanner_leaderboard/katalogu jako uruchamiana aplikacja w Go o nazwie leaderboard. Możesz z niej korzystać jako materiału referencyjnego 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 $_
Teraz utwórzmy podstawową aplikację w Go o nazwie „Leaderboard”, która używa biblioteki klienta Spanner do utworzenia tabeli wyników składającej się z 2 tabel: Players i Scores. Możesz to zrobić bezpośrednio w edytorze Cloud Shell:
Otwórz edytor Cloud Shell, klikając ikonę „Otwórz edytor” wyróżnioną poniżej:
W folderze ~/gopath/src/github.com/GoogleCloudPlatform/golang-samples/spanner/codelab utwórz plik o nazwie „leaderboard.go”.
- Najpierw upewnij się, że w edytorze Cloud Shell na liście folderów masz wybrany folder „codelab”.
- Następnie w menu „Plik” edytora Cloud Shell wybierz „Nowy plik”.
- Jako nazwę nowego pliku wpisz „leaderboard.go”.
Jest to główny plik aplikacji, który będzie zawierać kod aplikacji i odwołania do wszystkich zależności.
Aby utworzyć bazę danych leaderboard oraz tabele Players i Scores, skopiuj (Ctrl + P) i wklej (Ctrl + V) do pliku leaderboard.go ten kod 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)
}
}
Zapisz zmiany wprowadzone w pliku leaderboard.go, wybierając „Zapisz” w menu „Plik” w edytorze Cloud Shell.
W pliku leaderboard.go w katalogu golang-samples/spanner/spanner_leaderboard możesz zobaczyć przykład tego, jak powinien wyglądać plik leaderboard.go po dodaniu kodu umożliwiającego działanie polecenia createdatabase.
Aby skompilować aplikację w Cloud Shell, uruchom polecenie „go build” w katalogu codelab, w którym znajduje się plik leaderboard.go:
go build leaderboard.go
Po pomyślnym skompilowaniu aplikacji uruchom ją w Cloud Shell, wpisując to polecenie:
./leaderboard
Powinny pojawić się dane wyjściowe podobne do tych:
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.
Z tej odpowiedzi wynika, że jest to aplikacja Leaderboard, która ma obecnie 1 możliwe polecenie: createdatabase. Widzimy, że oczekiwanym argumentem polecenia createdatabase jest ciąg znaków zawierający konkretny identyfikator instancji i identyfikator bazy danych.
Teraz uruchom to polecenie. Pamiętaj, aby zastąpić my-project identyfikatorem projektu utworzonym na początku tych ćwiczeń z programowania.
./leaderboard createdatabase projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard
Po kilku sekundach powinna pojawić się odpowiedź podobna do tej:
Created database [projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard]
W sekcji przeglądu baz danych Cloud Spanner w konsoli Cloud w menu po lewej stronie powinna pojawić się 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 Go, aby wypełnić tabelę Players graczami, a tabelę Scores losowymi wynikami dla każdego gracza.
Jeśli edytor Cloud Shell nie jest jeszcze otwarty, otwórz go, klikając ikonę wyróżnioną poniżej:
Następnie edytuj plik leaderboard.go w edytorze Cloud Shell, aby dodać polecenie insertplayers, które można wykorzystać do wstawienia 100 graczy do tabeli Players. Dodamy też polecenie insertscores, które można wykorzystać do wstawienia 4 losowych wyników do tabeli Scores dla każdego gracza w tabeli Players.
Najpierw zaktualizuj sekcję imports u góry pliku leaderboard.go, zastępując obecną zawartość. Po zakończeniu powinna ona wyglądać tak:
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"
)
Następnie dodaj nowy typ polecenia wraz z listą poleceń u góry pliku, tuż pod wierszem zaczynającym się od „type adminCommand ...”, aby po zakończeniu wyglądało to tak:
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,
}
)
Następnie dodaj te funkcje insertPlayers i insertScores poniżej istniejącej funkcji createdatabase():
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
}
Następnie, aby polecenie insert działało, dodaj ten kod do funkcji „run” aplikacji poniżej instrukcji obsługi createdatabase, zastępując instrukcję 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
Gdy skończysz, funkcja run powinna wyglądać tak:
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
}
Ostatnim krokiem dodawania funkcji „insert” do aplikacji jest dodanie tekstu pomocy dla poleceń „insertplayers” i „insertscores” do funkcji flag.Usage(). Dodaj do funkcji flag.Usage() ten tekst pomocy, aby uwzględnić tekst pomocy dotyczący poleceń wstawiania:
Dodaj do listy możliwych poleceń te 2 polecenia:
Command can be one of: createdatabase, insertplayers, insertscores
Dodaj ten dodatkowy tekst pomocy pod tekstem pomocy dotyczącym polecenia 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.
Zapisz zmiany wprowadzone w pliku leaderboard.go, wybierając „Zapisz” w menu „Plik” w edytorze Cloud Shell.
W pliku leaderboard.go w katalogu golang-samples/spanner/spanner_leaderboard znajdziesz przykład tego, jak powinien wyglądać plik leaderboard.go po dodaniu kodu umożliwiającego korzystanie z poleceń insertplayers i insertscores.
Teraz skompilujmy i uruchommy aplikację, aby sprawdzić, czy nowe polecenia insertplayers i insertscores znajdują się na liście możliwych poleceń aplikacji. Aby utworzyć aplikację, uruchom to polecenie:
go build leaderboard.go
Uruchom utworzoną aplikację w Cloud Shell, wpisując to polecenie:
./leaderboard
W domyślnych danych wyjściowych aplikacji powinny się teraz pojawić polecenia insertplayers i insertscores:
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.
Teraz uruchom polecenie insertplayers z tymi samymi wartościami argumentów, których użyliśmy podczas wywoływania polecenia createdatabase. Pamiętaj, aby zastąpić my-project identyfikatorem projektu utworzonym na początku tych ćwiczeń z programowania.
./leaderboard insertplayers projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard
Po kilku sekundach powinna pojawić się odpowiedź podobna do tej:
Inserted players
Teraz użyjemy biblioteki klienta Go, aby wypełnić tabelę Scores 4 losowymi wynikami wraz z sygnaturami czasowymi 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. W tym ćwiczeniu zrobimy właśnie to.
Teraz uruchom polecenie insertscores z tymi samymi wartościami argumentów, których użyliśmy podczas wywoływania polecenia insertplayers. Pamiętaj, aby zastąpić my-project identyfikatorem projektu utworzonym na początku tych ćwiczeń z programowania.
./leaderboard insertscores projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard
Po kilku sekundach powinna pojawić się odpowiedź podobna do tej:
Inserted scores
Uruchomienie funkcji insertScores powoduje wstawienie losowo wygenerowanego sygnatury czasowej z datą i godziną z przeszłości za pomocą tego fragmentu kodu:
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,
},
})
Aby automatycznie wypełniać kolumnę Timestamp sygnaturą czasową dokładnie w momencie transakcji „Wstaw”, możesz zamiast tego wstawić stałą Go spanner.CommitTimestamp, jak w tym fragmencie kodu:
...
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,
},
})
Po zakończeniu wczytywania danych sprawdźmy wartości, które właśnie zapisaliśmy w nowych tabelach w sekcji Cloud Spanner w Cloud Console. 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ła zapytania SQL, które pozwolą odpowiedzieć na te pytania.
Dodamy polecenie query i polecenie queryWithTimespan, które umożliwią uruchamianie zapytań w celu uzyskania odpowiedzi na pytania, które dostarczą informacji wymaganych na potrzeby naszej tabeli wyników.
Edytuj plik leaderboard.go w edytorze Cloud Shell, aby zaktualizować aplikację i dodać polecenia query i queryWithTimespan. Dodamy też funkcję pomocniczą formatWithCommas, która będzie formatować wyniki za pomocą przecinków.
Najpierw zaktualizuj sekcję imports u góry pliku leaderboard.go, zastępując obecną zawartość. Po zakończeniu powinna ona wyglądać tak:
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"
)
Następnie dodaj te 2 funkcje i funkcję pomocniczą pod istniejącą metodą insertScores:
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()
}
Następnie u góry pliku leaderboard.go dodaj „query” jako jedną z opcji polecenia w zmiennej commands, tuż pod opcją „insertscores": insertScores”, tak aby zmienna commands wyglądała tak:
var (
commands = map[string]command{
"insertplayers": insertPlayers,
"insertscores": insertScores,
"query": query,
}
)
Następnie dodaj „queryWithTimespan” jako opcję polecenia w funkcji run, poniżej sekcji polecenia „createdatabase” i powyżej sekcji poleceń „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
}
Gdy skończysz, funkcja run powinna wyglądać tak:
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
}
Następnie, aby polecenie queryWithTimespan działało, zaktualizuj blok kodu flag.Parse() w metodzie „main” aplikacji, aby wyglądał tak:
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)
}
Ostatnim krokiem, który musisz wykonać, aby dodać do aplikacji funkcję „query”, jest dodanie tekstu pomocy do poleceń „query” i „querywithtimespan” w funkcji flag.Usage(). Dodaj do funkcji flag.Usage() te wiersze kodu, aby uwzględnić tekst pomocy dotyczący poleceń zapytań:
Dodaj do listy możliwych poleceń 2 polecenia „query”:
Command can be one of: createdatabase, insertplayers, insertscores, query, querywithtimespan
Dodaj ten dodatkowy tekst pomocy pod tekstem pomocy dotyczącym polecenia 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.
Zapisz zmiany wprowadzone w pliku leaderboard.go, wybierając „Zapisz” w menu „Plik” w edytorze Cloud Shell.
W pliku leaderboard.go w katalogu golang-samples/spanner/spanner_leaderboard znajdziesz przykład tego, jak powinien wyglądać plik leaderboard.go po dodaniu kodu umożliwiającego korzystanie z poleceń query i querywithtimespan.
Teraz skompilujmy i uruchommy aplikację, aby sprawdzić, czy nowe polecenia query i querywithtimespan znajdują się na liście możliwych poleceń aplikacji.
Aby utworzyć aplikację, uruchom w Cloud Shell to polecenie:
go build leaderboard.go
Uruchom utworzoną aplikację w Cloud Shell, wpisując to polecenie:
./leaderboard
Polecenia query i querywithtimespan powinny być teraz uwzględnione w domyślnych danych wyjściowych aplikacji jako nowa opcja polecenia:
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.
Z odpowiedzi wynika, że możemy użyć polecenia query, aby uzyskać listę 10 najlepszych graczy wszech czasów. Widzimy też, że polecenie querywithtimespan pozwala określić przedział czasu w godzinach, który będzie używany do filtrowania rekordów na podstawie ich wartości w kolumnie Timestamp tabeli Scores.
Uruchommy polecenie query, używając tych samych wartości argumentów, których użyliśmy podczas uruchamiania polecenia create. Pamiętaj, aby zastąpić my-project identyfikatorem projektu utworzonym na początku tych ćwiczeń z programowania.
./leaderboard query projects/my-project/instances/cloudspanner-leaderboard/databases/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 querywithtimespan 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. Pamiętaj, aby zastąpić my-project identyfikatorem projektu utworzonym na początku tych ćwiczeń z programowania.
./leaderboard querywithtimespan projects/my-project/instances/cloudspanner-leaderboard/databases/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 querywithtimespan, aby wyszukać 10 najlepszych graczy w danym miesiącu, określając „timespan” (okres) równy liczbie godzin w miesiącu, czyli 730. Pamiętaj, aby zastąpić my-project identyfikatorem projektu utworzonym na początku tych ćwiczeń z programowania.
./leaderboard querywithtimespan projects/my-project/instances/cloudspanner-leaderboard/databases/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 querywithtimespan, aby wysłać zapytanie o „Najlepszą dziesiątkę” graczy tygodnia, określając „timespan” równy liczbie godzin w tygodniu, czyli 168. Pamiętaj, aby zastąpić my-project identyfikatorem projektu utworzonym na początku tych ćwiczeń z programowania.
./leaderboard querywithtimespan projects/my-project/instances/cloudspanner-leaderboard/databases/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 Go
- Jak utworzyć bazę danych i tabele Spanner za pomocą biblioteki klienta w języku Go
- Wczytywanie danych do bazy danych Spanner za pomocą biblioteki klienta w języku Go
- Jak wysyłać zapytania o „10 najlepszych” wyników z danych za pomocą sygnatur czasowych zatwierdzenia w Spannerze i biblioteki klienta Go
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.