Hologres:Lixeira de tabelas

SELECT * FROM hologres.hg_recyclebin;

-- Change the retention period of tables to 5 days.
ALTER DATABASE <db_name> SET hg_recyclebin_retention_days = 5; 

-- Purge a single table.
PURGE TABLE {table_name};

-- Purge all tables from the recycle bin. This command must be run by a superuser.
CALL hologres.hg_purge_all_tables();

-- 1. user1 creates schema1 and grants the CREATE permission on the schema to user2.
CREATE SCHEMA schema1;
GRANT CREATE ON SCHEMA schema1 TO "BASIC$user2";

-- 2. user2 creates schema1.table2 and becomes the table owner.
CREATE TABLE schema1.table2(id INT);

-- user1 can delete schema1 and all objects within it, including table2, but cannot view table2.
SELECT * FROM schema1.table2; 
# ERROR:  permission denied for table table2

DROP SCHEMA schema1 CASCADE; 
# DROP CASCADES TO TABLE schema1.table2
# DROP SCHEMA

Exemplo 1: Excluir e recuperar uma tabela

1. Crie uma tabela padrão e exclua-a.

   CREATE TABLE tbl1 (
     id INT NOT NULL)
   WITH (
       orientation = 'column',
       distribution_key = 'id',
       clustering_key = 'id',
       event_time_column = 'id');
   INSERT INTO tbl1 SELECT i  FROM GENERATE_SERIES(1, 1000000) i;
   DROP TABLE tbl1;

2. Verifique a lixeira para confirmar que a tabela foi movida para ela.

   SELECT * FROM hologres.hg_recyclebin;

   Resultado retornado:

   table_id | schema_name | table_name |   table_owner   |    dropby   |   drop_time        
   ---------+-------------+------------+-----------------+-------------+-----------------------
          14| public      | tbl1       | xx_developer  | 1365xxxxxxxx| 2025-04-17 19:23:10+08
   (1 row)

   Verifique o armazenamento da tabela:

   SELECT (hologres.hg_recyclebin_relation_size('tbl1')/1024)::text||'KB' AS hg_recyclebin_relation_size;

   O comando retorna o tamanho de armazenamento da tabela:

   hg_recyclebin_relation_size 
   -----------------------------
                         1336KB
   (1 row)

3. Recupere a tabela.

   -- Recover all data and properties of the standard table tbl1, including its primary key and clustering key.
   RECOVER TABLE tbl1;  

Exemplo 2: Excluir e recuperar uma tabela particionada

1. Crie uma tabela particionada com as tabelas pai e filho correspondentes.

   CREATE TABLE tbl2_parent(id INT) PARTITION BY list (id);
   CREATE TABLE tbl2_child_1 PARTITION OF tbl2_parent FOR VALUES IN (1);
   CREATE TABLE tbl2_child_2 PARTITION OF tbl2_parent FOR VALUES IN (2);

2. Exclua uma das tabelas filho e recupere-a. A tabela filho recuperada torna-se uma tabela padrão e deve ser anexada manualmente à tabela pai original.

   -- Delete a child table.
   DROP TABLE tbl2_child_1;
   
   -- The child table is moved to the recycle bin.
   SELECT * FROM hologres.hg_recyclebin;

   Resultado retornado:

   table_id | schema_name |  table_name  |   table_owner    |   dropby  |       drop_time        
   ----------+-------------+--------------+------------------+-----------+------------------------
          16 | public      | tbl2_child_1 | xx_developer   | 1365xxxxx | 2025-04-17 19:33:30+08
   (1 row)

   Recupere a tabela filho e verifique sua estrutura. Ela agora é uma tabela padrão e não é mais uma tabela filho.

   RECOVER TABLE tbl2_child_1;  
   SELECT hg_dump_script('tbl2_child_1');

   Resultado retornado:

    hg_dump_script                        
   --------------------------------------------------------------
    BEGIN;                                                      +
                                                                +
    /*                                                          +
    DROP TABLE public.tbl2_child_1;                             +
    */                                                          +                   
    CREATE TABLE public.tbl2_child_1 (                          +
        id INTEGER                                              +
    ) WITH (                                                    +
    orientation = 'column',                                     +
    storage_format = 'orc',                                     +
    table_group = 'xxxx_tg_default',                            +
    table_storage_mode = 'any',                                 +
    time_to_live_in_seconds = '3153600000'                      +
    );                                                          +
                                                                +
                                                                +
                                                                +
    COMMENT ON TABLE public.tbl2_child_1 IS NULL;               +
    ALTER TABLE public.tbl2_child_1 OWNER TO "xx_developer";    +
                                                                +
                                                                +
    END;                                                        +
    
   (1 row)

3. Exclua a tabela pai. Após a recuperação, ela permanece como uma tabela particionada.

   -- Delete the parent table.
   DROP TABLE tbl2_parent CASCADE;
   
   -- Check the recycle bin. The parent and child tables are both moved to the recycle bin.
   SELECT * FROM hologres.hg_recyclebin;                   

   Resultado retornado:

   table_id | schema_name |  table_name  |   table_owner |      dropby   |       drop_time        
   ---------+-------------+--------------+---------------+---------------+------------------------
         17 | public      | tbl2_child_2 | xx_developer | 1365xxxxxxxx | 2025-04-17 19:41:04+08
         15 | public      | tbl2_parent  | xx_developer | 1365xxxxxxxx | 2025-04-17 19:41:04+08

   Recupere a tabela pai.

   RECOVER TABLE tbl2_parent; 

   Execute a instrução a seguir em um cliente psql para visualizar o DDL da tabela pai.

   \d+ tbl2_parent;

   O resultado a seguir mostra que a tabela filho também foi recuperada.

                             Partitioned table "public.tbl2_parent"
    Column |  Type   | Collation | Nullable | Default | Storage | Stats target | Description
   --------+---------+-----------+----------+---------+---------+--------------+-------------
    id     | integer |           |          |         | plain   |              |
   Partition key: LIST (id)
   Partitions: tbl2_child_2 FOR VALUES IN (2)

Exemplo 4: Recuperar uma tabela com nome conflitante

• Se você excluir uma tabela e depois criar uma nova tabela com o mesmo nome, a recuperação da tabela excluída falhará. Primeiro, renomeie a tabela existente.

  1. Crie e exclua tbl6.

     CREATE TABLE tbl6(id INT);
     -- Delete the table and move it to the recycle bin.
     DROP TABLE tbl6;

  2. Crie uma nova tabela que também se chame tbl6 e tente recuperar a tabela excluída.

     CREATE TABLE tbl6(id INT);
     RECOVER TABLE tbl6;   

     Resultado retornado. A recuperação falha porque já existe uma tabela com o mesmo nome. Exclua ou renomeie a tabela existente.

     ERROR:  Table public.tbl6 already exists

  3. Renomeie a tabela existente tbl6 para tbl6_rename e, em seguida, recupere a tbl6 original. A recuperação agora é bem-sucedida.

     ALTER TABLE tbl6 RENAME TO tbl6_rename;
     RECOVER TABLE tbl6; 

• Se a tabela existente com o mesmo nome tiver a mesma chave primária e clustering key da tabela excluída, renomeá-la não funcionará. Mova a tabela existente para outro schema ou exclua-a antes de recuperar a tabela excluída.

  1. Crie uma tabela chamada tbl1 e exclua-a.

     -- Create a table and set a PK and a clustering key.
     CREATE TABLE tbl1 (
         col1 INT,
         col2 INT,
         col3 INT,
         PRIMARY KEY (col1, col2)
     )
     WITH (
         clustering_key = 'col1'
     );
     -- Delete the table.
     DROP TABLE  tbl1;
     
     -- Create a new table with the same name, PK, and clustering key.
     CREATE TABLE tbl1 (
         col1 INT,
         col2 INT,
         col3 INT,
         PRIMARY KEY (col1, col2)
     )
     WITH (
         clustering_key = 'col1'
     );
     
     -- Check the recycle bin.
     SELECT * FROM  hologres.hg_recyclebin;

     Resultado retornado:

     table_id | schema_name | table_name |   table_owner    |      dropby      |       drop_time        
     ----------+-------------+------------+------------------+------------------+------------------------
            493497 | public      | tbl1         | 13659371xxx| 13659371xxx | 2025-04-17 20:11:08+08

  2. A tentativa de recuperar a tabela tbl1 da lixeira falha.

     -- Attempt to recover the dropped table from the recycle bin. The recovery fails.
     RECOVER  TABLE tbl1;

     Mensagem de erro retornada:

     ERROR: Table public.tbl1 already exists

  3. Renomear a tabela tbl1 e tentar recuperar a tabela original também falha.

     -- Rename the existing table.
     ALTER TABLE tbl1 RENAME TO tbl2;
     
     -- The recovery still fails because the existing table has a primary key and clustering key.
     RECOVER  TABLE tbl1;

     Mensagem de erro retornada:

     ERROR: relation "tbl1_pkey" already EXISTS IN SCHEMA "public" 

  4. Mova a nova tabela para outro schema. Em seguida, será possível recuperar a tabela original com sucesso.

     CREATE SCHEMA test;
     ALTER TABLE tbl2 SET SCHEMA test;
     
     -- The recovery is successful.
     RECOVER  TABLE tbl1;

-- Delete a standard table without moving it to the recycle bin.
CREATE TABLE tbl1(id INT);
DROP TABLE tbl1 FORCE;   

CREATE TABLE tbl1(id INT);
DROP TABLE tbl1;
-- Forcibly delete the table from the recycle bin.
PURGE TABLE tbl1;