Lorsque des 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 de requête en mode d'intégrité appliquée par défaut.

Le suivi des modifications de partition logique (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 obsolètes au niveau de la partition à des fins d'actualisation et de réécriture. Alors que le suivi des modifications de partitionnement classique (PCT) repose sur le partitionnement physique des tables, LPCT n'a aucune dépendance vis-à-vis des tables physiquement partitionnées ; 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 (partitions) FRESH des vues matérialisées, alors que les autres sous-ensembles sont STALE. Des temps de réponse plus courts peuvent être obtenus pour les requêtes utilisateur car les résultats précalculés dans les vues matérialisées sont utilisés plus souvent. Outre l'augmentation de la convivialité des vues matérialisées, PCT et LPCT permettent également une 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.

Pour plus d'informations, voir Vues matérialisées avancées.

Le suivi des modifications de partition logique (LPCT) partitionne logiquement une table à l'aide d'une colonne et d'une méthode de clé spécifiées.

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

• Création de partitions logiques - BNF
  Décrit la syntaxe de création de partitions logiques BNF.
• Choix 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.
• Actualisation des vues matérialisées à l'aide du suivi des modifications de partition logique
  Le mécanisme de suivi des modifications de partition logique (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 indiquées lors de chaque modification de données.
• Réécriture avec des vues matérialisées à l'aide du suivi des modifications de partition logique
  A 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.
• Actualisation des vues matérialisées à l'aide du suivi des modifications de partition logique
  L'actualisation du suivi des modifications de partition logique (LPCT) peut être implémentée à l'aide d'une granularité de données plus fine pour actualiser de manière incrémentielle les sous-ensembles STALE d'une vue matérialisée, ce qui élimine une actualisation complète coûteuse ou une actualisation rapide basée sur les journaux.
• 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.

Présente les étapes à suivre pour utiliser le suivi des modifications de partition logique (LPCT) à l'aide d'une vue matérialisée contenant des jointures et des agrégats.

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

      La table MYSALES est alors créée.

   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 opération remplit 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 en utilisant TIME_ID comme clé.
   4. Créez la table MYCUSTOMERS.

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

      La table MYCUSTOMERS est alors créée.
   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 opération remplit 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 en utilisant AGE comme clé.
2. Créez une vue matérialisée sur les tables avec suivi des modifications de partition logique.
   1. Créez 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;

      La vue matérialisée SALES_AGE_TIME est alors créée.
   2. Recherchez 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;

      Indique 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 fonctionnalités d'actualisation et de réécriture liées aux partitions logiques.

      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;

      Indique 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 DML sur votre vue matérialisée.
   1. Introduisez une nouvelle partition logique sur 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 n° 6) sur la table MYSALES.
   2. Introduisez une nouvelle partition logique sur 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 n° 6) sur la table MYSALES.
   3. Introduisez une nouvelle partition logique sur la table MYCUSTOMERS.

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

      Cela introduit une nouvelle partition (partition #3) sur la table MYCUSTOMERS.
   4. Introduisez une nouvelle partition logique sur 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 sur 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) sur la table MYSALES.
   6. Recherchez 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 les tables 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 la requête 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 la requête 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. Tirez 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 la requête 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;