विशाल विभाजित तालिका में डेटा लोड

यह काम।

क्या आपके पास ऑनलाइन क्वेरी, या देर से पहुंचने वाले डेटा (उदाहरण के लिए, क्या आप आज/कल की तुलना में आज किसी भी दिन के लिए एक पंक्ति प्राप्त कर सकते हैं) के लिए स्टेजिंग क्षेत्र तक पहुंच बनाने की चुनौती है?

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

मेरी तालिका श्रेणी/सूची है, श्रेणी/हैश नहीं। तो आपको इसे कुछ संशोधित करना होगा, शायद सही उप-विभाजन खोजने के लिए ORA_HASH फ़ंक्शन का उपयोग करना। मैं एक टेबल को भी लिखता हूं, जिन उप-विभाजनों को मैं अनुपयोगी के रूप में चिह्नित करने जा रहा हूं, इसलिए मैं वह सब एक ही पास में कर सकता हूं। एकल ALTER TABLE स्टेटमेंट में सभी सबपार्टिशन के इंडेक्स को अनुपयोगी के रूप में चिह्नित करना थोड़ा अधिक कुशल हो सकता है; मैं मूल रूप से केवल बिटमैप इंडेक्स को अक्षम कर रहा था, लेकिन डेटा लोड के दौरान एक भी बी * ट्री इंडेक्स ऑफ़लाइन होने से भी दक्षता में काफी सुधार हुआ।

  procedure DISABLE_LOCAL_INDEXES as
     l_part_name varchar2(30);
     l_subpart_name varchar2(30);
     l_sql varchar2(2000);
     type partition_rec_type is record
     (table_name         varchar2(30),
      partition_name     varchar2(30),
      subpartition_name  varchar2(30),
      list_value         varchar2(10),
      min_ts             timestamp,
      max_ts             timestamp);
     type partition_recs_type
                         is table of partition_rec_type;
     l_partition_recs    partition_recs_type := partition_recs_type();
     l_partition_rec     partition_rec_type;
     l_subpart_id        number := 1;
     l_start_ts          timestamp;
     l_end_ts            timestamp;
     l_found_list_part boolean;
   begin
     -- build set of subpartitions
     l_start_ts := to_timestamp ('1970-01-01', 'yyyy-mm-dd');
     for i in (select p.table_name, p.partition_name, sp.subpartition_name,
                      p.high_value as part_high_value, 
                      sp.high_value as subpart_high_value,
                      p.partition_position, sp.subpartition_position
                 from user_tab_subpartitions sp
                      inner join user_tab_partitions p
                         on p.table_name     = sp.table_name
                        and p.partition_name = sp.partition_name
                where p.table_name = 'MY_TARGET_TABLE'
                order by p.partition_position, sp.subpartition_position)
     loop
       if ( (i.partition_position <> 1) and (i.subpartition_position = 1) ) then
         l_start_ts    := l_end_ts + to_dsinterval('0 00:00:00.000000001');
       end if;
       if (i.subpartition_position = 1) then
         l_end_ts := high_val_to_ts (i.part_high_value);
         l_end_ts := l_end_ts - to_dsinterval('0 00:00:00.000000001');
       end if;
       l_partition_rec.table_name        := i.table_name;
       l_partition_rec.partition_name    := i.partition_name;
       l_partition_rec.subpartition_name := i.subpartition_name;
       l_partition_rec.list_value        := i.subpart_high_value;
       l_partition_rec.min_ts            := l_start_ts;
       l_partition_rec.max_ts            := l_end_ts;
       l_partition_recs.extend();
       l_partition_recs(l_subpart_id) := l_partition_rec;
       l_subpart_id := l_subpart_id + 1;
     end loop;
     -- for every combination of list column and date column
     -- which is going to be pushed to MY_TARGET_TABLE
     -- find the subpartition
     -- otherwise find the partition and default subpartition
     for i in (select distinct LIST_COLUMN, DATE_COLUMN as DATE_VALUE
                 from MY_SOURCE_TABLE
                where IT_IS_BEING_MOVED_TO_TARGET IS TRUE)
     loop
       -- iterate over the partitions
       l_found_list_part := false;
       for k in l_partition_recs.first..l_partition_recs.last
       loop
         -- find the right partition / subpartition for list_value / date_value
         if (    (i.DATE_VALUE >= l_partition_recs(k).min_ts)
             and (i.DATE_VALUE <= l_partition_recs(k).max_ts) ) then
           if (l_found_list_value = false) then
             if (to_char(i.LIST_COLUMN, '9999') = l_partition_recs(k).LIST_COLUMN) then
               l_found_list_value := true;
             elsif (l_partition_recs(k).LIST_COLUMN = 'DEFAULT') then
               l_partition_rec := l_partition_recs(k);
             end if;
           end if;
         end if;
       end loop;  -- over l_partition_recs
       -- log those partitions for later index rebuild
       begin
         insert into index_subpart_rebuild
           (table_name, partition_name, subpartition_name)
         values
           (l_partition_rec.table_name, l_partition_rec.partition_name,
            l_partition_rec.subpartition_name);
       exception
         when dup_val_on_index then null;
         when others then raise;
       end;
     end loop;  -- over MY_TARGET_TABLE.DATE_VALUE values
     commit;
     for i in (select ui.index_name, uis.subpartition_name
                 from user_indexes ui
                      inner join user_ind_subpartitions uis
                         on ui.index_name = uis.index_name
                      inner join index_subpart_rebuild re
                         on re.subpartition_name = uis.subpartition_name
                where ui.table_name = 'MY_TARGET_TABLE')
     loop
       l_sql := 'alter index ' || i.index_name ||
                ' modify subpartition ' || i.subpartition_name || ' unusable';
       execute immediate l_sql;
     end loop;
   end DISABLE_LOCAL_INDEXES;