BD SQL DDL DML (versao antiga)

Texto

(1)Banco de Dados - II. Introdução à linguagem SQL (utilizando SGBD Oracle 9i, release 2). Conceitos Iniciais Breve Histórico A SQL (Structured Query Language – linguagem de consulta estruturada) é a linguagem utilizada em praticamente todos os bancos de dados relacionais. Embora seja um “padrão” há diferenças nas implementações dessa linguagem nos vários SGBD’s (sistemas gerenciadores de bancos de dados) no mercado, ou seja, cada fabricante de software cria extensões (com sintaxes, funções, recursos, etc.) específicos de seus sistemas, formando diferentes “dialetos” e “versões” da linguagem. É possível escrever aplicações utilizando apenas o SQL padrão (com os comandos comuns à maioria dos SGBD’s), porém, na prática, muitas vezes faz-se uso das sintaxes proprietárias para aproveitar recursos específicos ou conseguir um melhor desempenho. A SQL foi desenvolvida pela IBM em meados dos anos 70 e inicialmente era denominada “SEQUEL” (que é com se lê a sigla SQL, em inglês). Contudo o primeiro SGBD lançado com uma implementação da linguagem SQL, em 1979, foi o Oracle (na época a empresa chama-se Relational Software). Em 1986, o American National Standards Institute (ANSI) definiu um padrão para a linguagem SQL, homologando-a para trabalhar com bancos de dados relacionais — sendo depois também aceito pelo International Standards Organization (ISO). Em 1992 foi publicado o ANSI SQL-92, também conhecido como SQL2, um dos padrões mais difundidos. A atualização mais recente é o SQL-99 (SQL3), de 1999, que entre outras coisas, define o tratamento de objetos complexos.. Características Básicas •. As queries (consultas) da SQL têm uma estrutura semelhante à linguagem natural (em inglês).. •. As instruções de manipulação de dados sempre trabalham com tabelas e/ou retornam resultados em forma de tabelas — com linhas (registros, também chamados de “tuplas”) e colunas (campos ou “atributos”).. •. É uma linguagem não-procedural, isto é, as sentenças em SQL declaram a tarefa a ser realizada sem a necessidade de especificar os procedimentos passo-a-passo que o sistema deve seguir para executá-la.. •. Independência física dos dados e dispositivos: não especifica o método de acesso aos dados e nem como estão armazenados (os SGBD’s possuem um “otimizador” que se encarrega de a maneira de recuperar os dados).. Tipos de comandos Os comandos da linguagem SQL podem ser divididos em grupos: •. DML (data manipulation language) – englobam os comandos que correspondem às quatro funções essenciais de manipulação de dados: recuperação, inclusão, atualização e exclusão de dados — respectivamente os comandos SELECT, INSERT, UPDATE e DELETE. Outros comandos importantes: COMMIT e ROLLBACK.. •. DDL (data definition language) – para definição (criação, alteração e eliminação) de estruturas. Principais comandos: CREATE, ALTER e DROP.. •. DCL (data control language) – para controle da base de dados. Principais comandos: GRANT e REVOKE.. SQL*Plus O Oracle SQL*Plus é uma ferramenta client para acesso ao servidor Oracle, servindo com uma interface simples e eficiente (baseada em prompt de comando) para que os usuários possam editar e executar instruções SQL e PL/SQL, além de permitir a consulta de dados e geração de arquivos. Inicialmente iremos utilizar os comandos: CONNECT, DISCONNECT, SET, EDIT, RUN, DESCRIBE, SHOW e EXIT. No SQL*Plus, comandos SQL podem ser escritos com quebras de linha — na configuração padrão, um sinal de ponto-evírgula (;) marca o fim da sentença. Já os comandos específicos da interface deve ser escritos em uma única linha, não necessitando do ponto-e-vírgula para definir o final do comando. Outra diferença, no SQL*Plus, entre comandos SQL e comandos da interface é que as instruções SQL (ou blocos PL/SQL) são armazenadas em um buffer (SQL buffer) antes de serem enviados ao servidor Oracle — sendo que o buffer continua armazenando o último comando SQL digitado (e apenas um único comando), podendo ser editado ou executado novamente. Já os comandos específicos da interface não passam por esse buffer.. BD-II: Linguagem SQL (parte 1). Uninove – prof. André Santos (set./2002 – rev.: set./2005). pág. 1 / 12.

(2) Exemplo para Estudo Para estudar os comandos SQL, vamos nos basear no seguinte exemplo:. 1. Moeda. cota. n. Taxa Cambial. Vamos criar 2 tabelas: uma contendo o cadastro das “moedas” e outra com as “taxas de conversão cambial” para a cotação diária das moedas. Tabela: MOEDA Campo. Tipo Tam. Dec. Obrig. PK UK FK Tab. Ref.. CODIGO. C. 3. NOME. C. 30. SISCOMEX. N. 3. Campo Ref.. Validação. Descrição Sigla da moeda. X. Nome da Moeda. X. Código da moeda no Siscomex. X. Tabela: TAXA_CAMBIAL Campo. Tipo Tam. Dec. Obrig. PK UK FK Tab. Ref.. COD_MOEDA. C. 3. X. DATA_TAXA. D. -. X. VAL_TAXA. N. 12. 6. X. X. MOEDA. Campo Ref.. Validação Descrição. COD_MOEDA. Sigla da moeda Data da cotação. >0. Valor da cotação (em R$). Siglas e nomenclaturas utilizadas: PK (primary key – chave primária): é o atributo, ou conjunto de atributos, que identifica univocamente cada linha da tabela. Todos os campos que formam uma PK são obrigatórios, ou seja, não podem aceitar nulos (NOT NULL). FK (foreign key – chave estrangeira): é o atributo, ou conjunto de atributos, que faz o relacionamento com um registro de outra tabela (integridade referencial), ou seja, aponta para (ou faz referência a) a chave primária da tabela relacionada. UK (unique key – chave única): define um atributo, ou conjunto de atributos, que não admite ocorrências repetidas nas linhas de uma tabela, porém não necessariamente é um campo obrigatório. Pode ser chamada também de “chave alternativa”. CK (check constraint – regra de validação): é uma verificação para garantir a integridade de dados, conforme uma regra estabelecida. NN (not null – não nulo): indica um tipo de check constraint para definir campos obrigatórios, isto é, que não podem aceitar o valor nulo (o nulo indica um valor desconhecido ou não definido para o campo).. Tipos de dados utilizados no modelo lógico e correspondência no BD Oracle: Caractere (C) – campos texto. No Oracle, geralmente, irão corresponder ao tipo VARCHAR2. Numérico (N) – campos com valores numéricos. No Oracle, iremos utilizar o tipo NUMBER. Data (D) – campos com data e hora. No Oracle, correspondem ao tipo DATE.. Para os campos tipo VARCHAR2 e NUMBER, pode-se especificar o tamanho máximo do campo entre parênteses. VARCHAR2( t ) : onde t corresponde ao tamanho máximo em bytes (geralmente, correspondendo ao número de caracteres). NUMBER( t , d ) : onde t corresponde ao número máximo de dígitos (precisão), sem considerar o ponto decimal, e d é o número máximo de casas decimais (escala).. BD-II: Linguagem SQL (parte 1). Uninove – prof. André Santos (set./2002 – rev.: set./2005). pág. 2 / 12.

(3) Comandos SQL - DDL Para criar uma tabela, definindo as colunas de sua estrutura, utilizamos o comando CREATE TABLE: CREATE TABLE moeda ( codigo VARCHAR2(3), nome VARCHAR2(30), siscomex NUMBER(3) ); Assim criamos uma tabela com o nome “MOEDA” e duas colunas, conforme a descrição no exemplo em estudo. Porém, desse modo, a tabela não possui nenhuma verificação de integridade (constraint), nem mesmo chave primária (PK) — lembrando que sem integridade de chave primária a tabela não obedece rigorosamente à 1ª forma normal. Podemos usar o comando DESCRIBE (ou simplesmente DESC), do SQL*Plus, para visualizar a estrutura da tabela: SQL> DESC moeda Nome Nulo? ----------------------------------------- -------CODIGO NOME SISCOMEX. Tipo ---------------------------VARCHAR2(3) VARCHAR2(30) NUMBER(3). Vamos alterar a tabela, adicionando a constraint de PK: ALTER TABLE moeda ADD PRIMARY KEY (codigo); Podemos conferir que a definição da chave primária deixa o respectivo campo como obrigatório (not null): SQL> DESC moeda Nome Nulo? ----------------------------------------- -------CODIGO NOT NULL NOME SISCOMEX. Tipo ---------------------------VARCHAR2(3) VARCHAR2(30) NUMBER(3). Pensando num ambiente profissional, há um problema na forma como foi criada essa chave primária. •. Não foi definido um nome para identificar a regra de validação (constraint) de chave primária.. Nota: Constraints de chave primária (PK) ou unique (UK), automaticamente, criam índices para que o SGBD possa fazer a verificação de maneira eficiente. Podemos verificar isso, consultando o dicionário de dados do Oracle: SQL> SELECT constraint_name, constraint_type, table_name 2 FROM user_constraints; CONSTRAINT_NAME C TABLE_NAME ------------------------------ - -----------------------------SYS_C003005 P MOEDA. O nome da constraint, “SYS_C003005”, foi gerado pelo SGBD Oracle. Vamos eliminar essa constraint e depois recriá-la pensando na adequação ao aspecto já comentado. Alterando a tabela Moeda eliminando a constraint SYS_C003005: ALTER TABLE moeda DROP CONSTRAINT sys_c003005;. Recriando a chave primária com o nome “PK_MOEDA”: ALTER TABLE moeda ADD CONSTRAINT pk_moeda PRIMARY KEY (codigo);. BD-II: Linguagem SQL (parte 1). Uninove – prof. André Santos (set./2002 – rev.: set./2005). pág. 3 / 12.

(4) Verificando o dicionário de dados: SQL> SELECT constraint_name, constraint_type, table_name 2 FROM user_constraints; CONSTRAINT_NAME C TABLE_NAME ------------------------------ - -----------------------------PK_MOEDA P MOEDA. O campo NOME_MOEDA deve ser obrigatório. Para isso vamos definir uma outra constraint na tabela. Uma constraint not null é definida como uma propriedade de uma coluna da tabela, por isso o modo de escrever o comando ALTER TABLE é diferente — vamos alterar a tabela para modificar a coluna desejada definindo a constraint not null (ao invés de alterar a tabela para adicionar diretamente uma constraint). ALTER TABLE moeda MODIFY nome CONSTRAINT nn_moeda_nome NOT NULL; A constraint foi criada com o nome “NN_MOEDA_NOME” para identificá-la no dicionário de dados (caso contrário teria um nome gerado automaticamente pelo SGBD). Finalmente, o campo “SICOMEX” também é uma chave de valor único (UK) — não admitindo repetições, de modo semelhante a uma chave primária. Para adicionar a constraint de chave única (unique): ALTER TABLE moeda ADD CONSTRAINT uk_moeda_siscomex UNIQUE (siscomex); Verificando a estrutura da tabela: SQL> DESC moeda Nome ----------------------------------------CODIGO NOME SISCOMEX. Nulo? -------NOT NULL NOT NULL. Tipo ---------------------------VARCHAR2(3) VARCHAR2(30) NUMBER(3). Verificando as constraints do esquema do nosso usuário: SQL> SQL> SQL> SQL> 2. COLUMN search_condition FORMAT A40 SET LINESIZE 150 SELECT constraint_name, constraint_type, table_name, search_condition FROM user_constraints;. CONSTRAINT_NAME -----------------------------UK_MOEDA_SISCOMEX PK_MOEDA NN_MOEDA_NOME. C U P C. TABLE_NAME SEARCH_CONDITION ------------------------------ -----------------------------MOEDA MOEDA MOEDA "NOME" IS NOT NULL. Podemos criar uma tabela já definindo as constraints, no mesmo comando. Vamos eliminar a tabela Moeda e depois criá-la novamente dessa maneira. DROP TABLE moeda; Criando a tabela e definindo as constraints de cada coluna: CREATE TABLE moeda ( codigo VARCHAR2(3) CONSTRAINT pk_moeda PRIMARY KEY, nome VARCHAR2(30) CONSTRAINT nn_moeda_nome NOT NULL, siscomex NUMBER(3) CONSTRAINT nn_moeda_siscomex UNIQUE );. Na tabela TAXA_CAMBIAL há 3 itens novos a serem comentados: • Uma constraint de integridade referencial (chave estrangeira). • Uma chave composta. • Check constraints para regras de validação.. BD-II: Linguagem SQL (parte 1). Uninove – prof. André Santos (set./2002 – rev.: set./2005). pág. 4 / 12.

(5) Inicialmente vamos criar a tabela TAXA_CAMBIAL apenas com a PK e as constraints NN. Porém há uma dificuldade: note que a chave primária é composta, ou seja, é formada por mais de um campo. Desse modo, não é possível definir a constraint junto à especificação da coluna da tabela. Qualquer constraint que faça referência a mais de uma coluna da tabela, deve ser especificada separadamente, como um componente independente, na tabela. Abaixo segue a forma como podemos fazer isso: Repare na vírgula, indicando que CREATE TABLE taxa_cambial ( termina a especificação da coluna cod_moeda VARCHAR2(3), “VAL_TAXA” e suas constraints. data_taxa DATE, val_taxa NUMBER(12,6) CONSTRAINT nn_taxa_val NOT NULL, CONSTRAINT pk_taxa PRIMARY KEY ( cod_moeda, data_taxa ) ); SQL> SET LINESIZE 80 SQL> SQL> DESC taxa_cambial Nome ----------------------------------------COD_MOEDA DATA_TAXA VAL_TAXA. Nulo? -------NOT NULL NOT NULL NOT NULL. Tipo ---------------------------VARCHAR2(3) DATE NUMBER(12,6). Agora vamos alterar a tabela, definindo a FK e a CK: ALTER TABLE taxa_cambial ADD CONSTRAINT fk_taxa_moeda FOREIGN KEY (cod_moeda) REFERENCES moeda; OBS.: Opcionalmente pode-se indicar o nome do campo (ou campos) na cláusula references que correspondem à chave primária (PK) da “tabela-pai” referenciada — isso seria feito apenas para maior clareza na leitura do comando (pois o Oracle já procuraria a chave primária da tabela referenciada, mesmo sem essa declaração). No comando acima, na última linha poderia constar então: REFERENCES moeda (codigo);. A check constraint para impor que o valor seja maior que zero: ALTER TABLE taxa_cambial ADD CONSTRAINT ck_taxa_val CHECK ( val_taxa > 0 );. Para criar a tabela com todas as constraints num único comando, poderíamos fazer: CREATE TABLE taxa_cambial ( cod_moeda VARCHAR2(3) CONSTRAINT fk_taxa_moeda REFERENCES moeda, data_taxa DATE, val_taxa NUMBER(12,6) CONSTRAINT nn_taxa_val NOT NULL CONSTRAINT ck_taxa_val CHECK ( val_taxa > 0 ), CONSTRAINT pk_taxa PRIMARY KEY ( cod_moeda, data_taxa ) );. Integridade referencial com “exclusão em cascata”. Em geral, uma constraint de integridade referencial (relacionamento, chave estrangeira) não permite que se exclua um registro da “tabela pai” que esteja sendo referenciado por FK’s de uma tabela “filha” (caso contrário ficariam registros “órfãos”).. BD-II: Linguagem SQL (parte 1). Uninove – prof. André Santos (set./2002 – rev.: set./2005). pág. 5 / 12.

(6) Exemplo: SQL> INSERT INTO moeda (codigo, nome) VALUES ('USD', 'Dólar'); 1 linha criada. SQL> INSERT INTO moeda (codigo, nome) VALUES ('EUR', 'Euro'); 1 linha criada. SQL> INSERT INTO taxa_cambial VALUES ('USD', SYSDATE, 2.35); 1 linha criada. SQL> INSERT INTO taxa_cambial VALUES ('EUR', SYSDATE, 3.40); 1 linha criada. SQL> SELECT * FROM moeda; COD --USD EUR. NOME SISCOMEX ------------------------------ ---------Dólar Euro. SQL> SELECT * FROM taxa_cambial; COD --USD EUR. DATA_TAX VAL_TAXA -------- ---------12/09/05 2,35 12/09/05 3,4. SQL> DELETE moeda 2 WHERE codigo = 'USD'; DELETE moeda * ERRO na linha 1: ORA-02292: restrição de integridade (ALUNO.FK_TAXA_MOEDA) violada - registro filho localizado. Porém, às vezes é desejável que os registros filhos sejam excluídos automaticamente, ao eliminar um registro pai (ou seja, excluir todos os registros de uma tabela, relacionados ao registro da tabela “pai”). Assim, de modo diferente, ainda é garantida a integridade de dados (pois não ficam registros “órfãos”, já que os registros “filhos” também são eliminados). Esse recurso é conhecido como “exclusão em cascata” e pode ser implementado em uma constraint referencial, através da cláusula ON DELETE CASCADE.. Para fazer os testes, vamos eliminar a constraint referencial, para recriá-la depois com o recurso citado. SQL> ALTER TABLE taxa_cambial 2 DROP CONSTRAINT fk_taxa_moeda; Tabela alterada.. Redefinindo a integridade referencial, com exclusão em cascata: ALTER TABLE taxa_cambial ADD CONSTRAINT fk_taxa_moeda FOREIGN KEY (cod_moeda) REFERENCES moeda ON DELETE CASCADE;. Verificando o novo comportamento: SQL> SELECT * FROM moeda; COD --USD EUR. NOME SISCOMEX ------------------------------ ---------Dólar Euro. BD-II: Linguagem SQL (parte 1). Uninove – prof. André Santos (set./2002 – rev.: set./2005). pág. 6 / 12.

(7) SQL> SELECT * FROM taxa_cambial; COD --USD EUR. DATA_TAX VAL_TAXA -------- ---------12/09/05 2,35 12/09/05 3,4. SQL> DELETE moeda 2 WHERE codigo = 'USD'; 1 linha deletada. SQL> SELECT * FROM moeda; COD NOME SISCOMEX --- ------------------------------ ---------EUR Euro SQL> SELECT * FROM taxa_cambial; COD DATA_TAX VAL_TAXA --- -------- ---------EUR 12/09/05 3,4. Adicionando e eliminando colunas. Para adicionar uma coluna numa tabela, por exemplo um campo para observações: ALTER TABLE moeda ADD obs_moeda VARCHAR2(50); Podemos adicionar vários campos ao mesmo tempo: ALTER TABLE moeda ADD ( obs_1_moeda VARCHAR2(50), obs_2_moeda VARCHAR2(50) ); Verificando: SQL> DESC moeda Nome ----------------------------------------CODIGO NOME SISCOMEX OBS_MOEDA OBS_1_MOEDA OBS_2_MOEDA. Nulo? -------NOT NULL NOT NULL. Tipo ---------------------------VARCHAR2(3) VARCHAR2(30) NUMBER(3) VARCHAR2(50) VARCHAR2(50) VARCHAR2(50). Nulo? -------NOT NULL NOT NULL. Tipo ---------------------------VARCHAR2(3) VARCHAR2(30) NUMBER(3) VARCHAR2(50) VARCHAR2(50). Nulo? -------NOT NULL NOT NULL. Tipo ---------------------------VARCHAR2(3) VARCHAR2(30) NUMBER(3). Para eliminar uma coluna: ALTER TABLE moeda DROP COLUMN obs_moeda; SQL> DESC moeda Nome ----------------------------------------CODIGO NOME SISCOMEX OBS_1_MOEDA OBS_2_MOEDA. Ou várias colunas ao mesmo tempo: ALTER TABLE moeda DROP ( obs_1_moeda , obs_2_moeda );. SQL> DESC moeda Nome ----------------------------------------CODIGO NOME SISCOMEX BD-II: Linguagem SQL (parte 1). Uninove – prof. André Santos (set./2002 – rev.: set./2005). pág. 7 / 12.

(8) No Oracle, a opção de eliminar colunas de uma tabela, só foi disponibilizada a partir da versão 8i (8.1.5) — antes dessa versão era necessário recriar a tabela, caso se desejasse eliminar colunas.. Alterando propriedades de colunas. Para aumentar o tamanho de uma coluna, pode-se fazer: ALTER TABLE moeda MODIFY nome VARCHAR2(40); SQL> DESC moeda Nome ----------------------------------------CODIGO NOME SISCOMEX. Nulo? -------NOT NULL NOT NULL. Tipo ---------------------------VARCHAR2(3) VARCHAR2(40) NUMBER(3). OBS.: Em muitos casos, para diminuir o tamanho ou alterar o datatype de uma coluna, a tabela deve estar sem dados nessa coluna (ou seja, deve constar nulo no campo correspondente, em todos os registros — ou a tabela deve estar vazia, sem registros).. Colunas com valor “default”. Em alguns casos, o projetista do banco de dados pode definir que colunas tenham valores “default”, isto é, caso não seja informado um valor respectivo à coluna, na inclusão da linha na tabela, a coluna assume o valor definido como padrão. Por exemplo, para especificar que a moeda padrão seja “USD”, na tabela TAXA_CAMBIAL: ALTER TABLE taxa_cambial MODIFY cod_moeda DEFAULT 'USD'; Teste: SQL> INSERT INTO moeda (codigo, nome) VALUES ('USD', 'Dólar'); 1 linha criada. SQL> SELECT * FROM moeda; COD --EUR USD. NOME SISCOMEX ------------------------------ ---------Euro Dólar. SQL> SELECT * FROM taxa_cambial; COD DATA_TAX VAL_TAXA --- -------- ---------EUR 12/09/05 3,4 SQL> INSERT INTO taxa_cambial (data_taxa, val_taxa) VALUES (SYSDATE, 2.37); 1 linha criada. SQL> SELECT * FROM taxa_cambial; COD --EUR USD. DATA_TAX VAL_TAXA -------- ---------12/09/05 3,4 12/09/05 2,37. BD-II: Linguagem SQL (parte 1). Uninove – prof. André Santos (set./2002 – rev.: set./2005). pág. 8 / 12.

(9) Para definir o valor “default” na criação da tabela, poderíamos fazer da seguinte forma: CREATE TABLE taxa_cambial ( cod_moeda VARCHAR2(3) DEFAULT 'USD' CONSTRAINT fk_taxa_moeda REFERENCES moeda, data_taxa DATE, val_taxa NUMBER(12,6) CONSTRAINT nn_taxa_val NOT NULL CONSTRAINT ck_taxa_val CHECK ( val_taxa > 0 ), CONSTRAINT pk_taxa PRIMARY KEY ( cod_moeda, data_taxa ) );. Eliminando uma tabela referenciada por chaves estrangeiras. Ao tentar eliminar uma tabela que é referenciada por constraints de integridade referencial, com o comando DROP TABLE simples, por exemplo: DROP TABLE moeda;. Ocorreria um erro, conforme mostrado abaixo: SQL> DROP TABLE moeda; DROP TABLE moeda * ERRO na linha 1: ORA-02449: chaves primárias/exclusivas na tabela referenciadas por chaves externas. Verificando as constraints do esquema do usuário: SQL> SET LINESIZE 150 SQL> SQL> SELECT constraint_name, 2 constraint_type, 3 table_name, 4 search_condition 5 FROM user_constraints; CONSTRAINT_NAME -----------------------------NN_MOEDA_NOME PK_MOEDA NN_MOEDA_SISCOMEX NN_TAXA_VAL CK_TAXA_VAL PK_TAXA FK_TAXA_MOEDA. C C P U C C P R. TABLE_NAME -----------------------------MOEDA MOEDA MOEDA TAXA_CAMBIAL TAXA_CAMBIAL TAXA_CAMBIAL TAXA_CAMBIAL. SEARCH_CONDITION -----------------------------"NOME" IS NOT NULL. "VAL_TAXA" IS NOT NULL val_taxa > 0. 7 linhas selecionadas.. Especificamente a constraint referencial: SQL> SELECT constraint_name, 2 constraint_type, 3 table_name, 4 r_constraint_name 5 FROM user_constraints 6 WHERE constraint_type = 'R'; CONSTRAINT_NAME C TABLE_NAME R_CONSTRAINT_NAME ------------------------------ - ------------------------------ -----------------------------FK_TAXA_MOEDA R TAXA_CAMBIAL PK_MOEDA. Se realmente deseja-se eliminar a tabela MOEDA (correndo-se o risco de deixar registros “órfãos”, nas tabelas filhas), pode-se acrescentar a cláusula CASCADE CONSTRAINTS: DROP TABLE moeda CASCADE CONSTRAINTS;. BD-II: Linguagem SQL (parte 1). Uninove – prof. André Santos (set./2002 – rev.: set./2005). pág. 9 / 12.

(10) Consultando o dicionário de dados, verifica-se que a constraint referencial da “tabela filha” também foi eliminada: SQL> SELECT constraint_name, constraint_type, table_name, search_condition 2 FROM user_constraints; CONSTRAINT_NAME -----------------------------NN_TAXA_VAL CK_TAXA_VAL PK_TAXA. C C C P. TABLE_NAME SEARCH_CONDITION ------------------------------ -----------------------------TAXA_CAMBIAL "VAL_TAXA" IS NOT NULL TAXA_CAMBIAL val_taxa > 0 TAXA_CAMBIAL. Renomeando uma tabela. Para renomear um tabela, por exemplo, de “MOEDA” para “MOEDA_CAMBIO”. RENAME moeda TO moeda_cambio;. Regras para nomes de objetos no Oracle: • Devem ter de 1 a 30 caracteres (com exceção de databases, limitados a 8 caracteres, e de database links, que podem ter até 128 caracteres); • Podem conter letras, números e o caracter de sublinhado _ (“underline” ou “underscore”). O Oracle também aceita os caracteres $ e #, porém não recomenda que sejam utilizados pelos usuários (assim como letras acentuadas). Objetos do tipo “database link” também podem conter pontos (.) e o caracter @. • Devem começar com uma letra (a menos que o nome esteja entre aspas — o que traria um trabalho extra na escrita dos comandos). • Normalmente, nomes não são “case sensitive”, ou seja, o Oracle ignora a diferença entre minúsculas e maiúsculas (sendo que os nomes são armazenados em maiúsculas no dicionário de dados). • Não podem coincidir com palavras reservadas do Oracle.. BD-II: Linguagem SQL (parte 1). Uninove – prof. André Santos (set./2002 – rev.: set./2005). pág. 10 / 12.

(11) Comandos SQL - DML Abaixo segue a sintaxe básica dos comandos SQL para manipulação de dados (recuperação, inclusão, atualização e exclusão). Para inclusão de dados em uma tabela:. INSERT INTO tabela (campo_1, campo_2, ..., campo_n) VALUES (valor_campo_1, valor_campo2, ..., valor_campo_n). lista de campos. Os valores devem ocupar as posições na mesma seqüência em que foram indicados os campos correspondentes. A lista de campos não é obrigatória — nesse caso a lista de valores corresponder a todos os campos da tabela, obedecendo a seqüência de sua estrutura. Os valores podem ser quaisquer expressões que retornem valores válidos para os respectivos campos. Para atualização de dados em uma tabela:. UPDATE tabela SET campo_1 = valor_1, campo_2 = valor_2, ..., campo_n = valor_n WHERE condições_de_seleção As condições de seleção são expressões lógicas (normalmente com testes envolvendo campos da tabela), e que irão restringir a ação do comando apenas às linha que satisfizerem as condições. Se a cláusula WHERE não for especificada, serão processadas todas as linhas (registros) da tabela. Para exclusão de linhas (registros) em uma tabela:. DELETE FROM tabela WHERE condições_de_seleção Não é obrigatório escrever a palavra FROM. Para recuperação (leitura) de dados de tabelas:. SELECT coluna_1, coluna_2, ..., coluna_n FROM tabela_A, tabela_B, ..., tabela_x WHERE condições_de_seleção ORDER BY campo_i, campo_ii, ..., campo_ix. lista de colunas a serem retornadas lista de tabelas lista de campos para ordenação. Se a lista de colunas tiver campos de nomes iguais (a serem retornados) mas de tabelas diferentes, deve-se usar um “qualificador” do tipo tabela.campo para indicar a qual tabela refere-se o campo a ser retornado. Se desejarmos retornar todas as colunas de uma tabela, podemos usar asterisco (*) no lugar da lista de colunas. A cláusula FROM especifica as tabelas (ou views) que são as fontes de dados. Se houver mais de uma tabela, é muito recomendável utilizar o qualificador comentado acima. Além disso, se houver mais de uma tabela, a cláusula WHERE assume também o papel de estabelecer as condições para junção (join) das linhas da tabela, especificando o relacionamento entre as tabelas — caso não seja especificada a condição de relacionamento será retornado um “produto cartesiano” entre as linhas selecionadas das tabelas, isto é, a quantidade de linhas da consulta será igual as linhas selecionadas de uma tabela vezes as linhas selecionadas da outra tabela. Se a cláusula ORDER BY não for especificada, as linhas serão retornadas na ordem conforme a leitura do SGBD — não necessariamente será a ordem natural na qual os registros foram inseridos na tabela. Representação de valores literais: •. Texto: strings devem estar delimitados entre apóstrofos (aspas simples: ' ).. •. Valores numéricos: são representados diretamente, sem separadores de milhar, e com ponto como separador de decimais caso seja necessário.. •. Datas: podem ser representados como textos (entre apóstrofos) que serão convertidos (conversão implícita) para datas — se estiverem obedecendo ao formato de data padrão configurado no banco de dados (na instalação “default”, normalmente DD-MMM-YY, onde DD = dia (com 2 dígitos), MMM = 3 letras iniciais do mês (em inglês) e YY = 2 dígitos correspondentes ao ano). Outra maneira de representar datas (e horas) é através da função TO_DATE.. BD-II: Linguagem SQL (parte 1). Uninove – prof. André Santos (set./2002 – rev.: set./2005). pág. 11 / 12.

(12) Commit e Rollback •. COMMIT – confirma as alterações (inserts, updates e deletes), gravando os dados atualizados nas tabelas do banco de dados.. OBS.: um comando DDL (por exemplo um CREATE, ALTER ou DROP) força um commit implícito. •. ROLLBACK – descarta as últimas alterações, ainda não gravadas.. Iremos estudar as operações com os comandos COMMIT e ROLLBACK com mais detalhes posteriormente, quando abordarmos o assunto “transações”.. Exemplos de comando DML: insert into MOEDA (COD_MOEDA, NOME_MOEDA) values ('USD', 'Dólar');. insert into MOEDA values ('EUR', 'Euro');. update MOEDA set NOME_MOEDA = 'Dólar americano' where COD_MOEDA = 'USD';. insert into TAXA_CAMBIAL (COD_MOEDA, DATA_TAXA, VAL_COMPRA_TAXA, VAL_VENDA_TAXA) values ('USD', '18-SEP-02', 3.292, 3.294); Função TO_DATE: a 1ª string indica a data e/ou hora e. delete from TAXA_CAMBIAL a 2ª define o formato na qual a data/hora é expressa. where COD_MOEDA = 'USD' and DATA_TAXA = to_date('19/09/2002','dd/mm/yyyy');. insert into TAXA_CAMBIAL values ('USD', sysdate, 3.292, 3.294); Função SYSDATE: retorna a data e hora corrente do servidor.. select * from MOEDA;. select T.COD_MOEDa, T.DATA_TAXA, T.VAL_VENDA_TAXA, M.NOME_MOEDA from TAXA_CAMBIAL T, Cada nome de tabela pode ser acompanhado de um “alias” (apelido) MOEDA M para facilitar a escrita dos qualificadores de campos no comando. where T.COD_MOEDA = M.COD_MOEDA;. commit;. BD-II: Linguagem SQL (parte 1). Uninove – prof. André Santos (set./2002 – rev.: set./2005). pág. 12 / 12.

(13)