Aula 14: Sequences e Synonyms — gerando IDs e aliases no Oracle

Bem-vindo à Aula 14 do curso Oracle SQL — Do Zero ao Avançado. Hoje, terça-feira, 23 de junho de 2026, mergulhamos em um território intermediário que separa os desenvolvedores que apenas consomem bancos de dados daqueles que verdadeiramente dominam a arquitetura de dados: Sequences e Synonyms. Se você já trabalhou com tabelas e constraints, sabe que a integridade dos dados depende de identificadores únicos e consistentes. Nesta aula, você vai aprender a criar geradores automáticos de IDs com sequences e a simplificar o acesso a objetos com synonyms, dois recursos que, combinados, formam a espinha dorsal de aplicações Oracle escaláveis e de fácil manutenção.

Sequences são objetos independentes de tabela projetados para gerar números sequenciais de forma rápida e com controle refinado sobre intervalos, cache e comportamento cíclico. Synonyms, por sua vez, são apelidos — aliases lógicos — que permitem referenciar objetos de banco sem expor o schema proprietário, facilitando migrações, modularização e segurança. Em nossos projetos na JRT Technology Solutions, utilizamos diariamente sequences para primary keys de tabelas com milhões de registros e synonyms para isolar ambientes de desenvolvimento, homologação e produção sem alterar uma linha de código PL/SQL.

Ao final desta aula, você será capaz de criar sequences com parâmetros avançados como CACHE, NOCACHE, ORDER e CYCLE; manipular o estado da sequence com ALTER SEQUENCE; consumir valores com NEXTVAL e CURRVAL em múltiplas sessões; e criar synonyms públicos e privados que abstraem a localização física dos objetos. Tudo isso com exemplos práticos executáveis que você pode reproduzir no seu ambiente. Vamos direto ao ponto.

O que você vai aprender nesta aula

• Compreender o ciclo de vida de uma sequence e sua independência de transações
• Criar sequences com CREATE SEQUENCE e todos os seus parâmetros relevantes
• Utilizar NEXTVAL e CURRVAL em instruções INSERT, UPDATE e subconsultas
• Alterar e reiniciar sequences sem recriá-las
• Diferenciar synonyms públicos de synonyms privados
• Criar, utilizar e remover synonyms com CREATE SYNONYM, DROP SYNONYM
• Combinar sequences e synonyms em arquiteturas multischema
• Diagnosticar os erros mais frequentes ao trabalhar com esses objetos

Pré-requisitos e Ambiente

Para executar todos os exemplos desta aula, você precisa de um banco de dados Oracle 19c ou superior acessível com privilégios de CREATE SEQUENCE, CREATE ANY SYNONYM (ou CREATE SYNONYM) e CREATE TABLE. O schema de exemplo pode ser o clássico HR ou um schema próprio. Usaremos o SQL*Plus ou SQL Developer — ambos funcionam perfeitamente. Se você concluiu a Aula 13 sobre índices e constraints, já tem as tabelas necessárias e o ambiente configurado. Caso contrário, criaremos uma tabela simples tb_pedidos para demonstrar o uso de sequences como geradores de chave primária.

Antes de iniciar, conecte-se com um usuário que tenha os privilégios adequados. Se estiver utilizando o Oracle XE ou uma instância local, o usuário SYS ou SYSTEM pode conceder as permissões necessárias. Em ambientes corporativos como os que gerenciamos na JRT Technology Solutions, as sequences e synonyms são criados por DBAs ou desenvolvedores seniores com grants explícitos — recomendo que você pratique em um ambiente de desenvolvimento isolado.

-- Concedendo privilégios básicos para o schema de exemplo (execute como DBA)
GRANT CREATE SEQUENCE, CREATE SYNONYM, CREATE TABLE TO meu_usuario;
-- Para criar synonyms públicos, é necessário privilégio adicional
GRANT CREATE PUBLIC SYNONYM TO meu_usuario;

O que são Sequences e Synonyms no Oracle Database

Uma sequence é um objeto de banco de dados cuja única finalidade é gerar uma série numérica de acordo com especificações definidas no momento de sua criação. Diferente de colunas IDENTITY (introduzidas no Oracle 12c), sequences são completamente independentes de tabelas: você pode usar a mesma sequence para alimentar diversas tabelas ou até mesmo para qualquer lógica de negócio que exija números únicos. Sequences são globais dentro do schema e seus valores são cacheados em memória (SGA) para máxima performance, o que significa que uma chamada a NEXTVAL raramente precisa acessar o dicionário de dados.

Um synonym é essencialmente um apelido lógico que aponta para um objeto real — tabela, view, sequence, procedure, entre outros. Synonyms não armazenam dados nem código; são ponteiros que resolvem a referência em tempo de execução. Existem dois tipos: privados, que pertencem a um schema específico e são visíveis apenas para ele (e para quem receber grants), e públicos, que são visíveis para todos os usuários do banco. Em nossa experiência na JRT Technology Solutions, synonyms públicos são frequentemente usados para expor tabelas de catálogo ou APIs de sistemas legados sem obrigar os desenvolvedores a qualificar o schema em cada consulta.

Criando e Utilizando Sequences — do básico ao avançado

A sentença CREATE SEQUENCE é surpreendentemente rica em parâmetros. Vamos começar com um exemplo minimalista e evoluir até configurações complexas. Para esta aula, criaremos uma tabela de pedidos que será populada com uma sequence como gerador de chave primária.

-- Criando a tabela de exemplo
CREATE TABLE tb_pedidos (
    pedido_id       NUMBER(12)   PRIMARY KEY,
    cliente_cod     NUMBER(8)    NOT NULL,
    data_pedido     DATE         DEFAULT SYSDATE,
    valor_total     NUMBER(10,2) CHECK (valor_total > 0)
);

-- Sequence básica: inicia em 1, incrementa de 1 em 1, sem limite máximo
CREATE SEQUENCE seq_pedido_id;

O comando acima cria uma sequence chamada seq_pedido_id com todos os valores padrão: START WITH 1, INCREMENT BY 1, MAXVALUE 999999999999999999999999999 (10^28 – 1), sem ciclo, com cache de 20 valores e NOORDER. Agora vamos consumir os valores gerados pela sequence em instruções INSERT.

-- Inserindo registros usando a sequence
INSERT INTO tb_pedidos (pedido_id, cliente_cod, valor_total)
VALUES (seq_pedido_id.NEXTVAL, 101, 1500.00);

INSERT INTO tb_pedidos (pedido_id, cliente_cod, valor_total)
VALUES (seq_pedido_id.NEXTVAL, 102, 2300.50);

-- Consultando o último valor gerado pela sequence na sessão atual
SELECT seq_pedido_id.CURRVAL AS ultimo_valor FROM DUAL;

ULTIMO_VALOR
------------
           2

Observe o comportamento de NEXTVAL e CURRVAL: NEXTVAL avança a sequence e retorna o novo valor; CURRVAL retorna o último valor obtido por NEXTVAL na sessão atual, sem avançar o contador. Tentar acessar CURRVAL antes de qualquer NEXTVAL na sessão resulta no erro ORA-08002: sequence seq_pedido_id.CURRVAL is not yet defined in this session. Isso é intencional: cada sessão mantém seu próprio ponteiro de CURRVAL.

Parâmetros Avançados de Sequences — controle refinado

Agora que você entendeu a operação básica, vamos explorar os parâmetros que tornam uma sequence adequada para cenários empresariais. A Tabela 2 resume todos os parâmetros disponíveis no CREATE SEQUENCE do Oracle 19c.

Vamos criar uma sequence mais sofisticada para um sistema de protocolo anual que utiliza incremento de 10 e faz ciclo após o fim do ano, reiniciando com o número 1000.

-- Sequence com ciclo, incremento de 10, cache de 50 e ordenação
CREATE SEQUENCE seq_protocolo_anual
    START WITH     1000
    INCREMENT BY   10
    MAXVALUE       9990
    MINVALUE       1000
    CYCLE
    CACHE          50
    ORDER;

Os parâmetros foram escolhidos com o seguinte racional: o protocolo começa em 1000 e vai até 9990 porque estamos usando incrementos de 10, garantindo números como 1000, 1010, 1020, etc. CYCLE permite que, quando a sequence atingir 9990, o próximo NEXTVAL retorne 1000 novamente — útil em sistemas com limite numérico superior definido por regra de negócio. O CACHE 50 otimiza a performance ao pré-alocar 50 valores na SGA a cada chamada ao dicionário. O ORDER garante sequencialidade estrita mesmo em ambiente RAC, com pequeno custo de performance.

Em cenários de alta concorrência, como os que enfrentamos em aplicações de e-commerce na JRT Technology Solutions, o cache é um aliado crítico. Sem cache, cada NEXTVAL provoca um acesso ao dicionário de dados e uma gravação no redo log — um gargalo insustentável quando milhares de transações por segundo demandam novos IDs. Por outro lado, o cache implica que, em caso de crash da instância, os valores cacheados e ainda não utilizados são perdidos, criando “buracos” na sequência. Isso é aceitável para 99% dos casos de uso, pois IDs são identificadores surrogados, sem significado de negócio atrelado à continuidade.

Gerenciando Sequences — ALTER, DROP, REINÍCIO e visualização no dicionário

Sequences não são imutáveis. O comando ALTER SEQUENCE permite modificar quase todos os parâmetros — exceto START WITH. Para alterar o valor inicial, você precisa dropar e recriar a sequence, ou usar um truque com alteração temporária do INCREMENT BY que abordaremos a seguir.

-- Alterando o cache da sequence para 100 e definindo NOCYCLE
ALTER SEQUENCE seq_protocolo_anual
    CACHE 100
    NOCYCLE;

-- Se você precisar reiniciar uma sequence em um novo valor sem recriá-la:
-- Etapa 1: Altere INCREMENT BY para a diferença negativa necessária
-- Exemplo: seq_pedido_id está atualmente em 15; queremos que vá para 1000
ALTER SEQUENCE seq_pedido_id INCREMENT BY 985; -- (1000-15) = 985
-- Etapa 2: Execute NEXTVAL uma vez
SELECT seq_pedido_id.NEXTVAL FROM DUAL;
-- Etapa 3: Restaure o incremento original
ALTER SEQUENCE seq_pedido_id INCREMENT BY 1;

   NEXTVAL
----------
      1000

-- Sequence alterada.
-- Sequence alterada.

Para remover uma sequence que não é mais necessária, utilize DROP SEQUENCE. O dicionário de dados USER_SEQUENCES (ou ALL_SEQUENCES, DBA_SEQUENCES) contém os metadados de todas as sequences acessíveis. A coluna LAST_NUMBER indica o próximo valor que será obtido por NEXTVAL considerando o cache — e não o último valor efetivamente usado.

-- Consultando informações sobre as sequences do schema
SELECT sequence_name, min_value, max_value, increment_by,
       cache_size, last_number, cycle_flag, order_flag
FROM   user_sequences
WHERE  sequence_name LIKE 'SEQ%'
ORDER BY sequence_name;

SEQUENCE_NAME          MIN_VALUE  MAX_VALUE                INCREMENT_BY CACHE_SIZE LAST_NUMBER CYCLE_FLAG ORDER_FLAG
---------------------- ---------- ------------------------ ------------ ---------- ----------- ---------- ----------
SEQ_PEDIDO_ID          1          999999999999999999999999999  1          100        1020        N          N
SEQ_PROTOCOLO_ANUAL    1000       9990                         10         100        1050        N          Y

Observe LAST_NUMBER: para seq_pedido_id, ele reflete 1020, o que significa que o Oracle já pré-alocou os próximos 100 valores (cache) a partir da última chamada. O valor real próximo pode ser 1001 ou algo próximo, dependendo do momento da consulta. Este detalhe é crucial ao auditar sequences em produção — na JRT Technology Solutions, sempre checamos LAST_NUMBER antes de realizar manutenções programadas em sequences de missão crítica.

Synonyms — criando aliases inteligentes para objetos de banco

Agora que dominamos sequences, vamos explorar o segundo pilar desta aula: Synonyms. A sintaxe de criação é extremamente simples, mas o impacto arquitetural é profundo. Synonyms permitem que uma aplicação referencie objetos sem hardcoding do schema proprietário, facilitando migrações entre ambientes e implementação de segurança por camadas.

Existem dois escopos: synonym privado, que pertence a um schema e só é visível para ele (e para quem receber grants), e synonym público, visível para todos os usuários do banco. Em projetos que gerenciamos na JRT Technology Solutions, adotamos a convenção de synonyms públicos apenas para objetos verdadeiramente compartilhados, como tabelas de domínio e APIs centrais; para o restante, synonyms privados com grants seletivos são mais seguros.

-- Cenário: o schema VENDAS precisa acessar a tabela tb_pedidos
-- que está no schema COMPRAS, sem qualificar o schema a cada consulta.

-- Conectado como COMPRAS: criando um synonym privado para a própria tabela
-- (útil para padronização de código)
CREATE SYNONYM pedidos FOR tb_pedidos;
-- Agora COMPRAS pode consultar "SELECT * FROM pedidos" sem prefixo.

-- Conectado como VENDAS (após receber GRANT SELECT ON compras.tb_pedidos):
CREATE SYNONYM pedidos_vendas FOR compras.tb_pedidos;
-- A aplicação em VENDAS usa pedidos_vendas, sem saber onde a tabela reside.

-- Criando um synonym público para uma sequence compartilhada
-- (exige CREATE PUBLIC SYNONYM)
CREATE PUBLIC SYNONYM seq_pedido_global FOR compras.seq_pedido_id;

Synonyms não transferem privilégios automaticamente. Para que um usuário utilize um synonym que aponta para uma tabela de outro schema, o usuário precisa ter os grants adequados sobre o objeto alvo. O Oracle resolve o synonym primeiro para o objeto real e, em seguida, verifica os privilégios sobre o objeto real — nunca sobre o synonym em si.

A exclusão de synonyms segue a mesma lógica: DROP SYNONYM nome_synonym; para privados e DROP PUBLIC SYNONYM nome_synonym; para públicos. Se um objeto alvo for removido (DROP TABLE), o synonym permanece no dicionário como um ponteiro inválido — estado que você pode verificar consultando a coluna STATUS em USER_OBJECTS. Synonyms inválidos podem ser recriados (OR REPLACE) sem dropar primeiro, com o comando CREATE OR REPLACE SYNONYM.

Sequences e Synonyms em conjunto — arquiteturas multischema

Em sistemas corporativos, é comum que uma tabela e sua sequence associada residam em schemas diferentes daquele que a aplicação utiliza para conexão. Imagine um ambiente com três schemas: APP_DATA (dono das tabelas e sequences), APP_API (dono de procedures e funções) e APP_USER (schema de conexão da aplicação front-end). A combinação de synonyms e sequences é o que torna essa arquitetura viável sem que a aplicação precise saber em qual schema cada objeto reside.

-- Schema APP_DATA: criando tabela e sequence
CREATE TABLE app_data.clientes (
    cliente_id  NUMBER(10)  PRIMARY KEY,
    nome        VARCHAR2(100)
);

CREATE SEQUENCE app_data.seq_cliente_id START WITH 1 INCREMENT BY 1 CACHE 30;

-- Concedendo privilégios para APP_API e APP_USER
GRANT SELECT, INSERT, UPDATE, DELETE ON app_data.clientes TO app_api, app_user;
GRANT SELECT ON app_data.seq_cliente_id TO app_api, app_user;

-- Schema APP_API: criando synonyms privados para os objetos de APP_DATA
CREATE SYNONYM app_api.clientes      FOR app_data.clientes;
CREATE SYNONYM app_api.seq_cliente   FOR app_data.seq_cliente_id;

-- Schema APP_USER: criando synonyms privados com nomes simplificados
CREATE SYNONYM app_user.clientes     FOR app_data.clientes;
CREATE SYNONYM app_user.seq_cliente  FOR app_data.seq_cliente_id;

Com essa configuração, qualquer desenvolvedor trabalhando no schema APP_USER pode executar INSERT INTO clientes VALUES (seq_cliente.NEXTVAL, 'Maria Silva') sem qualificar o schema real. Quando a aplicação migra para um ambiente de produção com schemas diferentes, basta recriar os synonyms apontando para os novos objetos — o código-fonte permanece inalterado. Na JRT Technology Solutions, esta é a técnica padrão em todos os projetos com mais de 50 tabelas, pois reduz drasticamente o tempo de deploy e o risco de erros de referência.

Verificando a Instalação / Testando a Configuração

Para garantir que tudo está funcionando corretamente, vamos executar uma bateria de verificações que cobrem sequences e synonyms em conjunto. Estes passos devem ser executados na sessão do seu schema de testes.

-- 1. Listar todas as sequences do schema e verificar se estão saudáveis
SELECT sequence_name, last_number, cache_size, cycle_flag
FROM   user_sequences
ORDER BY sequence_name;

-- 2. Testar geração de valores com NEXTVAL e CURRVAL
SELECT seq_pedido_id.NEXTVAL AS proximo_id FROM DUAL;
SELECT seq_pedido_id.CURRVAL AS atual_id  FROM DUAL;

-- 3. Verificar synonyms existentes e seu status
SELECT synonym_name, table_owner, table_name, db_link
FROM   user_synonyms
ORDER BY synonym_name;

-- 4. Validar que o synonym aponta para o objeto correto
-- (tentativa de acesso real — deve funcionar sem erro)
SELECT COUNT(*) FROM pedidos;  -- se você criou o synonym pedidos para tb_pedidos

SEQUENCE_NAME          LAST_NUMBER CACHE_SIZE CYCLE_FLAG
---------------------- ----------- ---------- ----------
SEQ_PEDIDO_ID          1070       100        N
SEQ_PROTOCOLO_ANUAL    1100       100        N

PROXIMO_ID
----------
      1071

ATUAL_ID
--------
      1071

SYNONYM_NAME           TABLE_OWNER  TABLE_NAME    DB_LINK
---------------------- ------------ ------------- ----------
PEDIDOS                COMPRAS      TB_PEDIDOS

  COUNT(*)
----------
         5

Se todas as saídas corresponderem ao esperado — sequences retornando valores incrementais, synonyms listados com TABLE_OWNER correto e consulta via synonym funcionando — sua configuração está perfeita. Caso contrário, prossiga para a seção de erros comuns abaixo.

Erros Comuns e Como Resolver

Durante a prática com sequences e synonyms, alguns erros aparecem com frequência. Abaixo listamos quatro situações reais, suas causas, sintomas e soluções definitivas.

• ORA-08002: sequence NOME.CURRVAL is not yet defined in this session
  Causa: Tentativa de acessar CURRVAL sem antes ter executado NEXTVAL na sessão atual.
  Sintoma: Ocorre logo após conectar ao banco ou após reiniciar a sessão.
  Solução: Execute SELECT nome_sequence.NEXTVAL FROM DUAL; ao menos uma vez na sessão antes de usar CURRVAL. Em aplicações, faça uma chamada inicial de aquecimento na sequence.
• ORA-01775: looping chain of synonyms
  Causa: Um synonym aponta para outro synonym que, em última análise, aponta de volta para o primeiro, criando um ciclo infinito.
  Sintoma: Erro ao tentar selecionar do synonym; o Oracle detecta o loop e impede a execução.
  Solução: Verifique a cadeia de synonyms com SELECT * FROM user_synonyms WHERE synonym_name = 'NOME'; e corrija as referências para que todos apontem diretamente para o objeto final, sem intermediários cíclicos.
• ORA-00955: name is already used by an existing object
  Causa: Tentativa de criar um synonym com o mesmo nome de um objeto já existente no schema (tabela, view, etc.).
  Sintoma: Falha na execução do CREATE SYNONYM.
  Solução: Escolha um nome único ou use CREATE OR REPLACE SYNONYM se o objeto existente for outro synonym. Se for uma tabela, você precisa dropar a tabela ou renomeá-la antes, pois synonyms não podem sobrescrever objetos reais.
• ORA-04002: sequence NOME exceeds MAXVALUE e NOCYCLE está ativo
  Causa: A sequence atingiu seu MAXVALUE e o parâmetro NOCYCLE está em vigor.
  Sintoma: Chamadas a NEXTVAL falham com esse erro, interrompendo inserções.
  Solução: Se a lógica de negócio permitir, altere a sequence para CYCLE ou eleve o MAXVALUE com ALTER SEQUENCE ... MAXVALUE novo_valor;. Em sistemas com partitionamento por ID, considere recriar a sequence com um START WITH mais alto após arquivar dados antigos.

Além desses, fique atento a ORA-02289: sequence does not exist, que ocorre quando você referencia uma sequence inexistente ou de outro schema sem o devido synonym ou grant. Verifique USER_SEQUENCES e as permissões antes de assumir que a sequence não foi criada.

Boas Práticas e Dicas Avançadas

Ao longo de centenas de implementações na JRT Technology Solutions, consolidamos um conjunto de boas práticas que evitam dores de cabeça futuras com sequences e synonyms. A primeira e mais importante: nunca confie que NEXTVAL retornará valores sem gaps. Rollbacks, crashes de instância e cache não utilizado causam saltos irreversíveis — e isso não é um bug, é uma característica de performance. IDs surrogados não devem ter significado de negócio atrelado à sequencialidade.

• Use CACHE sempre que possível (o padrão 20 é razoável; 100 a 1000 para tabelas com altíssima taxa de inserção).
• Para tabelas particionadas por range de data e que usam sequence como PK, evite CYCLE — o risco de duplicação de ID ao ciclar é real.
• Prefira synonyms privados com grants explícitos a synonyms públicos, a menos que a visibilidade global seja estritamente necessária.
• Adote uma convenção de nomenclatura: sequences prefixadas com SEQ_ e synonyms sem prefixo, ou alguma variação que seu time padronize. Isso evita que alguém confunda uma sequence solta com uma coluna ou variável PL/SQL.
• Em scripts de deploy, coloque a criação de synonyms e sequences em arquivos separados de tabelas e índices. Isso facilita o versionamento e a reexecução isolada.
• Use ALTER SEQUENCE ... RESTART (Oracle 18c+) para reiniciar sequences sem os malabarismos de INCREMENT BY. Exemplo: ALTER SEQUENCE seq_pedido_id RESTART; reinicia do START WITH original, ou RESTART START WITH 5000 para um valor específico.

Outra dica avançada: sequences escaláveis (SCALE EXTEND) para ambientes RAC com altíssima contenção. Quando você especifica SCALE EXTEND, o Oracle gera números compostos que incluem o ID da instância, eliminando a disputa pelo mesmo cache global. O formato do número muda — por exemplo, 1010001 em vez de 1001 — e pode exigir adaptação nas aplicações, mas o ganho de throughput em RAC é substancial.

Resumo da Aula 14

Nesta aula densa e prática, você aprendeu a dominar dois objetos fundamentais do Oracle SQL que, juntos, resolvem os problemas de geração automática de identificadores e de abstração de localização física de objetos. Começamos com a criação de sequences básicas e avançadas, explorando cada parâmetro do CREATE SEQUENCE e seu impacto em performance e comportamento. Vimos como consumir valores com NEXTVAL e CURRVAL, como alterar e reiniciar sequences, e como consultar o dicionário de dados para auditoria.

Em seguida, mergulhamos nos synonyms, entendendo a diferença entre tipos públicos e privados e como eles permitem que aplicações transitem entre ambientes sem reescrita de código. A combinação de sequences e synonyms em arquiteturas multischema encerrou a parte prática, demonstrando um padrão de projeto que utilizamos diariamente na JRT Technology Solutions para sistemas de médio e grande porte. Por fim, diagnosticamos os erros mais frequentes e consolidamos boas práticas que vão economizar horas de troubleshooting no seu dia a dia como DBA ou desenvolvedor Oracle.

O que você deve levar desta aula: sequences não são apenas contadores; são objetos tunáveis que impactam diretamente a escalabilidade das suas aplicações. Synonyms não são meros atalhos; são ferramentas de arquitetura que promovem modularidade e segurança. Ambos merecem o mesmo rigor de projeto que você dedica a tabelas e índices.

Na próxima aula — Aula 15: Visões Materializadas — acelerando consultas com snapshots no Oracle — avançaremos para um recurso poderoso que combina o melhor das views e das tabelas, com aplicações em data warehousing e replicação de dados. Você aprenderá a criar materialized views com refresh automático, logs de materialized view e estratégias de tuning para consultas que antes levavam minutos e passarão a executar em segundos. Até lá, pratique exaustivamente os conceitos desta aula e nos vemos na próxima terça-feira!