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

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

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

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

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

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

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

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

  • कोई वेब ब्राउज़र, जैसे कि 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 चालू करें gcLMt5IuEcJJNnMId-Bcz3sxCd0rZn7IzT_r95C8UZeqML68Y1efBG_B0VRp7hc7qiZTLAF-TXD7SsOadxn8uadgHhaLeASnVS3ZHK39eOlKJOgj9SJua_oeGhMxRrbOg3qigddS2A पर क्लिक करें. इसे चालू होने और एनवायरमेंट से कनेक्ट होने में कुछ ही समय लगेगा.

JjEuRXGg0AYYIY6QZ8d-66gx_Mtc-_jDE9ijmbXLJSAXFvJt-qUpNtsBsYjNpv2W6BQSrDc1D-ARINNQ-1EkwUhz-iUK-FUCZhJ-NtjvIEx9pIkE-246DomWuCfiGHK78DgoeWkHRw

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

158fNPfwSxsFqz9YbtJVZes8viTS3d1bV4CVhij3XPxuzVFOtTObnwsphlm6lYGmgdMFwBJtc-FaLrZU7XHAg_ZYoCrgombMRR3h-eolLPcvO351c5iBv506B3ZwghZoiRg6cz23Qw

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

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

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

dceb68e9ed3801e8.png

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

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

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

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

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

git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git

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

cd java-docs-samples/spanner/leaderboard

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

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

mkdir codelab && cd $_

नीचे दिए गए Maven (mvn) कमांड का इस्तेमाल करके, "Leaderboard" नाम का नया बेसिक Java ऐप्लिकेशन बनाएं:

mvn -B archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DgroupId=com.google.codelabs -DartifactId=leaderboard -DarchetypeVersion=1.4

इस कमांड से एक सामान्य कंसोल ऐप्लिकेशन बनता है. इसमें दो मुख्य फ़ाइलें होती हैं: Maven ऐप्लिकेशन कॉन्फ़िगरेशन फ़ाइल pom.xml और Java ऐप्लिकेशन फ़ाइल App.java.

इसके बाद, डायरेक्ट्री को अभी-अभी बनाई गई लीडरबोर्ड डायरेक्ट्री में बदलें और उसके कॉन्टेंट की सूची बनाएं:

cd leaderboard && ls

आपको pom.xml फ़ाइल और src डायरेक्ट्री की सूची दिखेगी:

pom.xml  src

अब हम इस कंसोल ऐप्लिकेशन को अपडेट करते हैं. इसके लिए, App.java में बदलाव करके, Java Spanner क्लाइंट लाइब्रेरी का इस्तेमाल करें. इससे दो टेबल वाला लीडरबोर्ड बनाया जा सकेगा: खिलाड़ी और स्कोर. Cloud Shell Editor में जाकर, यह काम किया जा सकता है:

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

73cf70e05f653ca.png

लीडरबोर्ड फ़ोल्डर में मौजूद pom.xml फ़ाइल खोलें. java-docs-samples\ spanner\leaderboard\codelab\leaderboard फ़ोल्डर में मौजूद pom.xml फ़ाइल खोलें. यह फ़ाइल, Maven बिल्ड सिस्टम को कॉन्फ़िगर करती है, ताकि हमारे ऐप्लिकेशन को जार में बनाया जा सके. इसमें हमारी सभी डिपेंडेंसी शामिल होती हैं.

मौजूदा </properties> एलिमेंट के ठीक नीचे, डिपेंडेंसी मैनेजमेंट का यह नया सेक्शन जोड़ें:

<dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>com.google.cloud</groupId>
        <artifactId>google-cloud-bom</artifactId>
        <version>0.83.0-alpha</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>

मौजूदा <dependencies> सेक्शन में एक नई डिपेंडेंसी भी जोड़ें. इससे ऐप्लिकेशन में Cloud Spanner Java क्लाइंट लाइब्रेरी जुड़ जाएगी.

    <dependency>
      <!-- Version auto-managed by BOM -->
      <groupId>com.google.cloud</groupId>
      <artifactId>google-cloud-spanner</artifactId>
    </dependency>

इसके बाद, pom.xml फ़ाइल के मौजूदा <build> सेक्शन को इस <build> सेक्शन से बदलें:

 <build>
    <plugins>
      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <version>2.5.5</version>
        <configuration>
          <finalName>leaderboard</finalName>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
          <archive>
            <manifest>
              <mainClass>com.google.codelabs.App</mainClass>
            </manifest>
          </archive>
          <appendAssemblyId>false</appendAssemblyId>
          <attach>false</attach>
        </configuration>
        <executions>
          <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-failsafe-plugin</artifactId>
        <version>3.0.0-M3</version>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>3.0.0-M3</version>
        <configuration>
            <useSystemClassLoader>false</useSystemClassLoader>
        </configuration>
      </plugin>  
    </plugins>
  </build>

pom.xml फ़ाइल में किए गए बदलावों को सेव करें. इसके लिए, Cloud Shell Editor के "फ़ाइल" मेन्यू में जाकर "सेव करें" को चुनें या कीबोर्ड पर "Ctrl" और "S" बटन को एक साथ दबाएँ.

इसके बाद, src/main/java/com/google/codelabs/ फ़ोल्डर में मौजूद Cloud Shell Editor में App.java फ़ाइल खोलें. फ़ाइल के मौजूदा कोड को उस कोड से बदलें जिसकी ज़रूरत leaderboard डेटाबेस और Players और Scores टेबल बनाने के लिए होती है. इसके लिए, App.java फ़ाइल में यहां दिया गया Java कोड चिपकाएं:

package com.google.codelabs;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.spanner.Database;
import com.google.cloud.spanner.DatabaseAdminClient;
import com.google.cloud.spanner.DatabaseClient;
import com.google.cloud.spanner.DatabaseId;
import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerException;
import com.google.cloud.spanner.SpannerExceptionFactory;
import com.google.cloud.spanner.SpannerOptions;
import com.google.spanner.admin.database.v1.CreateDatabaseMetadata;
import java.util.Arrays;
import java.util.concurrent.ExecutionException;

/**
 * Example code for using the Cloud Spanner API with the Google Cloud Java client library
 * to create a simple leaderboard.
 * 
 * This example demonstrates:
 *
 * <p>
 *
 * <ul>
 *   <li>Creating a Cloud Spanner database.
 * </ul>
 */
public class App {

  static void create(DatabaseAdminClient dbAdminClient, DatabaseId db) {
    OperationFuture<Database, CreateDatabaseMetadata> op =
        dbAdminClient.createDatabase(
            db.getInstanceId().getInstance(),
            db.getDatabase(),
            Arrays.asList(
                "CREATE TABLE Players(\n"
                    + "  PlayerId INT64 NOT NULL,\n"
                    + "  PlayerName STRING(2048) NOT NULL\n"
                    + ") PRIMARY KEY(PlayerId)",
                "CREATE TABLE Scores(\n"
                    + "  PlayerId INT64 NOT NULL,\n"
                    + "  Score INT64 NOT NULL,\n"
                    + "  Timestamp TIMESTAMP NOT NULL\n"
                    + "  OPTIONS(allow_commit_timestamp=true)\n"
                    + ") PRIMARY KEY(PlayerId, Timestamp),\n"
                    + "INTERLEAVE IN PARENT Players ON DELETE NO ACTION"));
    try {
      // Initiate the request which returns an OperationFuture.
      Database dbOperation = op.get();
      System.out.println("Created database [" + dbOperation.getId() + "]");
    } catch (ExecutionException e) {
      // If the operation failed during execution, expose the cause.
      throw (SpannerException) e.getCause();
    } catch (InterruptedException e) {
      // Throw when a thread is waiting, sleeping, or otherwise occupied,
      // and the thread is interrupted, either before or during the activity.
      throw SpannerExceptionFactory.propagateInterrupt(e);
    }
  }

  static void printUsageAndExit() {
    System.out.println("Leaderboard 1.0.0");
    System.out.println("Usage:");
    System.out.println("  java -jar leaderboard.jar "
        + "<command> <instance_id> <database_id> [command_option]");
    System.out.println("");
    System.out.println("Examples:");
    System.out.println("  java -jar leaderboard.jar create my-instance example-db");
    System.out.println("      - Create a sample Cloud Spanner database along with "
        + "sample tables in your project.\n");
    System.exit(1);
  }

  public static void main(String[] args) throws Exception {
    if (!(args.length == 3 || args.length == 4)) {
      printUsageAndExit();
    }
    SpannerOptions options = SpannerOptions.newBuilder().build();
    Spanner spanner = options.getService();
    try {
      String command = args[0];
      DatabaseId db = DatabaseId.of(options.getProjectId(), args[1], args[2]);
      DatabaseClient dbClient = spanner.getDatabaseClient(db);
      DatabaseAdminClient dbAdminClient = spanner.getDatabaseAdminClient();
      switch (command) {
        case "create":
          create(dbAdminClient, db);
          break;
        default:
          printUsageAndExit();
      }
    } finally {
      spanner.close();
    }
    System.out.println("Closed client");
  }
}

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

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

अपना ऐप्लिकेशन बनाने के लिए, उस डायरेक्ट्री से mvn package चलाएं जहां आपका pom.xml मौजूद है:

mvn package

Java jar फ़ाइल बन जाने के बाद, क्लाउड शेल में इस कमांड को डालकर, ऐप्लिकेशन चलाएं:

java -jar target/leaderboard.jar

आपको इस तरह का आउटपुट दिखेगा:

Leaderboard 1.0.0
Usage:
  java -jar leaderboard.jar <command> <instance_id> <database_id> [command_option]

Examples:
  java -jar leaderboard.jar create my-instance example-db
      - Create a sample Cloud Spanner database along with sample tables in your project.

इस जवाब से हमें पता चलता है कि यह Leaderboard ऐप्लिकेशन है. फ़िलहाल, इसके लिए एक निर्देश उपलब्ध है: create. हम देख सकते हैं कि create कमांड के लिए, इंस्टेंस आईडी और डेटाबेस आईडी के तौर पर आर्ग्युमेंट दिए जाने चाहिए.

अब यह कमांड चलाएं.

java -jar target/leaderboard.jar create cloudspanner-leaderboard leaderboard

कुछ सेकंड बाद, आपको इस तरह का जवाब दिखेगा:

Created database [projects/your-project/instances/cloudspanner-leaderboard/databases/leaderboard]

Cloud Console के Cloud Spanner सेक्शन में, आपको बाईं ओर मौजूद मेन्यू में अपना नया डेटाबेस और टेबल दिखनी चाहिए.

ba9008bb84cb90b0.png

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

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

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

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

ef49fcbaaed19024.png

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

सबसे पहले, ऐप्लिकेशन फ़ाइल में सबसे ऊपर मौजूद imports सेक्शन को अपडेट करें. इसके लिए, मौजूदा जानकारी को नई जानकारी से बदलें. अपडेट करने के बाद, यह सेक्शन इस तरह दिखना चाहिए:

package com.google.codelabs;

import static com.google.cloud.spanner.TransactionRunner.TransactionCallable;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.spanner.Database;
import com.google.cloud.spanner.DatabaseAdminClient;
import com.google.cloud.spanner.DatabaseClient;
import com.google.cloud.spanner.DatabaseId;
import com.google.cloud.spanner.Mutation;
import com.google.cloud.spanner.ResultSet;
import com.google.cloud.spanner.Spanner;
import com.google.cloud.spanner.SpannerException;
import com.google.cloud.spanner.SpannerExceptionFactory;
import com.google.cloud.spanner.SpannerOptions;
import com.google.cloud.spanner.Statement;
import com.google.cloud.spanner.TransactionContext;
import com.google.spanner.admin.database.v1.CreateDatabaseMetadata;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ThreadLocalRandom;

इसके बाद, मौजूदा create() तरीके के नीचे और मौजूदा printUsageAndExit() तरीके के ऊपर, insert, insertPlayers, और insertScores के ये तरीके जोड़ें:

  static void insert(DatabaseClient dbClient, String insertType) {
    try {
      insertType = insertType.toLowerCase();
    } catch (Exception e) {
      // Invalid input received, set insertType to empty string.
      insertType = "";
    }
    if (insertType.equals("players")) {
      // Insert players.
      insertPlayers(dbClient);
    } else if (insertType.equals("scores")) {
      // Insert scores.
      insertScores(dbClient);
    } else {
      // Invalid input.
      System.out.println("Invalid value for 'type of insert'. "
          + "Specify a valid value: 'players' or 'scores'.");
      System.exit(1);
    }
  }

  static void insertPlayers(DatabaseClient dbClient) {
    dbClient
        .readWriteTransaction()
        .run(
            new TransactionCallable<Void>() {
              @Override
              public Void run(TransactionContext transaction) throws Exception {
                // Get the number of players.
                String sql = "SELECT Count(PlayerId) as PlayerCount FROM Players";
                ResultSet resultSet = transaction.executeQuery(Statement.of(sql));
                long numberOfPlayers = 0;
                if (resultSet.next()) {
                  numberOfPlayers = resultSet.getLong("PlayerCount");
                }
                // Insert 100 player records into the Players table.
                List<Statement> stmts = new ArrayList<Statement>();
                long randomId;
                for (int x = 1; x <= 100; x++) {
                  numberOfPlayers++;
                  randomId = (long) Math.floor(Math.random() * 9_000_000_000L) + 1_000_000_000L;
                  Statement statement =
                      Statement
                        .newBuilder(
                            "INSERT INTO Players (PlayerId, PlayerName) "
                            + "VALUES (@PlayerId, @PlayerName) ")
                        .bind("PlayerId")
                        .to(randomId)
                        .bind("PlayerName")
                        .to("Player " + numberOfPlayers)
                        .build();
                  stmts.add(statement);
                }
                transaction.batchUpdate(stmts);
                return null;
              }
            });
    System.out.println("Done inserting player records...");
  }

  static void insertScores(DatabaseClient dbClient) {
    boolean playerRecordsFound = false;
    ResultSet resultSet =
        dbClient
            .singleUse()
            .executeQuery(Statement.of("SELECT * FROM Players"));
    while (resultSet.next()) {
      playerRecordsFound = true;
      final long playerId = resultSet.getLong("PlayerId");
      dbClient
          .readWriteTransaction()
          .run(
              new TransactionCallable<Void>() {
                @Override
                public Void run(TransactionContext transaction) throws Exception {
                  // Initialize objects for random Score and random Timestamp.
                  LocalDate endDate = LocalDate.now();
                  long end = endDate.toEpochDay();
                  int startYear = endDate.getYear() - 2;
                  int startMonth = endDate.getMonthValue();
                  int startDay = endDate.getDayOfMonth();
                  LocalDate startDate = LocalDate.of(startYear, startMonth, startDay);
                  long start = startDate.toEpochDay();
                  Random r = new Random();
                  List<Statement> stmts = new ArrayList<Statement>();
                  // Insert 4 score records into the Scores table 
                  // for each player in the Players table.
                  for (int x = 1; x <= 4; x++) {
                    // Generate random score between 1,000,000 and 1,000
                    long randomScore = r.nextInt(1000000 - 1000) + 1000;
                    // Get random day within the past two years.
                    long randomDay = ThreadLocalRandom.current().nextLong(start, end);
                    LocalDate randomDayDate = LocalDate.ofEpochDay(randomDay);
                    LocalTime randomTime = LocalTime.of(
                        r.nextInt(23), r.nextInt(59), r.nextInt(59), r.nextInt(9999));
                    LocalDateTime randomDate = LocalDateTime.of(randomDayDate, randomTime);
                    Instant randomInstant = randomDate.toInstant(ZoneOffset.UTC);
                    Statement statement =
                        Statement
                        .newBuilder(
                          "INSERT INTO Scores (PlayerId, Score, Timestamp) "
                          + "VALUES (@PlayerId, @Score, @Timestamp) ")
                        .bind("PlayerId")
                        .to(playerId)
                        .bind("Score")
                        .to(randomScore)
                        .bind("Timestamp")
                        .to(randomInstant.toString())
                        .build();
                    stmts.add(statement);
                  }
                  transaction.batchUpdate(stmts);
                  return null;
                }
              });

    }
    if (!playerRecordsFound) {
      System.out.println("Parameter 'scores' is invalid since "
          + "no player records currently exist. First insert players "
          + "then insert scores.");
      System.exit(1);
    } else {
      System.out.println("Done inserting score records...");
    }
  }

इसके बाद, insert कमांड को चालू करने के लिए, अपने ऐप्लिकेशन के "main" तरीके में insert स्टेटमेंट के अंदर यह कोड जोड़ें :switch (command)

        case "insert":
          String insertType;
          try {
            insertType = args[3];
          } catch (ArrayIndexOutOfBoundsException exception) {
            insertType = "";
          }
          insert(dbClient, insertType);
          break;

switch (command) स्टेटमेंट पूरा होने के बाद, कुछ इस तरह दिखेगा:

      switch (command) {
        case "create":
          create(dbAdminClient, db);
          break;
        case "insert":
          String insertType;
          try {
            insertType = args[3];
          } catch (ArrayIndexOutOfBoundsException exception) {
            insertType = "";
          }
          insert(dbClient, insertType);
          break;
        default:
          printUsageAndExit();
      }

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

    System.out.println("  java -jar leaderboard.jar insert my-instance example-db players");
    System.out.println("      - Insert 100 sample Player records into the database.\n");
    System.out.println("  java -jar leaderboard.jar insert my-instance example-db scores");
    System.out.println("      - Insert sample score data into Scores sample Cloud Spanner "
        + "database table.\n");

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

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

अब ऐप्लिकेशन को फिर से बनाएं और चलाएं, ताकि यह पुष्टि की जा सके कि नई insert कमांड को ऐप्लिकेशन की संभावित कमांड की सूची में शामिल किया गया है.

अपना ऐप्लिकेशन बनाने के लिए, उस डायरेक्ट्री से mvn package चलाएं जहां आपकी pom.xml फ़ाइल मौजूद है:

mvn package

Java jar फ़ाइल बन जाने के बाद, यह कमांड चलाएं:

java -jar target/leaderboard.jar

अब आपको ऐप्लिकेशन के डिफ़ॉल्ट आउटपुट में insert कमांड शामिल दिखेगी:

Leaderboard 1.0.0
Usage:
  java -jar leaderboard.jar <command> <instance_id> <database_id> [command_option]

Examples:
  java -jar leaderboard.jar create my-instance example-db
      - Create a sample Cloud Spanner database along with sample tables in your project.

  java -jar leaderboard.jar insert my-instance example-db players
      - Insert 100 sample Player records into the database.

  java -jar leaderboard.jar insert my-instance example-db scores
      - Insert sample score data into Scores sample Cloud Spanner database table.

जवाब में देखा जा सकता है कि इंस्टेंस आईडी और डेटाबेस आईडी के अलावा, एक और आर्ग्युमेंट है. इसकी वैल्यू ‘players' या ‘scores' हो सकती है.

अब हम insert कमांड को उसी आर्ग्युमेंट वैल्यू के साथ चलाएंगे जिसका इस्तेमाल हमने create कमांड को कॉल करते समय किया था. साथ ही, "players" को "टाइप ऑफ़ इंसर्ट" आर्ग्युमेंट के तौर पर जोड़ेंगे.

java -jar target/leaderboard.jar insert cloudspanner-leaderboard leaderboard players

कुछ सेकंड बाद, आपको इस तरह का जवाब दिखेगा:

Done inserting player records...

अब हम Java क्लाइंट लाइब्रेरी का इस्तेमाल करके, 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 कार्रवाइयों के लिए, सटीक लेन-देन के टाइमस्टैंप के साथ अपने-आप भर जाता है.

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

अब हम insert कमांड को उसी आर्ग्युमेंट वैल्यू के साथ चलाएंगे जिसका इस्तेमाल हमने create कमांड को कॉल करते समय किया था. साथ ही, "स्कोर" को "टाइप ऑफ़ इंसर्ट" आर्ग्युमेंट के तौर पर जोड़ेंगे.

java -jar target/leaderboard.jar insert cloudspanner-leaderboard leaderboard scores

कुछ सेकंड बाद, आपको इस तरह का जवाब दिखेगा:

Done inserting score records...

insert को scores के तौर पर तय किए गए "टाइप ऑफ़ इंसर्ट" के साथ चलाने पर, insertScores तरीके को कॉल किया जाता है. यह तरीका, नीचे दिए गए कोड स्निपेट का इस्तेमाल करके, तारीख और समय के साथ रैंडम तरीके से जनरेट किया गया टाइमस्टैंप डालता है:

          LocalDate endDate = LocalDate.now();
          long end = endDate.toEpochDay();
          int startYear = endDate.getYear() - 2;
          int startMonth = endDate.getMonthValue();
          int startDay = endDate.getDayOfMonth();
          LocalDate startDate = LocalDate.of(startYear, startMonth, startDay);
          long start = startDate.toEpochDay();
...
            long randomDay = ThreadLocalRandom.current().nextLong(start, end);
            LocalDate randomDayDate = LocalDate.ofEpochDay(randomDay);
            LocalTime randomTime = LocalTime.of(
                        r.nextInt(23), r.nextInt(59), r.nextInt(59), r.nextInt(9999));
            LocalDateTime randomDate = LocalDateTime.of(randomDayDate, randomTime);
            Instant randomInstant = randomDate.toInstant(ZoneOffset.UTC);

...
               .bind("Timestamp")
               .to(randomInstant.toString())

"Insert" लेन-देन कब हुआ, इसकी टाइमस्टैंप की जानकारी Timestamp कॉलम में अपने-आप भरने के लिए, Java कॉन्स्टेंट Value.COMMIT_TIMESTAMP डालें. इसे नीचे दिए गए कोड स्निपेट में दिखाया गया है:

               .bind("Timestamp")
               .to(Value.COMMIT_TIMESTAMP)

डेटा लोड हो गया है. अब हम उन वैल्यू की पुष्टि करते हैं जिन्हें हमने अभी-अभी नई टेबल में लिखा है. पहले leaderboard डेटाबेस चुनें. इसके बाद, Players टेबल चुनें. Data टैब पर क्लिक करें. आपको दिखेगा कि टेबल के PlayerId और PlayerName कॉलम में डेटा मौजूद है.

7bc2c96293c31c49.png

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

d8a4ee4f13244c19.png

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

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

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

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

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

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

ऐप्लिकेशन को अपडेट करने के लिए, Cloud Shell Editor में App.java फ़ाइल में बदलाव करें, ताकि query कमांड जोड़ी जा सके. query कमांड में दो query तरीके शामिल हैं. इनमें से एक में सिर्फ़ DatabaseClient आर्ग्युमेंट होता है और दूसरे में एक अतिरिक्त timespan आर्ग्युमेंट होता है. इससे, घंटों में तय की गई समयावधि के हिसाब से नतीजों को फ़िल्टर करने में मदद मिलती है.

मौजूदा insertScores() तरीके के नीचे और मौजूदा printUsageAndExit() तरीके के ऊपर, यहां दिए गए दो query तरीके जोड़ें:

  static void query(DatabaseClient dbClient) {
    String scoreDate;
    String score;
    ResultSet resultSet =
        dbClient
            .singleUse()
            .executeQuery(
                Statement.of(
                    "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"));
    while (resultSet.next()) {
      scoreDate = String.valueOf(resultSet.getTimestamp("Timestamp"));
      score = String.format("%,d", resultSet.getLong("Score"));
      System.out.printf(
          "PlayerId: %d  PlayerName: %s  Score: %s  Timestamp: %s\n",
          resultSet.getLong("PlayerId"), resultSet.getString("PlayerName"), score,
          scoreDate.substring(0,10));
    }
  }

  static void query(DatabaseClient dbClient, int timespan) {
    String scoreDate;
    String score;
    Statement statement =
        Statement
            .newBuilder(
              "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")
            .bind("Timespan")
            .to(timespan)
            .build();
    ResultSet resultSet =
        dbClient
            .singleUse()
            .executeQuery(statement);
    while (resultSet.next()) {
      scoreDate = String.valueOf(resultSet.getTimestamp("Timestamp"));
      score = String.format("%,d", resultSet.getLong("Score"));
      System.out.printf(
          "PlayerId: %d  PlayerName: %s  Score: %s  Timestamp: %s\n",
          resultSet.getLong("PlayerId"), resultSet.getString("PlayerName"), score,
          scoreDate.substring(0,10));
    }
  }

इसके बाद, query कमांड को काम करने लायक बनाने के लिए, अपने ऐप्लिकेशन के "main" तरीके में switch(command) स्टेटमेंट में यह कोड जोड़ें:

        case "query":
          if (args.length == 4) {
            int timespan = 0;
            try {
              timespan = Integer.parseInt(args[3]);
            } catch (NumberFormatException e) {
              System.err.println("query command's 'timespan' parameter must be a valid integer.");
              System.exit(1);
            }
            query(dbClient, timespan);
          } else {
            query(dbClient);
          }
          break;

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

    System.out.println("  java -jar leaderboard.jar query my-instance example-db");
    System.out.println("      - Query players with top ten scores of all time.\n");
    System.out.println("  java -jar leaderboard.jar query my-instance example-db 168");
    System.out.println("      - Query players with top ten scores within a timespan "
        + "specified in hours.\n");

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

dotnet-docs-samples/applications/leaderboard/step6/src डायरेक्ट्री में मौजूद App.java फ़ाइल का इस्तेमाल करके, यह देखा जा सकता है कि query कमांड चालू करने के लिए कोड जोड़ने के बाद, आपकी App.java फ़ाइल कैसी दिखेगी.

अपना ऐप्लिकेशन बनाने के लिए, उस डायरेक्ट्री से mvn package चलाएं जहां आपकी pom.xml फ़ाइल मौजूद है:

mvn package

अब ऐप्लिकेशन को चलाकर यह पुष्टि करें कि नई query कमांड, ऐप्लिकेशन की संभावित कमांड की सूची में शामिल है. यह कमांड चलाएं:

java -jar target/leaderboard.jar

अब आपको ऐप्लिकेशन के डिफ़ॉल्ट आउटपुट में, query कमांड एक नए कमांड विकल्प के तौर पर दिखेगी:

Leaderboard 1.0.0
Usage:
  java -jar leaderboard.jar <command> <instance_id> <database_id> [command_option]

Examples:
  java -jar leaderboard.jar create my-instance example-db
      - Create a sample Cloud Spanner database along with sample tables in your project.

  java -jar leaderboard.jar insert my-instance example-db players
      - Insert 100 sample Player records into the database.

  java -jar leaderboard.jar insert my-instance example-db scores
      - Insert sample score data into Scores sample Cloud Spanner database table.

  java -jar leaderboard.jar query my-instance example-db
      - Query players with top ten scores of all time.

  java -jar leaderboard.jar query my-instance example-db 168
      - Query players with top ten scores within a timespan specified in hours.

जवाब से पता चलता है कि इंस्टेंस आईडी और डेटाबेस आईडी आर्ग्युमेंट के अलावा, query कमांड हमें घंटों की संख्या में एक वैकल्पिक समयावधि तय करने की अनुमति देती है. इसका इस्तेमाल, Scores टेबल के Timestamp कॉलम में मौजूद वैल्यू के आधार पर रिकॉर्ड को फ़िल्टर करने के लिए किया जाता है. टाइम्सपैन आर्ग्युमेंट वैकल्पिक होता है. इसका मतलब है कि अगर टाइम्सपैन आर्ग्युमेंट शामिल नहीं किया जाता है, तो टाइमस्टैंप के हिसाब से कोई भी रिकॉर्ड फ़िल्टर नहीं किया जाएगा. इसलिए, हम query कमांड का इस्तेमाल "टाइम्सपैन" वैल्यू के बिना कर सकते हैं, ताकि हमें अब तक के "टॉप टेन" खिलाड़ियों की सूची मिल सके.

आइए, "timespan" तय किए बिना query कमांड चलाएं. इसके लिए, हम वही तर्क वैल्यू इस्तेमाल करेंगे जो हमने create कमांड चलाते समय इस्तेमाल की थीं.

java -jar target/leaderboard.jar query cloudspanner-leaderboard 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

अब ज़रूरी आर्ग्युमेंट के साथ query कमांड चलाएं. इससे साल के "टॉप टेन" खिलाड़ियों के बारे में क्वेरी की जा सकेगी. इसके लिए, "टाइम्सपैन" को एक साल में घंटों की संख्या के बराबर सेट करें. यह संख्या 8,760 है.

java -jar target/leaderboard.jar query cloudspanner-leaderboard 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

अब महीने के "टॉप टेन" खिलाड़ियों के बारे में क्वेरी करने के लिए, query कमांड चलाएं. इसके लिए, "timespan" को एक महीने में मौजूद घंटों की संख्या के बराबर सेट करें. यह संख्या 730 है.

java -jar target/leaderboard.jar query cloudspanner-leaderboard 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

अब "टॉप टेन" खिलाड़ियों के बारे में क्वेरी करने के लिए, query कमांड चलाएं. इसके लिए, "टाइम्सपैन" को एक हफ़्ते में मौजूद घंटों की संख्या के बराबर सेट करें. यह संख्या 168 है.

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

अगले चरण:

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

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