Cloud Spanner: Go के साथ गेमिंग लीडरबोर्ड बनाएं

1. खास जानकारी

Google Cloud Spanner, पूरी तरह से मैनेज की जाने वाली, हॉरिज़ॉन्टल तौर पर स्केल की जा सकने वाली, दुनिया भर में उपलब्ध, और रिलेशनल डेटाबेस सेवा है. यह बेहतर परफ़ॉर्मेंस और ज़्यादा अपटाइम के साथ-साथ, ACID ट्रांज़ैक्शन और SQL सिमैंटिक उपलब्ध कराती है.

इस लैब में, आपको Cloud Spanner इंस्टेंस को सेट अप करने का तरीका बताया जाएगा. आपको डेटाबेस और स्कीमा बनाने का तरीका बताया जाएगा. इनका इस्तेमाल गेमिंग लीडरबोर्ड के लिए किया जा सकता है. सबसे पहले, आपको खिलाड़ियों की जानकारी सेव करने के लिए, Players टेबल बनानी होगी. इसके बाद, खिलाड़ियों के स्कोर सेव करने के लिए, Scores टेबल बनानी होगी.

इसके बाद, टेबल में सैंपल डेटा डाला जाएगा. इसके बाद, लैब को पूरा करने के लिए, टॉप 10 सैंपल क्वेरी चलाएं. आखिर में, संसाधनों को खाली करने के लिए इंस्टेंस मिटाएं.

आपको क्या सीखने को मिलेगा

  • Cloud Spanner इंस्टेंस सेट अप करने का तरीका.
  • डेटाबेस और टेबल बनाने का तरीका.
  • कमिट टाइमस्टैंप कॉलम का इस्तेमाल करने का तरीका.
  • टाइमस्टैंप के साथ, Cloud Spanner डेटाबेस टेबल में डेटा लोड करने का तरीका.
  • Cloud Spanner डेटाबेस को क्वेरी करने का तरीका.
  • Cloud Spanner इंस्टेंस मिटाने का तरीका.

W****आपको इन चीज़ों की ज़रूरत होगी

  • कोई वेब ब्राउज़र, जैसे कि Chrome या Firefox.

इस ट्यूटोरियल का इस्तेमाल कैसे किया जाएगा?

सिर्फ़ इसे पढ़ें इसे पढ़ें और एक्सरसाइज़ पूरी करें

Google Cloud Platform को इस्तेमाल करने के अपने अनुभव को आप क्या रेटिंग देंगे?

शुरुआती सामान्य एडवांस

2. सेटअप और ज़रूरी शर्तें

अपने हिसाब से एनवायरमेंट सेट अप करना

अगर आपके पास पहले से कोई Google खाता (Gmail या Google Apps) नहीं है, तो आपको एक खाता बनाना होगा. Google Cloud Platform Console ( console.cloud.google.com) में साइन इन करें और एक नया प्रोजेक्ट बनाएं.

अगर आपके पास पहले से कोई प्रोजेक्ट है, तो कंसोल में सबसे ऊपर बाईं ओर मौजूद, प्रोजेक्ट चुनने वाले पुल-डाउन मेन्यू पर क्लिक करें:

6c9406d9b014760.png

इसके बाद, नया प्रोजेक्ट बनाने के लिए, डायलॉग बॉक्स में मौजूद ‘नया प्रोजेक्ट' बटन पर क्लिक करें:

f708315ae07353d0.png

अगर आपके पास पहले से कोई प्रोजेक्ट नहीं है, तो आपको अपना पहला प्रोजेक्ट बनाने के लिए इस तरह का डायलॉग दिखेगा:

870a3cbd6541ee86.png

इसके बाद, प्रोजेक्ट बनाने के डायलॉग बॉक्स में, नए प्रोजेक्ट की जानकारी डाली जा सकती है:

6a92c57d3250a4b3.png

प्रोजेक्ट आईडी याद रखें. यह सभी Google Cloud प्रोजेक्ट के लिए एक यूनीक नाम होता है. ऊपर दिया गया नाम पहले ही इस्तेमाल किया जा चुका है. इसलिए, यह आपके लिए काम नहीं करेगा. माफ़ करें! इस कोड लैब में इसे बाद में PROJECT_ID के तौर पर दिखाया जाएगा.

इसके बाद, अगर आपने अब तक ऐसा नहीं किया है, तो आपको Google Cloud के संसाधनों का इस्तेमाल करने के लिए, Developers Console में बिलिंग चालू करनी होगी. साथ ही, Cloud Spanner API चालू करना होगा.

15d0ef27a8fbab27.png

इस कोडलैब को पूरा करने में आपको कुछ डॉलर से ज़्यादा खर्च नहीं करने पड़ेंगे. हालांकि, अगर आपको ज़्यादा संसाधनों का इस्तेमाल करना है या उन्हें चालू रखना है, तो यह खर्च बढ़ सकता है. इस दस्तावेज़ के आखिर में "सफाई" सेक्शन देखें. Google Cloud Spanner की कीमत के बारे में जानकारी यहां दी गई है.

Google Cloud Platform के नए उपयोगकर्ताओं को, मुफ़्त में आज़माने के लिए 300 डॉलर मिलते हैं. इससे इस कोडलैब का इस्तेमाल बिना किसी शुल्क के किया जा सकता है.

Google Cloud Shell सेटअप करना

Google Cloud और Spanner को लैपटॉप से रिमोटली ऐक्सेस किया जा सकता है. हालांकि, इस कोडलैब में हम Google Cloud Shell का इस्तेमाल करेंगे. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.

यह Debian पर आधारित वर्चुअल मशीन है. इसमें डेवलपमेंट के लिए ज़रूरी सभी टूल पहले से मौजूद हैं. यह 5 जीबी की होम डायरेक्ट्री उपलब्ध कराता है और Google Cloud में चलता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस बेहतर होती है. इसका मतलब है कि इस कोडलैब के लिए, आपको सिर्फ़ एक ब्राउज़र की ज़रूरत होगी. हां, यह Chromebook पर भी काम करता है.

  1. Cloud Console से Cloud Shell चालू करने के लिए, बस Cloud Shell चालू करें a8460e837e9f5fda.png पर क्लिक करें. इसे चालू होने और एनवायरमेंट से कनेक्ट होने में कुछ ही समय लगेगा.

b532b2f19ab85dda.png

Screen Shot 2017-06-14 at 10.13.43 PM.png

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 के डैशबोर्ड में जाकर इसे देखें:

2485e00c1223af09.png

Cloud Shell, कुछ एनवायरमेंट वैरिएबल को डिफ़ॉल्ट रूप से भी सेट करता है. ये वैरिएबल, आने वाले समय में कमांड चलाने के दौरान आपके काम आ सकते हैं.

echo $GOOGLE_CLOUD_PROJECT

कमांड आउटपुट

<PROJECT_ID>
  1. आखिर में, डिफ़ॉल्ट ज़ोन और प्रोजेक्ट कॉन्फ़िगरेशन सेट करें.
gcloud config set compute/zone us-central1-f

आपके पास अलग-अलग ज़ोन चुनने का विकल्प होता है. ज़्यादा जानकारी के लिए, रीजन और ज़ोन देखें.

खास जानकारी

इस चरण में, आपको अपना एनवायरमेंट सेट अप करना होता है.

आगे बढ़ें

इसके बाद, आपको Cloud Spanner इंस्टेंस सेट अप करना होगा.

3. Cloud Spanner इंस्टेंस सेट अप करना

इस चरण में, हम इस कोडलैब के लिए अपना Cloud Spanner इंस्टेंस सेट अप करते हैं. सबसे ऊपर बाईं ओर मौजूद हैमबर्गर मेन्यू 1a6580bd3d3e6783.png में जाकर, Spanner एंट्री खोजें 3129589f7bc9e5ce.png या "/" दबाकर Spanner खोजें और "Spanner" टाइप करें

36e52f8df8e13b99.png

इसके बाद, 19bb9864067757cb.png पर क्लिक करें और फ़ॉर्म भरें. इसके लिए, अपने इंस्टेंस के लिए इंस्टेंस का नाम cloudspanner-leaderboard डालें, कॉन्फ़िगरेशन चुनें (क्षेत्रीय इंस्टेंस चुनें), और नोड की संख्या सेट करें. इस कोडलैब के लिए, हमें सिर्फ़ एक नोड की ज़रूरत होगी. प्रोडक्शन इंस्टेंस के लिए और Cloud Spanner के एसएलए की ज़रूरी शर्तें पूरी करने के लिए, आपको अपने Cloud Spanner इंस्टेंस में तीन या उससे ज़्यादा नोड चलाने होंगे.

आखिर में, "बनाएं" पर क्लिक करें. इसके बाद, कुछ ही सेकंड में आपके पास Cloud Spanner इंस्टेंस उपलब्ध होगा.

dceb68e9ed3801e8.png

अगले चरण में, हम Go क्लाइंट लाइब्रेरी का इस्तेमाल करके, अपने नए इंस्टेंस में डेटाबेस और स्कीमा बनाएंगे.

4. डेटाबेस और स्कीमा बनाना

इस चरण में, हम अपना सैंपल डेटाबेस और स्कीमा बनाएंगे.

आइए, Go क्लाइंट लाइब्रेरी का इस्तेमाल करके दो टेबल बनाते हैं. पहली टेबल, खिलाड़ियों की जानकारी के लिए और दूसरी टेबल, खिलाड़ियों के स्कोर सेव करने के लिए. इसके लिए, हम Cloud Shell में Go कंसोल ऐप्लिकेशन बनाने के चरणों के बारे में जानेंगे.

सबसे पहले, इस कोडलैब के लिए सैंपल कोड को Github से क्लोन करें. इसके लिए, Cloud Shell में यह निर्देश टाइप करें:

export GO111MODULE=auto
go get -u github.com/GoogleCloudPlatform/golang-samples/spanner/...

इसके बाद, डायरेक्ट्री को "leaderboard" डायरेक्ट्री में बदलें. यहां आपको अपना ऐप्लिकेशन बनाना होगा.

cd gopath/src/github.com/GoogleCloudPlatform/golang-samples/spanner/spanner_leaderboard

इस कोडलैब के लिए ज़रूरी सभी कोड, मौजूदा golang-samples/spanner/spanner_leaderboard/ डायरेक्ट्री में मौजूद हैं. इन्हें leaderboard नाम के Go ऐप्लिकेशन के तौर पर चलाया जा सकता है. कोडलैब के दौरान, इनका इस्तेमाल रेफ़रंस के तौर पर किया जा सकता है. हम एक नई डायरेक्ट्री बनाएंगे और लीडरबोर्ड ऐप्लिकेशन की कॉपी को चरणों में तैयार करेंगे.

ऐप्लिकेशन के लिए "codelab" नाम की नई डायरेक्ट्री बनाएं. इसके बाद, इस डायरेक्ट्री में जाने के लिए यह कमांड इस्तेमाल करें:

mkdir codelab && cd $_

अब हम "Leaderboard" नाम का एक बुनियादी Go ऐप्लिकेशन बनाएंगे. यह Spanner क्लाइंट लाइब्रेरी का इस्तेमाल करके, दो टेबल वाला लीडरबोर्ड बनाएगा: Players और Scores. Cloud Shell Editor में जाकर, यह काम किया जा सकता है:

नीचे हाइलाइट किए गए "एडिटर खोलें" आइकॉन पर क्लिक करके, Cloud Shell Editor खोलें:

7519d016b96ca51b.png

~/gopath/src/github.com/GoogleCloudPlatform/golang-samples/spanner/codelab फ़ोल्डर में "leaderboard.go" नाम की फ़ाइल बनाएं.

  • सबसे पहले, पक्का करें कि आपने Cloud Shell Editor में फ़ोल्डर की सूची में "codelab" फ़ोल्डर चुना हो.
  • इसके बाद, Cloud Shell Editor के "फ़ाइल" मेन्यू में जाकर, "नई फ़ाइल" को चुनें.
  • नई फ़ाइल का नाम "leaderboard.go" डालें.

यह ऐप्लिकेशन की मुख्य फ़ाइल है. इसमें ऐप्लिकेशन का कोड और डिपेंडेंसी शामिल करने के लिए रेफ़रंस शामिल होंगे.

leaderboard डेटाबेस और Players और Scores टेबल बनाने के लिए, यहां दिए गए Go कोड को leaderboard.go फ़ाइल में कॉपी (Ctrl + P) करें और चिपकाएं (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)
        }
}

Cloud Shell Editor के "फ़ाइल" मेन्यू में जाकर, "सेव करें" को चुनें. इससे leaderboard.go फ़ाइल में किए गए बदलाव सेव हो जाएंगे.

golang-samples/spanner/spanner_leaderboard डायरेक्ट्री में मौजूद leaderboard.go फ़ाइल का इस्तेमाल करके, यह देखा जा सकता है कि createdatabase कमांड चालू करने के लिए कोड जोड़ने के बाद, आपकी leaderboard.go फ़ाइल कैसी दिखेगी.

Cloud Shell में अपना ऐप्लिकेशन बनाने के लिए, codelab डायरेक्ट्री से "go build" चलाएं. यह डायरेक्ट्री वह जगह है जहां आपकी 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 डेटाबेस की खास जानकारी वाले सेक्शन में, आपको बाईं ओर मौजूद मेन्यू में अपना नया डेटाबेस और टेबल दिखनी चाहिए.

a12fa65e352836b1.png

अगले चरण में, हम अपने ऐप्लिकेशन को अपडेट करेंगे, ताकि आपके नए डेटाबेस में कुछ डेटा लोड किया जा सके.

5. डेटा लोड करें

अब हमारे पास leaderboard नाम का एक डेटाबेस है. इसमें दो टेबल हैं: Players और Scores. अब, Go क्लाइंट लाइब्रेरी का इस्तेमाल करके, Players टेबल में प्लेयर और Scores टेबल में हर प्लेयर के लिए रैंडम स्कोर भरते हैं.

अगर Cloud Shell Editor पहले से खुला नहीं है, तो नीचे हाइलाइट किए गए आइकॉन पर क्लिक करके इसे खोलें:

7519d016b96ca51b.png

इसके बाद, Cloud Shell Editor में leaderboard.go फ़ाइल में बदलाव करें. ऐसा करने के लिए, insertplayers कमांड जोड़ें. इस कमांड का इस्तेमाल करके, Players टेबल में 100 खिलाड़ियों को जोड़ा जा सकता है. हम एक insertscores कमांड भी जोड़ेंगे. इसका इस्तेमाल, Players टेबल में मौजूद हर खिलाड़ी के लिए, Scores टेबल में चार रैंडम स्कोर डालने के लिए किया जा सकता है.

सबसे पहले, imports फ़ाइल में सबसे ऊपर मौजूद 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,
        }
)

इसके बाद, मौजूदा 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 कमांड को चालू करने के लिए, अपने ऐप्लिकेशन के "run" फ़ंक्शन में, 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
}

अपने ऐप्लिकेशन में "डालें" सुविधा जोड़ने के लिए, आखिरी चरण यह है कि flag.Usage()फ़ंक्शन में "insertplayers" और "insertscores" कमांड के लिए सहायता टेक्स्ट जोड़ें. flag.Usage() फ़ंक्शन में यह मदद वाला टेक्स्ट जोड़ें, ताकि insert कमांड के लिए मदद वाला टेक्स्ट शामिल किया जा सके:

इन दोनों निर्देशों को, संभावित निर्देशों की सूची में जोड़ें:

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.

Cloud Shell Editor के "फ़ाइल" मेन्यू में जाकर, "सेव करें" को चुनें. इससे 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

अब हम Go क्लाइंट लाइब्रेरी का इस्तेमाल करके, 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,
        },
})

"Insert" लेन-देन कब हुआ, इसकी जानकारी 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 कॉलम में डेटा मौजूद है.

86dc5b927809a4ec.png

इसके बाद, आइए पुष्टि करें कि स्कोर टेबल में भी डेटा है. इसके लिए, Scores टेबल पर क्लिक करें और Data टैब चुनें. आपको टेबल के PlayerId, Timestamp, और Score कॉलम में डेटा दिखेगा.

87c8610c92d3c612.png

बहुत खूब! आइए, हम अपने ऐप्लिकेशन को अपडेट करें, ताकि हम कुछ ऐसी क्वेरी चला सकें जिनका इस्तेमाल गेमिंग लीडरबोर्ड बनाने के लिए किया जा सकता है.

6. लीडरबोर्ड की क्वेरी चलाना

हमने अपना डेटाबेस सेट अप कर लिया है और अपनी टेबल में जानकारी लोड कर ली है. अब इस डेटा का इस्तेमाल करके, लीडरबोर्ड बनाते हैं. इसके लिए, हमें इन चार सवालों के जवाब देने होंगे:

  1. अब तक के "टॉप टेन" खिलाड़ी कौनसे हैं?
  2. इस साल के "टॉप टेन" खिलाड़ी कौनसे हैं?
  3. महीने के "टॉप टेन" खिलाड़ी कौनसे हैं?
  4. इस हफ़्ते के "टॉप टेन" खिलाड़ी कौनसे हैं?

आइए, हम अपने ऐप्लिकेशन को अपडेट करें, ताकि एसक्यूएल क्वेरी चलाई जा सकें और इन सवालों के जवाब दिए जा सकें.

हम query और queryWithTimespan कमांड जोड़ेंगे. इनकी मदद से, क्वेरी को चलाया जा सकेगा. इससे उन सवालों के जवाब मिलेंगे जिनसे लीडरबोर्ड के लिए ज़रूरी जानकारी मिलेगी.

ऐप्लिकेशन को अपडेट करने के लिए, Cloud Shell Editor में leaderboard.go फ़ाइल में बदलाव करें. साथ ही, query और queryWithTimespan कमांड जोड़ें. हम अपने स्कोर को कॉमा के साथ फ़ॉर्मैट करने के लिए, formatWithCommas हेल्पर फ़ंक्शन भी जोड़ेंगे.

सबसे पहले, imports फ़ाइल में सबसे ऊपर मौजूद 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"
)

इसके बाद, यहां दिए गए दो फ़ंक्शन और हेल्पर फ़ंक्शन को मौजूदा 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, &timestamp); 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, &timestamp); 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 फ़ाइल में सबसे ऊपर, commands वैरिएबल में "query" को एक कमांड विकल्प के तौर पर जोड़ें. इसे "insertscores": insertScores विकल्प के ठीक नीचे जोड़ें, ताकि commands वैरिएबल इस तरह दिखे:

var (
        commands = map[string]command{
                "insertplayers": insertPlayers,
                "insertscores":  insertScores,
                "query":         query,
        }
)

इसके बाद, "createdatabase" कमांड सेक्शन के नीचे और "insert and query" कमांड हैंडलिंग सेक्शन के ऊपर, run फ़ंक्शन में "queryWithTimespan" को कमांड विकल्प के तौर पर जोड़ें:

        // 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 कमांड को काम करने लायक बनाने के लिए, अपने ऐप्लिकेशन के "main" तरीके में flag.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)
        }

अपने ऐप्लिकेशन में "query" फ़ंक्शन जोड़ने के लिए, आपको flag.Usage()फ़ंक्शन में "query" और "querywithtimespan" कमांड के लिए सहायता टेक्स्ट जोड़ना होगा. क्वेरी कमांड के लिए मदद वाला टेक्स्ट शामिल करने के लिए, flag.Usage()फ़ंक्शन में कोड की ये लाइनें जोड़ें:

संभावित निर्देशों की सूची में, "query" वाले दो निर्देश जोड़ें:

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.

Cloud Shell Editor के "फ़ाइल" मेन्यू में जाकर, "सेव करें" को चुनें. इससे 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 कमांड का इस्तेमाल करके, अब तक के "टॉप टेन" खिलाड़ियों की सूची पा सकते हैं. हम यह भी देख सकते हैं कि querywithtimespan कमांड की मदद से, हम घंटों की संख्या में समयसीमा तय कर सकते हैं. इसका इस्तेमाल, Scores टेबल के Timestamp कॉलम में मौजूद वैल्यू के आधार पर रिकॉर्ड फ़िल्टर करने के लिए किया जाता है.

आइए, query कमांड को उसी आर्ग्युमेंट वैल्यू के साथ चलाएं जिसका इस्तेमाल हमने create कमांड को चलाते समय किया था. पक्का करें कि आपने my-project की जगह, इस कोडलैब की शुरुआत में बनाया गया प्रोजेक्ट आईडी डाला हो.

./leaderboard query  projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard

आपको ऐसा जवाब दिखेगा जिसमें अब तक के "टॉप टेन" खिलाड़ियों के नाम शामिल होंगे. जैसे:

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

आपको ऐसा जवाब दिखेगा जिसमें साल के "टॉप टेन" खिलाड़ियों के नाम शामिल होंगे. जैसे:

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 कमांड चलाएं. इसके लिए, "timespan" को एक महीने में मौजूद घंटों की संख्या के बराबर सेट करें. यह संख्या 730 है. पक्का करें कि आपने my-project की जगह, इस कोडलैब की शुरुआत में बनाया गया प्रोजेक्ट आईडी डाला हो.

./leaderboard querywithtimespan projects/my-project/instances/cloudspanner-leaderboard/databases/leaderboard 730

आपको ऐसा जवाब दिखेगा जिसमें महीने के "टॉप टेन" खिलाड़ियों के नाम शामिल होंगे. जैसे:

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

आपको ऐसा जवाब दिखेगा जिसमें हफ़्ते के "टॉप टेन" खिलाड़ियों के नाम शामिल होंगे. जैसे:

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 Spanner इंस्टेंस, डेटाबेस, और टेबल स्कीमा
  • Go कंसोल ऐप्लिकेशन बनाने का तरीका
  • Go क्लाइंट लाइब्रेरी का इस्तेमाल करके, Spanner डेटाबेस और टेबल बनाने का तरीका
  • Go क्लाइंट लाइब्रेरी का इस्तेमाल करके, Spanner डेटाबेस में डेटा लोड करने का तरीका
  • Spanner कमिट टाइमस्टैंप और Go क्लाइंट लाइब्रेरी का इस्तेमाल करके, अपने डेटा से "टॉप टेन" नतीजे पाने के लिए क्वेरी करने का तरीका

अगले चरण:

हमें सुझाव/राय दें या शिकायत करें

  • कृपया थोड़ा समय निकालकर, हमारे छोटे से सर्वे में हिस्सा लें