1. खास जानकारी
Google Cloud Spanner, पूरी तरह से मैनेज की गई हॉरिज़ॉन्टल तौर पर बढ़ाने वाली, दुनिया भर में डिस्ट्रिब्यूट की जाने वाली, रिलेशनल डेटाबेस सेवा है. यह परफ़ॉर्मेंस और ज़्यादा उपलब्धता को छोड़े बिना, ACID लेन-देन और SQL सिमैंटिक उपलब्ध कराती है.
इस लैब में, आपको Cloud Spanner इंस्टेंस को सेटअप करने का तरीका बताया जाएगा. आपको ऐसा डेटाबेस और स्कीमा बनाने का तरीका बताया जाएगा जिसका इस्तेमाल गेमिंग लीडरबोर्ड के लिए किया जा सकता है. सबसे पहले आपको एक प्लेयर टेबल बनानी होगी, जिसमें खिलाड़ी की जानकारी सेव की जा सकती है. साथ ही, खिलाड़ी के स्कोर को स्टोर करने के लिए एक स्कोर टेबल बनाई जाती है.
इसके बाद, टेबल में सैंपल डेटा का इस्तेमाल होगा. इसके बाद, टॉप 10 सैंपल क्वेरी चलाकर और आखिर में संसाधनों को खाली करने के लिए, इंस्टेंस को मिटाकर लैब को खत्म करें.
आपको इनके बारे में जानकारी मिलेगी
- Cloud Spanner इंस्टेंस सेट अप करने का तरीका.
- डेटाबेस और टेबल बनाने का तरीका.
- कमिट टाइमस्टैंप कॉलम को इस्तेमाल करने का तरीका.
- टाइमस्टैंप की मदद से, Cloud Spanner की डेटाबेस टेबल में डेटा लोड करने का तरीका.
- अपने क्लाउड स्पैनर डेटाबेस के लिए क्वेरी कैसे करें.
- Cloud Spanner इंस्टेंस मिटाने का तरीका.
आपको इनकी ज़रूरत होगी
इस ट्यूटोरियल का इस्तेमाल कैसे किया जाएगा?
Google Cloud Platform के साथ अपने अनुभव को आप कितनी रेटिंग देंगे?
2. सेटअप और ज़रूरी शर्तें
अपने हिसाब से एनवायरमेंट सेटअप करना
अगर आपके पास पहले से Google खाता (Gmail या Google Apps) नहीं है, तो आपको एक खाता बनाना होगा. Google Cloud Platform कंसोल ( console.cloud.google.com) में साइन इन करें और एक नया प्रोजेक्ट बनाएं.
अगर आपके पास पहले से कोई प्रोजेक्ट है, तो कंसोल के ऊपर बाईं ओर मौजूद, प्रोजेक्ट चुनने के लिए पुल डाउन मेन्यू पर क्लिक करें:
और 'नया प्रोजेक्ट' पर क्लिक करें बटन:
अगर आपके पास पहले से कोई प्रोजेक्ट नहीं है, तो आपको अपना पहला प्रोजेक्ट बनाने के लिए, इस तरह का डायलॉग बॉक्स दिखेगा:
इसके बाद, प्रोजेक्ट बनाने वाले डायलॉग बॉक्स की मदद से अपने नए प्रोजेक्ट की जानकारी डाली जा सकती है:
वह प्रोजेक्ट आईडी याद रखें जो Google Cloud के सभी प्रोजेक्ट के लिए एक यूनीक नाम होता है. ऊपर दिया गया नाम पहले ही किसी दूसरे प्रोजेक्ट के लिए इस्तेमाल किया जा चुका है. इसलिए, यह आपके लिए काम नहीं करेगा! बाद में, इस कोडलैब को इस कोडलैब में PROJECT_ID के तौर पर दिखाया जाएगा.
इसके बाद, अगर आपने पहले से ऐसा नहीं किया है, तो आपको Google Cloud के संसाधनों का इस्तेमाल करने के लिए, Developers Console में बिलिंग चालू करनी होगी. साथ ही, Cloud Spanner API को चालू करना होगा.
इस कोडलैब को आज़माने के लिए आपको कुछ डॉलर से ज़्यादा खर्च नहीं करना चाहिए. हालांकि, अगर आप ज़्यादा संसाधनों का इस्तेमाल करने का फ़ैसला करते हैं या उन्हें बंद कर देते हैं, तो यह ज़्यादा हो सकता है (इस दस्तावेज़ के आखिर में "क्लीनअप" सेक्शन देखें). Google Cloud Spanner की कीमत की जानकारी यहां दी गई है.
Google Cloud Platform के नए उपयोगकर्ता 300 डॉलर के मुफ़्त में आज़माने की ज़रूरी शर्तें पूरी करते हैं. इसके तहत, कोडलैब का यह वर्शन बिना किसी शुल्क के इस्तेमाल किया जा सकता है.
Google Cloud Shell का सेटअप
Google Cloud और Spanner को आपके लैपटॉप से कहीं से भी ऑपरेट किया जा सकता है. हालांकि, इस कोडलैब में हम Google Cloud Shell का इस्तेमाल करेंगे. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.
Debian आधारित इस वर्चुअल मशीन में ऐसे सभी डेवलपमेंट टूल मौजूद हैं जिनकी आपको ज़रूरत पड़ेगी. यह पांच जीबी की स्थायी होम डायरेक्ट्री उपलब्ध कराता है और Google Cloud में चलता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रक्रिया को बेहतर बनाने में मदद मिलती है. इसका मतलब है कि इस कोडलैब के लिए आपको सिर्फ़ एक ब्राउज़र की ज़रूरत होगी. हां, यह Chromebook पर काम करता है.
- Cloud Console से Cloud Shell को चालू करने के लिए, 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 इंस्टेंस सेट अप करते हैं. 
सबसे ऊपर बाईं ओर मौजूद हैमबर्गर मेन्यू 
में स्पैनर एंट्री खोजें या "/" दबाकर स्पैनर खोजें और "स्पैनर" लिखें
इसके बाद, 
पर क्लिक करें और अपने इंस्टेंस के लिए इंस्टेंस का नाम cloudspanner-leaderboard डालकर, एक कॉन्फ़िगरेशन चुनें (कोई क्षेत्रीय इंस्टेंस चुनें) और नोड की संख्या सेट करें. इस कोडलैब के लिए, हमें सिर्फ़ एक नोड की ज़रूरत होगी. प्रोडक्शन इंस्टेंस और Cloud Spanner एसएलए की ज़रूरी शर्तों को पूरा करने के लिए, आपको अपने Cloud Spanner इंस्टेंस में तीन या उससे ज़्यादा नोड चलाने होंगे.
आखिर में, "बनाएं" पर क्लिक करें. और कुछ ही सेकंड में आपके पास Cloud Spanner का इंस्टेंस उपलब्ध हो जाता है.
अगले चरण में, हम आपके नए इंस्टेंस में डेटाबेस और स्कीमा बनाने के लिए, गो क्लाइंट लाइब्रेरी का इस्तेमाल करेंगे.
4. डेटाबेस और स्कीमा बनाना
इस चरण में, हम सैंपल डेटाबेस और स्कीमा बनाते हैं.
दो टेबल बनाने के लिए, क्लाइंट लाइब्रेरी का इस्तेमाल करें; खिलाड़ी की जानकारी के लिए खिलाड़ी टेबल और खिलाड़ी के स्कोर सेव करने के लिए 'स्कोर' टेबल. इसके लिए, हम Cloud Shell में Go Console ऐप्लिकेशन बनाने का तरीका बताएंगे.
पहले Cloud Shell में यह कमांड टाइप करके, GitHub से इस कोडलैब के सैंपल कोड का क्लोन बनाएं:
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/डायरेक्ट्री में, leaderboard नाम के रन किए जा सकने वाले Go ऐप्लिकेशन के तौर पर मौजूद होते हैं, ताकि कोडलैब में आपकी प्रोग्रेस के साथ-साथ उसे रेफ़रंस के तौर पर इस्तेमाल किया जा सके. हम एक नई डायरेक्ट्री बनाएंगे और अलग-अलग चरणों में लीडरबोर्ड ऐप्लिकेशन की एक कॉपी बनाएंगे.
"कोडलैब" नाम की नई डायरेक्ट्री बनाएं और निम्न आदेश से इसमें निर्देशिका को बदलें:
mkdir codelab && cd $_
आइए, अब एक बेसिक Go ऐप्लिकेशन बनाते हैं जिसका नाम "लीडरबोर्ड" है जो दो टेबल वाला लीडरबोर्ड बनाने के लिए स्पैनर क्लाइंट लाइब्रेरी का इस्तेमाल करता है; खिलाड़ी और स्कोर. Cloud Shell Editor में जाकर ऐसा किया जा सकता है:
"एडिटर खोलें" पर क्लिक करके, क्लाउड शेल एडिटर खोलें आइकॉन नीचे हाइलाइट किया गया है:
"लीडरबोर्ड.go" नाम की फ़ाइल बनाएं ~/gopath/src/github.com/GoogleCloudPlatform/golang-सैंपल/spanner/codelab फ़ोल्डर में देखें.
- सबसे पहले यह पक्का कर लें कि आपके पास "कोडलैब" है Cloud Shell Editor की फ़ोल्डर की सूची में चुना गया फ़ोल्डर चुनें.
- इसके बाद, "नई फ़ाइल" चुनें पर जाकर, मेन्यू.
- "लीडरबोर्ड.go" डालें डालें.
यह ऐप्लिकेशन की मुख्य फ़ाइल है. इसमें हमारा ऐप्लिकेशन कोड और किसी भी डिपेंडेंसी को शामिल करने के रेफ़रंस होंगे.
leaderboard डेटाबेस के साथ-साथ Players और Scores टेबल बनाने के लिए, (Ctrl + P) को कॉपी करें और leaderboard.go फ़ाइल में नीचे दिया गया गो कोड चिपकाएं (Ctrl + V):
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 फ़ाइल में किए गए बदलाव सेव करें पर जाकर, मेन्यू.
createdatabase कमांड को चालू करने के लिए कोड जोड़ने के बाद, आपकी leaderboard.go फ़ाइल कैसी दिखनी चाहिए, इसका उदाहरण देखने के लिए, golang-samples/spanner/spanner_leaderboard डायरेक्ट्री में leaderboard.go फ़ाइल का इस्तेमाल करें.
अपने ऐप्लिकेशन को 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 ऐप्लिकेशन है, जिसमें फ़िलहाल एक संभावित निर्देश है: createdatabase. हम देख सकते हैं कि createdatabase निर्देश का अनुमानित आर्ग्युमेंट एक खास इंस्टेंस आईडी और डेटाबेस आईडी वाली स्ट्रिंग है.
अब नीचे दिया गया कमांड चलाएं. पक्का करें कि आपने my-project की जगह वह प्रोजेक्ट आईडी डाला हो जिसे आपने कोडलैब की शुरुआत में बनाया था.
./leaderboard createdatabase projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard
कुछ सेकंड के बाद, आपको कुछ ऐसा जवाब दिखेगा:
Created database [projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard]
Cloud Console के Cloud Spanner डेटाबेस की खास जानकारी वाले सेक्शन में, आपको बाईं ओर दिए गए मेन्यू में नया डेटाबेस और टेबल दिखेंगी.
अगले चरण में, हम अपने ऐप्लिकेशन को अपडेट करेंगे, ताकि आपके नए डेटाबेस में कुछ डेटा लोड किया जा सके.
5. डेटा लोड करें
अब हमारे पास leaderboard नाम का एक डेटाबेस है, जिसमें दो टेबल हैं; Players और Scores. आइए, अब 'गो की क्लाइंट लाइब्रेरी' का इस्तेमाल करके, अपनी Players टेबल में प्लेयर और Scores टेबल को हर खिलाड़ी के लिए रैंडम स्कोर से भरें.
अगर यह पहले से खुला नहीं है, तो नीचे हाइलाइट किए गए आइकॉन पर क्लिक करके क्लाउड शेल एडिटर खोलें:
इसके बाद, एक insertplayers निर्देश जोड़ने के लिए, क्लाउड शेल एडिटर में leaderboard.go फ़ाइल में बदलाव करें. इसका इस्तेमाल, Players टेबल में 100 प्लेयर जोड़ने के लिए किया जा सकता है. हम एक insertscores निर्देश भी जोड़ेंगे. इसका इस्तेमाल, Players टेबल में हर खिलाड़ी के लिए, Scores टेबल में चार रैंडम स्कोर जोड़ने के लिए किया जा सकता है.
पहले leaderboard.go फ़ाइल में सबसे ऊपर मौजूद imports सेक्शन को अपडेट करें, ताकि मौजूदा फ़ाइल को बदला जा सके. ऐसा करने के बाद, आपका काम पूरा होने के बाद, यह कुछ ऐसा दिखेगा:
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"
)
इसके बाद, फ़ाइल के सबसे ऊपर, निर्देशों की सूची के साथ एक नया कमांड टाइप जोड़ें. यह सूची, "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,
}
)
इसके बाद, मौजूदा createdatabase() फ़ंक्शन के नीचे नीचे दिए गए InsertPlayers, और InsertScores फ़ंक्शन जोड़ें:
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 हैंडलिंग स्टेटमेंट के नीचे मौजूद फ़ंक्शन, 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
}
"शामिल करें" जोड़ने की प्रक्रिया पूरी करने का आखिरी चरण आपकी ऐप्लिकेशन की कार्यक्षमता "insertplayers" के लिए सहायता लेख जोड़ना है और "insertscores" flag.Usage() फ़ंक्शन को निर्देश देता है. शामिल करने के निर्देशों के लिए सहायता टेक्स्ट शामिल करने के लिए, flag.Usage() फ़ंक्शन में नीचे दिया गया सहायता टेक्स्ट जोड़ें:
संभावित निर्देशों की सूची में दोनों कमांड जोड़ें:
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 फ़ाइल में किए गए बदलाव सेव करें पर जाकर, मेन्यू.
insertplayers और insertscores कमांड को चालू करने के लिए कोड जोड़ने के बाद, आपकी leaderboard.go फ़ाइल कैसी दिखनी चाहिए, इसका उदाहरण देखने के लिए, golang-samples/spanner/spanner_leaderboard डायरेक्ट्री में मौजूद leaderboard.go फ़ाइल का इस्तेमाल करें.
आइए, अब ऐप्लिकेशन बनाते और चलाते हैं, ताकि यह पुष्टि की जा सके कि ऐप्लिकेशन की संभावित कमांड की सूची में, नए insertplayers और insertscores निर्देश शामिल हैं. ऐप्लिकेशन बनाने के लिए, यहां दिया गया कमांड चलाएं:
go build leaderboard.go
नीचे दिया गया निर्देश डालकर, क्लाउड शेल में बनने वाले ऐप्लिकेशन को चलाएं:
./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
कुछ सेकंड के बाद, आपको कुछ ऐसा जवाब दिखेगा:
Inserted players
अब हम 'गो क्लाइंट लाइब्रेरी' का इस्तेमाल करके, अपनी Scores टेबल में, Players टेबल में हर खिलाड़ी के लिए टाइमस्टैंप के साथ चार रैंडम स्कोर उपलब्ध कराते हैं.
Scores टेबल के Timestamp कॉलम को "टाइमस्टैंप" के तौर पर बताया गया था कॉलम को नीचे दिए गए 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 कार्रवाइयों के लेन-देन के सटीक टाइमस्टैंप के साथ अपने-आप जानकारी भर जाती है.
"टाइमस्टैंप जोड़े" में अपने टाइमस्टैंप की वैल्यू भी डाली जा सकती हैं कॉलम में तब तक सेट रहेगा, जब तक आप किसी पुरानी वैल्यू के साथ टाइमस्टैंप शामिल करते हैं. हम इस कोडलैब के मकसद को पूरा करने के लिए ऐसा ही करेंगे.
अब insertscores कमांड को उन्हीं आर्ग्युमेंट वैल्यू के साथ चलाएं जिनका इस्तेमाल हमने insertplayers कमांड को कॉल करते समय किया था. पक्का करें कि आपने my-project की जगह वह प्रोजेक्ट आईडी डाला हो जिसे आपने कोडलैब की शुरुआत में बनाया था.
./leaderboard insertscores projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard
कुछ सेकंड के बाद, आपको कुछ ऐसा जवाब दिखेगा:
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 Console के Cloud Spanner सेक्शन में अपनी नई टेबल में लिखी हैं. पहले leaderboard डेटाबेस चुनें. इसके बाद, Players टेबल चुनें. Data टैब पर क्लिक करें. आपको टेबल के PlayerId और PlayerName कॉलम में डेटा दिखेगा.
आइए, Scores टेबल पर क्लिक करके Data टैब चुनकर यह पुष्टि करें कि स्कोर टेबल में भी डेटा मौजूद है. आपको दिखाई देगा कि आपके पास टेबल के PlayerId, Timestamp, और Score कॉलम में डेटा है.
बहुत खूब! कुछ ऐसी क्वेरी चलाने के लिए अपने ऐप्लिकेशन को अपडेट करते हैं जिनका इस्तेमाल हम गेमिंग लीडरबोर्ड बनाने में कर सकते हैं.
6. लीडरबोर्ड क्वेरी चलाएं
अब हमने अपना डेटाबेस सेट अप कर लिया है और अपनी टेबल में जानकारी लोड कर दी है, तो अब इस डेटा का इस्तेमाल करके लीडरबोर्ड बनाते हैं. ऐसा करने के लिए, हमें इन चार सवालों के जवाब देने होंगे:
- कौनसे खिलाड़ी "टॉप 10" खिलाड़ी हैं हर समय का?
- कौनसे खिलाड़ी "टॉप 10" खिलाड़ी हैं का सुझाव दिया है?
- कौनसे खिलाड़ी "टॉप 10" खिलाड़ी हैं महीने का?
- कौनसे खिलाड़ी "टॉप 10" खिलाड़ी हैं सप्ताह का?
SQL क्वेरी चलाने के लिए, अपने ऐप्लिकेशन को अपडेट करते हैं, जिससे इन सवालों के जवाब मिलेंगे.
हम एक query कमांड और एक queryWithTimespan कमांड जोड़ेंगे. इससे उन सवालों के जवाब देने के लिए क्वेरी चलाई जा सकेगी जिनसे लीडरबोर्ड के लिए ज़रूरी जानकारी मिलेगी.
ऐप्लिकेशन को अपडेट करने के लिए, Cloud Shell Editor में leaderboard.go फ़ाइल में बदलाव करें. इससे ऐप्लिकेशन में query कमांड और queryWithTimespan कमांड जोड़ा जा सकेगा. हम कॉमा का इस्तेमाल करके अपने स्कोर फ़ॉर्मैट करने के लिए, formatWithCommas हेल्पर फ़ंक्शन भी जोड़ेंगे.
पहले leaderboard.go फ़ाइल में सबसे ऊपर मौजूद imports सेक्शन को अपडेट करें, ताकि मौजूदा फ़ाइल को बदला जा सके. ऐसा करने के बाद, आपका काम पूरा होने के बाद, यह कुछ ऐसा दिखेगा:
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"
)
इसके बाद, मौजूदा 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 फ़ाइल के सबसे ऊपर "क्वेरी" जोड़ें "insertscores": insertScores विकल्प के ठीक नीचे, commands वैरिएबल में एक कमांड विकल्प के तौर पर शामिल करें, ताकि commands वैरिएबल इस तरह दिखे:
var (
commands = map[string]command{
"insertplayers": insertPlayers,
"insertscores": insertScores,
"query": query,
}
)
इसके बाद "queryWithTimespan" जोड़ें "createdatabase" के नीचे run फ़ंक्शन में कमांड विकल्प के तौर पर कमांड सेक्शन और "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() कोड ब्लॉक को अपडेट करें विधि को इस तरह से दिखाया जाए:
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)
}
"क्वेरी" जोड़ने की प्रक्रिया पूरी करने का आखिरी चरण आपके ऐप्लिकेशन की मुख्य सुविधा "क्वेरी" के लिए सहायता टेक्स्ट जोड़ना है और "क्वेरी के साथ टाइमस्पैन" है flag.Usage() फ़ंक्शन को निर्देश देता है. क्वेरी कमांड के लिए सहायता टेक्स्ट शामिल करने के लिए, flag.Usage() फ़ंक्शन में कोड की इन लाइनों को जोड़ें:
दो "क्वेरी" जोड़ें कमांड की सूची देखें:
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 फ़ाइल में किए गए बदलाव सेव करें पर जाकर, मेन्यू.
query और querywithtimespan कमांड को चालू करने के लिए कोड जोड़ने के बाद, आपकी leaderboard.go फ़ाइल कैसी दिखनी चाहिए, इसका उदाहरण देखने के लिए, golang-samples/spanner/spanner_leaderboard डायरेक्ट्री में मौजूद leaderboard.go फ़ाइल का इस्तेमाल करें.
आइए, अब ऐप्लिकेशन बनाते और चलाते हैं, ताकि यह पुष्टि की जा सके कि ऐप्लिकेशन की संभावित कमांड की सूची में, नए query और querywithtimespan निर्देश शामिल हैं.
ऐप्लिकेशन बनाने के लिए, Cloud Shell में यह कमांड चलाएं:
go build leaderboard.go
नीचे दिया गया निर्देश डालकर, क्लाउड शेल में बनने वाले ऐप्लिकेशन को चलाएं:
./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 निर्देश की मदद से, Scores टेबल के Timestamp कॉलम में रिकॉर्ड की वैल्यू के आधार पर उन्हें फ़िल्टर करने के लिए, इस्तेमाल किए जा सकने वाले घंटों की समयावधि तय की जा सकती है.
चलिए, 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 कमांड चलाते हैं "टाइमस्पैन" तय करके साल के बेहतरीन खिलाड़ी साल के घंटों की संख्या के बराबर है, जो 8,760 है. पक्का करें कि आपने 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 कमांड चलाकर देखते हैं "समयावधि" तय करके, महीने के बेहतरीन खिलाड़ी महीने के घंटों की संख्या के बराबर है, जो 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 कमांड चलाकर देखते हैं "समयावधि" तय करके, हफ़्ते के बेहतरीन खिलाड़ी एक हफ़्ते में घंटों की संख्या के बराबर है, जो 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 Console के Cloud Spanner सेक्शन में जाकर, "Cloud Spanner इंस्टेंस सेट करें" नाम के कोडलैब चरण में बनाए गए इंस्टेंस को मिटा देते हैं.
8. बधाई हो!
हमने इन विषयों के बारे में बात की:
- लीडरबोर्ड के लिए Google Cloud स्पैनर इंस्टेंस, डेटाबेस, और टेबल स्कीमा
- Go Console ऐप्लिकेशन बनाने का तरीका
- Go क्लाइंट लाइब्रेरी का इस्तेमाल करके स्पैनर डेटाबेस और टेबल बनाने का तरीका
- Go क्लाइंट लाइब्रेरी का इस्तेमाल करके, स्पैनर डेटाबेस में डेटा लोड करने का तरीका
- "टॉप 10" से जुड़ी क्वेरी करने का तरीका स्पैनर कमिट टाइमस्टैंप और Go क्लाइंट लाइब्रेरी का इस्तेमाल करके आपके डेटा के नतीजे
अगले चरण:
- स्पैनर कैप व्हाइट पेपर पढ़ें
- स्कीमा डिज़ाइन और क्वेरी के सबसे सही तरीकों के बारे में जानें
- Cloud Spanner के कमिट टाइमस्टैंप के बारे में ज़्यादा जानें
हमें अपना सुझाव/राय दें या शिकायत करें
- कृपया थोड़ा समय निकालकर, हमारे बहुत छोटे से सर्वे को पूरा करें