1. ภาพรวม
Google Cloud Spanner เป็นบริการฐานข้อมูลเชิงสัมพันธ์ที่รองรับการปรับขนาดในวงกว้างและกระจายไปทั่วโลกที่มีการจัดการครบวงจร ซึ่งมอบธุรกรรม ACID และความหมายของ SQL โดยไม่สูญเสียประสิทธิภาพการทำงานและความพร้อมใช้งานสูง
ในห้องทดลองนี้ คุณจะได้ดูวิธีตั้งค่าอินสแตนซ์ Cloud Spanner คุณจะเข้าสู่ขั้นตอนต่างๆ ในการสร้างฐานข้อมูลและสคีมาที่ใช้สำหรับลีดเดอร์บอร์ดการเล่นเกม คุณจะเริ่มต้นด้วยการสร้างตารางผู้เล่นสำหรับจัดเก็บข้อมูลผู้เล่น และตารางคะแนนเพื่อเก็บคะแนนผู้เล่น
ถัดไป คุณจะต้องเติมข้อมูลในตารางด้วยข้อมูลตัวอย่าง จากนั้นคุณจะสรุปห้องทดลองโดยการเรียกใช้คำค้นหาตัวอย่างยอดนิยม 10 อันดับแรก และสุดท้ายให้ลบอินสแตนซ์เพื่อทำให้ทรัพยากรว่างมากขึ้น
สิ่งที่คุณจะได้เรียนรู้
- วิธีตั้งค่าอินสแตนซ์ Cloud Spanner
- วิธีสร้างฐานข้อมูลและตาราง
- วิธีใช้คอลัมน์การประทับเวลาคอมมิต
- วิธีโหลดข้อมูลลงในตารางฐานข้อมูล Cloud Spanner พร้อมการประทับเวลา
- วิธีค้นหาฐานข้อมูล Cloud Spanner
- วิธีลบอินสแตนซ์ Cloud Spanner
คุณสมบัติ****หมวก
คุณจะใช้บทแนะนำนี้อย่างไร
คุณจะให้คะแนนประสบการณ์การใช้งาน Google Cloud Platform อย่างไร
2. การตั้งค่าและข้อกำหนด
การตั้งค่าสภาพแวดล้อมตามเวลาที่สะดวก
หากยังไม่มีบัญชี Google (Gmail หรือ Google Apps) คุณต้องสร้างบัญชีก่อน ลงชื่อเข้าใช้คอนโซล Google Cloud Platform ( console.cloud.google.com) และสร้างโปรเจ็กต์ใหม่
หากคุณมีโปรเจ็กต์อยู่แล้ว ให้คลิกเมนูแบบเลื่อนลงสำหรับการเลือกโปรเจ็กต์ที่ด้านซ้ายบนของคอนโซล
แล้วคลิก "โปรเจ็กต์ใหม่" ในกล่องโต้ตอบที่ปรากฏขึ้นเพื่อสร้างโปรเจ็กต์ใหม่ ดังนี้
หากคุณยังไม่มีโปรเจ็กต์ คุณจะเห็นกล่องโต้ตอบลักษณะนี้ให้สร้างโปรเจ็กต์แรก
กล่องโต้ตอบการสร้างโปรเจ็กต์ที่ตามมาจะให้คุณป้อนรายละเอียดของโปรเจ็กต์ใหม่:
จดจำรหัสโปรเจ็กต์ ซึ่งเป็นชื่อที่ไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมด (ระบบใช้ชื่อด้านบนนี้ไปแล้ว และจะใช้ไม่ได้ ขออภัย) และจะมีการอ้างอิงใน Codelab ว่า PROJECT_ID ในภายหลัง
ขั้นตอนถัดไป คุณจะต้องเปิดใช้การเรียกเก็บเงินใน 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 ซึ่งจะช่วยเพิ่มประสิทธิภาพของเครือข่ายและการตรวจสอบสิทธิ์ได้อย่างมาก ซึ่งหมายความว่าสิ่งที่คุณต้องมีสำหรับ Codelab นี้คือเบราว์เซอร์ (ใช่แล้ว ทั้งหมดนี้ทำงานได้บน 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 โดยกด "/" และพิมพ์ "SPANer"
ถัดไป ให้คลิก 
และกรอกแบบฟอร์มโดยป้อนชื่ออินสแตนซ์ cloudspanner-leaderboard สำหรับอินสแตนซ์ เลือกการกำหนดค่า (เลือกอินสแตนซ์ระดับภูมิภาค) และกำหนดจำนวนโหนด สำหรับ Codelab นี้ เราต้องการเพียง 1 โหนดเท่านั้น สำหรับอินสแตนซ์ที่ใช้งานจริงและเพื่อให้มีคุณสมบัติสำหรับ SLA ของ Cloud Spanner คุณจะต้องเรียกใช้โหนดอย่างน้อย 3 รายการในอินสแตนซ์ Cloud Spanner
สุดท้ายแต่ไม่ท้ายสุด ให้คลิก "สร้าง" และคุณก็มีอินสแตนซ์ Cloud Spanner อยู่แล้วภายในไม่กี่วินาที
ในขั้นตอนถัดไปเราจะใช้ไลบรารีของไคลเอ็นต์ Go เพื่อสร้างฐานข้อมูลและสคีมาในอินสแตนซ์ใหม่
4. สร้างฐานข้อมูลและสคีมา
ในขั้นตอนนี้ เราจะสร้างฐานข้อมูลและสคีมาตัวอย่าง
ลองใช้ไลบรารีไคลเอ็นต์ Go เพื่อสร้าง 2 ตาราง ตารางผู้เล่นสำหรับข้อมูลผู้เล่นและตารางคะแนนสำหรับจัดเก็บคะแนนผู้เล่น โดยเราจะแนะนำขั้นตอนการสร้างแอปพลิเคชันคอนโซล 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
โค้ดทั้งหมดที่จำเป็นสำหรับ Codelab จะอยู่ในไดเรกทอรี golang-samples/spanner/spanner_leaderboard/ ที่มีอยู่ โดยเป็นแอปพลิเคชัน Go ที่เรียกใช้ได้ชื่อ leaderboard เพื่อใช้อ้างอิงขณะดำเนินการใน Codelab เราจะสร้างไดเรกทอรีใหม่และสำเนาของแอปพลิเคชันลีดเดอร์บอร์ดเป็นขั้นตอน
สร้างไดเรกทอรีใหม่ชื่อ "codelab" สำหรับแอปพลิเคชันและเปลี่ยนไดเรกทอรีลงในไดเรกทอรีด้วยคำสั่งต่อไปนี้
mkdir codelab && cd $_
ตอนนี้ มาสร้างแอปพลิเคชัน Go พื้นฐานชื่อ "ลีดเดอร์บอร์ด" กัน ที่ใช้ไลบรารีไคลเอ็นต์ Spanner เพื่อสร้างลีดเดอร์บอร์ดที่ประกอบด้วย 2 ตาราง ได้แก่ ผู้เล่นและคะแนน โดยทำใน Cloud Shell Editor เลย ดังนี้
เปิด Cloud Shell Editor โดยคลิกที่ "เปิดเครื่องมือแก้ไข" ที่ไฮไลต์ด้านล่าง
สร้างไฟล์ชื่อ "ลีดเดอร์บอร์ด.go" ในโฟลเดอร์ ~/gopath/src/github.com/GoogleCloudPlatform/golang-samples/spanner/codelab
- ก่อนอื่น ให้ตรวจสอบว่าคุณมี "Codelab" โฟลเดอร์ที่เลือกไว้ในรายการโฟลเดอร์ของ Cloud Shell Editor
- จากนั้นเลือก "ไฟล์ใหม่" ในส่วน "ไฟล์" ของ Cloud Shell Editor เมนู
- ป้อน "ลีดเดอร์บอร์ด.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 ด้วยรหัสโปรเจ็กต์ที่คุณสร้างในตอนต้นของ Codelab นี้
./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
}
จากนั้นหากต้องการทำให้คำสั่ง insert ทำงานได้ ให้เพิ่มโค้ดต่อไปนี้ลงในการ "เรียกใช้" ของแอปพลิเคชัน ด้านล่างคำสั่ง createdatabase handling แทนที่คำสั่ง 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
เมื่อทำเสร็จแล้ว ฟังก์ชัน 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
}
ขั้นตอนสุดท้ายในการเพิ่ม "insert" ให้เสร็จสมบูรณ์ ให้กับแอปพลิเคชันของคุณก็คือ เพิ่มข้อความช่วยเหลือสำหรับ "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 ด้วยรหัสโปรเจ็กต์ที่คุณสร้างในตอนต้นของ Codelab นี้
./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 ด้วยรหัสโปรเจ็กต์ที่คุณสร้างในตอนต้นของ Codelab นี้
./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 ข้อต่อไปนี้
- ผู้เล่นคนใดบ้างที่อยู่ใน "สิบอันดับแรก" ของช่วงเวลาทั้งหมด
- ผู้เล่นคนใดบ้างที่อยู่ใน "สิบอันดับแรก" ของปีนี้คืออะไร
- ผู้เล่นคนใดบ้างที่อยู่ใน "สิบอันดับแรก" ของเดือนนี้
- ผู้เล่นคนใดบ้างที่อยู่ใน "สิบอันดับแรก" ของสัปดาห์นี้กัน
มาอัปเดตแอปพลิเคชันให้เรียกใช้การค้นหา 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 ให้เพิ่ม "คำค้นหา" เป็นตัวเลือกคำสั่ง 1 รายการในตัวแปร 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
}
จากนั้นหากต้องการให้คำสั่ง queryWithTimespan ทำงานได้ ให้อัปเดตโค้ดบล็อกแฟล็ก.Parse() ใน "main" ของแอปพลิเคชัน เพื่อให้มีลักษณะดังต่อไปนี้
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)
}
ขั้นตอนสุดท้ายในการเพิ่ม "คำค้นหา" ให้เสร็จสมบูรณ์ ให้กับแอปพลิเคชันของคุณก็คือ
เพิ่มข้อความช่วยเหลือสำหรับ "คำค้นหา" และ "querywithtimespan" ลงในฟังก์ชัน flag.Usage() เพิ่มบรรทัดโค้ดต่อไปนี้ในฟังก์ชัน flag.Usage() เพื่อรวมข้อความช่วยเหลือสำหรับคำสั่งการค้นหา
เพิ่ม "คำค้นหา" 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 เพื่อดูรายการ "อันดับสูงสุด" ของเราได้ ผู้เล่นตลอดกาล นอกจากนี้ เรายังเห็นว่าคำสั่ง querywithtimespan ช่วยให้เราระบุระยะเวลาเป็นจำนวนชั่วโมงเพื่อใช้ในการกรองระเบียนตามค่าในคอลัมน์ Timestamp ของตาราง Scores
เรียกใช้คำสั่ง query โดยใช้ค่าอาร์กิวเมนต์เดียวกันกับที่เราใช้เมื่อเรียกใช้คำสั่ง create อย่าลืมแทนที่ my-project ด้วยรหัสโปรเจ็กต์ที่คุณสร้างในตอนต้นของ Codelab นี้
./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 ที่มีอาร์กิวเมนต์ที่จำเป็นเพื่อค้นหา "Top Ten" ผู้เล่นแห่งปีด้วยการระบุ "ช่วงเวลา" เท่ากับจำนวนชั่วโมงใน 1 ปีซึ่งเท่ากับ 8760 อย่าลืมแทนที่ my-project ด้วยรหัสโปรเจ็กต์ที่คุณสร้างในตอนต้นของ Codelab นี้
./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" กัน ผู้เล่นของเดือนโดยระบุ "ช่วงเวลา" เท่ากับจำนวนชั่วโมงในหนึ่งเดือน ซึ่งก็คือ 730 อย่าลืมแทนที่ my-project ด้วยรหัสโปรเจ็กต์ที่คุณสร้างในตอนต้นของ Codelab นี้
./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" กัน ผู้เล่นประจำสัปดาห์โดยการระบุ "ช่วงเวลา" เท่ากับจำนวนชั่วโมงใน 1 สัปดาห์ ซึ่งก็คือ 168 ชั่วโมง อย่าลืมแทนที่ my-project ด้วยรหัสโปรเจ็กต์ที่คุณสร้างในตอนต้นของ Codelab นี้
./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 แล้วลบอินสแตนซ์ที่เราสร้างในขั้นตอน Codelab ที่ชื่อว่า "Setup a Cloud Spannerอินสแตนซ์"
8. ยินดีด้วย
หัวข้อที่ครอบคลุมมีดังนี้
- อินสแตนซ์ ฐานข้อมูล และสคีมาตารางของ Google Cloud Spanner สำหรับลีดเดอร์บอร์ด
- วิธีสร้างแอปพลิเคชันคอนโซล Go
- วิธีสร้างฐานข้อมูลและตาราง Spanner โดยใช้ไลบรารีของไคลเอ็นต์ Go
- วิธีโหลดข้อมูลลงในฐานข้อมูล Spanner โดยใช้ไลบรารีของไคลเอ็นต์ Go
- วิธีค้นหา "10 อันดับแรก" ผลลัพธ์จากข้อมูลของคุณโดยใช้การประทับเวลาคอมมิตของ Spanner และไลบรารีของไคลเอ็นต์ Go
ขั้นตอนถัดไป:
- อ่านสมุดปกขาว CAP ของตัวกรอง
- เรียนรู้เกี่ยวกับการออกแบบสคีมาและแนวทางปฏิบัติแนะนำสำหรับการค้นหา
- ดูข้อมูลเพิ่มเติมเกี่ยวกับการประทับเวลาคอมมิตของ Cloud Spanner
แสดงความคิดเห็น
- โปรดสละเวลาสักครู่เพื่อทำแบบสำรวจสั้นๆ ของเรา