1. ภาพรวม
Google Cloud Spanner เป็นบริการฐานข้อมูลเชิงสัมพันธ์ที่มีการจัดการครบวงจรซึ่งปรับขนาดในแนวนอนได้ กระจายอยู่ทั่วโลก และมอบธุรกรรม ACID และความหมายของ SQL โดยไม่ลดทอนประสิทธิภาพและความพร้อมใช้งานสูง
ในแล็บนี้ คุณจะได้เรียนรู้วิธีตั้งค่าอินสแตนซ์ Cloud Spanner คุณจะได้ดูขั้นตอนการสร้างฐานข้อมูลและสคีมาที่ใช้กับลีดเดอร์บอร์ดเกมได้ คุณจะเริ่มต้นด้วยการสร้างตารางผู้เล่นเพื่อจัดเก็บข้อมูลผู้เล่น และตารางคะแนนเพื่อจัดเก็บคะแนนของผู้เล่น
จากนั้นคุณจะป้อนข้อมูลตัวอย่างลงในตาราง จากนั้นคุณจะสรุปแล็บด้วยการเรียกใช้ตัวอย่างคำค้นหายอดนิยม 10 อันดับ และสุดท้ายคือลบอินสแตนซ์เพื่อเพิ่มพื้นที่ว่างสำหรับทรัพยากร
สิ่งที่คุณจะได้เรียนรู้
- วิธีตั้งค่าอินสแตนซ์ Cloud Spanner
- วิธีสร้างฐานข้อมูลและตาราง
- วิธีใช้คอลัมน์การประทับเวลาการคอมมิต
- วิธีโหลดข้อมูลลงในตารางฐานข้อมูล Cloud Spanner ที่มีแสตมป์เวลา
- วิธีค้นหาฐานข้อมูล Cloud Spanner
- วิธียกเลิกอินสแตนซ์ Cloud Spanner
W****สิ่งที่คุณต้องมี
คุณจะใช้บทแนะนำนี้อย่างไร
คุณจะให้คะแนนประสบการณ์การใช้งาน Google Cloud Platform เท่าไร
2. การตั้งค่าและข้อกำหนด
การตั้งค่าสภาพแวดล้อมแบบเรียนรู้ด้วยตนเอง
หากยังไม่มีบัญชี Google (Gmail หรือ Google Apps) คุณต้องสร้างบัญชี ลงชื่อเข้าใช้คอนโซล Google Cloud Platform ( console.cloud.google.com) แล้วสร้างโปรเจ็กต์ใหม่
หากมีโปรเจ็กต์อยู่แล้ว ให้คลิกเมนูแบบเลื่อนลงเพื่อเลือกโปรเจ็กต์ที่ด้านซ้ายบนของคอนโซล
แล้วคลิกปุ่ม "โปรเจ็กต์ใหม่" ในกล่องโต้ตอบที่ปรากฏขึ้นเพื่อสร้างโปรเจ็กต์ใหม่
หากยังไม่มีโปรเจ็กต์ คุณจะเห็นกล่องโต้ตอบแบบนี้เพื่อสร้างโปรเจ็กต์แรก
กล่องโต้ตอบการสร้างโปรเจ็กต์ในภายหลังจะช่วยให้คุณป้อนรายละเอียดของโปรเจ็กต์ใหม่ได้
โปรดจดจำรหัสโปรเจ็กต์ ซึ่งเป็นชื่อที่ไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมด (ชื่อด้านบนมีผู้ใช้แล้วและจะใช้ไม่ได้ ขออภัย) ซึ่งจะเรียกว่า PROJECT_ID ในภายหลังใน Codelab นี้
จากนั้น หากยังไม่ได้ดำเนินการ คุณจะต้องเปิดใช้การเรียกเก็บเงินใน Developers Console เพื่อใช้ทรัพยากร Google Cloud และเปิดใช้ Cloud Spanner API
การทำตาม Codelab นี้ไม่ควรมีค่าใช้จ่ายเกิน 2-3 ดอลลาร์ แต่ก็อาจมีค่าใช้จ่ายมากกว่านี้หากคุณตัดสินใจใช้ทรัพยากรเพิ่มเติมหรือปล่อยให้ทรัพยากรทำงานต่อไป (ดูส่วน "การล้างข้อมูล" ที่ท้ายเอกสารนี้) ดูเอกสารประกอบเกี่ยวกับการกำหนดราคาของ Google Cloud Spanner ได้ที่นี่
ผู้ใช้ใหม่ของ Google Cloud Platform มีสิทธิ์รับช่วงทดลองใช้ฟรีมูลค่า$300 ซึ่งจะทำให้ Codelab นี้ไม่มีค่าใช้จ่ายใดๆ
การตั้งค่า Google Cloud Shell
แม้ว่าคุณจะใช้งาน Google Cloud และ Spanner จากแล็ปท็อประยะไกลได้ แต่ใน Codelab นี้เราจะใช้ Google Cloud Shell ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานในระบบคลาวด์
เครื่องเสมือนที่ใช้ Debian นี้มาพร้อมเครื่องมือพัฒนาทั้งหมดที่คุณต้องการ โดยมีไดเรกทอรีหลักแบบถาวรขนาด 5 GB และทำงานใน Google Cloud ซึ่งช่วยเพิ่มประสิทธิภาพเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก ซึ่งหมายความว่าคุณจะต้องมีเพียงเบราว์เซอร์เท่านั้นสำหรับโค้ดแล็บนี้ (ใช่แล้ว ใช้ได้ใน Chromebook)
- หากต้องการเปิดใช้งาน Cloud Shell จาก Cloud Console เพียงคลิกเปิดใช้งาน Cloud Shell
(ระบบจะใช้เวลาเพียงไม่กี่นาทีในการจัดสรรและเชื่อมต่อกับสภาพแวดล้อม)
เมื่อเชื่อมต่อกับ Cloud Shell แล้ว คุณควรเห็นว่าระบบได้ตรวจสอบสิทธิ์คุณแล้ว และตั้งค่าโปรเจ็กต์เป็น PROJECT_ID แล้ว
gcloud auth list
เอาต์พุตของคำสั่ง
Credentialed accounts: - <myaccount>@<mydomain>.com (active)
gcloud config list project
เอาต์พุตของคำสั่ง
[core] project = <PROJECT_ID>
หากไม่ได้ตั้งค่าโปรเจ็กต์ด้วยเหตุผลบางประการ ให้เรียกใช้คำสั่งต่อไปนี้
gcloud config set project <PROJECT_ID>
หากกำลังมองหา PROJECT_ID ตรวจสอบว่าคุณใช้รหัสใดในขั้นตอนการตั้งค่า หรือค้นหารหัสในแดชบอร์ด Cloud Console
นอกจากนี้ Cloud Shell ยังตั้งค่าตัวแปรสภาพแวดล้อมบางอย่างโดยค่าเริ่มต้น ซึ่งอาจมีประโยชน์เมื่อคุณเรียกใช้คำสั่งในอนาคต
echo $GOOGLE_CLOUD_PROJECT
เอาต์พุตของคำสั่ง
<PROJECT_ID>
- สุดท้าย ให้ตั้งค่าโซนเริ่มต้นและการกำหนดค่าโปรเจ็กต์
gcloud config set compute/zone us-central1-f
คุณเลือกโซนต่างๆ ได้หลากหลาย ดูข้อมูลเพิ่มเติมได้ที่ภูมิภาคและโซน
สรุป
ในขั้นตอนนี้ คุณจะได้ตั้งค่าสภาพแวดล้อม
ถัดไป
จากนั้นคุณจะตั้งค่าอินสแตนซ์ Cloud Spanner
3. ตั้งค่าอินสแตนซ์ Cloud Spanner
ในขั้นตอนนี้ เราจะตั้งค่าอินสแตนซ์ Cloud Spanner สำหรับ Codelab นี้ ค้นหารายการ Spanner 
ในเมนูแฮมเบอร์เกอร์ด้านซ้ายบน 
หรือค้นหา Spanner โดยกด "/" แล้วพิมพ์ "Spanner"
จากนั้นคลิก 
แล้วกรอกแบบฟอร์มโดยป้อนชื่ออินสแตนซ์ cloudspanner-leaderboard สำหรับอินสแตนซ์ เลือกการกำหนดค่า (เลือกอินสแตนซ์ระดับภูมิภาค) และตั้งค่าจำนวนโหนด สำหรับ Codelab นี้ เราต้องการเพียง 1 โหนด สำหรับอินสแตนซ์ที่ใช้งานจริงและเพื่อให้มีสิทธิ์รับ SLA ของ Cloud Spanner คุณจะต้องเรียกใช้โหนดอย่างน้อย 3 โหนดในอินสแตนซ์ Cloud Spanner
สุดท้าย ให้คลิก "สร้าง" แล้วคุณจะมีอินสแตนซ์ Cloud Spanner พร้อมใช้งานภายในไม่กี่วินาที
ในขั้นตอนถัดไป เราจะใช้ไลบรารีของไคลเอ็นต์ Go เพื่อสร้างฐานข้อมูลและสคีมาในอินสแตนซ์ใหม่
4. สร้างฐานข้อมูลและสคีมา
ในขั้นตอนนี้ เราจะสร้างฐานข้อมูลและสคีมาตัวอย่าง
มาใช้ไลบรารีไคลเอ็นต์ Go เพื่อสร้างตาราง 2 ตารางกัน ตาราง Players สำหรับข้อมูลผู้เล่น และตาราง Scores สำหรับจัดเก็บคะแนนของผู้เล่น โดยเราจะแนะนำขั้นตอนการสร้างแอปพลิเคชันคอนโซล Go ใน Cloud Shell
ก่อนอื่นให้โคลนโค้ดตัวอย่างสำหรับ Codelab นี้จาก Github โดยพิมพ์คำสั่งต่อไปนี้ใน Cloud Shell
export GO111MODULE=auto
go get -u github.com/GoogleCloudPlatform/golang-samples/spanner/...
จากนั้นเปลี่ยนไดเรกทอรีเป็นไดเรกทอรี "ลีดเดอร์บอร์ด" ที่คุณจะสร้างแอปพลิเคชัน
cd gopath/src/github.com/GoogleCloudPlatform/golang-samples/spanner/spanner_leaderboard
โค้ดทั้งหมดที่จำเป็นสำหรับโค้ดแล็บนี้อยู่ในgolang-samples/spanner/spanner_leaderboard/ไดเรกทอรีที่มีอยู่แล้วในรูปแบบแอปพลิเคชัน Go ที่เรียกใช้ได้ชื่อ leaderboard เพื่อใช้เป็นข้อมูลอ้างอิงขณะที่คุณทำตามโค้ดแล็บ เราจะสร้างไดเรกทอรีใหม่และสร้างสำเนาแอปพลิเคชันลีดเดอร์บอร์ดเป็นระยะๆ
สร้างไดเรกทอรีใหม่ชื่อ "codelab" สำหรับแอปพลิเคชัน แล้วเปลี่ยนไดเรกทอรีเป็นไดเรกทอรีดังกล่าวด้วยคำสั่งต่อไปนี้
mkdir codelab && cd $_
ตอนนี้มาสร้างแอปพลิเคชัน Go พื้นฐานชื่อ "ลีดเดอร์บอร์ด" ที่ใช้ไลบรารีไคลเอ็นต์ Spanner เพื่อสร้างลีดเดอร์บอร์ดที่ประกอบด้วย 2 ตาราง ได้แก่ ผู้เล่นและคะแนน คุณทำได้ใน Cloud Shell Editor โดยทำดังนี้
เปิด Cloud Shell Editor โดยคลิกไอคอน "เปิดโปรแกรมแก้ไข" ที่ไฮไลต์ไว้ด้านล่าง
สร้างไฟล์ชื่อ "leaderboard.go" ในโฟลเดอร์ ~/gopath/src/github.com/GoogleCloudPlatform/golang-samples/spanner/codelab
- ก่อนอื่น ตรวจสอบว่าคุณได้เลือกโฟลเดอร์ "codelab" ในรายการโฟลเดอร์ของ Cloud Shell Editor
- จากนั้นเลือก "ไฟล์ใหม่" ในเมนู "ไฟล์" ของ Cloud Shell Editor
- ป้อน "leaderboard.go" เป็นชื่อของไฟล์ใหม่
นี่คือไฟล์หลักของแอปพลิเคชันซึ่งจะมีโค้ดแอปพลิเคชันและการอ้างอิงเพื่อรวมทรัพยากร Dependency
หากต้องการสร้างleaderboardฐานข้อมูล รวมถึงตาราง Players และ Scores ให้คัดลอก (Ctrl + P) และวาง (Ctrl + V) โค้ด Go ต่อไปนี้ลงในไฟล์ leaderboard.go
package main
import (
"context"
"flag"
"fmt"
"io"
"log"
"os"
"regexp"
"time"
"cloud.google.com/go/spanner"
database "cloud.google.com/go/spanner/admin/database/apiv1"
adminpb "google.golang.org/genproto/googleapis/spanner/admin/database/v1"
)
type adminCommand func(ctx context.Context, w io.Writer, adminClient *database.DatabaseAdminClient, database string) error
func createDatabase(ctx context.Context, w io.Writer, adminClient *database.DatabaseAdminClient, db string) error {
matches := regexp.MustCompile("^(.*)/databases/(.*)$").FindStringSubmatch(db)
if matches == nil || len(matches) != 3 {
return fmt.Errorf("Invalid database id %s", db)
}
op, err := adminClient.CreateDatabase(ctx, &adminpb.CreateDatabaseRequest{
Parent: matches[1],
CreateStatement: "CREATE DATABASE `" + matches[2] + "`",
ExtraStatements: []string{
`CREATE TABLE Players(
PlayerId INT64 NOT NULL,
PlayerName STRING(2048) NOT NULL
) PRIMARY KEY(PlayerId)`,
`CREATE TABLE Scores(
PlayerId INT64 NOT NULL,
Score INT64 NOT NULL,
Timestamp TIMESTAMP NOT NULL
OPTIONS(allow_commit_timestamp=true)
) PRIMARY KEY(PlayerId, Timestamp),
INTERLEAVE IN PARENT Players ON DELETE NO ACTION`,
},
})
if err != nil {
return err
}
if _, err := op.Wait(ctx); err != nil {
return err
}
fmt.Fprintf(w, "Created database [%s]\n", db)
return nil
}
func createClients(ctx context.Context, db string) (*database.DatabaseAdminClient, *spanner.Client) {
adminClient, err := database.NewDatabaseAdminClient(ctx)
if err != nil {
log.Fatal(err)
}
dataClient, err := spanner.NewClient(ctx, db)
if err != nil {
log.Fatal(err)
}
return adminClient, dataClient
}
func run(ctx context.Context, adminClient *database.DatabaseAdminClient, dataClient *spanner.Client, w io.Writer,
cmd string, db string, timespan int) error {
// createdatabase command
if cmd == "createdatabase" {
err := createDatabase(ctx, w, adminClient, db)
if err != nil {
fmt.Fprintf(w, "%s failed with %v", cmd, err)
}
return err
}
return nil
}
func main() {
flag.Usage = func() {
fmt.Fprintf(os.Stderr, `Usage: leaderboard <command> <database_name> [command_option]
Command can be one of: createdatabase
Examples:
leaderboard createdatabase projects/my-project/instances/my-instance/databases/example-db
- Create a sample Cloud Spanner database along with sample tables in your project.
`)
}
flag.Parse()
flagCount := len(flag.Args())
if flagCount != 2 {
flag.Usage()
os.Exit(2)
}
cmd, db := flag.Arg(0), flag.Arg(1)
// Set timespan to zero, as it's not currently being used
var timespan int = 0
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Minute)
defer cancel()
adminClient, dataClient := createClients(ctx, db)
if err := run(ctx, adminClient, dataClient, os.Stdout, cmd, db, timespan); err != nil {
os.Exit(1)
}
}
บันทึกการเปลี่ยนแปลงที่คุณทำกับไฟล์ leaderboard.go โดยเลือก "บันทึก" ในเมนู "ไฟล์" ของ Cloud Shell Editor
คุณใช้ไฟล์ leaderboard.go ในไดเรกทอรี golang-samples/spanner/spanner_leaderboard เพื่อดูตัวอย่างลักษณะของไฟล์ leaderboard.go หลังจากเพิ่มโค้ดเพื่อเปิดใช้คำสั่ง createdatabase แล้วได้
หากต้องการสร้างแอปใน Cloud Shell ให้เรียกใช้ "go build" จากไดเรกทอรี codelab ที่มีไฟล์ leaderboard.go อยู่
go build leaderboard.go
เมื่อสร้างแอปพลิเคชันสำเร็จแล้ว ให้เรียกใช้แอปพลิเคชันที่ได้ใน Cloud Shell โดยป้อนคำสั่งต่อไปนี้
./leaderboard
คุณควรเห็นเอาต์พุตดังต่อไปนี้
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.
จากการตอบกลับนี้ เราจะเห็นว่านี่คือแอปพลิเคชัน Leaderboard ซึ่งปัจจุบันมีคำสั่งที่ใช้ได้ 1 คำสั่งคือ createdatabase เราจะเห็นว่าอาร์กิวเมนต์ที่คาดไว้ของคำสั่ง createdatabase คือสตริงที่มีรหัสอินสแตนซ์และรหัสฐานข้อมูลที่เฉพาะเจาะจง
ตอนนี้ให้เรียกใช้คำสั่งต่อไปนี้ ตรวจสอบว่าคุณได้แทนที่ my-project ด้วยรหัสโปรเจ็กต์ที่สร้างไว้ตอนต้นของโค้ดแล็บนี้
./leaderboard createdatabase projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard
หลังจากผ่านไป 2-3 วินาที คุณควรเห็นการตอบกลับดังต่อไปนี้
Created database [projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard]
ในส่วนภาพรวมฐานข้อมูล Cloud Spanner ของ Cloud Console คุณควรเห็นฐานข้อมูลและตารางใหม่ปรากฏในเมนูด้านซ้าย
ในขั้นตอนถัดไป เราจะอัปเดตแอปพลิเคชันเพื่อโหลดข้อมูลบางอย่างลงในฐานข้อมูลใหม่
5. โหลดข้อมูล
ตอนนี้เรามีฐานข้อมูลชื่อ leaderboard ซึ่งมี 2 ตาราง ได้แก่ Players และ Scores ตอนนี้เรามาใช้ไลบรารีไคลเอ็นต์ Go เพื่อป้อนข้อมูลตาราง Players ด้วยผู้เล่น และตาราง Scores ด้วยคะแนนแบบสุ่มสำหรับผู้เล่นแต่ละคนกัน
หากยังไม่ได้เปิด ให้เปิด Cloud Shell Editor โดยคลิกไอคอนที่ไฮไลต์ด้านล่าง
จากนั้นแก้ไขไฟล์ leaderboard.go ใน Cloud Shell Editor เพื่อเพิ่มคำสั่ง insertplayers ที่ใช้แทรกผู้เล่น 100 คนลงในตาราง Players ได้ นอกจากนี้ เราจะเพิ่มคำสั่ง insertscores ที่ใช้เพื่อแทรกคะแนนแบบสุ่ม 4 รายการในตาราง Scores สำหรับผู้เล่นแต่ละคนในตาราง Players
ก่อนอื่นให้อัปเดตส่วน imports ที่ด้านบนของไฟล์ leaderboard.go โดยแทนที่ข้อมูลที่มีอยู่เพื่อให้เมื่อดำเนินการเสร็จแล้ว ไฟล์จะมีลักษณะดังนี้
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"
)
จากนั้นเพิ่มประเภทคำสั่งใหม่พร้อมกับรายการคำสั่งที่ด้านบนของไฟล์ ใต้บรรทัดที่ขึ้นต้นด้วย "type adminCommand ..." เพื่อให้เมื่อคุณทำเสร็จแล้วจะมีลักษณะดังนี้
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,
}
)
จากนั้นเพิ่มฟังก์ชัน insertPlayers และ insertScores ต่อไปนี้ใต้ฟังก์ชัน 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
}
จากนั้นเพิ่มโค้ดต่อไปนี้ลงในฟังก์ชัน "run" ของแอปพลิเคชันใต้คำสั่งการจัดการ createdatabase โดยแทนที่คำสั่ง return nil เพื่อให้คำสั่ง insert ทำงานได้
// 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
เมื่อเสร็จแล้ว ฟังก์ชัน run ควรมีลักษณะดังนี้
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
}
ขั้นตอนสุดท้ายในการเพิ่มฟังก์ชัน "แทรก" ลงในแอปพลิเคชันคือการเพิ่มข้อความช่วยเหลือสำหรับคำสั่ง "insertplayers" และ "insertscores" ลงในflag.Usage()ฟังก์ชัน เพิ่มข้อความช่วยเหลือต่อไปนี้ลงในflag.Usage()ฟังก์ชันเพื่อรวมข้อความช่วยเหลือสำหรับคำสั่งแทรก
เพิ่ม 2 คำสั่งต่อไปนี้ลงในรายการคำสั่งที่เป็นไปได้
Command can be one of: createdatabase, insertplayers, insertscores
และเพิ่มข้อความช่วยเหลือเพิ่มเติมนี้ใต้ข้อความช่วยเหลือสำหรับคำสั่ง 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.
บันทึกการเปลี่ยนแปลงที่คุณทำกับไฟล์ leaderboard.go โดยเลือก "บันทึก" ในเมนู "ไฟล์" ของ Cloud Shell Editor
คุณใช้ไฟล์ leaderboard.go ในไดเรกทอรี golang-samples/spanner/spanner_leaderboard เพื่อดูตัวอย่างลักษณะของไฟล์ leaderboard.go หลังจากเพิ่มโค้ดเพื่อเปิดใช้คำสั่ง insertplayers และ insertscores
ตอนนี้เรามาสร้างและเรียกใช้แอปพลิเคชันเพื่อยืนยันว่าคำสั่ง insertplayers และ insertscores ใหม่รวมอยู่ในรายการคำสั่งที่เป็นไปได้ของแอปพลิเคชัน เรียกใช้คำสั่งต่อไปนี้เพื่อสร้างแอปพลิเคชัน
go build leaderboard.go
เรียกใช้แอปพลิเคชันที่ได้ใน Cloud Shell โดยป้อนคำสั่งต่อไปนี้
./leaderboard
ตอนนี้คุณควรเห็นคำสั่ง insertplayers และ 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.
ตอนนี้เรามาเรียกใช้คำสั่ง insertplayers โดยใช้ค่าอาร์กิวเมนต์เดียวกันกับที่เราใช้เมื่อเรียกใช้คำสั่ง createdatabase ตรวจสอบว่าคุณได้แทนที่ my-project ด้วยรหัสโปรเจ็กต์ที่สร้างไว้ตอนต้นของโค้ดแล็บนี้
./leaderboard insertplayers projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard
หลังจากผ่านไป 2-3 วินาที คุณควรเห็นการตอบกลับดังต่อไปนี้
Inserted players
ตอนนี้เรามาใช้ไลบรารีไคลเอ็นต์ Go เพื่อป้อนข้อมูลลงในตาราง Scores ด้วยคะแนนแบบสุ่ม 4 รายการพร้อมกับการประทับเวลาสำหรับผู้เล่นแต่ละคนในตาราง Players
เรากำหนดคอลัมน์ Timestamp ของScoresตารางเป็นคอลัมน์ "การประทับเวลาการคอมมิต" ผ่านคำสั่ง SQL ต่อไปนี้ซึ่งดำเนินการเมื่อเราเรียกใช้คำสั่ง 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
สังเกตแอตทริบิวต์ OPTIONS(allow_commit_timestamp=true) ซึ่งจะทำให้ Timestamp เป็นคอลัมน์ "การประทับเวลาการคอมมิต" และช่วยให้ระบบป้อนข้อมูลการประทับเวลาธุรกรรมที่แน่นอนโดยอัตโนมัติสำหรับการดำเนินการ INSERT และ UPDATE ในแถวของตารางที่กำหนด
นอกจากนี้ คุณยังแทรกค่าการประทับเวลาของคุณเองลงในคอลัมน์ "การประทับเวลาการคอมมิต" ได้ตราบใดที่คุณแทรกการประทับเวลาที่มีค่าเป็นอดีต ซึ่งเป็นสิ่งที่เราจะทำเพื่อวัตถุประสงค์ของ Codelab นี้
ตอนนี้เรามาเรียกใช้คำสั่ง insertscores โดยใช้ค่าอาร์กิวเมนต์เดียวกันกับที่เราใช้เมื่อเรียกใช้คำสั่ง insertplayers ตรวจสอบว่าคุณได้แทนที่ my-project ด้วยรหัสโปรเจ็กต์ที่สร้างไว้ตอนต้นของโค้ดแล็บนี้
./leaderboard insertscores projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard
หลังจากผ่านไป 2-3 วินาที คุณควรเห็นการตอบกลับดังต่อไปนี้
Inserted scores
การเรียกใช้ฟังก์ชัน insertScores จะใช้ข้อมูลโค้ดต่อไปนี้เพื่อแทรกการประทับเวลาที่สร้างขึ้นแบบสุ่มพร้อมวันที่และเวลาที่เกิดขึ้นในอดีต
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,
},
})
หากต้องการป้อนข้อมูลในคอลัมน์ Timestamp โดยอัตโนมัติด้วยการประทับเวลาที่ตรงกับเวลาที่เกิดธุรกรรม "แทรก" คุณสามารถแทรกลักษณะค่าคงที่ของ Go spanner.CommitTimestamp แทนได้ ดังเช่นในตัวอย่างโค้ดต่อไปนี้
...
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,
},
})
ตอนนี้เราโหลดข้อมูลเสร็จแล้ว มาตรวจสอบค่าที่เราเพิ่งเขียนลงในตารางใหม่ในส่วน Cloud Spanner ของ Cloud Console กัน ก่อนอื่นให้เลือกleaderboardฐานข้อมูล แล้วเลือกPlayersตาราง คลิกแท็บ Data คุณควรเห็นว่ามีข้อมูลในคอลัมน์ PlayerId และ PlayerName ของตาราง
จากนั้นมาตรวจสอบว่าตารางคะแนนมีข้อมูลด้วยหรือไม่โดยคลิกตาราง Scores แล้วเลือกแท็บ Data คุณควรเห็นว่ามีข้อมูลในคอลัมน์ PlayerId, Timestamp และ Score ของตาราง
เยี่ยมมาก! มาอัปเดตแอปเพื่อเรียกใช้การค้นหาบางอย่างที่เราใช้สร้างลีดเดอร์บอร์ดเกมได้กัน
6. เรียกใช้การค้นหาลีดเดอร์บอร์ด
ตอนนี้เราได้ตั้งค่าฐานข้อมูลและโหลดข้อมูลลงในตารางแล้ว มาสร้างลีดเดอร์บอร์ดโดยใช้ข้อมูลนี้กัน โดยเราต้องตอบคำถาม 4 ข้อต่อไปนี้
- ผู้เล่นคนใดเป็น "10 อันดับ" ตลอดกาล
- ผู้เล่นคนใดเป็น "10 อันดับแรก" ของปี
- ผู้เล่นคนใดเป็น "10 อันดับแรก" ของเดือน
- ผู้เล่นคนใดเป็น "10 อันดับแรก" ของสัปดาห์
มาอัปเดตแอปพลิเคชันเพื่อเรียกใช้คำค้นหา SQL ที่จะตอบคำถามเหล่านี้กัน
เราจะเพิ่มคำสั่ง query และคำสั่ง queryWithTimespan ซึ่งจะช่วยให้คุณเรียกใช้การค้นหาเพื่อตอบคำถามที่จะสร้างข้อมูลที่จำเป็นสำหรับลีดเดอร์บอร์ดได้
แก้ไขไฟล์ leaderboard.go ใน Cloud Shell Editor เพื่ออัปเดตแอปพลิเคชันเพื่อเพิ่มคำสั่ง query และคำสั่ง queryWithTimespan นอกจากนี้ เราจะเพิ่มformatWithCommasฟังก์ชันตัวช่วยเพื่อจัดรูปแบบคะแนนด้วยเครื่องหมายคอมมา
ก่อนอื่นให้อัปเดตส่วน imports ที่ด้านบนของไฟล์ leaderboard.go โดยแทนที่ข้อมูลที่มีอยู่เพื่อให้เมื่อดำเนินการเสร็จแล้ว ไฟล์จะมีลักษณะดังนี้
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"
)
จากนั้นเพิ่มฟังก์ชัน 2 รายการต่อไปนี้และฟังก์ชันตัวช่วยใต้เมธอด 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()
}
จากนั้นที่ด้านบนของไฟล์ leaderboard.go ให้เพิ่ม "query" เป็นตัวเลือกคำสั่งหนึ่งในตัวแปร commands ใต้ตัวเลือก insertscores": insertScores เพื่อให้ตัวแปร commands มีลักษณะดังนี้
var (
commands = map[string]command{
"insertplayers": insertPlayers,
"insertscores": insertScores,
"query": query,
}
)
จากนั้นเพิ่ม "queryWithTimespan" เป็นตัวเลือกคำสั่งภายในrunฟังก์ชัน ใต้ส่วนคำสั่ง "createdatabase" และเหนือส่วนการจัดการคำสั่ง "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
}
เมื่อเสร็จแล้ว ฟังก์ชัน run ควรมีลักษณะดังนี้
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
}
จากนั้นให้อัปเดตบล็อกโค้ด flag.Parse() ในเมธอด "main" ของแอปพลิเคชันเพื่อให้ดูเหมือนโค้ดต่อไปนี้ เพื่อให้คำสั่ง queryWithTimespan ทำงานได้
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)
}
ขั้นตอนสุดท้ายในการเพิ่มฟังก์ชัน "query" ลงในแอปพลิเคชันให้เสร็จสมบูรณ์คือการเพิ่มข้อความช่วยเหลือสำหรับคำสั่ง "query" และ "querywithtimespan" ลงในฟังก์ชัน flag.Usage() เพิ่มบรรทัดโค้ดต่อไปนี้ลงในflag.Usage()ฟังก์ชันเพื่อรวมข้อความช่วยเหลือสำหรับคำสั่งการค้นหา
เพิ่มคำสั่ง "query" 2 รายการลงในรายการคำสั่งที่เป็นไปได้
Command can be one of: createdatabase, insertplayers, insertscores, query, querywithtimespan
และเพิ่มข้อความช่วยเหลือเพิ่มเติมนี้ใต้ข้อความช่วยเหลือสำหรับคำสั่ง 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.
บันทึกการเปลี่ยนแปลงที่คุณทำกับไฟล์ leaderboard.go โดยเลือก "บันทึก" ในเมนู "ไฟล์" ของ Cloud Shell Editor
คุณใช้ไฟล์ leaderboard.go ในไดเรกทอรี golang-samples/spanner/spanner_leaderboard เพื่อดูตัวอย่างลักษณะของไฟล์ leaderboard.go หลังจากเพิ่มโค้ดเพื่อเปิดใช้คำสั่ง query และ querywithtimespan
ตอนนี้เรามาสร้างและเรียกใช้แอปพลิเคชันเพื่อยืนยันว่าคำสั่ง query และ querywithtimespan ใหม่รวมอยู่ในรายการคำสั่งที่เป็นไปได้ของแอปพลิเคชัน
เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อสร้างแอปพลิเคชัน
go build leaderboard.go
เรียกใช้แอปพลิเคชันที่ได้ใน Cloud Shell โดยป้อนคำสั่งต่อไปนี้
./leaderboard
ตอนนี้คุณควรเห็นคำสั่ง query และ querywithtimespan รวมอยู่ในเอาต์พุตเริ่มต้นของแอปเป็นตัวเลือกคำสั่งใหม่แล้ว
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.
คุณจะเห็นจากคำตอบว่าเราใช้คำสั่ง query เพื่อดูรายชื่อผู้เล่น "10 อันดับแรก" ตลอดกาลได้ นอกจากนี้ เรายังเห็นว่าคำสั่ง querywithtimespan ช่วยให้เราระบุช่วงเวลาเป็นจำนวนชั่วโมงเพื่อใช้ในการกรองระเบียนตามค่าในคอลัมน์ Timestamp ของตาราง Scores ได้
มาเรียกใช้คำสั่ง query โดยใช้อาร์กิวเมนต์ที่มีค่าเดียวกันกับที่เราใช้เมื่อเรียกใช้คำสั่ง create กัน ตรวจสอบว่าคุณได้แทนที่ my-project ด้วยรหัสโปรเจ็กต์ที่สร้างไว้ตอนต้นของโค้ดแล็บนี้
./leaderboard query projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard
คุณควรเห็นคำตอบที่มีผู้เล่น "10 อันดับแรก" ตลอดกาล เช่น
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
ตอนนี้เรามาเรียกใช้คำสั่ง querywithtimespan พร้อมอาร์กิวเมนต์ที่จำเป็นเพื่อค้นหาผู้เล่น "10 อันดับแรก" ของปีโดยระบุ "ช่วงเวลา" เท่ากับจำนวนชั่วโมงใน 1 ปี ซึ่งก็คือ 8760 ตรวจสอบว่าคุณได้แทนที่ my-project ด้วยรหัสโปรเจ็กต์ที่สร้างไว้ตอนต้นของโค้ดแล็บนี้
./leaderboard querywithtimespan projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard 8760
คุณควรเห็นคำตอบที่มีผู้เล่น "10 อันดับแรก" ของปี เช่น คำตอบต่อไปนี้
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
ตอนนี้เรามาเรียกใช้คำสั่ง querywithtimespan เพื่อค้นหาผู้เล่น "10 อันดับแรก" ของเดือนโดยระบุ "ช่วงเวลา" เท่ากับจำนวนชั่วโมงใน 1 เดือน ซึ่งก็คือ 730 ตรวจสอบว่าคุณได้แทนที่ my-project ด้วยรหัสโปรเจ็กต์ที่สร้างไว้ตอนต้นของโค้ดแล็บนี้
./leaderboard querywithtimespan projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard 730
คุณควรเห็นคำตอบที่มีผู้เล่น "10 อันดับแรก" ของเดือน เช่น คำตอบต่อไปนี้
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
ตอนนี้มาเรียกใช้คำสั่ง querywithtimespan เพื่อค้นหาผู้เล่น "10 อันดับแรก" ของสัปดาห์โดยระบุ "timespan" เท่ากับจำนวนชั่วโมงใน 1 สัปดาห์ ซึ่งก็คือ 168 ตรวจสอบว่าคุณได้แทนที่ my-project ด้วยรหัสโปรเจ็กต์ที่สร้างไว้ตอนต้นของโค้ดแล็บนี้
./leaderboard querywithtimespan projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard 168
คุณควรเห็นคำตอบที่มีผู้เล่น "10 อันดับแรก" ของสัปดาห์ เช่น คำตอบต่อไปนี้
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
เยี่ยมมาก
ตอนนี้เมื่อคุณเพิ่มระเบียน Cloud Spanner จะปรับขนาดฐานข้อมูลให้มีขนาดเท่าที่คุณต้องการ ไม่ว่าฐานข้อมูลจะเติบโตมากเพียงใด ลีดเดอร์บอร์ดของเกมก็ยังคงขยายขนาดได้อย่างแม่นยำด้วย Cloud Spanner และเทคโนโลยี Truetime
7. ล้างข้อมูล
หลังจากสนุกกับการเล่น Spanner แล้ว เราต้องทำความสะอาดสนามเด็กเล่นเพื่อประหยัดทรัพยากรและเงินอันมีค่า โชคดีที่ขั้นตอนนี้ง่ายมาก เพียงไปที่ส่วน Cloud Spanner ของ Cloud Console แล้วลบอินสแตนซ์ที่เราสร้างในขั้นตอนของโค้ดแล็บที่ชื่อ "ตั้งค่าอินสแตนซ์ Cloud Spanner"
8. ยินดีด้วย
สิ่งที่เราได้พูดถึง
- อินสแตนซ์ ฐานข้อมูล และสคีมาตารางของ Google Cloud Spanner สำหรับลีดเดอร์บอร์ด
- วิธีสร้างแอปพลิเคชันคอนโซล Go
- วิธีสร้างฐานข้อมูลและตาราง Spanner โดยใช้ไลบรารีไคลเอ็นต์ Go
- วิธีโหลดข้อมูลลงในฐานข้อมูล Spanner โดยใช้ไลบรารีของไคลเอ็นต์ Go
- วิธีค้นหาผลลัพธ์ "10 อันดับแรก" จากข้อมูลโดยใช้การประทับเวลาการคอมมิตของ Spanner และไลบรารีไคลเอ็นต์ Go
ขั้นตอนถัดไป:
- อ่านเอกสารประกอบเกี่ยวกับ CAP ของ Spanner
- ดูข้อมูลเกี่ยวกับการออกแบบสคีมาและแนวทางปฏิบัติแนะนำในการค้นหา
- ดูข้อมูลเพิ่มเติมเกี่ยวกับการประทับเวลาการคอมมิตของ Cloud Spanner
แสดงความคิดเห็น
- โปรดสละเวลาสักครู่เพื่อทำแบบสำรวจสั้นๆ ของเรา