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 im Standardmodus für erzwungene Integrität verwendet werden.

Logical Partition Change Tracking (LPCT) bietet die Möglichkeit, die vom Benutzer bereitgestellten logischen Partitionierungsinformationen von Basistabellen einer Materialized View für eine feiner granulierte Verfolgung veralteter Daten auf Partitionsebene sowohl für Aktualisierungs- als auch für Neuschreibzwecke zu nutzen. Während das klassische Partitionierungs-Änderungs-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 nicht partitionierten Tabellen verwendet werden.

Der Mechanismus zur Verfolgung logischer Partitionsänderungen verwendet die FRESH-Untergruppen (Partitionen) von Materialized Views, obwohl andere Untergruppen STALE sind. Für Benutzerabfragen können schnellere Antwortzeiten erzielt werden, da vorberechnete Ergebnisse in Materialized Views häufiger verwendet werden. Abgesehen von der Erhöhung der Benutzerfreundlichkeit von Materialized Views ermöglichen 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 für erweiterte Materialized Views.

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

Die Syntax zur Erstellung von 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, sodass Sie Ihre Anforderungen flexibler erfüllen können. LPCT-Erstellung ist nur Metadaten.

• Logische Partitionen erstellen - BNF
  Beschreibt die Syntax zum Erstellen logischer BNF-Partitionen.
• Logische Partitionsschlüsselspalte auswählen
  Der logische Partitionierungsschlüssel wird zur Definition der Grenzen jeder logischen Partition angegeben.
• Freshness of Materialized Views Using Logical Partition Change Tracking
  Der Logical Partition Change Tracking-(LPCT-)Veralterungsverfolgungsmechanismus erfasst und konsolidiert die Änderungsstatistiken bei jeder Datenänderung automatisch intern basierend auf dem angegebenen logischen Partitionsschlüssel und der angegebenen Partitionierungsmethode.
• Mit Materialized Views mit logischem Partitionsänderungs-Tracking neu schreiben
  Mit Logical Partition Change Tracking (LPCT) weiß Oracle, dass eine Materialized View in Bezug auf einige logische Partitionen der Basistabelle STALE ist, in Bezug auf andere Teile jedoch FRESH.
• Aktualisieren von Materialized Views mit logischem Partitionsänderungs-Tracking
  Die Aktualisierung des logischen Partitionsänderungs-Trackings (LPCT) kann mit der feiner granulierten Datenalterung implementiert werden, um STALE-Teilmengen einer Materialized View inkrementell zu aktualisieren. Dadurch entfallen kostspielige vollständige Aktualisierungen oder logbasierte Fast Refreshes.
• Logisches Partitionsänderungs-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 Change Partitionen 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. Fügen Sie Datensätze in die Tabelle MYSALES ein.

      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. Erstellen Sie das Tracking der logischen Partition für die Tabelle MYSALES.

      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. Fügen Sie Datensätze in die Tabelle MYCUSTOMERS ein.

      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. Erstellen Sie das Tracking der logischen Partition für die Tabelle MYCUSTOMERS.

      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 mit dem Change Tracking der logischen Partition eine Materialized View über Tabellen.
   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;

      Zeigt die folgende Ausgabe an.

      
      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 Funktionen zum Aktualisieren und Umschreiben der logischen Partition 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;

      Zeigt die folgende Ausgabe an.

      
      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 in der 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 in der 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 in der Tabelle MYCUSTOMERS ein.

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

      Dadurch wird eine neue Partition (Partition Nr. 3) in der Tabelle MYCUSTOMERS eingeführt.
   4. Führen Sie eine neue logische Partition in der 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 in der 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 Nr. 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-Umschreibungen auf 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 Umschreiben 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. Nutzen Sie LPCT für die inkrementelle Aktualisierung.
   1. Führen Sie den folgenden Code aus, um die LPCT-Aktualisierung durchzufü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;