Oracle Cloud Infrastructure-Dokumentation

Änderungsverfolgung für logische Partitionen und Materialized Views

Beschreibt Informationen zum Logical Partition Change Tracking-(LPCT-)Metadaten-Framework und Query Rewrite mit Logical Partition Change Tracking in Autonomous Database.

Übergeordnetes Thema: Autonomous Database für erfahrene Oracle Database-Benutzer

Logische Partitionsänderungsverfolgung

Logical Partition Change Tracking (LPCT) verfolgt die Veralterung von Materialized Views.

Mit dem Logical Partition Change Tracking können Sie logische Partitionen für Basistabellen erstellen. Es wertet die Veralterung der Basistabellen für einzelne logische Partitionen aus, ohne ein Materialized View Log zu verwenden oder eine der Tabellen, die in der Materialized View verwendet werden, zu partitionieren.

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.

Änderungsverfolgung für logische Partitionen verwenden

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.

Übergeordnetes Thema: Tracking für logische Partitionen und Materialized Views

Logische Partitionen erstellen - BNF

Beschreibt die Syntax zum Erstellen logischer BNF-Partitionen.

Die Syntax zum Erstellen logischer BNF-Partitionen lautet wie folgt:

CREATE LOGICAL PARTITION TRACKING ON table_name
    PARTITION BY RANGE (partition_key)
    INTERVAL (interval_clause)
    (partition_specification);
  • Nur logische Partitionierungsmethoden RANGE und INTERVAL werden unterstützt.
  • Es wird nur eine einzelne logische Partitionsschlüsselspalte unterstützt.
  • Die Partitionsschlüsselspalte kann folgende Datentypen aufweisen:
    • NUMBER
    • DATE
    • CHAR
    • VARCHAR
    • VARCHAR2
    • TIMESTAMP
    • TIMESTAMP WITH TIME ZONE

Logische Partitionsschlüsselspalten auswählen

Der logische Partitionierungsschlüssel wird angegeben, um die Grenzen jeder logischen Partition zu definieren.

Der logische Partitionsschlüssel ist nicht physisch. Das bedeutet, dass Tabellenzeilen, die zu einem Schlüsselbereich gehören, nicht in eine separate physische Partition getrennt sind. Die Tabelle kann für einen anderen Schlüssel als den logischen Partitionsschlüssel nicht partitioniert oder partitioniert sein. Der logische Partitionsschlüssel kann frei gewählt und Partitionsgrenzen flexibel gestaltet werden.

Um eine Schlüsselspalte für das Logical Partition Change Tracking (LPCT) auszuwählen, können Sie eine geclusterte Spalte berücksichtigen, d.h. eine Spalte, in der Daten fast nach Spaltenwert sortiert sind, die häufig in den Abfragefilterprädikaten referenziert werden. Bei einer geclusterten Spalte sind beim Laden von Daten wahrscheinlich weniger logische Partitionen betroffen. Das bedeutet, dass weniger logische STALE-Partitionen aktualisiert werden müssen und mehr logische FRESH-Partitionen für das Neuschreiben bereit sind. Wenn eine Tabelle bereits partitioniert ist, wird empfohlen, einen LPCT mit einer anderen Spalte als der Partitionsschlüsselspalte zu erstellen. LPCT bietet ähnliche Vorteile wie Partitioning Change Tracking (PCT), und die kombinierten Vorteile werden nicht maximiert, wenn die Datenverfolgung in derselben Spalte erfolgt.

Aktualität von Materialized Views mit Logical Partition Change Tracking

Der Tracking-Mechanismus für veraltete logische 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 bei jeder Datenänderung.

Angrenzende Änderungsdaten werden in einer "logischen" Partition gruppiert. Anders als bei Partitioning Change Tracking (PCT), das an physische Partitionsgrenzen gebunden ist, bietet das LPCT-Schema Flexibilität bei der Verwaltung und Gruppierung der Datenänderungen, die sich aus auf die Basistabelle angewendeten DMLs ergeben.

Bei herkömmlichen DMLs und Direct-Loads verwendet LPCT den gleichen Algorithmus, mit dem PCT die Veralterung verfolgt. Während des Umschreibens von Abfragen verwendet LPCT denselben Algorithmus, mit dem PCT das Umschreibeinhalt berechnet.

Wenn eine Tabelle anhand von Schlüsselbereichen logisch partitioniert wird, kann eine in der Tabelle definierte Materialized View LPCT für das Veralten von Tracking, Refresh und Query Rewrite verwenden, vorausgesetzt, die Materialized View enthält den logischen Partitionsschlüssel.

Hinweis

Alle Typen von Materialized Views werden für LPCT unterstützt.

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.

Mit den feiner granulierten Datenveralterungsinformationen der Basistabellen würde die zugehörige Materialized View aufgrund von LPCT-Rewrite häufiger verwendet.

Oracle identifiziert und nutzt die Teilmenge FRESH der Materialized Views für das Umschreiben von Abfragen transparent, um komplizierte Abfragen von Basistabellen zu beantworten, wenn QUERY_REWRITE_INTEGRITY = ENFORCED |TRUSTED.

Wenn die Materialized View-Zeilen in Bezug auf diese logischen Partitionen teilweise FRESH sind, kann ein partielles Umschreiben stattfinden, um die Abfrage teilweise mit der Materialized View zu beantworten, d.h. mit logischen FRESH-Partitionen und teilweise mit der Basistabelle, d.h. den logischen STALE-Partitionen.

Materialized Views mit Logical Partition Change Tracking aktualisieren

Die Aktualisierung von Logical Partition Change Tracking (LPCT) kann mit der feiner granulierten Datenveralterung implementiert werden, um STALE-Teilmengen einer Materialized View schrittweise zu aktualisieren. Dadurch entfällt eine kostspielige vollständige Aktualisierung oder eine logbasierte Fast Refresh-Funktion.

Wenn eine LPCT-Aktualisierung angegeben wird, werden die logischen STALE-Partitionen identifiziert, und Zielaktualisierungsvorgänge werden nur für diese logischen Partitionen ausgeführt.

Um die Aktualisierung mithilfe des logischen Partitionsänderungstrackings aufzurufen, geben Sie ‘L’ oder ‘l’ ("logisch") als Aktualisierungsmethode an.

Beispiel: execute DBMS_MVIEW.REFRESH(<materialized_view_name>,’L’);

Wenn REFRESH FORCE angegeben ist, wird eine FAST-Aktualisierung ausgewählt und durchgeführt, falls möglich. Andernfalls wird eine COMPLETE-Aktualisierung ausgeführt. Bei der Aktualisierung der Materialized View FORCE hat die LPCT-Aktualisierung dieselbe Priorität wie die PCT-Aktualisierung (Partitioning Change Tracking).

Change Tracking für logische Partitionen – Data Dictionary Views

Beschreibt die Data Dictionary Views, um Informationen über logische Partitionen zu finden.

Fragen Sie die folgenden Data Dictionary Views ab, um Informationen zu logischen Partitionen abzurufen.

  • ALL_MVIEW_DETAIL_LOGICAL_PARTITION: Diese Ansicht zeigt die Aktualitätsinformationen der Materialized Views in Bezug auf eine logische Partition für LPCT-Details an, auf die der aktuelle Benutzer zugreifen kann. Weitere Informationen finden Sie unter ALL_MVIEW_DETAIL_PARTITION.

  • DBA_MVIEW_DETAIL_ LOGICAL_PARTITION: Zeigt Aktualitätsinformationen für alle Materialized Views in der Datenbank in Bezug auf eine logische Partition mit LPCT-Detail an. Weitere Informationen finden Sie unter DBA_MVIEW_DETAIL_PARTITION.

  • USER_MVIEW_DETAIL_ LOGICAL_PARTITION: Zeigt Aktualitätsinformationen für alle Materialized Views in Bezug auf eine logische Partition für LPCT-Details an, deren Eigentümer der aktuelle Benutzer ist. Weitere Informationen finden Sie unter USER_MVIEW_DETAIL_PARTITION.

Beispiel: Logical Partition Change Tracking

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;