Quando uma ou mais tabelas-base dependentes de uma view materializada são atualizadas, uma view materializada torna-se STALE e não pode ser usada para regravação de consulta no modo de integridade imposta padrão.

O LPCT (Logical Partition Change Tracking) fornece a capacidade de aproveitar as informações de particionamento lógico fornecidas pelo usuário das tabelas base de uma view materializada para um rastreamento mais detalhado no nível da partição de dados obsoletos para fins de atualização e regravação. Enquanto o Partitioning Change Tracking (PCT) clássico depende do particionamento físico de tabelas, o LPCT não tem dependência de tabelas que estão sendo particionadas fisicamente; o LPCT pode ser usado com tabelas particionadas e não particionadas.

O mecanismo de Rastreamento de Alteração de Partição Lógica usa os subconjuntos (partições) FRESH de views materializadas, apesar de outros subconjuntos serem STALE. Tempos de resposta mais rápidos podem ser alcançados para consultas de usuários porque os resultados pré-calculados em views materializadas são usados com mais frequência. Além de aumentar a usabilidade de views materializadas, PCT e LPCT também permitem a atualização incremental das views materializadas sem a necessidade de logs de view materializada; a atualização pode ser ON DEMAND ou ON COMMIT.

Semelhante ao Rastreamento de Alteração de Particionamento (PCT), o Rastreamento de Alteração de Partição Lógica (LPCT) é associado a uma tabela base e pode identificar com precisão as linhas em uma View Materializada afetadas por alterações de dados na tabela base, de acordo com os limites de partição lógica definidos.

Consulte Views Materializadas Avançadas Views Materializadas Avançadas para obter mais informações.

O Rastreamento de Alterações de Partição Lógica (LPCT) faz a partição lógica de uma tabela usando uma coluna e um método de chave especificados.

A sintaxe de criação do Rastreamento de Alteração de Partição Lógica é análoga às partições físicas. Ao contrário das partições físicas, que devem ser criadas como parte da criação da tabela, o LPCT pode ser especificado livremente, independentemente da criação da tabela e sua forma, permitindo mais flexibilidade para atender às suas necessidades. A criação de LPCT é apenas metadados.

• Criando Partições Lógicas - BNF
  Descreve a sintaxe para criar partições lógicas BNF.
• Escolhendo a Coluna de Chave de Partição Lógica
  A chave de particionamento lógica é especificada para definir os limites de cada partição lógica.
• Atualização de Views Materializadas Usando Rastreamento de Alteração de Partição Lógica
  O mecanismo de rastreamento de paralisação de Rastreamento de Alteração de Partição Lógica (LPCT) registra e consolida automaticamente as estatísticas de alteração internamente com base na chave de partição lógica especificada e no método de particionamento durante cada alteração de dados.
• Reescrever com Views Materializadas Usando Rastreamento de Alteração de Partição Lógica
  Usando o Rastreamento de Alteração de Partição Lógica (LPCT), a Oracle sabe que uma view materializada é STALE em relação a algumas partições lógicas da tabela base, mas FRESH em relação a outras partes.
• Atualização de Views Materializadas Usando Rastreamento de Alteração de Partição Lógica
  A atualização do Rastreamento de Alteração de Partição Lógica (LPCT) pode ser implementada usando a paralisação de dados refinada para atualizar incrementalmente os subconjuntos STALE de uma view materializada, eliminando a atualização completa dispendiosa ou a atualização rápida baseada em log.
• Rastreamento de Alterações de Partição Lógica - Views de Dicionário de Dados
  Descreve as views do dicionário de dados para encontrar informações sobre partições lógicas.

Mostra as etapas para usar o Rastreamento de Alterações de Partição Lógica (LPCT) usando uma View Materializada que contém junções e agregações.

1. Criar tabelas base com partições de alteração lógica.
   1. Crie a tabela 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));

      Isso cria a tabela MYSALES.

   2. Insira registros na tabela 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;

      Isso preenche a tabela MYSALES.
   3. Crie o rastreamento de partição lógica para a tabela 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'))
        );

      Isso cria um rastreamento de partição lógica para a tabela MYSALES usando TIME_ID como chave.
   4. Crie a tabela MYCUSTOMERS.

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

      Isso cria a tabela MYCUSTOMERS.
   5. Insira registros na tabela 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;

      Isso preenche a tabela MYCUSTOMERS.
   6. Crie o rastreamento de partição lógica para a tabela MYCUSTOMERS.

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

      Isso cria um rastreamento de partição lógica para a tabela MYSALES usando AGE como chave.
2. Crie uma view materializada em cima de tabelas com rastreamento de alteração de partição lógica.
   1. Crie view materializada nas tabelas MYSALES e 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;

      Isso criará a view materializada SALES_AGE_TIME.
   2. Consulte a view DBA_MVIEW_DETAIL_LOGICAL_PARTITION do dicionário de dados.

      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;

      Ele mostra a saída a seguir.

      
      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. Use EXPLAIN_MVIEW para avaliar os recursos de atualização e regravação relacionados à partição lógica.

      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;

      Ele mostra a saída a seguir.

      
      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. Observe o impacto dos DMLs na view materializada.
   1. Apresente uma nova partição lógica na tabela MYSALES.

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

      Isso introduz uma nova partição (partição #6) na tabela MYSALES.
   2. Apresente uma nova partição lógica na tabela MYSALES.

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

      Isso introduz uma nova partição (partição #6) na tabela MYSALES.
   3. Apresente uma nova partição lógica na tabela MYCUSTOMERS.

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

      Isso introduz uma nova partição (partição #3) na tabela MYCUSTOMERS.
   4. Apresente uma nova partição lógica na tabela 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);

      Isso introduz uma nova partição (partição #7) na tabela MYSALES.
   5. Apresente uma nova partição lógica na tabela 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;

      Isso introduz uma nova partição (partição #2) na tabela MYSALES.
   6. Consulte a view DBA_MVIEW_DETAIL_LOGICAL_PARTITION do dicionário de dados.

      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;

      Agora, ele mostra a saída a seguir.

      
      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. Execute a reescrita de LPCT no subconjunto de lpart #1 em MYSALES e lpart #0 nas tabelas 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. Consulte REWRITE_TABLE para verificar as regravações.

      SELECT mv_name, sequence, pass, message FROM rewrite_table;

   9. Execute a consulta a seguir.

      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. Exiba o plano de explicação da consulta acima para verificar as regravações.

       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. Aproveite o LPCT para atualização incremental.
   1. Execute o código a seguir para executar a atualização LPCT.

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

   2. Verifique a atualização usando a consulta a seguir.

      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;