# Sequências e colunas de identidade Sequências e colunas de identidade geram valores de inteiro e são úteis quando identificadores compactos ou legíveis por humanos são necessários. Esses valores envolvem o comportamento de alocação e armazenamento em cache descrito na documentação [`CREATE SEQUENCE`](create-sequence-syntax-support.md). **Topics** + [ # Funções de manipulação de sequências ](sequence-functions-syntax-support.md) + [ # Colunas de identidade ](sequences-identity-columns-overview.md) + [ # Trabalhar com sequências e colunas de identidade ](sequences-identity-columns-working-with.md) # Funções de manipulação de sequências Esta seção descreve funções para operar em objetos de sequência, também chamados de geradores de sequência ou apenas sequências. Objetos de sequência são tabelas especiais de linha única criadas com[`CREATE SEQUENCE`](create-sequence-syntax-support.md). Eles são comumente usados para gerar identificadores exclusivos para linhas de uma tabela. As funções de sequência oferecem métodos simples e seguros para vários usuários quando se deseja obter valores de sequência sucessivos de objetos de sequência. **Importante** Ao usar sequências, é necessário considerar cuidadosamente o valor do cache. Para ter mais informações, consulte o texto explicativo “Importante” na página [`CREATE SEQUENCE`](create-sequence-syntax-support.md). Para obter orientações sobre a melhor forma de usar sequências com base nos padrões de workload, consulte [Trabalhar com sequências e colunas de identidade](sequences-identity-columns-working-with.md). | Função | Descrição | | --- | --- | | nextval ( regclass ) → bigint | Avança o objeto de sequência para o próximo valor e exibe esse valor. Isso é feito atomicamente: mesmo que várias sessões executem nextval simultaneamente, cada uma receberá com segurança um valor de sequência distinto. Se o objeto de sequência tiver sido criado com parâmetros padrão, as chamadas nextval sucessivas exibirão valores crescentes que começam com 1. Outros comportamentos podem ser obtidos usando os parâmetros apropriados no comando [`CREATE SEQUENCE`](create-sequence-syntax-support.md). Essa função requer o privilégio USAGE ou UPDATE na sequência. | | setval ( regclass, bigint [, boolean ] ) → bigint | Define o valor atual do objeto de sequência e, opcionalmente, o respectivo sinalizador is\$1called. O formulário de dois parâmetros define o campo last\$1value da sequência com o valor especificado e define o campo is\$1called como true, o que significa que o próximo nextval avançará a sequência antes de exibir um valor. O valor que será relatado por currval também é definido como o valor especificado. No formulário de três parâmetros, é possível definir is\$1called como true ou false. true tem o mesmo efeito que o formulário de dois parâmetros. Se estiver definido como false, o próximo nextval exibirá exatamente o valor especificado e o avanço da sequência começará com o nextval subsequente. Além disso, o valor informado por currval não é alterado aqui. Por exemplo: 
SELECT setval('myseq', 42);           -- Next nextval will return 43
SELECT setval('myseq', 42, true);     -- Same as above
SELECT setval('myseq', 42, false);    -- Next nextval will return 42
O resultado exibido por setval é simplesmente o valor do segundo argumento. Essa função requer o privilégio UPDATE na sequência. | | currval ( regclass ) → bigint | Exibe o valor obtido mais recentemente por nextval para essa sequência na sessão atual. (Será relatado um erro se nextval nunca tiver sido chamado para essa sequência nessa sessão.) Como está sendo exibido um valor de sessão local, essa função fornecerá uma resposta previsível independentemente de outras sessões terem executado nextval porque a sessão atual executou. Essa função requer o privilégio USAGE ou SELECT na sequência. | | lastval () → bigint | Mostra o valor exibido mais recentemente por nextval na transação atual. Essa função é idêntica a currval, exceto que, em vez de usar o nome da sequência como argumento, ela se refere a qualquer sequência à qual nextval foi aplicado mais recentemente na transação atual. É um erro chamar lastval quando nextval ainda não foi chamado na transação atual. Essa função requer o privilégio USAGE ou SELECT na última sequência usada. | **Atenção** O valor obtido por `nextval` não será recuperado para reutilização se a transação de chamada for cancelada posteriormente. Isso significa que cancelamentos de transações ou falhas no banco de dados podem gerar intervalos na sequência dos valores atribuídos. Isso também pode acontecer sem o cancelamento de uma transação. Por exemplo, um `INSERT` com uma cláusula `ON CONFLICT` calculará a tupla a ser inserida e fará qualquer chamada `nextval` necessária antes de detectar qualquer conflito que faria com que a regra `ON CONFLICT` fosse seguida. Portanto, os objetos de sequência do Aurora DSQL *não podem ser usados para obter sequências “sem intervalos”*. Da mesma forma, as alterações de estado de sequência criadas por `setval` podem vistas imediatamente por outras transações e não serão desfeitas se a transação de chamada for revertida. A sequência a ser operada por uma função de sequência é especificada por um argumento `regclass`, que é simplesmente o identificador de objeto (OID) da sequência no catálogo de sistema `pg_class`. No entanto, não é necessário pesquisar o OID manualmente, porque o conversor de entrada do tipo de dados `regclass` fará isso para você. Consulte a documentação [Object Identifier Types](https://www.postgresql.org/docs/current/datatype-oid.html) do PostgreSQL para ver detalhes. # Colunas de identidade **Importante** Ao usar colunas de identidade, é necessário considerar cuidadosamente o valor do cache. Para ter mais informações, consulte o texto explicativo “Importante” na página [`CREATE SEQUENCE`](create-sequence-syntax-support.md). Para obter orientações sobre a melhor forma de usar colunas de identidade com base nos padrões de workload, consulte [Trabalhar com sequências e colunas de identidade](sequences-identity-columns-working-with.md). Uma coluna de identidade é uma coluna especial gerada automaticamente com base em uma sequência implícita. Ela pode ser usado para gerar valores de chave. Para criar uma coluna de identidade, use a cláusula `GENERATED ... AS IDENTITY` em[`CREATE TABLE`](create-table-syntax-support.md). Por exemplo: ``` CREATE TABLE people ( id bigint GENERATED ALWAYS AS IDENTITY (CACHE 70000), ... ); ``` ou alternativamente: ``` CREATE TABLE people ( id bigint GENERATED BY DEFAULT AS IDENTITY (CACHE 70000), ... ); ``` Consulte [`CREATE TABLE`](create-table-syntax-support.md) para obter mais detalhes. Se um comando `INSERT` for executado na tabela com a coluna de identidade e nenhum valor for especificado explicitamente para a coluna de identidade, será inserido um valor gerado pela sequência implícita. Por exemplo, com as definições anteriores e presumindo colunas adicionais apropriadas, escrever: ``` INSERT INTO people (name, address) VALUES ('A', 'foo'); INSERT INTO people (name, address) VALUES ('B', 'bar'); ``` geraria valores para a coluna `id` a partir de 1 e os seguintes dados da tabela: ``` id | name | address ----+------+--------- 1 | A | foo 2 | B | bar ``` Também é possível especificar a palavra-chave `DEFAULT`, em vez de um valor, para solicitar explicitamente o valor gerado pela sequência: ``` INSERT INTO people (id, name, address) VALUES (DEFAULT, 'C', 'baz'); ``` Da mesma forma, a palavra-chave `DEFAULT` pode ser usada em comandos `UPDATE`. Portanto, sob vários aspectos, uma coluna de identidade se comporta como uma coluna com um valor padrão. As cláusulas `ALWAYS` e `BY DEFAULT` na definição da coluna determinam como os valores especificados pelo usuário são tratados explicitamente nos comandos `INSERT` e `UPDATE`. Em um comando `INSERT`, se `ALWAYS` estiver selecionado, um valor especificado pelo usuário só será aceito se a instrução `INSERT` especificar`OVERRIDING SYSTEM VALUE`. Se `BY DEFAULT` estiver selecionado, o valor especificado pelo usuário terá precedência. Portanto, o uso de `BY DEFAULT` gera um comportamento mais semelhante aos valores padrão, em que o valor padrão pode ser substituído por um valor explícito, enquanto `ALWAYS` oferece um pouco mais de proteção contra a inserção acidental de um valor explícito. O tipo de dados de uma coluna de identidade deve ser um dos tipos de dados aceitos pelas sequências. (Consulte [`CREATE SEQUENCE`](create-sequence-syntax-support.md).) As propriedades da sequência associada podem ser especificadas ao criar uma coluna de identidade (consulte [`CREATE TABLE`](create-table-syntax-support.md)) ou alteradas posteriormente (consulte [`ALTER TABLE`](alter-table-syntax-support.md)). Uma coluna de identidade é marcada automaticamente como `NOT NULL`. No entanto, uma coluna de identidade não garante exclusividade. (Uma sequência normalmente exibe valores exclusivos, mas ela pode ser redefinida ou os valores podem ser inseridos manualmente na coluna de identidade, conforme discutido anteriormente.) A exclusividade precisaria ser aplicada usando uma restrição `PRIMARY KEY` ou `UNIQUE`. # Trabalhar com sequências e colunas de identidade Esta seção ajuda a entender a melhor forma de usar sequências e colunas de identidade com base nos padrões de workload. **Importante** Consulte o texto explicativo “Importante” na página [`CREATE SEQUENCE`](create-sequence-syntax-support.md) para ver mais detalhes sobre alocação e comportamento de armazenamento em cache. ## Escolher tipos de identificador O Amazon Aurora DSQL permite identificadores baseados em UUID e valores inteiros gerados por meio de sequências ou colunas de identidade. Essas opções diferem com relação à forma como os valores são alocados e à forma como são escalados sob carga. Os valores de UUID podem ser gerados sem coordenação e são adequados para workloads em que são criados identificadores com frequência ou em várias sessões. Como o Amazon Aurora DSQL foi projetado para operação distribuída, evitar a coordenação geralmente é útil. Por esse motivo, os UUIDs são recomendados como o tipo de identificador padrão, especialmente para chaves primárias em workloads em que a escalabilidade é importante e a ordenação estrita dos identificadores não é necessária. Sequências e colunas de identidade geram valores inteiros compactos que são convenientes para identificadores legíveis por humanos, geração de relatórios e interfaces externas. Quando os identificadores numéricos são preferidos por motivos de usabilidade ou integração, considere a possibilidade de usar concomitantemente uma sequência ou coluna de identidade e identificadores baseados em UUID. Quando a sequência de inteiros ou os valores de identidade são necessários, a escolha de um tamanho de cache apropriado se torna uma parte essencial do design da workload. Consulte a seção a seguir para obter orientações sobre como escolher um tamanho de cache. ## Escolher o tamanho do cache A seleção de um valor de cache apropriado é essencial para o uso eficaz de sequências e colunas de identidade. A configuração do cache determina como a alocação de identificadores se comporta sob carga, influenciando o throughput do sistema e até que ponto os valores retratam a ordem de alocação. **Um tamanho de cache maior, como `CACHE >= 65536`, é adequado quando:** + Os identificadores são gerados em alta frequência. + Várias sessões são inseridas simultaneamente. + A workload consegue tolerar intervalos e efeitos de ordenação visíveis. Por exemplo, workloads de ingestão de eventos de alto volume (como IoT ou telemetria), bem como identificadores operacionais, como IDs de execução de tarefas, referências de casos de suporte ou números de pedidos internos, geralmente se beneficiam de tamanhos de cache maiores, em que os identificadores são gerados com frequência e a ordenação estrita não é necessária. **Um tamanho de cache de 1 é mais adequado quando:** + As taxas de alocação são relativamente baixas. + Espera-se que os identificadores sigam a ordem de alocação de maneira mais estreita ao longo do tempo. + A minimização dos intervalos é mais importante do que o throughput máximo. Determinadas workloads, como atribuição de números de conta ou de referência, nas quais são gerados identificadores com menor frequência e uma ordenação mais estreita é desejável, se alinham melhor com um tamanho de cache de 1.