Cloud Spanner: יצירת לידרבורד של גיימינג באמצעות Java

1. סקירה כללית

‫Google Cloud Spanner הוא שירות מנוהל של מסד נתונים רלציוני, שניתן להרחבה אופקית, מבוזר גלובלית ומספק עסקאות ACID וסמנטיקה של SQL, בלי להתפשר על ביצועים וזמינות גבוהה.

בשיעור ה-Lab הזה תלמדו איך להגדיר מופע של Cloud Spanner. תעברו על השלבים ליצירת מסד נתונים וסכימה שאפשר להשתמש בהם ללידרבורד של משחקים. תתחילו ביצירת טבלת שחקנים לאחסון פרטי השחקנים וטבלת ניקוד לאחסון הניקוד של השחקנים.

בשלב הבא מאכלסים את הטבלאות בנתונים לדוגמה. בסיום שיעור ה-Lab, תריצו כמה שאילתות לדוגמה של עשרת המובילים ולבסוף תמחקו את המופע כדי לפנות משאבים.

מה תלמדו

איך מגדירים מופע של 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) ויוצרים פרויקט חדש.

אם כבר יש לכם פרויקט, לוחצים על התפריט הנפתח לבחירת פרויקט בפינה הימנית העליונה של המסוף:

ולוחצים על הלחצן 'פרויקט חדש' בתיבת הדו-שיח שמופיעה כדי ליצור פרויקט חדש:

אם עדיין אין לכם פרויקט, תופיע תיבת דו-שיח כמו זו שבהמשך כדי ליצור את הפרויקט הראשון:

בתיבת הדו-שיח הבאה ליצירת פרויקט, אפשר להזין את הפרטים של הפרויקט החדש:

חשוב לזכור את מזהה הפרויקט, שהוא שם ייחודי בכל הפרויקטים ב-Google Cloud (השם שלמעלה כבר תפוס ולא יתאים לכם, מצטערים!). בהמשך ה-codelab הזה נתייחס אליו כאל PROJECT_ID.

לאחר מכן, אם עדיין לא עשיתם זאת, תצטרכו להפעיל את החיוב במסוף למפתחים כדי להשתמש במשאבים של Google Cloud ולהפעיל את Cloud Spanner API.

העלות של ה-Codelab הזה לא אמורה להיות גבוהה מכמה דולרים, אבל היא יכולה להיות גבוהה יותר אם תחליטו להשתמש ביותר משאבים או אם תשאירו אותם פועלים (ראו את הקטע 'ניקוי נתונים' בסוף המסמך הזה). מידע על התמחור של Google Cloud Spanner מופיע כאן.

משתמשים חדשים ב-Google Cloud Platform זכאים לתקופת ניסיון בחינם בשווי 300$, כך שסדנת ה-codelab הזו אמורה להיות בחינם לגמרי.

הגדרה של Google Cloud Shell

אפשר להפעיל את Google Cloud ואת Spanner מרחוק מהמחשב הנייד, אבל ב-codelab הזה נשתמש ב-Google Cloud Shell, סביבת שורת פקודה שפועלת בענן.

המכונה הווירטואלית הזו מבוססת על Debian, וטעונים בה כל הכלים הדרושים למפתחים. יש בה ספריית בית בנפח מתמיד של 5GB והיא פועלת ב-Google Cloud, מה שמשפר מאוד את הביצועים והאימות ברשת. כלומר, כל מה שצריך כדי לבצע את ההוראות במאמר הזה הוא דפדפן (כן, זה עובד ב-Chromebook).

כדי להפעיל את Cloud Shell ממסוף Cloud, פשוט לוחצים על הפעלת Cloud Shell (הקצאת המשאבים והחיבור לסביבה אמורים להימשך רק כמה רגעים).

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>

לבסוף, מגדירים את אזור ברירת המחדל ואת הגדרת הפרויקט.

gcloud config set compute/zone us-central1-f

אפשר לבחור מתוך מגוון אזורים שונים. מידע נוסף זמין במאמר בנושא אזורים ותחומים.

סיכום

בשלב הזה מגדירים את הסביבה.

הבא בתור

בשלב הבא, תגדירו מופע של Cloud Spanner.

3. הגדרת מופע של Cloud Spanner

בשלב הזה נגדיר את מופע Cloud Spanner שלנו בשביל ה-codelab הזה. מחפשים את הערך Spanner בתפריט ההמבורגר בפינה הימנית העליונה או מחפשים את Spanner על ידי הקשה על '/' והקלדת 'Spanner'.

לאחר מכן, לוחצים על וממלאים את הטופס. מזינים את שם המכונה cloudspanner-leaderboard, בוחרים הגדרה (מכונה אזורית) ומגדירים את מספר הצמתים. בשביל ה-codelab הזה נצטרך רק צומת אחד. כדי שמכונות ייצור יעמדו בדרישות של הסכם רמת השירות (SLA) של Cloud Spanner, צריך להריץ 3 צמתים או יותר במופע Cloud Spanner.

לבסוף, לוחצים על Create (יצירה) ותוך שניות מופעלת לכם אינטס של Cloud Spanner.

בשלב הבא נשתמש בספריית הלקוח של Java כדי ליצור מסד נתונים וסכימה במופע החדש שלנו.

4. יצירה של מסד נתונים וסכימה

בשלב הזה ניצור את מסד הנתונים ואת הסכימה לדוגמה.

נשתמש בספריית הלקוח של Java כדי ליצור שתי טבלאות: טבלת Players לפרטי השחקנים וטבלת Scores לאחסון ציוני השחקנים. כדי לעשות את זה, נסביר איך ליצור אפליקציית קונסולה של Java ב-Cloud Shell.

קודם משכפלים את הקוד לדוגמה של ה-codelab הזה מ-GitHub על ידי הקלדת הפקודה הבאה ב-Cloud Shell:

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

לאחר מכן משנים את הספרייה לספרייה 'applications' שבה תיצור את האפליקציה.

cd java-docs-samples/spanner/leaderboard

כל הקוד שנדרש ל-codelab הזה נמצא בספרייה הקיימת java-docs-samples/spanner/leaderboard/complete כאפליקציית C# שאפשר להפעיל בשם Leaderboard, כדי שתשמש כהפניה במהלך ה-codelab. ניצור ספרייה חדשה ונבנה עותק של אפליקציית טבלת המובילים בשלבים.

יוצרים ספרייה חדשה בשם codelab לאפליקציה ועוברים אליה באמצעות הפקודה הבאה:

mkdir codelab && cd $_

יוצרים אפליקציית Java בסיסית חדשה בשם Leaderboard באמצעות פקודת Maven‏ (mvn) הבאה:

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 ליצירת לידרבורד שמורכב משתי טבלאות: Players ו-Scores. אפשר לעשות את זה ישירות ב-Cloud Shell Editor:

פותחים את Cloud Shell Editor בלחיצה על הסמל שמודגש למטה:

פותחים את הקובץ pom.xml בתיקייה leaderboard. פותחים את הקובץ pom.xml שנמצא בתיקייה java-docs-samples\ spanner\leaderboard\codelab\leaderboard.הקובץ הזה מגדיר את מערכת ה-build של Maven כך שתבנה את האפליקציה שלנו כקובץ jar, כולל כל התלויות.

מוסיפים את הקטע החדש הבא לניהול יחסי תלות, מיד אחרי הרכיב הקיים </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>

לאחר מכן, מחליפים את הקטע <build> הקיים בקובץ pom.xml בקטע <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 במקלדת.

לאחר מכן, פותחים את הקובץ App.java ב-Cloud Shell Editor שנמצא בתיקייה src/main/java/com/google/codelabs/. כדי להחליף את הקוד הקיים בקובץ בקוד שנדרש ליצירת מסד הנתונים leaderboard והטבלאות Players ו-Scores, מדביקים את קוד ה-Java הבא בקובץ App.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");
  }
}

שומרים את השינויים שביצעתם בקובץ App.java על ידי בחירה באפשרות 'שמירה' בתפריט 'קובץ' של Cloud Shell Editor.

אפשר להשתמש בקובץ App.java בספרייה java-docs-samples/spanner/leaderboard/step4/src כדי לראות דוגמה לאופן שבו קובץ App.java צריך להיראות אחרי שמוסיפים את הקוד להפעלת הפקודה create.

כדי ליצור את האפליקציה, מריצים את הפקודה mvn package מהספרייה שבה נמצא הקובץ pom.xml:

mvn package

אחרי שקובץ ה-jar של Java נוצר בהצלחה, מריצים את האפליקציה שנוצרה ב-Cloud Shell באמצעות הפקודה הבאה:

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 Spanner במסוף Cloud, אמורים להופיע בתפריט הימני מסד הנתונים והטבלאות החדשים שיצרתם.

בשלב הבא נעדכן את האפליקציה שלנו כדי לטעון נתונים למסד הנתונים החדש.

5. טען נתונים

עכשיו יש לנו מסד נתונים בשם leaderboard שמכיל שתי טבלאות: Players ו-Scores. עכשיו נשתמש בספריית הלקוח של Java כדי לאכלס את הטבלה Players עם שחקנים ואת הטבלה Scores עם ציונים אקראיים לכל שחקן.

אם הוא לא פתוח, פותחים את Cloud Shell Editor בלחיצה על הסמל שמודגש למטה:

בשלב הבא, עורכים את הקובץ App.java ב-Cloud Shell Editor כדי להוסיף פקודה insert שאפשר להשתמש בה כדי להוסיף 100 שחקנים לטבלה Players, או כדי להוסיף 4 תוצאות אקראיות לטבלה Scores לכל שחקן בטבלה Players.

קודם צריך לעדכן את הקטע 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;

לאחר מכן מוסיפים את הפונקציות הבאות: insert,‏ insertPlayers ו-insertScores מתחת לפונקציה הקיימת create() ומעל הפונקציה הקיימת printUsageAndExit():

  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(). מוסיפים את שורות הקוד הבאות ל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");

שומרים את השינויים שביצעתם בקובץ App.java על ידי בחירה באפשרות 'שמירה' בתפריט 'קובץ' של Cloud Shell Editor.

אפשר להשתמש בקובץ App.java בספרייה java-docs-samples/spanner/leaderboard/step5/src כדי לראות דוגמה לאופן שבו קובץ App.java צריך להיראות אחרי שמוסיפים את הקוד להפעלת הפקודה insert.

עכשיו נבנה מחדש את האפליקציה ונריץ אותה כדי לוודא שהפקודה החדשה insert נכללת ברשימת הפקודות האפשריות של האפליקציה.

כדי ליצור את האפליקציה, מריצים את הפקודה mvn package מהספרייה שבה נמצא הקובץ pom.xml:

mvn package

אחרי שקובץ ה-JAR של Java נוצר בהצלחה, מריצים את הפקודה הבאה:

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.

העמודה Timestamp בטבלה Scores הוגדרה כעמודה של חותמת זמן של ביצוע (commit) באמצעות הצהרת ה-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 בשורה נתונה בטבלה.

אפשר גם להוסיף ערכים של חותמות זמן משלכם לעמודה commit timestamp (חותמת זמן של ביצוע), כל עוד מוסיפים חותמת זמן עם ערך שמתייחס לעבר. זה מה שנעשה לצורך ה-codelab הזה.

עכשיו נריץ את הפקודה insert עם אותם ערכי ארגומנטים שבהם השתמשנו כשקראנו לפקודה create, ונוסיף את הארגומנט scores כארגומנט נוסף מסוג insert.

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())

כדי לאכלס אוטומטית את העמודה Timestamp עם חותמת הזמן של הרגע המדויק שבו מתבצעת העסקה 'הוספה', אפשר במקום זאת להוסיף את הקבוע Java Value.COMMIT_TIMESTAMP כמו בקטע הקוד הבא:

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

עכשיו, אחרי שסיימנו לטעון את הנתונים, נבדוק את הערכים שכתבנו זה עתה בטבלאות החדשות. קודם בוחרים את מסד הנתונים leaderboard ואז בוחרים את הטבלה Players. לוחצים על הכרטיסייה Data. אפשר לראות שיש נתונים בעמודות PlayerId ו-PlayerName בטבלה.

עכשיו נבדוק אם יש נתונים גם בטבלה Scores. לשם כך, לוחצים על הטבלה Scores ובוחרים בכרטיסייה Data. אפשר לראות שיש נתונים בעמודות PlayerId, Timestamp ו-Score בטבלה.

כל הכבוד! נניח שאנחנו רוצים לעדכן את האפליקציה שלנו כדי להריץ כמה שאילתות שבעזרתן נוכל ליצור טבלת הישגים במשחק.

6. הרצת שאילתות של טבלת ההייפ

אחרי שהגדרנו את מסד הנתונים וטעןנו מידע לטבלאות, נשתמש בנתונים האלה כדי ליצור טבלת הישגים. כדי לעשות זאת, צריך לענות על ארבע השאלות הבאות:

מי השחקנים שנכללים ב-"עשרת הגדולים" בכל הזמנים?
אילו שחקנים נכללים ב'עשרת המובילים' של השנה?
מי השחקנים שנכללים ב'עשרת המובילים' של החודש?
מי השחקנים שנכללים ב-Top Ten של השבוע?

בואו נעדכן את האפליקציה כדי להריץ את שאילתות ה-SQL שיענו על השאלות האלה.

נוסיף פקודה query שתאפשר להריץ את השאילתות כדי לענות על השאלות שיובילו למידע שנדרש לטבלת המובילים שלנו.

כדי לעדכן את האפליקציה ולהוסיף לה את הפקודה query, עורכים את הקובץ App.java ב-Cloud Shell Editor. הפקודה query מורכבת משתי שיטות query. אחת מהן מקבלת רק ארגומנט DatabaseClient, והשנייה מקבלת ארגומנט נוסף timespan כדי לאפשר סינון של התוצאות לפי טווח זמן שצוין בשעות.

מוסיפים את שתי השיטות הבאות query מתחת לשיטה הקיימת insertScores() ומעל לשיטה הקיימת printUsageAndExit():

  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 תפעל, מוסיפים את הקוד הבא להצהרה switch(command) בשיטה main של האפליקציה:

        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(). מוסיפים את שורות הקוד הבאות לprintUsageAndExit()שיטה כדי לכלול טקסט עזרה לפקודה query:

    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");

שומרים את השינויים שביצעתם בקובץ App.java על ידי בחירה באפשרות 'שמירה' בתפריט 'קובץ' של Cloud Shell Editor.

אפשר להשתמש בקובץ App.java בספרייה dotnet-docs-samples/applications/leaderboard/step6/src כדי לראות דוגמה לאופן שבו קובץ App.java צריך להיראות אחרי שמוסיפים את הקוד להפעלת הפקודה query.

כדי ליצור את האפליקציה, מריצים את הפקודה 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.

מהתשובה אפשר לראות שבנוסף לארגומנטים Instance ID ו-Database ID, הפקודה query מאפשרת לנו לציין טווח זמן אופציונלי במספר שעות לשימוש בסינון רשומות על סמך הערך שלהן בעמודה Timestamp בטבלה Scores. מכיוון שהארגומנט של טווח הזמן הוא אופציונלי, אם לא כוללים אותו, המערכת לא תסנן רשומות לפי חותמות זמן. לכן, אפשר להשתמש בפקודה query בלי לציין ערך של "טווח זמן" כדי לקבל רשימה של עשרת השחקנים המובילים בכל הזמנים.

נריץ את הפקודה query בלי לציין את הארגומנט timespan, ונשתמש באותם ערכי ארגומנט שבהם השתמשנו כשהרצנו את הפקודה 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 עם הארגומנטים הנדרשים כדי לשאול על 10 השחקנים המובילים של השנה. לשם כך נציין את הארגומנט timespan (טווח זמן) ששווה למספר השעות בשנה, כלומר 8760.

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 כדי לשלוח שאילתה לגבי 10 השחקנים המובילים של החודש. לשם כך, נציין את פרק הזמן (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 כדי לשלוף את 10 השחקנים המובילים של השבוע. לשם כך, נציין את פרק הזמן (timespan) ששווה למספר השעות בשבוע, כלומר 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 Spanner ב-Cloud Console ומוחקים את המופע שיצרנו בשלב של ה-codelab שנקרא 'הגדרת מופע Cloud Spanner'.

8. מעולה!

הנושאים שנדון בהם:

מופעים, מסדי נתונים וסכמת טבלאות של Google Cloud Spanner לטבלת ניקוד
איך יוצרים אפליקציית מסוף Java
איך יוצרים מסד נתונים וטבלאות ב-Spanner באמצעות ספריית הלקוח של Java
איך טוענים נתונים למסד נתונים של Spanner באמצעות ספריית הלקוח של Java
איך ליצור שאילתה של התוצאות 'העשר המובילים' מהנתונים באמצעות חותמות זמן של שמירה ב-Spanner וספריית הלקוח של Java

השלבים הבאים:

לקריאת הסקירה הטכנית בנושא Spanner CAP
מידע נוסף על תכנון סכימה ועל שיטות מומלצות לשאילתות
מידע נוסף על חותמות זמן של ביצוע פעולות ב-Cloud Spanner

שליחת משוב

נשמח אם תקדישו כמה רגעים למילוי הסקר הקצר שלנו.