Desenvolvimento de Bancos de Dados Seguros

DESENVOLVIMENTO DE BANCOS DE DADOS SEGUROS
Introdução aos Sistemas Gerenciadores de

Banco de Dados e a linguagem SQL-ANSI
Mostrar como os bancos de dados são controlados pelos principais Sistemas Gerenciadores de Banco de Dados
e as características da linguagem SQL.
NESTE TÓPICO
DADOS E INFORMAÇÃO
SISTEMA GERENCIADORES DE BANCO DE DADOS (SGBD)
O SURGIMENTO DA LINGUAGEM SQL
CARACTERISTICAS DOS SGBDS
CARACTERÍSTICAS DA LINGUAGEM SQL
Referências
NESTE TÓPICO
SISTEMA GERENCIADORES DE BANCO DE DADOS (SGBD)
Referências
Marcar
tópico
Olá alunos,
Bem-vindos à área de desenvolvimento de banco de dados que constituí toda a base da informação para a área
de TI e vamos conhecer alguns dos principais sistemas de gerenciamento de banco de dados mais utilizados no
mercado.
Primeiramente, porque utilizar um banco de dados?
Os nossos ancestrais já gravavam com tintas através de pinturas em cavernas, conhecidas como pinturas
rupestres. Era uma forma de deixar registrado o seu cotidiano.
Após a revolução industrial, as empresas desenvolveram o seu “sistema de informação” muito antes do
surgimento do computador. Registravam os seus dados em papeis, livros contábeis, etc. As pessoas guardavam
telefones de parentes e amigos em cadernetas, isto era um banco de dados? Sim, escritos com canetas ou
impressos através de uma máquina de datilografia em papeis, mas era um banco de dados.
Com o surgimento do computador, tínhamos um dispositivo conhecido como memória principal, onde
podíamos armazenar dados ou valores em variáveis. Mas este tipo de memória é volátil: os dados ficam nessas
variáveis temporariamente, durante a execução do software e se a energia elétrica cessar, também todo o
conteúdo da memória principal será perdido.
Então, certos dados não podem ficar neste tipo de memória, não podemos deixar armazenados, por exemplo, o
número do RA ou o nome do aluno somente em variáveis, temos que armazená-los de forma permanente. E
como isto foi resolvido ao longo do tempo?
Primeiramente foram utilizados cartões perfurados, onde o furo significava o bit 1 e o não furo o bit 0, estes
bits eram colocados em colunas (na vertical) no cartão em um conjunto de 8 bits, que formavam 1 Byte e
podiam representar um caractere em cada coluna. Isto mesmo, o banco de dados, já na forma binária ficavam
em cartões de papel.
Depois começaram a utilizar rolos de fitas magnéticas, onde, também, imitando o modelo dos cartões, os
caracteres foram colocados em colunas na fita, onde o bit 1 era magnetizado e o bit 0 representava a área não
magnetizada. Tínhamos aí então, o banco de dados na forma magnetizada.
Em setembro de 1957, a IBM lança o dispositivo IBM 305 RAMAC, que depois ficou conhecido como Hard
Disk (HD), um “HD” que pesava cerca de uma tonelada e tinha uma incrível capacidade de armazenamento de
5 Mega Bytes!
Veja na figura abaixo, a geometria de um HD:
A geometria de um HD.
No caso das memórias eletrônicas como a memória principal, a unidade de armazenamento é a célula e na HD,
a unidade de armazenamento dos dados são os setores que ficam em trilhas. Portanto, atualmente, quando
falamos em banco de dados, este banco está armazenado de forma permanente em discos, pois é um tipo de
memória não volátil.
“DATA” do latim: dados, (“datum”, dado no singular). “Data Banks”, “DataBase”, Banco de Dados.
O dado possui um valor absoluto, por exemplo, se eu dizer: “33700”, isto é apenas um dado, mas se eu disser:
“O salário de um deputado é de R$ 33700,00”, isto traz um valor significativo, representa uma informação.
Portanto, a informação é a abstração dos dados ou os dados processados.
SISTEMA GERENCIADORES DE BANCO DE DADOS
(SGBD)
Com a crescente demanda por banco de dados na forma computacional, vários sistemas surgiram para
controlar os dados armazenados em discos, conhecidos como SGBD (Sistema Gerenciador de Banco de
Dados) como o modelo de dados hierárquico e o modelo de dados em redes. Estes tipos de modelos
consumiam uma grande quantidade de hardware e ficava difícil a manutenção.
Sistema Gerenciador de Banco de Dados (SGBD)

Em junho de 1970, o matemático Edgard F Codd publica um artigo ( “Relational Model of Data for Large
Shared Data Banks”) propondo um modelo de Banco de Dados Relacional, que se tornou a base de todos os
SGBDs presentes no mercado. Os dados ou valores são armazenados em atributos ou colunas ou popularmente
conhecidos como campos, estes campos ficam em tabelas e estas tabelas são relacionadas com outras tabelas.
Em 1971, a IBM inicia o projeto do System R, um SGBD baseado no Modelo Relacional de Codd.
O próprio Edgard Codd cria uma espécie de linguagem para que o desenvolvedor pudesse implantar o banco de
dados e criar a massa de dados, permitindo a manutenção e a consulta aos dados. Esta linguagem ficou
conhecida como SEQUEL (Structured English QUEry Language).
Isto permitiu que o desenvolvedor, o analista ou o usuário ficasse independente da linguagem de programação
ou do programador e podia simplificar a consulta e a manutenção em diversas quantidades de dados. A ideia
foi tão boa que em 1986 a ANSI (American National Standards Institute) resolve padronizar a linguagem e
torna-la obrigatória em todos os SGBDs que fossem lançados no mercado, com a abreviação da sua sigla
para: SQL (Structured Query Language) ou também conhecida como SQL- ANSI.
Vamos supor que em um consultório médico, o médico solicitasse à sua secretária que verificasse quais foram
os pacientes que fizeram o exame de endoscopia nos últimos três meses. Se o banco de dados está em
prontuários em um arquivo de pastas suspensas, a secretária terá que abrir cada prontuário para verificar os
dados. Se estes dados estiverem em um banco de dados relacional, poderemos com uma única instrução SQL
retornar as informações necessárias.
Neste exemplo, a massa de dados ainda é pequena, mas imagine ter de fazer este tipo de consulta em um banco
de dados com milhões de registros, a mesma instrução SQL também serviria.
A partir das vantagens em se utilizar SGBD, muitas fabricas de softwares lançaram este tipo de produto no
mercado:
O primeiro SGBD comercial lançado no mercado foi o Oracle da Relational Software Inc, que mudou o nome
da empresa para Oracle Corporation.
Em seguida a IBM lança o DB2, depois a Microsoft lança o MS SQL Server.
Atualmente temos também SGBDs famosos na categoria GPL (General Public License), com licença pública,
como o MySQL (hoje também da Oracle Corp), PostgreSQL e FireBird.
Os SGBDs possuem as seguintes características:
 Integridade dos dados.
 Segurança de acesso aos dados.
 Atomicidade das transações.
 Concentração dos dados em um repositório.
 Independência de linguagem de programação.

 Imposição de regras de utilização para toda e qualquer aplicação que se conectar ao banco
de dados.
Em relação a segurança de dados, os SGBDs possuem controle de acesso aos usuários, controle das transações:
todos os comandos SQL que causam alterações no banco de dados, controle de concorrência: pois podemos ter
vários usuários acessando a mesma base de dados, em um mesmo instante e permitem estabelecer políticas de
backup.
Mais adiante, veremos como mais detalhes a parte da segurança de dados dos principais SGBDs do mercado.
Banco de Dados Relacionais

A linguagem SQL praticamente funciona como uma interface entre o usuário e a base de dados, que é
controlada pelo Sistema Gerenciador de Banco de Dados.
Como é uma linguagem padronizada para todos os SGBDs, poderemos utilizar qualquer software de SGBD de
qualquer fabricante, que todos possuem a linguagem SQL com os mesmos comandos, com alguns pequenos
detalhes diferentes em relação a algumas funções.
As principais características são:
 Comandos para criar a estrutura do banco de dados (criar as tabelas).
 Comandos para realizar manutenções nas tabelas criadas.
 Comandos para cadastrar, alterar e apagar dados nas tabelas.
 Comandos para criar usuários e controlar os acessos.
 Comandos para controlar as transações realizadas.
 Comando para realizar consultas e estabelecer relatórios.
O SQL está dividido nas seguintes categorias de comandos:
CATEGORIA: COMANDOS:
CREATE
DDL ALTER
(Data Definition Language) TRUNCATE
DROP
INSERT
DML
UPDATE
(Data Manipulation Language)
DELETE
DCL GRANT
(Data Control Language) REVOKE
DTL COMMIT
(Data Transaction Language) ROLLBACK
DQL
SELECT
(Data Query Language)
A linguagem SQL é mais simples de se utilizar do que qualquer linguagem de programação e deve ser de
conhecimento de qualquer profissional da área de TI.
Como a linguagem SQL não é uma linguagem procedural (não possui os comandos de decisão e de repetição),
ela pode ser embutida em qualquer linguagem de programação. Podemos, por exemplo, criar uma aplicação
para o usuário final em Java e colocar os comandos SQL no código em Java para realizar alguma transação
com o banco de dados.
O Banco de Dados fica armazenado em discos (HD), controlados por um SGBD com a linguagem SQL e
através da conexão da linguagem de programação (qualquer linguagem de programação se conecta com
qualquer SGBD), o usuário poderá acessar os dados em disco, através de uma aplicação.
SAIBA MAIS...
Dê uma olhada nos links abaixo para saber mais sobre os Sistemas Gerenciadores de banco de Dados e a
linguagem SQL:
https://education.oracle.com/pt_BR/learn/database/pPillar_2
https://www.microsoft.com/en-us/sql-server/developer-get-started/
https://www.postgresql.org/docs/
Neste tópico realizamos uma introdução aos Sistemas Gerenciadores de Banco de Dados e apresentamos as
principais características. Vimos também, como é importante conhecermos a linguagem SQL e a sua aplicação.
Utilização dos comandos DDL (Data Definition

Language) do SQL
Trabalhar com os comandos da categoria Data Definition Language (DDL) do SQL.
NESTE TÓPICO
UTILIZANDO OS COMANDOS DDL
UTILIZANDO O COMANDO CREATE
UTILIZANDO O COMANDO ALTER
UTILIZANDO O COMANDO TRUNCATE
UTILIZANDO O COMANDO DROP
DECLARANDO CHAVE PRIMÁRIA
DECLARANDO CHAVE ESTRANGEIRA
Referências
NESTE TÓPICO

Referências
Marcar
tópico
Olá alunos,
Vamos instalar o SGBD Oracle e iniciar a construção das tabelas do nosso banco de dados.
A Oracle foi a primeira empresa a lançar no mercado um SGBD no modelo relacional e é o Sistema
Gerenciador de Banco de Dados mais utilizado atualmente.
Este sistema pode ser instalado tanto em alta plataforma (para MainFrame) como em baixa plataforma (para
microcomputadores) e temos as versões atuais como Oracle 10g, 11g, 12c e 18c.
Cada versão possui duas versões comerciais e uma gratuita:
 Oracle Enterprise Edition (EE) versão comercial para qualquer tipo de empresas,
principalmente para empresas de grande porte.
 Oracle Standard Edition (SE) versão comercial para qualquer tipo de empresas, mais para
empresas de pequeno e médio porte.
 Oracle Express Edition (XE) versão gratuita para área acadêmica ou para microempresas.
Vamos fazer o download da versão gratuita Oracle 11g Express Edition (Oracle XE) que pode ser adquirido
através do link:
https://www.oracle.com/technetwork/database/database-technologies/express-edition/downloads/xe-prior-
releases-5172097.html
No site da Oracle você vai encontrar diversos tipos de produtos, como o ambiente para o desenvolvimento da
linguagem Java.
Veja na imagem abaixo, a tela para download do Oracle:
Você deve aceitar a licença e depois pode escolher uma das versões para diversos tipos de sistemas
operacionais, vamos escolher a versão para Windows em 64 bits. Esta versão poderá ser instalada no Windows
XP, Vista, 8, 10 e para versões do Windows para servidor, desde o Windows Server 2003.
Para fazer o download de qualquer produto, você terá que antes fazer um cadastro para gerar um login com
nome e senha. Este login servirá para outras atividades futuras no site da Oracle, portanto, é recomendado que
você tenha um cadastro na Oracle.
Depois do download, o arquivo vem compactado (.zip), você terá que descompactar (extrair).
Abra a pasta (OracleXE112_Win64) e clique em setup.
A instalação é simples, mas logo no inicio será solicitado que você crie uma senha e confirme, esta senha
servirá para você fazer a conexão com o banco de dados. Se você esquecer esta senha, terá que instalar o
Oracle novamente.
A versão XE instala a interface “SQL PLUS”, que é nativa em todos os produtos da Oracle e também uma
interface gráfica chamada “CONCEITOS BÁSICOS DO ORACLE DATABASE 11g Express Edition” que só
existe na versão XE. Por enquanto, vamos trabalhar com o SQL PLUS, mais adiante trabalharemos com a
interface gráfica: “SQL Developer”
Após a instalação, vá para:
“TODOS OS PROGRAMAS” ---> “ORACLE DATABASE 11g Express Edition” -->
“EXECUTAR LINHA DE COMANDOS SQL”, para utilizar linhas de comandos pelo prompt (SQL PLUS).
Ao abrir o SQL PLUS é necessário antes de mais nada, realizarmos a conexão com o comando: connect ou na
forma abreviada conn. A conexão é obrigatória para realizar qualquer ação no Oracle.
SQL*Plus: Release 11.2.0.2.0 Production on Dom Out 14 19:39:16 2018
Copyright (c) 1982, 2014, Oracle. All rights reserved.
SQL> connect system

Informe a senha:
Conectado.
SQL>
Na linha 5, digitamos o comando connect, também poderíamos ter digitado CONNECT ou CONN, os
comandos podem ser escritos em letras minúsculas ou maiúsculas, o Oracle não é case sensitive. Em seguida
digitamos system que é o usuário padrão e o “super usuário” do Oracle.
Na linha 6, digite a senha, a mesma senha que você criou no momento da instalação (lembrando que se você
esqueceu a senha deverá instalar o Oracle novamente!).
Detalhe: ao digitar a senha, o cursor ficará parado, não será impresso asteriscos na tela, isto é normal no
Oracle.
Também podemos fazer a conexão da seguinte forma: conn system/senha.
Vamos fazer alguns testes, com alguns comandos úteis:
Conectado.
SQL> SELECT * FROM ALL_USERS;
USERNAME USER_ID CREATED

------------------------------ ---------- --------
XS$NULL 2147483638 29/05/14
DENILSON 49 15/05/18
RH 48 11/04/18
APEX_040000 47 29/05/14
. APEX_PUBLIC_USER 45 29/05/14
. FLOWS_FILES 44 29/05/14
. HR 43 29/05/14
. MDSYS 42 29/05/14
. ANONYMOUS 35 29/05/14
. XDB 34 29/05/14
. CTXSYS 32 29/05/14
.
. USERNAME USER_ID CREATED
. ------------------------------ ---------- --------
. APPQOSSYS 30 29/05/14
. DBSNMP 29 29/05/14
. ORACLE_OCM 21 29/05/14
. DIP 14 29/05/14
. OUTLN 9 29/05/14
. SYSTEM 5 29/05/14
. SYS 0 29/05/14
.
. 18 linhas selecionadas.
.
. SQL>
Na linha 2, utilizamos o comando para listar todos os usuários criados pelo sistema.
Para listar todas as tabelas do usuário system:
SELECT TABLE_NAME FROM USER_TABLES;
SQL> SELECT SYSDATE FROM DUAL;
SYSDATE
--------
14/10/18
SQL> SELECT SYSTIMESTAMP FROM DUAL;
SYSTIMESTAMP
. ---------------------------------------------------------------------------
. 14/10/18 20:06:53,363000 -03:00
.
. SQL> SELECT (5*40)/4 + 17 FROM DUAL;
.
. (5*40)/4+17
. -----------
. 67
.
. SQL>
Testamos mais alguns comandos, na linha 1, o comando retorna a data do sistema.

Na linha 7, o comando retorna além da data, a hora, minutos e bilionésimos de segundos em que o comando
foi executado, além das horas em relação ao meridiano de Greenwich, no caso menos três horas em relação ao
horário de Brasília.
Na linha 13, fizemos um cálculo qualquer, o comando SELECT aceita qualquer cálculo aritmético.
Mais à diante, veremos com mais detalhes o comando SELECT.
Depois de conectarmos, se formos iniciar a criação do banco de dados, a primeira coisa que faremos, é
criarmos as tabelas, utilizando a categoria de comandos DDL do SQL, no caso o comando CREATE.
Criando uma tabela:
NOMENCLATURA DE COLUNAS E TABELAS:
Não utilizar caracteres especiais (exceto o underline “_”);
Começar com uma letra e não com um número;
Evitar acentuação e “ç”;
Não utilizar espaços.
A sintaxe do comando CREATE:
CREATE TABLE nomeTabela (
nomeColuna1 tipo restrição,
nomeColunan tipo restrição);
Para verificarmos a estrutura da tabela:
DESCRIBE nomeTabela; ou DESC nomeTabela;
TIPOS DE DADOS MAIS UTILIZADOS:
char(n):
Aceita caracteres com tamanho 1 até 2000 caracteres.
varchar(n):
Aceita caracteres de tamanho variável com valor máximo de 2000 caracteres.
varchar2(n):
Aceita caracteres de tamanho variável com valor máximo de 4000 caracteres.
number(n,d):
Valores numéricos tipo inteiro ou com casas decimais.
date:
Armazena data e pode trabalhar com os valores: sysdate (data atual do sistema) ou systimestamp (data e hora
atual do sistema).
long:
Caracteres de tamanho variável com tamanho máximo de 2GB (um tipo por tabela).
raw e long raw: (até a versão Oracle 8i, a partir da versão 9i utiliza-se BLOB)
Para dados gráficos de áudio e imagens.
TIPOS DE RESTRIÇÕES (CONSTRAINT):
NULL ou NOT NULL:
Para receber ou não valores nulos.
UNIQUE:
Os valores não podem ser repetidos.
CHECK:
Especifica os valores que uma coluna pode assumir.
Ex: idade NUMBER(3) CHECK (idade >= 16);
DEFAULT:
Determina um valor padrão para a coluna.
Ex: dtAdmissao DATE DEFAULT SYSDATE;
PRIMARY KEY:
Cria a chave primária.
FOREIGN KEY:
Com a cláusula REFERENCES implementa a integridade referencial.
Veja no vídeo abaixo, um exemplo de criação de tabela:
Após criarmos a tabela, se houver necessidade de realizar qualquer tipo de alteração, utilizamos o
comando ALTER:
MANUTENÇÃO EM TABELAS:
Para incluirmos uma nova coluna (campo) ou constraint (restrição) na tabela:
ALTER TABLE nomeTabela ADD nomeColuna tipo restrição;
ALTER TABLE nomeTabela ADD CONSTRAINT restrição;
Para modificarmos uma coluna existente na tabela:
ALTER TABLE nomeTabela MODIFY (nomeColuna tipo restrição);
Para excluirmos uma coluna existente na tabela:
ALTER TABLE nomeTabela DROP COLUMN nomeColuna;
Para alterar o nome de uma coluna (campo) na tabela:
ALTER TABLE nomeTabela RENAME COLUMN nomeCampo TO novoNomeCampo;
Para alterar o nome da tabela:
ALTER TABLE nomeTabela RENAME TO novoNomeTabela;
OU
RENAME nomeTabela TO novoNomeTabela;
Para apagarmos todos os dados da tabela, utilizamos o comando:
TRUNCATE TABLE nomeTabela;
O comando limpa a tabela, mas não elimina a tabela.
Para excluirmos uma tabela:
DROP TABLE nomeTabela;
O comando elimina a tabela e também todos os dados dela.
CHAVE PRIMÁRIA (PRIMARY KEY – PK): (CONSTRAINT)
Para declarar uma chave primária:
CREATE TABLE tabelaA (
coluna1 NUMBER(5),
coluna2 VARCHAR2(30),
CONSTRAINT tabelaA_pk PRIMARY KEY(coluna1));
Declarando de forma simplificada:
coluna1 NUMBER(5) PRIMARY KEY,
coluna2 VARCHAR2(30));
Declarando mais de um campo como chave primária:
coluna1 NUMBER(5),
coluna2 NUMBER(2),
CONSTRAINT tabelaA_pk PRIMARY KEY(coluna1,coluna2));
CHAVE ESTRANGEIRA (FOREIGN KEY – FK): (CONSTRAINT)
Campo que estabelece o relacionamento entre duas tabelas. Corresponde à chave primária da tabela original.
Declarando uma chave estrangeira (É NECESSÁRIO CRIAR A tabelaA EM PRIMEIRO LUGAR):
CREATE TABLE tabelaB (
coluna1 NUMBER(5),
coluna2 NUMBER(5),
CONSTRAINT tabelaB_pk PRIMARY KEY (coluna1),
CONSTRAINT tabelaB_coluna2_fk FOREIGN KEY(coluna2) REFERENCES tabelaA (coluna chave
primária tabelaA));
OU
Forma simplificada:
CREATE TABLE tabelaB (
coluna1 NUMBER(5) PRIMARY KEY,
coluna2 NUMBER(5),
FOREIGN KEY(coluna2) REFERENCES tabelaA(coluna chave primária tabelaA));
Eliminar restrições (constraint) :
ALTER TABLE nomeTabela DROP CONSTRAINT nomeTabela_campo_fk;
Se for eliminar uma tabela com as cláusulas CONSTRAINT e REFERENCES criadas nesta tabela, o Oracle
não executará o comando DROP TABLE por motivo de segurança.
Deverá ser utilizado as cláusulas CASCADE CONSTRAINTS:
DROP TABLE nomeTabela CASCADE CONSTRAINTS;
Vamos criar a tabela Funcionario, considerando que a modelagem de dados já foi realizada:
Nome da tabela: Funcionario
Campo: Tipo: Tamanho: Restrição:
codFunc Inteiro 3 Chave primária
nomeFunc Caractere 50 Não nulo
salario Número 10,2 Não nulo
Com a forma clássica de declarar restrições, personalizando as constraints:
SQL> CREATE TABLE Funcionario(

2 codFunc NUMBER(3) constraint funcionario_pk PRIMARY KEY,
3 nomeFunc VARCHAR2(50) constraint funcionario_nome_nu NOT NULL,
4 salario NUMBER(10,2) constraint funcionario_salario_nu NOT NULL);
Tabela criada.
ou
Com declaração compactada das restrições:
CREATE TABLE Funcionario(
codFunc NUMBER(3) PRIMARY KEY,
nomeFunc VARCHAR2(50) NOT NULL,
salario NUMBER(10,2) NOT NULL);
Vamos realizar algumas modificações como exemplo:
Incluir a coluna telefone com 12 caracteres, não nula, na tabela funcionário:
SQL> ALTER TABLE Funcionario ADD telefone VARCHAR(12) NOT NULL;
Tabela alterada.
SQL> DESCRIBE Funcionario;

Nome Nulo? Tipo
----------------------------------------- -------- ----------------------------
CODFUNC NOT NULL NUMBER(3)
NOMEFUNC NOT NULL VARCHAR2(50)
. SALARIO NOT NULL NUMBER(10,2)
. TELEFONE NOT NULL VARCHAR2(12)
.
. SQL>
Na linha 1, utilizamos a comando ALTER com a clausula ADD para incluir um novo campo na tabela
Funcionário.
Na linha 5, utilizamos o comando DESCRIBE só para verificarmos como ficou a tabela depois da alteração.
Continuando, vamos alterar o tamanho do campo nomeFunc para 70 caracteres:
SQL> ALTER TABLE Funcionario MODIFY nomeFunc VARCHAR(70);
Tabela alterada.
SQL> DESC Funcionario;

Nome Nulo? Tipo
----------------------------------------- -------- ----------------------------
. SALARIO NOT NULL NUMBER(10,2)
.
. SQL>
Na linha 1, utilizamos a comando ALTER com a clausula MODIFY para aumentarmos o tamanho do campo.
Note que só colocamos o que foi alterado no caso VARCHAR(70).
Continuando, vamos alterar a coluna salário para aceitar valores nulos:
SQL> ALTER TABLE Funcionario MODIFY salario NULL;
Tabela alterada.
SQL> DESC Funcionario;

Nome Nulo? Tipo
----------------------------------------- -------- ----------------------------
. SALARIO NUMBER(10,2)
.
. SQL>
Trocar o nome do campo salario para sal:
SQL> ALTER TABLE Funcionario RENAME COLUMN salario TO sal;
Tabela alterada.
SQL>
Trocar o nome da tabela funcionario para o nome colaborador:
SQL> ALTER TABLE Funcionario RENAME TO Colaborador;
Tabela alterada.
SQL> DESC Colaborador;

Nome Nulo? Tipo
----------------------------------------- -------- ----------------------------
. SAL NUMBER(10,2)
.
. SQL>
Excluir o campo telefone:
SQL> ALTER TABLE Colaborador DROP COLUMN telefone;
Tabela alterada.
SQL>
Excluir a tabela colaborador:
SQL> DROP TABLE Colaborador CASCADE CONSTRAINTS;
Tabela eliminada.
SQL>
SAIBA MAIS...
linguagem SQL:
Neste tópico vimos como instalar o SGBD Oracle e utilizamos os comandos da categoria DDL do SQL:
CREATE, ALTER, TRUNCATE e DROP.
Utilização dos comandos DML (Data

Manipulation Language) do SQL
Trabalhar com os comandos da categoria Data Manipulation Language (DML) do SQL.
NESTE TÓPICO
INSERINDO DADOS NA TABELA
ALTERANDO DADOS NA TABELA
APAGANDO DADOS NA TABELA
Referências
NESTE TÓPICO

Referências
Marcar
tópico
Olá alunos,
Após criarmos as tabelas, o próximo passo é criar a massa de dados, relembrando que o primeiro passo é
utilizarmos os comandos da categoria DDL, como o CREATE para criarmos as tabelas e agora teremos que
utilizar os comandos da categoria DML (Data Manipulation Language) para criar e fazer alterações nos dados.
Os comandos da categoria DDL são de uso mais exclusivo dos profissionais, pois agem na estrutura das
tabelas, enquanto os comandos da categoria DML, agem sobre a massa de dados e são mais populares e os
mais utilizados, pois é o que mais interessa ao usuário: cadastrar, consultar e alterar dados.
Utilizaremos comandos DML (Data Manipulation Language) do SQL para inser, modificar e consultar
registros.
Para inserirmos dados vamos utilizar o comando INSERT:
INSERT INTO nomeTabela VALUES (valor1,valorN);
OU
INSERT INTO nomeTabela (campo1,campoN) VALUES (valor1,valorN);
No primeiro caso, temos a sintaxe básica e obrigatória para utilizarmos o comando INSERT, teremos que
entrar com os valores de acordo com a estrutura da tabela.
No segundo caso, podemos utilizar os nomes dos campos, determinando a ordem de entrada dos valores, sem
se preocupar com a estrutura das tabelas.
Para verificarmos os dados inseridos, executamos a query SELECT:
SELECT tipo campo1,campoN FROM nomeTabela;
Exemplo:
SELECT * FROM funcionario;
Esta é a sintaxe básica do comando SELECT, onde o asterístico (*) é um coringa que representa todos os
campos da tabela.
Como vimos anteriormente os registros podem ser inseridos com o comando INSERT:
INSERT INTO nomeTabela VALUES (valorCampo1,...,valorCampoN);
Na ordem como foi estruturada a tabela ou podemos determinar a ordem a serem inseridos os valores:
INSERT INTO nomeTabela (nomeCampo1,...,nomeCampoN) VALUES (valorCampo1,...,valorCampoN);
Ex:
INSERT INTO endereço (cidade,CEP) VALUES (‘São Paulo’,099990);
Um exemplo de cadastro de valores com o comando INSERT:
Como exemplo a tabela Funcionario com os seguintes campos: idFunc, nomeFunc, salario, dataAdmissao.
INSERT INTO Funcionario VALUES (202, ‘Rafael Ribeiro’, ‘2345,56’, ‘23/09/2018’)
O valor 202 será atribuído ao campo idFunc e assim por diante. Não é necessário utilizar apóstrofos.
Note que o nome, como é tipo caractere deverá ser utilizado entre apóstrofos (‘ ‘).
O salário como é tipo número com partes fracionárias, se utilizar virgula na parte fracionária (no exemplo, os
centavos) devemos colocar entre apóstrofos também. Agora você pode entrar com o valor na representação
ASCII ou britânica com o ponto em lugar da vírgula, daí não se utiliza apóstrofos. Ex: 2345.56.
A data de admissão, que é tipo date (data), também deve estar entre apóstrofos. Se você utilizar uma versão do
Oracle em inglês, deverá entrar com a data no padrão britânico: ano/mês/dia. Ex: ‘2018/09/23’.
Em resumo:
Para números inteiros: posso ou não utilizar apóstrofos.
Para números com vírgulas, caracteres e datas: utilizo apóstrofos.
Para números com ponto: não utilizo apóstrofos.
O comando INSERT pode ser utilizado para inserir um conjunto de registros que existam em outra tabela:
INSERT INTO nomeTabelaDestino SELECT * FROM nomeTabelaFonte;
Ou criar uma tabela nova com registros de outra tabela:
CREATE TABLE nomeTabelaNova AS SELECT * FROM nomeTabelaExistente;
O comando UPDATE é utilizado para alterar valores dos registros inseridos nos campos:
Não confunda o comando UPDATE com o comando ALTER TABLE, o comando ALTER TABLE serve para
alterar a estrutura da tabela enquanto o comando UPDATE altera dados de tabela.
UPDATE nomeTabela SET nomeCampo = Expressão WHERE condição;
A clausula WHERE é opcional e representa um filtro de linhas ou registros.
** Se não for utilizada a cláusula WHERE a alteração se dará em todos os registros da tabela.
Ex:
Alterar o salário da funcionária Elizabete Fontenova:
UPDATE Funcionario SET salario = '3456,77' WHERE nomeFunc = ‘Elizabete Fontenova’;
Alterar o salário de todos os funcionários com acréscimo de 10%:
UPDATE Funcionario SET salario = salario * 1.1;
Também podemos alterar dois ou mais campos de um registro no mesmo comando:
UPDATE Funcionario SET salario = ‘2345,56’, nome = ‘Raphael Ribeiro’ WHERE idFunc = 204
Veja no vídeo abaixo, um exemplo da utilização dos comandos: INSERT e UPDATE:
O comando DELETE permite apagar um ou todos os registros:
DELETE FROM nomeTabela WHERE condição;
** CUIDADO! O comando DELETE sem a cláusula WHERE apaga TODOS os registros da tabela.
Ex:
Apagar o registro do funcionário de código 101:
DELETE FROM Funcionario WHERE codFunc = 101;
Apagar todos os registros da tabela cliente:
DELETE FROM Cliente;
A diferença do comando TRUNCATE e DELETE é que o TRUNCATE apaga todos os registros da tabela e
não tem como desfazer o comando enquanto o comando DELETE pode utilizar o filtro de registros com a
clausula WHERE para apagarmos um ou alguns registros e o comando pode ser desfeito, como veremos mais
adiante.
O comando WHERE sempre vem acompanhado de uma condição onde utilizaremos os operados relacionais
e/ou os operadores lógicos.
Operadores Relacionais:
Operador Descrição
= Igual a
> Maior que
< Menor que
>= Maior ou igual a

<= Menor ou igual a
<> ou != Diferente de
Operadores Lógicos:
Operador Tipo
NOT Negação
AND Conjunção
OR Disjunção
Vamos ver um exemplo:

Criar a tabela abaixo:
Nome da tabela: DVD
Descrição: CADASTRO DE FILMES EM DVD
Campo Descrição Tipo Tamanho Regras
codigo Código do DVD Inteiro 3 Chave Primária
titulo Titulo do Filme Caractere 20 Not null
preco Preço do DVD Numérico 5,2 Not null
SQL> CREATE TABLE DVD

2 (codigo NUMBER(3) PRIMARY KEY,
3 titulo VARCHAR(20) NOT NULL,
4 preco NUMBER(5,2) NOT NULL);
Tabela criada.
SQL>
Inserir os dados abaixo na tabela DVD:
codigo título preco
100 Extraordinário 39,99
101 O Círculo 29,55
102 Vingadores 19,44
103 Star Wars 39,88
104 Batman vs Superman 17,99
105 Steve Jobs 29,33
SQL> INSERT INTO DVD VALUES(100,'Extraordinário','39,99');
1 linha criada.
SQL> INSERT INTO DVD VALUES(101,'O Círculo','29,55');
1 linha criada.
SQL> INSERT INTO DVD VALUES(102,'Vingadores','19,44');

.
. 1 linha criada.
.
. SQL> INSERT INTO DVD VALUES(103,'Star Wars','39,88');
.
. 1 linha criada.
.
. SQL> INSERT INTO DVD VALUES(104,'Batman vs Superman','17,99');
.
. 1 linha criada.
.
. SQL> INSERT INTO DVD VALUES(105,'Steve Jobs','29,33');
.
. 1 linha criada.
.
. SQL> SELECT * FROM DVD;
.
. CODIGO TITULO PRECO
. ---------- -------------------- ----------
. 100 Extraordinário 39,99
. 101 O Círculo 29,55
. 102 Vingadores 19,44
. 103 Star Wars 39,88
. 104 Batman vs Superman 17,99
. 105 Steve Jobs 29,33
.
. 6 linhas selecionadas.
.
. SQL>
SQL> SELECT * FROM DVD WHERE codigo < 104;
CODIGO TITULO PRECO

---------- -------------------- ----------
101 O Círculo 29,55
102 Vingadores 19,44
103 Star Wars 39,88
Liste todos os filmes inseridos com códigos inferiores a 104:

Altere o preço do DVD de código 105 para 24,99:
SQL> UPDATE DVD SET preco = '24,99' WHERE codigo = 105;
1 linha atualizada.
SQL> SELECT * FROM DVD WHERE codigo = 105;
CODIGO TITULO PRECO

---------- -------------------- ----------
105 Steve Jobs 24,99
Exclua os filmes com preço inferior a 20,00:
SQL> DELETE FROM DVD WHERE preco < '20,00';
2 linhas deletadas.
SQL> SELECT * FROM DVD;
CODIGO TITULO PRECO

---------- -------------------- ----------
. 101 O Círculo 29,55
. 103 Star Wars 39,88
. 105 Steve Jobs 24,99
SAIBA MAIS...
linguagem SQL:
Neste tópico vimos como utilizamos os comandos da categoria DML do SQL, que atuam sobre a massa de
dados: INSERT, UPDATE e DELETE.
Utilização dos comandos DTL (Data
Transaction Language) para controle das
transações
Como trabalhar com os comandos de controle de transações da categoria Data Transaction Language (DTL) do
SQL.
NESTE TÓPICO
A TRANSAÇÃO NO SQL
O COMANDO COMMIT
O COMANDO ROLLBACK
O CONTROLE DA TRANSAÇÃO
O COMANDO SAVEPOINT
Referências
NESTE TÓPICO
O COMANDO COMMIT
O COMANDO ROLLBACK
O COMANDO SAVEPOINT
Referências
Marcar
tópico
Olá alunos,
Quando lidamos com os comandos do SQL que causam alterações no banco de dados, o SQL permite que
possamos controlar estas transações quando necessário. São comandos específicos que podem ser declarados,
só que não valem para todos os comandos do SQL. É importante aprendermos a controlar as transações, pois
nos dará uma segurança maior no momento em que executarmos transações noo banco de dados e é isto que
vamos ver a partir de agora.
Qualquer software ou programa, processo ou aplicativo são carregados na memória principal do computador
para serem executados pela CPU (processador). Isto foi determinado por Alan Turing e von Neumann: “o
conceito do programa armazenado”, todo o conjunto de instruções deve ser carregado na memória principal e
as instruções do SQL seguem este procedimento, qualquer comando do SQL é executado a partir da memória
principal.
Ao subirmos qualquer SGBD, este sistema toma uma área da memória principal para fazer o controle das
transações que são requeridas pelo usuário. No caso do Oracle, esta área é conhecida como SGA (System
Global Area), que mantém um cache dos dados e das transações que estão ocorrendo. Como o banco de dados
fica no disco (HD), estes dados envolvidos na transação também são levados para a memória principal.
Por exemplo, ao executarmos um comando INSERT, este é executado a partir da memória principal e os dados
a serem inseridos ficam numa área de cache da memória. Ao executarmos um UPDATE ou um DELETE, os
dados envolvidos nestes comandos também ficam na memória principal. Devemos lembrar que a memória
principal é volátil, os dados ficam ali de forma temporária, qualquer problema que ocorrer, o conteúdo da
memória é perdido, não é necessário só cessar a energia elétrica, qualquer “travamento” do sistema ou se o
usuário fechar a aplicação, o conteúdo também será perdido. Portanto, se realizarmos um comando INSERT
para cadastrar os dados e fecharmos a aplicação, os dados não foram para a tabela ou para o disco, então o que
devemos fazer para evitar isto?
O COMANDO COMMIT
O comando COMMIT é um sinal (flag) que avisa ao SGBD que a transação ou as transações foram finalizadas
e a partir daí o sistema faz o flush (descarga) dos dados da memória principal e armazenam no disco. Portanto,
o comando COMMIT é conhecido como o comando que grava definitivamente os dados no disco.
Então, quando executarmos os comandos INSERT, UPDATE e DELETE, devemos declarar (explicitar) o
comando COMMIT para gravar os dados no disco.
O COMANDO ROLLBACK
O SQL permite que possamos desfazer a transação com o comando ROLLBACK, por exemplo, se apagamos
algum registro com o comando DELETE, podemos desfazer a transação e o dado apagado volta a “aparecer”
novamente. Neste exemplo, na realidade, o que ocorreu é que a transação do DELETE foi realizada na
memória principal, a ação ainda não foi gravada no disco e através do comando ROLLBACK desfazemos a
transação do DELETE.
O SQL permite que através dos comandos COMMIT ou ROLLBACK possamos controlar as transações, mas
não em todos os comandos. Os comandos da categoria DDL: CREATE, ALTER, TRUNCATE e DROP e os
comandos da categoria DCL: GRANT e REVOKE não podem ser desfeitos, uma fez executados, os
comandos destas categorias são concluídos, pois o SQL realiza o COMMIT implícito, ou seja, não adianta
executar o comando ROLLBACK que não terá efeito.
É na categoria DML: INSERT, UPDATE e DELETE que podemos controlar a transação, pois são comandos
que agem sobre os dados e são comuns aos usuários e os comandos das categorias DDL e DCL são comandos
de uso do DBA e dos profissionais de TI.
Portanto, nas transações com os comandos INSERT, UPDATE e DELETE devemos EXPLICITAR o
comando COMMIT, com a seguinte linha:
COMMIT;
Ou no SQL PLUS podemos habilitar o commit automático com o comando:
SET AUTOCOMMIT ON;
Ou desabilitar com SET AUTOCOMMIT OFF;
Neste caso, ao habilitarmos o commit automático, qualquer transação finalizada será concluída e não poderá
ser desfeita com o comando ROLLBACK.
O COMANDO SAVEPOINT
Podemos colocar uma marcação para retornarmos e desfazer a transação ou as transações até o ponto desta
marcação com o comando SAVEPOINT.
O SAVEPOINT serve para determinarmos um ponto onde poderemos retornar no comando ROLLBACK. É
necessário criarmos o SAVEPOINT através do comando:
SAVEPOINT nome_do_ponto;
Para desfazer todas as atualizações a partir do savepoint criado, executa-se o comando:
ROLLBACK TO nome_do_ponto;
Se utilizarmos apenas o comando:
ROLLBACK;
Será desfeita todas as atualizações que não tiverem COMMIT.
Vamos ver um exemplo com o vídeo abaixo:
ATENÇÃO!
Ao executarmos o comando COMMIT não tem mais como desfazer as atualizações e se foi criado algum
SAVEPOINT, este será destruído.
Em resumo:
Os comandos da categoria DTL são: COMMIT, ROLLBACK e SAVEPOINT.
COMMIT EXPLÍCITO:
Grava definitivamente no disco os dados das transações de um INSERT, DELETE E UPDATE.
ROLLBACK EXPLÍCITO:
Desfaz os efeitos das transações de um INSERT, DELETE E UPDATE.
COMMIT IMPLÍCITO:
Todos os comandos DDL: CREATE, ALTER E DROP e comandos DCL: GRANT E REVOKE provocam um
COMMIT IMPLÍCITO no fim da transação e não podem ser desfeitos.
Os comandos COMMIT , ROLLBACK e SAVEPOINT são usados para controle de execução, de
confirmação e de retorno de um evento com INSERT, UPDATE ou DELETE.
O COMMIT (explícito) confirma todas as atualizações e depois da execução deste comando não existe mais
retorno.
COMMIT;
No comando ROLLBACK (explícito) é possível retornar (desfazer) os comandos executados e que não tenham
sidos “comitados”.
ROLLBACK;
Para testarmos os comandos, vamos realizar um exercício como exemplo:
CREATE TABLE Aluno (RA NUMBER(2) PRIMARY KEY,
nome VARCHAR(20));
INSERT INTO Aluno VALUES(01, 'Luiza Lima');

INSERT INTO Aluno VALUES(02, 'Pedro Pereira');
SELECT * FROM ALUNO;

RA NOME
---------- --------------------
. 1 Luiza Lima
. 2 Pedro Pereira
.
. ROLLBACK;
. Rollback concluído.
.
. SELECT * FROM ALUNO;
. nenhuma linha selecionada
.
. INSERT INTO Aluno VALUES(03, 'Ana Almeida');
. INSERT INTO Aluno VALUES(04, 'Caio Costa');
. RA NOME
. ---------- --------------------
. 3 Ana Almeida
. 4 Caio Costa
.
. SAVEPOINT Teste;
.
. INSERT INTO Aluno VALUES(05, 'Beatriz Barros');
. RA NOME
. ---------- --------------------
. 3 Ana Almeida
. 4 Caio Costa
. 5 Beatriz Barros
.
. DELETE FROM Aluno;
.
. ROLLBACK TO Teste;
. Rollback concluído.
. RA NOME
. ---------- --------------------
. 3 Ana Almeida
. 4 Caio Costa
.
. DELETE FROM Aluno;
.
. COMMIT;
. Commit concluído.
.
. ROLLBACK TO Teste;
. Erro de SQL: ORA-01086: O ponto de salvamento 'TESTE' nunca foi estabelecido nesta sessão ou é inválido
.
Nas linhas 4 e 5, inserimos dois registros e na linha 13, executamos o comando rollback e os dois comandos
insert foram desfeitos, como verificado com o comando SELECT na linha 16.
Nas linhas 19 e 20, inserimos mais dois registros.
Na linha 27, estabelecemos uma marcação, criando um ponto de salvamento.
Na linha 29, inserimos mais um registro.
Na linha 37, apagamos todos os registros da tabela.
Na linha 41, realizamos um rollback até a marcação com o ponto de salvamento.
Na linha 43, verificamos com o comando SELECT que dois registros voltaram, porque foram desfeitos o
comando DELETE (Linha 37) e o comando INSERT (Linha 29) até a marcação com o SAVEPOINT (Linha
27).
Na linha 49, executamos o comando DELETE e apagamos os dados e na linha 53, executamos o comando
COMMIT.
Na linha 56, executamos o comando para desfazer a transação até o ponto de salvamento, mas o comando
commit da linha 53 concluiu todas as transações e desfez o SAVEPOINT.
SAIBA MAIS...
linguagem SQL:
Neste tópico vimos como utilizamos os comandos da categoria DTL do SQL: COMMIT, ROLLBACK e
SAVEPOINT, para controlar as transações que manipulam dados.
Utilização do comando SELECT (DQL - Data

Query Language) com as cláusulas: WHERE e
ORDER BY
Trabalhar com as cláusulas WHERE e ORDER BY no comando de consulta SELECT da categoria Data Query
Language (DQL) do SQL.
NESTE TÓPICO
NESTE TÓPICO
O COMANDO SELECT
A CLÁUSULA WHERE
Referências
Marcar
tópico
Olá alunos,
Já vimos um pouco a utilização do comando SELECT, lembrando que o SELECT é o comando mais utilizado
quando se fala em banco de dados. É o comando que permite realizarmos qualquer tipo de consulta e permite
que possamos trabalhar com várias cláusulas e vamos ver duas destas cláusulas: WHERE e ORDER BY. Estas
cláusulas serão utilizadas para realizarmos auditorias em banco de dados.
O COMANDO SELECT
O SELECT é o único comando do SQL que pode retornar nenhuma linha, uma linha ou várias linhas, é um
comando de consulta que só retorna dados e não instancia (não causa instância) no banco de dados, não muda
o estado do banco de dados, portanto não tem o controle de transação como o COMMIT e o ROLLBACK.
A sintaxe básica do comando SELECT é a seguinte:
SELECT campo1, campo2, campoN FROM tabela;
Logo após o comando SELECT, listamos o nome do campo ou dos campos que se deseja, separados por uma
vírgula, e se quisermos listar todos os campos da tabela, não será necessário escreve-los e sim utilizar o
asterisco “*” que é um coringa e representa todos os campos da tabela:
SELECT * FROM tabela;
Depois de listarmos os campos, temos que colocar obrigatoriamente a cláusula FROM que representa a
procedência, de onde estamos retirando os dados, então depois do FROM sempre vem o nome da tabela de
onde queremos os dados. Ao executarmos o comando SELECT, a primeira coisa que o interpretador do SQL
irá realizar, será localizar a tabela que está depois do FROM.
A saída do comando, aquilo que será impresso, é o campo ou os campos que determinarmos entre o SELECT e
o FROM.
Fora as cláusulas obrigatórias, o SELECT aceita outras, assim como também várias funções, como as funções
numéricas, funções de agregação e funções de datas.
A CLÁUSULA WHERE
Uma das cláusulas é o WHERE que representa um filtro de linhas ou registros de uma tabela. Serve para
restringir o número de linhas e a sintaxe é WHERE condição, sempre vem acompanhada de uma condição e
como a linguagem SQL é estruturada, devemos obedecer a posição da cláusula no comando SELECT:
SELECT campos FROM tabela WHERE condição;
A cláusula WHERE é declarada sempre depois do nome da tabela, acompanhada de uma condição e podemos
utilizar os seguintes operadores para estabelecer as condições:
OPERADORES RELACIONAIS:
Operador Descrição
= Igual a
> Maior que
< Menor que
>= Maior ou igual a
<= Menor ou igual a
<> ou != Diferente de
OPERADORES LÓGICOS:
Operador Tipo
NOT Negação
AND Conjunção
OR Disjunção
Exemplos:
Listar os produtos com preços entre R$ 200,00 e R$ 400,00:
SELECT nomeProduto FROM Produto WHERE preco >= 200 AND preco <= 400;
OU
SELECT nomeProduto FROM Produto WHERE preco BETWEEN 200 AND 400;
Neste exemplo, quando temos uma seleção com um intervalo de valores, podemos utilizar o operador
BETWEEN (entre).
A CLÁUSULA ORDER BY
Quando executamos uma consulta, a ordem de apresentação do resultado será sempre pela chave primária da
tabela, mesmo que não solicitamos o campo chave primária no comando SELECT, como no exemplo acima, o
resultado com os nomes dos produtos será apresentado pela ordem da chave primária da tabela Produto. Isto
ocorre porque quando determinamos um campo como chave primária (PRIMARY KEY), este campo é
automaticamente indexado pelo sistema, ou seja, internamente, conforme os dados forem entrando, estes dados
já ficam ordenados.
Porém, se quisermos apresentar o resultado em uma ordenação que não seja por chave primária, devemos
utilizar a cláusula: ORDER BY acompanhado pelo nome do campo que queremos ordenar. A sintaxe
é: ORDER BY campo1, campo2,.... ASC ou DESC
Podemos realizar a ordenação por mais de um campo, o sistema irá considerar a ordenação pelo campo1,
depois pelo campo2, etc. Podemos também determinar pela ordem ascendente ( ASC), do menor valor para o
maior ou descendente (DESC), do maior valor pelo menor. O padrão é pela ordem ascendente.
A ordenação poderá ser por qualquer tipo de campo: numérico, tipo caractere ou tipo data.
A posição do ORDER BY será sempre no final do comando SELECT e serve para ordenar o resultado na
consulta e não modifica a ordem dos dados na tabela.
A sintaxe do comando SELECT com as cláusulas possíveis é:
SELECT campo1,... FROM tabela1, tabela2,... WHERE condição GROUP BY campo1,... HAVING
condição_agregação ORDER BY campo1,...ASC / DESC;
As cláusulas WHERE, GROUP BY, HAVING ou ORDER BY são opcionais e se forem utilizadas, devem
seguir esta ordem no comando SELECT.
Vamos criar a tabela Funcionário e inserir alguns dados:
SQL> CREATE TABLE Funcionario

2 (idFunc NUMBER(3) PRIMARY KEY,
3 nomeFunc VARCHAR(30) NOT NULL,
4 cargo VARCHAR(15),
5 dataAdmissao DATE,
6 salario NUMBER(7,2));
INSERT INTO Funcionario VALUES(01,'Antonio Almeida','Programador','10/10/2009','3400,00');
. INSERT INTO Funcionario VALUES(02,'Vilmar Valencia','Analista','01/02/2015','4300,00');

.
. INSERT INTO Funcionario VALUES(03,'Rogério Rocha','Gerente','10/04/2002','8500,00');
.
. INSERT INTO Funcionario VALUES(04,'Ana Almeida','Analista','21/12/2008','4600,00');
.
. INSERT INTO Funcionario VALUES(05,'Luis Lopes','Programador','08/07/2012','3200,00');
Agora, realizando algumas consultas:

Listar o código, nome e salário dos funcionários, em ordem alfabética pelo nome:
SQL> SELECT idFunc, nomeFunc, salario FROM Funcionario ORDER BY nomeFunc;
IDFUNC NOMEFUNC SALARIO

---------- ------------------------------ ----------
4 Ana Almeida 4600
1 Antonio Almeida 3400
5 Luis Lopes 3200
3 Rogério Rocha 8500
2 Vilmar Valencia 4300
Listar o código, nome e salário dos funcionários em ordem do maior para o menor salário da empresa:
SQL> SELECT idFunc, nomeFunc, salario FROM Funcionario ORDER BY salario DESC;
IDFUNC NOMEFUNC SALARIO
---------- ------------------------------ ----------
3 Rogério Rocha 8500
4 Ana Almeida 4600
2 Vilmar Valencia 4300
1 Antonio Almeida 3400
5 Luis Lopes 3200
Listar os códigos e nome dos funcionários que ganham entre 3500,00 e 5000,00:
SQL> SELECT idFunc, nomeFunc FROM Funcionario WHERE salario BETWEEN 3500 AND 5000;
IDFUNC NOMEFUNC
---------- ------------------------------
2 Vilmar Valencia
4 Ana Almeida
Listar o nome do funcionário e a data de admissão, ordenando o resultado do funcionário mais novo para o
mais antigo da empresa:
SQL> SELECT nomeFunc, dataAdmissao FROM Funcionario ORDER BY dataAdmissao DESC;
NOMEFUNC DATAADMI
------------------------------ --------
Vilmar Valencia 01/02/15
Luis Lopes 08/07/12
Antonio Almeida 10/10/09
Ana Almeida 21/12/08
Rogério Rocha 10/04/02
Listar todos os dados dos funcionários que são analistas ou programadores em ordem alfabética pelo nome do
funcionário:
SQL> SELECT * FROM Funcionario WHERE cargo = 'Analista' OR cargo = 'Programador' ORDER BY nomeFunc;
IDFUNC NOMEFUNC CARGO DATAADMI SALARIO

---------- ------------------------------ --------------- -------- ----------
4 Ana Almeida Analista 21/12/08 4600
1 Antonio Almeida Programador 10/10/09 3400
5 Luis Lopes Programador 08/07/12 3200
2 Vilmar Valencia Analista 01/02/15 4300
Veja no vídeo abaixo um exemplo da execução dos comandos SELECT, WHERE e ORDER BY:
SAIBA MAIS...
linguagem SQL:
Neste tópico vimos como utilizamos as cláusulas WHERE e ORDER BY para realizar consultas com o
comando SELECT.
Criação de VIEWS
Mostrar como utilizar os recursos com a criação de VIEWS.
NESTE TÓPICO
CARACTERÍSTICAS DA VIEW
PORQUE UTILIZAR VIEWS?
SINTAXE PARA A CRIAÇÃO DE UMA VIEW
EXCLUINDO UMA VIEW
Referências
NESTE TÓPICO
EXCLUINDO UMA VIEW
Referências
Marcar
tópico
Olá alunos,
A utilização da VIEW pode ser realizada de várias formas no mudo corporativo. A princípio a ideia era criar
visões (VIEW) para uma mesma base de dados para usuários diferentes. Por exemplo, um funcionário do RH
pode ter acesso aos dados de todos os funcionários, inclusive o salário. E se a empresa gera produtos acabados,
qualquer funcionário desta empresa pode comprar estes produtos, com um valor reduzido. O departamento de
Vendas terá que cuidar da venda, expedindo a fatura e a nota fiscal dos produtos adquiridos pelo funcionário,
para isto os funcionários de Vendas poderiam acessar a tabela Funcionário, mas os funcionários de Vendas não
podem ver o salário dos funcionários. Como podemos resolver isto? Uma das formas é com a criação de
VIEWS, evitando assim, o acesso a certos dados que são confidenciais. E é o que veremos a seguir.
 Um dos seus benefícios é a implementação da independência lógica de dados.
 É um modo de enxergar os dados de uma ou mais tabelas de uma outra forma.
 Uma visão (VIEW) é um objeto criado a partir de um comando CREATE VIEW. É

armazenado no dicionário de dados e possui a mesma estrutura de uma tabela.
 Pode ser utilizada nos comandos SELECT, INSERT, UPDATE e DELETE.

 Numa situação onde temos que utilizar constantemente o mesmo comando SELECT, com
várias tabelas podemos simplificar esta consulta criando um objeto chamado “view”.
 Visões são tabelas virtuais cujo conteúdo provém de tabelas reais.

 Restringir acesso aos dados: podemos filtrar linhas e colunas que não devem ser mostradas a
todos os usuários.
 Buscas complexas tornam-se simples com a criação de visões desses comandos complexos.
Assim, quando os usuários necessitarem da informação, farão a busca na visão.
 Uma VIEW para todos os efeitos funciona como uma tabela virtual derivada de uma tabela
real, portanto, se eliminarmos uma VIEW não afetará a tabela original do qual deriva.

CREATE VIEW nome_da_view AS subquery (SELECT);
Exemplo:
Criar uma VIEW para os funcionários de Vendas acessarem os dados dos funcionários, menos o salário:
CREATE VIEW vVendas AS SELECT idFunc, nomeFunc, endereço, cpf, rg FROM Funcionario;
SELECT * FROM vVendas;
SELECT nomeFunc FROM vVendas;
Exemplo:
Criar uma VIEW para restringir o acesso aos dados dos funcionários que ganham salários maiores que R$
5000,00:
CREATE VIEW vFunc AS SELECT * FROM Funcionario WHERE Salario < 5000.00;
Exemplo:
Criar VIEWS para SELECTs complexos, onde os dados são extraídos de várias tabelas ou podem conter
funções e conter dados agrupados, e há a necessidade de realizar estes tipos de consultas frequentemente, então
podemos criar VIEWS para simplificar a consulta:
CREATE VIEW vMenor_Salario AS SELECT nomeFunc, salario FROM Funcionario WHERE salario <
(SELECT SUM(comissao) FROM Funcionario);
Realizando a consulta pela VEW:
SELECT * FROM vMenor_Salario;
CREATE VIEW vLista_Pedido AS SELECT Pedido.numPedido, Cliente.nomeCliente,
Produto.nomeProduto FROM tab_Pedido, tab_Cliente,,tab_Produto WHERE Pedido.numPedido =
Produto.numPedido AND Pedido.idCliente = Cliente.idCliente ORDER BY Cliente.nomeCliente;
Realizando a consulta pela VIEW:
SELECT * FROM vLista_Pedido;
EXCLUINDO UMA VIEW
Ao excluir uma visão (VIEW), não estamos excluindo os dados (linhas e colunas), os dados permanecem nas
tabelas originais.
Sintaxe:
DROP VIEW nome_da_view;
Exemplo:
DROP VIEW vVendas;
Vamos ver um exemplo com a utilização da VIEW como uma tabela virtual:
SQL> CREATE TABLE Aluno

2 (RA NUMBER(5) PRIMARY KEY,
3 nome VARCHAR(20),
4 media NUMBER(3,1));
Tabela criada.
SQL> CREATE VIEW vAluno AS SELECT * FROM Aluno;
. View criada.
Inserindo dados através da VIEW:
SQL> INSERT INTO vAluno VALUES(11,'Sandro Silva',8.5);
1 linha criada.
SQL> INSERT INTO vAluno VALUES(22,'Sueli Souza',9.0);
1 linha criada.
SQL> INSERT INTO vAluno VALUES(33,'Dimas Duarte',5.5);

.
. 1 linha criada.
.
. SQL> SELECT * FROM vAluno;
.
. RA NOME MEDIA
. ---------- -------------------- ----------
. 11 Sandro Silva 8,5
. 22 Sueli Souza 9
. 33 Dimas Duarte 5,5
.
. SQL> SELECT * FROM Aluno;
.
. RA NOME MEDIA
. ---------- -------------------- ----------
. 11 Sandro Silva 8,5
. 22 Sueli Souza 9
Realizando uma consulta na tabela Aluno, verificamos que os dados foram cadastrados através da VIEW
vAluno.
Agora, atualizando dados através da VIEW:
SQL> UPDATE vAluno SET media = 7.5 WHERE RA = 33;

1 linha atualizada.
SQL> SELECT * FROM Aluno;
RA NOME MEDIA
---------- -------------------- ----------
11 Sandro Silva 8,5
. 22 Sueli Souza 9
Verificamos que a atualização foi realizada na tabela através da VIEW.

Agora vamos apagar dados através da VIEW:
SQL> DELETE FROM vAluno WHERE RA = 11;
1 linha deletada.
RA NOME MEDIA
---------- -------------------- ----------
22 Sueli Souza 9
Verificamos que o registro foi apagado na tabela através da VIEW.

Agora vamos eliminar a VIEW vAluno:
SQL> DROP VIEW vAluno;
View eliminada.
RA NOME MEDIA
---------- -------------------- ----------
22 Sueli Souza 9
Ao eliminarmos a VIEW vAluno, os dados na tabela Aluno permanecem intactos.

Este é um exemplo de como utilizar a VIEW como tabela virtual, criamos a VIEW com um SELECT sem
restrições, que apanha todos os dados e todas as colunas de uma tabela. Desta forma, poderemos utilizar os
comandos INSERT, UPDATE e DELETE para realizar transações na tabela original, através da VIEW. E ao
eliminarmos a VIEW, os dados permanecem na tabela original.
Veja este exemplo no vídeo abaixo, com a execução dos comandos para criar e eliminar uma view:
SAIBA MAIS...
linguagem SQL:
Neste tópico verificamos como utilizar a VIEW para simplificar consultas com selects complexos, para
disponibilizar a mesma base de dados com visões diferentes aos usuários e como tabela virtual.
Introdução a linguagem PL/SQL e a criação de

rotinas em stored procedures
Introduzir a parte procedural da linguagem SQL: PL/SQL da Oracle.
NESTE TÓPICO
CARACTERÍSTICAS DA LINGUAGEM PL/SQL
UTILIZANDO O SQL DEVELOPER
ESTRUTURA DE UM BLOCO PL
UTILIZANDO O BLOCO PL EM UM BLOCO ANÔNIMO
Referências
NESTE TÓPICO

UTILIZANDO O BLOCO PL EM UM BLOCO ANÔNIMO
Referências
Marcar
tópico
Olá alunos,
Vamos a partir de agora ver a parte procedural da linguagem SQL, ela foi lançada pela Oracle com um
propósito e mais tarde outras empresas como a IBM, a Microsoft e até os SBGDs com licença pública também
lançaram os recursos procedurais na linguagem SQL.
Lembrando que o SQL é uma linguagem estruturada e não procedural e os comandos SQL, principalmente os
comandos da categoria DML, podem ser embutidos em qualquer linguagem de programação. Então, porque a
Oracle lançou o PL/SQL, a parte procedural, da linguagem SQL?
A linguagem PL/SQL (Procedural Language / SQL) foi desenvolvida pela Oracle em 1991 e lançada na versão
Oracle 6, e é utilizada para montar os blocos PL/SQL.
Um bloco PL/SQL consiste de um conjunto de instruções SQL (SELECT, INSERT, UPDATE, DELETE) ou
comandos PL/SQL, e desempenha uma função lógica única, afim de resolver um problema específico ou
executar um conjunto de tarefas afins. O Bloco PL/SQL também pode ser referenciado com Unidade de
Programa PL/SQL.
Principais recursos oferecidos pela linguagem:
 Executar comandos SQL para manipular dados nas tabelas;
 Criar constantes e variáveis;
 Criar cursores para tratar o resultado de uma consulta;
 Criar registros para guardar o resultado de um cursor ou campo de tabela;
 Tratar erros;
 Utilizar comandos de controle (if, if-then-else, case) e de repetição (loop, for, while);
 Construir procedimentos para garntir a segurança dos dados.
Os blocos ou rotinas ou subprogramas PL, que envolvem transações que manipulam dados são executados a
partir da memória principal, evitando muitas I/O (input/output) em disco, já que o disco (HD) não é uma
memória eletrônica e o seu tempo de acesso é muito alto. A Oracle então descobriu que, em vez de colocar o
comando SQL embutido diretamente no código da aplicação construído com alguma linguagem de
programação (em Java, por exemplo), o comando SQL que fica no bloco PL/SQL será executado de forma
mais rápida.
Os blocos PL/SQL são qualificados em bloco anônimo e Stored Procedure. No caso do Oracle, em outros
sistemas, como o MySQL, por exemplo, não é possível trabalhar com blocos anônimos, isto porque, o PL não
é padronizado pela ANSI ou pela ISO como no caso do SQL.
Diferenças entre o bloco anônimo e a Stored Procedure (SubPrograma armazenado):
BLOCOS ANÔNIMOS SUBPROGRAMAS (STORED

PROCEDURE)
Blocos PL/SQL não nomeados Blocos PL/SQL nomeados
Compilados todas as vezes Compilados apenas uma vez
Não armazenados no banco de dados Armazenados no banco de dados
Não podem ser chamados por outra São nomeados e, portanto, podem
aplicação ser chamados por outras aplicações
Não retornam valores Funções chamadas por

subprogramas devem retornar
valores
Não podem aceitar parâmetros Podem aceitar parâmetros

Para trabalharmos com o PL/SQL é aconselhado utilizarmos a interface SQL Developer, que é distribuída
gratuitamente pela Oracle. Pode-se trabalhar também com o SQL Plus, vai funcionar da mesma forma, mas,
diferente dos comandos SQL, que são executados em uma instrução de cada vez, com o PL precisamos
escrever códigos com várias linhas e com certeza alterá-los depois, com isso o SQL Developer se torna mais
prático.
O link abaixo é para baixar o SQL Developer:
https://www.oracle.com/technetwork/developer-tools/sql-developer/downloads/index.html
E escolher o arquivo de acordo com o sistema operacional, com o Windows por exemplo:
Não é necessário instalar o SQL Developer, basta descompactá-lo (extrair) os arquivos em uma pasta e
executar o setup.
Segue, clicando aqui , uma apostila da própria Oracle, que é um tutorial para se trabalhar com o SQL
Developer: (EM INGLÊS)
A estrutura de um bloco PL/SQL é constituida de três seções:
SEÇÃO DE DECLARAÇÃO (DECLARE):
Nesta seção são definidos os objetos PL/SQL como variáveis, constantes, cursores e exceções definidas pelo
usuário que poderão ser utilizadas dentro do bloco.
SEÇÃO DE EXECUÇÕES (BEGIN...END;):
Nesta seção contemplará a sequência de comandos PL/SQL e instruções SQL do bloco.
SEÇÃO DE TRATAMENTO DE ERRO (EXCEPTION):
Nesta seção serão tratados os erros definidos e levantados pelo próprio bloco e os erros gerados pela execução
do bloco.
DECLARE <--- Opcional
-- declarações
BEGIN <--- Obrigatório
-- instruções e comandos
EXCEPTION <--- Opcional
-- tratamentos de erro
END; <--- Obrigatório
Comentários em PL/SQL:
Os comentários em PL/SQL são de dois tipos:
-- Utiliza-se este delimitador para comentários de uma linha. A partir de dois hífens tudo o que for escrito até o
final da linha é considerado comentário.
/* e */ Utiliza-se estes delimitadores para abrir e para fechar comentários de múltiplas linhas. Tudo e todas as
linhas que estiverem entre os dois delimitadores serão ignorados pelo compilador PL/SQL na execução.
BEGIN
-- comentando apenas uma linha
/* comentando
várias linhas */
;COMANDO; -- o resto será ignorado
END;
Declarações de variáveis (seção de declaração):
Para utilizar variáveis e constantes no seu programa, você deve declará-los anteriormente. É na seção
DECLARE que são declaradas as variáveis e constantes.
Exemplos:
DECLARE
vPreco NUMBER(6,2);
nomeVendedor VARCHAR(50) := ‘José Junior’;
dataVenda DATE := SYSDATE;
BEGIN
Comandos;
END;
/
A barra / é necessária para executar o código no SQL PLUS e não no SQL Developer.
SINAIS DE ATRIBUIÇÃO:
Para atribuir (carregar) um valor em uma variável podemos utilizar os sinais “:=“ como são utilizados nas
linguagens BASIC, PASCAL, ADA.
Exemplo:
X := 5;
SINAIS DE COMPARAÇÃO DE IGUALDADE:
Para comparar a igualdade entre valores de variáveis ou entre valores e variáveis, utilizando o sinal de “=“.
Exemplos:
X = 5;
X = Y;
COMANDOS DE I/O (INPUT/OUTPUT):
Pré-definidos pela linguagem:
LER ---> Receber dados de um dispositivo de entrada como o teclado.
Em PL/SQL, basta colocar o & antes da variável de atribuição e o sistema irá aguardar a entrada de dados via
teclado.
Ex: &RA, &nomeAluno, &dataNascimento, &salario.
ESCREVER ---> Envia dados de uma variável de saída para a tela.
Em PL/SQL, podemos utilizar o comando de saída do pacote DBMS_OUTPUT.
Pacote DBMS_OUTPUT:
Na programação PL/SQL, para darmos saídas para mensagens na tela utiliza-se o package DBMS_OUTPUT e
a procedure PUT_LINE.
Para habilitar este pacote e a procedure no SQL*Plus e no SQL Developer utilizamos o comando SET
SERVEROUTPUT em ON:
SET SERVEROUTPUT {ON | OFF}
Com esses passos completados, a saída impressa na tela do SQL*Plus depois que o bloco for completamente
executado. Durante a execução, o buffer é preenchido pelas chamadas de DBMS_OUTPUT.PUT_LINE. O
SQL*Plus não recupera o conteúdo do buffer e não o imprime até que o controle retorne para o SQL*Plus,
depois que o bloco terminou a execução.
SET SERVEROUTPUT ON
DECLARE
Variavel NUMBER(2) := &variavel;
BEGIN
DBMS_OUTPUT.PUT_LINE(‘Imprimindo mensagem na tela’);
DBMS_OUTPUT.PUT_LINE(‘Imprimindo mensagem na tela’|| variavel);
END;
* Utilizamos 2 pipes “||” para concatenarmos mensagem e valores de variáveis.
UTILIZANDO O BLOCO PL EM UM BLOCO
ANÔNIMO
Exemplo:
Vamos desenvolver um bloco anônimo para receber as notas e calcular a média aritmética simples dos alunos,
considerando que a média é composta por três notas:
-- Um bloco anônimo que calcula a média aritmética de três notas;

SET SERVEROUTPUT ON;
DECLARE
Nota1 NUMBER(3,1) := &Nota1;
media NUMBER(3,1);
BEGIN
. media := (Nota1 + Nota2 + Nota3)/3;
. DBMS_OUTPUT.PUT_LINE('A média do aluno é: '|| media);
. END;
./
.
. Procedimento PL/SQL concluído com sucesso.
.
. A média do aluno é: 8,8
Na linha 2, habilitamos o servidor de saída porque vamos utilizar o pacote DBMS_OUTPUT.

Nas linhas 4, 5 e 6, declaramos as variáveis: Nota1, Nota2 e Nota3 e entramos com as notas: 8, 8.5 e 10,
utilizando o &.
Na linha 10, calculamos a média.
Na linha 11, imprimimos a mensagem ‘A média do aluno é: ‘ e imprimimos o valor da variável media.
Veja no vídeo abaixo, a execução do boco anônimo do exemplo acima:
SAIBA MAIS...
Dê uma olhada nos links abaixo para saber mais sobre a linguagem PL/SQL:
https://www.oracle.com/technetwork/database/application-development/index-101230.html
Neste tópico vimos como trabalhar com o bloco anônimo em PL/SQL, utilizando a interface do SLQ
Developer e os comandos de entrada e saída de dados.
Criação de Procedures
Como criar procedimentos armazenados (stored procedures) utilizando os comandos PL/SQL.
NESTE TÓPICO
UTILIZANDO O COMANDO SELECT NO BLOCO PL/SQL
UTILIZANDO A ESTRUTURA DA PROCEDURE
Referências
NESTE TÓPICO
UTILIZANDO O COMANDO SELECT NO BLOCO PL/SQL

Referências
Marcar
tópico
Olá alunos,
Vamos ver agora como criar os procedimentos armazenados (stored procedures) que é muito utilizado para a
criação de rotinas em várias aplicações no mundo corporativo e foi o principal objetivo para a criação da
linguagem PL. A PROCEDURE permite que possamos colocar os comandos SQL, principalmente os da
categoria DML (INSERT, UPDATE e DELETE) nos blocos PL e estas rotinas depois de armazenando estas
rotinas também em disco. Para armazenar a rotina necessitamos compilar o código, e se estiver tudo correto, o
procedimento é criado e armazenado no disco.
Primeiro, é necessário utilizar o comando:
CREATE PROCEDURE nome_da_Procedure
BEGIN
-- COMANDOS
END;
Toda vez que utilizamos o comando CREATE e damos um nome, no caso para a PROCEDURE, este se torna
um tipo de objeto e após a compilação acaba se tornando um procedimento armazenado em disco, daí para
executarmos o código da PROCEDURE basta chama-la pelo nome com o comando:
EXECUTE nome_da_Procedure;
Ou na forma abreviada:
EXEC nome_da_Procedure;
Lembrando que para darmos um nome para a procedure, não utilize ç, acentuação gráfica, espaço em branco e
não iniciar com um número. É permitido utilizar o _ (underline).
UTILIZANDO O COMANDO SELECT NO BLOCO
PL/SQL
Comandos DML (SELECT, INSERT, UPDATE e DELETE) podem ser utilizados dentro de um bloco PL/SQL.
O comando SELECT deverá receber obrigatoriamente a cláusula INTO para que o resultado seja armazenado
em variáveis e deverá retornar apenas uma linha. Caso mais de uma linha seja retornada, apresentará o
erro: too_many_rows e se não retornar nenhuma linha, apresentará o erro: no_data_found.
Tipos de dados:
O comando %TYPE nos dá a possibilidade de associarmos ao tipo de uma variável o tipo de uma coluna de
uma tabela, desta forma, automaticamente a variável assumirá o tipo de dado da coluna.
O comando %ROWTYPE criará uma estrutura de registro idêntica à estrutura de uma tabela.
DECLARE
Nome_variável nome_tabela.nome_coluna%TYPE; -- variável
Nome_registro nome_tabela%ROWTYPE; -- registro
BEGIN
-- instruções e comandos
END;
Ex:
DECLARE
dtVenda dataVenda%TYPE;
vNomeFunc funcionario.nomeFunc%TYPE;
A variável dtVenda vai assumir o tipo da variável dataVenda que foi criada anteriormente.
A variável vNomeFunc assume o mesmo tipo da coluna nomeFunc da tabela funcionario.
DECLARE
vFuncionario Funcionario%ROWTYPE;
A variável vFuncionario é uma variável indexada com todas as colunas da tabela Funcionario. Por exemplo,
para acessar o conteúdo da coluna nome do funcionário, utiliza-se vFuncionario.nomeFunc.
Nesta abordagem o código fica mais ligado à estrutura e não será necessária a reescrita do código quando o
tipo de coluna for alterado.
A segunda forma de atribuir valor a uma variável é através de um resultado de SELECT que será transferido à
variável.
Um SELECT que atribui valor a uma variável obrigatoriamente deverá retornar uma e somente uma linha,
caso contrário, um erro de execução será disparado.
DECLARE
reajuste5 NUMBER;
reajuste10 NUMBER;
vCodProduto Produto.codProduto%TYPE := &codigo;
BEGIN
SELECT preco * 1.05, preco * 1.10 INTO reajuste5, rejuste10 FROM Produto WHERE codProduto = vCodProduto;
DBMS_OUTPUT.PUT_LINE('O preço com reajuste de 5% seria de :: '|| reajuste5);
DBMS_OUTPUT.PUT_LINE(' O preço com reajuste de 5% seria de :: '|| reajuste10);
END;
./
CRIANDO UM CURSOR
Cursores são áreas compostas de linhas e colunas em memória que servem para armazenar o resultado de uma
seleção que retorna 0 (zero) ou mais linhas.
Cursor é um tipo de ponteiro utilizado em linguagens de programação. Servem para acessar os valores de um
registro ou linha que estão armazenados em uma tabela.
O cursor deve ser explicitamente declarado na área DECLARE.
Para nomear o resultado do cursor é necessário que ele e suas colunas possuam nomes (alias). Para isso
algumas regras devem ser observadas:
• O nome do cursor não pode ser igual ao da tabela.
• Para dar um nome a uma coluna da seleção, basta colocar o nome do alias logo após a definição da coluna ou
expressão.
CURSOR nome_do_cursor IS SELECT coluna1, coluna2 ...FROM nome_da_tabela;
UTILIZANDO: OPEN, FETCH E CLOSE:
Após sua declaração, o cursor deverá ser manipulado com o uso de alguns comandos:
OPEN abre o cursor.
FETCH disponibiliza a linha corrente e posiciona na próxima linha do cursor. As linhas armazenadas no cursor
somente poderão ser processadas quando o seu conteúdo for transferido para variáveis que possam ser
manipuladas no PL/SQL.
CLOSE fecha o cursor.
OBSERVAÇÃO: Após declarar uma variável como sendo do tipo nome_do_cursor%rowtype, essa variável
será um tipo de registro (variável composta de diversas subvariáveis) cujas subvariáveis terão os mesmos
nomes, tipos e tamanhos e estarão na mesma ordem dos campos especificados no comando SELECT do cursor.
O conteúdo da variável desse tipo é referenciado com nome_do_registro.nome da subvariável.
Exemplo:
DECLARE
CURSOR c_cliente IS SELECT codigo, nome FROM cliente;
v_cliente c_cliente%ROWTYPE;
BEGIN
OPEN c_cliente;
LOOP
FETCH c_cliente INTO v_cliente;
EXIT WHEN c_cliente%NOTFOUND;
DBMS_OUTPUT.PUT_LINE('Cliente: '|| v_cliente.nome);
END LOOP;
CLOSE c_cliente;
END;
UTILIZANDO: FOR (CURSOR)
O comando FOR ... LOOP, quando aplicado a um cursor, executa automaticamente as seguintes ações:
• Cria a variável do tipo registro que receberá os dados;
• Abre (OPEN) o cursor;
•Copia as linhas uma a uma (FETCH), a cada iteração do comando;
• Controla o final do cursor;
• Fecha (CLOSE) o cursor.
NOTA: Caso seja necessário sair do loop do comando FOR durante sua execução, o cursor deverá ser fechado
explicitamente com o comando CLOSE.
O mesmo exemplo anterior utilizando o CURSOR com o FOR:
DECLARE
CURSOR c_cliente IS SELECT codigo, nome FROM cliente;
BEGIN
FOR v_cliente IN c_cliente
LOOP
DBMS_OUTPUT.PUT_LINE('Cliente: '|| v_cliente.nome);
END LOOP;
END;
Utilizar o CURSOR com o FOR é altamente recomendado, pois simplifica o desenvolvimento do código.
Lembrando que procedures são subprogramas ou rotinas armazenadas em disco que executam uma
determinada ação. Não retornam valores e, portanto, não são utilizadas para atribuir valores a variáveis ou
como argumento em um comando SELECT.
CREATE OR REPLACE PROCEDURE nome_procedure
(parâmetro1 modo tipo_de_dados, parâmetro2 modo tipo_de_dados, parâmetroN modo tipo_de_dados)
IS ou AS
variáveis locais, constantes, ...
BEGIN
...
END nome_procedure;
REPLACE
Substitui a procedure caso ela já exista.
PARÂMETRO
Nome da variável que será enviada para a procedure. No caso da Procedure, o parâmetro é OPCIONAL. Pode
ser passado em um dos três modos a seguir.
MODO
• IN (padrão): Passa um valor do ambiente chamador para procedure e este valor não pode ser alterado dentro
da mesma. (Passagem de parâmetro por valor).
• OUT: Passa um valor da procedure para o ambiente chamador. (Passagem de parâmetro por referência).
• IN/OUT: Passa um valor do ambiente chamador para a procedure. Esse valor pode ser alterado dentro da
mesma e retornar com o valor atualizado para o ambiente chamador. (Passagem de parâmetro por referência).
IS ou AS
Por convenção usa-se IS na criação de procedures e AS para criar pacotes.
Vamos considerar o seguinte exemplo:
Criar uma procedure NOTAS (com um CURSOR) para gravar os valores da MÉDIA e do RESULTADO,
conforme as seguintes regras:
• MEDIA: (NOTA1 + NOTA2) / 2
• RESULTADO: MÉDIA >= 6: 'APROVADO ';
MÉDIA < 6: ‘RECUPERAÇÃO‘;
Primeiramente vamos criar o banco de dados:
CREATE TABLE tb_ALUNO (

RA NUMBER(5) PRIMARY KEY,
nome VARCHAR2(25),
AV1 NUMBER(3,1),
AV2 NUMBER(3,1),
media NUMBER(3,1),
resultado VARCHAR2(15));
insert into tb_aluno (RA,nome,AV1,AV2) values(2201,'Alessandra Alice','9','7');
insert into tb_aluno (RA,nome,AV1,AV2) values(2202,'Iris Inácio','4','6');
. insert into tb_aluno (RA,nome,AV1,AV2) values(2203,'Lia Lemos','7','5');
. insert into tb_aluno (RA,nome,AV1,AV2) values(2204,'Gisele Gomes','5','6');
. insert into tb_aluno (RA,nome,AV1,AV2) values(2205,'Isis Iranda','7','10');
. insert into tb_aluno (RA,nome,AV1,AV2) values(2206,'Ana Almeida','8','4');
Depois de criarmos a tabela e cadastrarmos os dados, vamos criar a Procedure:
CREATE OR REPLACE PROCEDURE nota_aluno

is
CURSOR c_Aluno is SELECT * FROM TB_ALUNO;
BEGIN
FOR vAluno IN c_Aluno
LOOP
vAluno.MEDIA := (vAluno.AV1 + vAluno.AV2)/2;
IF vAluno.MEDIA >= 6 THEN
vAluno.RESULTADO := 'APROVADO';
. ELSE vAluno.RESULTADO := 'RECUPERAÇÃO';
. END IF;
. UPDATE TB_ALUNO SET RESULTADO = vAluno.RESULTADO,MEDIA = vAluno.MEDIA WHERE RA = vAluno.RA;
. END LOOP;
. END;
Procedure NOTA_ALUNO compilado

Criamos a PROCEDURE sem passar parâmetros. Na linha 3, criamos um cursor considerando todos os dados
da tabela Aluno.
Na linha 5, criamos um loop com FOR, onde a variável vAluno receberá o resultado do cursor c_Aluno.
Na linha 7, calculamos a média com as notas do primeiro registro encontrado na tabela.
Nas linhas 8, 9, 10 e 11, classificamos o resultado conforme a média calculada.
Na linha 12, incluímos na tabela Aluno a média e o resultado de cada aluno.
Agora vamos executar a procedure:
EXECUTE NOTA_ALUNO;
Procedimento PL/SQL concluído com sucesso.
Vamos verificar o que aconteceu na tabela, com uma consulta:

SELECT * FROM tb_Aluno;
RA NOME AV1 AV2 MEDIA RESULTADO
---------- ------------------------- ---------- ---------- ---------- ---------------
2201 Alessandra Alice 9 7 8 APROVADO
2202 Iris Inácio 4 6 5 RECUPERAÇÃO
2203 Lia Lemos 7 5 6 APROVADO
2204 Gisele Gomes 5 6 5,5 RECUPERAÇÃO
2205 Isis Iranda 7 10 8,5 APROVADO
2206 Ana Almeida 8 4 6 APROVADO
A cada loop realizado, o cursor apanhou o registro da tabela e fez o cálculo da média, a classificação do
resultado e a atualização dos dados de todos os registros da tabela Aluno.
Veja no vídeo abaixo a criação e a execução da Procedure do exemplo acima:
SAIBA MAIS...
Neste tópico vimos como criar um procedimento armazenado (stored procedure), tipo PROCEDURE,
utilizando comandos do SQL e os cursores.
Criação de Functions
Como criar procedimentos armazenados (stored procedures) utilizando uma Function.
NESTE TÓPICO
AS DIFERENÇAS ENTRE PROCEDURE E FUNCTION
A SINTAXE DA FUNCTION
Referências
NESTE TÓPICO

Referências
Marcar
tópico
Olá alunos,
Outro tipo de procedimento armazenado (stored procedure) que vamos ver agora é a FUNCTION que poderá
ser utilizada em certas situações. Como assegurar que determinados dados possam ser manipulados e
apresentados em relatórios, antes de serem armazenados.
1 - A FUNCTION também é um subprograma, a exemplo da Procedure, mas retorna valores, ao contrário da
Procedure que não retorna valores.
2 - Outra diferença é que na Procedure a passagem de parâmetros é opcional enquanto na Function a utilização
de parâmetros é obrigatória.
3 - Oura diferença é que a Procedure é executada através do comando EXECUTE enquanto a FUNCTION é
chamada por uma query (SELECT) ou utilizadas em cálculos.
CREATE OR REPLACE FUNCTION nome_funcao
(parâmetro1 modo tipo_de_dados,
parâmetro2 modo tipo_de_dados,
parâmetroN modo tipo_de_dados)
RETURN tipo_de_dado
IS ou AS
variáveis locais,constantes,...
BEGIN
-- COMANDOS;
END nome_funcao;
Para eliminar uma função:
DROP FUNCTION nome_da_funcao;
Exemplo 1:
Criar uma função que retorne a quantidade de produtos de uma determinada categoria. Para isso, ela receberá o
código da categoria que será totalizada.
CREATE OR REPLACE FUNCTION conta_produto

(p_categoria IN produto.categoria%TYPE)
RETURN number
IS
v_total number;
BEGIN
SELECT COUNT(*) INTO v_total FROM produto
WHERE categoria = p_categoria;
RETURN v_total;
. END conta_produto;
./
Criamos a FUNCTION passando o parâmetro p_categoria.

Na linha 3, indicamos o tipo de dados que será retornado.
Na linha 5, criamos a variável v_total. Note que na Procedure e na Function não utilizamos a clausula
DECLARE, mas a área do DECLARE (declaração de variáveis) é depois do IS e antes do BEGIN.
Na linha 7, utilizamos o comando SELECT com a função de agregação: COUNT(*), que é um contador de
linhas ou registros. Neste caso, vai retornar a quantidade de produtos, de acordo com o código da categoria
passado pelo usuário (WHERE categoria = p_categoria) e atribuir esta quantidade na variável (INTO
v_total).
Na linha 9, retornamos a quantidade de produtos armazenado na variável v_total.
Na linha 11, utilizamos a barra “/ “ para executarmos o código no SQL PLUS (linha de comando), no SQL
Developer não é necessária.
Para utilizar a Function:
SELECT conta_produto (10) FROM dual;
O usuário vai executar o SELECT com a função, passando o código da categoria que se deseja saber a
quantidade de produtos desta categoria.
Exemplo 2:
Criar uma função para apresentar o fatorial de um número a ser informado no comando SELECT. Lembrete: x!
= x * (x-1)!
CREATE OR REPLACE FUNCTION fatorial

(p_n IN NUMBER)
RETURN number
IS
BEGIN
IF p_n = 1 THEN
RETURN 1;
ELSE
RETURN p_n * fatorial (p_n-1);
. END IF;
. END fatorial;
./
Utilizando a Function:
SELECT fatorial (3) FROM dual;
O usuário utilizará a função, passando o número que deseja calcular o factorial.

Exemplo 3:
Criar uma função que recebe um número de RA de aluno, como uma entrada e retorna o nome e o sobrenome
concatenados.
CREATE TABLE ALUNO (

RA NUMBER,
NOME VARCHAR2(20),
SOBRENOME VARCHAR2(30));
INSERT INTO ALUNO VALUES (1,'ANTONIO','ALVES');

INSERT INTO ALUNO VALUES (2,'BEATRIZ','BERNARDES');
CREATE OR REPLACE FUNCTION NOME_ALUNO (
. P_RA ALUNO.RA%TYPE)
. RETURN VARCHAR2
. IS
. V_NOMECOMPLETO VARCHAR2(60);
. BEGIN
. SELECT NOME || ' ' || SOBRENOME
. INTO V_NOMECOMPLETO
. FROM ALUNO
. WHERE RA = P_RA;
. RETURN V_NOMECOMPLETO;
. END NOME_ALUNO;
Criamos a tabela e inserimos os dados para formar o banco de dados do exemplo.

Na linha 9, criamos a função passando um parâmetro.
Na linha 13, criamos a variável V_NOMECOMPLETO.
Na linha 15, com o comando SELECT pegamos o dado do campo NOME e o dado do
campo SOBRENOME e armazenamos na variável V_NOMECOMPLETO (INTO V_NOMECOMPLETO).
Na linha 19, retornamos o nome completo do aluno.
Utilizando a FUNCTION NOME_ALUNO:
SELECT RA, NOME_ALUNO(RA) "NOME COMPLETO" FROM ALUNO;

1 ANTONIO ALVES
2 BEATRIZ BERNARDES
Utilizamos a FUNCTION apresentando o RA e o nome completo de cada aluno.

Como parâmetro passamos o campo RA e assim a função será aplicada em todos os registros da tabela.
SELECT NOME_ALUNO(02) FROM DUAL;

BEATRIZ BERNARDES
Agora, utilizamos a mesma função, passando como parando um determinado número do RA de um aluno,
assim a função será aplicada somente em um registro.
Exemplo 4:
Criar uma função que calcula o INSS. Receberá o valor do salário como parâmetro e retornará o valor do
desconto de INSS, conforme a tabela de desconto abaixo:
Salário Desconto
Até R$ 1693,72 8%
De R$ 1693,73 a R$ 2822,90 9%
De R$ 2822,91 a R$ 5645,80 11%
Acima de R$ 5645,80 O desconto é de R$ 621,04.
CREATE TABLE funcionario(

codfunc number(2),
nomefunc varchar(20),
salario number(7,2));
INSERT INTO funcionario VALUES(1,'Fernanda Fernandez',1693.72);

INSERT INTO funcionario VALUES(2,'Silvio Santos',1693.73);
INSERT INTO funcionario VALUES(3,'Carla Camargo',2850.02);
INSERT INTO funcionario VALUES(4,'Marilia Marques',2400.79);
. INSERT INTO funcionario VALUES(5,'Emilio Ernandes',6306.23);
.
. CREATE OR REPLACE FUNCTION f_calcula_INSS (v_salario IN NUMBER)
. RETURN NUMBER
. IS
. BEGIN
. IF v_salario <= 1693.72 THEN
. RETURN round((v_salario * 0.08),2);
. ELSIF v_salario >=1693.73 AND v_salario <= 2822.90 THEN
. ELSIF v_salario >=2822.91 AND v_salario <= 5645.80 THEN
. ELSE
. RETURN 621.04;
. END IF;
. END;
Criamos a tabela e inserimos os dados para formar o banco de dados.

Na linha 12, criamos a FUNCTION e passamos o parâmetro v_salario.
Das linhas 16 à 24, utilizamos o bloco IF para calcularmos o desconto do INSS.
A cada condição satisfeita, já retornamos o cálculo do desconto do INSS com o comando RETURN.
Utilizamos a função round que fez o arredondamento, considerando 2 casas decimais para os centavos.
Para utilizar a função:
*Colocar o nome do campo, não o valor do salário:
SELECT codfunc, nomefunc, salario, f_calcula_INSS (salario) "Desconto INSS:" FROM Funcionario;
CODFUNC NOMEFUNC SALARIO Desconto INSS:

---------- -------------------- ---------- ---------------------------------------
1 Fernanda Fernandez 1693,72 135,5
2 Silvio Santos 1693,73 152,44
3 Carla Camargo 2850,02 313,5
4 Marilia Marques 2400,79 216,07
5 Emilio Ernandes 6306,23 621,04
Utilizamos a função, passando como parâmetro o campo salário, no SELECT, para retornar o desconto do
INSS de cada funcionário, relacionando os demais dados como o código, o nome e o salário de cada
funcionário.
Podemos realizar outros tipos de consulta utilizando a mesma função:
SELECT nomefunc, salario, f_calcula_INSS (salario) "Desconto INSS:", salario - f_calcula_INSS (salario)
"Salário Líquido:" FROM Funcionario;
NOMEFUNC SALARIO Desconto INSS: Salário

Líquido:
-------------------- ---------- ---------------------------------------
---------------------------------------
Fernanda Fernandez 1693,72 135,5
1558,22
Silvio Santos 1693,73 152,44
1541,29
Carla Camargo 2850,02 313,5
2536,52
Marilia Marques 2400,79 216,07
2184,72
Emilio Ernandes 6306,23 621,04
5685,19
Agora, utilizamos a mesma função para realizarmos um outro tipo de relatório, já que o comando SELECT
aceita qualquer cálculo aritmético, pegamos cada salário e subtraímos o desconto do INSS, utilizando a função
(salario – f_calcula_INSS (salario)).
Lembrando, que neste caso, o cálculo só irá gerar um relatório, sem alterar nada na tabela, para armazenarmos
os dados na tabela, teríamos que criar uma PROCEDURE com um comando UPDATE.
Veja no vídeo abaixo, a criação e utilização da Function do exemplo acima:
SAIBA MAIS...
Neste tópico vimos como podemos criar um outro tipo de procedimento armazenado (stored procedure), como
a FUNCTION, utilizando comandos do SQL e funções.
Criação de Triggers para auditoria em banco de

dados
Como utilizar o procedimento armazenado TRIGGER para realizar auditoria em banco de dados.
NESTE TÓPICO
NESTE TÓPICO
CARACTERÍSTICAS DA TRIGGER
DIFERENÇAS ENTRE A TRIGGER, A PROCEDURE E A FUNCTION
Referências
Marcar
tópico
Olá alunos,
Além das stored procedures: PROCEDURE e FUNCTION, também temos um outro de tipo de procedimento
armazenado: a TRIGGER, que pode ser utilizada de uma forma diferente, como por exemplo, para criar
auditorias das transações em Banco de Dados.
Auditoria em banco de dados significa monitorar as transações realizadas pelos usuários, assegurando as regras
de negócio, quanto a manipulação de dados, estabelecidas pela empresa.
CARACTERÍSTICAS DA TRIGGER
São blocos PL/SQL disparados automaticamente e implicitamente sempre que ocorrer um evento associado a
uma tabela: INSERT, UPDATE ou DELETE, por exemplo.
Utilizadas para:
• Manutenção de tabelas
• Implementação de níveis de segurança mais complexos
• Geração de valores de colunas (Exemplo: gerar o valor total do pedido a cada inclusão, alteração ou exclusão
na tabela Pedido)
A sintaxe de uma TRIGGER:
CREATE OR REPLACE TRIGGER nome_trigger
BEFORE ou AFTER INSERT OR UPDATE OR DELETE OF (nome_coluna1, nome_coluna2, .)
ON nome_tabela
FOR EACH ROW (OPCIONAL)
WHEN condição (OPCIONAL)
DECLARE
...
BEGIN
...
END;
DIFERENÇAS ENTRE A TRIGGER, A PROCEDURE E
A FUNCTION
A TRIGGER também é uma stored procedure, o seu código depois de compilado, fica armazenado em disco,
mas tem características um pouco diferentes da PROCEDURE e da FUNCTION:
A PROCEDURE é executada através do comando EXECUTE ou EXEC e pode ou não receber valores
por parâmetros.
A FUNCTION é utilizada através de uma query (comando SELECT) e o recebimento de valores
por parâmetros é obrigatória.
A TRIGGER (gatilho) é “disparada” a partir de um evento (comando) associado a ela e não tem recebimento
de valores por parâmetros.
Outra característica da TRIGGER: o TEMPO:
Os tempos de uma trigger podem ser:
• BEFORE – o código da TRIGGER é executado antes de ocorrer o evento: a execução do comando a ela
associado.
• AFTER – o código da TRIGGER é executado depois que o evento ocorreu: depois da execução do comando
a ela associado.
EVENTO:
Os eventos de uma trigger podem ser:
 INSERT
 UPDATE
 DELETE
 LOGON
 LOGOFF
Cláusula WHEN
Utilizada para restringir as linhas que irão disparar a trigger.
TIPOS:
Indica quantas vezes a trigger poderá ser disparada. Os tipos podem ser:
• Comando: acionada antes ou depois de um comando, independentemente de este afetar uma ou mais linhas.
Não permite acesso às linhas atualizadas por meio dos prefixos :OLD e :NEW. Não utiliza a cláusula FOR
EACH ROW no cabeçalho de criação.
• Linha: acionada uma vez para cada linha afetada pelo comando ao qual a trigger estiver associada. Permite o
uso dos prefixos :OLD e :NEW no corpo da trigger e da cláusula WHEN em seu cabeçalho. Deve-se incluir a
cláusula FOR EACH ROW no cabeçalho.
OS PREFIXOS :OLD E :NEW
Vamos lembrar que Turing e Von Neumann instituíram o conceito de instruções armazenadas em memória:
todo programa, aplicativo, software e dados são armazenados na Memória Principal, conhecida como memória
RAM.
Quando você sobe qualquer Sistema Gerenciador de Banco de Dados, seja da Oracle, da Microsoft, o
PostGree, por exemplo, o SGBD vai ocupar uma parte da Memória Principal do computador para realizar o
armazenamento das instruções e dos dados que estão sendo executados, além de executar os processos do
SGBD conhecidos como processos de background (segundo plano). No caso do Oracle, esta área da memória é
chamada de SGA (System Global Area).
Como todas as instruções do SQL também são executadas a partir da Memória Principal e os dados envolvidos
nestas instruções também ficam em uma área da memória.
Com os comandos :NEW e :OLD, que na realidade são como ponteiros que apontam para os dados que estão
nestas áreas da memória.
Por exemplo, se for executado um comando INSERT, são dados novos deste comando que ainda não estão na
tabela que está no disco (HD) e com o prefixo :NEW, posso acessar estes dados que estão nesta área da MP
(Memória Principal).
Se for executado um comando DELETE, os dados que serão apagados subiram do disco para a memória, e com
o prefixo :OLD posso acessar esta área da memória onde estão estes dados.
Se for executado um comando UPDATE, os dados que serão alterados subiram do disco para a memória, e
com o prefixo :OLD posso acessar esta área da memória onde estão estes dados e com o prefixo :NEW, posso
acessar os novos valores da área da memória.
Portanto, em resumo podemos representar a utilização de :NEW e :OLD com a tabela abaixo:
Conteúdo das áreas OLD e NEW
EVENTO: OLD NEW
INSERT NULL valor novo a ser

inserido
UPDATE valor antes da valor após a alteração

alteração
DELETE valor antes da NULL

exclusão
• Em TRIGGERS com cláusula de tempo BEFORE (antes do comando SQL ser executado) é possível
consultar e alterar o valor de :NEW, pois o comando SQL ainda não foi executado.
• Em TRIGGERS com cláusula de tempo AFTER (depois do comando SQL ser executado) é possível apenas
consultar o valor de :NEW, pois o comando SQL já foi executado.
Outras regras para a criação de triggers:
• Número máximo de triggers possíveis para uma tabela: 12 (doze) (todas as combinações possíveis entre
tempos, eventos e tipos).
• Não podem ser utilizados os comandos COMMIT e ROLLBACK, inclusive em procedures e functions
chamadas pela trigger.
• Não podem ser alteradas chaves primárias, únicas ou estrangeiras.
Comandos que podemos utilizar para controlar a execução de TRIGGER:
DROP TRIGGER nome_trigger; Elimina uma trigger
ALTER TRIGGER nome_trigger Habilita uma trigger

ENABLE;
ALTER TRIGGER nome_trigger Desabilita uma trigger

DISABLE;
ALTER TABLE nome_tabela Habilita todas as triggers de uma

ENABLE ALL_TRIGGERS; tabela
ALTER TABLE nome_tabela Desabilita todas as triggers de

DISABLE ALL_TRIGGERS; uma tabela
Como a TRIGGER é acionada (disparada) por estar associada a um comando, podemos habilitar ou desabilitar
a execução da TRIGGER caso seja necessário. Por padrão, quando compilamos e criamos uma TRIGGER, esta
já está habilitada.
Exemplo 1:
CREATE TABLE produto (codigo NUMBER(4), preco NUMBER(7,2));
INSERT INTO produto VALUES (1,'20,54');

Criamos como exemplo uma tabela Produto com os campos: código do produto e preço.
Depois cadastramos alguns produtos.
Agora vamos criar uma tabela para registrar a ação do usuário na tabela Produto.
CREATE TABLE log_produto (

codigo NUMBER(4),
preco_anterior NUMBER(7,2),
preco_atual NUMBER(7,2),
usuario VARCHAR(30),
data_atual DATE);
Esta tabela não pertence ao sistema de informação da empresa e é para o profissional de TI monitorar a ação
do usuário. O usuário nem deve saber que esta tabela existe.
Agora vamos criar uma TRIGGER para registrar a ação do usuário:
CREATE OR REPLACE TRIGGER verifica_preco

BEFORE UPDATE OF preco ON produto
FOR EACH ROW
BEGIN
INSERT INTO log_produto VALUES
(:OLD.codigo, :OLD.preco, :NEW.preco, user, sysdate);
END;
Na linha 1, criamos uma TRIGGER verifica_preco.

Na linha 2, colocamos o tempo BEFORE e associamos a TRIGGER ao comando SQL: UPDATE no
campo preco na tabela Produto. Assim determinamos quando o código da TRIGGER será executado: quando
o usuário realizar uma alteração (UPDATE) no campo preço da tabela Produto. Se o usuário realizar um
INSERT, DELETE ou um UPDATE em um outro campo, que não seja o preço, da tabela Produto, nada
acontecerá, a TRIGGER não será acionada.
Na linha 3, o comando FOR EACH ROW é opcional, mas como vamos utilizar os ponteiros: :NEW e :OLD,
este comando é obrigatório para que os ponteiros percorram cada linha do comando SQL, no caso do
UPDATE, afetada.
Na linha 5, cadastramos na tabela log_produto, NÃO na tabela Produto, os seguintes dados:
O código do produto que foi alterado (:OLD.codigo), o preço do produto que estava na tabela (:OLD.preco),
o valor para o qual foi alterado (:NEW.preco), o usuário que realizou a transação (user) e a data e hora em
que o usuário realizou a transação (sysdate).
Vamos agora realizar, como se fosse o usuário, uma alteração de preço no produto de código 3, por exemplo:
UPDATE produto SET preco = '40,44' WHERE codigo = 3;
Agora, como se fossemos um profissional de TI (um DBA, um analista de segurança), vamos sem o usuário
saber, realizar uma simples consulta na tabela que criamos para registrar (log) a ação do usuário:
SELECT * FROM log_produto;
CODIGO PRECO_ANTERIOR PRECO_ATUAL USUARIO DATA_ATUAL

---------- -------------- ----------- ------------------------------ ----------
3 58,99 40,44 DENILSON 14/11/18
Verificamos que, no momento em que a transação foi realizada, a TRIGER foi acionada pelo comando
UPDATE e foi registrado o código do produto, o preço que era, para quanto mudou, o nome do usuário e a
data em que foi realizada a ação.
Se tivéssemos realizado um UPDATE em todos os preços da tabela, a TRIGGER iria registrar tudo, cada
registro alterado.
Agora vamos fazer uma pequena alteração no código da TRIGGER:
CREATE OR REPLACE TRIGGER verifica_preco

BEFORE UPDATE OF preco ON produto
FOR EACH ROW
BEGIN
if (:NEW.preco < 0) then
RAISE_APPLICATION_ERROR (-20500, 'Não é permitido preço negativo');
else
INSERT INTO log_produto VALUES
(:OLD.codigo, :OLD.preco, :NEW.preco, user, sysdate);
. END IF;
. END;
Nas linhas 5, 6 e 7, incluímos um bloco if com a condição que vai verificar se o usuário for alterar o preço
novo, colocando um preço negativo, a TRIGGER vai impedir a realização do comando UPDATE, pois
colocamos o tempo BEFORE, se tivéssemos colocado o tempo AFTER, o comando UPDATE seria realizado e
assim o preço negativo seria incluído no comando.
Na linha 6, se o usuário digitar um preço negativo, a mensagem será emitida ao usuário.
O comando RAISE_APPLICATION_ERROR é um comando de saída, semelhante ao
DBMS_OUTPUT.PUT_LINE, só que permite criar um número para o erro, mas não é qualquer número, o
Oracle permite que você escolha uma número entre 20000 até 20999.
Veja a vídeo aula abaixo sobre estes exemplos de TRiGGERs:
SAIBA MAIS...
https://www.oracle.com/technetwork/database/focus-areas/application-development/index-101230.html
Neste tópico vimos como utilizar um outro tipo de stored procedure: a TRIGGER e como utilizá-la para
realizarmos auditorias no banco de dados.
Auditoria das transações utilizando o recurso

AUDIT do Oracle
Mostrar como utilizar o recurso AUDIT, um recurso próprio do Sistema Gerenciador de Banco de Dados
Oracle para realizar auditorias em transações que envolvem dados.
NESTE TÓPICO
AUDITORIA DO ORACLE
Referências
NESTE TÓPICO
AUDITORIA DO ORACLE
Referências
Marcar
tópico
Olá alunos,
A utilização de recursos para a realização de auditorias em banco de dados é de extrema importância para o
setor corporativo. Monitorar e registrar as transações realizadas no banco de dados pelos funcionários
(usuários) da empresa. Existem vários procedimentos que podem ser implantados e a Oracle, para atender esta
necessidade, criou o recurso AUDIT, que veremos a partir de agora.
AUDITORIA DO ORACLE
O Oracle tem a capacidade de fazer a auditoria das ações ocorridas no banco de dados.
Vamos utilizar, no princípio, a interface por linhas de comando SQL PLUS.
Faça a conexão como usuário system com o comando:
ALTER SYSTEM SET AUDIT_TRAIL=DB SCOPE=SPFILE;
CONNECT system/senha;
Este recurso é nativo no sistema do Oracle, mas deve ser ativado e para ativar a auditoria, devemos ajustar o
parâmetro estático AUDIT_TRAIL através do seguinte comando:
ALTER SYSTEM SET AUDIT_TRAIL=DB SCOPE=SPFILE;
O que fizemos foi utilizar o ALTER SYSTEM para alterar o sistema e com a cláusula SET realizar o ajuste
da “trilha” da auditoria apontando para o Banco de Dados ( DB) e estendendo (SCOPE) para o parâmetro do
arquivo de inicialização: SPFILE.
Mesmo executado este comando, para que o sistema aceite estas alterações, devemos encerrar e reiniciar a
instância do sistema, conforme os comandos abaixo, mas para realizar estes comandos, SHUTDOWN e
STARTUP, por exemplo, você deverá entrar, além do usuário system também com recursos de DBA, da
seguinte forma:
CONN system/senha AS SYSDBA;
Depois, então encerrar o Banco de Dados:
SHUTDOWN IMMEDIATE;
E a mensagem do sistema:
Banco de dados fechado.

Banco de dados desmontado.
InstÔncia ORACLE desativada.
E depois abrir novamente (reiniciar):
STARTUP;
E a mensagem do sistema:
InstÔncia ORACLE iniciada.
Total System Global Area 1068937216 bytes

Fixed Size 2260048 bytes
Variable Size 838861744 bytes
Database Buffers 222298112 bytes
Redo Buffers 5517312 bytes
Banco de dados montado.
Banco de dados aberto.
Agora, vamos verificar se tudo foi alterado e ativado através do comando:
SELECT NAME, VALUE FROM V$PARAMETER WHERE NAME = 'audit_trail';
E a informação do sistema:
NAME
--------------------------------------------------------------------------------
VALUE
--------------------------------------------------------------------------------
audit_trail
DB
Com o valor (VALUE) do audit_trail em DB significa que o recurso da auditoria foi ativado. Se o valor
apresentado fosse NONE em vez de DB, teríamos que refazer o processo.
Antes de continuarmos, vamos criar um banco de dados como exemplo para aplicarmos a auditoria.
Podemos agora abrir o SQL Developer (sem fechar o SQL Plus), se conectar com outro usuário que não seja o
system e criar a tabela:
CREATE TABLE tb_Funcionario (

nome VARCHAR(30),
salario NUMBER(7,2));
Agora, voltando como system no SQL Plus, vamos configurar a auditoria na tabela criada.
O Oracle utiliza a tabela do sistema (system): SYS.AUD$. É a tabela que armazenará os dados das ações do
usuário, funcionando como uma tabela de log.
Os comandos do SQL que são auditados, são os comandos mais comuns utilizados pelos usuários: SELECT,
INSERT, UPDATE e DELETE.
A sintaxe do comando para configurar a auditoria é o seguinte:
AUDIT comandoSQL1, comandoSQL2,… ON Nome_do_usuario.Tabela BY ACCESS;
Temos que utilizar a cláusula BY ACCESS para que o registro de auditoria seja gravado toda vez que o objeto
(tabela) for acessado pelo usuário. Esta cláusula é utilizada para medir o número de ações separadas que
ocorrem durante um intervalo de tempo específico.
E para proteger o controle de auditoria em SYS.AUD$, por acesso, devemos utilizar o seguinte comando:
AUDIT ALL ON SYS.AUD$ BY ACCESS;
Vamos então configurar a auditoria para o nosso exemplo, como se fossemos o DBA do sistema:
SQL> AUDIT ALL ON SYS.AUD$ BY ACCESS;
Auditoria realizada.
SQL> AUDIT INSERT, UPDATE, DELETE ON denilson.tb_Funcionario BY ACCESS;
Auditoria realizada.
Utilizamos o primeiro comando para realizar toda (ALL) auditoria por acesso na tabela AUD$ do sistema.
Este comando é obrigatório para este tipo de auditoria.
Depois, determinamos que fosse realizada a auditoria dos comandos : INSERT, UPDATE e DELETE na
tabela: tb_Funcionario, que pertence ao usuário denilson. Se o usuário realizar uma consulta na tabela
tb_Funcionario com o comando SELECT, por exemplo, esta consulta não será registrada na tabela de
auditoria, pois só determinamos os comandos: INSERT, UPDATE e DELETE para serem registrados na tabela
de auditoria do sistema (SYS.AUD$).
Agora, vamos agir como o usuário, voltar ao SQL Developer e inserir um registro na tabela tb_Funcionario:
INSERT INTO tb_Funcionario VALUES ('Mary Mateus', '3245,76');
Agora, como se fossemos o DBA, voltando para o SQL Plus, vamos realizar uma consulta na tabela de
auditoria:
SQL> SELECT username, obj_name, action_name, TO_CHAR(timestamp, 'dd-mm-yyyy hh24:mi:ss') "Data e Hora:"
FROM DBA_AUDIT_OBJECT ORDER BY "Data e Hora:" DESC;
USERNAME OBJ_NAME
ACTION_NAME Data e Hora:
------------------------------ -------------------------------------------------------------------
---------------------------- -------------------
DENILSON TB_FUNCIONARIO INSERT
16-11-2018 00:47:48
No relatório com o SELECT determinamos o nome do usuário (USERNAME), o nome do objeto

(OBJ_NAME), que no caso é a tabela, a transação realizada pelo usuário (ACTION_NAME), que no caso é o
comando SQL e a data e a hora em que o usuário executou o comando. Para a data e a hora utilizamos a
função timestamp, que captura a data e a hora do sistema. Utilizamos a função TO_CHAR( ) para
formatarmos a data e a hora como desejamos. Utilizamos os parâmetros: 'dd-mm-yyyy hh24:mi:ss', para
apresentar o dia, o mês, o ano com quatro dígitos (yyyy), a hora com o sistema 24, os minutos e os segundos.
O resultado foi o nome do usuário, a tabela que ele acessou ( tb_Funcionario), o comando realizado
(INSERT) e a data, a hora, minutos e segundos que o usuário fez a transação.
Vamos realizar outro exemplo, voltando a ser o usuário no SQL Developer:
UPDATE tb_Funcionario SET salario = '4988,91' WHERE nome = 'Mary Mateus';
Voltando como DBA no SQL Plus, vamos realizar novamente a consulta na tabela de auditoria:
SQL> SELECT username, obj_name, action_name, TO_CHAR(timestamp, 'dd-mm-yyyy hh24:mi:ss') "Data e Hora:"
FROM DBA_AUDIT_OBJECT ORDER BY "Data e Hora:" DESC;
USERNAME OBJ_NAME
ACTION_NAME Data e Hora:
------------------------------ --------------------------------------------------------------------
---------------------------- -------------------
DENILSON TB_FUNCIONARIO
UPDATE 16-11-2018 01:14:04
DENILSON TB_FUNCIONARIO
INSERT 16-11-2018 00:47:48
Realizamos, como se fossemos um usuário, uma alteração no salário do funcionário com o

comando UPDATE.
Depois, como se fossemos um DBA, realizamos novamente a consulta na tabela de auditoria e também foi
registrado a ação do usuário. Como ordenamos a consulta pela data e a hora com o comando ORDER BY,
utilizamos a cláusula DESC (ordem descendente pela data) para apresentar o resultado com as ações realizadas
mais recentemente em primeiro lugar na lista, senão, as ações mais antigas ficariam no topo do relatório e as
últimas transações realizadas ficariam no final do relatório.
Veja no vídeo a seguir à utilização do recurso AUDIT do exemplo acima:
Imaginem também que dentro de uma empresa, pode-se ter várias transações sendo realizadas na mesma
tabela, por vários usuários, em um mesmo dia e em uma semana ou passado meses, esta tabela de auditoria irá
crescer muito em volumes de registros, mas podemos limpá-la periodicamente com os comandos:
DELETE FROM SYS.AUD$;
Ou
TRUNCATE TABLE SYS.AUD$;
Podemos utilizar o comando DELETE se quisermos utilizar filtros para apagar certos registros, como por
exemplo, apagar todos os registros do usuário denilson:
DELETE FROM SYS.AUD$ WHERE USERNAME = ‘denilson’;
Ou poderemos apagar os registros de uma determinada data, mas é aconselhável que se arquive o conteúdo da
tabela de auditoria e realize o comando TRUNCATE TABLE para limpar toda a tabela.
Note que este recurso do Oracle só permite realizarmos a auditoria pelo comando SQL realizado em uma
determinada tabela, mas se criarmos uma trigger como auditoria, poderemos registrar também, no caso de um
UPDATE, por exemplo, quais foram os valores e de quais campos e quais linhas ou registros da tabela foram
alterados.
SAIBA MAIS...
Neste tópico vimos como utilizar o recurso implantado pela Oracle para realizarmos auditorias e monitorarmos
as ações dos usuários em um Banco de Dados.
Visão geral de segurança do Oracle

Apresentar as principais características do Sistema Gerenciador de Banco de Dados Oracle quanto ao seu
sistema de segurança aos dados.
NESTE TÓPICO
CARACTERÍSTICAS DA SEGURANÇA DO ORACLE
CONEXÃO E ACESSO AOS DADOS
PRIVILÉGIOS DE SISTEMA
PRIVILÉGIOS DE OBJETO
AUDITORIA
BACKUP E RECUPERAÇÃO
Referências
NESTE TÓPICO

AUDITORIA
Referências
Marcar
tópico
Olá alunos,
Após a revolução industrial, as empresas desenvolveram o seu “sistema de informação” muito antes do
surgimento do computador. Registravam os seus dados em papeis, livros contábeis, etc. As pessoas guardavam
telefones de parentes e amigos em cadernetas, isto era um banco de dados? Sim, escritos com canetas ou
impressos através de uma máquina de datilografia em papeis, mas era um tipo de banco de dados.
Com o surgimento do computador, tínhamos um dispositivo conhecido como memória principal, onde
podíamos armazenar dados ou valores em variáveis. Mas este tipo de memória é volátil: os dados ficam nessas
variáveis temporariamente, durante a execução do software e se a energia elétrica cessar, também todo o
conteúdo da memória principal será perdido.
Então, certos dados não podem ficar neste tipo de memória, primeiramente foram utilizados cartões perfurados
e atualmente, quando falamos em banco de dados, este banco está armazenado de forma permanente em discos,
pois é um tipo de memória não volátil.
Sistema Gerenciadores de Banco de Dados (SGBD):
Com a crescente demanda por banco de dados na forma computacional, vários sistemas surgiram para
controlar os dados armazenados em discos, conhecidos como SGBD (Sistema Gerenciador de Banco de
Dados) como o modelo de dados hierárquico e o modelo de dados em redes. Em junho de 1970, o matemático
Edgard F Codd publica um artigo (“Relational Model of Data for Large Shared Data Banks”) propondo um
modelo de Banco de Dados Relacional, que se tornou a base de todos os SGBDs presentes no mercado. Os
dados ou valores são armazenados em atributos ou colunas ou popularmente conhecidos como campos, estes
campos ficam em tabelas e estas tabelas são relacionadas com outras tabelas.
Todo o SGBD é um software, mas é muito mais do que isto, é um sistema gerenciador, ou seja, um software
que controla o acesso aos dados e garante a consistência destes dados.
O Oracle tem em seu sistema, processos implantados para permitir acesso aos dados pelos usuários e controlar
as transações disparadas por eles.
Lembrando que a linguagem SQL é padronizada e obrigatória em todos os SGBDs do mercado, mas a parte de
gerenciamento e segurança, é uma particularidade de cada sistema, esta parte não é padronizada, mas
praticamente é obrigatória nos SGBDs e vamos ver agora alguns destes recursos do sistema da Oracle.
CARACTERÍSTICAS DE SEGURANÇA
Todo o SGBD é preparado para trabalhar como servidor, de forma distribuída, e assim podemos ter a
possibilidade de diversos usuários acessarem uma mesma base de dados em um mesmo instante.
Então, um dos recursos de segurança é controlar o acesso e a utilização do banco de dados pelos usuários:
 Não permitir acessos à dados não autorizados.
 Monitorar as transações dos usuários, através de auditoria.
Lembrando que um SGBD tem diversos recursos semelhantes aos de um SO (Sistema Operacional) tipo
servidor (server) e não a um SO doméstico (desktop), como controle de concorrência, mecanismos de acesso a
arquivos e a dispositivos de hardware.
O Oracle tem uma particularidade um pouco diferente dos outros SGBDs, lembrando que o modelo utilizado
por todos os sistemas é o modelo Relacional, que é baseado na teoria dos conjuntos: um banco de dados é um
conjunto de tabelas relacionados, cada tabela tem um conjunto de registros e cada registro um conjunto de
valores (dados) atribuídos em campos.
Portanto, nos outros sistemas, devemos primeiramente criar o banco de dados, depois abrir este banco e então
criar as tabelas.
No caso do Oracle, devemos criar um esquema (SCHEMA) que está diretamente ligado à um usuário, na
realidade, devemos criar um usuário e este usuário estará associado a um esquema.
O esquema possui dois mecanismos de segurança: segurança de sistema e segurança de objetos (dados).
A segurança de sistema permite acesso do usuário aos recursos do sistema como, por exemplo, a conexão com
o banco de dados, através do comando CONNECT, a determinação de recursos de hardware, como por
exemplo, espaço disponível em disco para cada usuário (esquema).
A segurança de objetos permite o acesso do usuário aos objetos, como por exemplo, à uma tabela e quais serão
as ações do usuário a este objeto: consultas e/ou alterações.
O Oracle obriga que o usuário se conecte através de um esquema com um nome e senha para ter acesso aos
dados. Este esquema possui os privilégios de acesso ao sistema e aos dados. Após realizada esta conexão, é
que o usuário poderá criar as tabelas, isto se tiver também autorização (privilégio) para a criação de tabelas.
Cada usuário do sistema Oracle terá que fazer uma conexão com um nome e senha válidos, se a conexão é
validada, o usuário tem uma sessão aberta. Só que para realizar esta conexão, este usuário deverá ter o
privilégio de sistema para o comando CONNECT, senão mesmo tendo um nome e senha válidos, mas não
tiver o privilégio do comando CONNECT, não conseguirá realizar a conexão e consequentemente nada poderá
fazer no sistema, mesmo que tenha autorização para criar tabelas. Observa-se aí, o esquema de segurança do
Oracle, já na conexão.
Assim, cada usuário tem um conjunto de recursos ligados a um esquema:
TIPOS DE SEGURANÇA RECURSOS
Privilégios Privilégios de sistema, privilégios de

objetos
Auditoria Auditoria de objetos, auditoria de

privilégio.
Backup e recuperação Monitoramento e registros das

transações
Privilégios:
Os privilégios, dão autorizações, concedem permissões para o usuário executar determinadas ações no banco
de dados.
Geralmente, este tipo de privilégio é concedido, em grande parte, para os profissionais de TI, como o DBA, os
desenvolvedores e analistas. São privilégios que permitem estipular limites aos outros usuários e realizar ações
administrativas do banco, como definição de espaços (tablespace) para o usuário, definição de políticas de
backup e até de “derrubar” o banco de dados, como por exemplo, o comando SHUTDOWN. Para o usuário
final, por exemplo, pode-se conceder o privilégio de conexão com o comando CONNECT.
Estes tipos de privilégios determinam quais serão os tipos de ações que o usuário irá realizar em um objeto,
como por exemplo uma tabela ou uma view.
Por exemplo, se for concedido a permissão de consulta em uma tabela, este usuário só poderá realizar isto, não
poderá cadastrar ou modificar dados desta tabela. Se for concedido autorização para o usuário utilizar os
comandos: SELECT, INSERT, UPDATE e DELETE, este usuário poderá realizar, além da consulta, cadastro e
alterações nos dados da tabela.
Podemos também criar grupos de privilégios e denomina-los, conhecidos como papéis ( roles). Veremos mais
adiante como criar estes recursos. A criação de papéis facilita a organização e a aplicação dos privilégios.
Por exemplo, podemos criar grupos de privilégios (papéis) para cada cargo da empresa, assim quando um
assistente de vendas for admitido, podemos passar os privilégios do papel (role) assistente_Vendas para este
funcionário, que será diferente do grupo de privilégios do gerente de vendas.
AUDITORIA
O Oracle disponibiliza recursos, como o AUDIT, para monitorar e registrar as transações dos usuários nos
objetos do banco de dados.
Também, podemos realizar a auditoria no acesso ao banco de dados, quando o usuário se conecta e se
desconecta do banco de dados, por exemplo, registrando a data, hora, minutos e segundos em que o usuário fez
a conexão e também o horário em que ele fechou a conexão.
A política de backup faz parte da segurança dos dados, pois em caso de falhas ( crash) que podem ocorrer por
falhas do sistema ou por falhas de hardware. E o crash pode ocorrer internamente, dentro do ambiente da
empresa ou pode ser ocasionado por um crash externo, como a queda de energia da concessionaria de energia
elétrica.
O Oracle tem recursos tanto para determinar planos de backup periódicos como para a recuperação do banco
de dados em caso de falhas. Veremos também como utilizar estes recursos mais adiante.
SAIBA MAIS...
Dê uma olhada nos links abaixo para saber mais sobre a segurança em Banco de Dados:
Neste tópico tivemos uma overview dos recursos do Oracle para a implantação de mecanismos de segurança no
banco de dados.
Visão geral de segurança do MS SQL Server

Apresentar as principais características do Sistema Gerenciador de Banco de Dados da Microsoft: MS SQL
Server quanto ao seu sistema de segurança aos dados.
NESTE TÓPICO
CARACTERÍSTICAS DE SEGURANÇA DO MS SQL SERVER
O PROCESSO DE AUTENTICAÇÃO
SEGURANÇA DO SQL SERVER
COMPARANDO ORACLE E SQL SERVER
Referências
NESTE TÓPICO
CARACTERÍSTICAS DE SEGURANÇA DO MS SQL SERVER

Referências
Marcar
tópico
Olá alunos,
Vamos ver agora o Sistema Gerenciador de Banco de Dados de outra empresa: Microsoft e o seu SGBD: MS
SQL Server. Lembrando que a parte administrativa do sistema difere de um SGBD para outro, pois ao
contrário da linguagem SQL, esta parte administrativa não é padronizada.
O MS SQL Server começa a ser desenvolvido nos anos 80 em parceria com a Sybase.
Nos anos 90, a Microsoft rompe a parceria com a Sybase e lança a versão MS SQL Server 4.2 junto com o SO
(Sistema Operacional) para servidor: Windows NT 3.1. Com a junção do SGBD e do SO, a Microsoft tornou o
SQL Server um dos mais populares do mercado, perdendo só para o Oracle.
A Microsoft distribui outro sistema de banco de dados, conhecido como MS Access, que é próprio para
aplicações em pequenos negócios e pode trabalhar de forma desktop, sem a necessidade de servidor, mas para
o mundo corporativo, que exige aplicações em grande massa de dados e grande volume de transações, o MS
SQL Server é o sistema indicado.
CARACTERÍSTICAS DE SEGURANÇA DO MS SQL
SERVER
Conforme já citado, a Microsoft integrou o sistema de banco de dados com o sistema operacional, então a
primeira ação de segurança de proteção é a autenticação, que é a realização do logon e este logon gera uma
requisição (cria uma instância) ao servidor de banco de dados que irá realizar a autorização do acesso aos
objetos e transações do banco de dados, conforme as permissões associadas ao logon.
Portanto, a Microsoft determina uma hierarquia de acesso. Quando falamos em hierarquia, a referência é a de
uma estrutura em árvore, onde a raiz ou o topo é o primeiro elemento da hierarquia, então o servidor está no
topo e é o primeiro a ser instanciado pelo Sql Server quando o logon é realizado:
No caso da Microsoft, a autenticação padrão é realizada pelo sistema operacional: o Windows Server,
lembrando que no caso estamos falando sobre a versão do Windows para servidor, em um ambiente
corporativo, e não na versão desktop ou caseira.
Como o SQL Server está integrado com o sistema operacional, realizando o logon pelo SO, não será necessário
realizar outro logon para o sistema de banco de dados, as contas dos usuários, com suas permissões já estarão
disponíveis.
Podemos também realizar o logon no modo misto: pelo Windows e pelo SQL Server ou somente pelo SQL
Server, mas neste caso, não é recomendável, pois torna a ação menos segura. Porque, mesmo que os dados do
logon: nome e senha estejam criptografados, estes dados vão circular pela rede, enquanto que a realização do
logon pelo Windows Server, a autenticação será feita, também com os dados criptografados, somente entre o
Windows Server e o SQL Server.
Realizando o logon pelo Windows Server, não haverá a necessidade de realizar outro logon pelo SQL Server.
Atualmente, o Windows Server exige a criação de uma senha complexa para logon no SQL Server, a fim de
dificultar ataques de força bruta para captura de senhas. Veja a representação gráfica:
O administrador de redes Microsoft deverá determinar permissões individuas ou por grupos para o usuário
acessar os objetos do banco de dados do SQL Server. As autenticações são distintas para os usuários da rede
Windows e para os usuários do SQL Server.
A segurança do SQL Server é baseada em funções onde o administrador do sistema poderá atribuir permissões
para uma função ou para um grupo de usuários, no caso da criação de uma função, este procedimento é
semelhante a criação de papéis (roles) do Oracle. Tanto nos roles como nas funções, posso criar um conjunto
de permissões para a função dos funcionários da empresa, por exemplo: criar uma função: assistente_Vendas,
assim todos os usuários que possuírem o cargo de assistente de vendas herdarão as permissões da função
assistente_Vendas.
Posso criar um grupo de usuários, por exemplo: gerente e todo o grupo de gerentes da empresa herdarão as
permissões.
Neste caso, os usuários são relacionados a uma função e herdarão as permissões associadas a esta função. Por
exemplo: se for concedido ao usuário a função db_datawriter, o usuário terá permissão para realizar os
comandos INSERT, UPDATE e DELETE, se for concedido a função db_datareader, o usuário só terá
permissão de executar o comando SELECT. Nestes exemplos, estas funções (db_datareader e db_datawriter) já
fazem parte do SQL Server e são consideradas funções fixas do banco de dados, mas o administrador do
sistema também poderá criar suas próprias funções.
No Oracle, em primeiro lugar, o usuário tem que fazer a conexão à um esquema através de um logon, a partir
dai, os objetos (tabelas) que forem criados pertencerão a este usuário, que se torna o owner (proprietário) e
terá todos os direitos sobre estes objetos. Nenhum outro usuário poderá acessar o objeto, a não ser que o owner
ou o DBA conceda a permissão.
Em relação ao SQL Server, temos algo semelhante: o proprietário do objeto tem todas as permissões sobre este
objeto e nem o administrador do sistema poderá eliminar um usuário se este possuir pelo menos um objeto
associado a ele.
Já, um esquema no banco de dados SQL Server representa um contêiner denominado de objetos do banco de
dados, por exemplo, o esquema Financeiro contém todos os objetos (tabelas, usuários) relacionados ao
departamento Financeiro. Já no Oracle, o esquema está diretamente ligado à um usuário.
No SQL Server pode-se aplicar restrições de segurança a um esquema e todos os objetos deste esquema
herdaram estas regras. Neste caso, novos usuários poderão ser adicionados a um esquema.
Um desenvolvedor pode criar tabelas (objetos) em um esquema e ser o proprietário destes objetos, mas o
proprietário do esquema é o usuário responsável pela segurança dos dados.
Veja o exemplo representado pela figura abaixo:
SAIBA MAIS...
Dê uma olhada nos links abaixo para saber mais sobre segurança em Banco de Dados:
Neste tópico tivemos uma visão dos recursos do MS SQL Server para a implantação de mecanismos de
segurança no banco de dados.
Visão geral de segurança do PostgreSQL

Apresentar as principais características do Sistema Gerenciador de Banco de Dados PostgreSQL quanto ao seu
sistema de segurança aos dados.
NESTE TÓPICO
CARACTERÍSTICAS DO POSTGRESQL
CARACTERÍSTICAS QUANTO À SEGURANÇA
CONTROLANDO O ACESSO DO USUÁRIO
RECURSOS PARA RECUPERAÇÃO DE DADOS
UTILIZANDO O POSTGRE
Referências
NESTE TÓPICO
Referências
Marcar
tópico
Olá alunos,
Vamos ver um outro tipo de Sistema Gerenciador de Banco de Dados com licença não proprietária: o
PostgreSQL.
É um sistema open source (código aberto), criado na década de 80 pela Universidade de Berkeley (a mesma
universidade onde estudou Steve Jobs), sob a licença BSD (Berkeley Software Distribution), o mesmo tipo de
licença do Unix. Este sistema começou a ganhar popularidade a partir da década de 90 no setor corporativo e
para aplicações baseadas em WEB. A princípio, a sua utilização era simples em sistemas operacionais como
Linux e Unix e um pouco mais trabalhosa no Windows, mas atualmente já não.
É um sistema de gerenciamento simples e robusto e multiplataforma: atua em diversos sistemas operacionais
como Windows (desktop e Server), Linux, Unix e Solaris.
Além de possuir a linguagem SQL, também tem a parte procedural com a possibilidade de criação de
procedimentos armazenados.
Por ser um sistema open source, permite aplicações desenvolvidas por vários tipos de fabricantes como a
Microsoft através das linguagens C# e VB, como a Borland através das linguagens Delphi e C++, como
aplicações WEB através das linguagens PHP, Perl e Python e como a Oracle através da linguagem Java.
Tem a capacidade de suportar uma grande quantidade de transações realizadas em um mesmo instante,
atendendo transações simultâneas de vários usuários realizadas a partir de um desktop.
Para isto, o PostgreSQL utiliza o processo principal: postmaster, que é um processo mestre, é conhecido como
o processo supervisor dos outros processos. As transações dos usuários realizadas a partir do servidor
PostgreSQL são controladas pelo postmaster.
Veja a representação no diagrama abaixo:

O PostgreSQL é semelhante aos outros SGBDs, como o MS Sql Server, quanto a construção do banco de
dados, o superusuário deve entrar com os privilégios, criar o banco de dados, conectar com o banco de dados
criado e criar as tabelas, daí estas tabelas pertencerão a este banco de dados. O Oracle diferencia dos demais,
pois exige a conexão, através de um login, em um esquema para depois criar as tabelas e estas tabelas
pertencerão a este esquema (usuário).
O primeiro aspecto de segurança aos dados é controlar os acessos dos usuários. Não permitir que usuários
acessem objetos da base de dados que não devam. O superusuário (DBA) deverá ter uma senha extremamente
complexa e não deverá ser passada nem para outros usuários mais especialistas, como os desenvolvedores, que
deverão ter outro grupo de privilégios diferente dos usuários comuns.
O PostgreSQL contém recursos para criar usuários e criar papéis (roles): um conjunto de privilégios que
poderão ser passados para grupos de usuários. E o responsável por criar usuários e roles é o Administrador do
Sistema (DBA).
A exemplo do que acontece no Oracle, posso associar uma tabela a um esquema e o PostgreSQL permite
controlar a visualização dos objetos, no caso a tabela deste esquema. É importante o DBA definir quem e como
será realizado o acesso à determinado esquema. O DBA não deverá permitir que o usuário comum possa criar
esquemas ou tabelas no banco de dados, já os desenvolvedores poderão ter privilégios para criar tabelas. Ao
usuário comum só deverá ser permitido acesso aos comandos: SELECT, INSERT, UPDATE e DELETE e o
PostgreSQL possui comandos para proteger o acesso indevido a esquemas e tabelas.
O PostgreSQL permite também criptografar as senhas armazenadas para login.
No processo de autenticação, o PostgreSQL inclui o controle de acesso do sistema operacional servidor, como,
por exemplo, os soquetes de domínio do Unix.
O PostgreSQL executa rotinas de backup através do SQL e também permite a cópia fisicamente através do
sistema operacional.
Nas versões mais atuais, o PostgreSQL possui a técnica Point-In-Time Recovery que permite recuperar o
banco de dados em caso de crash (falha) até um determinado ponto ou até a execução de uma determinada
transação.
O sistema permite que o DBA possa criar tablespaces para organizar os espaços nos discos e assim realizar os
backups em separado, por exemplo, o DBA poderá colocar todas as tabelas do banco de dados do
departamento de vendas em uma tablespace e programar o backup três vezes por dia da tablespace Vendas.
O backup pode ser realizado tirando o banco de dados fora do ar (shutdown) ou sem a necessidade de fazer o
shutdown, com a utilização do SQL Dump, que é o tipo de backup mais recomendado. Como realizar estes
tipos de backup veremos mais adiante.
Outro recurso que é disponibilizado pelo PostgreSQL é a estatística de dados, que permite monitorar a
quantidade de acessos a uma determinada tabela, por exemplo.
O Postgre por ser um SGBD open source, pode ser baixado de forma gratuita pelo link abaixo:
https://www.enterprisedb.com/downloads/postgres-postgresql-downloads
Veja no exemplo da imagem abaixo, que podemos baixar o Postgre para diversas plataformas:
Tem opções para diversas versões do Linux, para o sistema da Apple e no caso, escolhemos o sistema para
Windows 64bits, que poderá ser instalado no Windows 10.
Após o download, vamos instalar o Postgre, no início da instalação será solicitado que se crie uma senha e
confirme. Esta será a senha do super usuário: postgres.
No restante da instalação é só aceitar as configurações padrões ou caso queira, poderá modifica-las.
Vamos utilizar o psql (SQL Shell), que é a interface nativa do Postgre e realizar a conexão:
Username [postgres]: postgres

Senha para usuário postgres:
postgres=#
Na linha 1, note que o username postgres, que é o super usuário, já vem entre colchetes e não há a
necessidade de digitarmos: postgres, bastava pressionar a tecla enter.
Na linha 2, foi solicitado a senha e você deve digitar a senha que você criou no momento da instalação (se
esquecer, terá que instalar o sistema novamente!). Note que por questão de segurança, no momento da
digitação da senha, o cursor não se movimentará e nem mostrará asteriscos.
Veja no vídeo abaixo o exemplo de execução de comando SQL no Postgre:
Lembrando que a linguagem SQL é padronizada, então podemos executar os comandos desta linguagem no
PostgreSQL da mesma forma que executamos nos outros SGBDs.
SAIBA MAIS...
https://www.postgresql.org/docs /
Neste tópico tivemos uma visão dos recursos do PostgreSQL para a implantação de mecanismos de segurança
no banco de dados.
Introdução a linguagem DCL (Data Control

language)
Mostrar os principais comandos da linguagem DCL, uma das categorias da linguagem SQL, para controlar o
acesso aos dados, utilizando o SGBD Oracle.
NESTE TÓPICO
COMANDOS DA CATEGORIA DCL
CRIANDO UM USUÁRIO
ALTERANDO O USUÁRIO
ELIMINANDO UM USUÁRIO
Referências
NESTE TÓPICO
CRIANDO UM USUÁRIO
Referências
Marcar
tópico
Olá alunos,
Agora vamos começar a conhecer os comandos que determinam a permissão de acesso aos dados pelos
usuários, utilizando o Oracle. Iniciando com os comandos para criação de usuários e suas senhas. Esta fase é
extremamente importante para a segurança do sistema de banco de dados e do próprio usuário.
Lembrando que a linguagem SQL é dividida em categorias como a categoria DDL (Data Definition Language)
com os comandos:
 CREATE
 ALTER
 TRUNCATE
 DROP
A categoria DML (Data Manipulation Language), com os comandos:
 INSERT
 UPDATE
 DELETE
A categoria DTL (Data Tansaction Language com os comandos:
 COMMIT
 ROLLBACK
A categoria DCL (Data Control Language) com os comandos:
 GRANT
 REVOKE
E o comando da categoria DQL (Data Query Language) mais utilizado em banco de dados: SELECT.
Os comandos que mais trabalharemos a partir de agora, são os comandos da categoria DCL: os
comandos GRANT e REVOKE.
Com estes comandos poderemos definir o nível de acesso aos dados pelo usuário. Por exemplo, no mundo
corporativo, o acesso do usuário vai depender do cargo ou função dele na empresa. O Gerente de Vendas terá
privilégios diferentes do Assistente de Vendas ou de um estagiário.
Portanto, para concedermos privilégios aos usuários, utilizamos o comando; GRANT e para tirarmos
privilégios concedidos aos usuários, utilizamos o comando: REVOKE.
Mas, antes de iniciarmos a concessão de privilégios aos usuários, primeiramente devemos é criar o usuário.
CRIANDO UM USUÁRIO
Vamos ver o conceito de usuário:
“Pessoa previamente cadastrada e autorizada para acessar o Oracle.”
É necessário que o usuário faça um login para a autenticação, através de um nome e senha. O usuário pode ser
autenticado através de três métodos diferentes: pela rede, pelo sistema operacional e/ou pelo banco de dados.
Lembrando que no caso de um ambiente Microsoft, é aconselhável a autenticação somente através do sistema
operacional Windows Server.
O usuário só pode ser criado por um DBA ou por um outro usuário com privilégios para criação de usuários.
Para criarmos um usuário é necessário utilizarmos o comando: CREATE, o mesmo comando que utilizamos
para criar tabela, view, procedure, function, trigger, etc. Toda vez que utilizamos o comando CREATE,
estamos na realidade, criando, internamente, um objeto no banco de dados.
A sintaxe básica do comando para a criação de um usuário é:
CREATE USER nome_usuario IDENTIFIED BY senha;
Lembrando que para criarmos o nome do usuário, não utilizar espaço em branco, acentuação gráfica, cedilha,
etc.
Esta é a sintaxe básica do comando, com as cláusulas obrigatórias para criarmos um usuário, mas poderemos
também utilizar alguns parâmetros (comandos) opcionais, como por exemplo:
CREATE USER nome_usuario IDENTIFIED BY senha PASSWORD EXPIRE;
Neste exemplo, o comando PASSWORD EXPIRE, a senha é expirada imediatamente após o primeiro login do
usuário, obrigando o usuário a criar uma nova senha no momento da primeira conexão. Por exemplo,
poderíamos criar os usuários com uma senha padrão e no momento em que realizassem o seu primeiro login,
os usuários criariam a sua própria senha, o que é mais aconselhável, pois daria mais segurança ao próprio
usuário e ao Administrador do Sistema.
Vamos ver outro exemplo, utilizando outro parâmetro:
CREATE USER nome_usuario IDENTIFIED BY senha ACCOUNT LOCK PASSWORD EXPIRE;
Neste caso, utilizamos o comando: ACCOUNT LOCK para bloquearmos o login do usuário, se não
utilizarmos este comando, o default (padrão) é ACCOUNT UNLOCK (conta desbloqueada). Isto poderá ser
necessário se, por exemplo, pretendemos criar vários usuários e por segurança, não queremos que o usuário já
faça o login, sem antes terminarmos de criar todos os usuários. Depois, então poderemos mudar o status da
conta do usuário, aplicando o comando de alteração que veremos a seguir.
Após criar o usuário poderemos verificar se o usuário foi criado ou os usuários que já foram criados, com os
seguintes comandos:
SELECT * FROM ALL_USERS;
OU
SELECT USERNAME FROM DBA_USERS;
Como acontece com as tabelas depois de criadas, onde poderemos realizar manutenções com o comando
ALTER TABLE, com os usuários é o mesmo tipo de comando:
ALTER USER nome_usuario comandos;
Exemplo:
ALTER USER nome_usuario ACCOUNT UNLOCK;
Neste exemplo, desbloqueamos a conta do usuário. Em alguns casos, é um procedimento necessário, pois o
login de um usuário pode ficar bloqueado por algum motivo e este comando desbloqueará o login do usuário.
Vamos a outro exemplo:
ALTER USER nome_usuario IDENTIFIED BY senha;
Agora, utilizamos o comando ALTER USER para mudar a senha de algum usuário.
Estes são alguns exemplos de como utilizar o comando ALTER USER para realizarmos manutenções no login
do usuário, mais adiante vamos usar este comando em outras situações.
No Oracle, ao conectarmos com um login de um usuário e depois criamos uma ou mais tabelas, estas tabelas
vão fazer parte do esquema, que é o mesmo nome do usuário, ou seja, o esquema do Oracle está diretamente
relacionado com um usuário. Portanto, todos os objetos (tabelas, views) que o usuário criar, pertencerão a este
usuário, que se torna o proprietário (owner) dos objetos.
Para eliminarmos um usuário, utilizaremos o comando DROP, que é o mesmo comando utilizado para
eliminarmos outros tipos de objetos do banco de dados. O comando DROP é o contrário do comando
CREATE, com CREATE nós criamos e como DROP nós eliminamos.
A sintaxe para eliminarmos um usuário é:
DROP USER nome_usuario;
Porém, se este usuário já havia criado pelo menos uma tabela com o seu login, o comando acima não será
executado, ou seja, o usuário não será eliminado. Mas, se realmente é necessário eliminar o usuário com seus
objetos, teremos que utilizar o seguinte comando:
DROP USER nome_usuario CASCADE;
Agora acrescentando a cláusula CASCADE, eliminamos o usuário e também todos os objetos pertencentes a
este usuário, em efeito “cascata”. Se este usuário possuir uma tabela com milhares de registros, esta será
eliminada também.
Vamos realizar alguns exercícios para praticar:
1. Conectar com o Banco de dados como system:
SQL> conn system

Informe a senha:
Conectado.
2. Criar um novo usuário com o seu nome e uma senha:
SQL> CREATE USER seu_nome IDENTIFIED BY 123;
Usußrio criado.
3. Listar os usuários criados:
SQL> SELECT USERNAME FROM DBA_USERS;
USERNAME
------------------------------
SEU_NOME
SYS
SYSTEM
ANONYMOUS
APEX_PUBLIC_USER
. FLOWS_FILES
. APEX_040000
. OUTLN
. DIP
4. Alterar a senha para abc:
SQL> ALTER USER seu_nome IDENTIFIED BY abc;
Usußrio alterado.
5. Eliminar o usuário criado:
SQL> DROP USER seu_nome CASCADE;
Usußrio eliminado.
Lembrando que para a excução dos comandos acima, é necessário entrarmos como o usuário system, o
superusuário.
Veja no vídeo abaixo, um exemplo da criação de usuário:
Neste tópico vimos como utilizar os comandos: CREATE USER para criar usuários e suas senhas e comandos
para fazer manutenção nos usuários com o comando ALTER USER e DROP USER.
Aplicação de mecanismos de segurança com a

criação de usuários com privilégios de sistema
Apresentar os comandos da linguagem DCL para determinar o acesso dos usuários aos recursos do SGBD.
NESTE TÓPICO
NESTE TÓPICO
COMANDOS GRANT E REVOKE
Referências
Marcar
tópico
Olá alunos,
Depois de criarmos o usuário, é necessário conceder privilégios para que possa utilizar os recursos do sistema,
mas o que é o privilégio:
“Autorização para que o usuário acesse e manipule um objeto do banco de dados.”
Exemplo: um usuário pode ter o privilégio de selecionar dados de tabelas, porém não pode modifica-los.
Existem dois tipos de privilégios que podem ser passados aos usuários:
 PRIVILÉGIO DE SISTEMA.
 PRIVILÉGIO DE OBJETO.
Vamos ver primeiramente os privilégios de sistema no SGBD Oracle.
É a permissão de executar determinada ação em objetos de banco de dados. Existem vários tipos de privilégios
associados a ações de banco de dados. O nome do privilégio é praticamente o nome da ação que ele executa.
Exemplos de privilégios de sistema: CONNECT, RESOURCE, CREATE USER.
No exemplo do privilegio tipo RESOURCE é representado um grupo de ações que envolvem os
comandos: CREATE TABLE, CREATE PROCEDURE, CREATE TRIGGER.
COMANDOS GRANT E REVOKE
Para concedermos privilégios aos usuários utilizamos o comando: GRANT e para realizarmos o contrário,
para retiramos os privilégios dos usuários, utilizamos o comando: REVOKE.
A sintaxe do comando GRANT:
GRANT privilegio1, privilegio2, ..... TO nome_usuario opções;
Após o comando GRANT, descrevemos o nome do privilégio ou dos privilégios a serem concedidos. A
cláusula TO determina para qual usuário será passado o privilégio e o nome do usuário, esta é a sintaxe básica
para concedermos privilégios. As opções são comandos que poderemos utilizar, se necessário.
No Oracle, depois de criarmos um usuário, com o nome e a senha, precisamos conceder o privilégio de
sistema: CONNECT, senão o usuário mesmo com um nome e uma senha definido, não conseguirá se conectar
com o banco de dados.
Exemplo:
SQL> CREATE USER teste IDENTIFIED BY 123;
Usußrio criado.
SQL> CONNECT teste/123

ERROR:
ORA-01045: user TESTE lacks CREATE SESSION privilege; logon denied
AdvertÛncia: VocÛ nÒo estß mais conectado ao ORACLE.
Criamos o usuário teste com a senha 123 e depois o usuário teste tentou fazer a conexão e o Oracle retornou o
erro, não realizando a conexão.
SQL> conn system

Informe a senha:
Conectado.
SQL> GRANT CONNECT TO teste;
ConcessÒo bem-sucedida.
SQL> CONNECT teste/123

Conectado.
Agora, entramos de novo como system, o super usuário e concedemos a permissão de conexão ao
usuário teste. E o usuário teste pôde realizar a conexão com o banco de dados.
Continuando, o usuário teste tentará criar uma tabela:
SQL> CREATE TABLE tabela1 (nome VARCHAR(10));

CREATE TABLE tabela1 (nome VARCHAR(10))
*
ERRO na linha 1:
ORA-01031: privilÚgios insuficientes
O usuário teste tentou criar uma tabela e o Oracle retornou a mensagem que usuário não tem privilégio para
criar tabelas.
Vamos resolver isto:
SQL> CONN system

Informe a senha:
Conectado.
SQL> GRANT RESOURCE TO teste;
SQL> CONN teste/123

Conectado.
. SQL> CREATE TABLE tabela1 (nome VARCHAR(10));
.
. Tabela criada.
Entramos como system e concedemos o privilégio de sistema: RESOURCE para o usuário teste.
O usuário teste se conectou e agora conseguiu criar a tabela.
A partir de agora, o usuário teste é proprietário do objeto tipo tabela e poderá realizar qualquer comando do
SQL nesta tabela como: ALTER TABLE, DROP TABLE, TRUNCATE TABLE, INSERT, UPDATE,
DELETE e SELECT.
Vamos continuar o exemplo, retirando o privilégio de criar tabelas:
SQL> CONN system

Informe a senha:
Conectado.
SQL> REVOKE RESOURCE FROM teste;
RevogaþÒo bem-sucedida.
SQL> CONN teste/123

Conectado.
. SQL> CREATE TABLE tabela2 (codigo NUMBER(3));
. CREATE TABLE tabela2 (codigo NUMBER(3))
.*
. ERRO na linha 1:
. ORA-01950: nÒo hß privilÚgios no tablespace SYSTEM'
Entramos como system e retiramos o privilégio RESOURCE do usuário teste com o comando REVOKE. Na
sintaxe do comando REVOKE, descrevemos o nome do privilégio a ser retirado e agora utilizamos a
cláusula FROM (em vez de TO) e o nome do usuário.
Depois, o usuário teste fez a conexão, mas não conseguiu criar a tabela.
Vamos realizar um exercício:
1. Criar um novo usuário com o seu nome e uma senha:
SQL> CONN system

Informe a senha:
Conectado.
SQL> CREATE USER seu_nome IDENTIFIED BY 123;
Usußrio criado.
2. Conceder os privilégios de conexão e de criação de objetos ao novo usuário:
SQL> GRANT CONNECT, RESOURCE TO seu_nome;
3. Conecte com o novo usuário e crie uma tabela:
SQL> CONN seu_nome/123

Conectado.
SQL> CREATE TABLE teste (codigo NUMBER(3));
Tabela criada.
4. Insira um registro na tabela criada:
SQL> INSERT INTO teste VALUES(43);

1 linha criada.
SQL> SELECT * FROM teste;
CODIGO
----------
43
5. Entre como system e retire o privilégio de criação de objetos:
SQL> CONN system

Informe a senha:
Conectado.
SQL> REVOKE RESOURCE FROM seu_nome;
RevogaþÒo bem-sucedida.
6. Elimine o usuário criado:
SQL> DROP USER seu_nome CASCADE;

Usußrio eliminado.
Veja no vídeo abaixo, a concessão de privilégios de sistemas para um usuário:

Neste tópico vimos como utilizar os comandos da categoria DCL: GRANT e REVOKE para conceder e retirar
privilégios de sistemas aos usuários.
Aplicação de mecanismos de segurança para

conceder privilégios de objetos aos usuários
Apresentar os comandos da linguagem DCL para determinar o tipo de acesso dos usuários aos objetos do
Banco de Dados.
NESTE TÓPICO
NESTE TÓPICO
PAPEL (ROLE)
CRIAR UM NOVO PAPEL (ROLE)
Referências
Marcar
tópico
Olá alunos,
Depois de criarmos o usuário e passar os privilégios de sistema aos usuários, também podemos passar
privilégios sobre os objetos do Banco de Dados.
Quando concedemos o privilégio para a criação de tabelas, o usuário ao criar uma tabela vai ser o proprietário
ou owner desta tabela, a partir daí, ele poderá realizar os comandos do SQL, como os da categoria DDL:
CREATE, ALTER, TRUNCATE e DROP e também os da categoria DML: INSERT, UPDATE, DELETE e
SELECT. Ou seja, o usuário ao criar uma tabela, ele poderá realizar todas as ações nesta tabela, como alterar a
estrutura da tabela e cadastrar, modificar e acessar os dados desta tabela.
Nenhum outro usuário poderá acessar esta tabela, a não ser que o proprietário da tabela dê autorização.
Somente o usuário proprietário da tabela e o DBA poderão conceder permissão de acesso aos outros usuários.
Este tipo de concessão é conhecido como privilégio de objeto.
O privilégio é a permissão a um usuário de executar uma determinada ação em um objeto em que ele não é o
proprietário, por exemplo, o direito de incluir uma linha em uma tabela.
Os tipos de objetos que podem receber os privilégios:
Tabelas, Views, Sequences, Procedures, Triggers.
Alguns tipos de privilégios de objeto:
PRIVILÉGIO DESCRIÇÃO
SELECT Seleciona dados de uma tabela ou de uma view.
INSERT Insere linhas em uma tabela ou através de uma view.
DELETE Exclui linhas de uma tabela ou através de uma view.
UPDATE Atualiza linhas de uma tabela.
ALTER Altera a estrutura de uma tabela.
ALL Concede todos os privilégios acima.
A sintaxe para conceder privilégios de objeto:

GRANT nomePrivilegio ON nomeTabela TO nomeUsuario;
Note que agora temos que incluir o nome do objeto, por exemplo uma tabela, depois da cláusula ON.
Para conceder todos os privilégios sobre um objeto a um usuário:
GRANT ALL ON nomeTabela TO nomeUsuario;
Com a cláusula ALL, passamos todos os privilégios que dará direito ao usuário de executar os comandos SQL
no objeto.
Para conceder direito a um usuário que poderá dar privilégios a outros usuários:
GRANT ALL ON nomeTabela TO nomeUsuario WITH GRANT OPTION;
Com a cláusula WITH GRANT OPTION, damos permissão ao usuário para que ele possa passar privilégios
do objeto para outros usuários.
Conceder privilégios para todos os usuários:
GRANT ALL ON nomeTabela TO PUBLIC;
É possível também restringir o privilégio nos campos da tabela:
GRANT COMANDO(campo1,campo2) ON Esquema.Tabela TO Usuário;
Como os usuários irão acessar tabelas que não lhe pertencem, será necessário também indicar o nome do
esquema (usuário) no qual a tabela pertence, fazendo a referência com um ponto, sempre obedecendo a
hierárquia: nome_usuario.nome_tabela.nome_campo.
PAPEL (ROLE)
São grupos de privilégios que podem incluir, tanto privilégios de sistema quanto de objetos.
A utilização de papéis facilita a administração dos privilégios concedidos aos usuários do banco de dados,
pois, em vez de conceder diversos privilégios individualmente aos usuários, é possível concedê-los a um papel
e este, por sua vez, ser concedido aos usuários.
Caso seja necessária alguma alteração, esta poderá ser feita no papel e os privilégios de todos os usuários que
utilizam este papel serão automaticamente alterados.
Geralmente o DBA pode criar papéis de acordo com os cargos de uma empresa, como por exemplo, criar um
role para o cargo assistente de vendas, assim todos os assistentes de vendas terão o mesmo tipo de acesso e de
ações.
Lembrando que já existem papeis (roles) pré-definidos pelo Oracle:
 CONNECT : Conexão com um esquema.
 RESOURCE : CREATE em vários objetos: tabelas, procedures, triggers.
 DBA: Todos os privilégios.
CRIAR UM NOVO PAPEL (ROLE)

Sintaxe para criar um ROLE:
CREATE ROLE nomeRole;
CONCEDER PRIVILÉGIOS E PAPÉIS A UM PAPEL(ROLE):
Um papel pode receber privilégios que podem ser específicos ou de outros papéis.
GRANT nomePapel TO nomeRole;
CONCEDER UM PAPEL (ROLE) A UM USUÁRIO:
GRANT nomeRole TO nomeUsuario;
Exemplo:
CREATE ROLE Teste;
GRANT SELECT, INSERT ON FUNCIONARIO TO Teste;
GRANT Teste TO Usuario;
Dar privilegio de consultar qualquer tabela em qualquer esquema (usuário):
GRANT SELECT ANY TABLE TO nomeUsuario;
Dar privilegio de alterar qualquer tabela em qualquer esquema (usuário):
GRANT ALTER ANY TABLE TO nomeUsuario;
Neste caso, estes dois tipos de privilégios são considerados privilégios de sistema.
REVOGAR UM PRIVILÉGIO DE SISTEMA OU PAPEL CONCEDIDO:
REVOKE nomePapel FROM nomeUsuario;
REVOGAR UM PRIVILÉGIO DE OBJETO DE UM USUÁRIO:
REVOKE nomePrivilegio ON nomeTabela FROM nomeUsuario;
EXCLUIR UM PAPEL:
DROP ROLE nomeRole;
Vamos praticar com um exemplo, considerando o departamento do RH:
1 – Como Administrador do sistema crie um schema RH com a senha rh e conceda permissão para criar tabelas
e para a criação de objetos:
SQL> conn system

Informe a senha:
Conectado.
SQL> CREATE USER RH IDENTIFIED BY rh;
UsuÃ¿Â¿rio criado.
SQL> GRANT CONNECT, RESOURCE TO RH;
. ConcessÃ¿Â¿o bem-sucedida.
2 - Conecte-se como RH, crie uma tabela Funcionário com os campos: id, nome e salário:
SQL> conn RH/rh

Conectado.
SQL> CREATE TABLE Funcionario (
2 id NUMBER(3), nome VARCHAR(30), salario NUMBER(7,2));
Tabela criada.
3 – Agora como Administrador do Sistema, crie um usuário (gerente do RH) com seu nome e senha. Conceda
permissão para conexão. Conceda todos os privilégios sobre a tabela Funcionário, com direito a conceder
privilégios aos outros usuários:
SQL> conn system

Informe a senha:
Conectado.
SQL> CREATE USER seu_nome IDENTIFIED BY senha;
Usußrio criado.
SQL> GRANT CONNECT TO seu_nome;
. ConcessÒo bem-sucedida.
.
. SQL> GRANT ALL ON RH.Funcionario TO seu_nome WITH GRANT OPTION;
.
. ConcessÒo bem-sucedida.
4 – Ainda como Administrador do Sistema, crie um papel chamado assistente_RH:
SQL> CREATE ROLE assistente_RH;
AtribuiþÒo criada.
5 - Conceda os privilégios para o papel assistente_RH, de consulta e alteração de registros na tabela

Funcionário, menos para o campo salário:
SQL> GRANT SELECT, UPDATE (id, nome) ON RH.Funcionario TO assistente_RH;
ConcessÃ¿o bem-sucedida.
A partir de agora, qualquer funcionário admitido como Assistente de RH terá a permissão para realizar
consultas e alterações na tabela Funcionário, menos para o campo salário, ou seja, o assistente de RH poderá
acessar os dados de todos os funcionários para consulta ou atualizações, menos para o campo salário.
Veja no vídeo abaixo, a concessão de privilégios de objeto para um usuário:
Neste tópico vimos como utilizar os comandos da categoria DCL: GRANT e REVOKE para conceder e retirar
privilégios de objetos aos usuários ou para papéis (roles).
Aplicação da segurança no controle de

bloqueios das transações
Apresentar os principais comandos para controle de locks (bloqueios) do sistema da Oracle.
NESTE TÓPICO
NESTE TÓPICO
LOCK DE LINHA
LOCK DE TABELA
DEAD LOCK (IMPASSE)
BLOQUEIO EXPLÍCITO
BLOQUEIO IMPLÍCITO
MONITORANDO E CONTROLANDO BLOQUEIOS (LOCKS)
Referências
Marcar
tópico
Olá alunos,
Como os sistemas atuais são multiusuários, tanto os Sistemas Operacionais para servidor quanto os SGBDs,
um grande problema a ser resolvido é a questão da concorrência entre os usuários quando acessam arquivos ou
no nosso caso, o banco de dados, isto é, os mesmos dados de uma tabela podem ser acessados e até mesmo
atualizados por vários usuários ao mesmo tempo.
Para evitar travamentos do sistema durante a interação entre essas transações, a grande maioria dos SGBDs
disponíveis no mercado possuem algum mecanismo de controle de lock (bloqueio).
A ideia básica atrás desse processo é que quando um usuário modifica um dado em uma tabela através de uma
transação, esse dado permanecerá bloqueado, ou seja, o sistema coloca um bloqueio exclusivo nesta transação,
até que esta transação seja efetivada pelo comando COMMIT ou desfeita com ROLLBACK, caso contrário,
nenhum outro usuário conseguirá realizar transações nesta tabela.
O mecanismo de lock presente no Oracle é um dos melhores e mais eficientes entre os SGBDs existentes no
mercado, como o da Microsoft (MS SQL Server) e o da IBM (DB2).
Nos dois SGBDs, o da Microsoft e o da IBM, os controles de locks são realizados pelo lock manager e no
sistema da Oracle, isto é diferente: esse controle é realizado onde os dados foram bloqueados.
O Oracle faz todo o gerenciamento de locks utilizando dois níveis (level): Lock de linha e Lock de tabela.
LOCK DE LINHA
Um bloqueio do tipo de linha é diretamente aplicado às linhas de uma tabela de forma exclusiva. Quando uma
linha está bloqueada, nenhuma outra sessão (session) conseguirá modifica-la até que a transação que detém o
lock chegue ao fim (com COMMIT ou ROLLBACK).
Neste caso, se uma determinada linha de uma tabela estiver bloqueada por uma determinada transação, outros
comandos como: SELECT, UPDATE ou DELETE, poderão ser realizadas em outros registros desta tabela,
desde que também não estejam bloqueadas. Por exemplo, se o usuário alterou o preço de um produto e não
finalizou a transação com um COMMIT, esta linha ou registro deste produto ficará bloqueada e outro usuário
(sessão) não poderá modificar este produto, mas poderá alterar outros produtos da tabela.
LOCK DE TABELA
Esse tipo de bloqueio é realizado em nível de tabela.
É aplicado quando a transação faz uma atualização em todas as linhas da tabela.
O Oracle bloqueia esta tabela e não permitirá alterações de outros usuários. Por exemplo: se agora um usuário
faz um reajuste de preço em todos os produtos da tabela e não finalizar esta transação, a tabela toda estará
bloqueada e os outros usuários não poderão realizar alterações nesta tabela.
A consulta (SELECT) pode ser realizada, pois o comando SELECT não causa instância, não muda o estado da
tabela como os comandos INSERT, UPDATE e DELETE.
DEAD LOCK (IMPASSE)
Quando dois ou mais usuários estão esperando por acesso a dados que um usuário obteve em bloqueio
exclusivo é conhecido como um dead lock ou impasse.
Quando ocorre este conflito, as transações deixam de ir em frente, pois elas ficam presas.
Nestes casos, os SGBD quebram o impasse, forçando uma ou mais transações a serem desfeitas.
Se o bloqueio padrão dos SGBD são substituídos em qualquer nível, o administrador de banco de dados ou o
desenvolvedor do aplicativo deve garantir que os procedimentos de bloqueio devam funcionar corretamente,
dando garantia da integridade e simultaneidade dos dados.
BLOQUEIO EXPLÍCITO
Realizado pelo próprio administrador quando quer fazer uma manutenção em algum objeto do banco de dados
e é feito por meio do comando lock table.
BLOQUEIO IMPLÍCITO
Realizado internamente pelo próprio sistema gerenciador de banco de dados quando emitimos um comando
DML: INSERT, UPDATE ou DELETE. Este bloqueio somente é liberado quando é emitido um comando com
a efetivação da sessão (commit) ou caso ela não tenha ocorrido com sucesso (rollback).
Uma vez identificados às respectivas sessões, deve-se tomar medidas para eliminar o impasse (dead lock) por
meio da remoção das sessões que estão sendo prejudicadas.
MONITORANDO E CONTROLANDO BLOQUEIOS
(LOCKS)
Para monitorar os bloqueios podemos utilizar a view: V$LOCK ou também a view: V$SESSION.
Em V$SESSION temos vários parâmetros e podemos observar alguns como: SID (id da sessão do
usuário), SERIAL# (serial number: número da sessão), PROGRAM (nome do programa que está sendo
executado), USERNAME (login), STATUS, BLOCKING_SESSION (sid da sessão que está bloqueando).
Podemos realizar uma consulta para saber qual usuário está causando o bloqueio, impedindo a ação dos outros
usuários:
SELECT sid, username FROM V$SESSION WHERE sid IN (SELECT blocking_session FROM
V$SESSION);
O SELECT que está entre parêntesis será realizado em primeiro lugar, retornando para o SELECT externo o
número do SID do usuário que está bloqueando os outros usuários e o SELECT externo também mostrará o
nome do usuário.
Podemos também verificar qual usuário ou usuários estão aguardando a finalização da transação que causou o
bloqueio, com o seguinte comando:
SELECT sid, username, blocking_session FROM V$SESSION WHERE blocking_session IS NOT
NULL;
Esta consulta traz o SID, o nome do usuário que está aguardando a finalização da transação bloqueada e o SID
do usuário que está causando o bloqueio.
Podemos encerrar (matar) manualmente uma sessão que está causando dead lock com o comando KILL, com a
sintaxe:
ALTER SYSTEM KILL SESSION ‘SID, SERIAL#’ IMMEDIATE;
Só que para realizarmos este comando, precisamos saber os números do SID e do SERIAL, então teremos que
realizar a seguinte consulta para apanharmos estes números:
SELECT sid, serial# FROM V$SESSION WHERE username = ‘NOME_LOGIN’;
Vamos realizar um exercício como exemplo:
1 – Abra uma sessão (janela) no SQL PLUS, entre como system e crie um usuário com o nome bill e a
senha bill:
SQL> CONN system

Informe a senha:
Conectado.
SQL> CREATE USER bill IDENTIFIED BY bill;
Usußrio criado.
2 – Crie um segundo usuário com o nome ada e a senha ada:
SQL> CREATE USER ada IDENTIFIED BY ada:
Usußrio criado.
3 – Conceda privilégios para conexão e criação de tabelas para os dois usuários:
SQL> GRANT CONNECT, RESOURCE TO bill, ada;
4 – Deixe aberta a janela da sessão do system e abra outra janela no SQL PLUS, conectando-se como
usuário bill, crie a tabela Produto, insira dois registros e confirme as transações com o comando COMMIT:
SQL> CONN bill/bill;

Conectado.
SQL> CREATE TABLE Produto
2 (id NUMBER(3) PRIMARY KEY,
3 preco NUMBER(7,2));
Tabela criada.
SQL> INSERT INTO Produto VALUES(1,220);

.
. 1 linha criada.
.
. SQL> INSERT INTO Produto VALUES(2,330);
.
. 1 linha criada.
.
. SQL> COMMIT;
.
. Commit concluÝdo.
5 – Ainda como bill, conceda permissão ao usuário ada para selecionar e atualizar a tabela Produto:
SQL> GRANT SELECT, UPDATE ON Produto TO ada;
6 – Ainda como bill, atualize o preço do produto do id 1 para 440, não dê COMMIT:
SQL> UPDATE Produto SET preco = 440 WHERE id = 1;
1 linha atualizada.
7 – Deixe aberta também a janela da sessão do bill e abra uma outra janela (sessão) no SQL PLUS,
conectando-se como usuário ada e atualize o preço para 550 no mesmo produto com id 1. Observe o que
aconteceu:
SQL> CONN ada/ada

Conectado.
SQL> UPDATE bill.Produto SET preco = 550 WHERE id = 1;
Neste caso, ocorreu um impasse com um bloqueio (lock) de linha porque o usuário bill não confirmou a
transação com o comando COMMIT.
Pode-se resolver o impasse, neste caso, de duas formas:
1. O usuário bill realiza o comando COMMIT.
2. O DBA encerra a sessão do usuário bill que está causando o impasse e libera os recursos.
8 – Como DBA, volte para a sessão do usuário system e verifique qual é a sessão do usuário que está
bloqueando outros usuários:
SQL> SELECT sid, username FROM V$SESSION WHERE sid IN (SELECT blocking_session FROM V$SESSION);
SID USERNAME
---------- ------------------------------
96 BILL
Este é o usuário que está causando o impasse.

9 – Ainda como system vamos verificar quais são os usuários que estão aguardando commit de outra sessão:
SQL> SELECT sid, username, blocking_session FROM V$SESSION WHERE blocking_session IS NOT NULL;
SID USERNAME BLOCKING_SESSION

---------- ------------------------------ ----------------
138 ADA 96
Este é o usuário que está aguardando a resolução do impasse.

10 – Ainda como system, para podermos encerrar a sessão, em primeiro lugar, vamos identificar o SID e o
SERIAL# da sessão que está causando o impasse:
SQL> SELECT sid, serial# FROM V$SESSION WHERE username = 'BILL';
SID SERIAL#
---------- ----------
96 375
Agora descobrimos os números do SID e do SERIAL determinados pelo Oracle.

11 – Agora vamos encerrar a sessão do usuário bill através do comando KILL do Oracle, colocando os
números do SID e do SERIAL identificados na consulta anterior:
SQL> ALTER SYSTEM KILL SESSION '96, 375' IMMEDIATE;

Sistema alterado.
Onde o número 96 é SID é o número 375 é o SERIAL# são os números que foram identificados pelo
comando anterior. Estes números são gerados internamente pelo Oracle e vão diferenciar dos números do seu
ambiente.
12 – Voltar para a janela do usuário ada e verifique o que aconteceu:
SQL> UPDATE bill.Produto SET preco = 550 WHERE id = 1;
1 linha atualizada.
Após você como Administrador do Sistema ter encerrado a sessão do usuário bill, o update do usuário bill não
foi realizado. Vá para a sessão do usuário bill e tente fazer uma consulta na tabela Produto:
SQL> SELECT * FROM Produto;

SELECT * FROM Produto
*
ERRO na linha 1:
ORA-03113: fim de arquivo no canal de comunicaþÒo
ID do Processo: 15900
ID da SessÒo: 96 N·mero de sÚrie: 375
Como a sessão do usuário bill foi encerrada pelo DBA, o usuário bill deverá se conectar novamente.
13 – Conecte-se novamente como bill e faça de novo a consulta:
SQL> CONN bill/bill

Conectado.
ID PRECO
---------- ----------
1 220
2 330
Note que o preço do produto de id 1, não foi alterado.
14 – Agora, volte para a sessão ada e realize um COMMIT e faça a consulta novamente:
SQL> COMMIT;
Commit concluÝdo.
SQL> SELECT * FROM bill.Produto;
ID PRECO
---------- ----------
1 550
. 2 330
15 – E realizando novamente a consulta como usuário bill:
ID PRECO
---------- ----------
1 550
2 330
Depois que o usuário ada realizou o commit, o preço do produto de id 1 foi atualizado.
Veja no vídeo abaixo a execução do exemplo acima:
Neste tópico verificamos como podem ocorrer bloqueios em transações de banco de dados e como um
administrador de banco de dados pode resolver estes impasses.
Criação de políticas de backup e de recuperação

(restore) do banco de dados
Apresentar os principais processos dos sistemas para estabelecer backups e recuperação do banco de dados em
caso de falhas.
NESTE TÓPICO
ARQUITETURA BÁSICA DO ORACLE
ARQUIVOS DE DADOS (DATA FILES)
OS ARQUIVOS DE CONTROLE (CONTROL FILES)
ARQUIVOS DE REDO (REDO LOG FILES)
BACKUP
BACKUP LÓGICO (EXPORTAÇÃO/IMPORTAÇÃO)
BACKUP FÍSICO
Referências
NESTE TÓPICO

BACKUP
BACKUP FÍSICO
Referências
Marcar
tópico
Olá alunos,
Vamos ver agora algo muito importante para a segurança, o backup ou cópias de segurança dos dados. Imagine
se você ligasse o seu computador e seus arquivos foram perdidos ou estão inacessíveis e você não tem backup
deles!
Agora, imagine uma empresa perdendo seu banco de dados. Praticamente, hoje o banco de dados é a vida da
empresa, então, o processo de backup é de extrema importância e deve ser uma rotina frequente no mundo
corporativo para assegurar o banco de dados em caso de crashes (falhas).
O Oracle, bem como os outros SGBDs possuem recursos para executar backups, assim como os SO (Sistemas
Operacionais). E é o que vamos ver agora.
O Oracle é composto de duas partes básicas:
 Banco de Dados (Database), que fica no Disco (HD)
 Instância (Instance), que fica na Memória Principal (RAM)
O Banco de Dados representa os arquivos físicos que armazenam os dados.
A Instância é composta pelas estruturas de memória que no Oracle é chamado de SGA (System Global
Area) e pelos processos de segundo plano (background). Lembrando que todo o processo e execução de
comandos acontecem a partir da memória principal.
Os processos de segundo plano (background) do Oracle monitoram todas as transações realizadas no banco de
dados.
Mas, como a memória principal é uma memória temporária e volátil, o Oracle tem que registrar as ações no
disco, além de armazenar os dados e o dicionário de dados do banco.
Um banco de dados Oracle consiste em três tipos de arquivos que formam sua estrutura física, no disco:
São os arquivos que guardam os dados que são cadastrados pelo usuário, assim como o dicionário de dados
(uma tabela, por exemplo) com a estrutura do banco. Um banco de dados contém pelo menos um arquivo de
dados, com as seguintes características:
 É associado a apenas um banco de dados e seus arquivos possuem as extensão .dbf (data
base file)
 Podem ser configurados para ter crescimento automático quando o banco ficar sem espaço e
o limite será o espaço em Disco.
 Um ou mais arquivo de dados, formam uma tablespace (espaço da tabela).
Ao criarmos uma tabela, automaticamente esta tabela pertencerá a uma tablespace e fará parte do dicionário de
dados.
A tablespace permite que possamos organizar o nosso banco de dados. Por exemplo, podemos criar uma
tablespace com o nome RH e todas as tabelas (Funcionário, Departamento, Projeto, etc) pertencerão a esta
tablespace. Assim, se houver a necessidade de tirar um backup somente do banco de dados do RH, basta copiar
os arquivos que estão na tablespace RH.
Arquivos que contêm as informações necessárias para manter e verificar a integridade do banco de dados. Ele
é usado para identificar os arquivos de dados e de redo log. É como se fosse um índice de um livro, contém os
endereços de todos os arquivos de dados (Data File) e dos arquivos de recuperação (Redo Log File)
São arquivos que contêm registro das alterações efetuadas no banco de dados, para ativar a recuperação dos
dados, se houver falhas. Todos os comandos SQL iniciados pelos usuários são registrados neste arquivo, até a
finalização das transações.
Exemplo: se o usuário executa um comando UPDATE, o início desta transação é registrada no REDO LOG
FILE e quando esta transação for finalizada, com o comando COMMIT, esta informação também será
registrada no REDO LOG FILE.
Agora, vamos supor que algum tipo de crash (falha) ocorreu durante a execução da transação do UPDATE e
esta não foi finalizada.
Quando ocorre qualquer tipo de crash, após a solução do problema, o sistema será reiniciado e, em tempo de
boot, o Oracle vai abrir os arquivos do CONTROL FILE e buscar os registros dos status das transações
no REDO LOG FILE para saber qual era a situação das transações no momento em que ocorreu o crash.
No nosso exemplo, se o UPDATE teve o registro de início, mas não tem o registro de finalização no REDO
LOG FILE, o Oracle vai desfazer a transação, ou seja, o banco de dados vai voltar para o estado em que o
banco estava antes da realização do UPDATE, o usuário terá que realizar novamente a transação.
Veja a representação abaixo:
Os arquivos que ficam no disco: CONTROL FILE, REDO LOG FILE e principalmente os DATA
FILES são os arquivos físicos e podem ser facilmente copiados em uma operação de backup.
Além destes arquivos, o Oracle armazena também as configurações realizadas pelos administradores do
sistema no arquivo PARAMETER FILE e um arquivo que armazena as senhas dos usuários para autenticação
que é o PASSWORD FILE. Também mantém cópias dos arquivos do REDO LOG FILE, em um arquivo
chamado: ARCHIVED REDO LOG.
Em todos estes arquivos: DATA FILE, CONTROL FILE, REDO LOG FILE, PARAMETER FILE,
PASSWORD FILE e ARCHIVED REDO LOG poderão ser realizados backups.
BACKUP
Com o recurso do backup, podemos:
 Criar backups completos ou parciais de um banco de dados do Oracle.
 Copiar objetos que variam de uma tabela até um banco de dados completo.
 Mover os objetos ou dados entre computadores e banco de dados.
 Migrar um banco de dados de uma versão para outra.
Falhas (crashes) comuns que necessitam de recuperação do Banco:
 Queda de energia.
 Problemas de hardware.
 Problemas de software.
 Falha de um dos processos do Oracle.

É realizado através dos comandos: EXPDP (Exportação) e IMPDP (Importação)
Estes comandos são realizados a partir do prompt do Sistema Operacional (Windows, Unix/Linux) e não no
SQL*PLUS.
VANTAGENS:
Não requer que o banco de dados fique indisponível.
DESVANTAGENS:
A maioria das ações são realizadas pelo prompt do SO.
É necessário ter privilégios do sistema além de privilégios de DBA.
Difícil de realizar.
Não permite backup completo do banco de dados.
Requer várias interações do usuário.
BACKUP FÍSICO
O backup físico pode ser realizado de duas formas:
 BACKUP Físico (on-line)
 BACKUP Físico (off-line)
BACKUP FÍSICO (ON-LINE):
Também conhecido como “a quente” (hot backup) permite que seja realizado enquanto o Oracle está aberto.
Não é permitido a cópia dos arquivos de REDO e do CONTROL FILE, somente dos DATA FILES.
VANTAGENS:
Simples e realizado através dos comandos de copiar e colar do Sistema Operacional.
Fácil de fazer.
Não é necessário deixar o Banco de Dados indisponível.
DESVANTAGENS:
Só permite a cópia dos DATA FILES (.dbf).
BACKUP FÍSICO TOTAL DA BASE DE DADOS (FULL OFF-LINE):
Além de ser um backup essencial, também é o mais seguro.
É necessário pelo menos um backup full off-line, para que possa ser usada uma estratégia de backup.
VANTAGENS:
Conceitualmente simples, e realizado através dos comandos de copiar e colar do Sistema Operacional.
Fácil de fazer.
Requer pouca interação do operador.
Confiável.
DESVANTAGENS:
Requer que o Banco de Dados fique indisponível durante o Backup.
Exemplo:
Vamos realizar um Backup Físico total do BD Oracle (full off-line) com o Sistema Operacional
Windows:
Primeiro vamos identificar o local onde estão todos os arquivos do banco de dados a serem copiados
(backup):
(Data Files, Redo Log Files, Control File, Parameter file, Password file):
Para isto, vamos realizar o seguinte comando de consulta:
SELECT FILE_NAME FROM DBA_DATA_FILES;
FILE_NAME
--------------------------------------------------------------------------------
C:\ORACLEXE\APP\ORACLE\ORADATA\XE\USERS.DBF
C:\ORACLEXE\APP\ORACLE\ORADATA\XE\SYSAUX.DBF
C:\ORACLEXE\APP\ORACLE\ORADATA\XE\UNDOTBS1.DBF
C:\ORACLEXE\APP\ORACLE\ORADATA\XE\SYSTEM.DBF
A consulta acima nos trouxe o caminho (path) de onde estão os arquivos físicos do Oracle.
Agora, basta abrirmos os diretórios através do explorer do Windows. Veja as imagens abaixo, seguindo o
caminho dos diretórios encontrados:
Primeiro diretório do caminho: C:\ORACLEXE:
Clicando no diretório: ORACLEXE, temos o próximo diretório do caminho: C:\ORACLEXE\APP
Na sequência: C:\ORACLEXE\APP\ORACLE\
C:\ORACLEXE\APP\ORACLE\ORADATA\:
C:\ORACLEXE\APP\ORACLE\ORADATA\XE\
Clicando no diretório XE, chegamos nos arquivos físicos:
Acessamos todos os arquivos físicos que estão com a extensão: .DBF. Os arquivos de controle
CONTROL.DBF, os arquivos com as informações dos usuários (senha, perfil): USERS.DBF, as tabelas e os
dados do system: SYSTEM.DBF.
Para copiar os arquivos de redo, utilizamos a seguinte consulta:
SELECT MEMBER FROM V$LOGFILE;
MEMBER
--------------------------------------------------------------------------------
C:\ORACLEXE\APP\ORACLE\FAST_RECOVERY_AREA\XE\ONLINELOG\O1_MF_2_FCG21HNH_.LOG
C:\ORACLEXE\APP\ORACLE\FAST_RECOVERY_AREA\XE\ONLINELOG\O1_MF_1_FCG21G97_.LOG
Seguindo o caminho retornado pela consulta, poderemos acessar os arquivos de REDO e também fazermos
backup. Veja na imagem abaixo:
Como o backup é off-line. Antes de tirar cópias dos arquivos, vamos tirar do ar o Banco de Dados. Lembrando
que para realizarmos estas operações (SHUTDOWN e STARTUP) devemos entrar com privilégios de DBA,
por exemplo, com o usuário system:
CONN system AS SYSDBA/senha
1 - Dar shutdown (nenhum usuário poderá se conectar mais):
SHUTDOWN IMMEDIATE;
2 - COPIAR OS ARQUIVOS SELECIONADOS, VIA WINDOWS:
Basta selecionarmos os arquivos e realizar o famoso Control + C e Control + V para copiar e gravar os
arquivos em outro local. Pode-se, criar rotinas de backup com comandos de copiar para outro servidor ou para
a nuvem.
Depois de realizarmos o backup, vamos subir o Banco de Dados:
3 - Reiniciar o banco de dados com o seguinte comando:
STARTUP;
Agora, tornamos o Banco de Dados disponível para todos os usuários.
Veja no vídeo abaixo, a realização do exemplo de localização dos arquivos para backup:
Veja no vídeo abaixo como colocar o banco off-line:
Neste tópico vimos as formas de se utilizar um backup como medida de segurança em caso de falhas.

Desenvolvimento de Bancos de Dados Seguros

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Desenvolvimento de Bancos de Dados Seguros

Enviado por

Direitos autorais:

Formatos disponíveis

DESENVOLVIMENTO DE BANCOS DE DADOS SEGUROS

Introdução aos Sistemas Gerenciadores de

Sistema Gerenciador de Banco de Dados (SGBD)

 Integridade dos dados.

 Segurança de acesso aos dados.

 Atomicidade das transações.

 Concentração dos dados em um repositório.

 Independência de linguagem de programação.

Banco de Dados Relacionais

CARACTERÍSTICAS DA LINGUAGEM SQL

 Comandos para criar a estrutura do banco de dados (criar as tabelas).

 Comandos para realizar manutenções nas tabelas criadas.

 Comandos para cadastrar, alterar e apagar dados nas tabelas.

 Comandos para criar usuários e controlar os acessos.

 Comandos para controlar as transações realizadas.

 Comando para realizar consultas e estabelecer relatórios.

O SQL está dividido nas seguintes categorias de comandos:

Utilização dos comandos DDL (Data Definition

UTILIZANDO OS COMANDOS DDL

SQL*Plus: Release 11.2.0.2.0 Production on Dom Out 14 19:39:16 2018

Copyright (c) 1982, 2014, Oracle. All rights reserved.

SQL> connect system

USERNAME USER_ID CREATED

SQL> SELECT SYSDATE FROM DUAL;

SQL> SELECT SYSTIMESTAMP FROM DUAL;

Testamos mais alguns comandos, na linha 1, o comando retorna a data do sistema.

Campo: Tipo: Tamanho: Restrição:

codFunc Inteiro 3 Chave primária

nomeFunc Caractere 50 Não nulo

salario Número 10,2 Não nulo

Com a forma clássica de declarar restrições, personalizando as constraints:

SQL> CREATE TABLE Funcionario(

SQL> ALTER TABLE Funcionario ADD telefone VARCHAR(12) NOT NULL;

SQL> DESCRIBE Funcionario;

SQL> ALTER TABLE Funcionario MODIFY nomeFunc VARCHAR(70);

SQL> DESC Funcionario;

SQL> ALTER TABLE Funcionario MODIFY salario NULL;

SQL> DESC Funcionario;

Trocar o nome do campo salario para sal:

SQL> ALTER TABLE Funcionario RENAME COLUMN salario TO sal;

Trocar o nome da tabela funcionario para o nome colaborador:

SQL> ALTER TABLE Funcionario RENAME TO Colaborador;

SQL> DESC Colaborador;

Excluir o campo telefone:

SQL> ALTER TABLE Colaborador DROP COLUMN telefone;

Excluir a tabela colaborador:

SQL> DROP TABLE Colaborador CASCADE CONSTRAINTS;

Utilização dos comandos DML (Data

INSERINDO DADOS NA TABELA

> Maior que

< Menor que

>= Maior ou igual a

Vamos ver um exemplo:

Campo Descrição Tipo Tamanho Regras

codigo Código do DVD Inteiro 3 Chave Primária

titulo Titulo do Filme Caractere 20 Not null

preco Preço do DVD Numérico 5,2 Not null

SQL> CREATE TABLE DVD

Inserir os dados abaixo na tabela DVD:

codigo título preco

100 Extraordinário 39,99

101 O Círculo 29,55

102 Vingadores 19,44