PostgreSQL और Oracle GTT के लिए अस्थायी तालिकाओं की तुलना करना

अस्थायी तालिकाएँ अधिकांश SGBDs में मौजूद एक उपयोगी अवधारणा है, भले ही वे अक्सर अलग तरह से काम करती हैं।

यह ब्लॉग कुछ विशिष्ट उदाहरणों के साथ PostgreSQL (संस्करण 11) या Oracle (संस्करण 12c) डेटाबेस में इस प्रकार की तालिकाओं के लिए तकनीकी विशेषताओं का वर्णन करता है। हालांकि इन तालिकाओं का उद्देश्य सभी SGBD के लिए समान हो सकता है, उनकी विशिष्टताएं, या कार्यान्वयन और हेरफेर का तरीका पूरी तरह से अलग हैं।

इस सुविधा का उपयोग डेवलपर्स या डेटाबेस व्यवस्थापक दोनों द्वारा मध्यवर्ती परिणामों को संग्रहीत करने के लिए किया जा सकता है जो कि अच्छे प्रदर्शन मेट्रिक्स प्रदान करने के लिए आगे की प्रक्रिया के लिए आवश्यक होंगे।

PostgreSQL में अस्थायी तालिकाएँ

PostgreSQL में ये ऑब्जेक्ट केवल वर्तमान सत्र के लिए मान्य हैं:वे एक ही सत्र के साथ बनाए गए, उपयोग किए गए और छोड़े गए:तालिका की संरचना और प्रबंधित डेटा केवल वर्तमान सत्र के लिए दृश्यमान हैं, इस प्रकार अन्य सत्रों की पहुंच नहीं है अन्य सत्रों में बनाई गई अस्थायी तालिकाएँ।

नीचे एक अस्थायी तालिका बनाने का एक सरल उदाहरण दिखाया गया है:

CREATE TEMPORARY TABLE tt_customer
(
     customer_id INTEGER
)
ON COMMIT DELETE ROWS;

अस्थायी तालिकाएँ एक अस्थायी स्कीमा में बनाई जाती हैं:pg_temp_nn और इन तालिकाओं पर अनुक्रमणिका बनाना संभव है:

tt_customer(customer_id) पर

creation index  tt_cusomer_idx_1 on tt_customer(customer_id)

चूंकि इन तालिकाओं पर डेटा पंक्तियों को भी हटाया जा सकता है, इसलिए कब्जे वाले भंडारण को वैक्यूम के निष्पादन के माध्यम से जारी करना संभव है। आदेश:

VACUUM VERBOSE tt_customer

विश्लेषण आँकड़ों को इकट्ठा करने के लिए कमांड को अस्थायी तालिकाओं पर भी निष्पादित किया जा सकता है:

ANALYZE VERBOSE tt_customer;

इस प्रकार की तालिका के लिए दोनों कमांड को SQL कमांड के रूप में निष्पादित किया जा सकता है, हालांकि, autovaccum उन्हें निष्पादित करने वाला डेमॉन अस्थायी तालिकाओं पर कार्य नहीं करता है।

एक और महत्वपूर्ण बिंदु पर विचार करना एक ही नाम के साथ स्थायी और अस्थायी तालिकाओं से संबंधित है:एक बार ऐसा होने पर स्थायी तालिका को केवल तभी ध्यान में रखा जाता है जब इसके स्कीमा को उपसर्ग के रूप में कहा जाता है।

web_db=# BEGIN TRANSACTION;
BEGIN
web_db=# SELECT COUNT(*) FROM customers;
  count  
---------
 1030056
(1 row)

web_db=# CREATE TEMPORARY TABLE customers(
web_db(#   id INTEGER
web_db(# )
web_db-# ON COMMIT PRESERVE ROWS;
CREATE TABLE
web_db=# INSERT INTO customers(id) VALUES(1023);
INSERT 0 1
web_db=# SELECT COUNT(*) FROM customers;
 count 
-------
     1
(1 row)
web_db=# \dt *customers*
                  List of relations
  Schema   |         Name         | Type  |  Owner   
-----------+----------------------+-------+----------
 pg_temp_5 | customers            | table | postgres
 web_app   | customers            | table | postgres
 web_app   | customers_historical | table | postgres
(3 rows)
web_db=# DROP TABLE customers;
DROP TABLE
web_db=# \dt *customers*
                 List of relations
 Schema  |         Name         | Type  |  Owner   
---------+----------------------+-------+----------
 web_app | customers            | table | postgres
 web_app | customers_historical | table | postgres
(2 rows)
web_db=# SELECT COUNT(*) FROM web_app.customers; 
  count  
---------
 1030056
(1 row)
web_db=# SELECT COUNT(*) FROM customers; 
  count  
---------
 1030056
(1 row)

पिछले उदाहरण से, जबकि अस्थायी तालिका मौजूद है ग्राहकों . के सभी संदर्भ स्थायी तालिका के बजाय इस तालिका को संदर्भित करता है।

अस्थायी तालिकाओं के लिए डेवलपर युक्तियाँ

इस उदाहरण का उद्देश्य उन ग्राहकों के लिए बोनस प्रदान करना है जिन्होंने एक वर्ष से अधिक समय से खरीदारी या लॉगिन नहीं किया है, इसलिए डेवलपर की स्क्रिप्ट संभावित समाधान के रूप में प्रश्नों में उप-प्रश्नों का उपयोग करने के लिए (या सीटीई का उपयोग करना) कथन) अस्थायी तालिकाओं का उपयोग कर सकता है (जो आमतौर पर उप-प्रश्नों का उपयोग करने से तेज़ होता है):

web_db=# BEGIN TRANSACTION;
BEGIN
web_db=# CREATE TEMPORARY TABLE tt_customers(
web_db(#   id INTEGER
web_db(# )
web_db-# ON COMMIT DELETE ROWS;
CREATE TABLE
web_db=# SELECT COUNT(*) FROM tt_customers;
 count 
-------
     0
(1 row)
web_db=# INSERT INTO tt_customers(id)
web_db-# SELECT customer_id
web_db-#   FROM web_app.orders
web_db-# WHERE order_dt <= NOW()-INTERVAL '6 MONTH';
INSERT 0 1030056
web_db=# SELECT COUNT(*) FROM tt_customers;
  count  
---------
 1030056
(1 row)
web_db=# DELETE FROM tt_customers c
web_db-# WHERE EXISTS(SELECT 1 
web_db(#                FROM web_app.users u JOIN web_app.login l 
web_db(#                       ON (l.user_id=u.user_id) 
web_db(#               WHERE u.customer_id=c.id 
web_db(#                 AND l.login_dt > NOW()-INTERVAL '6 MONTH'
web_db(#                 );
DELETE 194637
web_db=# SELECT COUNT(*) FROM tt_customers;
 count  
--------
 835419
(1 row)
web_db=# UPDATE web_app.customers as c SET BONUS=5
web_db-# FROM tt_customers t
web_db-# WHERE t.id = c.id;
UPDATE 835419
web_db=# SELECT COUNT(*) FROM tt_customers;
 count  
--------
 835419
(1 row)
web_db=# COMMIT TRANSACTION;
COMMIT
web_db=# SELECT COUNT(*) FROM tt_customers;
 count 
-------
     0
(1 row)

अस्थायी तालिकाओं के लिए DBA युक्तियाँ

डेटाबेस प्रशासकों के लिए एक विशिष्ट कार्य किसी भी बड़ी तालिका को शुद्ध करना है जिसमें डेटा होता है जिसकी अब आवश्यकता नहीं है। इसे बहुत जल्दी पूरा करने की जरूरत है और ऐसा अक्सर होता है। मानक तरीका यह है कि इस डेटा को किसी अन्य स्कीमा में ऐतिहासिक तालिका में ले जाया जाए या ऐसे डेटाबेस में ले जाया जाए जिसे कम बार एक्सेस किया जाता है।

इसलिए, इस मूविंग को करने के लिए, प्रदर्शन के मुद्दों के कारण अस्थायी तालिकाओं का उपयोग करना सबसे अच्छा समाधान हो सकता है:

CREATE TEMPORARY TABLE tt_customer
(
     customer_id INTEGER
)
ON COMMIT DROP;

इस उदाहरण में, अस्थायी तालिका को DROP विकल्प के साथ बनाया गया था, इसलिए इसका मतलब है कि वर्तमान लेनदेन ब्लॉक के अंत में इसे छोड़ दिया जाएगा।

यहाँ PostgreSQL अस्थायी तालिकाओं के बारे में कुछ अन्य महत्वपूर्ण जानकारी दी गई है:

अस्थायी तालिकाओं को स्वचालित रूप से सत्र के अंत में छोड़ दिया जाता है या, जैसा कि पिछले उदाहरण में प्रस्तुत किया गया है, वर्तमान लेनदेन के अंत में
जब तक अस्थायी तालिका मौजूद है, तब तक समान नाम वाली स्थायी तालिकाएं वर्तमान सत्र के लिए दृश्यमान नहीं हैं, जब तक कि उन्हें स्कीमा-योग्य नामों से संदर्भित नहीं किया जाता है
अस्थायी तालिका पर बनाई गई कोई भी अनुक्रमणिका स्वचालित रूप से भी अस्थायी होती है
COMMIT पर पंक्तियों को संरक्षित करें यह डिफ़ॉल्ट व्यवहार है
वैकल्पिक रूप से, GLOBAL या LOCAL को TEMPORARY या TEMP से पहले लिखा जा सकता है। यह वर्तमान में PostgreSQL में कोई फर्क नहीं पड़ता है और इसे हटा दिया गया है
द ऑटोवैक्यूम डेमॉन इन तालिकाओं तक नहीं पहुंच सकता है और इसलिए अस्थायी तालिकाओं का निर्वात या विश्लेषण नहीं कर सकता है, हालांकि, जैसा कि पहले दिखाया गया है कि ऑटोवैक्यूम और विश्लेषण कमांड का उपयोग SQL कमांड के रूप में किया जा सकता है।

Oracle में वैश्विक अस्थायी तालिकाएं (GTT)

इस तरह की तालिकाओं को Oracle दुनिया में एक वैश्विक अस्थायी तालिका (या GTT) के रूप में जाना जाता है। ये ऑब्जेक्ट डेटाबेस में स्थायी होते हैं और इन्हें निम्नलिखित विशेषताओं द्वारा संक्षेपित किया जा सकता है:

संरचना स्थिर है और सभी उपयोगकर्ताओं के लिए दृश्यमान है, हालांकि, इसकी सामग्री केवल वर्तमान सत्र के लिए दृश्यमान है
इसे एक विशिष्ट स्कीमा में बनाया जा सकता है (डिफ़ॉल्ट रूप से उस उपयोगकर्ता के स्वामित्व में होगा जो कमांड जारी करता है) और वे TEMP टेबलस्पेस में निर्मित होते हैं
डेटाबेस में एक बार बन जाने के बाद इसे प्रत्येक सत्र में फिर से नहीं बनाया जा सकता है, हालांकि, एक सत्र द्वारा प्रबंधित डेटा अन्य सत्रों के लिए दृश्यमान नहीं होता है
अनुक्रमणिका बनाना और आंकड़े बनाना संभव है
चूंकि डेटाबेस में इन तालिकाओं की संरचना को भी परिभाषित किया गया है, इसलिए इसका नाम स्थायी तालिका में निर्दिष्ट करना संभव नहीं है (Oracle में दो वस्तुओं का अलग-अलग प्रकार से भी एक ही नाम नहीं हो सकता है)
बहुत सारे फिर से लॉग जनरेट न करें और 12c से पहले के किसी भी संस्करण के लिए ओवरहेड को पूर्ववत करें यह एक स्थायी तालिका (केवल इन कारणों से GTT का उपयोग करना तेज़ है) की तुलना में कम है। 12c संस्करण से अस्थायी पूर्ववत की एक अवधारणा है, जिससे GTT के लिए पूर्ववत को अस्थायी टेबलस्पेस पर लिखा जा सकता है, इस प्रकार यह पूर्ववत और फिर से कम कर रहा है।

PostgreSQL में प्रस्तुत उसी उदाहरण के बाद, GTT का निर्माण काफी समान है:

CREATE GLOBAL TEMPORARY TABLE tt_customer
(
     customer_id NUMBER
)
ON COMMIT DELETE ROWS;

अनुक्रमणिका बनाना भी संभव है।

tt_customer(customer_id) पर

creation index  tt_cusomer_idx_1 on tt_customer(customer_id)

Oracle 12c से पहले वैश्विक अस्थायी तालिकाओं के लिए आंकड़ों की पीढ़ी का वैश्विक तरीके से एक व्यवहार था:एक विशिष्ट GTT के लिए एक विशिष्ट सत्र में उत्पन्न आंकड़े दृश्यमान थे और अन्य सत्रों के लिए उपयोग किए गए थे (केवल आंकड़े डेटा नहीं!), हालांकि, संस्करण 12c से प्रत्येक सत्र के लिए अपने स्वयं के आंकड़े उत्पन्न करना संभव है।

सबसे पहले वरीयता सेट करना आवश्यक है global_temp_table_stats सत्र . के लिए :

exec dbms_stats.set_table_prefs(USER,’TT_CUSTOMER’,’GLOBAL_TEMP_TABLE_STATS’,’SESSION’);

और फिर आँकड़ों का निर्माण:

exec dbms_stats.gather_table_stats(USER,’TT_CUSTOMER’);

मौजूदा वैश्विक अस्थायी तालिका को निम्न क्वेरी के निष्पादन द्वारा जांचा जा सकता है:

select table_name from all_tables where temporary = 'Y';

वैश्विक अस्थायी तालिकाओं के लिए डेवलपर युक्तियाँ (GTT)

PostgreSQL अनुभाग पर उदाहरण के बाद:उन ग्राहकों के लिए बोनस असाइन करने के लिए जिन्होंने खरीदारी नहीं की है या एक वर्ष से अधिक समय तक लॉगिन नहीं किया है, Oracle में वैश्विक अस्थायी तालिकाओं के उपयोग का एक ही लक्ष्य है कि PostgreSQL में:बेहतर प्रदर्शन प्राप्त करने के लिए। संसाधन का उपयोग या निष्पादन गति में।

SQL> SELECT COUNT(*) FROM tt_customers;
  COUNT(*)
----------
         0
SQL>
SQL> INSERT INTO tt_customers(id)
  2  SELECT customer_id
  3    FROM orders
  4  WHERE order_dt <= ADD_MONTHS(SYSDATE,-6);
1030056 rows created.
SQL>
SQL> SELECT COUNT(*) FROM tt_customers;
  COUNT(*)
----------
   1030056
SQL>
SQL> DELETE FROM tt_customers c
  2  WHERE EXISTS(SELECT 1
  3                 FROM users u JOIN login l
  4                        ON (l.user_id=u.user_id)
  5                WHERE u.customer_id=c.id
  6                  AND l.login_dt > ADD_MONTHS(SYSDATE,-6)
  7                  );
194637 rows deleted.
SQL>
SQL> SELECT COUNT(*) FROM tt_customers;
  COUNT(*)
----------
    835419
SQL>
SQL> UPDATE CUSTOMERS c SET BONUS=5
  2  WHERE EXISTS(SELECT 1 FROM tt_customers tc WHERE tc.id=c.id);
835419 rows updated.
SQL>
SQL> SELECT COUNT(*) FROM tt_customers;
  COUNT(*)
----------
    835419
SQL>
SQL> COMMIT;
Commit complete.
SQL>
SQL> SELECT COUNT(*) FROM tt_customers;
  COUNT(*)
----------
         0

SQL>

Oracle में डिफ़ॉल्ट रूप से एक SQL/PLSQL ब्लॉक/स्टेटमेंट परोक्ष रूप से एक लेनदेन शुरू होता है।

वैश्विक अस्थायी तालिकाओं के लिए DBA युक्तियाँ (GTT)

बयान के रूप में छोड़ें वैश्विक अस्थायी तालिकाओं के लिए मौजूद नहीं है तालिका बनाने का आदेश यह पिछले वाले जैसा ही है:

CREATE GLOBAL TEMPORARY TABLE tt_customer
(
     customer_id NUMBER
)
ON COMMIT DELETE ROWS;

ग्राहक . को शुद्ध करने के लिए Oracle में कोड का समतुल्य स्निपेट तालिका यह निम्न है:

SQL> INSERT INTO tt_customers(id)
  2  SELECT l.user_id
  3    FROM users u JOIN login l
  4           ON (l.user_id=u.user_id)
  5   WHERE l.login_dt < ADD_MONTHS(SYSDATE,-12);
194637 rows created.
SQL>
SQL> INSERT INTO tt_customers(id)
  2  SELECT user_id
  3    FROM web_deactive;
2143 rows created.
SQL>
SQL> INSERT INTO tt_customers(id)
  2  SELECT user_id
  3    FROM web_black_list;
4234 rows created.
SQL>
SQL> INSERT INTO customers_historical(id,name)
  2  SELECT c.id,c.name
  3  FROM customers c,
  4  tt_customers tc
  5  WHERE tc.id = c.id;
201014 rows created.
SQL>
SQL> DELETE FROM customers c
  2  WHERE EXISTS (SELECT 1 FROM  tt_customers tc WHERE tc.id = c.id );
201014 rows deleted.

pg_global_temp_tables लाइब्रेरी

जैसा कि ऊपर उल्लेख किया गया है, PostgreSQL में अस्थायी तालिकाओं को schema.table संकेतन का उपयोग करके लागू नहीं किया जा सकता है , इसलिए pg_global_temp_tables लाइब्रेरी (जीथब पर कुछ समान लाइब्रेरी उपलब्ध हैं) यह Oracle से PostgreSQL में डेटाबेस माइग्रेशन में उपयोग करने के लिए बहुत उपयोगी वर्कअराउंड है।

Oracle अंकन schema.temporary_table रखने के लिए प्रश्नों या संग्रहीत प्रक्रियाओं में:

SELECT c.id,c.nam
    FROM web_app.tt_customers tc,
                 Web_app.customers c
    WHERE c.id = tc.id

यह स्कीमा संकेतन के साथ कोड पर अस्थायी टेबल बने रहने की अनुमति देता है।

मूल रूप से, इसमें एक दृश्य होता है:web_app.tt_customers उस स्कीमा के तहत बनाया गया है जिस पर अस्थायी तालिका होनी चाहिए और यह दृश्य अस्थायी तालिका tt_customers को क्वेरी करेगा web_app.select_tt_customers . नामक फ़ंक्शन के माध्यम से :

CREATE OR REPLACE VIEW WEB_APP.TT_CUSTOMERS AS 
  SELECT * FROM WEB_APP.SELECT_TT_CUSTOMERS();

यह फ़ंक्शन अस्थायी तालिका की सामग्री लौटाता है:

CREATE OR REPLACE FUNCTION WEB_APP.SELECT_TT_CUSTOMERS() RETURNS TABLE(ID INR, NAME VARCHAR) AS $$
BEGIN
    CREATE TEMPORARY TABLE IF NOT EXISTS TT_CUSTOMERS(ID INT, NAME) ON COMMIT DROP;
    RETURN QUERY SELECT * FROM TT_CUSTOMERS;
END;
$$ LANGUAGE PLPGSQL;

सारांश

अस्थायी तालिकाओं का उपयोग अनिवार्य रूप से मध्यवर्ती परिणामों को संग्रहीत करने के लिए किया जाता है और इस प्रकार जटिल और भारी कंप्यूटिंग से बचा जाता है,

इसके बाद यह अस्थायी तालिकाओं की कुछ विशेषताओं को या तो PostgreSQL या Oracle में सूचीबद्ध करता है:

इसे देखने पर इस्तेमाल किया जा सकता है
यह TRUNCATE कमांड का उपयोग कर सकता है
इसे विभाजित नहीं किया जा सकता
अस्थायी तालिकाओं पर विदेशी कुंजी बाधा की अनुमति नहीं है
इस तरह की टेबल सीटीई (कॉमन टेबल एक्सप्रेशंस) के लिए एक विकल्प है, जिसे ओरेकल प्रोफेशनल्स के लिए विद क्लॉज के रूप में भी जाना जाता है
सुरक्षा और गोपनीयता के संदर्भ में, ये तालिकाएं एक मूल्यवान संपत्ति हैं क्योंकि डेटा केवल वर्तमान सत्र के लिए दृश्यमान है
सत्र/लेन-देन समाप्त होने के बाद अस्थायी तालिकाएं स्वचालित रूप से हटा दी जाती हैं (पोस्टग्रेएसक्यूएल में) या हटा दी जाती हैं (ओरेकल में)।

PostgreSQL में अस्थायी तालिकाओं के लिए यह सलाह दी जाती है कि अस्थायी तालिका में स्थायी तालिका के समान नाम का उपयोग न करें। Oracle की ओर से सत्र के लिए आंकड़ों का निर्माण करना एक अच्छा अभ्यास है जिसमें GTT में डेटा की काफी मात्रा शामिल है ताकि लागत-आधारित अनुकूलक (CBO) को इस प्रकार की तालिकाओं का उपयोग करने वाले प्रश्नों के लिए सर्वोत्तम योजना चुनने के लिए बाध्य किया जा सके। ।