इस पेज का अनुवाद Cloud Translation API से किया गया है.

AlloyDB Omni में कॉलमर इंजन की मदद से विश्लेषण करने वाली क्वेरी की रफ़्तार बढ़ाना.

1. परिचय

इस कोडलैब में, आपको AlloyDB Omni को डिप्लॉय करने और क्वेरी की परफ़ॉर्मेंस को बेहतर बनाने के लिए, कॉलम इंजन का इस्तेमाल करने का तरीका पता चलेगा.

ज़रूरी शर्तें

Google Cloud Console की बुनियादी जानकारी
कमांड-लाइन इंटरफ़ेस और Google शेल की बुनियादी जानकारी

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

Google Cloud में GCE (जीसीई) वर्चुअल मशीन पर AlloyDB Omni को डिप्लॉय करने का तरीका
AlloyDB Omni से कनेक्ट करने का तरीका
AlloyDB Omni में डेटा लोड करने का तरीका
कॉलम इंजन को चालू करने का तरीका
अपने-आप चालू होने वाले मोड में कॉलम इंजन की जांच करने का तरीका
कॉलम स्टोर को मैन्युअल तरीके से पॉप्युलेट करने का तरीका

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

Google Cloud खाता और Google Cloud प्रोजेक्ट
Chrome जैसा कोई वेब ब्राउज़र

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

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

Google Cloud Console में साइन इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास पहले से कोई Gmail या Google Workspace खाता नहीं है, तो आपको एक खाता बनाना होगा.

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

इसके बाद, आपको Cloud के संसाधनों/एपीआई का इस्तेमाल करने के लिए, Cloud Console में बिलिंग की सुविधा चालू करनी होगी. इस कोडलैब को चलाने के लिए, आपसे कोई शुल्क नहीं लिया जाएगा. इस ट्यूटोरियल के बाद बिलिंग से बचने के लिए, बनाए गए संसाधनों को बंद किया जा सकता है या प्रोजेक्ट को मिटाया जा सकता है. Google Cloud के नए उपयोगकर्ता, 300 डॉलर के मुफ़्त ट्रायल वाले कार्यक्रम में शामिल हो सकते हैं.

Cloud Shell शुरू करना

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

Google Cloud Console में, सबसे ऊपर दाएं टूलबार में मौजूद Cloud Shell आइकॉन पर क्लिक करें:

एनवायरमेंट से कनेक्ट होने और उसे प्रोवाइड करने में सिर्फ़ कुछ मिनट लगेंगे. इसके पूरा होने पर, आपको कुछ ऐसा दिखेगा:

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

3. शुरू करने से पहले

एपीआई चालू करना

आउटपुट:

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

Cloud Shell में, पक्का करें कि आपका प्रोजेक्ट आईडी सेट अप हो:

PROJECT_ID=$(gcloud config get-value project)
echo $PROJECT_ID

अगर यह क्लाउड शेल कॉन्फ़िगरेशन में तय नहीं किया गया है, तो इसे सेट अप करने के लिए नीचे दिए गए निर्देशों का पालन करें

export PROJECT_ID=<your project>
gcloud config set project $PROJECT_ID

सभी ज़रूरी सेवाएं चालू करें:

gcloud services enable compute.googleapis.com

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

student@cloudshell:~ (test-project-001-402417)$ PROJECT_ID=$(gcloud config get-value project)
Your active configuration is: [cloudshell-14650]
student@cloudshell:~ (test-project-001-402417)$ gcloud config set project test-project-001-402417
Updated property [core/project].
student@cloudshell:~ (test-project-001-402417)$ gcloud services enable compute.googleapis.com
Operation "operations/acat.p2-4470404856-1f44ebd8-894e-4356-bea7-b84165a57442" finished successfully.

4. GCE पर AlloyDB Omni को डिप्लॉय करना

GCE पर AlloyDB Omni को डिप्लॉय करने के लिए, हमें काम करने वाले कॉन्फ़िगरेशन और सॉफ़्टवेयर के साथ वर्चुअल मशीन तैयार करनी होगी. यहां Debian पर आधारित वर्चुअल मशीन (VM) पर AlloyDB Omni को डिप्लॉय करने का उदाहरण दिया गया है.

GCE वीएम बनाना

हमें सीपीयू, मेमोरी, और स्टोरेज के लिए, स्वीकार किए जा सकने वाले कॉन्फ़िगरेशन के साथ एक वर्चुअल मशीन (वीएम) डिप्लॉय करनी होगी. हम डिफ़ॉल्ट Debian इमेज का इस्तेमाल करने जा रहे हैं. इसमें सिस्टम डिस्क का साइज़ बढ़ाकर 20 जीबी कर दिया गया है, ताकि AlloyDB Omni डेटाबेस फ़ाइलों को स्टोर किया जा सके.

हम शुरू किए गए Cloud Shell या Cloud SDK टूल के साथ टर्मिनल का इस्तेमाल कर सकते हैं

AlloyDB Omni के लिए, शुरुआत करने का तरीका में भी सभी चरणों के बारे में बताया गया है.

अपने डिप्लॉयमेंट के लिए एनवायरमेंट वैरिएबल सेट अप करें.

export ZONE=us-central1-a
export MACHINE_TYPE=n2-highmem-2
export DISK_SIZE=20
export MACHINE_NAME=omni01

इसके बाद, हम GCE वर्चुअल मशीन बनाने के लिए gcloud का इस्तेमाल करते हैं.

gcloud compute instances create $MACHINE_NAME \
    --project=$(gcloud info --format='value(config.project)') \
    --zone=$ZONE  --machine-type=$MACHINE_TYPE \
    --metadata=enable-os-login=true \
    --create-disk=auto-delete=yes,boot=yes,size=$DISK_SIZE,image=projects/debian-cloud/global/images/$(gcloud compute images list --filter="family=debian-12 AND family!=debian-12-arm64" \
    --format="value(name)"),type=pd-ssd

कंसोल का अनुमानित आउटपुट:

gleb@cloudshell:~ (gleb-test-short-001-415614)$ export ZONE=us-central1-a
export MACHINE_TYPE=n2-highmem-2
export DISK_SIZE=20
export MACHINE_NAME=omni01
gleb@cloudshell:~ (gleb-test-short-001-415614)$ gcloud compute instances create $MACHINE_NAME \
    --project=$(gcloud info --format='value(config.project)') \
    --zone=$ZONE  --machine-type=$MACHINE_TYPE \
    --metadata=enable-os-login=true \
    --create-disk=auto-delete=yes,boot=yes,size=$DISK_SIZE,image=projects/debian-cloud/global/images/$(gcloud compute images list --filter="family=debian-12 AND family!=debian-12-arm64" \
    --format="value(name)"),type=pd-ssd
Created [https://www.googleapis.com/compute/v1/projects/gleb-test-short-001-415614/zones/us-central1-a/instances/omni01].
WARNING: Some requests generated warnings:
 - Disk size: '20 GB' is larger than image size: '10 GB'. You might need to resize the root repartition manually if the operating system does not support automatic resizing. See https://cloud.google.com/compute/docs/disks/add-persistent-disk#resize_pd for details.

NAME: omni01
ZONE: us-central1-a
MACHINE_TYPE: n2-highmem-2
PREEMPTIBLE: 
INTERNAL_IP: 10.128.0.3
EXTERNAL_IP: 35.232.157.123
STATUS: RUNNING
gleb@cloudshell:~ (gleb-test-short-001-415614)$

AlloyDB Omni इंस्टॉल करना

बनाए गए वीएम से कनेक्ट करें:

gcloud compute ssh omni01 --zone $ZONE

कंसोल का अनुमानित आउटपुट:

gleb@cloudshell:~ (gleb-test-short-001-415614)$ gcloud compute ssh omni01 --zone $ZONE
Warning: Permanently added 'compute.5615760774496706107' (ECDSA) to the list of known hosts.
Linux omni01.us-central1-a.c.gleb-test-short-003-421517.internal 6.1.0-20-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.85-1 (2024-04-11) x86_64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
gleb@omni01:~$

कनेक्ट किए गए टर्मिनल में यह कमांड चलाएं.

वीएम पर Docker इंस्टॉल करें:

sudo apt update
sudo apt-get -y install docker.io

कंसोल का अनुमानित आउटपुट(छिपाया गया):

gleb@omni01:~$ sudo apt update
sudo apt-get -y install docker.io
Get:1 file:/etc/apt/mirrors/debian.list Mirrorlist [30 B]
Get:5 file:/etc/apt/mirrors/debian-security.list Mirrorlist [39 B]
Get:7 https://packages.cloud.google.com/apt google-compute-engine-bookworm-stable InRelease [5146 B]
Get:8 https://packages.cloud.google.com/apt cloud-sdk-bookworm InRelease [6406 B]        
Get:9 https://packages.cloud.google.com/apt google-compute-engine-bookworm-stable/main amd64 Packages [1916 B]
Get:2 https://deb.debian.org/debian bookworm InRelease [151 kB]
...
Setting up binutils (2.40-2) ...
Setting up needrestart (3.6-4+deb12u1) ...
Processing triggers for man-db (2.11.2-2) ...
Processing triggers for libc-bin (2.36-9+deb12u4) ...
gleb@omni01:~$

postgres उपयोगकर्ता के लिए पासवर्ड तय करें:

export PGPASSWORD=<your password>

AlloyDB के ओमनी डेटा के लिए डायरेक्ट्री बनाएं. ऐसा करना ज़रूरी नहीं है, लेकिन हमारा सुझाव है कि आप ऐसा करें. डिफ़ॉल्ट रूप से, डेटा को docker इफ़ेमरल फ़ाइल सिस्टम लेयर का इस्तेमाल करके बनाया जाएगा. साथ ही, docker कंटेनर मिटाए जाने पर, डेटा भी मिट जाएगा. इसे अलग से रखने से, कंटेनर को अपने डेटा से अलग मैनेज किया जा सकता है. साथ ही, इसे बेहतर आईओ (इनपुट/आउटपुट) सुविधाओं वाले स्टोरेज में भी रखा जा सकता है

यहां एक ऐसा निर्देश दिया गया है जो उपयोगकर्ता की होम डायरेक्ट्री में एक डायरेक्ट्री बनाता है. इस डायरेक्ट्री में सारा डेटा सेव किया जाएगा:

mkdir -p $HOME/alloydb-data

AlloyDB Omni कंटेनर को डिप्लॉय करना:

sudo docker run --name my-omni \
  -e POSTGRES_PASSWORD=$PGPASSWORD \
  -p 5432:5432 \
  -v $HOME/alloydb-data:/var/lib/postgresql/data \
  -v /dev/shm:/dev/shm \
  -d google/alloydbomni

कंसोल का अनुमानित आउटपुट(छिपाया गया):

gleb@omni01:~$ export PGPASSWORD=StrongPassword
gleb@omni01:~$ sudo docker run --name my-omni \
  -e POSTGRES_PASSWORD=$PGPASSWORD \
  -p 5432:5432 \
  -v $HOME/alloydb-data:/var/lib/postgresql/data \
  -v /dev/shm:/dev/shm \
  -d google/alloydbomni
Unable to find image 'google/alloydbomni:latest' locally
latest: Pulling from google/alloydbomni
71215d55680c: Pull complete 
...
2e0ec3fe1804: Pull complete 
Digest: sha256:d6b155ea4c7363ef99bf45a9dc988ce5467df5ae8cd3c0f269ae9652dd1982a6
Status: Downloaded newer image for google/alloydbomni:latest
56de4ae0018314093c8b048f69a1e9efe67c6c8117f44c8e1dc829a2d4666cd2
gleb@omni01:~$

वीएम में PostgreSQL क्लाइंट सॉफ़्टवेयर इंस्टॉल करें (ज़रूरी नहीं - ऐसा हो सकता है कि यह पहले से इंस्टॉल हो):

sudo apt install -y  postgresql-client

कंसोल का अनुमानित आउटपुट:

gleb@omni01:~$ sudo apt install -y  postgresql-client
Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
postgresql-client is already the newest version (15+248).
0 upgraded, 0 newly installed, 0 to remove and 4 not upgraded.

AlloyDB Omni से कनेक्ट करने के लिए:

psql -h localhost -U postgres

कंसोल का अनुमानित आउटपुट:

gleb@omni01:~$ psql -h localhost -U postgres
psql (15.6 (Debian 15.6-0+deb12u1), server 15.5)
Type "help" for help.

postgres=#

AlloyDB Omni से डिसकनेक्ट करने के लिए:

exit

कंसोल का अनुमानित आउटपुट:

postgres=# exit
gleb@omni01:~$

5. टेस्ट डेटाबेस तैयार करना

कॉलम इंजन की जांच करने के लिए, हमें एक डेटाबेस बनाना होगा और उसमें कुछ टेस्ट डेटा भरना होगा.

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

AlloyDB Omni VM से कनेक्ट करना और डेटाबेस बनाना

Cloud Shell सेशन में, यह तरीका अपनाएं:

gcloud config set project $(gcloud config get-value project)

AlloyDB Omni VM से कनेक्ट करने के लिए:

ZONE=us-central1-a
gcloud compute ssh omni01 --zone $ZONE

कंसोल का अनुमानित आउटपुट:

student@cloudshell:~ (gleb-test-short-001-416213)$ gcloud config set project $(gcloud config get-value project)
Updated property [core/project].
student@cloudshell:~ (gleb-test-short-001-416213)$ ZONE=us-central1-a
gcloud compute ssh omni01 --zone $ZONE
Linux omni01.us-central1-a.c.gleb-test-short-003-421517.internal 6.1.0-20-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.85-1 (2024-04-11) x86_64

The programs included with the Debian GNU/Linux system are free software;
the exact distribution terms for each program are described in the
individual files in /usr/share/doc/*/copyright.

Debian GNU/Linux comes with ABSOLUTELY NO WARRANTY, to the extent
permitted by applicable law.
Last login: Mon Mar  4 18:17:55 2024 from 35.237.87.44
student@omni01:~$

एसएसएच सेशन में, यह कमांड चलाएं:

export PGPASSWORD=<your password>

psql -h localhost -U postgres -c "CREATE DATABASE quickstart_db"

कंसोल का अनुमानित आउटपुट:

student@omni01:~$ psql -h localhost -U postgres -c "CREATE DATABASE quickstart_db"
CREATE DATABASE
student@omni01:~$

सैंपल डेटा के साथ टेबल बनाना

हम अपने टेस्ट के लिए, आयोवा में लाइसेंस रखने वाले इंश्योरेंस प्रोड्यूसर के सार्वजनिक डेटा का इस्तेमाल करेंगे. यह डेटासेट, आयोवा की सरकारी वेबसाइट - https://data.iowa.gov/Regulation/Insurance-Producers-Licensed-in-Iowa/n4cc-vqyk/about_data पर उपलब्ध है .

सबसे पहले, हमें एक टेबल बनानी होगी.

GCE (जीसीई) वीएम में, यह तरीका अपनाएं:

psql -h localhost -U postgres -d quickstart_db -c "DROP TABLE if exists insurance_producers_licensed_in_iowa;
CREATE TABLE insurance_producers_licensed_in_iowa (
        npn int8,
        last_name text,
        first_name text,
        address_line_1 text,
        address_line_2 text,
        address_line_3 text,
        city text,
        state text,
        zip int4,
        firstactivedate timestamp,
        expirydate timestamp,
        business_phone text,
        email text,
        physical_location text,
        iowaresident text,
        loa_has_crop text,
        loa_has_surety text,
        loa_has_ah text,
        loa_has_life text,
        loa_has_variable text,
        loa_has_personal_lines text,
        loa_has_credit text,
        loa_has_excess text,
        loa_has_property text,
        loa_has_casualty text,
        loa_has_reciprocal text
);"

कंसोल का अनुमानित आउटपुट:

otochkin@omni01:~$ psql -h localhost -U postgres -d quickstart_db -c "DROP TABLE if exists insurance_producers_licensed_in_iowa;
CREATE TABLE insurance_producers_licensed_in_iowa (
        npn int8,
        last_name text,
        first_name text,
        address_line_1 text,
        address_line_2 text,
        address_line_3 text,
        city text,
        state text,
        zip int4,
        firstactivedate timestamp,
        expirydate timestamp,
        business_phone text,
        email text,
        physical_location text,
        iowaresident text,
        loa_has_crop text,
        loa_has_surety text,
        loa_has_ah text,
        loa_has_life text,
        loa_has_variable text,
        loa_has_personal_lines text,
        loa_has_credit text,
        loa_has_excess text,
        loa_has_property text,
        loa_has_casualty text,
        loa_has_reciprocal text
);"
NOTICE:  table "insurance_producers_licensed_in_iowa" does not exist, skipping
DROP TABLE
CREATE TABLE
otochkin@omni01:~$

टेबल में डेटा लोड करें.

GCE (जीसीई) वीएम में, यह तरीका अपनाएं:

curl https://data.iowa.gov/api/views/n4cc-vqyk/rows.csv | psql -h localhost -U postgres -d quickstart_db -c "\copy insurance_producers_licensed_in_iowa from stdin csv header"

कंसोल का अनुमानित आउटपुट:

otochkin@omni01:~$ curl https://data.iowa.gov/api/views/n4cc-vqyk/rows.csv | psql -h localhost -U postgres -d quickstart_db -c "\copy insurance_producers_licensed_in_iowa from stdin csv header"
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100 39.3M    0 39.3M    0     0  1004k      0 --:--:--  0:00:40 --:--:-- 1028k
COPY 210898
otochkin@omni01:~$

हमने अपने डेटाबेस में, इंश्योरेंस प्रोड्यूसर के बारे में 2,10,898 रिकॉर्ड लोड किए हैं. अब हम कुछ जांच कर सकते हैं.

टेस्ट क्वेरी चलाना

psql का इस्तेमाल करके quickstart_db से कनेक्ट करें और क्वेरी के चलने में लगने वाले समय को मेज़र करने के लिए, टाइमिंग चालू करें.

GCE (जीसीई) वीएम में, यह तरीका अपनाएं:

psql -h localhost -U postgres -d quickstart_db

कंसोल का अनुमानित आउटपुट:

student@omni01:~$ psql -h localhost -U postgres -d quickstart_db
psql (13.14 (Debian 13.14-0+deb11u1), server 15.5
WARNING: psql major version 13, server major version 15.
         Some psql features might not work.
Type "help" for help.

quickstart_db=#

PSQL सेशन में, यह फ़ंक्शन चलाएं:

\timing

कंसोल का अनुमानित आउटपुट:

quickstart_db=# \timing
Timing is on.
quickstart_db=#

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

PSQL सेशन में, यह फ़ंक्शन चलाएं:

SELECT city, count(*) 
FROM insurance_producers_licensed_in_iowa 
WHERE loa_has_ah ='Yes' and expirydate > now() + interval '6 MONTH' 
GROUP BY city ORDER BY count(*) desc limit 5;

कंसोल का अनुमानित आउटपुट:

quickstart_db=# SELECT city, count(*)
FROM insurance_producers_licensed_in_iowa
WHERE loa_has_ah ='Yes' and expirydate > now() + interval '6 MONTH'
GROUP BY city ORDER BY count(*) desc limit 5;
    city     | count
-------------+-------
 TAMPA       |  1885
 OMAHA       |  1656
 KANSAS CITY |  1279
 AUSTIN      |  1254
 MIAMI       |  1003
(5 rows)

Time: 94.965 ms

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

psql सेशन से बाहर निकलने के लिए:

exit

6. कॉलम इंजन चालू करना

अब हमें अपने AlloyDB Omni पर कॉलम इंजन चालू करना होगा.

AlloyDB Omni के पैरामीटर अपडेट करना

हमें अपने AlloyDB Omni के लिए, इंस्टेंस पैरामीटर "google_columnar_engine.enabled" को "चालू है" पर स्विच करना होगा. इसके बाद, इसे रीस्टार्ट करना होगा.

/var/alloydb/config डायरेक्ट्री में postgresql.conf को अपडेट करें और इंस्टेंस को रीस्टार्ट करें.

GCE (जीसीई) वीएम में, यह तरीका अपनाएं:

sudo docker exec my-omni /bin/bash -c "echo google_columnar_engine.enabled=true >>/var/lib/postgresql/data/postgresql.conf"
sudo docker exec my-omni /bin/bash -c "echo shared_preload_libraries=\'google_columnar_engine,google_job_scheduler,google_db_advisor,google_storage\' >>/var/lib/postgresql/data/postgresql.conf"
sudo docker stop my-omni
sudo docker start my-omni

कंसोल का अनुमानित आउटपुट:

student@omni01:~$ sudo docker exec my-omni /bin/bash -c "echo google_columnar_engine.enabled=true >>/var/lib/postgresql/data/postgresql.conf"
sudo docker exec my-omni /bin/bash -c "echo shared_preload_libraries=\'google_columnar_engine,google_job_scheduler,google_db_advisor,google_storage\' >>/var/lib/postgresql/data/postgresql.conf"
sudo docker stop my-omni
sudo docker start my-omni
my-omni
my-omni
student@omni01:~$

कॉलम इंजन की पुष्टि करना

psql का इस्तेमाल करके डेटाबेस से कनेक्ट करें और कॉलम वाले इंजन की पुष्टि करें.

AlloyDB Omni डेटाबेस से कनेक्ट करना

VM एसएसएच सेशन में, डेटाबेस से कनेक्ट करें:

psql -h localhost -U postgres -d quickstart_db -c "show google_columnar_engine.enabled"

कमांड से, चालू कॉलम इंजन दिखना चाहिए.

कंसोल का अनुमानित आउटपुट:

student@omni01:~$ psql -h localhost -U postgres -d quickstart_db -c "show google_columnar_engine.enabled"
 google_columnar_engine.enabled 
--------------------------------
 on
(1 row)

7. परफ़ॉर्मेंस की तुलना

अब हम कॉलम वाले इंजन स्टोर को पॉप्युलेट कर सकते हैं और परफ़ॉर्मेंस की पुष्टि कर सकते हैं.

कॉलम के हिसाब से अपने-आप जानकारी भरने की सुविधा

डिफ़ॉल्ट रूप से, स्टोर में डेटा भरने वाली जॉब हर घंटे चलती है. हम इस समय को 10 मिनट तक कम कर रहे हैं, ताकि आपको इंतज़ार न करना पड़े.

GCE (जीसीई) वीएम में, यह तरीका अपनाएं:

sudo docker exec my-omni /bin/bash -c "echo google_columnar_engine.auto_columnarization_schedule=\'EVERY 10 MINUTES\' >>/var/lib/postgresql/data/postgresql.conf"
sudo docker stop my-omni
sudo docker start my-omni

इसका अनुमानित आउटपुट यह होगा:

student@omni01:~$ sudo docker exec my-omni /bin/bash -c "echo google_columnar_engine.auto_columnarization_schedule=\'EVERY 5 MINUTES\' >>/var/lib/postgresql/data/postgresql.conf"
sudo docker stop my-omni
sudo docker start my-omni
my-omni
my-omni
student@omni01:~$

सेटिंग की पुष्टि करना

GCE (जीसीई) वीएम में, यह तरीका अपनाएं:

psql -h localhost -U postgres -d quickstart_db -c "show google_columnar_engine.auto_columnarization_schedule;"

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

student@omni01:~$ psql -h localhost -U postgres -d quickstart_db -c "show google_columnar_engine.auto_columnarization_schedule;"
 google_columnar_engine.auto_columnarization_schedule 
------------------------------------------------------
 EVERY 10 MINUTES
(1 row)

student@omni01:~$

कॉलम स्टोर में ऑब्जेक्ट देखें. यह खाली होना चाहिए.

GCE (जीसीई) वीएम में, यह तरीका अपनाएं:

psql -h localhost -U postgres -d quickstart_db -c "SELECT database_name, schema_name, relation_name, column_name FROM g_columnar_recommended_columns;"

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

student@omni01:~$ psql -h localhost -U postgres -d quickstart_db -c "SELECT database_name, schema_name, relation_name, column_name FROM g_columnar_recommended_columns;"
 database_name | schema_name | relation_name | column_name 
---------------+-------------+---------------+-------------
(0 rows)

student@omni01:~$

डेटाबेस से कनेक्ट करें और उसी क्वेरी को चलाएं जिसे हमने पहले कई बार चलाया था.

GCE (जीसीई) वीएम में, यह तरीका अपनाएं:

psql -h localhost -U postgres -d quickstart_db

PSQL सेशन में.

टाइमिंग की सुविधा चालू करना

\timing

क्वेरी को कुछ बार चलाएं:

SELECT city, count(*) 
FROM insurance_producers_licensed_in_iowa 
WHERE loa_has_ah ='Yes' and expirydate > now() + interval '6 MONTH' 
GROUP BY city ORDER BY count(*) desc limit 5;

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

quickstart_db=# SELECT city, count(*)
FROM insurance_producers_licensed_in_iowa
WHERE loa_has_ah ='Yes' and expirydate > now() + interval '6 MONTH'
GROUP BY city ORDER BY count(*) desc limit 5;
    city     | count
-------------+-------
 TAMPA       |  1885
 OMAHA       |  1656
 KANSAS CITY |  1279
 AUSTIN      |  1254
 MIAMI       |  1003
(5 rows)

Time: 94.289 ms
quickstart_db=# SELECT city, count(*)
FROM insurance_producers_licensed_in_iowa
WHERE loa_has_ah ='Yes' and expirydate > now() + interval '6 MONTH'
GROUP BY city ORDER BY count(*) desc limit 5;
    city     | count
-------------+-------
 TAMPA       |  1885
 OMAHA       |  1656
 KANSAS CITY |  1279
 AUSTIN      |  1254
 MIAMI       |  1003
(5 rows)

Time: 94.608 ms
quickstart_db=#

10 मिनट इंतज़ार करें और देखें कि insurance_producers_licensed_in_iowa टेबल के कॉलम, कॉलम वाले स्टोर में अपने-आप भर गए हैं या नहीं.

SELECT database_name, schema_name, relation_name, column_name FROM g_columnar_recommended_columns;

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

quickstart_db=# SELECT database_name, schema_name, relation_name, column_name FROM g_columnar_recommended_columns;
 database_name | schema_name |            relation_name             | column_name
---------------+-------------+--------------------------------------+-------------
 quickstart_db | public      | insurance_producers_licensed_in_iowa | city
 quickstart_db | public      | insurance_producers_licensed_in_iowa | expirydate
 quickstart_db | public      | insurance_producers_licensed_in_iowa | loa_has_ah
(3 rows)

Time: 0.643 ms

अब हम insurance_producers_licensed_in_iowa टेबल के लिए क्वेरी को फिर से चला सकते हैं और देख सकते हैं कि परफ़ॉर्मेंस बेहतर हुई है या नहीं.

SELECT city, count(*)
FROM insurance_producers_licensed_in_iowa
WHERE loa_has_ah ='Yes' and expirydate > now() + interval '6 MONTH'
GROUP BY city ORDER BY count(*) desc limit 5;

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

quickstart_db=# SELECT city, count(*)
FROM insurance_producers_licensed_in_iowa
WHERE loa_has_ah ='Yes' and expirydate > now() + interval '6 MONTH'
GROUP BY city ORDER BY count(*) desc limit 5;
    city     | count
-------------+-------
 TAMPA       |  1885
 OMAHA       |  1656
 KANSAS CITY |  1279
 AUSTIN      |  1254
 MIAMI       |  1003
(5 rows)

Time: 14.380 ms
quickstart_db=# SELECT city, count(*)
FROM insurance_producers_licensed_in_iowa
WHERE loa_has_ah ='Yes' and expirydate > now() + interval '6 MONTH'
GROUP BY city ORDER BY count(*) desc limit 5;
    city     | count
-------------+-------
 TAMPA       |  1885
 OMAHA       |  1656
 KANSAS CITY |  1279
 AUSTIN      |  1254
 MIAMI       |  1003
(5 rows)

Time: 13.279 ms

एक्सीक्यूशन में लगने वाला समय 94 मिलीसेकंड से घटकर 14 मिलीसेकंड हो गया है. अगर आपको कोई सुधार नहीं दिखता है, तो g_columnar_columns व्यू की मदद से यह देखा जा सकता है कि कॉलम, कॉलम स्टोर में सही तरीके से पॉप्युलेट हुए हैं या नहीं.

SELECT relation_name,column_name,column_type,status,size_in_bytes from g_columnar_columns;

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

quickstart_db=# select relation_name,column_name,column_type,status,size_in_bytes from g_columnar_columns;
            relation_name             | column_name | column_type | status | size_in_bytes
--------------------------------------+-------------+-------------+--------+---------------
 insurance_producers_licensed_in_iowa | city        | text        | Usable |        664231
 insurance_producers_licensed_in_iowa | expirydate  | timestamp   | Usable |        212434
 insurance_producers_licensed_in_iowa | loa_has_ah  | text        | Usable |        211734
(3 rows)

अब हम यह पुष्टि कर सकते हैं कि क्वेरी एक्सीक्यूशन प्लान, कॉलम इंजन का इस्तेमाल करता है या नहीं.

PSQL सेशन में, यह फ़ंक्शन चलाएं:

EXPLAIN (ANALYZE,SETTINGS,BUFFERS)
SELECT city, count(*)
FROM insurance_producers_licensed_in_iowa
WHERE loa_has_ah ='Yes' and expirydate > now() + interval '6 MONTH'
GROUP BY city ORDER BY count(*) desc limit 5;

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

quickstart_db=# EXPLAIN (ANALYZE,SETTINGS,BUFFERS)
SELECT city, count(*)
FROM insurance_producers_licensed_in_iowa
WHERE loa_has_ah ='Yes' and expirydate > now() + interval '6 MONTH'
GROUP BY city ORDER BY count(*) desc limit 5;
                                                                                      QUERY PLAN
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 Limit  (cost=2279.72..2279.73 rows=5 width=17) (actual time=12.248..12.252 rows=5 loops=1)
   ->  Sort  (cost=2279.72..2292.91 rows=5277 width=17) (actual time=12.246..12.248 rows=5 loops=1)
         Sort Key: (count(*)) DESC
         Sort Method: top-N heapsort  Memory: 25kB
         ->  HashAggregate  (cost=2139.30..2192.07 rows=5277 width=17) (actual time=10.235..11.250 rows=7555 loops=1)
               Group Key: city
               Batches: 1  Memory Usage: 1169kB
               ->  Append  (cost=20.00..1669.24 rows=94012 width=9) (actual time=10.231..10.233 rows=94286 loops=1)
                     ->  Custom Scan (columnar scan) on insurance_producers_licensed_in_iowa  (cost=20.00..1665.22 rows=94011 width=9) (actual time=10.229..10.231 rows=94286 loops=1)
                           Filter: ((loa_has_ah = 'Yes'::text) AND (expirydate > (now() + '6 mons'::interval)))
                           Rows Removed by Columnar Filter: 116612
                           Rows Aggregated by Columnar Scan: 94286
                           Columnar cache search mode: native
                     ->  Seq Scan on insurance_producers_licensed_in_iowa  (cost=0.00..4.02 rows=1 width=9) (never executed)
                           Filter: ((loa_has_ah = 'Yes'::text) AND (expirydate > (now() + '6 mons'::interval)))
 Planning Time: 0.216 ms
 Execution Time: 12.353 ms

साथ ही, हम देख सकते हैं कि business_licenses टेबल सेगमेंट पर "Seq Scan" ऑपरेशन कभी लागू नहीं किया गया था. इसके बजाय, "कस्टम स्कैन (कॉलम स्कैन)" का इस्तेमाल किया गया था. इससे हमें जवाब मिलने में लगने वाले समय को 94 से 12 मिलीसेकंड तक कम करने में मदद मिली.

अगर हमें कॉलम वाले इंजन से अपने-आप भरने वाले कॉन्टेंट को हटाना है, तो हम SQL फ़ंक्शन google_columnar_engine_reset_recommendation का इस्तेमाल कर सकते हैं.

PSQL सेशन में, यह फ़ंक्शन चलाएं:

SELECT google_columnar_engine_reset_recommendation(drop_columns => true);

इससे, अपने-आप जानकारी भरने वाले कॉलम खाली हो जाएंगे. इसकी पुष्टि, g_columnar_columns और g_columnar_recommended_columns व्यू में की जा सकती है, जैसा कि पहले दिखाया गया था.

SELECT database_name, schema_name, relation_name, column_name FROM g_columnar_recommended_columns;

SELECT relation_name,column_name,column_type,status,size_in_bytes from g_columnar_columns;

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

quickstart_db=# SELECT database_name, schema_name, relation_name, column_name FROM g_columnar_recommended_columns;
 database_name | schema_name | relation_name | column_name
---------------+-------------+---------------+-------------
(0 rows)

Time: 0.447 ms
quickstart_db=# select relation_name,column_name,column_type,status,size_in_bytes from g_columnar_columns;
 relation_name | column_name | column_type | status | size_in_bytes
---------------+-------------+-------------+--------+---------------
(0 rows)

Time: 0.556 ms
quickstart_db=#

मैन्युअल कॉलमनर स्टोर डेटा

हम SQL फ़ंक्शन का इस्तेमाल करके, कॉलम वाले इंजन स्टोर में मैन्युअल तरीके से कॉलम जोड़ सकते हैं. इसके अलावा, इंस्टेंस शुरू होने पर उन्हें अपने-आप लोड करने के लिए, इंस्टेंस फ़्लैग में ज़रूरी इकाइयों की जानकारी दे सकते हैं.

google_columnar_engine_add SQL फ़ंक्शन का इस्तेमाल करके, पहले जैसे ही कॉलम जोड़ते हैं.

PSQL सेशन में, यह फ़ंक्शन चलाएं:

SELECT google_columnar_engine_add(relation => 'insurance_producers_licensed_in_iowa', columns => 'city,expirydate,loa_has_ah');

हम उसी g_columnar_columns व्यू का इस्तेमाल करके, नतीजे की पुष्टि कर सकते हैं:

SELECT relation_name,column_name,column_type,status,size_in_bytes from g_columnar_columns;

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

quickstart_db=# SELECT relation_name,column_name,column_type,status,size_in_bytes from g_columnar_columns;
            relation_name             | column_name | column_type | status | size_in_bytes
--------------------------------------+-------------+-------------+--------+---------------
 insurance_producers_licensed_in_iowa | city        | text        | Usable |        664231
 insurance_producers_licensed_in_iowa | expirydate  | timestamp   | Usable |        212434
 insurance_producers_licensed_in_iowa | loa_has_ah  | text        | Usable |        211734
(3 rows)

Time: 0.692 ms
quickstart_db=#

पहले की तरह ही क्वेरी चलाकर और एक्सीक्यूशन प्लान की जांच करके, यह पुष्टि की जा सकती है कि कॉलम स्टोर का इस्तेमाल किया जा रहा है या नहीं:

EXPLAIN (ANALYZE,SETTINGS,BUFFERS)
SELECT city, count(*)
FROM insurance_producers_licensed_in_iowa
WHERE loa_has_ah ='Yes' and expirydate > now() + interval '6 MONTH'
GROUP BY city ORDER BY count(*) desc limit 5;

psql सेशन से बाहर निकलने के लिए:

exit

AlloyDB Omni कंटेनर को रीस्टार्ट करने पर, हमें पता चलता है कि कॉलम वाली सारी जानकारी मिट गई है.

शेल सेशन में, यह कमांड चलाएं:

sudo docker stop my-omni
sudo docker start my-omni

पांच से 10 सेकंड इंतज़ार करें और यह चलाएं:

psql -h localhost -U postgres -d quickstart_db -c "SELECT relation_name,column_name,column_type,status,size_in_bytes from g_columnar_columns"

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

student@omni01:~$ psql -h localhost -U postgres -d quickstart_db -c "SELECT relation_name,column_name,column_type,status,size_in_bytes from g_columnar_columns"
 relation_name | column_name | column_type | status | size_in_bytes
---------------+-------------+-------------+--------+---------------
(0 rows)

रीस्टार्ट के दौरान कॉलम में अपने-आप डेटा भरने के लिए, हम उन्हें अपने AlloyDB Omni पैरामीटर में डेटाबेस फ़्लैग के तौर पर जोड़ सकते हैं. हम google_columnar_engine.relations=‘quickstart_db.public.insurance_producers_licensed_in_iowa(city,expirydate,loa_has_ah)' फ़्लैग जोड़ रहे हैं और कंटेनर को फिर से शुरू कर रहे हैं.

शेल सेशन में, यह कमांड चलाएं:

sudo docker exec my-omni /bin/bash -c "echo google_columnar_engine.relations=\'quickstart_db.public.insurance_producers_licensed_in_iowa\(city,expirydate,loa_has_ah\)\' >>/var/lib/postgresql/data/postgresql.conf"
sudo docker stop my-omni
sudo docker start my-omni

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

पांच से 10 सेकंड इंतज़ार करें और यह चलाएं:

psql -h localhost -U postgres -d quickstart_db -c "SELECT relation_name,column_name,column_type,status,size_in_bytes from g_columnar_columns"

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

student@omni01:~$ psql -h localhost -U postgres -d quickstart_db -c "SELECT relation_name,column_name,column_type,status,size_in_bytes from g_columnar_columns"
            relation_name             | column_name | column_type | status | size_in_bytes
--------------------------------------+-------------+-------------+--------+---------------
 insurance_producers_licensed_in_iowa | city        | text        | Usable |        664231
 insurance_producers_licensed_in_iowa | expirydate  | timestamp   | Usable |        212434
 insurance_producers_licensed_in_iowa | loa_has_ah  | text        | Usable |        211734
(3 rows)

8. पर्यावरण को साफ़ करना

अब हम अपना AlloyDB Omni VM मिटा सकते हैं

GCE वीएम मिटाना

Cloud Shell में, यह कमांड चलाएं:

export GCEVM=omni01
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
    --zone=$ZONE \
    --quiet

कंसोल का अनुमानित आउटपुट:

student@cloudshell:~ (test-project-001-402417)$ export GCEVM=omni01
export ZONE=us-central1-a
gcloud compute instances delete $GCEVM \
    --zone=$ZONE \
    --quiet
Deleted

9. बधाई हो

कोडलैब पूरा करने के लिए बधाई.

हमने क्या-क्या शामिल किया है

Google Cloud में GCE (जीसीई) वर्चुअल मशीन पर AlloyDB Omni को डिप्लॉय करने का तरीका
AlloyDB Omni से कनेक्ट करने का तरीका
AlloyDB Omni में डेटा लोड करने का तरीका
कॉलम इंजन को चालू करने का तरीका
अपने-आप चालू होने वाले मोड में कॉलम इंजन की जांच करने का तरीका
कॉलम स्टोर को मैन्युअल तरीके से पॉप्युलेट करने का तरीका

कॉलम इंजन के साथ काम करने के बारे में ज़्यादा जानने के लिए, दस्तावेज़ पढ़ें.

10. सर्वे

आउटपुट:

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

सिर्फ़ पढ़ें

इसे पढ़ें और इसमें दिए गए अभ्यास पूरे करें