: GRILLE DE SUIVI PAR LE CONCEPTEUR DE CONTENUS

NOTE D’OPPORTUNITÉ DU PROJET FOAD

ANNEXE 06 : GRILLE DE SUIVI PAR LE CONCEPTEUR DE CONTENUS

Uma entrada SQL é constituída por uma seqüência de comandos. Um comando é composto por uma seqüência de símbolos (tokens (http://foldoc.org/?query=token) 2345_{) 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).

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.

4.1.1. Identificadores e palavras chave

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 9 - áéç... -

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

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úscúlas e minúsculas acentuadas utilizando o idioma C. 10

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

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

Lista de relações

-- 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

-- 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

=> \dt ação

Lista de relações

=> \dt AÇÃO

Lista de relações

-- 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

-- 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

=> \dt "AÇÃO"

Lista de relações

=> 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. 11121314

4.1.2.1. Constantes do tipo cadeia de caracteres

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, é colocar 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. 15

PostgreSQL 8.0.0:

=> 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)

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 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

DB2 8.1:

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

4.1.2.2. Constantes cadeia de caracteres delimitadas por cifrão

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, nem são os caracteres de cifrão, a menos que sejam parte da seqüência correspondento a 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.

4.1.2.3. Constantes do tipo cadeia de bits

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.

4.1.2.4. Constantes numéricas

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.

4.1.2.5. Constantes de outros tipos

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

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.

4.1.3. Operadores

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.

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 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 utlizado como argumento da função de agregação COUNT.

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

Dans le document d ’ un projet de formation hybride ou entièrement à distance GUIDE (Page 116-124)