एक कमजोर टाइप किए गए SYS_REFCURSOR चर के% ROWTYPE को कैसे घोषित करें?

संक्षिप्त उत्तर है, आप नहीं कर सकते। आपको प्रत्येक कॉलम के लिए एक वैरिएबल परिभाषित करना होगा जो लौटाया जाएगा।

DECLARE
    P_RS SYS_REFCURSOR;
    L_T_COL1 T.COL1%TYPE;
    L_T_COL1 T.COL2%TYPE;
    ...

और फिर कॉलम की सूची में लाएं:

FETCH P_RS INTO L_T_COL1, L_T_COL2, ... ;

यह दर्दनाक है लेकिन प्रबंधनीय है जब तक आप जानते हैं कि आप रेफ कर्सर में क्या उम्मीद कर रहे हैं। T.* . का उपयोग करना आपकी प्रक्रिया में यह नाजुक हो जाता है, हालांकि तालिका में एक कॉलम जोड़ने से वह कोड टूट जाएगा जो सोचता है कि यह जानता है कि कौन से कॉलम हैं और वे किस क्रम में हैं। (यदि टेबल नहीं बने हैं तो आप इसे वातावरण के बीच भी तोड़ सकते हैं) लगातार - मैंने ऐसे स्थान देखे हैं जहां अलग-अलग वातावरण में कॉलम ऑर्डरिंग अलग है)। आप शायद यह सुनिश्चित करना चाहेंगे कि आप वैसे भी केवल उन स्तंभों का चयन कर रहे हैं जिनकी आप वास्तव में परवाह करते हैं, उन चीज़ों के लिए चर परिभाषित करने से बचने के लिए जिन्हें आप कभी नहीं पढ़ेंगे।

11g से आप DBMS_SQL का उपयोग कर सकते हैं अपने sys_refcursor . को बदलने के लिए पैकेज एक DBMS_SQL . में कर्सर, और आप पूछताछ कर सकते हैं कि कॉलम निर्धारित करने के लिए। आप क्या कर सकते हैं इसका एक उदाहरण के रूप में, यह कॉलम नाम के साथ प्रत्येक पंक्ति में प्रत्येक कॉलम का मान प्रिंट करेगा:

DECLARE
    P_RS SYS_REFCURSOR;
    L_COLS NUMBER;
    L_DESC DBMS_SQL.DESC_TAB;
    L_CURS INTEGER;
    L_VARCHAR VARCHAR2(4000);
BEGIN
    CAPITALEXTRACT(P_RS => P_RS);
    L_CURS := DBMS_SQL.TO_CURSOR_NUMBER(P_RS);
    DBMS_SQL.DESCRIBE_COLUMNS(C => L_CURS, COL_CNT => L_COLS,
        DESC_T => L_DESC);

    FOR i IN 1..L_COLS LOOP
        DBMS_SQL.DEFINE_COLUMN(L_CURS, i, L_VARCHAR, 4000);
    END LOOP;

    WHILE DBMS_SQL.FETCH_ROWS(L_CURS) > 0 LOOP
        FOR i IN 1..L_COLS LOOP
            DBMS_SQL.COLUMN_VALUE(L_CURS, i, L_VARCHAR);
            DBMS_OUTPUT.PUT_LINE('Row ' || DBMS_SQL.LAST_ROW_COUNT
                || ': ' || l_desc(i).col_name
                || ' = ' || L_VARCHAR);
        END LOOP;
    END LOOP;

    DBMS_SQL.CLOSE_CURSOR(L_CURS);
END;
/

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

यदि आप अपने रेफरी कर्सर से केवल कुछ कॉलम चाहते हैं, तो मुझे लगता है, l_desc के आसपास लूप करें और उस स्थिति को रिकॉर्ड करें जहां column_name आप जिस चीज में रुचि रखते हैं, वह एक संख्यात्मक चर के रूप में है; आप बाद में उस वेरिएबल द्वारा कॉलम को संदर्भित कर सकते हैं जहां आप सामान्य रूप से कर्सर लूप में नाम का उपयोग करेंगे। निर्भर करता है कि आप डेटा के साथ क्या कर रहे हैं।

लेकिन जब तक आप उम्मीद कर रहे हों आप जिस कॉलम ऑर्डर को वापस प्राप्त कर रहे हैं उसे नहीं जानने के लिए, जो कि संभावना नहीं है क्योंकि आप प्रक्रिया को नियंत्रित करते हैं - और यह मानते हुए कि आप .* s - आप शायद लौटाए गए कॉलम को कम से कम अपनी आवश्यकता के अनुसार कम करने और उन सभी को अलग-अलग घोषित करने से बेहतर हैं।