4.1.1. Identificadores e palavras chave

Os termos SELECT, UPDATE e VALUES mostrados no exemplo acima são exemplos de palavras chave, ou seja, palavras que possuem um significado definido na linguagem SQL. Os termos MINHA_TABELA e A são exemplos de identificadores, os quais identificam nomes de tabelas, colunas e outros objetos do banco de dados, dependendo do comando onde são utilizados. Portanto, algumas vezes são simplesmente chamados de "nomes". As palavras chave e os identificadores possuem a mesma estrutura léxica, significando que não é possível saber se o termo é um identificador ou uma palavra chave sem conhecer a linguagem. A relação completa das palavras chave pode ser encontrada no Apêndice C .

Os identificadores e as palavras chave do SQL devem iniciar por uma letra (a-z e, também, letras com diacrítico [3] - áéç... - e letras não latinas), ou o caractere sublinhado (_). Os demais caracteres de um identificador, ou da palavra chave, podem ser letras, sublinhados, dígitos (0-9) ou o cifrão ($). Deve ser observado que, de acordo com o padrão SQL, o cifrão não é permitido em identificadores e, portanto, pode tornar a aplicação menos portável. O padrão SQL não irá definir palavra chave contendo dígitos, ou começando ou terminando por sublinhado e, portanto, os identificadores com esta forma estão a salvo contra possíveis conflitos com extensões futuras do padrão.

O sistema não utiliza mais que NAMEDATALEN-1 caracteres de um identificador; podem ser escritos nomes mais longos nos comandos, mas são truncados. Por padrão NAMEDATALEN é 64 e, portanto, o comprimento máximo de um identificador é 63. Se este limite causar problema, pode ser aumentado modificando a constante NAMEDATALEN no arquivo src/include/postgres_ext.h).

Os identificadores e as palavras chave não fazem distinção entre letras maiúsculas e minúsculas. Portanto,

UPDATE MINHA_TABELA SET A = 5;

pode ser escrito de forma equivalente como

uPDaTE Minha_Tabela SeT a = 5;

Normalmente utiliza-se a convenção de escrever as palavras chave em letras maiúsculas e os nomes em letras minúsculas, como mostrado abaixo:

UPDATE minha_tabela SET a = 5;

Existe um segundo tipo de identificador: o identificador delimitado ou identificador entre aspas, formado pela colocação de uma seqüência arbitrária de caracteres entre aspas ("). Um identificador delimitado é sempre um identificador, e nunca uma palavra chave. Portanto, "select" pode ser usado para fazer referência a uma tabela ou coluna chamada "select", enquanto select sem aspas sempre é uma palavra chave ocasionando, por isso, um erro do analisador quando usado onde um nome de tabela ou de coluna for esperado. O exemplo acima pode ser reescrito utilizando identificadores entre aspas como mostrado abaixo:

UPDATE "minha_tabela" SET "a" = 5;

Identificadores entre aspas podem conter qualquer caractere que não seja a própria aspas (Para incluir uma aspas, devem ser escritas duas aspas). Esta funcionalidade permite criar nomes de tabelas e de colunas que não seriam possíveis de outra forma, como os contendo espaços ou e-comercial (&). O limite do comprimento ainda se aplica.

Colocar um identificador entre aspas torna diferente as letras maiúsculas e minúsculas, enquanto as letras dos nomes não envoltos por aspas são sempre convertidas em minúsculas. Por exemplo, os identificadores FOO, foo e "foo" são considerados o mesmo identificador pelo PostgreSQL, mas "Foo" e "FOO" são diferentes dos três primeiros e entre si.

A transformação das letras dos nomes que não estão entre aspas em minúsculas feita pelo PostgreSQL é incompatível com o padrão SQL, que especifica a transformação em maiúsculas das letras dos nomes que não estão entre aspas. Portanto, foo deveria ser equivalente a "FOO", e não a "foo", de acordo com o padrão. Se for desejado desenvolver aplicações portáveis, aconselha-se a colocar o nome sempre entre aspas, ou nunca entre aspas.

=> SELECT name, setting FROM pg_settings WHERE name LIKE 'lc%';

    name     | setting
-------------+---------
 lc_collate  | C
 lc_ctype    | C
 lc_messages | C
 lc_monetary | C
 lc_numeric  | C
 lc_time     | C
(6 linhas)

=> CREATE TABLE AÇÃO(cod_ação int, nome_ação text);

=> \dt

            Lista de relações
 Esquema |   Nome    |  Tipo  |   Dono
---------+-----------+--------+----------
 public  | aÇÃo      | tabela | postgres
 public  | teste_abc | tabela | postgres
 public  | testeaabc | tabela | postgres
(3 linhas)

-- No exemplo acima ÇÃ não foi convertido em minúsculas

=> \dt AÇÃO
Não foi encontrada nenhuma relação correspondente.
=> \dt ação
Não foi encontrada nenhuma relação correspondente.
=> \dt "aÇÃo"

         Lista de relações
 Esquema | Nome |  Tipo  |   Dono
---------+------+--------+----------
 public  | aÇÃo | tabela | postgres
(1 linha)

-- Os exemplos acima mostram que só aÇÃo entre aspas corresponde ao nome da tabela.

-- Abaixo a tabela é criada com letras minúsculas.

=> CREATE TABLE ação(cod_ação int, nome_ação text);

=> \dt

            Lista de relações
 Esquema |   Nome    |  Tipo  |   Dono
---------+-----------+--------+----------
 public  | ação      | tabela | postgres
 public  | teste_abc | tabela | postgres
 public  | testeaabc | tabela | postgres
(3 linhas)

=> \dt ação

         Lista de relações
 Esquema | Nome |  Tipo  |   Dono
---------+------+--------+----------
 public  | ação | tabela | postgres
(1 linha)

=> \dt AÇÃO

         Lista de relações
 Esquema | Nome |  Tipo  |   Dono
---------+------+--------+----------
 public  | ação | tabela | postgres
(1 linha)

-- Nos exemplos acima foram bem-sucedidas a utilização tanto de ação quanto de AÇÃO.

=> INSERT INTO AÇÃO VALUES (1,'primeira ação');
ERRO: a relação "aÇÃo" não existe
=> INSERT INTO ação VALUES (1,'primeira ação');
INSERT 1665900 1

-- Nos exemplos acima só foi bem-sucedida a utilização de ação.

-- Para todas as letras do nome ficarem maiúsculas estes devem
-- ser escritos com letras maiúsculas e colocados entre aspas.

=> CREATE TABLE "AÇÃO"("COD_AÇÃO" int, "NOME_AÇÃO" text);

=> teste=# \dt

            Lista de relações
 Esquema |   Nome    |  Tipo  |   Dono
---------+-----------+--------+----------
 public  | AÇÃO      | tabela | postgres
 public  | teste_abc | tabela | postgres
 public  | testeaabc | tabela | postgres
(3 linhas)

=> \dt "AÇÃO"

         Lista de relações
 Esquema | Nome |  Tipo  |   Dono
---------+------+--------+----------
 public  | AÇÃO | tabela | postgres
(1 linha)

=> INSERT INTO "AÇÃO" ("COD_AÇÃO", "NOME_AÇÃO") VALUES (1,'primeira ação');

=> SELECT * FROM "AÇÃO";

 COD_AÇÃO |   NOME_AÇÃO
----------+---------------
        1 | primeira ação
(1 linha)

4.1.2. Constantes

Existem três tipos de constante com tipo implícito no PostgreSQL: cadeias de caracteres, cadeias de bits e numéricas. As constantes também podem ser especificadas com tipo explícito, o que permite uma representação mais precisa, e um tratamento mais eficiente por parte do sistema. Estas alternativas são mostradas nas próximas subseções.

SELECT 'foo'
'bar';

SELECT 'foobar';

SELECT 'foo'      'bar';

=> CREATE TABLE "AÇÃO"("COD_AÇÃO" int, "NOME_AÇÃO" text);

=> INSERT INTO "AÇÃO" ("COD_AÇÃO", "NOME_AÇÃO") VALUES (1,'um nome'
(> ' de ação'
(> ' muito longo');

=> SELECT * FROM "AÇÃO";

 COD_AÇÃO |          NOME_AÇÃO
----------+-----------------------------
        1 | um nome de ação muito longo
(1 linha)

CREATE TABLE "AÇÃO"("COD_AÇÃO" int, "NOME_AÇÃO" text)

INSERT INTO "AÇÃO" ("COD_AÇÃO", "NOME_AÇÃO") VALUES (1,'um nome' +
' de ação' +
' muito longo')

SELECT * FROM "AÇÃO"

COD_AÇÃO    NOME_AÇÃO                                                                                                                                                                                                                                                        
----------- ---------------------------
1           um nome de ação muito longo
(1 row(s) affected)

SQL> CREATE TABLE "AÇÃO"("COD_AÇÃO" int, "NOME_AÇÃO" varchar2(32));

SQL> INSERT INTO "AÇÃO" ("COD_AÇÃO", "NOME_AÇÃO") VALUES (1,'um nome' ||
  2  ' de ação' ||
  3  ' muito longo');

SQL> SELECT * FROM "AÇÃO";

  COD_AÇÃO NOME_AÇÃO
---------- --------------------------------
         1 um nome de ação muito longo

DB2SQL92> CREATE TABLE "AÇÃO"("COD_AÇÃO" int, "NOME_AÇÃO" varchar(32));
DB2SQL92> INSERT INTO "AÇÃO" ("COD_AÇÃO", "NOME_AÇÃO") VALUES (1,'um nome' ||
DB2SQL92> ' de ação' ||
DB2SQL92> ' muito longo');
DB2SQL92> SELECT * FROM "AÇÃO";

COD_AÇÃO     NOME_AÇÃO
-----------------------------------------------
          1  um nome de ação muito longo

dígitos
dígitos.[dígitos][e[+-]dígitos]
[dígitos].dígitos[e[+-]dígitos]
dígitose[+-]dígitos

REAL '1.23'  -- estilo cadeia de caracteres
1.23::REAL   -- estilo PostgreSQL (histórico)

tipo 'cadeia de caracteres'
'cadeia de caracteres'::tipo
CAST ( 'cadeia de caracteres' AS tipo )

nome_do_tipo ( 'cadeia de caracteres' )

4.1.3. Operadores

Um nome de operador é uma seqüência com até NAMEDATALEN-1 (por padrão 63) caracteres da seguinte lista:

+ - * / < > = ~ ! @ # % ^ & | ` ?

• Não podem ocorrer as seqüências -- e /* em nenhuma posição no nome do operador, porque são consideradas início de comentário.
• Um nome de operador com vários caracteres não pode terminar por + ou por -, a não ser que o nome também contenha ao menos um dos seguintes caracteres: ~ ! @ # % ^ & | ` ?. Por exemplo, @- é um nome de operador permitido, mas *- não é. Esta restrição permite ao PostgreSQL analisar comandos em conformidade com o padrão SQL sem requerer espaços entre os termos.

Ao trabalhar com nomes de operadores fora do padrão SQL, normalmente é necessário separar operadores adjacentes por espaço para evitar ambigüidade. Por exemplo, se for definido um operador unário-esquerdo chamado @, não poderá ser escrito X*@Y; deverá ser escrito X* @Y, para garantir que o PostgreSQL leia dois nomes de operadores e não apenas um.

4.1.4. Caracteres especiais

Alguns caracteres não alfanuméricos possuem significado especial diferente de ser um operador. Os detalhes da utilização podem ser encontrados nos locais onde a sintaxe do respectivo elemento é descrita. Esta seção se destina apenas a informar a existência e fazer um resumo das finalidades destes caracteres.

• O caractere cifrão ($) seguido por dígitos é utilizado para representar parâmetros posicionais no corpo da definição de uma função. Em outros contextos, o caractere cifrão pode ser parte de um identificador.
• Os parênteses (()) possuem seu significado usual de agrupar expressões e impor a precedência. Em alguns casos, os parênteses são requeridos como parte da sintaxe fixada para um determinado comando SQL.
• Os colchetes ([]) são utilizados para selecionar elementos da matriz. Veja a Seção 8.10 para obter mais informações sobre matrizes.
• As vírgulas (,) são utilizadas em algumas construções sintáticas para separar elementos da lista.
• O ponto-e-vírgula (;) termina um comando SQL, não podendo aparecer em nenhum lugar dentro do comando, exceto dentro de constantes do tipo cadeia de caracteres ou identificadores entre aspas.
• Os dois-pontos (:) são utilizados para selecionar "fatias" de matrizes (veja a Seção 8.10 ). Em certos dialetos do SQL, como a linguagem SQL incorporada, os dois-pontos são utilizados como prefixo dos nomes das variáveis.
• O asterisco (*) é utilizado em alguns contextos para denotar todos os campos da linha de uma tabela ou de um valor composto. Também possui um significado especial quando utlizado como argumento da função de agregação COUNT.
• O ponto (.) é utilizado nas constantes numéricas, e para separar os nomes de esquemas, tabelas e colunas.

4.1.5. Comentários

Um comentário é uma seqüência arbitrária de caracteres começando por dois hífens e prosseguindo até o fim da linha como, por exemplo:

-- Este é um comentário em conformidade com o padrão SQL-92

Como alternativa, podem ser utilizados blocos de comentários no estilo C:

/* comentário de várias linhas
 * com aninhamento: /* bloco de comentário aninhado */
 */

onde o comentário começa por /* e se estende até encontrar a ocorrência correspondente de */. Estes blocos de comentários podem estar aninhados, conforme especificado no padrão SQL, mas diferentemente da linguagem C, permitindo transformar em comentário grandes blocos de código contendo blocos de comentários. [6] [7]

Os comentários são removidos do fluxo de entrada antes de prosseguir com a análise sintática, sendo substituídos por espaço em branco.

4.1.6. Precedência léxica

A Tabela 4-1 mostra a precedência e a associatividade dos operadores no PostgreSQL. A maioria dos operadores possui a mesma precedência e associatividade esquerda. A precedência e a associatividade dos operadores está codificada no analisador, podendo ocasionar um comportamento contra-intuitivo; por exemplo, os operadores booleanos < e > possuem uma precedência diferente dos operadores booleanos <= e >=. Também, em alguns casos é necessário adicionar parênteses ao utilizar uma combinação de operadores unários e binários. Por exemplo,

SELECT 5 ! - 6;

será analisado como

SELECT 5 ! (- 6);

porque o analisador não possui a menor idéia — até ser tarde demais — que o ! é definido como operador unário-direito (postfix), e não um operador binário colocado entre os operandos (infix). Neste caso, para obter o comportamento desejado deve ser escrito:

SELECT (5 !) - 6;

Este é o preço a ser pago pela extensibilidade.

Deve ser observado que as regras de precedência dos operadores também se aplicam aos operadores definidos pelos usuários que possuem os mesmos nomes dos operadores nativos mencionados acima. Por exemplo, se for definido pelo usuário um operador "+" para algum tipo de dado personalizado, este terá a mesma precedência do operador "+" nativo, não importando o que faça.

Quando um nome de operador qualificado pelo esquema é utilizado na sintaxe OPERATOR como, por exemplo, em

SELECT 3 OPERATOR(pg_catalog.+) 4;

a construção OPERATOR é assumida como tendo a precedência padrão mostrada na Tabela 4-1 para "qualquer outro" operador. Isto é sempre verdade, não importando qual o nome do operador especificado dentro de OPERATOR().