Este capítulo descreve a sintaxe [1] da linguagem SQL, estabelecendo a base para compreender os próximos capítulos que descrevem detalhadamente como os comandos SQL são utilizados para definir e modificar os dados.
Aconselha-se aos usuários já familiarizados com a linguagem SQL a leitura cuidadosa deste capítulo, porque existem várias regras e conceitos implementados pelos bancos de dados SQL de forma inconsistente, ou específicos do PostgreSQL.
Uma entrada SQL é constituída por uma seqüência de comandos. Um comando é composto por uma seqüência de símbolos (tokens [2] [3] [4] [5] ) terminada por um ponto-e-vírgula (";"). O fim do fluxo de entrada também termina o comando. Quais símbolos são válidos depende da sintaxe particular de cada comando. [6]
Um símbolo pode ser uma palavra chave, um identificador, um identificador entre aspas, um literal (ou constante), ou um caractere especial. Geralmente os símbolos são separados por espaço em branco (espaço, tabulação ou nova-linha), mas não há necessidade se não houver ambigüidade (o que geralmente só acontece quando um caractere especial está adjacente a outro tipo de símbolo). [7] [8] [9]
Além disso, podem existir comentários na entrada SQL. Os comentários não são símbolos, são efetivamente equivalentes a espaço em branco.
Por exemplo, o que vem a seguir é uma entrada SQL válida (sintaticamente):
SELECT * FROM MINHA_TABELA; UPDATE MINHA_TABELA SET A = 5; INSERT INTO MINHA_TABELA VALUES (3, 'oi você');
Esta é uma seqüência de três comandos, um por linha (embora isto não seja requerido; pode haver mais de um comando na mesma linha, e um único comando pode ocupar várias linhas).
A sintaxe do SQL não é muito consistente com relação a quais símbolos identificam comandos e quais são operandos ou parâmetros. Geralmente os primeiros símbolos são o nome do comando e, portanto, no exemplo mostrado acima pode-se dizer que estão presentes os comandos "SELECT", "UPDATE" e "INSERT". Mas, por exemplo, o comando UPDATE sempre requer que o símbolo SET apareça em uma determinada posição, e esta forma particular do comando INSERT também requer a presença do símbolo VALUES para estar completa. As regras precisas da sintaxe de cada comando estão descritas na Parte VI.
Os símbolos, como SELECT, UPDATE e VALUES presentes no exemplo acima, são exemplos de palavras chave, ou seja, palavras que possuem o significado definido na linguagem SQL. Os símbolos 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 símbolo é 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 [10] [11] - áéç... - 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 o aplicativo 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 aplicativos portáveis, aconselha-se a colocar o nome sempre entre aspas, ou nunca entre aspas.
Exemplo 4-1. Utilização de letras acentuadas em nomes de tabelas
Este exemplo tem por finalidade mostrar a utilização de letras acentuadas nos nomes de tabelas. Deve ser observado o problema na conversão de letras maiúsculas e minúsculas acentuadas utilizando o idioma C. [12]
=> 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)
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. [13] [14] [15] [16]
Uma constante cadeia de caracteres no SQL é uma seqüência arbitrária de caracteres envolta por apóstrofos (') como, por exemplo, 'Esta é uma cadeia de caracteres'. A forma de escrever um apóstrofo dentro de uma constante cadeia de caracteres, em conformidade com o padrão SQL, é colocando dois apóstrofos adjacentes como, por exemplo, 'Maria D''Almeida'. O PostgreSQL também permite utilizar a contrabarra ("\") como caractere de escape para colocar apóstrofos dentro de cadeia de caracteres como, por exemplo, 'Maria D\'Almeida'.
Outra extensão do PostgreSQL é permitir a utilização dos escapes de contrabarra no estilo da linguagem C: \b para voltar apagando (backspace), \f para avanço de formulário (form feed), \n para nova-linha (newline), \r para retorno do carro (carriage return), \t para tabulação (tab) e \xxx, onde xxx é um número octal, é o byte com o código correspondente (É sua responsabilidade que as seqüências de byte criadas sejam caracteres válidos no conjunto de codificação de caracteres do servidor). Qualquer outro caractere vindo após a contrabarra é interpretado literalmente. Portanto, para incluir uma contrabarra em uma constante do tipo cadeia de caracteres devem ser escritas duas contrabarras adjacentes.
O caractere com o código zero não pode estar presente em uma constante cadeia de caracteres.
Duas constantes cadeia de caracteres separadas apenas por espaço em branco com pelo menos um caractere de nova-linha, são concatenadas e tratadas efetivamente como se a cadeia de caracteres tivesse sido escrita em uma constante. Por exemplo:
SELECT 'foo' 'bar';
equivale a
SELECT 'foobar';
mas
SELECT 'foo' 'bar';
não é uma sintaxe válida (este comportamento, um tanto ao quanto esquisito, é especificado no padrão SQL; o PostgreSQL está seguindo o padrão).
Exemplo 4-2. Constantes cadeia de caracteres ocupando mais de uma linha
Este exemplo tem por finalidade mostrar a utilização de uma constante cadeia de caracteres ocupando mais de uma linha para inserir dados em uma tabela. No Oracle e no DB2 há necessidade do operador de concatenação ||, enquanto no SQL Server há necessidade do operador de concatenação +. Só não houve necessidade do operador de concatenação no PostgreSQL. Em todos os exemplos a tabela AÇÃO foi definida como uma tabela temporária, utilizando a sintaxe específica do gerenciador de banco de dados. [17]
PostgreSQL 8.0.0:
=> CREATE TEMPORARY 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)
SQL Server 2000:
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)
Oracle 10g:
SQL> CREATE GLOBAL TEMPORARY TABLE "AÇÃO"
2 ("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
DB2 9.1:
db2 => DECLARE GLOBAL TEMPORARY TABLE "AÇÃO"
db2 (cont.) => ("COD_AÇÃO" int, "NOME_AÇÃO" varchar(32))
db2 (cont.) => ON COMMIT PRESERVE ROWS;
db2 => INSERT INTO SESSION."AÇÃO" ("COD_AÇÃO", "NOME_AÇÃO") VALUES (1,'um nome' ||
db2 (cont.) => ' de ação' ||
db2 (cont.) => ' muito longo');
db2 => SELECT * FROM SESSION."AÇÃO";
COD_AÇÃO NOME_AÇÃO
----------- --------------------------------
1 um nome de ação muito longo
Embora a sintaxe padrão para especificar constantes cadeia de caracteres seja muitas vezes conveniente, quando a cadeia de caracteres desejada contém vários apóstrofos ou contrabarras pode ser difícil compreendê-la, uma vez que estes devem ser duplicados. Para tornar o comando mais legível em uma situação como esta, o PostgreSQL disponibiliza uma outra maneira para escrever constantes cadeia de caracteres, chamada de "delimitação por cifrão" (dollar quoting). Uma constante cadeia de caracteres delimitada por cifrão é formada por um cifrão ($), uma "marca" opcional com zero ou mais caracteres, outro cifrão, uma seqüência arbitrária de caracteres constituindo o conteúdo da cadeia de caracteres, o cifrão, a mesma "marca" que iniciou esta delimitação por cifrão, e um cifrão. Para exemplificar são mostradas abaixo duas formas diferentes de especificar a cadeia de caracteres "Maria D'Almeida" usando delimitação por cifrão:
$$Maria D'Almeida$$ $UmaMarca$Maria D'Almeida$UmaMarca$
Deve ser observado que, dentro da cadeia de caracteres delimitada por cifrão, os apóstrofos podem ser utilizados sem necessidade de escape. Na verdade, nenhum caractere dentro de uma cadeia de caracteres delimitada por cifrão recebe escape: o conteúdo da cadeia de caracteres é sempre escrito literalmente. As contrabarras não são caracteres especiais, e os caracteres de cifrão também não são, a menos que sejam parte da seqüência correspondendo à marca de abertura.
É possível aninhar constantes cadeias de caracteres delimitadas por cifrão escolhendo marcas diferentes a cada nível de aninhamento. É utilizado com mais freqüência ao escrever definições de funções. Por exemplo:
$function$
BEGIN
RETURN ($1 ~ $q$[\t\r\n\v\\]$q$);
END;
$function$
Aqui a seqüência $q$[\t\r\n\v\\]$q$ representa o literal cadeia de caracteres delimitada por cifrão [\t\r\n\v\\], que será reconhecido quando o corpo da função for executado pelo PostgreSQL. Mas uma vez que a seqüência não corresponde ao delimitador de cifrão externo $function$, são apenas mais alguns caracteres dentro da constante no que diz respeito à cadeia de caracteres externa.
A marca de uma cadeia de caracteres delimitada por cifrão, se houver, segue as mesmas regras de um identificador não delimitado, exceto que não pode conter o caractere cifrão. Nas marcas, letras maiúsculas e minúsculas são diferentes e, portanto, $marca$Conteúdo da cadeia de caracteres$marca$ está correto, mas $MARCA$Conteúdo da cadeia de caracteres$marca$ não está.
Uma cadeia de caracteres delimitada por cifrão, vindo após uma palavra chave ou um identificador, deve ser separada do mesmo por um espaço em branco, senão o cifrão delimitador da cadeia de caracteres delimitada por cifrão será considerado como parte do identificador que o precede.
A cadeia de caracteres delimitada por cifrão não faz parte do padrão SQL mas é, muitas vezes, uma forma mais conveniente de escrever literais cadeias de caracteres complicados do que a forma em conformidade com o padrão usando apóstrofos. É particularmente útil para representar constantes cadeias de caracteres dentro de outras constantes, geralmente necessário na definição de funções em linguagens procedurais. Com a sintaxe de apóstrofos, cada contrabarra no exemplo acima deveria ser escrita como quatro contrabarras, que seriam reduzidas para duas contrabarras na análise da constante cadeia de caracteres original e, depois, para uma quando a constante cadeia de caracteres interna fosse re-analisada durante a execução da função.
Uma constante do tipo cadeia de bits se parece com uma constante do tipo cadeia de caracteres contendo a letra B (maiúscula ou minúscula) imediatamente antes do apóstrofo de abertura (sem espaços separadores) como, por exemplo, B'1001'. Os únicos caracteres permitidos dentro de uma constante do tipo cadeia de bits são 0 e 1.
Como forma alternativa, constantes do tipo cadeia de bits podem ser especificadas usando a notação hexadecimal, colocando a letra X (maiúscula ou minúscula) no início como, por exemplo, X'1FF'. Esta notação equivale a uma constante do tipo cadeia de bits contendo quatro dígitos binários para cada dígito hexadecimal.
As duas formas de constantes do tipo cadeia de bits podem ocupar mais de uma linha, da mesma forma que uma constante do tipo cadeia de caracteres. A delimitação por cifrão não pode ser utilizada para o tipo cadeia de bits.
São aceitas constantes numéricas nas seguintes formas gerais:
dígitos dígitos.[dígitos][e[+-]dígitos] [dígitos].dígitos[e[+-]dígitos] dígitose[+-]dígitos
onde dígitos são um ou mais dígitos decimais (0 a 9). Deve haver pelo menos um dígito antes ou depois do ponto decimal, se este for usado. Deve haver pelo menos um dígito após a marca de expoente (e), caso esteja presente. Não podem existir espaços ou outros caracteres incorporados à constante. Deve ser observado que os sinais menos e mais que antecedem a constante não são, na verdade, considerados parte da constante, e sim um operador aplicado à constante.
Abaixo são mostrados alguns exemplos de constantes numéricas válidas:
42
3.5
4.
.001
5e2
1.925e-3
Uma constante numérica não contendo o ponto decimal nem o expoente é presumida, inicialmente, como sendo do tipo integer, se o seu valor for apropriado para o tipo integer (32 bits); senão é presumida como sendo do tipo bigint, se o seu valor for apropriado para o tipo bigint (64 bits); caso contrário, é assumida como sendo do tipo numeric. As constantes que contêm pontos decimais e/ou expoentes são sempre presumidas inicialmente como sendo do tipo numeric.
O tipo de dado atribuído inicialmente para a constante numérica é apenas o ponto de partida para os algoritmos de resolução de tipo. Na maioria dos casos, a constante é automaticamente convertida no tipo mais apropriado conforme o contexto. Quando for necessário, pode-se impor que o valor numérico seja interpretado como sendo de um tipo de dado específico, definindo a conversão a ser aplicada. Por exemplo, pode-se impor que o valor numérico seja tratado como sendo do tipo real (float4) escrevendo:
REAL '1.23' -- estilo cadeia de caracteres 1.23::REAL -- estilo PostgreSQL (histórico)
Na verdade estes são apenas casos especiais da notação geral de conversão mostrada a seguir.
Pode ser declarada uma constante de um tipo arbitrário utilizando uma das seguintes notações:
tipo 'cadeia de caracteres' 'cadeia de caracteres'::tipo CAST ( 'cadeia de caracteres' AS tipo )
O texto da constante cadeia de caracteres é passado para a rotina de conversão da entrada para o tipo chamado tipo. O resultado é uma constante do tipo indicado. A conversão explícita de tipo pode ser omitida caso não haja ambigüidade com relação ao tipo que a constante deva ter (por exemplo, quando é atribuída diretamente para uma coluna de uma tabela), neste caso é convertida automaticamente.
A constante cadeia de caracteres pode ser escrita utilizando tanto a notação regular do padrão SQL quanto a delimitação por cifrão.
Também é possível especificar a conversão de tipo utilizando a sintaxe semelhante à chamada de função
nome_do_tipo ( 'cadeia de caracteres' )
mas nem todos os nomes de tipo podem ser usados desta forma; consulte a Seção 4.2.8 para obter informações adicionais.
As sintaxes ::, CAST() e chamada de função também podem ser utilizadas para especificar a conversão de tipo em tempo de execução para expressões arbitrárias, conforme mostrado na Seção 4.2.8. Porém, a forma tipo 'cadeia de caracteres' somente pode ser utilizada para especificar o tipo de uma constante literal. Outra restrição com relação à sintaxe tipo 'cadeia de caracteres', é que não funciona em tipo matriz (arrays); deve ser usado :: ou CAST() para especificar o tipo de uma constante matriz.
Um nome de operador é uma seqüência com até NAMEDATALEN-1 (por padrão 63) caracteres da seguinte lista:
+ - * / < > = ~ ! @ # % ^ & | ` ?
Entretanto, existem algumas poucas restrições para os nomes de operadores: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 símbolos.
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.
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 ou declaração preparada. Em outros contextos, o caractere cifrão pode ser parte de um identificador ou de uma constante cadeia de caracteres delimitada por cifrão.
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. Consulte 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 constante cadeia ou identificador entre aspas.
Os dois-pontos (:) são utilizados para selecionar "fatias" de matrizes (consulte 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 utilizado 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.
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. [18] [19] [20] [21]
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.
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.
Tabela 4-1. Precedência dos operadores (decrescente)
| Operador/Elemento | Associatividade | Descrição |
|---|---|---|
| . | esquerda | separador de nome de tabela/coluna |
| :: | esquerda | conversão de tipo estilo PostgreSQL |
| [ ] | esquerda | seleção de elemento de matriz |
| - | direita | menos unário |
| ^ | esquerda | exponenciação |
| * / % | esquerda | multiplicação, divisão, módulo |
| + - | esquerda | adição, subtração |
| IS | IS TRUE, IS FALSE, IS UNKNOWN, IS NULL | |
| ISNULL | teste de nulo | |
| NOTNULL | teste de não nulo | |
| (qualquer outro) | esquerda | os demais operadores nativos e os definidos pelo usuário |
| IN | membro de um conjunto | |
| BETWEEN | contido em um intervalo | |
| OVERLAPS | sobreposição de intervalo de tempo | |
| LIKE ILIKE SIMILAR | correspondência de padrão em cadeia de caracteres | |
| < > | menor que, maior que | |
| = | direita | igualdade, atribuição |
| NOT | direita | negação lógica |
| AND | esquerda | conjunção lógica |
| OR | esquerda | disjunção lógica |
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().
| [1] |
sintaxe — do Lat. syntaxe < Gr. sýntaxis, arranjo, disposição — parte da estrutura gramatical de uma língua que contém as regras relativas à combinação das palavras em unidades maiores (como as orações), e as relações existentes entre as palavras dentro dessas unidades. PRIBERAM - Língua Portuguesa On-Line. (N. do T.) |
| [2] |
token — gramática — Uma unidade básica da linguagem, gramaticalmente indivisível, como uma palavra chave, um operador ou um identificador. FOLDOC - Free On-Line Dictionary of Computing (N. do T.) |
| [3] |
SQL Server — token — Na procura de texto integral (full-text search), uma palavra ou uma cadeia de caracteres identificada por um quebrador de palavra (word breaker). SQL Server 2005 Books Online — Glossary of Terms (N. do T.) |
| [4] |
DB2 — Os tokens são as unidades sintáticas básicas do SQL. O token é uma seqüência de um ou mais caracteres. O token não pode conter caracteres branco, a menos que seja uma constante cadeia ou um identificador delimitado, que podem conter brancos. DB2 Version 9 for Linux, UNIX, and Windows (N. do T.) |
| [5] |
token — [processamento de dados] s. indicação, f.; marca, f.; símbolo, m.; sinal, m.; unidade distinguível em uma seqüência de caracteres. token | Portuguese | Dictionary & Translation by Babylon (N. do T.) |
| [6] |
léxico — do Gr. léxicon, relativo às palavras — dicionário de línguas clássicas antigas; dicionário abreviado; conjunto dos vocábulos de uma língua; dicionário dos vocábulos usados num domínio especializado (ciência, técnica). PRIBERAM - Língua Portuguesa On-Line. (N. do T.) |
| [7] |
Oracle — Todo objeto do banco de dados possui um nome. Na declaração SQL, o nome do objeto é representado por um identificador delimitado ou por um identificador não delimitado. O identificador delimitado começa e termina por aspas ("). Se for dado um nome ao objeto do esquema utilizando identificador delimitado, então será necessário utilizar aspas sempre que for feita referência a este objeto. Um identificador não delimitado não é envolto por qualquer pontuação. — As seguintes regras se aplicam tanto aos identificadores delimitados quanto aos não delimitados, a não ser quando dito o contrário: 1. Os nomes devem ter de 1 a 30 bytes de comprimento, com as seguintes exceções: Os nomes dos bancos de dados são limitados a 8 bytes; Os nomes dos links para bancos de dados podem ter comprimento de até 128 bytes. 2. Os identificadores não delimitados não podem ser palavras reservadas do Oracle. Os identificadores delimitados podem ser palavras reservadas, embora isto não seja recomendado. Oracle® Database SQL Reference 10g Release 1 (10.1) Part Number B10759-01 (N. do T.) |
| [8] |
SQL Server — Identificador é o nome de um objeto do banco de dados. O identificador pode ter de 1 a 128 caracteres. SQL Server 2005 Books Online — Glossary of Terms (N. do T.) |
| [9] |
DB2 — Existem dois tipos de identificadores SQL: comuns e delimitados. O identificador comum é uma letra maiúscula seguida por zero ou mais caracteres, cada um dos quais é uma letra maiúscula, um dígito ou o caractere sublinhado. O identificador comum não deve ser idêntico a uma palavra reservada. O identificador delimitado é uma seqüência de um ou mais caracteres envoltos por aspas. São utilizadas duas aspas consecutivas para representar uma aspa dentro de um identificador delimitado. Desta maneira o identificador pode incluir letras minúsculas. DB2 Version 9 for Linux, UNIX, and Windows (N. do T.) |
| [10] |
diacrítico — do Gr. diakritikós, que se pode distinguir — diz-se dos sinais gráficos com que se notam os caracteres alfabéticos para lhe dar um valor especial. PRIBERAM - Língua Portuguesa On-Line. (N. do T.) |
| [11] |
diacrítico — (1) Uma marca aplicada ou anexada a um símbolo para criar um novo símbolo que representa um valor novo ou modificado. (2) Uma marca aplicada a um símbolo sem importar se muda o valor deste símbolo. No primeiro caso o diacrítico geralmente representa um valor independente (por exemplo, um acento, tom, ou outra informação lingüística). Glossary of Unicode Terms (N. do T.) |
| [12] |
Exemplo escrito pelo tradutor, não fazendo parte do manual original. |
| [13] |
Oracle — Os símbolos literal e valor constante são sinônimos e referem a um valor de dado fixo. Por exemplo, 'JACK', 'BLUE ISLAND' e '101' são todos literais caractere; 5001 é um literal numérico. Literais caractere são envoltos por apóstrofos, o que permite ao Oracle distingui-los dos nomes dos objetos do esquema. Oracle® Database SQL Reference 10g Release 1 (10.1) Part Number B10759-01 (N. do T.) |
| [14] |
SQL Server — A constante é um grupo de símbolos que representa um valor de dado específico. O formato da constante depende do tipo de dado do valor representado pela mesma. Por exemplo, 'abc' é uma constante cadeia de caracteres, 123 é uma constante inteira, 'December 16, 1999' é uma constante data-hora, e 0x02FA é uma constante binária. SQL Server 2005 Books Online — Glossary of Terms (N. do T.) |
| [15] |
DB2 — A constante (algumas vezes chamada de literal) especifica um valor. As constantes são classificadas como constantes cadeias e constantes numéricas. As constantes numéricas são ainda classificadas em inteiras, de ponto flutuante e decimal. Todas as constantes possuem o atributo NOT NULL. O valor zero negativo em uma constante numérica (-0) possui o mesmo valor do zero sem o sinal (0). Os tipos definidos pelo usuário possuem uma tipagem forte. Isto significa que os tipos definidos pelo usuário somente são compatíveis com o seu próprio tipo. Entretanto, a constante possui um tipo de dado nativo. Portanto, uma operação envolvendo um tipo definido pelo usuário e uma constante somente será possível se o tipo definido pelo usuário tiver sido convertido para o tipo nativo da constante, ou se a constante tiver sido convertida para o tipo definido pelo usuário. DB2 Version 9 for Linux, UNIX, and Windows (N. do T.) |
| [16] |
Cada tipo em Java possui "literais", que são a maneira como os valores constantes daquele tipo são escritos. Ken Arnold e James Gosling - Programando em Java - Makron Books - 1997 (N. do T.) |
| [17] |
Exemplo escrito pelo tradutor, não fazendo parte do manual original. |
| [18] |
Oracle — Em um comando o comentário pode aparecer entre quaisquer palavras chave, parâmetros ou marcas de pontuação. Podem ser incluídos comentários em um comando de duas formas: 1 - Começar o comentário por uma barra e um asterisco (/*). Prosseguir com o texto do comentário. Este texto pode abranger várias linhas. Terminar o comentário por um asterisco e uma barra (*/). Os caracteres de abertura e de fechamento não precisam estar separados do texto por espaço ou por quebra de linha. 2 - Começar o comentário por -- (dois hífens). Prosseguir com o texto do comentário. O texto não pode se estender para uma nova linha. Terminar o comentário pela quebra de linha. (O manual não cita comentários aninhados. Experiências com o SQL*Plus mostraram que não é possível aninhar comentários /* dentro de comentários /*, mas que é possível colocar comentários -- dentro de comentários /*). Oracle® Database SQL Reference 10g Release 1 (10.1) Part Number B10759-01. (N. do T.) |
| [19] |
SQL Server — O comentário -- indica um texto fornecido pelo usuário. Os comentários podem ser inseridos como uma linha separada, aninhados no final da linha de comando do Transact-SQL, ou dentro de um comando Transact-SQL. O servidor não avalia o comentário. Os comentários inseridos com -- são terminados pelo caractere de nova-linha. SQL Server 2005 Books Online — -- (Comment) (Transact-SQL) (N. do T.) |
| [20] |
SQL Server — O comentário /*...*/ indica um texto fornecido pelo usuário. O texto entre /* e */ não é avaliado pelo servidor. Os comentários podem ser inseridos em linhas separadas ou dentro do comando Transact-SQL. Os comentários de várias linhas devem ser indicados por /* e */. Um convenção de estilo bastante usada para comentários de várias linhas é começar a primeira linha por /*, as linhas seguintes por **, e terminar por */. Não existe comprimento máximo para os comentários. São suportados comentários aninhados. Se a seqüência de caracteres /* ocorrer em qualquer lugar dentro de um comentário existente, esta será tratada como sendo o início de um comentário aninhado e, portanto, requer a marca de fechamento de comentário */. Se a marca de fechamento de comentário não existir, será gerado um erro. SQL Server 2005 Books Online — /*...*/ (Comment) (Transact-SQL) (N. do T.) |
| [21] |
DB2 — Os comentários SQL são demarcados (introduzidos por /* e terminados por */), ou simples (introduzidos por dois hífens consecutivos e terminando no fim da linha). Os comandos SQL estáticos podem incluir comentários da linguagem hospedeira ou comentários SQL. Os comentários podem ser especificados em qualquer lugar onde um espaço pode ser especificado, exceto dentro de um token delimitador ou entre as palavras chave EXEC e SQL. DB2 Version 9 for Linux, UNIX, and Windows (N. do T.) |
