# Converter tabelas padrão em tabelas ilimitadas
<a name="limitless-converting-standard"></a>

É possível converter tabelas padrão em tabelas fragmentadas ou de referência. Durante a conversão, os dados são movidos da tabela padrão para a tabela distribuída e, em seguida, a tabela padrão de origem é excluída. Os dados são movidos usando o comando `INSERT INTO SELECT FROM`.

**Contents**
+ [Criar tabelas fragmentadas](#limitless-creating-sharded)
+ [Criar tabelas colocalizadas](#limitless-creating-sharded.colocated)
+ [Criar tabelas de referência](#limitless-creating-reference)

## Criar tabelas fragmentadas
<a name="limitless-creating-sharded"></a>

Você cria tabelas fragmentadas executando o procedimento `rds_aurora.limitless_alter_table_type_sharded` em tabelas padrão. Esse procedimento recebe uma tabela padrão e uma lista de colunas e, em seguida, distribui a tabela fornecida usando a lista de colunas como a chave de fragmento. O procedimento é executado de forma síncrona e adquire um bloqueio `ACCESS EXCLUSIVE` na tabela.

Depois que o procedimento for concluído com sucesso, a tabela padrão de origem será excluída e uma tabela fragmentada com o mesmo nome ficará disponível.

O procedimento `rds_aurora.limitless_alter_table_type_sharded` usa a seguinte sintaxe:

```
postgres=> CALL rds_aurora.limitless_alter_table_type_sharded('{{schema}}.{{table}}', ARRAY['{{shard_key1}}', '{{shard_key2}}', ... '{{shard_keyn}}']);
```

O procedimento requer os seguintes parâmetros:
+ `schema`: o esquema do banco de dados que contém a tabela a ser fragmentada. Se o esquema não for especificado, o procedimento usa o `search_path`.
+ `table`: a tabela a ser fragmentada.
+ `shard_keyn`: uma matriz de colunas da tabela para usar como chave de fragmento.

  Os valores da chave de fragmento são literais de string e, portanto, diferenciam maiúsculas de minúsculas. Se uma chave de fragmento contiver aspas simples ('), use outra aspa simples de escape. Por exemplo, se uma coluna da tabela tiver o nome `customer's id`, use `customer''s id` como chave de fragmento. Barras invertidas (\\) e aspas duplas (") não precisam de escape.

**nota**  
Todas as chaves primárias e únicas devem incluir a chave de fragmento. Isso significa que a chave de fragmento é um subconjunto da chave primária ou única.  
Em tabelas fragmentadas, a restrição `CHECK` não é compatível com expressões.  
Para ter mais informações, consulte [Restrições](limitless-reference.DDL-limitations.md#limitless-reference.DDL-limitations.Constraints).

**Como criar uma tabela fragmentada**

O exemplo a seguir mostra como criar a tabela fragmentada `customer` com a chave de fragmento `customer_id`.

1. Crie a tabela padrão.

   ```
   CREATE TABLE customer (customer_id INT PRIMARY KEY NOT NULL, zipcode INT, email VARCHAR);
   ```

1. Converta a tabela padrão em uma tabela fragmentada.

   ```
   postgres=> CALL rds_aurora.limitless_alter_table_type_sharded('public.customer', ARRAY['customer_id']);
   
   postgres=> \d
   
                       List of relations
    Schema |     Name     |       Type        |       Owner
   --------+--------------+-------------------+--------------------
    public | customer     | partitioned table | postgres_limitless
    public | customer_fs1 | foreign table     | postgres_limitless
    public | customer_fs2 | foreign table     | postgres_limitless
    public | customer_fs3 | foreign table     | postgres_limitless
    public | customer_fs4 | foreign table     | postgres_limitless
    public | customer_fs5 | foreign table     | postgres_limitless
   (6 rows)
   ```

## Criar tabelas colocalizadas
<a name="limitless-creating-sharded.colocated"></a>

Se duas ou mais tabelas forem fragmentadas usando a mesma chave de fragmento, você poderá alinhar (colocalizar) explicitamente essas tabelas. Quando duas ou mais tabelas são colocalizadas, as linhas dessas tabelas com os mesmos valores de chave de fragmento são colocadas no mesmo fragmento. A colocalização ajuda a restringir algumas operações a um único fragmento, o que resulta em melhor desempenho.

Você usa o procedimento `rds_aurora.limitless_alter_table_type_sharded` com a seguinte sintaxe:

```
postgres=> CALL rds_aurora.limitless_alter_table_type_sharded('{{schema}}.{{collocated_table}}', ARRAY['{{shard_key1}}', '{{shard_key2}}', ... '{{shard_keyn}}'], '{{schema}}.{{sharded_table}}');
```

O procedimento requer os seguintes parâmetros:
+ `schema`: o esquema do banco de dados que contém as tabelas a serem colocalizadas. Se o esquema não for especificado, o procedimento usa o `search_path`.
+ `collocated_table`: a tabela a ser colocalizada.
+ `shard_keyn`: uma matriz de colunas da tabela para usar como chave de fragmento.

  É necessário usar a mesma chave de fragmento da tabela fragmentada original, incluindo os mesmos nomes e tipos de coluna.
+ `sharded_table`: a tabela fragmentada com a qual você está colocalizando o `collocated_table`.

**Para criar uma tabela colocalizada**

1. Crie a primeira tabela fragmentada seguindo o procedimento em [Criar tabelas fragmentadas](#limitless-creating-sharded).

1. Crie a tabela padrão para a tabela colocalizada.

   ```
   CREATE TABLE mytable2 (customer_id INT PRIMARY KEY NOT NULL, column1 INT, column2 VARCHAR);
   ```

1. Converta a tabela padrão em uma tabela colocalizada.

   ```
   postgres=> CALL rds_aurora.limitless_alter_table_type_sharded('public.mytable2', 
   ARRAY['customer_id'], 'public.customer');
   
   postgres=> \d
   
                       List of relations
    Schema |     Name     |       Type        |       Owner
   --------+--------------+-------------------+--------------------
    public | customer     | partitioned table | postgres_limitless
    public | customer_fs1 | foreign table     | postgres_limitless
    public | customer_fs2 | foreign table     | postgres_limitless
    public | customer_fs3 | foreign table     | postgres_limitless
    public | customer_fs4 | foreign table     | postgres_limitless
    public | customer_fs5 | foreign table     | postgres_limitless
    public | mytable2     | partitioned table | postgres_limitless
    public | mytable2_fs1 | foreign table     | postgres_limitless
    public | mytable2_fs2 | foreign table     | postgres_limitless
    public | mytable2_fs3 | foreign table     | postgres_limitless
    public | mytable2_fs4 | foreign table     | postgres_limitless
    public | mytable2_fs5 | foreign table     | postgres_limitless
   (12 rows)
   ```

## Criar tabelas de referência
<a name="limitless-creating-reference"></a>

Você cria tabelas de referência executando o procedimento `rds_aurora.limitless_alter_table_type_reference` em tabelas padrão. Esse procedimento replica uma determinada tabela para todos os fragmentos no grupo de fragmentos de banco de dados e altera o tipo de tabela para referência. O procedimento é executado de forma síncrona e adquire um bloqueio `ACCESS EXCLUSIVE` na tabela.

Depois que o procedimento for concluído com sucesso, a tabela padrão de origem será excluída e uma tabela de referência com o mesmo nome ficará disponível.

O procedimento `rds_aurora.limitless_alter_table_type_reference` usa a seguinte sintaxe:

```
postgres=> CALL rds_aurora.limitless_alter_table_type_reference('{{schema}}.{{table}}');
```

O procedimento armazenado requer os seguintes parâmetros:
+ `schema`: o esquema do banco de dados que contém a tabela a ser replicada. Se o esquema não for especificado, o procedimento usa o `search_path`.
+ `table`: a tabela a ser replicada.

**nota**  
A tabela padrão a partir da qual você cria a tabela de referência deve ter uma chave primária.  
Nas tabelas de referência, a restrição `CHECK` não é compatível com expressões.  
A função anterior, `limitless_table_alter_type_reference`, está obsoleta.

**Como criar uma tabela de referência**

Os exemplos a seguir mostram como criar a tabela de referência `zipcodes`.

1. Crie a tabela padrão.

   ```
   CREATE TABLE zipcodes (zipcode INT PRIMARY KEY, details VARCHAR);
   ```

1. Converta a tabela padrão em uma tabela de referência.

   ```
   CALL rds_aurora.limitless_alter_table_type_reference('public.zipcodes');
   
   postgres=> \d
   
                       List of relations
    Schema |     Name     |       Type        |       Owner
   --------+--------------+-------------------+--------------------
    public | customer     | partitioned table | postgres_limitless
    public | customer_fs1 | foreign table     | postgres_limitless
    public | customer_fs2 | foreign table     | postgres_limitless
    public | customer_fs3 | foreign table     | postgres_limitless
    public | customer_fs4 | foreign table     | postgres_limitless
    public | customer_fs5 | foreign table     | postgres_limitless
    public | zipcodes     | foreign table     | postgres_limitless
   (7 rows)
   ```

   A saída mostra a tabela fragmentada `customer` e a tabela de referência `zipcodes`.