Documentation sur Oracle Cloud Infrastructure

Vues de suivi des modifications de partition logique

Décrit les informations sur le cadre de métadonnées du suivi des modifications de partition logique (LPCT) et la réécriture des interrogations avec le suivi des modifications de partition logique dans la base de données de l'IA autonome.

Rubrique parent : Base de données autonome d'IA pour les utilisateurs Oracle Database expérimentés

À propos du suivi des modifications de partition logique

Le suivi logique des modifications de partition (LPCT) assure le suivi de l'alignement des vues matérialisées.

Logical Partition Change Tracking vous permet de créer des partitions logiques sur des tables de base. Il évalue l'alignement des tables de base pour les partitions logiques individuelles sans utiliser de journal de vues matérialisées ni exiger le partitionnement d'une des tables utilisées dans la vue matérialisée.

Lorsqu'une ou plusieurs tables de base dépendantes d'une vue matérialisée sont mises à jour, une vue matérialisée devient STALE et ne peut pas être utilisée pour la réécriture d'interrogation en mode d'intégrité appliquée par défaut.

Logical Partition Change Tracking (LPCT) permet d'exploiter les informations de partitionnement logique fournies par l'utilisateur des tables de base d'une vue matérialisée pour un suivi plus détaillé des données périmées au niveau de la partition à des fins d'actualisation et de réécriture. Alors que le PCT (Partitioning Change Tracking) classique repose sur le partitionnement physique des tables, le LPCT n'a aucune dépendance vis-à-vis des tables qui sont physiquement partitionnées; le LPCT peut être utilisé avec des tables partitionnées et non partitionnées.

Le mécanisme de suivi des modifications de partition logique utilise les sous-ensembles FRESH (partitions) des vues matérialisées alors que les autres sous-ensembles sont STALE. Des temps de réponse plus rapides peuvent être obtenus pour les requêtes des utilisateurs car les résultats précalculés dans les vues matérialisées sont utilisés plus souvent. Outre l'augmentation de la facilité d'utilisation des vues matérialisées, le PCT et le LPCT permettent également l'actualisation incrémentielle des vues matérialisées sans avoir besoin de journaux de vues matérialisées; l'actualisation peut être à la fois ON DEMAND ou ON COMMIT.

Comme pour le suivi des modifications de partitionnement (PCT), le suivi des modifications de partition logique (LPCT) est associé à une table de base et peut identifier avec précision les lignes d'une vue matérialisée affectées par les modifications de données sur la table de base, en fonction des limites de partition logique définies.

Voir Vues matérialisées avancées pour plus d'informations.

Utiliser le suivi logique des modifications de partition

Logical Partition Change Tracking (LPCT) partitionne logiquement une table à l'aide d'une colonne de clé et d'une méthode spécifiées.

La syntaxe de création Logical Partition Change Tracking est analogue aux partitions physiques. Contrairement aux partitions physiques, qui doivent être créées dans le cadre de la création de la table, LPCT peut être librement spécifié indépendamment de la création de la table et de sa forme, ce qui permet plus de flexibilité pour répondre à vos besoins. La création de LPCT n'est que des métadonnées.

Rubrique parent : Suivi des modifications de partition logique et vues matérialisées

Création de partitions logiques - BNF

Décrit la syntaxe pour créer des partitions logiques BNF.

Voici la syntaxe pour créer des partitions logiques BNF :

CREATE LOGICAL PARTITION TRACKING ON table_name
    PARTITION BY RANGE (partition_key)
    INTERVAL (interval_clause)
    (partition_specification);
  • Seules les méthodes de partitionnement logique RANGE et INTERVAL sont prises en charge.
  • Seule une seule colonne de clé de partition logique est prise en charge.
  • La colonne de clé de partition peut être de ces types de données :
    • NUMBER
    • DATE
    • CHAR
    • VARCHAR
    • VARCHAR2
    • TIMESTAMP
    • TIMESTAMP WITH TIME ZONE

Sélection de la colonne de clé de partition logique

La clé de partitionnement logique est spécifiée pour définir les limites de chaque partition logique.

La clé de partition logique n'est pas physique, ce qui signifie que les lignes de table appartenant à un intervalle de clés ne sont pas séparées dans une partition physique distincte. La table peut être non partitionnée ou partitionnée sur une clé différente de la clé de partition logique. La clé de partition logique peut être choisie librement et les limites de partition peuvent être rendues flexibles.

Pour choisir une colonne de clé de suivi des modifications de partition logique (LPCT), vous pouvez envisager une colonne en grappe, c'est-à-dire une colonne où les données sont proches de triées par valeur de colonne, qui sont fréquemment référencées dans les prédicats de filtre d'interrogation. Pour une colonne en grappe, moins de partitions logiques sont susceptibles d'être affectées lors des chargements de données, ce qui signifie que moins de partitions logiques STALE doivent être actualisées et plus de partitions logiques FRESH sont prêtes à être utilisées pour les réécritures. Si une table est déjà partitionnée, il est recommandé de créer un LPCT à l'aide d'une colonne différente de la colonne de clé de partition. LPCT offre des avantages similaires à Partitioning Change Tracking (PCT), et les avantages combinés ne sont pas maximisés si le suivi des données est effectué sur la même colonne.

Fraîcheur des vues matérialisées à l'aide du suivi logique des modifications de partition

Le mécanisme de suivi de l'alignement des partitions logiques (LPCT) enregistre et consolide automatiquement les statistiques de modification en interne en fonction de la clé de partition logique et de la méthode de partitionnement spécifiées lors de chaque modification de données.

Les données de modification adjacentes sont regroupées dans une partition " logique ". Contrairement à Partitioning Change Tracking (PCT), qui est lié aux limites de partition physique, le schéma LPCT offre une flexibilité dans la gestion et le regroupement des modifications de données résultant des instructions LMD appliquées à la table de base.

Pendant les LMD et les charges directes classiques, le LPCT adopte le même algorithme que le PCT utilise pour suivre l'étalonnage. Pendant les réécritures de requête, LPCT adopte le même algorithme que PCT utilise pour calculer le confinement de réécriture.

Lorsqu'une table est logiquement partitionnée à l'aide d'intervalles de clés, une vue matérialisée définie sur la table peut utiliser LPCT pour le suivi de l'étalement, l'actualisation et la réécriture des interrogations, à condition que la vue matérialisée contienne la clé de partition logique.

Note

Tous les types de vues matérialisées sont pris en charge pour LPCT.

Réécrire avec des vues matérialisées à l'aide du suivi logique des modifications de partition

À l'aide du suivi des modifications de partition logique (LPCT), Oracle sait qu'une vue matérialisée est STALE par rapport à certaines partitions logiques de la table de base, mais FRESH par rapport à d'autres parties.

Avec les informations plus détaillées sur l'alignement des données des tables de base, la vue matérialisée associée serait utilisée plus fréquemment en raison de la réécriture du LPCT.

Oracle identifie et utilise de façon transparente le sous-ensemble FRESH de vues matérialisées pour la réécriture des interrogations afin de répondre aux interrogations complexes des tables de base lorsque QUERY_REWRITE_INTEGRITY = ENFORCED |TRUSTED.

Si les rangées de vue matérialisées sont partiellement FRESH par rapport à ces partitions logiques, une réécriture partielle peut avoir lieu pour répondre à l'interrogation en utilisant partiellement la vue matérialisée, c'est-à-dire les partitions logiques FRESH, et en utilisant partiellement la table de base, c'est-à-dire les partitions logiques STALE.

Actualisation des vues matérialisées à l'aide du suivi des modifications de partition logique

L'actualisation du suivi logique des modifications de partition (LPCT) peut être mise en oeuvre à l'aide de l'alignement des données plus fin pour actualiser de manière incrémentielle les sous-ensembles STALE d'une vue matérialisée, éliminant ainsi l'actualisation complète coûteuse ou l'actualisation rapide basée sur un journal.

Si l'actualisation LPCT est spécifiée, les partitions logiques STALE sont identifiées et des opérations d'actualisation ciblées seront effectuées uniquement pour ces partitions logiques.

Pour appeler l'actualisation à l'aide du suivi des modifications de partition logique, vous spécifiez ‘L’ ou ‘l’ ("logique") comme méthode d'actualisation.

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

Si REFRESH FORCE est spécifié, une actualisation FAST est sélectionnée et effectuée si possible, ou bien elle effectue une actualisation COMPLETE. Lors de l'actualisation de la vue matérialisée FORCE, l'actualisation LPCT a la même priorité que l'actualisation du suivi des modifications de partitionnement (PCT).

Suivi des modifications de partition logique – Vues du dictionnaire de données

Décrit les vues du dictionnaire de données pour rechercher des informations sur les partitions logiques.

Interrogez les vues suivantes du dictionnaire de données pour extraire des informations sur les partitions logiques.

  • ALL_MVIEW_DETAIL_LOGICAL_PARTITION : Cette vue affiche les informations de fraîcheur des vues matérialisées, par rapport à une partition logique de détail LPCT, accessible à l'utilisateur courant. Pour plus d'informations, voir ALL_MVIEW_DETAIL_PARTITION.

  • DBA_MVIEW_DETAIL_ LOGICAL_PARTITION : Affiche les informations de fraîcheur pour toutes les vues matérialisées de la base de données, par rapport à une partition logique détaillée LPCT. Pour plus d'informations, voir DBA_MVIEW_DETAIL_PARTITION.

  • USER_MVIEW_DETAIL_ LOGICAL_PARTITION : Affiche les informations de fraîcheur pour toutes les vues matérialisées, par rapport à une partition logique détaillée LPCT appartenant à l'utilisateur courant. Pour plus d'informations, voir USER_MVIEW_DETAIL_PARTITION.

Exemple : Suivi des modifications de partition logique

Affiche les étapes d'utilisation du suivi des modifications de partition logique (LPCT) à l'aide d'une vue matérialisée qui contient des jointures et des agrégats.

  1. Créez des tables de base avec des partitions de modification logique.
    1. Créez une table 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));

      Cela crée la table MYSALES.

    2. Insérez des enregistrements dans la table MYSALES.
      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;
      Cette action alimente la table MYSALES.
    3. Créez un suivi de partition logique pour la table 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'))
  );
      Cela crée un suivi de partition logique pour la table MYSALES à l'aide de la clé TIME_ID.
    4. Créez une table MYCUSTOMERS.
      CREATE TABLE mycustomers (cust_id NUMBER, age NUMBER, gender CHAR(1), address VARCHAR(100));
      Cela crée la table MYCUSTOMERS.
    5. Insérez des enregistrements dans la table MYCUSTOMERS.
      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;
      Cette action alimente la table MYCUSTOMERS.
    6. Créez un suivi de partition logique pour la table MYCUSTOMERS.
      CREATE LOGICAL PARTITION TRACKING ON mycustomers
 PARTITION BY RANGE (age) INTERVAL (20.5)
 (PARTITION m0 values less than (20));
      Cela crée un suivi de partition logique pour la table MYSALES à l'aide de la clé AGE.
  2. Créez une vue matérialisée au-dessus des tables avec le suivi logique des modifications de partition.
    1. Créer une vue matérialisée sur les tables MYSALES et 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;
      Cela crée la vue matérialisée SALES_AGE_TIME.
    2. Interrogez la vue du dictionnaire de données DBA_MVIEW_DETAIL_LOGICAL_PARTITION.
      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;

      Il affiche la sortie suivante.

      
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. Utilisez EXPLAIN_MVIEW pour évaluer les capacités d'actualisation et de réécriture liées à la partition logique.
      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;

      Il affiche la sortie suivante.

      
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. Observez l'impact des instructions LMD sur votre vue matérialisée.
    1. Introduisez une nouvelle partition logique dans la table MYSALES.
      INSERT INTO mysales (time_id, prod_id, cust_id, amount_sold) VALUES
      (TO_DATE('2019-02-05','yyyy-mm-dd'), 99, 2108, 33);
      Cela introduit une nouvelle partition (partition #6) sur la table MYSALES.
    2. Introduisez une nouvelle partition logique dans la table MYSALES.
      INSERT INTO mysales (time_id, prod_id, cust_id, amount_sold) VALUES (TO_DATE('2019-02-05','yyyy-mm-dd'), 99, 2108, 33);
      Cela introduit une nouvelle partition (partition #6) sur la table MYSALES.
    3. Introduisez une nouvelle partition logique dans la table MYCUSTOMERS.
      INSERT INTO mycustomers(cust_id, age, gender) VALUES (1399, 80, 'F');
      Cela introduit une nouvelle partition (partition #3) dans la table MYCUSTOMERS.
    4. Introduisez une nouvelle partition logique dans la table MYSALES.
      INSERT INTO mysales (time_id, prod_id, cust_id, amount_sold) VALUES (TO_DATE('2019-02-09','yyyy-mm-dd'), 99, 1997, 79.9);
      Cela introduit une nouvelle partition (partition #7) sur la table MYSALES.
    5. Introduisez une nouvelle partition logique dans la table MYSALES.
      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;
      Cela introduit une nouvelle partition (partition #2) dans la table MYSALES.
    6. Interrogez la vue du dictionnaire de données DBA_MVIEW_DETAIL_LOGICAL_PARTITION.
      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;

      Maintenant, il affiche la sortie suivante.

      
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. Effectuez une réécriture LPCT sur le sous-ensemble de lpart #1 sur MYSALES et lpart #0 sur les tables MYCUSTOMERS.
      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. Interrogez REWRITE_TABLE pour vérifier les réécritures.
      SELECT mv_name, sequence, pass, message FROM rewrite_table;
    9. Exécutez l'interrogation suivante.
      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. Consultez le plan d'exécution de l'interrogation ci-dessus pour vérifier les réécritures.
      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. Tirer parti de LPCT pour l'actualisation incrémentielle.
    1. Exécutez le code suivant pour effectuer l'actualisation LPCT.
      EXECUTE DBMS_MVIEW.REFRESH('SALES_AGE_TIME', 'L');
    2. Vérifiez l'actualisation à l'aide de l'interrogation suivante.
      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;