एसक्यूएल क्वेरी कोड पुनरावृत्ति को रोकने के लिए तार या प्रक्रियात्मक होने के विकल्प?

19

डिस्क्लेमर: कृपया मेरे साथ किसी ऐसे व्यक्ति के रूप में सहन करें, जो केवल अपने काम के समय का एक छोटा सा हिस्सा डेटाबेस का उपयोग करता है। (ज्यादातर समय मैं अपनी नौकरी में C ++ प्रोग्रामिंग करता हूं, लेकिन हर विषम महीने में मुझे एक Oracle डेटाबेस में कुछ सर्च / फिक्स / ऐड करना पड़ता है।)

मुझे बार-बार जटिल एसक्यूएल प्रश्नों को लिखने की आवश्यकता है, दोनों तदर्थ प्रश्नों के लिए और अनुप्रयोगों में निर्मित प्रश्नों के लिए, जहां प्रश्नों के बड़े हिस्से जहां "कोड" दोहराया जाता है।

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

संपादित करें: 1, मैं उन उत्तरदाताओं को धन्यवाद देना चाहता हूं जिन्होंने मेरे मूल उदाहरण में उत्कृष्ट सुधार प्रदान किए । हालाँकि, यह प्रश्न मेरे उदाहरण के बारे में नहीं है। यह SQL प्रश्नों में पुनरावृत्ति के बारे में है। जैसे, उत्तर ( जैकप , लेह ) अब तक यह दिखाने का एक बड़ा काम करते हैं कि आप बेहतर प्रश्न लिखकर पुनरावृत्ति को कम कर सकते हैं । हालाँकि तब भी आपको कुछ दोहराव का सामना करना पड़ता है, जिसे स्पष्ट रूप से नहीं हटाया जा सकता है: इसने मुझे हमेशा SQL के साथ जोड़ा। "पारंपरिक" प्रोग्रामिंग भाषाओं में मैं कोड में पुनरावृत्ति को कम करने के लिए काफी रिफ्लेक्टर कर सकता हूं, लेकिन एसक्यूएल के साथ ऐसा लगता है कि इसके लिए अनुमति देने वाले कम विवरण लिखने के अलावा, इसके लिए अनुमति देने वाले कोई उपकरण (?) नहीं हैं।

ध्यान दें कि मैंने ओरेकल टैग को फिर से हटा दिया है, क्योंकि मुझे वास्तव में दिलचस्पी होगी कि क्या कोई डेटाबेस या स्क्रिप्टिंग भाषा नहीं है जो कुछ और के लिए अनुमति देता है।

यहाँ एक ऐसा रत्न है जिसे मैंने आज एक साथ सिल दिया। यह मूल रूप से एक एकल तालिका के स्तंभों के सेट में अंतर की रिपोर्ट करता है। कृपया निम्नलिखित कोड के माध्यम से स्किम करें। अंत में बड़ी क्वेरी। मैं नीचे जारी रखूंगा।

--
-- Create Table to test queries
--
CREATE TABLE TEST_ATTRIBS (
id NUMBER PRIMARY KEY,
name  VARCHAR2(300) UNIQUE,
attr1 VARCHAR2(2000),
attr2 VARCHAR2(2000),
attr3 INTEGER,
attr4 NUMBER,
attr5 VARCHAR2(2000)
);

--
-- insert some test data
--
insert into TEST_ATTRIBS values ( 1, 'Alfred',   'a', 'Foobar', 33, 44, 'e');
insert into TEST_ATTRIBS values ( 2, 'Batman',   'b', 'Foobar', 66, 44, 'e');
insert into TEST_ATTRIBS values ( 3, 'Chris',    'c', 'Foobar', 99, 44, 'e');
insert into TEST_ATTRIBS values ( 4, 'Dorothee', 'd', 'Foobar', 33, 44, 'e');
insert into TEST_ATTRIBS values ( 5, 'Emilia',   'e', 'Barfoo', 66, 44, 'e');
insert into TEST_ATTRIBS values ( 6, 'Francis',  'f', 'Barfoo', 99, 44, 'e');
insert into TEST_ATTRIBS values ( 7, 'Gustav',   'g', 'Foobar', 33, 44, 'e');
insert into TEST_ATTRIBS values ( 8, 'Homer',    'h', 'Foobar', 66, 44, 'e');
insert into TEST_ATTRIBS values ( 9, 'Ingrid',   'i', 'Foobar', 99, 44, 'e');
insert into TEST_ATTRIBS values (10, 'Jason',    'j', 'Bob',    33, 44, 'e');
insert into TEST_ATTRIBS values (12, 'Konrad',   'k', 'Bob',    66, 44, 'e');
insert into TEST_ATTRIBS values (13, 'Lucas',    'l', 'Foobar', 99, 44, 'e');

insert into TEST_ATTRIBS values (14, 'DUP_Alfred',   'a', 'FOOBAR', 33, 44, 'e');
insert into TEST_ATTRIBS values (15, 'DUP_Chris',    'c', 'Foobar', 66, 44, 'e');
insert into TEST_ATTRIBS values (16, 'DUP_Dorothee', 'd', 'Foobar', 99, 44, 'e');
insert into TEST_ATTRIBS values (17, 'DUP_Gustav',   'X', 'Foobar', 33, 44, 'e');
insert into TEST_ATTRIBS values (18, 'DUP_Homer',    'h', 'Foobar', 66, 44, 'e');
insert into TEST_ATTRIBS values (19, 'DUP_Ingrid',   'Y', 'foo',    99, 44, 'e');

insert into TEST_ATTRIBS values (20, 'Martha',   'm', 'Bob',    33, 88, 'f');

-- Create comparison view
CREATE OR REPLACE VIEW TA_SELFCMP as
select 
t1.id as id_1, t2.id as id_2, t1.name as name, t2.name as name_dup,
t1.attr1 as attr1_1, t1.attr2 as attr2_1, t1.attr3 as attr3_1, t1.attr4 as attr4_1, t1.attr5 as attr5_1,
t2.attr1 as attr1_2, t2.attr2 as attr2_2, t2.attr3 as attr3_2, t2.attr4 as attr4_2, t2.attr5 as attr5_2
from TEST_ATTRIBS t1, TEST_ATTRIBS t2
where t1.id <> t2.id
and t1.name <> t2.name
and t1.name = REPLACE(t2.name, 'DUP_', '')
;

-- NOTE THIS PIECE OF HORRIBLE CODE REPETITION --
-- Create comparison report
-- compare 1st attribute
select 'attr1' as Different,
id_1, id_2, name, name_dup,
CAST(attr1_1 AS VARCHAR2(2000)) as Val1, CAST(attr1_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr1_1 <> attr1_2
or (attr1_1 is null and attr1_2 is not null)
or (attr1_1 is not null and attr1_2 is null)
union
-- compare 2nd attribute
select 'attr2' as Different,
id_1, id_2, name, name_dup,
CAST(attr2_1 AS VARCHAR2(2000)) as Val1, CAST(attr2_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr2_1 <> attr2_2
or (attr2_1 is null and attr2_2 is not null)
or (attr2_1 is not null and attr2_2 is null)
union
-- compare 3rd attribute
select 'attr3' as Different,
id_1, id_2, name, name_dup,
CAST(attr3_1 AS VARCHAR2(2000)) as Val1, CAST(attr3_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr3_1 <> attr3_2
or (attr3_1 is null and attr3_2 is not null)
or (attr3_1 is not null and attr3_2 is null)
union
-- compare 4th attribute
select 'attr4' as Different,
id_1, id_2, name, name_dup,
CAST(attr4_1 AS VARCHAR2(2000)) as Val1, CAST(attr4_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr4_1 <> attr4_2
or (attr4_1 is null and attr4_2 is not null)
or (attr4_1 is not null and attr4_2 is null)
union
-- compare 5th attribute
select 'attr5' as Different,
id_1, id_2, name, name_dup,
CAST(attr5_1 AS VARCHAR2(2000)) as Val1, CAST(attr5_2 AS VARCHAR2(2000)) as Val2
from TA_SELFCMP
where attr5_1 <> attr5_2
or (attr5_1 is null and attr5_2 is not null)
or (attr5_1 is not null and attr5_2 is null)
;

जैसा कि आप देख सकते हैं, "अंतर रिपोर्ट" उत्पन्न करने के लिए क्वेरी एक ही SQL SELECT ब्लॉक का 5 बार उपयोग करती है (आसानी से 42 बार!)। यह मुझे बिल्कुल ब्रेन डेड के रूप में मारता है (मुझे यह कहने की अनुमति है, आखिरकार मैंने कोड लिखा है), लेकिन मैं इसके लिए कोई अच्छा समाधान नहीं ढूंढ पाया।

  • यदि यह कुछ वास्तविक एप्लिकेशन कोड में एक क्वेरी होगी, तो मैं एक फ़ंक्शन लिख सकता हूं जो इस क्वेरी को एक स्ट्रिंग के रूप में एक साथ सिल देता है और फिर मैं एक स्ट्रिंग के रूप में क्वेरी निष्पादित करूंगा।

    • -> बिल्डिंग स्ट्रिंग्स परीक्षण और बनाए रखने के लिए भयानक और भयानक है। यदि "एप्लिकेशन कोड" को पीएल / एसक्यूएल जैसी भाषा में लिखा जाता है, तो ऐसा लगता है कि यह गलत है।

  • वैकल्पिक रूप से, यदि पीएल / एसक्यूएल या इसके जैसे से उपयोग किया जाता है, तो मुझे लगता है कि इस क्वेरी को अधिक बनाए रखने के लिए कुछ प्रक्रियात्मक साधन होंगे।

    • -> कोड पुनरावृत्ति को रोकने के लिए किसी चीज को प्रक्रियात्मक चरणों में व्यक्त किया जा सकता है, कुछ भी अनियंत्रित करना गलत भी लगता है।

  • यदि इस क्वेरी को डेटाबेस में एक दृश्य के रूप में आवश्यक होगा, तो - जहां तक ​​मैं समझता हूं - वास्तव में दृश्य परिभाषा को बनाए रखने के अलावा कोई रास्ता नहीं होगा जैसा कि मैंने ऊपर पोस्ट किया है। (!!?)

    • -> मुझे वास्तव में 2-पृष्ठ दृश्य परिभाषा पर कुछ रखरखाव करना था जो एक बार बयान से अधिक दूर नहीं था। जाहिर है, इस दृश्य में कुछ भी बदलने के लिए व्यू डेफिनिशन पर एक रेगेक्स पाठ खोज की आवश्यकता थी, क्या एक ही उप-कथन का दूसरी पंक्ति में उपयोग किया गया था और क्या इसे वहां बदलने की आवश्यकता थी।

इसलिए, जैसा कि शीर्षक जाता है - इस तरह के घृणित लेखन को रोकने के लिए क्या तकनीकें हैं?

query  dynamic-sql  scripting 
— मार्टिन
स्रोत

जवाबों:

13

आप बहुत मामूली हैं - आपकी SQL अच्छी तरह से और संक्षिप्त रूप से उस कार्य को लिखा है जिसे आप ले रहे हैं। कुछ संकेत:

  • t1.name <> t2.nameहमेशा सच है अगर t1.name = REPLACE(t2.name, 'DUP_', '')- आप पूर्व को गिरा सकते हैं
  • आमतौर पर आप चाहते हैं union all। unionमतलब union allफिर डुप्लिकेट ड्रॉप। इस मामले में कोई फर्क नहीं पड़ सकता है लेकिन हमेशा उपयोग union allकरना एक अच्छी आदत है जब तक आप स्पष्ट रूप से किसी भी डुप्लिकेट को छोड़ना नहीं चाहते हैं।

  • यदि आप varchar के लिए कास्टिंग के बाद होने वाली संख्यात्मक तुलना के लिए तैयार हैं , तो निम्नलिखित पर विचार करने लायक हो सकता है:

    create view test_attribs_cast as 
select id, name, attr1, attr2, cast(attr3 as varchar(2000)) as attr3, 
       cast(attr4 as varchar(2000)) as attr4, attr5
from test_attribs;

create view test_attribs_unpivot as 
select id, name, 1 as attr#, attr1 as attr from test_attribs_cast union all
select id, name, 2, attr2 from test_attribs_cast union all
select id, name, 3, attr3 from test_attribs_cast union all
select id, name, 4, attr4 from test_attribs_cast union all
select id, name, 5, attr5 from test_attribs_cast;

select 'attr'||t1.attr# as different, t1.id as id_1, t2.id as id_2, t1.name, 
       t2.name as name_dup, t1.attr as val1, t2.attr as val2
from test_attribs_unpivot t1 join test_attribs_unpivot t2 on(
       t1.id<>t2.id and 
       t1.name = replace(t2.name, 'DUP_', '') and 
       t1.attr#=t2.attr# )
where t1.attr<>t2.attr or (t1.attr is null and t2.attr is not null)
      or (t1.attr is not null and t2.attr is null);

    दूसरा दृश्य एक प्रकार का unpivotऑपरेशन है - यदि आप कम से कम 11 जी पर हैं तो आप इसे अधिक संक्षिप्त रूप से unpivotक्लॉज के साथ कर सकते हैं - यहां एक उदाहरण देखें

  • मैं कह रहा हूं कि यदि आप इसे SQL में कर सकते हैं तो प्रक्रियात्मक मार्ग से नीचे न जाएं, लेकिन ...
  • परीक्षण और रखरखाव के साथ आपके द्वारा बताई गई समस्याओं के बावजूद डायनेमिक SQL शायद विचार करने योग्य है

--EDIT--

प्रश्न के अधिक सामान्य पक्ष का उत्तर देने के लिए, SQL में पुनरावृत्ति को कम करने की तकनीकें हैं, जिनमें शामिल हैं:

लेकिन आप ओओ के विचारों को सीधे SQL दुनिया में नहीं ला सकते हैं - कई मामलों में पुनरावृत्ति ठीक है यदि क्वेरी पढ़ने योग्य और अच्छी तरह से लिखी गई है, और यह केवल पुनरावृत्ति से बचने के लिए गतिशील एसक्यूएल (उदाहरण के लिए) का सहारा लेने के लिए नासमझी होगी ।

लेह के सुझाए गए बदलाव और एक दृश्य के बजाय एक सीटीई सहित अंतिम क्वेरी कुछ इस तरह दिख सकती है:

with t as ( select id, name, attr#, 
                   decode(attr#,1,attr1,2,attr2,3,attr3,4,attr4,attr5) attr
            from test_attribs
                 cross join (select rownum attr# from dual connect by rownum<=5))
select 'attr'||t1.attr# as different, t1.id as id_1, t2.id as id_2, t1.name, 
       t2.name as name_dup, t1.attr as val1, t2.attr as val2
from t t1 join test_attribs_unpivot t2 
               on( t1.id<>t2.id and 
                   t1.name = replace(t2.name, 'DUP_', '') and 
                   t1.attr#=t2.attr# )
where t1.attr<>t2.attr or (t1.attr is null and t2.attr is not null)
      or (t1.attr is not null and t2.attr is null);
— जैक डगलस
स्रोत
1
+1, आंशिक रूप से UNION ALL। अक्सर UNIONबिना ALLछांटे के परिणामस्वरूप आवश्यक भंडारण के संचालन के लिए अस्थायी भंडारण होता है (जैसा कि 'UNION' का प्रभावी रूप से UNION ALLअनुसरण किया जाता है, DISTINCTजिसका अर्थ है एक प्रकार) ताकि कुछ मामलों में प्रदर्शन अंतर बहुत बड़ा हो सके।
— डेविड स्पिललेट
7

यहां JackPDouglas (+1) द्वारा दिए गए test_attribs_unpivot दृश्य का एक विकल्प है जो 11g से पहले के संस्करणों में काम करता है और कम पूर्ण तालिका स्कैन करता है:

CREATE OR REPLACE VIEW test_attribs_unpivot AS
   SELECT ID, Name, MyRow Attr#, CAST(
      DECODE(MyRow,1,attr1,2,attr2,3,attr3,4,attr4,attr5) AS VARCHAR2(2000)) attr
   FROM TEST_ATTRIBS 
   CROSS JOIN (SELECT level MyRow FROM dual connect by level<=5);

उनकी अंतिम क्वेरी को इस दृश्य के साथ अपरिवर्तित किया जा सकता है।

— लेह रिफ़ल
स्रोत
काफी बेहतर! मुझे लगता है कि आप कलाकारों को भी गिरा सकते हैं?
— जैक डगलस
SELECT rownum MyRow FROM test_attribs where rownum<=5उपयोग के बजाय select level MyRow from dual connect by level <= 5। आप नहीं चाहते कि उन सभी तार्किकों को सिर्फ 5 पंक्तियां बनाने के लिए मिले।
— एतेफान ओरवेक
@ Ittefan ओरेवेक - मेरे पास ऐसा था, लेकिन मैंने इसे बदल दिया क्योंकि मुझे यकीन नहीं था कि किस संस्करण के लिए पदानुक्रमित प्रश्न उपलब्ध थे। चूंकि यह कम से कम 8 संस्करण के बाद से उपलब्ध है, इसलिए मैं इसे बदल दूंगा।
— लेह रिफ़ेल
4

मैं अक्सर नई, हटाई गई या परिवर्तित पंक्तियों के लिए तालिका के दो संस्करणों की तुलना करने के लिए समान समस्या का सामना करता हूं। कुछ महीने पहले मैंने यहां PowerShell का उपयोग करते हुए SQL सर्वर के लिए एक समाधान प्रकाशित किया था ।

इसे आपकी समस्या के अनुकूल बनाने के लिए, मैं पहले दो पंक्तियों से मूल को अलग करने के लिए दो विचार बनाता हूं

CREATE OR REPLACE VIEW V1_TEST_ATTRIBS AS 
select * from TEST_ATTRIBS where SUBSTR(name, 1, 4) <> 'DUP_'; 

CREATE OR REPLACE VIEW V2_TEST_ATTRIBS AS 
select id, REPLACE(name, 'DUP_', '') name, attr1, attr2, attr3, attr4, attr5 from TEST_ATTRIBS where SUBSTR(name, 1, 4) = 'DUP_';

और फिर मैं परिवर्तनों की जाँच करता हूँ

SELECT 1 SRC, NAME, ATTR1, ATTR2, ATTR3, ATTR4, ATTR5 FROM V1_TEST_ATTRIBS
MINUS
Select 1 SRC, NAME, ATTR1, ATTR2, ATTR3, ATTR4, ATTR5 from V2_TEST_ATTRIBS
UNION
SELECT 2 SRC, NAME, ATTR1, ATTR2, ATTR3, ATTR4, ATTR5 FROM V2_TEST_ATTRIBS
MINUS
SELECT 2 SRC ,NAME, ATTR1, ATTR2, ATTR3, ATTR4, ATTR5 FROM V1_TEST_ATTRIBS
ORDER BY NAME, SRC;

यहां से मैं आपकी मूल आईडी पा सकता हूं

Select NVL(v1.id, v2.id) id,  t.name, t.attr1, t.attr2, t.attr3, t.attr4, t.attr5 from
(
SELECT 1 SRC, NAME, ATTR1, ATTR2, ATTR3, ATTR4, ATTR5 FROM V1_TEST_ATTRIBS
MINUS
Select 1 SRC, NAME, ATTR1, ATTR2, ATTR3, ATTR4, ATTR5 from V2_TEST_ATTRIBS
UNION
SELECT 2 SRC, NAME, ATTR1, ATTR2, ATTR3, ATTR4, ATTR5 FROM V2_TEST_ATTRIBS
MINUS
Select 2 SRC ,NAME, ATTR1, ATTR2, ATTR3, ATTR4, ATTR5 from V1_TEST_ATTRIBS
) t
LEFT JOIN V1_TEST_ATTRIBS V1 ON T.NAME = V1.NAME AND T.SRC = 1
LEFT JOIN V2_TEST_ATTRIBS V2 ON T.NAME = V2.NAME AND T.SRC = 2
ORDER by NAME, SRC;

BTW: MINUS और यूनिअन और ग्रुप अलग-अलग NULL के समान व्यवहार करते हैं। इन परिचालनों का उपयोग करके प्रश्नों को और अधिक सुंदर बना दिया जाता है।

SQL सर्वर उपयोगकर्ताओं के लिए संकेत: MINUS को वहां EXCEPT नाम दिया गया है, लेकिन समान काम करता है।

— bernd_k
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.