Oracle Database
संकेत

पैरामीटर

समानांतर संकेत

कथन स्तर के समानांतर संकेत सबसे आसान हैं:

SELECT /*+ PARALLEL(8) */ first_name, last_name FROM employee emp;

ऑब्जेक्ट-लेवल समानांतर संकेत अधिक नियंत्रण देते हैं लेकिन त्रुटियों के लिए अधिक प्रवण होते हैं; डेवलपर्स अक्सर ऑब्जेक्ट नाम के बजाय उपनाम का उपयोग करना भूल जाते हैं, या वे कुछ वस्तुओं को शामिल करना भूल जाते हैं।

SELECT /*+ PARALLEL(emp,8) */ first_name, last_name FROM employee emp;

SELECT /*+ PARALLEL(table_alias,Degree of Parallelism) */ FROM table_name table_alias;

मान लें कि समानांतर संकेत का उपयोग किए बिना किसी क्वेरी को निष्पादित करने में 100 सेकंड लगते हैं। यदि हम समान क्वेरी के लिए DOP को 2 में बदलते हैं, तो आदर्श रूप से समान संकेत वाली समान क्वेरी में 50 सेकंड का समय लगेगा। इसी तरह 4 के रूप में डीओपी का उपयोग करने में 25 सेकंड का समय लगेगा।

व्यवहार में, समानांतर निष्पादन कई अन्य कारकों पर निर्भर करता है और रैखिक रूप से स्केल नहीं करता है। यह विशेष रूप से छोटे रन समय के लिए सच है जहां समानांतर ओवरहेड कई समानांतर सर्वरों में चलने से प्राप्त होने वाले लाभ से बड़ा हो सकता है।

USE_NL

नेस्टेड लूप्स का उपयोग करें।

उपयोग: use_nl(AB)

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

SELECT /*+use_nl(e d)*/ *
FROM Employees E
JOIN Departments D on E.DepartmentID = D.ID

एप्लिकेशन को भेजें

"नई पंक्तियाँ डालने के लिए DIRECT PATH विधि का उपयोग करें"।

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

• जब तक आप लेन-देन शुरू या रोलबैक नहीं करते हैं, तब तक आप उसी सत्र में तालिका से पढ़ नहीं सकते हैं।
• यदि मेज पर परिभाषित ट्रिगर हैं तो ओरेकल प्रत्यक्ष पथ का उपयोग नहीं करेगा (यह sqlldr भार के लिए एक अलग कहानी है)।
• अन्य

उदाहरण।

INSERT /*+append*/ INTO Employees
SELECT *
FROM Employees;

USE_HASH

इंजन को तर्क में तालिकाओं में शामिल होने के लिए हैश विधि का उपयोग करने का निर्देश देता है।

उपयोग: use_hash(TableA [TableB] ... [TableN])

जैसा कि कई जगहों पर बताया गया है, "एक एचएएसएच जॉइन में, ओरेकल एक टेबल (आमतौर पर शामिल किए गए परिणामों के छोटे) तक पहुंचता है और मेमोरी में ज्वाइन की पर एक हैश टेबल बनाता है। यह तब दूसरी टेबल को जॉइन करता है (आमतौर पर बड़ा होता है। एक) और मैचों के लिए हैश टेबल की जांच करता है। "

यह नेस्टेड लूप विधि के खिलाफ पसंद किया जाता है जब टेबल बड़े होते हैं, कोई इंडेक्स हाथ में नहीं होता है, आदि।

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

उपयोग का उदाहरण:

SELECT /*+use_hash(e d)*/ *
FROM Employees E
JOIN Departments D on E.DepartmentID = D.ID

पूर्ण

पूर्ण संकेत ओरेकल को निर्दिष्ट तालिका पर एक पूर्ण तालिका स्कैन करने के लिए कहता है, चाहे कोई भी सूचकांक का उपयोग किया जा सकता है।

create table fullTable(id) as select level from dual connect by level < 100000;
create index idx on fullTable(id);

कोई संकेत नहीं के साथ, सूचकांक का उपयोग किया जाता है:

select count(1) from fullTable f where id between 10 and 100;
--------------------------------------------------------------------------
| Id  | Operation         | Name | Rows  | Bytes | Cost (%CPU)| Time     |
--------------------------------------------------------------------------
|   0 | SELECT STATEMENT  |      |     1 |    13 |     3   (0)| 00:00:01 |
|   1 |  SORT AGGREGATE   |      |     1 |    13 |            |          |
|*  2 |   INDEX RANGE SCAN| IDX  |     2 |    26 |     3   (0)| 00:00:01 |
--------------------------------------------------------------------------

पूर्ण संकेत एक पूर्ण स्कैन को बल देता है:

select /*+ full(f) */ count(1) from fullTable f where id between 10 and 100;
--------------------------------------------------------------------------------
| Id  | Operation          | Name      | Rows  | Bytes | Cost (%CPU)| Time     |
--------------------------------------------------------------------------------
|   0 | SELECT STATEMENT   |           |     1 |    13 |    47   (3)| 00:00:01 |
|   1 |  SORT AGGREGATE    |           |     1 |    13 |            |          |
|*  2 |   TABLE ACCESS FULL| FULLTABLE |     2 |    26 |    47   (3)| 00:00:01 |
--------------------------------------------------------------------------------

परिणाम कैश

Oracle ( 11g और उससे अधिक ) SQL प्रश्नों को SGA में कैश किया जा सकता है और प्रदर्शन को सुधारने के लिए पुन: उपयोग किया जाता है। यह डेटाबेस के बजाय कैश से डेटा पर सवाल उठाता है। इसके बाद उसी क्वेरी का निष्पादन तेजी से होता है क्योंकि अब डेटा को कैश से खींचा जा रहा है।

SELECT /*+ result_cache */ number FROM main_table;

आउटपुट -

Number
------
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10

Elapsed: 00:00:02.20

यदि मैं उसी क्वेरी को फिर से चलाता हूं, तो निष्पादित करने का समय कम हो जाएगा क्योंकि डेटा अब कैश से प्राप्त किया गया है जो पहले निष्पादन के दौरान सेट किया गया था।

आउटपुट -

Number
------
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10

Elapsed: 00:00:00.10

ध्यान दें कि कैसे बीता हुआ समय 2.20 सेकंड से घटकर 0.10 सेकंड हो जाता है ।

परिणाम कैश तब तक कैश रखता है जब तक डेटाबेस में डेटा अद्यतन / परिवर्तित / हटा नहीं दिया जाता है। कोई भी परिवर्तन कैश जारी करेगा।