Wenn eine oder mehrere abhängige Basistabellen einer Materialized View aktualisiert werden, wird eine Materialized View zu STALE und kann nicht für das Umschreiben von Abfragen unter dem standardmäßig erzwungenen Integritätsmodus verwendet werden.

Logical Partition Change Tracking (LPCT) bietet die Möglichkeit, die vom Benutzer bereitgestellten logischen Partitionierungsinformationen von Basistabellen einer Materialized View für ein feiner granuliertes Tracking auf Partitionsebene veralteter Daten sowohl für Aktualisierungs- als auch für Rewrite-Zwecke zu nutzen. Während das klassische Partitioning Change Tracking (PCT) auf der physischen Partitionierung von Tabellen basiert, ist LPCT nicht von Tabellen abhängig, die physisch partitioniert werden. LPCT kann sowohl mit partitionierten als auch mit nicht partitionierten Tabellen verwendet werden.

Das Logical Partition Change Tracking-Verfahren verwendet die FRESH-Teilmengen (Partitionen) von Materialized Views, obwohl andere Teilmengen STALE sind. Schnellere Antwortzeiten können für Benutzerabfragen erreicht werden, da vorab berechnete Ergebnisse in Materialized Views häufiger verwendet werden. Neben der Erhöhung der Benutzerfreundlichkeit von Materialized Views ermöglicht PCT und LPCT auch die inkrementelle Aktualisierung der Materialized Views, ohne dass Materialized View-Logs erforderlich sind. Die Aktualisierung kann sowohl ON DEMAND als auch ON COMMIT sein.

Ähnlich wie Partitioning Change Tracking (PCT) ist Logical Partition Change Tracking (LPCT) mit einer Basistabelle verknüpft und kann die Zeilen in einer Materialized View, die von Datenänderungen in der Basistabelle betroffen sind, entsprechend den definierten logischen Partitionsgrenzen genau identifizieren.

Weitere Informationen finden Sie unter Erweiterte Materialized Views.

Logical Partition Change Tracking (LPCT) partitioniert eine Tabelle logisch mit einer angegebenen Schlüsselspalte und -methode.

Die Syntax für das Erstellen des Logical Partition Change Tracking ist analog zu physischen Partitionen. Im Gegensatz zu physischen Partitionen, die im Rahmen der Tabellenerstellung erstellt werden müssen, kann LPCT unabhängig von der Tabellenerstellung und ihrer Form frei spezifiziert werden, was mehr Flexibilität ermöglicht, Ihre Anforderungen zu erfüllen. LPCT-Erstellung ist nur Metadaten.

• Logische Partitionen erstellen - BNF
  Beschreibt die Syntax zum Erstellen logischer BNF-Partitionen.
• Wählen der logischen Partitionsschlüsselspalte
  Der logische Partitionierungsschlüssel wird angegeben, um die Grenzen jeder logischen Partition zu definieren.
• Aktualität von Materialized Views mit Tracking von logischen Partitionsänderungen
  Der Tracking-Mechanismus für das Veralten von logischen Partitionsänderungen (Logical Partition Change Tracking, LPCT) zeichnet die Änderungsstatistiken automatisch auf und konsolidiert sie intern basierend auf dem angegebenen logischen Partitionsschlüssel und der Partitionierungsmethode während jeder Datenänderung.
• Mit Materialized Views mit Logical Partition Change Tracking umschreiben
  Mit Logical Partition Change Tracking (LPCT) weiß Oracle, dass eine Materialized View in Bezug auf einige logische Partitionen der Basistabelle STALE, aber in Bezug auf andere Teile FRESH ist.
• Aktualisieren von Materialized Views mit logischem Partitionsänderungs-Tracking
  Logisches Partitionsänderungs-Tracking (LPCT) kann mit dem feiner granulierten Daten-Staleness implementiert werden, um STALE Teilmengen einer Materialized View inkrementell zu aktualisieren. Dadurch entfällt eine kostspielige vollständige Aktualisierung oder ein logbasiertes Fast Refresh.
• Logical Partition Change Tracking – Data Dictionary Views
  Beschreibt die Data Dictionary Views, um Informationen zu logischen Partitionen zu finden.

Zeigt die Schritte zur Verwendung von Logical Partition Change Tracking (LPCT) mit einer Materialized View an, die Joins und Aggregate enthält.

1. Basistabellen mit logischen Änderungspartitionen erstellen
   1. Erstellen Sie die Tabelle MYSALES.

      CREATE TABLE mysales ( time_id DATE, prod_id NUMBER, cust_id NUMBER, channel_id CHAR(1), promo_id NUMBER(6), quantity_sold
            NUMBER(3), amount_sold NUMBER(10,2))    
            PARTITION BY LIST (prod_id) 
            (PARTITION p1 VALUES (1,2,3),
            PARTITION p2 VALUES (4,5,6),
            PARTITION p3 VALUES (7,8,9),
            PARTITION p4 VALUES(DEFAULT));

      Dadurch wird die Tabelle MYSALES erstellt.

   2. Datensätze in die Tabelle MYSALES einfügen.

      INSERT INTO mysales (time_id, prod_id, cust_id, amount_sold) VALUES (TO_DATE('2007-06-05','yyyy-mm-dd'), 1, 2088, 189.98);
      INSERT INTO mysales (time_id, prod_id, cust_id, amount_sold) VALUES (TO_DATE('2007-07-05','yyyy-mm-dd'), 2, 1354, 12.99);
      INSERT INTO mysales (time_id, prod_id, cust_id, amount_sold) VALUES (TO_DATE('2007-09-05','yyyy-mm-dd'), 5, 2088, 189.98);
      INSERT INTO mysales (time_id, prod_id, cust_id, amount_sold) VALUES (TO_DATE('2007-10-05','yyyy-mm-dd'), 18, 2088, 42);
      COMMIT;

      Dadurch wird die Tabelle MYSALES aufgefüllt.
   3. Logisches Partitionstracking für die Tabelle MYSALES erstellen.

      CREATE LOGICAL PARTITION TRACKING ON mysales
        PARTITION BY RANGE (time_id)
        INTERVAL(NUMTOYMINTERVAL(2, 'YEAR'))
        (
         PARTITION p0 VALUES LESS THAN (TO_DATE('7-15-2005', 'MM-DD-YYYY')),
         PARTITION p1 VALUES LESS THAN (TO_DATE('7-15-2007', 'MM-DD-YYYY'))
        );

      Dadurch wird ein logisches Partitionstracking für die Tabelle MYSALES mit dem Schlüssel TIME_ID erstellt.
   4. Erstellen Sie die Tabelle MYCUSTOMERS.

      CREATE TABLE mycustomers (cust_id NUMBER, age NUMBER, gender CHAR(1), address VARCHAR(100));

      Dadurch wird die Tabelle MYCUSTOMERS erstellt.
   5. Datensätze in die Tabelle MYCUSTOMERS einfügen.

      INSERT INTO mycustomers(cust_id, age, gender) VALUES (2088, 35, 'F');
      INSERT INTO mycustomers(cust_id, age, gender) VALUES (1234, 54, 'M');
      INSERT INTO mycustomers(cust_id, age, gender) VALUES (1354, 17, 'F');
      INSERT INTO mycustomers(cust_id, age, gender) VALUES (6666, 15, 'F');
      COMMIT;

      Dadurch wird die Tabelle MYCUSTOMERS aufgefüllt.
   6. Logisches Partitionstracking für die Tabelle MYCUSTOMERS erstellen.

      CREATE LOGICAL PARTITION TRACKING ON mycustomers
       PARTITION BY RANGE (age) INTERVAL (20.5)
       (PARTITION m0 values less than (20));

      Dadurch wird ein logisches Partitionstracking für die Tabelle MYSALES mit dem Schlüssel AGE erstellt.
2. Erstellen Sie eine Materialized View über Tabellen mit logischem Partition Change Tracking.
   1. Erstellen Sie eine Materialized View für die Tabellen MYSALES und MYCUSTOMERS.

      CREATE MATERIALIZED VIEW sales_age_time
       REFRESH FAST
       ENABLE QUERY REWRITE
       AS SELECT SUM(s.amount_sold) amount_total, c.age, s.time_id
       FROM mysales s, mycustomers c
       WHERE s.cust_id = c.cust_id
       GROUP BY c.age, s.time_id;

      Dadurch wird die Materialized View SALES_AGE_TIME erstellt.
   2. Fragen Sie die Data Dictionary View DBA_MVIEW_DETAIL_LOGICAL_PARTITION ab.

      SELECT mview_name, DETAILOBJ_NAME, DETAIL_LOGICAL_PARTITION_NAME LPARTNAME,
       DETAIL_LOGICAL_PARTITION_NUMBER LPART#, FRESHNESS
       FROM DBA_MVIEW_DETAIL_LOGICAL_PARTITION 
       WHERE mview_name = 'SALES_AGE_TIME' 
       ORDER BY 1,2,3;

      Es wird die folgende Ausgabe angezeigt.

      
      MVIEW_NAME        DETAILOBJ_NAME     LPARTNAME      LPART#      FRESHNESS
      ---------------   ---------------    ----------     ----------  ---------
      SALES_AGE_TIME    MYCUSTOMERS        M0             0 	      FRESH
      SALES_AGE_TIME    MYSALES            P0             0 	      FRESH
      SALES_AGE_TIME    MYSALES            P1             1 	      FRESH
      

   3. Verwenden Sie EXPLAIN_MVIEW, um die logischen Partitionsbezogenen Aktualisierungs- und Rewrite-Funktionen zu bewerten.

      EXECUTE DBMS_MVIEW.EXPLAIN_MVIEW ('sales_age_time');
      
      SELECT CAPABILITY_NAME, RELATED_TEXT, POSSIBLE
      FROM MV_CAPABILITIES_TABLE
      WHERE MVNAME = 'SALES_AGE_TIME' AND CAPABILITY_NAME LIKE '%LPT%'
      ORDER BY 1, 2;

      Es wird die folgende Ausgabe angezeigt.

      
      CAPABILITY_NAME               RELATED_TEXT                 POSSIBLE
      -------------------------     -------------------------    –--------------
      LPT                                                         Y
      LPT_TABLE                     MYCUSTOMERS                   Y
      LPT_TABLE                     MYSALES                       Y
      LPT_TABLE_REWRITE             MYCUSTOMERS                   Y
      LPT_TABLE_REWRITE             MYSALES                       Y
      REWRITE_LPT                                                 Y
      REFRESH_FAST_LPT                                            Y
      

3. Beobachten Sie die Auswirkungen von DMLs auf Ihre Materialized View.
   1. Führen Sie eine neue logische Partition für die Tabelle MYSALES ein.

      INSERT INTO mysales (time_id, prod_id, cust_id, amount_sold) VALUES
            (TO_DATE('2019-02-05','yyyy-mm-dd'), 99, 2108, 33);

      Dadurch wird eine neue Partition (Partition 6) in der Tabelle MYSALES eingeführt.
   2. Führen Sie eine neue logische Partition für die Tabelle MYSALES ein.

      INSERT INTO mysales (time_id, prod_id, cust_id, amount_sold) VALUES (TO_DATE('2019-02-05','yyyy-mm-dd'), 99, 2108, 33);

      Dadurch wird eine neue Partition (Partition 6) in der Tabelle MYSALES eingeführt.
   3. Führen Sie eine neue logische Partition für die Tabelle MYCUSTOMERS ein.

      INSERT INTO mycustomers(cust_id, age, gender) VALUES (1399, 80, 'F');

      Dadurch wird eine neue Partition (Partition 3) in der Tabelle MYCUSTOMERS eingeführt.
   4. Führen Sie eine neue logische Partition für die Tabelle MYSALES ein.

      INSERT INTO mysales (time_id, prod_id, cust_id, amount_sold) VALUES (TO_DATE('2019-02-09','yyyy-mm-dd'), 99, 1997, 79.9);

      Dadurch wird eine neue Partition (Partition 7) in der Tabelle MYSALES eingeführt.
   5. Führen Sie eine neue logische Partition für die Tabelle MYSALES ein.

      INSERT INTO mysales (time_id, prod_id, cust_id, amount_sold) VALUES (TO_DATE('2010-02-09','yyyy-mm-dd'), 110, 1997, 108.98);
      COMMIT;

      Dadurch wird eine neue Partition (Partition 2) in der Tabelle MYSALES eingeführt.
   6. Fragen Sie die Data Dictionary View DBA_MVIEW_DETAIL_LOGICAL_PARTITION ab.

      SELECT mview_name, DETAILOBJ_NAME, DETAIL_LOGICAL_PARTITION_NAME LPARTNAME,
       DETAIL_LOGICAL_PARTITION_NUMBER LPART#, FRESHNESS
       FROM DBA_MVIEW_DETAIL_LOGICAL_PARTITION 
       WHERE mview_name = 'SALES_AGE_TIME' 
       ORDER BY 1,2,3;

      Nun wird die folgende Ausgabe angezeigt.

      
      MVIEW_NAME        DETAILOBJ_NAME     LPARTNAME      LPART#      FRESHNESS
      ---------------   ---------------    ----------     ----------  ---------
      SALES_AGE_TIME    MYCUSTOMERS        M0             0             FRESH
      SALES_AGE_TIME    MYCUSTOMERS        SYS_88904P3    3             STALE
      SALES_AGE_TIME    MYSALES            P1             0             FRESH
      SALES_AGE_TIME    MYSALES            P1             1             FRESH
      SALES_AGE_TIME    MYSALES            SYS_88899P3    2             STALE
      SALES_AGE_TIME    MYSALES            SYS_88899P7    6             STALE
      

   7. Führen Sie LPCT-Neuschreibungen für Teilmenge von lpart #1 in MYSALES und lpart #0 in den MYCUSTOMERS-Tabellen durch.

      DELETE FROM rewrite_table;
      DECLARE    
       stmt varchar2(2000) := q'#select sum(s.amount_sold) amount_total,
       c.age, s.time_id
       FROM mysales s, mycustomers c
       WHERE s.cust_id = c.cust_id
       AND s.time_id < TO_DATE ('07-07-2007', 'MM-DD-YYYY')
       AND c.age < 18
       GROUP BY c.age, s.time_id#';
      BEGIN 
       dbms_mview.explain_rewrite (stmt,'sales_age_time');
      END;
      /
      SELECT mv_name, sequence, pass, message FROM rewrite_table;

   8. Fragen Sie REWRITE_TABLE ab, um die Neuschreibungen zu prüfen.

      SELECT mv_name, sequence, pass, message FROM rewrite_table;

   9. Führen Sie die folgende Abfrage aus.

      SELECT SUM(s.amount_sold) amount_total,
       c.age, s.time_id
       FROM mysales s, mycustomers c
       WHERE s.cust_id = c.cust_id
       AND s.time_id < TO_DATE ('07-07-2007', 'MM-DD-YYYY')
       AND c.age < 18
       GROUP BY c.age, s.time_id;

   10. Zeigen Sie den Explain-Plan für die obige Abfrage an, um die Neuschreibungen zu prüfen.

       SELECT * FROM TABLE(dbms_xplan.display_cursor);

       PLAN_TABLE_OUTPUT
       __________________________________________________
       SQL_ID  ampuzk8tbp6df, child number 0
       -------------------------------------
       SELECT SUM(s.amount_sold) amount_total,
       c.age, s.time_id
       FROM mysales s, mycustomers c
       WHERE s.cust_id = c.cust_id
       AND s.time_id < TO_DATE ('07-07-2007', 'MM-DD-YYYY')
       AND c.age < 18
       GROUP BY c.age, s.time_id;
       
       Plan hash
               value: 3902795718 
               -----------------------------------------------------------------------------------------------
               | Id  | Operation                    | Name           | Rows  | Bytes | Cost
               (%CPU)| Time     
               |-----------------------------------------------------------------------------------------------
               |   0 | SELECT STATEMENT             |                |      
                 |       |     2 (100)|         
               ||*  1 |  MAT_VIEW
               REWRITE ACCESS FULL| SALES_AGE_TIME |     1 |    35 |    
                 2   (0)| 00:00:01 
               |----------------------------------------------------------------------------------------------- 
               Predicate Information (identified by operation id):
               ---------------------------------------------------    
               1 - filter(("SALES_AGE_TIME"."TIME_ID"<TO_DATE('2007-07-07 00:00:00', 'syyyy-mm-dd hh24:mi:ss') AND "SALES_AGE_TIME"."AGE"<18)) 
       Note
       -----   
          - dynamic statistics used: dynamic sampling (level=2)  
       26 rows selected.

4. LPCT für inkrementelle Aktualisierung nutzen
   1. Führen Sie den folgenden Code aus, um die LPCT-Aktualisierung auszuführen.

      EXECUTE DBMS_MVIEW.REFRESH('SALES_AGE_TIME', 'L');

   2. Prüfen Sie die Aktualisierung mit der folgenden Abfrage.

      SELECT mview_name, DETAILOBJ_NAME, DETAIL_LOGICAL_PARTITION_NAME LPARTNAME, DETAIL_LOGICAL_PARTITION_NUMBER LPART#, FRESHNESS 
       FROM DBA_MVIEW_DETAIL_LOGICAL_PARTITION
       WHERE mview_name = 'SALES_AGE_TIME' 
       ORDER BY 1,2,3;