Limitações de DDL e outras informações do Aurora PostgreSQL Limitless Database

Consulte Restrições para obter detalhes sobre o que não é compatível.

Há suporte para valores padrão. Para ter mais informações, consulte Valores padrão.

Nem todos os índices são visíveis nos roteadores ao usar \d table_name ou comandos semelhantes. Em vez disso, use a exibição pg_catalog.pg_indexes para obter índices, conforme mostrado no exemplo a seguir.

SET rds_aurora.limitless_create_table_mode='sharded';
SET rds_aurora.limitless_create_table_shard_key='{"id"}';
CREATE TABLE items (id int PRIMARY KEY, val int);
CREATE INDEX items_my_index on items (id, val);

postgres_limitless=> SELECT * FROM pg_catalog.pg_indexes WHERE tablename='items';

 schemaname | tablename |   indexname    | tablespace |                                indexdef
------------+-----------+----------------+------------+------------------------------------------------------------------------
 public     | items     | items_my_index |            | CREATE INDEX items_my_index ON ONLY public.items USING btree (id, val)
 public     | items     | items_pkey     |            | CREATE UNIQUE INDEX items_pkey ON ONLY public.items USING btree (id)
(2 rows)

Há suporte para restrições simples que envolvem operadores de comparação com literais. Não há suporte para expressões e restrições mais complexas que exigem validações de funções, conforme mostrado nos exemplos a seguir.

CREATE TABLE my_table (
    id  INT CHECK (id > 0)                                     -- supported
  , val INT CHECK (val > 0 AND val < 1000)                     -- supported
  , tag TEXT CHECK (length(tag) > 0)                           -- not supported: throws "Expression inside CHECK constraint is not supported"
  , op_date TIMESTAMP WITH TIME ZONE CHECK (op_date <= now())  -- not supported: throws "Expression inside CHECK constraint is not supported"
);

Você pode dar nomes explícitos às restrições, conforme mostrado no exemplo a seguir.

CREATE TABLE my_table (
    id  INT CONSTRAINT positive_id  CHECK (id > 0)
  , val INT CONSTRAINT val_in_range CHECK (val > 0 AND val < 1000)
);

É possível utilizar a sintaxe de restrição em nível de tabela com a restrição CHECK, conforme mostrado no exemplo a seguir.

CREATE TABLE my_table (
    id INT CONSTRAINT positive_id  CHECK (id > 0)
  , min_val INT CONSTRAINT min_val_in_range CHECK (min_val > 0 AND min_val < 1000)
  , max_val INT
  , CONSTRAINT max_val_in_range CHECK (max_val > 0 AND max_val < 1000 AND max_val > min_val)
);

Não há suporte para restrições de exclusão no Aurora PostgreSQL Limitless Database.

Para ter mais informações, consulte Chaves externas.

Há suporte para restrições NOT NULL sem limitações.

A chave primária implica restrições únicas e, portanto, as mesmas restrições aplicadas às restrições únicas se aplicam à chave primária. Isso significa que:

Os exemplos a seguir ilustram o uso de chaves primárias.

-- Create a standard table.
CREATE TABLE public.my_table (
    item_id INT
  , location_code INT
  , val INT
  , comment text
);

-- Change the table to a sharded table using the 'item_id' and 'location_code' columns as shard keys.
CALL rds_aurora.limitless_alter_table_type_sharded('public.my_table', ARRAY['item_id', 'location_code']);

Tentando adicionar uma chave primária que não contém uma chave de fragmento:

-- Add column 'item_id' as the primary key.
-- Invalid because the primary key doesnt include all columns from the shard key:
-- 'location_code' is part of the shard key but not part of the primary key
ALTER TABLE public.my_table ADD PRIMARY KEY (item_id); -- ERROR

-- add column "val" as primary key
-- Invalid because primary key does not include all columns from shard key:
--  item_id and location_code iare part of shard key but not part of the primary key
ALTER TABLE public.my_table ADD PRIMARY KEY (item_id); -- ERROR

Tentando adicionar uma chave primária que contém uma chave de fragmento:

-- Add the 'item_id' and 'location_code' columns as the primary key.
-- Valid because the primary key contains the shard key.
ALTER TABLE public.my_table ADD PRIMARY KEY (item_id, location_code); -- OK

-- Add the 'item_id', 'location_code', and 'val' columns as the primary key.
-- Valid because the primary key contains the shard key.
ALTER TABLE public.my_table ADD PRIMARY KEY (item_id, location_code, val); -- OK

Alterar uma tabela padrão para uma tabela de referência.

-- Create a standard table.
CREATE TABLE zipcodes (zipcode INT PRIMARY KEY, details VARCHAR);

-- Convert the table to a reference table.
CALL rds_aurora.limitless_alter_table_type_reference('public.zipcode');

Consulte Criação de tabelas do Aurora PostgreSQL Limitless Database para obter mais informações sobre a criação de tabelas fragmentadas e de referência.

Em tabelas fragmentadas, a chave única deve conter a chave de fragmento. Ou seja, a chave de fragmento deve ser um subconjunto da chave única. Isso é verificado ao alterar o tipo de tabela para fragmentada. Não há restrição nas tabelas de referência.

CREATE TABLE customer (
    customer_id INT NOT NULL
  , zipcode INT
  , email TEXT UNIQUE
);

Há suporte para restrições em nível de tabela UNIQUE, conforme mostrado no exemplo a seguir.

CREATE TABLE customer (
    customer_id INT NOT NULL
  , zipcode INT
  , email TEXT
  , CONSTRAINT zipcode_and_email UNIQUE (zipcode, email)
);

O exemplo a seguir mostra o uso de uma chave primária e uma chave única juntas. Ambas as chaves devem incluir a chave de fragmento.

SET rds_aurora.limitless_create_table_mode='sharded';
SET rds_aurora.limitless_create_table_shard_key='{"p_id"}';
CREATE TABLE t1 (
p_id BIGINT NOT NULL,
c_id BIGINT NOT NULL,
PRIMARY KEY (p_id),
UNIQUE (p_id, c_id)
);

É possível criar extensões, como no PostgreSQL.

CREATE EXTENSION [ IF NOT EXISTS ] extension_name
    [ WITH ] [ SCHEMA schema_name ]
             [ VERSION version ]
             [ CASCADE ]

Para obter mais informações, consulte CREATE EXTENSION na documentação do PostgreSQL.

As seguintes DDLs são compatíveis:

ALTER EXTENSION name UPDATE [ TO new_version ]

ALTER EXTENSION name SET SCHEMA new_schema

Para obter mais informações, consulte ALTER EXTENSION na documentação do PostgreSQL.

É possível descartar extensões, como no PostgreSQL.

DROP EXTENSION [ IF EXISTS ] name [, ...] [ CASCADE | RESTRICT ]

Para obter mais informações, consulte DROP EXTENSION na documentação do PostgreSQL.

Não é possível adicionar ou descartar objetos membros das extensões.

ALTER EXTENSION name ADD member_object

ALTER EXTENSION name DROP member_object

rds_aurora.limitless_pgstattuple(relation_name)

rds_aurora.limitless_pgstattuple(relation_name, subcluster_id)

rds_aurora.limitless_pgstatindex(relation_name)

rds_aurora.limitless_pgstatindex(relation_name, subcluster_id)

rds_aurora.limitless_pgstatginindex(relation_name)

rds_aurora.limitless_pgstatginindex(relation_name, subcluster_id)

rds_aurora.limitless_pgstathashindex(relation_name)

rds_aurora.limitless_pgstathashindex(relation_name, subcluster_id)

rds_aurora.limitless_pg_relpages(relation_name)

rds_aurora.limitless_pg_relpages(relation_name, subcluster_id)

rds_aurora.limitless_pgstattuple_approx(relation_name)

rds_aurora.limitless_pgstattuple_approx(relation_name, subcluster_id)

Assim como no Aurora PostgreSQL, é possível criar funções, com exceção de alterar sua volatilidade ao substituí-las.

Para obter mais informações, consulte CREATE FUNCTION na documentação do PostgreSQL.

Assim como no Aurora PostgreSQL, é possível alterar funções, com exceção de alterar sua volatilidade.

Para obter mais informações, consulte ALTER FUNCTION na documentação do PostgreSQL.

Assim como no Aurora PostgreSQL, é possível descartar funções.

DROP FUNCTION [ IF EXISTS ] name [ ( [ [ argmode ] [ argname ] argtype [, ...] ] ) ] [, ...]
    [ CASCADE | RESTRICT ]

Para obter mais informações, consulte DROP FUNCTION na documentação do PostgreSQL.

Ao distribuir uma função ou um procedimento, ele lida apenas com dados limitados pelo intervalo de chaves de fragmento nesse fragmento. Nos casos em que a função ou o procedimento tentar acessar dados de um fragmento diferente, os resultados retornados pela função ou pelo procedimento distribuído serão diferentes em comparação com um que não está distribuído.

Por exemplo, você cria uma função que contém consultas que têm relação com vários fragmentos, mas depois chama o procedimento rds_aurora.limitless_distribute_function para distribuí-la. Quando você invoca essa função fornecendo argumentos para uma chave de fragmento, é provável que os resultados dessa execução sejam limitados pelos valores presentes nesse fragmento. Esses resultados são diferentes dos que são produzidos sem a distribuição da função.

Considere a função a seguir, func em que temos a tabela fragmentada customers com a chave de fragmento customer_id.

postgres_limitless=> CREATE OR REPLACE FUNCTION func(c_id integer, sc integer) RETURNS int
    language SQL
    volatile
    AS $$
    UPDATE customers SET score = sc WHERE customer_id = c_id RETURNING score;
    $$;

Agora, distribuímos essa função:

SELECT rds_aurora.limitless_distribute_function('func(integer, integer)', ARRAY['c_id'], 'customers');

Veja a seguir exemplos de planos de consulta.

EXPLAIN(costs false, verbose true) SELECT func(27+1,10);

                    QUERY PLAN
 --------------------------------------------------
  Foreign Scan
    Output: (func((27 + 1), 10))
    Remote SQL:  SELECT func((27 + 1), 10) AS func
  Single Shard Optimized
 (4 rows)

EXPLAIN(costs false, verbose true)
 SELECT * FROM customers,func(customer_id, score) WHERE customer_id=10 AND score=27;

                          QUERY PLAN
 ---------------------------------------------------------------------
  Foreign Scan
    Output: customer_id, name, score, func
    Remote SQL:  SELECT customers.customer_id,
      customers.name,
      customers.score,
      func.func
     FROM public.customers,
      LATERAL func(customers.customer_id, customers.score) func(func)
    WHERE ((customers.customer_id = 10) AND (customers.score = 27))
  Single Shard Optimized
 (10 rows)

O exemplo a seguir mostra um procedimento com os parâmetros IN e OUT como argumentos.

CREATE OR REPLACE FUNCTION get_data(OUT id INTEGER, IN arg_id INT)
    AS $$
    BEGIN
        SELECT customer_id,
        INTO id
        FROM customer
        WHERE customer_id = arg_id;
    END;
    $$ LANGUAGE plpgsql;

O exemplo a seguir distribui o procedimento usando somente parâmetros IN.

EXPLAIN(costs false, verbose true) SELECT * FROM get_data(1);

             QUERY PLAN
 -----------------------------------
  Foreign Scan
    Output: id
    Remote SQL:  SELECT customer_id
     FROM get_data(1) get_data(id)
  Single Shard Optimized
 (6 rows)

A função setval não é compatível. Para obter mais informações, consulte Sequence Manipulation Functions na documentação do PostgreSQL.

As opções a seguir não são compatíveis.

CREATE [{ TEMPORARY | TEMP} | UNLOGGED] SEQUENCE
    [[ NO ] CYCLE]

Para ter mais informações, consulte CREATE SEQUENCE na documentação do PostgreSQL.

As opções a seguir não são compatíveis.

ALTER SEQUENCE
    [[ NO ] CYCLE]

Para obter mais informações, consulte ALTER SEQUENCE na documentação do PostgreSQL.

O comando ALTER TABLE não é compatível com sequências.

postgres_limitless=> CREATE SEQUENCE s;
CREATE SEQUENCE

postgres_limitless=> SELECT nextval('s');

 nextval
---------
       1
(1 row)

postgres_limitless=> SELECT * FROM pg_sequence WHERE seqrelid='s'::regclass;

 seqrelid | seqtypid | seqstart | seqincrement | seqmax | seqmin | seqcache | seqcycle 
----------+----------+----------+--------------+--------+--------+----------+----------
    16960 |       20 |        1 |            1 |  10000 |      1 |        1 | f
(1 row)

% connect to another router
postgres_limitless=> SELECT nextval('s');

 nextval 
---------
   10001
(1 row)

postgres_limitless=> SELECT * FROM pg_sequence WHERE seqrelid='s'::regclass;

 seqrelid | seqtypid | seqstart | seqincrement | seqmax | seqmin | seqcache | seqcycle 
----------+----------+----------+--------------+--------+--------+----------+----------
    16959 |       20 |    10001 |            1 |  20000 |  10001 |        1 | f
(1 row)

postgres_limitless=> DROP SEQUENCE s;
DROP SEQUENCE

postgres_limitless=> CREATE SEQUENCE s;
CREATE SEQUENCE

postgres_limitless=> ALTER SEQUENCE s RESTART 500;
ALTER SEQUENCE

postgres_limitless=> SELECT nextval('s');

 nextval
---------
     500
(1 row)

postgres_limitless=> SELECT currval('s');

 currval
---------
     500
(1 row)

postgres=# CREATE TABLE t(a bigint primary key, b bigint);
CREATE TABLE

postgres=# CREATE SEQUENCE s minvalue 0 START 0;
CREATE SEQUENCE

postgres=# INSERT INTO t VALUES (nextval('s'), currval('s'));                                                                                             
INSERT 0 1

postgres=# INSERT INTO t VALUES (nextval('s'), currval('s'));
INSERT 0 1

postgres=# SELECT * FROM t;

 a | b
---+---
 0 | 0
 1 | 1
(2 rows)

postgres=# ALTER SEQUENCE s RESTART 10000;
ALTER SEQUENCE

postgres=# INSERT INTO t VALUES (nextval('s'), currval('s'));                                                                                             
INSERT 0 1

postgres=# SELECT * FROM t;

   a   |   b
-------+-------
     0 |     0
     1 |     1
 10000 | 10000
(3 rows)

Esta exibição mostra o estado e a configuração de uma sequência distribuída. As colunas minvalue, maxvalue, start, inc e cache têm o mesmo significado que na exibição pg_sequences e mostram as opções com as quais a sequência foi criada. A coluna lastval mostra o último valor alocado ou reservado em um objeto de sequência distribuída. Isso não significa que o valor já tenha sido usado, pois os roteadores mantêm partes da sequência localmente.

postgres_limitless=> SELECT * FROM rds_aurora.limitless_distributed_sequence WHERE sequence_name='test_serial_b_seq';

 schema_name |   sequence_name   | lastval | minvalue |  maxvalue  | start | inc | cache
-------------+-------------------+---------+----------+------------+-------+-----+-------
 public      | test_serial_b_seq | 1250000 |        1 | 2147483647 |     1 |   1 |     1
(1 row)

Esta exibição mostra metadados de sequência distribuídos e agrega metadados de sequência dos nós do cluster. Ela usa as seguintes colunas:

postgres_limitless=> SELECT * FROM rds_aurora.limitless_sequence_metadata WHERE sequence_name='test_serial_b_seq' order by subcluster_id;

 subcluster_id |   sequence_name   | schema_name | active_minvalue | active_maxvalue | reserved_minvalue | reserved_maxvalue | chunk_size | chunk_state | local_last_value 
---------------+-------------------+-------------+-----------------+-----------------+-------------------+-------------------+------------+-------------+------------------
 1             | test_serial_b_seq | public      |          500001 |          750000 |           1000001 |           1250000 |     250000 |           1 |           550010
 2             | test_serial_b_seq | public      |          250001 |          500000 |            750001 |           1000000 |     250000 |           1 |                 
(2 rows)

Se o tamanho da parte não for grande o suficiente e a taxa de transação for alta, os processos em segundo plano talvez não tenham tempo suficiente para solicitar novas partes antes que as partes ativas se esgotem. Isso pode levar a eventos de contenção e espera, como LIMITLESS:AuroraLimitlessSequenceReplace, LWLock:LockManager, Lockrelation e LWlock:bufferscontent.

Aumente o valor do parâmetro rds_aurora.limitless_sequence_chunk_size.

No PostgreSQL, o armazenamento em cache da sequência ocorre no nível da sessão. Cada sessão aloca valores de sequência sucessivos durante um acesso ao objeto de sequência e aumenta o last_value do objeto de sequência adequadamente. Em seguida, os próximos usos de nextval dentro dessa sessão simplesmente retornam os valores pré-alocados, sem tocar no objeto de sequência.

Quaisquer números alocados, mas não usados em uma sessão, são perdidos quando essa sessão termina, resultando em "lacunas" na sequência. Isso pode consumir o sequence_chunk rapidamente e levar a eventos de contenção e espera, como LIMITLESS:AuroraLimitlessSequenceReplace, LWLock:LockManager, Lockrelation e LWlock:bufferscontent.

Reduza a configuração do cache de sequência.