🤛🏾 🍚 🍬 विभाजक द्वारा एक रेखा को तोड़ें। थोड़ा कनेक्ट के बारे में 😽 🏇🏽 😞

आपका स्वागत है!

मैं पीएल / एसक्यूएल डेवलपर के रूप में काम करता हूं। सिस्टम लोड को ट्रैक करने के लिए मैट्रिक्स के लिए कुछ डेटा एकत्र करने का कार्य है। कुछ फ़ंक्शन है जो आईडी की सूची वाले पैरामीटर के साथ कहा जाता है।

1,2,3,4…1001,1002,1003…

कार्य निम्नानुसार है। तत्वों में ऐसी रेखा को तोड़ना और उन्हें पूर्णांक संग्रह में लिखना आवश्यक है।

चलिए शुरू करते हैं।

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

हम स्मार्ट नहीं होंगे, हम VARCHAR2 के साथ अनुक्रम करेंगे, न कि CLOB। अगला, मैं समझाऊंगा कि क्यों VARCHAR2।

अनुक्रम उत्पन्न करने के लिए फ़ंक्शन कोड:

 CREATE OR REPLACE FUNCTION createNumbers(v_N IN PLS_INTEGER) RETURN VARCHAR2 IS v_str VARCHAR2(4000) := '0'; too_small EXCEPTION; PRAGMA EXCEPTION_INIT(too_small, -6502); BEGIN FOR i IN 1..v_N LOOP BEGIN v_str := v_str || ',' || TO_CHAR(i); EXCEPTION WHEN too_small THEN EXIT; END; END LOOP; RETURN v_str || ','; END;

आइए अपने काम पर वापस लौटते हैं।

पहली बात जो मन में आती है वह लाइन के माध्यम से लूप करना है, प्रत्येक पुनरावृत्ति पर लाइन की लंबाई को कम करना। चूंकि, समस्या की स्थितियों के अनुसार, परिणाम को संग्रह में रखा जाना चाहिए, हम इसी संग्रह को बनाएंगे।

 DECLARE v_N PLS_INTEGER := 1000; v_str VARCHAR2(4000) := createNumbers(v_N => v_N); TYPE tab_number IS TABLE OF NUMBER(5); t_str tab_number := tab_number(); BEGIN WHILE v_str IS NOT NULL LOOP t_str.EXTEND; t_str(t_str.COUNT) := SUBSTR(v_str, 1, INSTR(v_str, ',', 1) - 1); v_str := SUBSTR(v_str, INSTR(v_str, ',', 1) + 1); END LOOP; FOR i IN t_str.FIRST..t_str.LAST LOOP dbms_output.put_line(t_str(i)); END LOOP; t_str.DELETE; END;

परिणाम:

CreateNumber () फ़ंक्शन लॉजिक v_N = 1000 लेता है। createNumber () फ़ंक्शन में, आप v_str वैरिएबल के ओवरफ़्लो हैंडलिंग देख सकते हैं। एक साधारण गणना के साथ, आप पता लगा सकते हैं कि 1021 नंबरों के लिए 4000 बाइट्स पर्याप्त हैं। हमारा 1000 बिना किसी समस्या के इस आकार में फिट बैठता है।

जैसा कि आप देख सकते हैं, परिणाम वही है जिसकी आवश्यकता थी। स्ट्रिंग विभाजित है।

भले ही ओरेकल में एक अंतर्निहित विभाजन () फ़ंक्शन नहीं है, जैसे कि जावा या पायथन में, यह विकल्प मुझे सूट नहीं करता है, क्योंकि मेरा मानना है कि स्ट्रिंग को विभाजित करने जैसे सरल कार्य के लिए बहुत अधिक कोड लिखा गया है।

इस स्तर पर, मैंने सोचा, क्या केवल एसक्यूएल का उपयोग करके एक स्ट्रिंग को विभाजित करना संभव है? मुझे क्लासिक एसक्यूएल से मतलब नहीं है, लेकिन एसक्यूएल जो ओरेकल प्रदान करता है।

मुझे प्रश्नों के पदानुक्रमित निर्माण के लिए डिज़ाइन याद आया।

वैकल्पिक स्टार्ट विथ ऑरेकल ओरेकल को बताता है कि लूप को कहां से शुरू करना है, अर्थात्। कौन सी पंक्ति मूल होगी। हालत लगभग किसी भी हो सकती है। CONNECT BY के बाद की स्थिति निर्दिष्ट की जानी चाहिए। यहां ओरेकल को यह बताना आवश्यक है कि चक्र को जारी रखने के लिए कब तक।

यह देखा जा सकता है कि एक पदानुक्रमित क्वेरी के निर्माण के लिए एकमात्र महत्वपूर्ण शर्त CONNECT BY ऑपरेटर है, बाकी आवश्यकतानुसार "स्ट्रैंग" है।

इसके अलावा, इस निर्माण में एक छद्म स्तंभ स्तर है, जो वर्तमान पुनरावृत्ति पर घोंसले के शिकार के स्तर को वापस करता है।

पहली नज़र में, ऐसा लग सकता है कि यह निर्माण एक लाइन को तोड़ने के लिए उपयुक्त नहीं है। यह पूरी तरह सच नहीं है। यदि स्थिति को सही ढंग से सेट किया गया है, तो पुनरावर्ती ट्रावेल को चक्रीय में बदल दिया जा सकता है, जैसे कि समय में या छोरों के लिए।

क्वेरी लिखने से पहले, एक लाइन-ट्रैवर्सल एल्गोरिथम पर विचार करें। यह आवश्यक है, लाइन की शुरुआत से, एक निश्चित संख्या में पात्रों को काटने के लिए, सीमांकक चरित्र को। ऊपर, मैंने छद्म स्तंभ स्तर के बारे में लिखा। हम इसे वर्तमान पुनरावृत्ति संख्या के रूप में उपयोग करेंगे।
यह कुछ इस तरह से निकलता है:

 SELECT SUBSTR(str, INSTR(str, ',', 1, level - 1) + 1, INSTR(str, ',', 1, level) - INSTR(str, ',', 1, level - 1) + 1)) FROM DUAL;

लेकिन अगर आप बारीकी से देखते हैं, तो आप देख सकते हैं कि यह एल्गोरिथ्म बहुत पहले चलना पर काम नहीं करेगा, क्योंकि INSTR () फ़ंक्शन का तीसरा तर्क 0 नहीं हो सकता है।

इसलिए, हम DECODE () फ़ंक्शन का उपयोग करके एक छोटी सी स्थिति जोड़ते हैं।

 SELECT SUBSTR(str, DECODE(level, 1, 1, INSTR(str, ',', 1, level - 1) + 1), INSTR(str, ',', 1, level) - DECODE(level, 1, 1, INSTR(str, ',', 1, level - 1) + 1)) FROM DUAL;

अब बहुत पहले चलना सही ढंग से काम करेगा।

निर्माण से कनेक्ट करने का समय आ गया है। साथ ही हम अपनी लाइन को ऊपर ले जाते हैं।

 WITH TMain AS (SELECT '100,200,300,400,500' || ',' AS str FROM DUAL) SELECT SUBSTR(str, DECODE(level, 1, 1, INSTR(str, ',', 1, level - 1) + 1), INSTR(str, ',', 1, level) - DECODE(level, 1, 1, INSTR(str, ',', 1, level - 1) + 1)) FROM TMain CONNECT BY NVL(INSTR(str, ',', 1, level), 0) <> 0;

मैंने पहले ही लिखा था कि, सही स्थिति में, CONNECT BY निर्माण लूप की तरह व्यवहार कर सकता है। जब तक INSTR () फ़ंक्शन विभाजक वर्ण की nth स्थिति को ढूँढ सकता है, जहां n वर्तमान पुनरावृत्ति की संख्या है, और जैसा कि हम याद करते हैं, छद्म-स्तंभ स्तर इटर्ज़ेशन संख्या के लिए ज़िम्मेदार है।

ऐसा लगता है कि समस्या हल हो गई है? नहीं।

कोड काम कर सकता है, लेकिन इसकी पठनीयता शून्य है। मैं पहले से ही लूप विकल्प पर वापस जाने के बारे में सोच रहा था, लेकिन मुझे लगा कि CONNECT BY विकल्प को कैसे बेहतर बनाया जाए।

ओरेकल में नियमित अभिव्यक्ति के रूप में ऐसा शक्तिशाली उपकरण है। विशेष रूप से, फ़ंक्शन regexp_instr () और regexp_substr ()।

regexp_instr(_, [, _ [, ] ]) - फ़ंक्शन पैटर्न के लिए मैच की शुरुआत या अंत में चरित्र की स्थिति देता है, साथ ही साथ इसके अनुरूप INSTR ()।

regexp_substr(_, [, [, ]]) - फ़ंक्शन पैटर्न से मेल खाने वाले एक विकल्प को लौटाता है।

नियमित अभिव्यक्तियों का उपयोग करके क्वेरी फिर से लिखें:

 WITH TMain AS (SELECT '100,200,300,400,500' || ',' AS str FROM DUAL) SELECT regexp_substr(str, '[^,]+', 1, level) FROM TMain CONNECT BY NVL(regexp_instr(str, '[^,]+', 1, level), 0) <> 0;

कोड पिछले उदाहरण की तुलना में बहुत बेहतर पढ़ता है। यह विकल्प मुझे सूट करता है।

अंत में, तीन विकल्पों के लिए रनटाइम पार्सिंग तुलना की तुलना करना तर्कसंगत होगा। ऊपर, मैंने यह समझाने का वादा किया कि CLOB प्रकार के बजाय हम VARCHAR2 प्रकार का उपयोग क्यों करेंगे। यह सिर्फ रनटाइम की तुलना करने के लिए है। चूंकि Oracle CLAR प्रकार को VARCHAR2 की तुलना में अलग तरीके से संभालता है, जो परिणामों को विकृत कर सकता है।

तीन विकल्पों के मूल्यांकन के लिए कोड:

 DECLARE v_N PLS_INTEGER := 1000; v_str VARCHAR2(32767); v_startTime TIMESTAMP(9); v_endTime TIMESTAMP(9); TYPE tab_number IS TABLE OF NUMBER(5); t_str tab_number := tab_number(); BEGIN v_str := createNumbers(v_N => v_N); v_startTime := SYSTIMESTAMP; WHILE v_str IS NOT NULL LOOP t_str.EXTEND; t_str(t_str.COUNT) := SUBSTR(v_str, 1, INSTR(v_str, ',', 1) - 1); v_str := SUBSTR(v_str, INSTR(v_str, ',', 1) + 1); END LOOP; v_endTime := SYSTIMESTAMP; dbms_output.put_line(v_endTime - v_startTime); t_str.DELETE; /*---------------------------------------------------------*/ v_str := createNumbers(v_N => v_N); v_startTime := SYSTIMESTAMP; SELECT TO_NUMBER(SUBSTR(v_str, DECODE(level, 1, 1, INSTR(v_str, ',', 1, level - 1) + 1), INSTR(v_str, ',', 1, level) - DECODE(level, 1, 1, INSTR(v_str, ',', 1, level - 1) + 1))) BULK COLLECT INTO t_str FROM DUAL CONNECT BY NVL(INSTR(v_str, ',', 1, level), 0) <> 0; v_endTime := SYSTIMESTAMP; dbms_output.put_line(v_endTime - v_startTime); t_str.DELETE; /*---------------------------------------------------------*/ v_str := createNumbers(v_N => v_N); v_startTime := SYSTIMESTAMP; SELECT TO_NUMBER(regexp_substr(v_str, '[^,]+', 1, level)) BULK COLLECT INTO t_str FROM DUAL CONNECT BY NVL(regexp_instr(v_str, '[^,]+', 1, level), 0) <> 0; v_endTime := SYSTIMESTAMP; dbms_output.put_line(v_endTime - v_startTime); t_str.DELETE; END;

परिणाम सारणीबद्ध हैं:

तोड़ विकल्प / संख्या की संख्या	10	100	1000
चक्र	0,05ms	0,15ms	1,52ms
कनेक्ट द्वारा	0,18ms	0,68ms	18,1ms
कनेक्ट द्वारा + नियमित अभिव्यक्ति	0,25ms	12,1ms	1s 137ms

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

पढ़ने के लिए धन्यवाद!

उपयोग किए गए स्रोतों की सूची:

1. पदानुक्रमित (पुनरावर्ती) प्रश्न

विभाजक द्वारा एक रेखा को तोड़ें। थोड़ा कनेक्ट के बारे में

More articles: