Spanner की मदद से ऑनलाइन बैंकिंग ऐप्लिकेशन बनाना

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

Spanner, पूरी तरह से मैनेज की जाने वाली, हॉरिज़ॉन्टली स्केल की जा सकने वाली, और दुनिया भर में उपलब्ध डेटाबेस सेवा है. यह रिलेशनल और नॉन-रिलेशनल, दोनों तरह के ऑपरेशनल वर्कलोड के लिए बेहतरीन है. Spanner में बुनियादी सुविधाओं के साथ-साथ, बेहतर सुविधाएं भी मिलती हैं. इनकी मदद से, डेटा पर आधारित स्मार्ट ऐप्लिकेशन बनाए जा सकते हैं.

यह कोडलैब, Spanner की बुनियादी जानकारी पर आधारित है. इसमें, डेटा प्रोसेसिंग और विश्लेषण की क्षमताओं को बेहतर बनाने के लिए, इसके ऐडवांस इंटिग्रेशन का इस्तेमाल करने के बारे में बताया गया है. इसके लिए, ऑनलाइन बैंकिंग ऐप्लिकेशन को आधार बनाया गया है.

हम तीन मुख्य ऐडवांस सुविधाओं पर फ़ोकस करेंगे:

• Vertex AI इंटिग्रेशन: जानें कि Spanner को Google Cloud के एआई प्लैटफ़ॉर्म, Vertex AI के साथ आसानी से कैसे इंटिग्रेट किया जा सकता है. आपको यह पता चलेगा कि Spanner एसक्यूएल क्वेरी में सीधे तौर पर Vertex AI मॉडल को कैसे लागू किया जाता है. इससे डेटाबेस में मौजूद डेटा को बेहतर तरीके से बदला जा सकता है और अनुमान लगाए जा सकते हैं. साथ ही, हमारे बैंकिंग ऐप्लिकेशन को बजट ट्रैकिंग और गड़बड़ी का पता लगाने जैसे इस्तेमाल के उदाहरणों के लिए, लेन-देन को अपने-आप कैटगरी में बांटने की सुविधा मिलती है.
• पूरे टेक्स्ट की खोज: Spanner में पूरे टेक्स्ट की खोज करने की सुविधा लागू करने का तरीका जानें. इसमें, टेक्स्ट डेटा को इंडेक्स करने और अपने ऑपरेशनल डेटा में कीवर्ड के आधार पर खोज करने के लिए असरदार क्वेरी लिखने के बारे में बताया जाएगा. इससे आपको डेटा को बेहतर तरीके से खोजने में मदद मिलेगी. जैसे, बैंकिंग सिस्टम में ईमेल पते के हिसाब से ग्राहकों को आसानी से ढूंढना.
• BigQuery फ़ेडरेटेड क्वेरी: जानें कि BigQuery में मौजूद डेटा पर सीधे तौर पर क्वेरी करने के लिए, Spanner की फ़ेडरेटेड क्वेरी की सुविधाओं का इस्तेमाल कैसे किया जाता है. इससे, Spanner के रीयल-टाइम ऑपरेशनल डेटा को BigQuery के विश्लेषण वाले डेटासेट के साथ जोड़ा जा सकता है. इससे, डेटा को डुप्लीकेट किए बिना या जटिल ईटीएल प्रोसेस के बिना, अहम जानकारी और रिपोर्टिंग की जा सकती है. इससे हमारे बैंकिंग ऐप्लिकेशन में कई इस्तेमाल के उदाहरणों को बेहतर बनाया जा सकता है. जैसे, BigQuery से मिले ज़्यादा समय के रुझानों के साथ रीयल-टाइम में मिले ग्राहक डेटा को मिलाकर, टारगेट किए गए मार्केटिंग कैंपेन चलाना.

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

• स्पैनर इंस्टेंस सेट अप करने का तरीका.
• डेटाबेस और टेबल बनाने का तरीका.
• अपने Spanner डेटाबेस की टेबल में डेटा लोड करने का तरीका.
• Spanner से Vertex AI मॉडल को कॉल करने का तरीका.
• फ़ज़ी सर्च और फ़ुल-टेक्स्ट सर्च का इस्तेमाल करके, अपने Spanner डेटाबेस को क्वेरी करने का तरीका.
• BigQuery से Spanner के ख़िलाफ़ फ़ेडरेटेड क्वेरी करने का तरीका.
• Spanner इंस्टेंस मिटाने का तरीका.

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

• Google Cloud प्रोजेक्ट, किसी बिलिंग खाते से कनेक्ट होना चाहिए.
• कोई वेब ब्राउज़र, जैसे कि Chrome या Firefox.

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

प्रोजेक्ट बनाना

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

अगर आपने कोई प्रोजेक्ट चुना है, तो ज़रूरी एपीआई चालू करें पर जाएं.

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

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

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

इसके बाद, प्रोजेक्ट बनाने का डायलॉग बॉक्स खुलेगा. इसमें अपने नए प्रोजेक्ट की जानकारी डालें.

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

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

Spanner की कीमत के बारे में जानकारी यहां दी गई है. अन्य संसाधनों से जुड़ी अन्य लागतों के बारे में जानकारी, उनके खास कीमत वाले पेजों पर दी जाएगी.

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

Google Cloud Shell का सेटअप

इस कोडलैब में, हम Google Cloud Shell का इस्तेमाल करेंगे. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.

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

ध्यान दें: अगर आपको लोकल मशीन पर काम करना है, तो Google Cloud CLI इंस्टॉल करने और Java डेवलपमेंट एनवायरमेंट सेटअप करने के लिए दिए गए निर्देशों का पालन करें. Cloud Shell में Git, Maven, Java, और Google Cloud CLI पहले से इंस्टॉल होते हैं. इनका इस्तेमाल इस कोडलैब में किया जाता है.

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

Cloud Shell से कनेक्ट होने के बाद, आपको दिखेगा कि आपकी पुष्टि पहले ही हो चुकी है और प्रोजेक्ट पहले से ही आपके PROJECT_ID पर सेट है.

gcloud auth list

अनुमानित आउटपुट:

Credentialed Accounts

ACTIVE: *
ACCOUNT: <myaccount>@<mydomain>.com

ध्यान दें: gcloud कमांड-लाइन टूल, Cloud Shell में पहले से इंस्टॉल होता है. ज़्यादा जानकारी के लिए, gcloud कमांड-लाइन टूल की खास जानकारी देखें.

gcloud config list project

अनुमानित आउटपुट:

[core]
project = <PROJECT_ID>

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

gcloud config set project <PROJECT_ID>

क्या आपको PROJECT_ID ढूंढना है? देखें कि आपने सेटअप के दौरान किस आईडी का इस्तेमाल किया था. इसके अलावा, Cloud Console के डैशबोर्ड में भी इसे देखा जा सकता है:

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

echo $GOOGLE_CLOUD_PROJECT

अनुमानित आउटपुट:

<PROJECT_ID>

ध्यान दें: gcloud के लिए कॉन्फ़िगरेशन सेटिंग, आपकी मशीन पर सभी सेशन के लिए बनी रहती हैं. हालांकि, आपको हर नए Cloud Shell सेशन के लिए इन्हें सेट करना होगा.

ज़रूरी एपीआई चालू करें

अपने प्रोजेक्ट के लिए Spanner, Vertex AI, और BigQuery API चालू करें:

gcloud services enable spanner.googleapis.com
gcloud services enable aiplatform.googleapis.com
gcloud services enable bigquery.googleapis.com
gcloud services enable bigqueryconnection.googleapis.com

खास जानकारी

इस चरण में, अगर आपके पास पहले से कोई प्रोजेक्ट नहीं था, तो आपने उसे सेट अप कर लिया है. साथ ही, आपने Cloud Shell को चालू कर लिया है और ज़रूरी एपीआई चालू कर लिए हैं.

अगला

इसके बाद, Spanner इंस्टेंस सेट अप करें.

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

Spanner इंस्टेंस बनाना

इस चरण में, आपको कोडलैब के लिए Spanner इंस्टेंस सेट अप करना होगा. इसके लिए, Cloud Shell खोलें और यह निर्देश चलाएं:

export SPANNER_INSTANCE=cloudspanner-onlinebanking
gcloud spanner instances create $SPANNER_INSTANCE \
  --config=regional-us-central1 \
  --description="Spanner Online Banking" \
  --nodes=1 \
  --edition=ENTERPRISE \
  --default-backup-schedule-type=NONE

ध्यान दें: इंस्टेंस बनाने में कुछ समय लग सकता है.

अनुमानित आउटपुट:

Creating instance...done.

ध्यान दें: यह पक्का करने के लिए कि Spanner, Vertex AI, और BigQuery एक साथ काम करें, ऐसा क्षेत्र चुनें जहां ये तीनों उपलब्ध हों. इस निर्देश में, regional-us-central1 को क्षेत्र के तौर पर इस्तेमाल किया जाता है. ज़्यादा जानकारी के लिए, Spanner के क्षेत्र से जुड़े कॉन्फ़िगरेशन, Vertex AI की जगह की जानकारी, और BigQuery की जगह की जानकारी देखें.

ध्यान दें: अगर आपको लागत कम रखनी है, तो --nodes=1 के बजाय --processing-units=PROCESSING_UNIT_COUNT सेट करें. PROCESSING_UNIT_COUNT 100 के गुणक (100, 200, 300 वगैरह) हो सकते हैं. साथ ही, 1,000 प्रोसेसिंग यूनिट एक नोड के बराबर होती हैं.

ध्यान दें: फ़ुल-टेक्स्ट सर्च और कुछ अन्य सुविधाओं के लिए, ENTERPRISE वर्शन की ज़रूरत होती है.

खास जानकारी

इस चरण में, आपने Spanner इंस्टेंस बनाया है.

अगला

इसके बाद, आपको शुरुआती ऐप्लिकेशन तैयार करना होगा. साथ ही, डेटाबेस और स्कीमा बनाना होगा.

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

शुरुआती आवेदन तैयार करना

इस चरण में, कोड की मदद से डेटाबेस और स्कीमा बनाया जाएगा.

सबसे पहले, Maven का इस्तेमाल करके onlinebanking नाम का Java ऐप्लिकेशन बनाएं:

mvn -B archetype:generate \
  -DarchetypeGroupId=org.apache.maven.archetypes \
  -DgroupId=com.google.codelabs \
  -DartifactId=onlinebanking \
  -DjavaCompilerVersion=1.8 \
  -DjunitVersion=4.13.2 \
  -DarchetypeVersion=1.5

हम डेटाबेस में जो डेटा फ़ाइलें जोड़ेंगे उन्हें चेकआउट करें और कॉपी करें. कोड रिपॉज़िटरी के लिए, यहां देखें:

git clone https://github.com/GoogleCloudPlatform/cloud-spanner-samples.git
cp -r ./cloud-spanner-samples/banking/data ./onlinebanking

ऐप्लिकेशन फ़ोल्डर पर जाएं:

cd onlinebanking

ध्यान दें: Cloud Shell के ज़रिए फ़ाइलें खोलने के लिए, हमारा सुझाव है कि आप कंसोल को नए टैब में खोलें. कंसोल को नए टैब में खोलकर, एडिटर खोलें बटन पर क्लिक करें. गड़बड़ियों से बचने के लिए, ओरिजनल विंडो में कंसोल बंद करें.

Maven pom.xml फ़ाइल खोलें. Google Cloud लाइब्रेरी के वर्शन को मैनेज करने के लिए, Maven BOM का इस्तेमाल करने के लिए, डिपेंडेंसी मैनेजमेंट सेक्शन जोड़ें:

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

एडिटर और फ़ाइल कुछ इस तरह दिखेंगे:

पक्का करें कि dependencies सेक्शन में वे लाइब्रेरी शामिल हों जिनका इस्तेमाल ऐप्लिकेशन करेगा:

<dependencies>
  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-nop</artifactId>
    <version>2.0.9</version>
  </dependency>
  <dependency>
    <groupId>com.opencsv</groupId>
    <artifactId>opencsv</artifactId>
    <version>5.10</version>
  </dependency>
  <dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-spanner</artifactId>
  </dependency>
  <dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-bigquery</artifactId>
  </dependency>
  <dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-bigqueryconnection</artifactId>
  </dependency>
</dependencies>

आखिर में, बिल्ड प्लगिन बदलें, ताकि ऐप्लिकेशन को JAR फ़ाइल में पैकेज किया जा सके:

<build>
  <plugins>
    <plugin>
      <artifactId>maven-resources-plugin</artifactId>
      <version>3.3.1</version>
      <executions>
        <execution>
          <id>copy-resources</id>
          <phase>process-resources</phase>
          <goals>
            <goal>copy-resources</goal>
          </goals>
          <configuration>
            <outputDirectory>${project.build.directory}/${project.artifactId}-resources</outputDirectory>
            <resources>
              <resource>
                <directory>resources</directory>
                <filtering>true</filtering>
              </resource>
            </resources>
          </configuration>
        </execution>
      </executions>
    </plugin>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-dependency-plugin</artifactId>
      <version>3.8.1</version>
      <executions>
        <execution>
          <id>copy-dependencies</id>
          <phase>prepare-package</phase>
          <goals>
            <goal>copy-dependencies</goal>
          </goals>
          <configuration>
            <outputDirectory>${project.build.directory}/${project.artifactId}-resources/lib</outputDirectory>
            <overWriteReleases>false</overWriteReleases>
            <overWriteSnapshots>false</overWriteSnapshots>
            <overWriteIfNewer>true</overWriteIfNewer>
          </configuration>
        </execution>
      </executions>
    </plugin>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-jar-plugin</artifactId>
      <version>3.4.2</version>
      <configuration>
        <finalName>${project.artifactId}</finalName>
        <outputDirectory>${project.build.directory}</outputDirectory>
        <archive>
          <index>false</index>
          <manifest>
            <mainClass>com.google.codelabs.App</mainClass>
            <addClasspath>true</addClasspath>
            <classpathPrefix>${project.artifactId}-resources/lib/</classpathPrefix>
          </manifest>
        </archive>
      </configuration>
    </plugin>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-failsafe-plugin</artifactId>
      <version>3.2.5</version>
      <executions>
        <execution>
          <goals>
            <goal>integration-test</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-surefire-plugin</artifactId>
      <version>3.2.5</version>
      <configuration>
        <useSystemClassLoader>false</useSystemClassLoader>
      </configuration>
    </plugin>
  </plugins>
</build>

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

अब जब डिपेंडेंसी तैयार हो गई हैं, तो आपको ऐप्लिकेशन में कोड जोड़ना होगा. इससे स्कीमा, कुछ इंडेक्स (खोज वाले इंडेक्स भी शामिल हैं), और रिमोट एंडपॉइंट से कनेक्ट किया गया एआई मॉडल बनाया जा सकेगा. इस कोडलैब में, इन आर्टफ़ैक्ट का इस्तेमाल करके इस क्लास में और तरीके जोड़े जाएंगे.

onlinebanking/src/main/java/com/google/codelabs में जाकर App.java खोलें और कॉन्टेंट को इस कोड से बदलें:

package com.google.codelabs;

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryOptions;
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;

public class App {

  // Create the Spanner database and schema
  public static void create(DatabaseAdminClient dbAdminClient, DatabaseId db,
      String location, String model) {
    System.out.println("Creating Spanner database...");
    List<String> statements = Arrays.asList(
      "CREATE TABLE Customers (\n"
          + "  CustomerId INT64 NOT NULL,\n"
          + "  FirstName STRING(256) NOT NULL,\n"
          + "  LastName STRING(256) NOT NULL,\n"
          + "  FullName STRING(512) AS (FirstName || ' ' || LastName) STORED,\n"
          + "  Email STRING(512) NOT NULL,\n"
          + "  EmailTokens TOKENLIST AS\n"
          + "    (TOKENIZE_SUBSTRING(Email, ngram_size_min=>2, ngram_size_max=>3,\n"
          + "      relative_search_types=>[\"all\"])) HIDDEN,\n"
          + "  Address STRING(MAX)\n"
          + ") PRIMARY KEY (CustomerId)",

      "CREATE INDEX CustomersByEmail\n"
          + "ON Customers(Email)",

      "CREATE SEARCH INDEX CustomersFuzzyEmail\n"
          + "ON Customers(EmailTokens)",

      "CREATE TABLE Accounts (\n"
          + "  AccountId INT64 NOT NULL,\n"
          + "  CustomerId INT64 NOT NULL,\n"
          + "  AccountType STRING(256) NOT NULL,\n"
          + "  Balance NUMERIC NOT NULL,\n"
          + "  OpenDate TIMESTAMP NOT NULL\n"
          + ") PRIMARY KEY (AccountId)",

      "CREATE INDEX AccountsByCustomer\n"
          + "ON Accounts (CustomerId)",

      "CREATE TABLE TransactionLedger (\n"
          + "  TransactionId INT64 NOT NULL,\n"
          + "  AccountId INT64 NOT NULL,\n"
          + "  TransactionType STRING(256) NOT NULL,\n"
          + "  Amount NUMERIC NOT NULL,\n"
          + "  Timestamp TIMESTAMP NOT NULL"
          + "  OPTIONS(allow_commit_timestamp=true),\n"
          + "  Category STRING(256),\n"
          + "  Description STRING(MAX),\n"
          + "  CategoryTokens TOKENLIST AS (TOKENIZE_FULLTEXT(Category)) HIDDEN,\n"
          + "  DescriptionTokens TOKENLIST AS (TOKENIZE_FULLTEXT(Description)) HIDDEN\n"
          + ") PRIMARY KEY (AccountId, TransactionId),\n"
          + "INTERLEAVE IN PARENT Accounts ON DELETE CASCADE",

      "CREATE INDEX TransactionLedgerByAccountType\n"
          + "ON TransactionLedger(AccountId, TransactionType)",

      "CREATE INDEX TransactionLedgerByCategory\n"
          + "ON TransactionLedger(AccountId, Category)",

      "CREATE SEARCH INDEX TransactionLedgerTextSearch\n"
          + "ON TransactionLedger(CategoryTokens, DescriptionTokens)",

      "CREATE MODEL TransactionCategoryModel\n"
          + "INPUT (prompt STRING(MAX))\n"
          + "OUTPUT (content STRING(MAX))\n"
          + "REMOTE OPTIONS (\n"
          + "  endpoint = '//aiplatform.googleapis.com/projects/" + db.getInstanceId().getProject()
              + "/locations/" + location + "/publishers/google/models/" + model + "',\n"
          + "  default_batch_size = 1\n"
          + ")");
    OperationFuture<Database, CreateDatabaseMetadata> op = dbAdminClient.createDatabase(
        db.getInstanceId().getInstance(),
        db.getDatabase(),
        statements);
    try {
      Database dbOperation = op.get();
      System.out.println("Created Spanner database [" + dbOperation.getId() + "]");
    } catch (ExecutionException e) {
      throw (SpannerException) e.getCause();
    } catch (InterruptedException e) {
      throw SpannerExceptionFactory.propagateInterrupt(e);
    }
  }

  static void printUsageAndExit() {
    System.out.println("Online Online Banking Application 1.0.0");
    System.out.println("Usage:");
    System.out.println("  java -jar target/onlinebanking.jar <command> [command_option(s)]");
    System.out.println("");
    System.out.println("Examples:");
    System.out.println("  java -jar target/onlinebanking.jar create");
    System.out.println("      - Create a sample Spanner database and schema in your "
        + "project.\n");
    System.exit(1);
  }

  public static void main(String[] args) {
    if (args.length < 1) {
      printUsageAndExit();
    }

    String instanceId = System.getProperty("SPANNER_INSTANCE", System.getenv("SPANNER_INSTANCE"));
    String databaseId = System.getProperty("SPANNER_DATABASE", System.getenv("SPANNER_DATABASE"));
    String location = System.getenv().getOrDefault("SPANNER_LOCATION", "us-central1");
    String model = System.getenv().getOrDefault("SPANNER_MODEL", "gemini-2.0-flash-lite");
    if (instanceId == null || databaseId == null) {
      System.err.println("Missing one or more required environment variables: SPANNER_INSTANCE or "
          + "SPANNER_DATABASE");
      System.exit(1);
    }

    BigQueryOptions bigqueryOptions = BigQueryOptions.newBuilder().build();
    BigQuery bigquery = bigqueryOptions.getService();

    SpannerOptions spannerOptions = SpannerOptions.newBuilder().build();
    try (Spanner spanner = spannerOptions.getService()) {
      String command = args[0];
      DatabaseId db = DatabaseId.of(spannerOptions.getProjectId(), instanceId, databaseId);
      DatabaseClient dbClient = spanner.getDatabaseClient(db);
      DatabaseAdminClient dbAdminClient = spanner.getDatabaseAdminClient();

      switch (command) {
        case "create":
          create(dbAdminClient, db, location, model);
          break;
        default:
          printUsageAndExit();
      }
    }
  }
}

App.java में किए गए बदलावों को सेव करें.

अपने कोड से बनाई जा रही अलग-अलग इकाइयों को देखें और ऐप्लिकेशन JAR बनाएं:

mvn package

अनुमानित आउटपुट:

[INFO] Building jar: /home/your_user/onlinebanking/target/onlinebanking.jar
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS

इस्तेमाल से जुड़ी जानकारी देखने के लिए, ऐप्लिकेशन चलाएं:

java -jar target/onlinebanking.jar

अनुमानित आउटपुट:

Online Banking Application 1.0.0
Usage:
  java -jar target/onlinebanking.jar <command> [command_option(s)]

Examples:
  java -jar target/onlinebanking.jar create
      - Create a sample Spanner database and schema in your project.

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

ऐप्लिकेशन के लिए ज़रूरी एनवायरमेंट वैरिएबल सेट करें:

export SPANNER_INSTANCE=cloudspanner-onlinebanking
export SPANNER_DATABASE=onlinebanking

create कमांड चलाकर डेटाबेस और स्कीमा बनाएं:

java -jar target/onlinebanking.jar create

ध्यान दें: डेटाबेस और स्कीमा बनाने में कुछ समय लग सकता है.

अनुमानित आउटपुट:

Creating Spanner database...
Created Spanner database [<DATABASE_RESOURCE_NAME>]

ध्यान दें: यह कोडलैब, Spanner से कनेक्ट करने और उसे मैनेज करने के लिए, Spanner क्लाइंट लाइब्रेरी का इस्तेमाल करता है. इसके अलावा, अपने Maven प्रोजेक्ट में आधिकारिक JDBC ड्राइवर इंपोर्ट किए जा सकते हैं, ताकि java.sql.* जैसे स्टैंडर्ड Java SQL API का फ़ायदा लिया जा सके.

Spanner में स्कीमा की जांच करना

Spanner कंसोल में, उस इंस्टेंस और डेटाबेस पर जाएं जिसे अभी बनाया गया है.

आपको तीनों टेबल दिखनी चाहिए - Accounts, Customers, और TransactionLedger.

ध्यान दें: इस उदाहरण में, प्राइमरी कुंजियां क्रम से आईडी के तौर पर दिखती हैं. Spanner में, इस तरह से लगातार बढ़ती हुई वैल्यू का इस्तेमाल करने से, परफ़ॉर्मेंस से जुड़ी समस्याएं हो सकती हैं. जैसे, हॉटस्पॉटिंग. इसे एंटी-पैटर्न माना जाता है. असल दुनिया में इस्तेमाल होने वाले ऐप्लिकेशन को, क्लस्टर में बेहतर तरीके से कुंजियां डिस्ट्रिब्यूट करने के लिए, यूयूआईडी, हैशिंग या बिट-रिवर्सल जैसी रणनीतियों का इस्तेमाल करना चाहिए. इससे हॉटस्पॉट को रोकने के साथ-साथ, आपके Spanner डेटाबेस में स्केलेबिलिटी और परफ़ॉर्मेंस को बेहतर बनाया जा सकता है.

इस कार्रवाई से डेटाबेस स्कीमा बनता है. इसमें Accounts, Customers, और TransactionLedger टेबल के साथ-साथ, डेटा को बेहतर तरीके से वापस पाने के लिए सेकंडरी इंडेक्स और Vertex AI मॉडल का रेफ़रंस शामिल होता है.

TransactionLedger टेबल को खातों के साथ इंटरलीव किया जाता है, ताकि बेहतर डेटा लोकैलिटी के ज़रिए खाते से जुड़े लेन-देन के लिए क्वेरी की परफ़ॉर्मेंस को बेहतर बनाया जा सके.

ध्यान दें: Spanner में, इंटरलीविंग की मदद से चाइल्ड टेबल (जैसे कि TransactionLedger) की लाइनों को, स्टोरेज नोड पर मौजूद उनकी पैरंट टेबल की लाइनों (Accounts) के साथ फ़िज़िकली को-लोकेट किया जाता है. डेटा को एक साथ सेव करने से, किसी खास खाते के लेन-देन के बारे में क्वेरी करते समय, डिस्क की खोज और नेटवर्क की लेटेन्सी कम हो जाती है.

इस कोडलैब में इस्तेमाल किए गए डेटा ऐक्सेस पैटर्न को ऑप्टिमाइज़ करने के लिए, सेकंडरी इंडेक्स (CustomersByEmail, CustomersFuzzyEmail, AccountsByCustomer, TransactionLedgerByAccountType, TransactionLedgerByCategory, TransactionLedgerTextSearch) लागू किए गए थे. जैसे, सटीक और मिलते-जुलते ईमेल पते के हिसाब से ग्राहक की जानकारी ढूंढना, ग्राहक के हिसाब से खाते वापस पाना, और लेन-देन के डेटा को असरदार तरीके से क्वेरी करना और खोजना.

TransactionCategoryModel, Vertex AI का इस्तेमाल करता है. इससे एलएलएम को सीधे तौर पर एसक्यूएल कॉल किए जा सकते हैं. इस कोडलैब में, इसका इस्तेमाल डाइनैमिक ट्रांज़ैक्शन कैटगरी के लिए किया जाता है.

खास जानकारी

इस चरण में, आपने Spanner डेटाबेस और स्कीमा बनाया है.

अगला

इसके बाद, आपको सैंपल ऐप्लिकेशन का डेटा लोड करना होगा.

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

अब आपको CSV फ़ाइलों से सैंपल डेटा को डेटाबेस में लोड करने की सुविधा जोड़नी होगी.

ध्यान दें: अगर आपको कोड में किए गए बदलावों का पता लगाने में मदद चाहिए, तो इस ऐप्लिकेशन का फ़ाइनल वर्शन यहां होस्ट किया गया है

App.java खोलें और इंपोर्ट की गई फ़ाइलों को बदलना शुरू करें:

package com.google.codelabs;

import java.io.FileReader;
import java.math.BigDecimal;
import java.time.Duration;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ExecutionException;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.Timestamp;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryOptions;
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.Key;
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.Struct;
import com.google.spanner.admin.database.v1.CreateDatabaseMetadata;
import com.opencsv.CSVReader;

इसके बाद, क्लास में शामिल करने के तरीके जोड़ें App:

  // Insert customers from CSV
  public static void insertCustomers(DatabaseClient dbClient) {
    System.out.println("Inserting customers...");
    dbClient
        .readWriteTransaction()
        .run(transaction -> {
          int count = 0;
          List<Statement> statements = new ArrayList<>();
          try (CSVReader reader = new CSVReader(new FileReader("data/customers.csv"))) {
            reader.skip(1);
            String[] line;
            while ((line = reader.readNext()) != null) {
              Statement statement = Statement.newBuilder(
                  "INSERT INTO Customers (CustomerId, FirstName, LastName, Email, Address) "
                      + "VALUES (@customerId, @firstName, @lastName, @email, @address)")
                  .bind("customerId").to(Long.parseLong(line[0]))
                  .bind("firstName").to(line[1])
                  .bind("lastName").to(line[2])
                  .bind("email").to(line[3])
                  .bind("address").to(line[4])
                  .build();
              statements.add(statement);
              count++;
            }
            transaction.batchUpdate(statements);
            System.out.println("Inserted " + count + " customers");
            return null;
          }
        });
  }

  // Insert accounts from CSV
  public static void insertAccounts(DatabaseClient dbClient) {
    System.out.println("Inserting accounts...");
    dbClient
        .readWriteTransaction()
        .run(transaction -> {
          int count = 0;
          List<Statement> statements = new ArrayList<>();
          try (CSVReader reader = new CSVReader(new FileReader("data/accounts.csv"))) {
            reader.skip(1);
            String[] line;
            while ((line = reader.readNext()) != null) {
              Statement statement = Statement.newBuilder(
                "INSERT INTO Accounts (AccountId, CustomerId, AccountType, Balance, OpenDate) "
                    + "VALUES (@accountId, @customerId, @accountType, @balance, @openDate)")
                .bind("accountId").to(Long.parseLong(line[0]))
                .bind("customerId").to(Long.parseLong(line[1]))
                .bind("accountType").to(line[2])
                .bind("balance").to(new BigDecimal(line[3]))
                .bind("openDate").to(line[4])
                .build();
              statements.add(statement);
              count++;
            }
            transaction.batchUpdate(statements);
            System.out.println("Inserted " + count + " accounts");
            return null;
          }
        });
  }

  // Insert transactions from CSV
  public static void insertTransactions(DatabaseClient dbClient) {
    System.out.println("Inserting transactions...");
    dbClient
        .readWriteTransaction()
        .run(transaction -> {
          int count = 0;
          List<Statement> statements = new ArrayList<>();
          try (CSVReader reader = new CSVReader(new FileReader("data/transactions.csv"))) {
            reader.skip(1);
            String[] line;

            // Specify timestamps that are within last 30 days
            Random random = new Random();
            Instant startTime = Instant.now().minus(15, ChronoUnit.DAYS);
            Instant currentTimestamp = startTime;

            Map<Long, BigDecimal> balanceChanges = new HashMap<>();
            while ((line = reader.readNext()) != null) {
              long accountId = Long.parseLong(line[1]);
              String transactionType = line[2];
              BigDecimal amount = new BigDecimal(line[3]);
              int randomMinutes = random.nextInt(60) + 1;
              currentTimestamp = currentTimestamp.plus(Duration.ofMinutes(randomMinutes));
              Timestamp timestamp = Timestamp.ofTimeSecondsAndNanos(
                  currentTimestamp.getEpochSecond(), currentTimestamp.getNano());
              Statement statement = Statement.newBuilder(
                "INSERT INTO TransactionLedger (TransactionId, AccountId, TransactionType, Amount,"
                    + "Timestamp, Category, Description) "
                    + "VALUES (@transactionId, @accountId, @transactionType, @amount, @timestamp,"
                    + "@category, @description)")
                .bind("transactionId").to(Long.parseLong(line[0]))
                .bind("accountId").to(accountId)
                .bind("transactionType").to(transactionType)
                .bind("amount").to(amount)
                .bind("timestamp").to(timestamp)
                .bind("category").to(line[5])
                .bind("description").to(line[6])
                .build();
              statements.add(statement);

              // Track balance changes per account
              BigDecimal balanceChange = balanceChanges.getOrDefault(accountId,
                  BigDecimal.ZERO);
              if ("Credit".equalsIgnoreCase(transactionType)) {
                balanceChanges.put(accountId, balanceChange.add(amount));
              } else if ("Debit".equalsIgnoreCase(transactionType)) {
                balanceChanges.put(accountId, balanceChange.subtract(amount));
              } else {
                System.err.println("Unsupported transaction type: " + transactionType);
                continue;
              }

              count++;
            }

            // Apply final balance updates
            for (Map.Entry<Long, BigDecimal> entry : balanceChanges.entrySet()) {
              long accountId = entry.getKey();
              BigDecimal balanceChange = entry.getValue();

              Struct row = transaction.readRow(
                  "Accounts",
                  Key.of(accountId),
                  List.of("Balance"));
              if (row != null) {
                BigDecimal currentBalance = row.getBigDecimal("Balance");
                BigDecimal updatedBalance = currentBalance.add(balanceChange);
                Statement statement = Statement.newBuilder(
                  "UPDATE Accounts SET Balance = @balance WHERE AccountId = @accountId")
                  .bind("accountId").to(accountId)
                  .bind("balance").to(updatedBalance)
                  .build();
                statements.add(statement);
              }
            }

            transaction.batchUpdate(statements);
            System.out.println("Inserted " + count + " transactions");
          }
          return null;
        });
  }

switch (command) में डालने के लिए, main तरीके में एक और केस स्टेटमेंट जोड़ें:

        case "insert":
          String insertType = (args.length >= 2) ? args[1] : "";
          if (insertType.equals("customers")) {
            insertCustomers(dbClient);
          } else if (insertType.equals("accounts")) {
            insertAccounts(dbClient);
          } else if (insertType.equals("transactions")) {
            insertTransactions(dbClient);
          } else {
            insertCustomers(dbClient);
            insertAccounts(dbClient);
            insertTransactions(dbClient);
          }
          break;

आखिर में, printUsageAndExit तरीके में इंसर्ट करने का तरीका जोड़ें:

    System.out.println("  java -jar target/onlinebanking.jar insert");
    System.out.println("      - Insert sample Customers, Accounts, and Transactions into the "
        + "database.\n");

App.java में किए गए बदलावों को सेव करें.

ऐप्लिकेशन को फिर से बनाएं:

mvn package

insert कमांड चलाकर, सैंपल डेटा डालें:

java -jar target/onlinebanking.jar insert

अनुमानित आउटपुट:

Inserting customers...
Inserted 100 customers
Inserting accounts...
Inserted 125 accounts
Inserting transactions...
Inserted 200 transactions

ध्यान दें: ग्राहकों, खातों, और लेन-देन का डेटा, CSV फ़ाइलों से लोड किया जाता है. खास तौर पर, लेन-देन की जानकारी डालने में, Spanner readWriteTransaction में मौजूद खातों के बैलेंस को अपडेट करना शामिल है. इससे यह पक्का होता है कि एसक्यूएल ट्रांज़ैक्शन से जुड़े सभी बदलाव (ट्रांज़ैक्शन रिकॉर्ड और बैलेंस अपडेट) एक साथ लागू होते हैं. इसका मतलब है कि या तो सभी बदलाव लागू होंगे या कोई भी बदलाव लागू नहीं होगा.

Spanner Console में, अपने इंस्टेंस और डेटाबेस के लिए Spanner Studio पर वापस जाएं. इसके बाद, TransactionLedger टेबल चुनें. साथ ही, यह पुष्टि करने के लिए कि डेटा लोड हो गया है, साइडबार में मौजूद "डेटा" पर क्लिक करें. टेबल में 200 लाइनें होनी चाहिए.

खास जानकारी

इस चरण में, आपने डेटाबेस में सैंपल डेटा डाला.

अगला

इसके बाद, Vertex AI इंटिग्रेशन का इस्तेमाल करके, सीधे तौर पर Spanner SQL में बैंकिंग लेन-देन को अपने-आप कैटगरी में बांटा जाएगा.

6. Vertex AI की मदद से डेटा को कैटगरी में बांटना

इस चरण में, आपको Vertex AI की मदद से, वित्तीय लेन-देन को अपने-आप कैटगरी में बांटने की सुविधा मिलेगी. यह सुविधा, सीधे तौर पर Spanner SQL में उपलब्ध होगी. Vertex AI की मदद से, पहले से ट्रेन किए गए किसी मॉडल को चुना जा सकता है. इसके अलावा, अपने डेटा के हिसाब से मॉडल को ट्रेन किया जा सकता है और उसे डिप्लॉय किया जा सकता है. Vertex AI Model Garden में उपलब्ध मॉडल देखें.

इस कोडलैब के लिए, हम Gemini के किसी एक मॉडल, Gemini Flash Lite का इस्तेमाल करेंगे. Gemini का यह वर्शन, कम लागत में उपलब्ध है. हालांकि, यह अब भी रोज़ाना के ज़्यादातर कामों को मैनेज कर सकता है.

फ़िलहाल, हमारे पास कई वित्तीय लेन-देन हैं. हमें इन्हें ब्यौरे के आधार पर कैटगरी में बांटना है (groceries, transportation वगैरह). इसके लिए, Spanner में मॉडल को रजिस्टर करें. इसके बाद, ML.PREDICT का इस्तेमाल करके एआई मॉडल को कॉल करें.

हम अपने बैंकिंग ऐप्लिकेशन में लेन-देन को कैटगरी के हिसाब से बांटना चाहते हैं, ताकि हमें ग्राहक के व्यवहार के बारे में ज़्यादा जानकारी मिल सके. इससे हम सेवाओं को बेहतर बना सकते हैं, गड़बड़ियों का पता ज़्यादा असरदार तरीके से लगा सकते हैं या ग्राहक को हर महीने अपने बजट को ट्रैक करने की सुविधा दे सकते हैं.

डेटाबेस और स्कीमा बनाते समय, पहला चरण पहले ही पूरा हो गया था. इससे इस तरह का मॉडल बन गया:

इसके बाद, हम ऐप्लिकेशन में ML.PREDICT को कॉल करने का एक तरीका जोड़ेंगे.

App.java खोलें और categorize तरीका जोड़ें:

  // Use Vertex AI to set the category of transactions
  public static void categorize(DatabaseClient dbClient) {
    System.out.println("Categorizing transactions...");
    try {
      // Create a prompt to instruct the LLM how to categorize the transactions
      String categories = String.join(", ", Arrays.asList("Entertainment", "Gifts", "Groceries",
          "Investment", "Medical", "Movies", "Online Shopping", "Other", "Purchases", "Refund",
          "Restaurants", "Salary", "Transfer", "Transportation", "Utilities"));
      String prompt = "Categorize the following financial activity into one of these "
          + "categories: " +  categories + ". Return Other if the description cannot be mapped to "
          + "one of these categories.  Only return the exact category string, no other text or "
          + "punctuation or reasoning. Description: ";
      String sql = "UPDATE TransactionLedger SET Category = (\n"
          + "  SELECT content FROM ML.PREDICT(MODEL `TransactionCategoryModel`, (\n"
          + "    SELECT CONCAT('" + prompt + "', CASE WHEN TRIM(Description) = ''\n"
          + "    THEN 'Other' ELSE Description END) AS prompt\n"
          + "  ))\n"
          + ") WHERE TRUE";

      // Use partitioned update to batch update a large number of rows
      dbClient.executePartitionedUpdate(Statement.of(sql));
      System.out.println("Completed categorizing transactions");
    } catch (SpannerException e) {
      throw e;
    }
  }

कैटगरी के लिए, main तरीके में एक और केस स्टेटमेंट जोड़ें:

        case "categorize":
          categorize(dbClient);
          break;

आखिर में, printUsageAndExit तरीके में 'कैटगरी के हिसाब से व्यवस्थित करें' सुविधा को इस्तेमाल करने का तरीका जोड़ें:

    System.out.println("  java -jar target/onlinebanking.jar categorize");
    System.out.println("      - Use AI to categorize transactions in the database.\n");

App.java में किए गए बदलावों को सेव करें.

ऐप्लिकेशन को फिर से बनाएं:

mvn package

categorize कमांड चलाकर, डेटाबेस में मौजूद लेन-देन को कैटगरी के हिसाब से बांटें:

java -jar target/onlinebanking.jar categorize

ध्यान दें: लेन-देन को कैटगरी में बांटने में कुछ समय लग सकता है.

अनुमानित आउटपुट:

Categorizing transactions...
Completed categorizing transactions

ध्यान दें: हर लाइन के लिए ब्यौरा, मॉडल को दिए गए प्रॉम्प्ट में जोड़ा जाता है. इस मामले में, मॉडल को हर लाइन में दी गई जानकारी के आधार पर कैटगरी असाइन करने के लिए कहा गया है. इसके बाद, वापस की गई कैटगरी को डेटाबेस में सेव कर दिया जाता है. ML.PREDICT को आपके ऐप्लिकेशन के वर्कफ़्लो में किसी भी समय, सीधे तौर पर SQL से कॉल किया जा सकता है.

ध्यान दें: कई लाइनों को आसानी से अपडेट करने के लिए, पार्टिशन किए गए डीएमएल तरीके executePartitionedUpdate का इस्तेमाल किया जाता है. यह ज़रूरी है, क्योंकि स्टैंडर्ड Spanner ट्रांज़ैक्शन के लिए साइज़ की सीमाएं होती हैं. इस वजह से, बड़े डेटासेट के लिए अपडेट नहीं हो पाता.

Spanner Studio में, TransactionLedger टेबल के लिए डेटा की झलक देखें स्टेटमेंट चलाएं. अब सभी लाइनों के लिए, Category कॉलम में वैल्यू भर दी गई होंगी.

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

खास जानकारी

इस चरण में, आपने पहले से ट्रेन किए गए मॉडल का इस्तेमाल करके, एआई की मदद से अपने डेटा को अलग-अलग कैटगरी में बांटा.

अगला

इसके बाद, फ़ज़ी और फ़ुल-टेक्स्ट सर्च करने के लिए, टोकनाइज़ेशन का इस्तेमाल किया जाएगा.

7. पूरे टेक्स्ट की खोज का इस्तेमाल करके क्वेरी करना

क्वेरी कोड जोड़ना

Spanner, फ़ुल-टेक्स्ट सर्च क्वेरी की कई सुविधाएं देता है. इस चरण में, आपको एग्ज़ैक्ट मैच वाली खोज करनी होगी. इसके बाद, फ़ज़ी सर्च और फ़ुल-टेक्स्ट सर्च करनी होगी.

App.java खोलें और इंपोर्ट की गई फ़ाइलों को बदलना शुरू करें:

package com.google.codelabs;

import java.io.FileReader;
import java.math.BigDecimal;
import java.time.Duration;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.Timestamp;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryOptions;
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.Key;
import com.google.cloud.spanner.ReadOnlyTransaction;
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.Struct;
import com.google.cloud.spanner.TimestampBound;
import com.google.spanner.admin.database.v1.CreateDatabaseMetadata;
import com.opencsv.CSVReader;

इसके बाद, क्वेरी के तरीके जोड़ें:

  // Get current account balance(s) by customer
  public static void getBalance(DatabaseClient dbClient, long customerId) {
    String query = "SELECT AccountId, Balance\n"
        + "FROM Accounts\n"
        + "WHERE CustomerId = @customerId";
    Statement statement = Statement.newBuilder(query)
        .bind("customerId").to(customerId)
        .build();

    // Ignore ongoing transactions, use stale reads as seconds-old data is sufficient
    TimestampBound stalenessBound = TimestampBound.ofMaxStaleness(5, TimeUnit.SECONDS);
    try (ReadOnlyTransaction transaction = dbClient.singleUseReadOnlyTransaction(stalenessBound);
        ResultSet resultSet = transaction.executeQuery(statement);) {
      System.out.println("Account balances for customer " + customerId + ":");
      while (resultSet.next()) {
        System.out.println("  Account " + resultSet.getLong("AccountId") + ": "
            + resultSet.getBigDecimal("Balance"));
      }
    }
  }

  // Find customers by email
  public static void findCustomers(DatabaseClient dbClient, String email) {
    // Query using fuzzy search (ngrams) to allow for spelling mistakes
    String query = "SELECT CustomerId, Email\n"
        + "FROM Customers\n"
        + "WHERE SEARCH_NGRAMS(EmailTokens, @email)\n"
        + "ORDER BY SCORE_NGRAMS(EmailTokens, @email) DESC\n"
        + "LIMIT 10";
    Statement statement = Statement.newBuilder(query)
        .bind("email").to(email)
        .build();

    try (ReadOnlyTransaction transaction = dbClient.singleUseReadOnlyTransaction();
        ResultSet resultSet = transaction.executeQuery(statement)) {
      System.out.println("Customer emails matching " + email + " (top 10 matches):");
      while (resultSet.next()) {
        System.out.println("  Customer " + resultSet.getLong("CustomerId") + ": "
            + resultSet.getString("Email"));
      }
    }
  }

  // Get total monthly spending for a customer by category
  public static void getSpending(DatabaseClient dbClient, long customerId, String category) {
    // Query category using full-text search
    String query = "SELECT SUM(Amount) as TotalSpending\n"
        + "FROM TransactionLedger t\n"
        + "JOIN Accounts a\n"
        + "  ON t.AccountId = a.AccountId\n"
        + "WHERE t.TransactionType = 'Debit'\n"
        + "  AND a.CustomerId = @customerId\n"
        + "  AND t.Timestamp >= TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL -30 DAY)\n"
        + "  AND (SEARCH(t.CategoryTokens, @category) OR SEARCH(t.DescriptionTokens, @category))";
    Statement statement = Statement.newBuilder(query)
        .bind("customerId").to(customerId)
        .bind("category").to(category)
        .build();

    try (ReadOnlyTransaction transaction = dbClient.singleUseReadOnlyTransaction();
        ResultSet resultSet = transaction.executeQuery(statement);) {
      System.out.println("Total spending for customer " + customerId + " under category "
          + category + ":");
      while (resultSet.next()) {
        BigDecimal totalSpending = BigDecimal.ZERO;
        if (!resultSet.isNull("TotalSpending")) {
          totalSpending = resultSet.getBigDecimal("TotalSpending");
        }
        System.out.println("  " + totalSpending);
      }
    }
  }

क्वेरी के लिए, main तरीके में एक और case स्टेटमेंट जोड़ें:

        case "query":
          String queryType = (args.length >= 2) ? args[1] : "";
          if (queryType.equals("balance")) {
            long customerId = (args.length >= 3) ? Long.parseLong(args[2]) : 1L;
            getBalance(dbClient, customerId);
          } else if (queryType.equals("email")) {
            String email = (args.length >= 3) ? args[2] : "";
            findCustomers(dbClient, email);
          } else if (queryType.equals("spending")) {
            long customerId = (args.length >= 3) ? Long.parseLong(args[2]) : 1L;
            String category = (args.length >= 4) ? args[3] : "";
            getSpending(dbClient, customerId, category);
          } else {
            printUsageAndExit();
          }
          break;

आखिर में, क्वेरी के लिए इस्तेमाल होने वाले निर्देशों को printUsageAndExit तरीके से जोड़ें:

    System.out.println("  java -jar target/onlinebanking.jar query balance 1");
    System.out.println("      - Query customer account balance(s) by customer id.\n");
    System.out.println("  java -jar target/onlinebanking.jar query email madi");
    System.out.println("      - Find customers by email using fuzzy search.\n");
    System.out.println("  java -jar target/onlinebanking.jar query spending 1 groceries");
    System.out.println("      - Query customer spending by customer id and category using "
        + "full-text search.\n");

App.java में किए गए बदलावों को सेव करें.

ऐप्लिकेशन को फिर से बनाएं:

mvn package

ग्राहक खाते के बैलेंस के लिए, एग्ज़ैक्ट मैच खोजें

एग्ज़ैक्ट मैच क्वेरी, मैच करने वाली उन लाइनों को ढूंढती है जो किसी शब्द से पूरी तरह मेल खाती हैं.

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

  "CREATE INDEX AccountsByCustomer\n"
          + "ON Accounts (CustomerId)",

getBalance तरीका, इस इंडेक्स का इस्तेमाल करके, दिए गए customerId से मैच करने वाले ग्राहकों को ढूंढता है. साथ ही, उस ग्राहक के खातों से भी जुड़ता है.

Spanner Studio में सीधे तौर पर क्वेरी चलाने पर, वह इस तरह दिखती है:

ध्यान दें: Spanner का क्वेरी ऑप्टिमाइज़र, आपकी एसक्यूएल क्वेरी के लिए सबसे बेहतर एक्ज़ीक्यूशन प्लान अपने-आप चुनता है. यह अक्सर प्राइमरी की और उपलब्ध सेकंडरी इंडेक्स में से किसी एक को चुनता है. ध्यान दें कि चुने गए इंडेक्स पर, Spanner के सेव किए गए क्वेरी के आंकड़ों का असर पड़ता है. इन आंकड़ों को ANALYZE कमांड से अपडेट किया जा सकता है. हालांकि, आखिरी विकल्प के तौर पर, Spanner को किसी खास सेकंडरी इंडेक्स का इस्तेमाल करने के लिए कहा जा सकता है. ऐसा FORCE_INDEX हिंट का इस्तेमाल करके किया जाता है.

यह देखने के लिए कि कौनसे इंडेक्स का इस्तेमाल किया जा रहा है, Google Cloud Console में Spanner Studio में क्वेरी के एक्ज़ीक्यूशन प्लान की जांच की जा सकती है. इसके लिए, क्वेरी के नतीजों के बगल में मौजूद "Explanation" को चुनें.

ग्राहक 1के खाते के बैलेंस की सूची देखने के लिए, यह कमांड चलाएं:

java -jar target/onlinebanking.jar query balance 1

अनुमानित आउटपुट:

Account balances for customer 1:
  Account 1: 9875.25
  Account 7: 9900
  Account 110: 38200

ध्यान दें: इस क्वेरी में, सिर्फ़ पढ़ने के लिए किए गए लेन-देन में, पुराने डेटा को पढ़ने की सुविधा का इस्तेमाल दिखाया गया है.

स्टेल रीड, पिछले टाइमस्टैंप से डेटा वापस पाते हैं. वहीं, स्ट्रॉन्ग रीड, कमिट किया गया सबसे नया डेटा वापस पाते हैं. जिन ऐप्लिकेशन में डेटा को अपडेट होने में कम समय लगता है और जिनमें कुछ समय पहले का डेटा इस्तेमाल किया जा सकता है (इस मामले में, पांच सेकंड तक पुराना डेटा इस्तेमाल किया जा सकता है, TimestampBound देखें), उनमें स्टेल रीड का इस्तेमाल करने से परफ़ॉर्मेंस में काफ़ी सुधार हो सकता है. जहां भी हो सके वहां स्ट्रॉन्ग रीड का इस्तेमाल करना चाहिए. हालांकि, जब लेटेन्सी एक समस्या बन जाए और सबसे नया डेटा ज़रूरी न हो, तो परफ़ॉर्मेंस को ऑप्टिमाइज़ करने के लिए, स्टेल रीड (बाउंडेड-स्टेलनेस या ऐक्ज़ैक्ट-स्टेलनेस) का इस्तेमाल करें.

रीड-ओनली लेन-देन में लॉक नहीं होते हैं. इसलिए, रीड-राइट लेन-देन की तुलना में, इनमें कम समय लगता है. डेटा में बदलाव करने की ज़रूरत होने पर ही, पढ़ने और लिखने वाले लेन-देन का इस्तेमाल करना सबसे सही तरीका है.

ध्यान दें: बड़े डेटासेट के लिए क्वेरी करने के लिए, Spanner के PartitionQuery एपीआई के साथ पैरलल रीड का इस्तेमाल करें. यह एपीआई, क्वेरी को छोटे-छोटे हिस्सों में बांट देता है. इन हिस्सों को एक साथ प्रोसेस किया जा सकता है. इससे डेटा को तेज़ी से वापस पाने में मदद मिलती है. इसके अलावा, विश्लेषण से जुड़ी क्वेरी के लिए, Spanner की Data Boost सुविधा का इस्तेमाल किया जा सकता है. इससे इंडिपेंडेंट कंप्यूट रिसोर्स का इस्तेमाल करके क्वेरी को एक्ज़ीक्यूट किया जा सकता है. इससे ऑपरेशनल वर्कलोड पर कम असर पड़ता है. यह कोडलैब, बाद के चरण में फ़ेडरेटेड क्वेरी के लिए डेटा बूस्ट का इस्तेमाल करता है.

यहां 100 ग्राहक हैं. इसलिए, किसी दूसरे ग्राहक आईडी का इस्तेमाल करके, किसी भी अन्य ग्राहक खाते के बैलेंस के बारे में क्वेरी की जा सकती है:

java -jar target/onlinebanking.jar query balance 5
java -jar target/onlinebanking.jar query balance 10
java -jar target/onlinebanking.jar query balance 99

ग्राहक के ईमेल पतों के आधार पर, फ़ज़ी सर्च करना

फ़ज़ी सर्च की मदद से, खोज के लिए इस्तेमाल किए गए शब्दों से मिलते-जुलते नतीजे पाए जा सकते हैं. इनमें स्पेलिंग में अंतर और टाइपिंग की गलतियां शामिल हैं.

डेटाबेस और स्कीमा बनाते समय, n-ग्राम इंडेक्स पहले ही जोड़ दिया गया था:

CREATE TABLE Customers (
  ...
  EmailTokens TOKENLIST AS (TOKENIZE_SUBSTRING(Email,
    ngram_size_min=>2,
    ngram_size_max=>3,
    relative_search_types=>["all"])) HIDDEN,
) PRIMARY KEY(CustomerId);

CREATE SEARCH INDEX CustomersFuzzyEmail ON Customers(EmailTokens);

findCustomers तरीके में, इस इंडेक्स के ख़िलाफ़ क्वेरी करने के लिए SEARCH_NGRAMS और SCORE_NGRAMS का इस्तेमाल किया जाता है, ताकि ईमेल पते के हिसाब से खरीदारों को ढूंढा जा सके. ईमेल कॉलम को n-ग्राम के हिसाब से टोकन में बदला गया है. इसलिए, इस क्वेरी में स्पेलिंग की गलतियां होने पर भी सही जवाब मिल सकता है. नतीजों को सबसे ज़्यादा मिलते-जुलते नतीजों के हिसाब से क्रम में लगाया जाता है.

madi वाले, मिलते-जुलते ग्राहक ईमेल पते ढूंढने के लिए, यह कमांड चलाएं:

java -jar target/onlinebanking.jar query email madi

अनुमानित आउटपुट:

Customer emails matching madi (top 10 matches):
  Customer 39: [e-mail]
  Customer 64: [e-mail]
  Customer 91: [e-mail]

इस जवाब में, सबसे मिलते-जुलते नतीजे दिखाए गए हैं. इनमें रैंक के क्रम में madi या इससे मिलती-जुलती स्ट्रिंग शामिल है.

Spanner Studio में सीधे तौर पर क्वेरी चलाने पर, वह इस तरह दिखती है:

फ़ज़ी सर्च की मदद से, वर्तनी की गलतियों को भी ठीक किया जा सकता है. जैसे, emily की गलत वर्तनी:

java -jar target/onlinebanking.jar query email emily
java -jar target/onlinebanking.jar query email emliy
java -jar target/onlinebanking.jar query email emilee

अनुमानित आउटपुट:

Customer emails matching emliy (top 10 matches):
  Customer 31: [e-mail]

हर मामले में, ग्राहक का ईमेल पता सबसे ऊपर दिखता है.

ध्यान दें: स्पैनर, n-ग्राम पर आधारित फ़ज़ी सर्च के साथ-साथ, Soundex का भी इस्तेमाल करता है. इससे एक जैसे शब्दों को खोजा जा सकता है. साथ ही, बेहतर क्वेरी मोड का इस्तेमाल किया जा सकता है. यह मोड, खोज के नतीजों को बेहतर बनाने के लिए इंटरनल एल्गोरिदम का इस्तेमाल करता है.

फ़ुल-टेक्स्ट सर्च की मदद से लेन-देन खोजना

Spanner की फ़ुल-टेक्स्ट सर्च सुविधा का इस्तेमाल, कीवर्ड या वाक्यांशों के आधार पर रिकॉर्ड वापस पाने के लिए किया जाता है. इसमें स्पेलिंग की गलतियों को ठीक करने या एक जैसे मतलब वाले शब्दों को खोजने की सुविधा होती है.

डेटाबेस और स्कीमा बनाते समय, फ़ुल-टेक्स्ट सर्च इंडेक्स पहले ही जोड़ दिया गया था:

CREATE TABLE TransactionLedger (
  ...
  CategoryTokens TOKENLIST AS (TOKENIZE_FULLTEXT(Category)) HIDDEN,
  DescriptionTokens TOKENLIST AS (TOKENIZE_FULLTEXT(Description)) HIDDEN,
) PRIMARY KEY(AccountId, TransactionId),
  INTERLEAVE IN PARENT Accounts ON DELETE CASCADE;

CREATE SEARCH INDEX TransactionLedgerTextSearch ON TransactionLedger(CategoryTokens, DescriptionTokens);

getSpending तरीका, उस इंडेक्स से मैच करने के लिए SEARCH फ़ुल-टेक्स्ट सर्च फ़ंक्शन का इस्तेमाल करता है. यह फ़ंक्शन, दिए गए ग्राहक आईडी के लिए पिछले 30 दिनों में हुए सभी खर्च (डेबिट) की जानकारी देता है.

groceries कैटगरी में, ग्राहक 1 के लिए पिछले महीने के कुल खर्च की जानकारी पाने के लिए, यह कमांड चलाएं:

java -jar target/onlinebanking.jar query spending 1 groceries

अनुमानित आउटपुट:

Total spending for customer 1 under category groceries:
  50

आपको अन्य कैटगरी (जिन्हें हमने पिछले चरण में कैटगरी में बांटा था) पर किए गए खर्च की जानकारी भी मिल सकती है. इसके अलावा, किसी दूसरे ग्राहक आईडी का इस्तेमाल भी किया जा सकता है:

java -jar target/onlinebanking.jar query spending 1 transportation
java -jar target/onlinebanking.jar query spending 1 restaurants
java -jar target/onlinebanking.jar query spending 12 entertainment

खास जानकारी

इस चरण में, आपने सटीक मिलान वाली क्वेरी के साथ-साथ फ़ज़ी और फ़ुल-टेक्स्ट खोजें कीं.

अगला

इसके बाद, फ़ेडरेटेड क्वेरी करने के लिए, Spanner को Google BigQuery के साथ इंटिग्रेट किया जाएगा. इससे, Spanner के रीयल-टाइम डेटा को BigQuery के डेटा के साथ जोड़ा जा सकेगा.

8. BigQuery की मदद से फ़ेडरेटेड क्वेरी चलाना

BigQuery डेटासेट बनाना

इस चरण में, फ़ेडरेटेड क्वेरी का इस्तेमाल करके, BigQuery और Spanner के डेटा को एक साथ लाया जाएगा.

ध्यान दें: BigQuery में Spanner डेटा को क्वेरी करने के बारे में ज़्यादा जानकारी के लिए, Spanner फ़ेडरेटेड क्वेरी देखें.

इसके लिए, Cloud Shell कमांड लाइन में जाकर, सबसे पहले MarketingCampaigns डेटासेट बनाएं:

bq mk --location=us-central1 MarketingCampaigns

ध्यान दें: BigQuery डेटासेट और Spanner कनेक्शन की लोकेशन वही होनी चाहिए जहां आपका Spanner इंस्टेंस मौजूद है.

अनुमानित आउटपुट:

Dataset '<PROJECT_ID>:MarketingCampaigns' successfully created.

ध्यान दें: bq कमांड-लाइन टूल, Cloud Shell में पहले से इंस्टॉल होता है. अगर आपको स्थानीय तौर पर काम करना है, तो आपको bq gcloud कॉम्पोनेंट इंस्टॉल करना होगा.

साथ ही, डेटासेट में एक CustomerSegments टेबल:

bq mk --table MarketingCampaigns.CustomerSegments CampaignId:STRING,CampaignName:STRING,CustomerId:INT64

अनुमानित आउटपुट:

Table '<PROJECT_ID>:MarketingCampaigns.CustomerSegments' successfully created.

इसके बाद, BigQuery से Spanner तक कनेक्शन बनाएं:

ध्यान दें: Cloud Shell में GOOGLE_CLOUD_PROJECT अपने-आप सेट हो जाता है. अगर इसे स्थानीय तौर पर चलाया जा रहा है, तो इसे PROJECT_ID के तौर पर सेट करें. उदाहरण के लिए, export GOOGLE_CLOUD_PROJECT=<PROJECT_ID>.

bq mk --connection \
  --connection_type=CLOUD_SPANNER \
  --properties="{\"database\": \"projects/$GOOGLE_CLOUD_PROJECT/instances/cloudspanner-onlinebanking/databases/onlinebanking\", \"useParallelism\": true, \"useDataBoost\": true}" \
  --location=us-central1 \
  spanner-connection

अनुमानित आउटपुट:

Connection <PROJECT_NUMBER>.us-central1.spanner-connection successfully created

ध्यान दें: इस कनेक्शन के लिए, डेटा बूस्ट की सुविधा चालू है. डेटा बूस्ट की मदद से, कंप्यूट संसाधनों के अलग सेट में अपनी विश्लेषण क्वेरी को लागू किया जा सकता है. इससे मौजूदा वर्कलोड पर कोई असर नहीं पड़ता.

आखिर में, BigQuery टेबल में कुछ ऐसे ग्राहक जोड़ें जिन्हें हमारे Spanner डेटा के साथ जोड़ा जा सकता है:

bq query --use_legacy_sql=false '
INSERT INTO MarketingCampaigns.CustomerSegments (CampaignId, CampaignName, CustomerId)
VALUES
  ("campaign1", "Spring Promotion", 1),
  ("campaign1", "Spring Promotion", 3),
  ("campaign1", "Spring Promotion", 5),
  ("campaign1", "Spring Promotion", 7),
  ("campaign1", "Spring Promotion", 9),
  ("campaign1", "Spring Promotion", 11)'

अनुमानित आउटपुट:

Waiting on bqjob_r76a7ce76c5ec948f_0000019644bda052_1 ... (0s) Current status: DONE
Number of affected rows: 6

BigQuery से क्वेरी करके, यह पुष्टि की जा सकती है कि डेटा उपलब्ध है या नहीं:

bq query --use_legacy_sql=false "SELECT * FROM MarketingCampaigns.CustomerSegments"

अनुमानित आउटपुट:

+------------+------------------+------------+
| CampaignId |   CampaignName   | CustomerId |
+------------+------------------+------------+
| campaign1  | Spring Promotion |          1 |
| campaign1  | Spring Promotion |          5 |
| campaign1  | Spring Promotion |          7 |
| campaign1  | Spring Promotion |          9 |
| campaign1  | Spring Promotion |         11 |
| campaign1  | Spring Promotion |          3 |
+------------+------------------+------------+

BigQuery में मौजूद यह डेटा, अलग-अलग बैंक वर्कफ़्लो के ज़रिए जोड़ा गया डेटा दिखाता है. उदाहरण के लिए, यह उन खरीदारों की सूची हो सकती है जिन्होंने हाल ही में खाते खोले हैं या मार्केटिंग प्रमोशन के लिए साइन अप किया है. हमें मार्केटिंग कैंपेन में जिन ग्राहकों को टारगेट करना है उनकी सूची बनाने के लिए, हमें BigQuery में मौजूद इस डेटा और Spanner में मौजूद रीयल-टाइम डेटा, दोनों पर क्वेरी करनी होगी. फ़ेडरेटेड क्वेरी की मदद से, हम एक ही क्वेरी में ऐसा कर सकते हैं.

BigQuery के साथ फ़ेडरेटेड क्वेरी चलाना

इसके बाद, हम ऐप्लिकेशन में एक तरीका जोड़ेंगे, ताकि फ़ेडरेटेड क्वेरी करने के लिए EXTERNAL_QUERY को कॉल किया जा सके. इससे BigQuery और Spanner, दोनों में मौजूद ग्राहक डेटा को एक साथ इस्तेमाल किया जा सकेगा और उसका विश्लेषण किया जा सकेगा. जैसे, यह पता लगाया जा सकेगा कि हाल ही में खर्च करने के आधार पर, कौनसे ग्राहक हमारे मार्केटिंग कैंपेन की ज़रूरी शर्तें पूरी करते हैं.

App.java खोलें और इंपोर्ट की गई फ़ाइलों को बदलना शुरू करें:

package com.google.codelabs;

import java.io.FileReader;
import java.math.BigDecimal;
import java.time.Duration;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.Timestamp;
import com.google.cloud.bigquery.BigQuery;
import com.google.cloud.bigquery.BigQueryException;
import com.google.cloud.bigquery.BigQueryOptions;
import com.google.cloud.bigquery.connection.v1.ConnectionName;
import com.google.cloud.bigquery.JobException;
import com.google.cloud.bigquery.QueryJobConfiguration;
import com.google.cloud.bigquery.TableResult;
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.Key;
import com.google.cloud.spanner.ReadOnlyTransaction;
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.Struct;
import com.google.cloud.spanner.TimestampBound;
import com.google.spanner.admin.database.v1.CreateDatabaseMetadata;
import com.opencsv.CSVReader;

इसके बाद, campaign तरीका जोड़ें:

  // Get customers for quarterly marketing campaign in BigQuery using Spanner data
  public static void campaign(BigQuery bq, DatabaseId db, String location, String campaignId,
      int threshold) {
    // The BigQuery dataset, table, and Spanner connection must already exist for this to succeed
    ConnectionName connection = ConnectionName.of(db.getInstanceId().getProject(), location,
        "spanner-connection");

    // Use a federated query to bring Spanner data into BigQuery
    String bqQuery = "SELECT cs.CampaignName, c.CustomerId, c.FullName, t.TotalSpending\n"
        + "FROM MarketingCampaigns.CustomerSegments cs\n"
        + "JOIN EXTERNAL_QUERY('" + connection.toString() + "',\n"
        + "  \"SELECT t.AccountId, SUM(t.Amount) AS TotalSpending"
        + "   FROM TransactionLedger t"
        + "   WHERE t.Timestamp >= TIMESTAMP_ADD(CURRENT_TIMESTAMP(), INTERVAL -90 DAY)"
        + "   GROUP BY t.AccountId"
        + "   HAVING SUM(t.Amount) > " + threshold + "\"\n"
        + ") t ON cs.CustomerId = t.AccountId\n"
        + "JOIN EXTERNAL_QUERY('" + connection.toString() + "',\n"
        + "  \"SELECT CustomerId, FullName"
        + "   FROM Customers\"\n"
        + ") c ON c.CustomerId = cs.CustomerId\n"
        + "WHERE cs.CampaignId = '" + campaignId + "'";
    try {
      QueryJobConfiguration queryConfig = QueryJobConfiguration.newBuilder(bqQuery).build();
      TableResult results = bq.query(queryConfig);

      System.out.println("Customers for campaign (" + campaignId + "):");
      results.iterateAll().forEach(row -> {
        System.out.println("  " + row.get("FullName").getStringValue()
            + " (" + row.get("CustomerId").getStringValue() + ")");
      });
    } catch (JobException e) {
      throw (BigQueryException) e.getCause();
    } catch (InterruptedException e) {
      throw SpannerExceptionFactory.propagateInterrupt(e);
    }
  }

कैंपेन के लिए, main तरीके में एक और केस स्टेटमेंट जोड़ें:

        case "campaign":
          String campaignId = (args.length >= 2) ? args[1] : "";
          int threshold = (args.length >= 3) ? Integer.parseInt(args[2]) : 5000;
          campaign(bigquery, db, location, campaignId, threshold);
          break;

आखिर में, कैंपेन को printUsageAndExit तरीके से इस्तेमाल करने का तरीका बताएं:

    System.out.println("  java -jar target/onlinebanking.jar campaign campaign1 5000");
    System.out.println("      - Use Federated Queries (BigQuery) to find customers that match a "
        + "marketing campaign by name based on a recent spending threshold.\n");

App.java में किए गए बदलावों को सेव करें.

ऐप्लिकेशन को फिर से बनाएं:

mvn package

यह तय करने के लिए फ़ेडरेटेड क्वेरी चलाएं कि मार्केटिंग कैंपेन (campaign1) में किन ग्राहकों को शामिल किया जाना चाहिए, अगर उन्होंने पिछले तीन महीनों में कम से कम $5000 खर्च किए हैं. इसके लिए, campaign कमांड चलाएं:

java -jar target/onlinebanking.jar campaign campaign1 5000

अनुमानित आउटपुट:

Customers for campaign (campaign1):
  Alice Smith (1)
  Eve Davis (5)
  Kelly Thomas (11)

अब हम इन ग्राहकों को खास ऑफ़र या इनाम दे सकते हैं.

इसके अलावा, हम उन ग्राहकों की संख्या का पता लगा सकते हैं जिन्होंने पिछले तीन महीनों में कम खर्च किया है:

java -jar target/onlinebanking.jar campaign campaign1 2500

अनुमानित आउटपुट:

Customers for campaign (campaign1):
  Alice Smith (1)
  Charlie Williams (3)
  Eve Davis (5)
  Ivy Taylor (9)
  Kelly Thomas (11)

खास जानकारी

इस चरण में, आपने BigQuery से फ़ेडरेटेड क्वेरी को सफलतापूर्वक एक्ज़ीक्यूट किया. इससे Spanner का रीयल-टाइम डेटा मिला.

अगला

इसके बाद, इस कोडलैब के लिए बनाए गए संसाधनों को मिटाएं, ताकि आपसे शुल्क न लिया जाए.

9. सफ़ाई (ज़रूरी नहीं)

यह करना ज़रूरी नहीं है. अगर आपको अपने Spanner इंस्टेंस के साथ एक्सपेरिमेंट जारी रखना है, तो आपको इसे अभी मिटाने की ज़रूरत नहीं है. हालांकि, जिस प्रोजेक्ट का इस्तेमाल किया जा रहा है उससे इंस्टेंस का शुल्क लिया जाता रहेगा. अगर आपको इस इंस्टेंस की अब ज़रूरत नहीं है, तो इन शुल्कों से बचने के लिए इसे अभी मिटा दें. इस कोडलैब में, Spanner इंस्टेंस के साथ-साथ एक BigQuery डेटासेट और कनेक्शन भी बनाया गया था. जब इनकी ज़रूरत न हो, तो इन्हें मिटा देना चाहिए.

Spanner इंस्टेंस मिटाएं:

gcloud spanner instances delete cloudspanner-onlinebanking

पुष्टि करें कि आपको जारी रखना है (Y टाइप करें):

Delete instance [cloudspanner-onlinebanking]. Are you sure?

Do you want to continue (Y/n)?

BigQuery कनेक्शन और डेटासेट मिटाएं:

bq rm --connection --location=us-central1 spanner-connection
bq rm -r MarketingCampaigns

BigQuery डेटासेट मिटाने की पुष्टि करें (Y टाइप करें):

rm: remove dataset '<PROJECT_ID>:MarketingCampaigns'? (y/N)

10. बधाई हो

🚀 आपने एक नया Cloud Spanner इंस्टेंस बनाया है, एक खाली डेटाबेस बनाया है, सैंपल डेटा लोड किया है, ऐडवांस कार्रवाइयां और क्वेरी की हैं, और (ज़रूरी नहीं) Cloud Spanner इंस्टेंस को मिटाया है.

हमने क्या-क्या कवर किया है

• स्पैनर इंस्टेंस सेट अप करने का तरीका.
• डेटाबेस और टेबल बनाने का तरीका.
• अपने Spanner डेटाबेस की टेबल में डेटा लोड करने का तरीका.
• Spanner से Vertex AI मॉडल को कॉल करने का तरीका.
• फ़ज़ी सर्च और फ़ुल-टेक्स्ट सर्च का इस्तेमाल करके, अपने Spanner डेटाबेस को क्वेरी करने का तरीका.
• BigQuery से Spanner के ख़िलाफ़ फ़ेडरेटेड क्वेरी करने का तरीका.
• Spanner इंस्टेंस मिटाने का तरीका.

आगे क्या करना है?

• Spanner की ऐडवांस सुविधाओं के बारे में ज़्यादा जानें. इनमें ये सुविधाएं शामिल हैं:
  • टाइम टू लाइव (टीटीएल).
  • ऐक्सेस कंट्रोल की बेहतर सुविधा.
  • वेक्टर एम्बेडिंग और खोज.
  • JSON फ़ाइल वाले खोज इंडेक्स.
  • Spanner Graph.
• उपलब्ध Spanner क्लाइंट लाइब्रेरी देखें.