Bando de Dados II – Aula 15A

Simulado para a prova de Banco de dados II, podendo ser baixado no Github, através do seguinte endereço:

https://github.com/rodrigoksaito/anchieta

 

Anúncios

Banco de Dados II – Aula 14

CONCORRÊNCIA DE TRANSAÇÕES

  • Transação é a forma por um grupo, lote, ou uma série de alterações em uma fonte de dados seja todas atualizadas com sucesso.
  • Caso uma delas venha a falhar, todos as alterações são desfeitas.
  • Para preserver a consistência dos dados envolvidos no lote de atualizações, o SQL Server mantém bloqueios nas linhas que estão sendo atualizadas.
  • O período de tempo que estes bloqueios são mantidos é conhecido como escopo de transação (transaction scope).
  • Uma forma de garantir a concorrência do banco de dados é garantir que os escopos de transação sejam matidos o menor tempo possível, permitindo o SQL Server liberar os bloqueios que estão sendo segurados e permitir que outros usuários acessem as linhas que foram modificadas.
  • As transações são uma forma de garantir as propriedade de atomicidade, consistência, isolamento e durabilidade (ACID) de um banco de dados. (pág. 468)

GERENCIAMENTO DE LOCK DO SQL SERVER

  • SQL Server utiliza, um mecanismo de bloqueio dinâmico cooperativo para proteger a consistência dos dados na base de dados.
  • Os muitos objetos que o SQL Server pode bloquear estão listadas na Tabela seguinte:

Sem título1

  • SQL Server irá travar o número mínimo de recursos necessários para atingir o seu objetivo;
  • Isto é conhecido como bloqueio de multi-granular.
  • Devido a este esquema, o SQL Server não deve apenas assumir os bloqueios que ele necessita (como um bloqueio em uma linha de uma página), mas também deve anunciar a sua intenção de níveis mais elevados.
  • Um exemplo pode ajudar a tornar isso claro.
  • Duas transações, T1 e T2, estão cada um tentando modificar diferentes linhas.
  • Para modificar uma linha, o SQL Server deve ter bloqueios exclusivos na linha que pretende modificar.
  • Se o SQL Server levou apenas o bloqueio exclusivo para T1 em R1, em seguida, T2 pediu um bloqueio em R2, o SQL Server teria que examinar a estrutura da árvore para determinar se essa linha pode ser bloqueado.
  • Isso seria muito custoso (processamento), por isso, SQL Server anuncia a sua intenção de níveis mais altos da árvore, colocando bloqueios de intenção acima da linha e navegar na árvore até a raiz.
  • Como você pode ver na figura seguinte, ao examinar os Locks, a intenção do SQL Server pode determinar rapidamente que há uma intenção de bloqueio exclusivo sobre a tabela, mas a linha de T1 está em uma parte separada da árvore, de modo que SQL Server podem agora adquirir o Lock que requer T2.

Sem título2

  • O SQL Server tem os seguintes bloqueios:

Sem título3

  • Os bloqueios de intenção pode ser considerado como um modificador para os outros modos de bloqueio.
  • Você colocaria um bloqueio compartilhado (S) em uma linha e ler essa linha, e um bloqueio de intenção compartilhado (IS) seriam colocados ao longo da navegação da raiz da B-Tree.

COMPATIBILIDADES DE LOCK

  • Embora alguns tipos de bloqueio impedem de outras transações adquirirem bloqueios no mesmo recurso, muitos bloqueios são compatíveis uns com os outros.
  • Uma tabela de compatibilidade de bloqueio abreviado é mostrada na Tabela 10-4.
  • Lendo este quadro pode ser confuso, por isso um exemplo vai ajudar.
  • Transação T1 atualmente detém um bloqueio de atualização (U) em uma linha.
  • Transação T2 concede um bloqueio compartilhado nessa linha.
  • Ao examinar a matriz, você pode ver que T2 será concedido o bloqueio compartilhado.
  • Com base na discussão anterior sobre bloqueios exclusivos, você pode perguntar por que um bloqueio IX atualmente concedido seria compatível com o pedido de um outro bloqueio IX.
  • Isso ocorre porque os bloqueios de intenção nunca são realizadas no nível do recurso real (como uma linha); eles são, pelo menos, a um nível acima na árvore. (Pág. 471)

Sem título4

  • SQL Server usa o gerenciamento de bloqueio dinâmico para aumentar a concorrência no banco de dados.
  • Por exemplo, se sua transação modifica uma linha em uma tabela, o SQL Server irá fazer um bloqueio de linha para a duração da modificação.
  • No entanto, em grandes tabelas em que seriam necessários muitos bloqueios de linha, o SQL Server, ao contrário, terá uma página ou a tabela de bloqueio.
  • Esta é dependente de todas as operações que levam bloqueios em uma tabela.
  • Se o otimizador de consulta decide que um grande número de linhas serão afetadas, os bloqueios de nível superior podem ser tomadas no início da transação.
  • No entanto, o SQL Server também pode escalar dinamicamente os tipos de bloqueio durante a execução.
  • Se o número total de bloqueios de linha tomadas por consultas por 100 usuários excede o limite, o SQL Server terá um bloqueio de tabela e, em seguida, irá liberar todos os bloqueios de leitura.
  • Isso simplifica o gerenciamento dos bloqueios, mas resulta em diminuição de simultaneidade. (Pág. 472)

NOTE TUNING TIP

Microsoft best practices specify that all tables should have a clustered index created because queries against heaps generally lead to table locks (because all leaf pages have to be scanned for results that match the query predicate) and reduce concurrency. (Pág 472)

NÍVEIS DE ISOLAMENTO DA TRANSAÇÃO

  • A American Nations Standards Institute (ANSI) especifica quatro níveis de isolamento de transação, cada um dos quais tem características muito específicas. As características dos níveis de isolamento são as seguintes:
  • Dirty read – Uma leitura suja ocorre quando uma transação tem permissão para ler dados de uma linha que foi modificada por outra transação em execução que ainda não foi comitada.
  • Non-repeatable read – A leitura não repetitiva ocorre quando, durante o curso de uma transação, uma linha é recuperada duas vezes e os valores dentro da linha diferem entre as leituras.
  • Phantom read – A leitura fantasma ocorre quando, no curso de uma operação, duas consultas idênticas são executadas, e a coleção de linhas retornadas pela segundo consulta é diferente da retornada pela primeira.

Sem título5

  • Os níveis de isolamento da transação são:

READ UNCOMMITTED – Os dados que não foram efetivados podem ser lidos. Embora um bloqueio exclusive ainda obstrua outro bloqueio exclusívo, as operações de leitura ignoram um bloqueio exclusívo.

READ COMMITTED  (Padrão do SQL Server) – Um bloqueio exclusívo obstrui bloqueios compartilhados, assim como bloqueios exclusívos. Os bloqueios compartilhados serão liberados assim que os dados forem lidos.

REPEATABLE READ – Os bloqueios exclusívos obstruem os bloqueios compartilhados e exclusívos. Os bloqueios compartilhados obstruem os bloqueios exclusívos. Os bloqueios compatilhados são mantidos pela duração da transação.

READ SERIALIZABLE – Igual a todas as constraints do nível de isolamento Repeatable Read. Além disso, voce não pode inserir uma nova linha dentro do intervalo do conjunto de chaves (keyset) correntemente bloqueado pela transação. Bloqueios são mantidos pela duração da transação.

SNAPSHOT – Usa o recurso de controle de versão de linha para impeder que bloqueis compartilhados e exclusívos obstruam uns aos outros, enquanto mantém a consistência dos dados. Uma operação de leitura recupera dados da versão da linha antes de iniciar uma operação de modificação de dados.

EXEMPLOS DOS NÍVEIS DE ISOLAMENTO

–Verifica nivel de isolamento corrente

DBCC USEROPTIONS
GO

--Criando um banco de dados
CREATE DATABASE IL
GO

USE IL
GO

--Criacao da tabela 1
CREATE TABLE tbIsolationLevel
(
Id INT IDENTITY,
Col1 varchar(10),
Col2 varchar(10),
Col3 varchar(10)
)
GO

--Inserindo dados na tabela 1
INSERT INTO tbIsolationLevel(Col1,Col2,Col3)
VALUES ('AAAAA','BBBBB','CCCCC')
GO 5

--Criacao da tabela 2
CREATE TABLE tbDeadlock ( id INT)
GO

--Inserindo dados de tabela 2
INSERT INTO tbDeadlock(ID) values (1),(2)
GO

READ COMMITED

/*********  RODAR NA CONEXÃO 1 *********/

BEGIN TRAN
UPDATE tbIsolationLevel set Col1 = 'DDDDD' where id = 1
WAITFOR DELAY '00:00:10'
ROLLBACK TRAN



/*********  RODAR NA CONEXÃO 2 *********/
SET TRANSACTION ISOLATION LEVEL READ COMMITTED
SELECT * FROM tbIsolationLevel

READ UNCOMMITED

/*********  RODAR NA CONEXÃO 1 *********/

BEGIN TRAN
UPDATE tbIsolationLevel set Col1 = 'DDDDD' where id = 1
WAITFOR DELAY '00:00:10'
ROLLBACK TRAN

/*********  RODAR NA CONEXÃO 2 *********/
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED
SELECT * FROM tbIsolationLevel

-- Usando o hint NOLOCK
SELECT * FROM tbIsolationLevel with (nolock)

REPETEATABLE READ

/*********  RODAR NA CONEXÃO 1 *********/
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ
BEGIN TRAN
SELECT * FROM tbIsolationLevel
WAITFOR DELAY '00:00:10'
SELECT * FROM tbIsolationLevel
ROLLBACK TRAN

/*********  RODAR NA CONEXÃO 2 *********/
UPDATE tbIsolationLevel set Col1 = 'DDDDD' where id = 1
--select * from tbIsolationLevel
INSERT INTO tbIsolationLevel(Col1,Col2,Col3)
VALUES ('DDDDD','EEEEE','FFFFF')

SNAPSHOT ISOLATION LEVEL

  • Em Snapshot Isolation, as versões de linha atualizados para cada transação são mantidos em TempDB. Uma vez que a transação foi iniciada, ignora todas as linhas mais recentes inseridos ou atualizados na tabela.
USE AdventureWorks2012
GO

--Aciona permissão de uso do SnapShot no banco
/
ALTER DATABASE AdventureWorks2012
SET ALLOW_SNAPSHOT_ISOLATION ON
GO

SELECT ModifiedDate
FROM HumanResources.Shift
GO

-- Session 1
SET TRANSACTION ISOLATION LEVEL SNAPSHOT
BEGIN TRAN
UPDATE HumanResources.Shift
SET ModifiedDate = GETDATE()
GO

-- Session 2
SET TRANSACTION ISOLATION LEVEL SNAPSHOT
BEGIN TRAN
SELECT ModifiedDate
FROM HumanResources.Shift
GO

-- Session 1
COMMIT

-- Session 2
SELECT ModifiedDate
FROM HumanResources.Shift
GO

--AINDA OS DADOS NAO FORAM ALTERADOS
-- Session 2
COMMIT

SELECT ModifiedDate
FROM HumanResources.Shift
GO

SNAPSHOT (INSTANTÂNEOS)

  • O recurso Database SnapShot foi introduzido no SQL Server 2005 para oferecer aos usuários um método para criar cópias somente leitura de dados rapidamente.
  • Esse recurso somente está disponível no SQL Server Enterprise.
  • O DataBase SnapShot não é compatível com FILE STREAM.

RECURSO DE CRIAÇÃO DE SNAPSHOTS

  • A criação de um snapshot de banco de dados é muito parecida com a criação de qualquer banco de dados.
  • Para criar um snapshot de banco de dados, você usa o comando CREATE DATABASE com a cláusula AS SNAPSHOT OF.
  • Como um snapshot é somente um cópia de leitura de dados de um banco de dados em um ponto no tempo, você não especifica um log de transação;

REQUISITOS PARA CRIAÇÃO DE SNAPSHOT

  • Voce deve incluir uma entrada para cada arquivo de dados especificado no banco de dados de origem;
  • O nome lógico de cada arquivo deve corresponder exatamente ao nome no banco de dados de origem;

RESTRIÇÕES PARA UM SNAPSHOT

  • Voce não pode fazer backup, restaurar ou remover um snapshot de banco de dados;
  • O snapshot de banco de dados deve existir na mesma instância do banco de dados de origem;
  • Índices full text não são suportados;
  • FILESTREAM não é suportado e quaisquer dados FILESTREAM serão inacessíveis por meio do snapshot de banco de dados;
  • Voce não pode criar um snapshot de banco de dados em um banco de dados de sistema;
  • Voce não pode eliminar, restaurar ou remover um banco de dados de origem que tenha um snapshot de banco de dados;
  • Você não pode fazer referencia a grupos de arquivos que estejam off-line, extintos ou sem restauração;
  • Para que um aplicativo acessa o snapshot é da mesma forma que acessasse um banco de dados normalmente;
  • No momento da criação do snapshot, o banco de dados não contém dados. Quando uma instrução SELECT é executada, o SQL Server usa o banco de dados de origem para recuperar dados que não mudaram desde que você criou o snapshot;

REVERTENDO DADOS DE UM SNAPSHOT

  • É possível fazer o retorno dos dados até o momento da criação do snapshot.
  • Em casos extremos, você pode usar o snapshot para retornar todo o conteúdo do banco de dados de origem para o estado do snapshot.
  • Por exemplo, se você precisar descartar todas as alterações ocorrida dentro do banco de dados desde que o snapshot de banco de dados foi criado;
  • Uma reversão de banco de dados é uma categoria especial de restauração de dados que pode ser executada quando você tiver criado um snapshot;
  • Você pode reverter apenas uma linha ou parte do banco de dados, podendo usar os comandos INSERT, UPDATE, DELETE ou MERGE, ou também reverter um banco de dados por completo.
  • Quando você usa o snapshot para reverter o banco de dados inteiro, o banco de dados de origem volta exatamente para como estava no momento em que o snapshot foi criado.
  • Todas as transações executadas no banco de dados são perdidas.
  • Quando você reverte um banco de dados de origem existem várias restrições:
    •  Pode existir apenas um snapshot de banco de dados para o banco de dados origem;
    • Catálogos full text no banco de dados de origem devem ser eliminados e então recriados, depois que a reversão terminar;
    • Como o log de transação é reconstruído, o encadeamento de logs de transação é desfeito;
    • O banco de dados de origem e o snapshot de banco de dados ficam offline durante o processo de reversão;
    • O banco de dados de origem não pode ser ativado para FileStream;

EXEMPLO DE CRIAÇÃO DE SNAPSHOT

USE master
GO

CREATE DATABASE AdventureWorks2012Snap on
(NAME=N'AdventureWorks2012_Data',
FILENAME=N'c:\temp\AdventureWorks2012.ds')
AS SNAPSHOT OF AdventureWorks2012
GO

use AdventureWorks2012Snap
select * from person.Address

use master
go

--Restaurando o banco de dados do snapshot
RESTORE DATABASE AdventureWorks2012 FROM
DATABASE_SNAPSHOT = 'AdventureWorks2012Snap'

SELECT * FROM AdventureWorks2012.sys.database_files
SELECT * FROM AdventureWorks2012Snap.sys.database_files
SELECT * FROM master.sys.databases

REFERÊNCIAS

https://msdn.microsoft.com/pt-br/library/ms173763.aspxhttp://www.diegonogare.net/2013/01/transaction-isolation-level-voc-est-usando-certo/

BIBLIOGRAFIA BÁSICA

  • HOTEK, M. MCTS Self-Paced Training Kit (Exam 70-432) Microsoft SQL Server 2008 – Implementation and Maintenance. EUA: Microsoft Press, 2009.
  • STANEK, William R. Microsoft SQL Server 2008 – Guia de Bolso do Administrador. Porto Alegre: Bookman, 2010.
  • HOTEK, M. Microsoft SQL Server 2008 – Passo a Passo. Porto Alegre: Bookman, 2010.

Video 01

Video 02

Banco de Dados II – Aula 13

PERMISSÃO PARA MODO DEBUG

ScreenHunter_114 May. 06 23.47

EXECUÇÃO DA PROCEDURE

ScreenHunter_115 May. 06 23.48

PASSOS PARA FAZER O DEBUG

ScreenHunter_116 May. 07 00.23

EXEMPLO DE CÓDIGO

CREATE OR REPLACE PROCEDURE SP_TESTE_DEBUG
  (p_employee_id_inicial IN EMPLOYEES.EMPLOYEE_ID%TYPE,
   p_employee_id_final   IN EMPLOYEES.EMPLOYEE_ID%TYPE)
IS
  v_employee_id EMPLOYEES.EMPLOYEE_ID%TYPE;
  v_last_name   EMPLOYEES.LAST_NAME%TYPE;
  v_hire_date   EMPLOYEES.HIRE_DATE%TYPE;
  v_contador NUMBER;
  
  CURSOR cur_ret_employees is
    SELECT EMPLOYEE_ID, FIRST_NAME, HIRE_DATE
    FROM EMPLOYEES
    WHERE EMPLOYEE_ID BETWEEN p_employee_id_inicial AND p_employee_id_final;
BEGIN
  v_contador := 0;
  
  FOR r_employees IN cur_ret_employees LOOP
    FETCH cur_ret_employees
    INTO v_employee_id, v_last_name, v_hire_date;
    EXIT WHEN cur_ret_employees%NOTFOUND;
    
    v_contador := v_contador +1;
    
    DBMS_OUTPUT.PUT_LINE('Record    : '|| v_contador);
    DBMS_OUTPUT.PUT_LINE('EmployeeId: '||   v_employee_id);
    DBMS_OUTPUT.PUT_LINE('Last Name : ' ||   v_last_name);
    DBMS_OUTPUT.PUT_LINE('Hire Date : ' ||   v_hire_date);
    DBMS_OUTPUT.PUT_LINE('');
  END LOOP;
  EXCEPTION WHEN OTHERS THEN
    DBMS_OUTPUT.PUT_LINE('Error was detected');
END;
/

TESTE DE DEBUG

  • Não crie bloco anônimo para fazer o teste do debug no código;
  • Nos parâmetros, coloque intervalos pequenos somente para ver o resultado;

TRIGGERS (GATILHOS)

  • Trigger é um bloco PL/SQL que é armazenado no banco de dados e executado em resposta de um específico evento;
  • O banco de dados Oracle executa um trigger automaticamente quando é especificada uma ocorrência de uma condição;
  • Uma trigger pode ser definida em uma tabela, view, schema (dono do schema), ou banco de dados (para todos os usuários)Untitled

TIPOS DE EVENTOS DAS TRIGGERS

  • Podemos escrever triggers que disparam em uma das operações que ocorre no banco de dados:
    • DML (insert, update, delete)
    • DDL (create, alter, drop)
    • Operações no banco como SERVERERROR, LOGON, LOGOFF, STARTUP ou SHUTDOWN;

CENÁRIOS DE APLICAÇÕES PARA IMPLEMENTAÇÃO

  • Podemos utilizar triggers em:
    • Segurança
    • Auditoria
    • Integridade de Dados
    • Integridade Referencial
    • Replicação de dados
    • Dados derivados de cálculos
    • Eventos de Logging

DISPONIBILIDADE DOS TIPOS DE TRIGGERS

  • Em DML simples
    • BEFORE
    • AFTER
    • INSTEAD OF

TIPOS DE EVENTOS DA TRIGGER E CORPO

  • Um tipo de evento da trigger determina como as cláusulas da declaração DML irá executar a trigger. As possibilidade são:
    • INSERT
    • UPDATE [OF COLUMN]
    • DELETE
  • O corpo determina a ação é chamada e é um bloco PL/SQL ou a chamada de uma procedure;

CRIANDO TRIGGER DML

ScreenHunter_117 May. 07 01.00

ESPECIFICANDO O TEMPO DE EXECUÇÃO

  • Voce pode especificar o tempo que a trigger irá ser executada em uma das declarações:
    • BEFORE: Executa o corpo da trigger antes do acionamento do evento DML na tabela;
    • AFTER: Executa o corpo da trigger depois do acionamento do evento DML na tabela;
    • INSTEAD OF: Executa o corpo da trigger ao invés do evento disparado (geralmente um comando DML);

SEQUENCIA DE DISPARO DAS TRIGGERS: MANIPULAÇÃO SIMPLES DE LINHA

  • A sequencia de disparo de uma trigger em uma tabela quando um linha é manipulada:

Untitled2

SEQUENCIA DE DISPARO DAS TRIGGERS: MANIPULAÇÃO DE VÁRIAS LINHAS

  • A sequencia de disparo de uma trigger em uma tabela quando são manipuladas várias linhas:

Untitled3

EXEMPLO DA TRIGGER SECURE_EMP

Untitled4

TESTANDO A TRIGGER SECURE_EMP

Untitled5

USANDO PREDICADOS CONDICIONAIS

CREATE OR REPLACE TRIGGER secure_emp BEFORE
  INSERT OR UPDATE OR DELETE ON employees
BEGIN
  IF (TO_CHAR(SYSDATE,'DY') IN ('SAT','SUN')) OR
     (TO_CHAR(SYSDATE,'HH24') NOT BETWEEN '08' AND '18') THEN
    IF DELETING THEN RAISE_APPLICATION_ERROR(
       -20502,'Voce pode deletar empregados durante o horario comercial.');
    ELSIF INSERTING THEN RAISE_APPLICATION_ERROR (
       -20500,'Voce pode inserir empregados durante o horario comercial.');
    ELSIF UPDATING ('SALARY') THEN RAISE_APPLICATION_ERROR (
       -20503,'Voce pode atualizar o salary em horario comercial');
    ELSE RAISE_APPLICATION_ERROR(
       -20504,'Voce pode atualizar a tabela empregados durante o horario comercial');
    END IF;
  END IF;
END;

desc employees

insert into employees (EMPLOYEE_ID, LAST_NAME, EMAIL, HIRE_DATE, JOB_ID)
VALUES (207,'TESTE','TESTE',TO_DATE('05/05/2017','MM/DD/YYYY'),'HR_REP')

CRIANDO TRIGGER DE DML DE LINHA

–EXEMPLO 2

CREATE OR REPLACE TRIGGER SALARIO_RESTRITO
  BEFORE INSERT OR UPDATE OF SALARY ON EMPLOYEES
  FOR EACH ROW
BEGIN
  IF NOT (:NEW.job_id IN ('AD_PRES','AD_VP'))
    AND :NEW.salary > 15000 THEN
      RAISE_APPLICATION_ERROR (-20202,
        'Empregado não pode ganhar mais que $15000.');
  END IF;
END;

--teste da chamada
UPDATE employees
SET salary = 15500
WHERE last_name = 'Russell';

USANDO QUALIFICADORES OLD E NEW

  • Quando uma linha é atingida, o motor do run-time PL/SQL cria e popula duas estruturas de dados:
  • OLD: armazena os valores originais do registro processado pela trigger;
  • NEW: contém os novos valores;
  • NEW e OLD tem a mesma estrutura do registro declarado usando %ROWTYPE na tabela a qual a trigger é atachada (criada);

Untitled6

CREATE TABLE AUDIT_EMP (
  USER_NAME        VARCHAR2(30),
  TIME_STAMP       DATE,
  ID               NUMBER(6),
  OLD_LAST_NAME    VARCHAR2(25),
  NEW_LAST_NAME    VARCHAR2(25),
  OLD_TITLE        VARCHAR2(10),
  NEW_TITLE        VARCHAR2(10),
  OLD_SALARY       NUMBER(8,2),
  NEW_SALARY       NUMBER(8,2)
)
/

CREATE OR REPLACE TRIGGER AUDIT_EMP_VALUES
  AFTER DELETE OR INSERT OR UPDATE ON EMPLOYEES
  FOR EACH ROW
BEGIN
  INSERT INTO AUDIT_EMP(USER_NAME, TIME_STAMP, ID,
                        OLD_LAST_NAME, NEW_LAST_NAME,
                        OLD_TITLE,    NEW_TITLE,
                        OLD_SALARY,   NEW_SALARY)
  VALUES (USER, SYSDATE, :OLD.EMPLOYEE_ID,
          :OLD.LAST_NAME, :NEW.LAST_NAME,
          :OLD.JOB_ID, :NEW.JOB_ID,
          :OLD.SALARY, :NEW.SALARY);
END;

--EXMEPLO DE CHAMADA DA FUNÇÃO

INSERT INTO EMPLOYEES (EMPLOYEE_ID, LAST_NAME, JOB_ID, SALARY,
EMAIL, HIRE_DATE)
VALUES (999,'TEMP EMP','SA_REP',6000, 'TEMP EMP', TRUNC(SYSDATE));
/

UPDATE EMPLOYEES
SET SALARY = 7000,
LAST_NAME = 'Smith'
WHERE EMPLOYEE_ID = 999;

SELECT *
FROM AUDIT_EMP;

Exercícios

1. Crie uma tabela chamada empregados2 com a mesma estrutura da tabela employees. Faça uma trigger que a medida que a tabela employees for sido preenchida, essa tabela empregados2 deve ter os mesmos dados;

2. Faça uma trigger que verifique se os dados da tabela empregados2 está sendo alterada. Caso o salário esteja sendo alterado, a trigger não deve permitir gravar o registro;

3. Crie uma tabela chamada empregados3. Copie todos os dados que tenham o job_id = ‘IT_PROG’ da tabela employees para essa tabela. Crie uma outra tabela chamada log_empregados3, contendo as estrutura da tabela empregados3, com dados antes e depois de alterações. Faça uma trigger na tabela empregados3 para fazer essa auditoria;

PACKAGES (Pacotes)

  • Package é um objeto de um schema que agrupa logicamente tipos PL/SQL, variáveis e subprogramas;
  • Packages geralmente são divididos em 2 partes:
  • A especificação (spec)
  • O corpo
  • A especificação é uma interface para a Package. Ela declara os tipos, variáveis, constantes, exceções, cursores, e subprogramas que pode ser referenciados do lado de fora da Package;
  • O corpo define as queries de cursores e o código para os subprogramas;
  • Habilita o servidor Oracle a ler múltiplos objetos na memória de uma vez;

VANTAGENS DO USO DAS PACKAGES

  • Modularidade: Encapsulando construtores relacionados;
  • Fácil manutenção: mantendo logicamente funcionalidades relacionadas juntas;
  • Fácil projeto de aplicação: Codificando e compilando a especificação e o corpo separadamente;
  • Escondendo informação:
    • Somente as declarações na Especificação da Package são visíveis e acessíveis para aplicações;
    • Construtores privados no corpo da Package são escondidos e inacessíveis;
    • Toda codificação é escondida no corpo da Package;
  • Adição de funcionalidades: Persistência de variáveis públicas e cursores;
  • Melhor desempenho:
    • Toda a Package é carregada para a memória quando uma Package é referenciada na primeira vez;
    • Há uma única cópia na memória para todos os usuários;
    • A hierárquia de dependência é simplificada;
    • Overloading: Múltiplos subprogramas com o mesmo nome;

COMPONENTES DE UMA PACKAGE PL/SQL

Untitled

VISIBILIDADE INTERNA E EXTERNA DOS COMPONENTES DA PACKAGE

Untitled2

CRIANDO A ESPECIFICAÇÃO DA PACKAGE

Untitled3

  • Variáveis declaradas na especificação da Package são inicializados NULL por padrão;
  • Todos os construtores declarados na especificação da Package são visíveis a usuários que tem privilégios na Package;

CRIANDO A ESPECIFICAÇÃO DA PACKAGE NO SQL DEVELOPER

Untitled4

CRIANDO O CORPO DA PACKAGE NO SQL DEVELOPER

Untitled5

EXEMPLO DE ESPECIFICAÇÃO DA PACKAGE

CREATE OR REPLACE PACKAGE COMM_PKG IS
V_STD_COMM NUMBER := 0.10; --INICIALIZADO COM 0.10
PROCEDURE RESET_COMM(P_NEW_COMM NUMBER);
END COMM_PKG;
/
  • V_STD_COMM é variável pública global inicializada com 0.10;
  • RESET_COMM é procedure publica usada para resetar a comissão padrão baseada em algumas regras de negócio; Será implementadado no corpo da Package;

CRIANDO O CORPO DA PACKAGE

Untitled6

  • Identificadores definidos como privado o corpo da Package e não visível do lado de fora do corpo da package;
  • Todos construtores privados precisam ser declarados antes de eles serem referenciados;
  • Construtores públicos são visíveis para todo o corpo da Package;

EXEMPLO DE CORPO DA PACKAGE

CREATE OR REPLACE PACKAGE BODY COMM_PKG IS
  FUNCTION VALIDATE(P_COMM NUMBER) RETURN BOOLEAN IS
    V_MAX_COMM  EMPLOYEES.COMMISSION_PCT%TYPE;
  BEGIN
    SELECT  MAX(COMMISSION_PCT)
    INTO    V_MAX_COMM
    FROM    EMPLOYEES;
    RETURN (P_COMM BETWEEN 0.0 AND V_MAX_COMM);
  END VALIDATE;

  PROCEDURE RESET_COMM(P_NEW_COMM NUMBER) IS
  BEGIN
    IF VALIDATE(P_NEW_COMM) THEN
      V_STD_COMM := P_NEW_COMM; -- RESETA A VARIAVEL PUBLICA
    ELSE
      RAISE_APPLICATION_ERROR (-20210,'COMISSAO RUIM');
    END IF;
  END RESET_COMM;
END COMM_PKG;
/

CHAMANDO SUBPROGRAMAS DA PACKAGE

EXECUTE COMM_PKG.RESET_COMM(0.15);

Exercícios

  1. Faça uma Package que faça a Insert de funcionários (employees) e Select por ID. Deve conter também uma função que retorne o nome completo do funcionário, passando por parâmetro o ID. Faça os devidos testes de chamadas;
  1. Crie uma Package que faça o Insert, Update, Delete, e Select por ID do Departamento e outra Select pelo Nome do Departamento. Para fazer Inserção e atualização, é necessário verificar se o nome do departamento não exista na tabela. Em caso de um departamento já existente, exiba uma mensagem para ser exibido pelo ambiente chamador. Faça os devidos testes de chamadas;

 

Video 01

Banco de Dados II – Aula 12

MANIPULANDO EXCEÇÕES

  • Quando desenvolvemos procedures que são chamadas de outras procedures, devemos ter ciência dos processamentos e exceções de não processamento nas transações e chamadas de procedures;
  • Quando uma exceção é levantada na chamada de uma procedure, o controle vai imediatamente para a seção de exceção daquele bloco.
  • Uma exceção é considera processada se a exceção fornece um manipulador para a exceção levantada;
  • Quando uma exceção ocorre e é manipulada, o seguinte fluxo de código ocorre:
    • A exceção é erguida/levantada;
    • O controle é transferido para o manipulador de exceção;
    • O bloco é terminado;
    • O bloco/programa chamador continua a executar como se nada tivesse acontecido;

Sem título

EXEMPLO

CREATE OR REPLACE PROCEDURE add_department (p_name   VARCHAR2,
                                            p_mgr    NUMBER,
                                            p_loc    NUMBER) IS
BEGIN
  INSERT INTO departments(department_id,
                          department_name,
                          manager_id,
                          location_id)
  VALUES (departments_seq.NEXTVAL,
          p_name,
          p_mgr,
          p_loc);

  DBMS_OUTPUT.PUT_LINE('Departamento adicionado: ' || p_name);
EXCEPTION
  WHEN OTHERS THEN
    DBMS_OUTPUT.PUT_LINE('Erro: adicionando departamento:' || p_name);
END add_department;
/

–CRIANDO UMA PROCEDURE PARA CHAMADA

CREATE OR REPLACE PROCEDURE CREATE_DEPARTMENTS IS
BEGIN
  add_department('Midia',100,1800);
  add_department('Edicao',99,1800);
  add_department('Propaganda',101,1800);
END;
/

–VERIFICANDO DADOS

SELECT * FROM DEPARTMENTS;

SET SERVEROUTPUT ON;

EXECUTE CREATE_DEPARTMENTS;

SELECT EMPLOYEE_ID
FROM   EMPLOYEES
WHERE  EMPLOYEE_ID IN (100,99,101);

ERRO GERADO DA CHAMADA DA PROCEDURE

Sem título2

MANIPULANDO EXCEÇÕES

  • Se uma exceção não é manipulada, então todos as declarações DML na chamada da procedure são feitas ROLLBACK, não efetivando nenhuma alteração em dados;
  • Declarações DML que não são afetadas são declarações que foram executadas antes da chamada do código PL/SQL a qual exceções não são manipuladas;

EXEMPLO

–EXEMPLO DE EXCEÇÕES NAO MANIPULADAS

SET SERVEROUTPUT ON;

CREATE OR REPLACE PROCEDURE add_department_noex (p_name VARCHAR2,
                                                 p_mgr  NUMBER,
                                                 p_loc  NUMBER ) IS
BEGIN
  INSERT INTO DEPARTMENTS (department_id,      
                           department_name,
                           manager_id,
                           location_id)
  VALUES(DEPARTMENTS_SEQ.NEXTVAL, p_name,
         p_mgr, p_loc);
  DBMS_OUTPUT.PUT_LINE('Departamento adicionado: ' || p_name);
END add_department_noex;
/

–CRIACAO DA PROCEDURE CHAMADORA

CREATE OR REPLACE PROCEDURE create_departments_noex IS
BEGIN
  add_department_noex('Midia 2',100,1800);
  add_department_noex('Edicao 2',99,1800);
  add_department_noex('Propaganda 2',101,1800);
END;

–CHAMADA DA PROCEDURE NOEX

EXECUTE create_departments_noex;

SELECT * FROM DEPARTMENTS;
  • Perceba que neste último exemplo, sem o tratamento de exceção, uma única linha não consistente não deixou que as demais linhas fossem incluídas na tabela;

Sem título3

EXCLUSÃO DE PROCEDURES

  • Para se fazer a exclusão de uma procedure, utilizamos o comando:
    • DROP PROCEDURE
  • Verifique antes na documentação se essa procedure não está sendo utilizada por nenhuma aplicação;
  • Caso você apague uma procedure que é chamada por outros objetos, o ORACLE não irá alertá-lo sobre isso;
  • As procedures ou objetos que são dependentes da procedure apagada ficam em estado “pendentes”;

Sem título4

VISUALIZANDO INFORMAÇÕES DE PROCEDURES UTILIZANDO DICIONARIO DE DADOS DAS VIEWS

  • O código fonte de subprogramas PL/SQL é armazenado no dicionário de dados;
  • Para ver os códigos armazenados, execute select nas declarações seguidas das tabelas:
    • Tabela USER_SOURCE mostra o código PL/SQL do seu dono;
    • Tabela ALL_SOURCE mostra o código a qual você tem direito concedido de EXECUTE pelo dono do subprograma;
DESCRIBE USER_SOURCE;

select * from USER_SOURCE;

DESCRIBE ALL_SOURCE;

select * from ALL_SOURCE;

LOOPS (LAÇOS)

  • Loops são repetições de um determinado trecho de código, ou seja, as instruções são executadas por várias vezes;
  • Em PL/SQL existem três tipos de loops;
    • LOOP BÁSICO (LAÇO);
    • LOOP FOR (PARA);
    • LOOP WHILE (ENQUANTO)

EXEMPLO DE LOOP BÁSICO

–LOOPS BASICO

DESCRIBE DEPARTMENTS;

DECLARE
  v_max_department_id  number;
  v_novo_departamento  departments.department_name%TYPE;
  v_contador           number := 1;
BEGIN
  SELECT MAX(DEPARTMENT_ID)
  INTO       v_max_department_id
  FROM      DEPARTMENTS;
  
  v_novo_departamento := '&NovoDepto';

  LOOP
    v_novo_departamento := v_novo_departamento || v_contador;
    
    INSERT INTO DEPARTMENTS(DEPARTMENT_ID, DEPARTMENT_NAME)
    VALUES (v_max_department_id + v_contador, v_novo_departamento);
    
    v_contador := v_contador + 1;
    
    EXIT WHEN v_contador > 4;
  END LOOP;
END;
/

–VERIFIQUE OS RESULTADOS

select * from departments;

EXEMPLO DE LOOP WHILE

DECLARE
  v_max_department_id  number;
  v_novo_departamento  departments.department_name%TYPE;
  v_contador           number := 1;
BEGIN
  SELECT MAX(DEPARTMENT_ID)
  INTO       v_max_department_id
  FROM      DEPARTMENTS;

  v_novo_departamento := '&NovoDepto';

  WHILE v_contador < 4 LOOP
    v_novo_departamento := v_novo_departamento || v_contador;
    INSERT INTO DEPARTMENTS(DEPARTMENT_ID, DEPARTMENT_NAME)
    VALUES (v_max_department_id + v_contador, v_novo_departamento);
    v_contador := v_contador + 1;
END LOOP;
END;
/

–VERIFIQUE OS RESULTADOS

select * from departments;

EXEMPLO DE LOOP FOR

DECLARE
  v_max_department_id   number;
  v_novo_departamento  departments.department_name%TYPE;
  v_contador            number := 1;
BEGIN
  SELECT MAX(DEPARTMENT_ID)
  INTO       v_max_department_id
  FROM      DEPARTMENTS;

  v_novo_departamento := '&NovoDepto';

  FOR I IN 1..3 LOOP
    v_novo_departamento := v_novo_departamento || v_contador;
    
    INSERT INTO DEPARTMENTS(DEPARTMENT_ID, DEPARTMENT_NAME)
    VALUES (v_max_department_id + v_contador, v_novo_departamento);

    v_contador := v_contador + 1;
  END LOOP;
END;
/

–VERIFIQUE OS RESULTADOS

select * from departments;

INSTRUÇÃO CONTINUE

  • É utilizado dentro de um dos tipos de loops;
  • Faz com que a condição do laço seja avaliada antes de terminar o bloco do loop;
  • Oferece aos programadores a habilidade de transferir o controle para a próxima interação;

EXEMPLO DE CONTINUE

SET SERVEROUTPUT ON;
DECLARE
  v_soma SIMPLE_INTEGER :=0;
BEGIN
  FOR i IN 1..10 LOOP
    v_soma := v_soma + 1;
    DBMS_OUTPUT.PUT_LINE('A soma é: ' || v_soma);
    CONTINUE WHEN i > 6;
    v_soma := v_soma +1;
    DBMS_OUTPUT.PUT_LINE('Sem entrar continue, soma é: ' || v_soma);
  END LOOP;
END;
/

DATATYPE

  • Datatypes são tipo de dados que possuem múltiplos valores, ou seja, pode-se armazenar vários dados em uma única variável, que ao contrário do tipos char, number, date, podem armazenar somente 1 por vez;
  • Podem ser do tipos RECORD e COLLECTION;

RECORDS e COLLECTIONS

  • RECORD é quando queremos armazenar um valor com diferentes tipos de dados em uma única ocorrência naquele momento;
  • COLLECTION é quando queremos armazenar alguns valores do mesmo tipo de dado (record);

Sem título5

  • RECORD contém um ou mais componentes, também conhecidos como campos de qualquer tipo escalar (number, char, date, etc);
  • São similares a estrutura da linguagem C;
  • Trata uma coleção de campos como uma unidade lógica;

ESTRUTURA DE UM RECORD

Sem título6

MANUPILAÇÃO DOS RECORDS

  • Notação de um campo individual:
    • CLI_RECORD.NOME;
  • Atribuindo um valor ao record:
    • CLI_RECORD.NOME := ‘JOAO DA SILVA’;

ATRIBUTO %ROWTYPE

  • Declara uma variável de acordo com uma coleção de colunas de uma tabela uma view;
  • Campos de um RECORD tem que ter mesmos nomes e tipos de colunas de uma tabela ou view;

EXEMPLO DE  %ROWTYPE

SET SERVER_OUTPUT ON;
DECLARE
  TYPE EMP_REC IS RECORD (
  v_sal       number(8),
  v_minsal    number(8) default 1000,
  v_hire_date employees.hire_date%TYPE,
  v_emp1      employees%ROWTYPE);
  v_meurec EMP_REC;
BEGIN
  v_meurec.v_sal := v_meurec.v_minsal + 500;
  v_meurec.v_hire_date := sysdate;

  SELECT  *
  INTO    v_meurec.v_emp1
  FROM    employees
  WHERE   EMPLOYEE_ID = 100;

  DBMS_OUTPUT.PUT_LINE(v_meurec.v_emp1.last_name || ' ' ||
  to_char(v_meurec.v_hire_date) || ' ' ||
  to_char(v_meurec.v_sal));
END;
/

CURSORES

  • Toda instrução SQL que é executada no Servidor Oracle é associado um cursor individual;
  • Cursor implícito é declarado e gerenciado pelo PL/SQL;
  • Cursor explícito é declarado e gerenciado pelo programador;

CURSORES EXPLICITOS

Sem título7

CONTROLANDO CURSORES EXPLÍCITOS

Sem título8

DECLARANDO CURSORES

  • Não incluir INTO na declaração do cursor, pois o carregamento dos valores será feita após o FETCH;
  • Caso queira que seja processado em uma determinada sequencia, utilize ORDER BY;
  • Um cursor pode suportar SELECTs com JOINS;
SET SERVEROUTPUT ON;
DECLARE
  CURSOR c_emp_cursor is
    SELECT  employee_id, last_name
    FROM    employees
    WHERE   department_id = 30;
  v_empno employees.employee_id%TYPE;
  v_lname employees.last_name%TYPE;
BEGIN
  OPEN c_emp_cursor;
  FETCH c_emp_cursor INTO v_empno, v_lname;
  DBMS_OUTPUT.PUT_LINE(v_empno || ' ' || v_lname);
END;
/

CURSORES COM LOOP

SET SERVEROUTPUT ON;
DECLARE
  CURSOR c_emp_cursor is
    SELECT  employee_id, last_name    
    FROM    employees WHERE   department_id = 30;
    v_empno employees.employee_id%TYPE;
    v_lname employees.last_name%TYPE;
BEGIN
  OPEN c_emp_cursor;
  
  LOOP
    FETCH c_emp_cursor INTO v_empno, v_lname;

    EXIT WHEN c_emp_cursor%NOTFOUND;

    DBMS_OUTPUT.PUT_LINE(v_empno || ' ' || v_lname);
  END LOOP;

  CLOSE c_emp_cursor ;
END;
/

LOOP FOR COM CURSORES

SET SERVEROUTPUT ON;
DECLARE
  CURSOR c_emp_cursor IS
    SELECT employee_id, last_name FROM employees
    WHERE department_id = 30;
BEGIN
  FOR emp_record IN c_emp_cursor
  LOOP
    DBMS_OUTPUT.PUT_LINE(emp_record.employee_id ||' '||   emp_record.last_name);
  END LOOP;
END;
/

STATUS DE CURSORES

Sem título9

UTILIZAÇÃO DO %ISOPEN

SET SERVEROUTPUT ON;
DECLARE
  CURSOR c_emp_cursor is
    SELECT  employee_id, last_name
    FROM    employees
    WHERE   department_id = 30;
  v_empno employees.employee_id%TYPE;
  v_lname employees.last_name%TYPE;
BEGIN
  IF NOT c_emp_cursor%ISOPEN THEN
    OPEN c_emp_cursor;
  END IF;
  
  LOOP
    FETCH c_emp_cursor INTO v_empno, v_lname;
    EXIT WHEN c_emp_cursor%NOTFOUND;
    DBMS_OUTPUT.PUT_LINE(v_empno || ' ' || v_lname);
  END LOOP;
END;
/

UTILIZAÇÃO DO %ROWCOUNT e %NOTFOUND

SET SERVEROUTPUT ON;
DECLARE
  CURSOR c_emp_cursor is
    SELECT  employee_id, last_name FROM    employees
    WHERE   department_id = &cod_departamento;
  v_emp_record c_emp_cursor%ROWTYPE;
BEGIN
  OPEN c_emp_cursor;
  LOOP
    FETCH c_emp_cursor INTO v_emp_record;
    EXIT WHEN c_emp_cursor%ROWCOUNT > 10 OR
    
    c_emp_cursor%NOTFOUND;
    
    DBMS_OUTPUT.PUT_LINE(v_emp_record.employee_id
    || ' ' || v_emp_record.last_name);
  END LOOP;
  CLOSE c_emp_cursor;
END;
/

FUNÇÕES

  • É um bloco PL/SQL nomeado que retorna um valor;
  • Pode ser armazenado no banco de dados como um objeto de schema para execuções repetidas;
  • É chamada como parte de uma expressão ou é usada para fornecer um valor de parâmetro para outro subprograma;
  • Pode ser agrupadas em pacotes do PL/SQL;
  • O bloco PL/SQL precisa ter ao menos uma declaração de retorno (RETURN);
  • É criado com o comando CREATE FUNCTION;
  • Apesar de parâmetros OUT e IN OUT serem modos que podem utilizar as funções, não é uma boa prática utilizá-las em funções;
  • No entanto, se você precisa retornar mais de um valor de uma função, considere retornar valores compostos de estrutura de dados como um registro ou tabela PL/SQL;

DIFERENÇAS ENTRE PROCEDURES E FUNÇÕES

PROCEDURES FUNCTIONS
Executa como declaração PL/SQL Chamado com uma parte de uma expressão
Não contém cláusula RETURN no cabeçalho Precisa conter um RETURN no cabeçalho
Pode passar valores (se precisar) usando parâmetros output Precisa retornar um valor simples
Pode conter a declaração RETURN sem um valor Precisa conter ao menos uma declaração RETURN

VISÃO GERAL DA CRIAÇÃO E EXECUÇÃO DE FUNÇÕES

Sem título10

CRIANDO E CHAMANDO UMA FUNÇÃO

–CRIANDO A FUNÇÃO

CREATE OR REPLACE FUNCTION get_sal
  (p_id IN employees.employee_id%TYPE)
RETURN NUMBER IS
  v_sal employees.salary%TYPE := 0;
BEGIN
  SELECT salary
  INTO   v_sal
  FROM   employees
  WHERE  employee_id = p_id;
  
  RETURN v_sal;
END get_sal;
/

–CHAMANDO A FUNÇÃO EM UMA EXPRESSAO
–COM UM VALOR DE PARAMETRO

SET SERVEROUTPUT ON;

EXECUTE dbms_output.put_line(get_sal(100));

DIFERENTES MÉTODOS PARA SE EXECUTAR UMA FUNÇÃO

–EXEMPLO 1

VARIABLE b_salary NUMBER

EXECUTE :b_salary := get_sal(100);

PRINT b_salary;

–EXEMPLO 2

SET SERVEROUTPUT ON

DECLARE
  sal employees.salary%TYPE;
BEGIN
  sal := get_sal(100);
  DBMS_OUTPUT.PUT_LINE('o SALÁRIO É: ' || sal);
END;
/

–EXEMPLO 3

EXECUTE dbms_output.put_line   (get_sal(100));

–EXEMPLO 4

SELECT  JOB_ID, GET_SAL(EMPLOYEE_ID)
FROM    EMPLOYEES;

TABELA DO DICIONÁRIO DE DADOS

  • Podemos utilizar a tabela USER_OBJECTS para identificar os tipos de objetos que o usuário corrente tem acesso;
SELECT   object_name,
         object_type
FROM     user_objects;

EXEMPLO DE FUNÇÃO COM COMPARAÇÕES

CREATE OR REPLACE FUNCTION check_sal
  RETURN Boolean IS
  v_dept_id   employees.department_id%TYPE;
  v_empno     employees.employee_id%TYPE;
  v_sal       employees.salary%TYPE;
  v_avg_sal   employees.salary%TYPE;
BEGIN
  v_empno := 205;
  SELECT  salary, department_id
  INTO    v_sal, v_dept_id,
  FROM    employees
  WHERE   employee_id = v_empno;

  SELECT  avg(salary)
  INTO    v_avg_sal
  FROM    employees
  WHERE   department_id = v_dept_id;

  IF v_sal > v_avg_sal THEN
    RETURN TRUE;
  ELSE
    RETURN FALSE;
  END IF;

EXCEPTION
  WHEN NO_DATA_FOUND THEN
    RETURN NULL;
END;

MOSTRANDO POSSÍVEIS ERROS

–mostrando onde estão os possíveis erros

SHOW ERRORS FUNCTION check_sal

--SERÁ MOSTRADO POSSIVELMENTE

LINE/COL ERROR
-------- ----------------------------------
9/3      PL/SQL: SQL Statement ignored
11/3     PL/SQL: ORA-00936: missing expression

AJUSTE DA FUNÇÃO

–ajuste a seguinte parte da função

SELECT  salary,
        department_id
INTO    v_sal,
        v_dept_id

CHAMADA DA FUNÇÃO

–chamada da função

SET SERVEROUTPUT ON;
BEGIN
  IF (check_sal IS NULL) THEN
  DBMS_OUTPUT.PUT_LINE('A função retornou NULL devido a exceção');
  ELSIF (check_sal) THEN
    DBMS_OUTPUT.PUT_LINE('Salario > média');
  ELSE
    DBMS_OUTPUT.PUT_LINE('Salario < média');
  END IF;
END;
/

PASSANDO PARAMETROS PARA UMA FUNÇÃO

CREATE OR REPLACE FUNCTION check_sal
  (p_empno employees.employee_id% TYPE)
RETURN Boolean IS
  v_dept_id   employees.department_id%TYPE;
  v_sal       employees.salary%TYPE;
  v_avg_sal   employees.salary%TYPE;
BEGIN
  SELECT  salary, department_id
  INTO    v_sal, v_dept_id
  FROM    employees
  WHERE   employee_id = p_empno;
  
  SELECT  avg(salary)
  INTO    v_avg_sal
  FROM    employees
  WHERE   department_id = v_dept_id;

  IF v_sal > v_avg_sal THEN
    RETURN TRUE;
  ELSE
    RETURN FALSE;
  END IF;

EXCEPTION
  WHEN NO_DATA_FOUND THEN
    RETURN NULL;
END;
/

CHAMADA DA FUNÇÃO COM PARAMETROS

SET SERVEROUTPUT ON;
BEGIN
  DBMS_OUTPUT.PUT_LINE('Checando o empregado 205');
  
  IF (check_sal(205) IS NULL) THEN
    DBMS_OUTPUT.PUT_LINE('A função retornou NULL devido   a exceção');
  ELSIF (check_sal(205)) THEN
    DBMS_OUTPUT.PUT_LINE('Salario > média');
  ELSE
    DBMS_OUTPUT.PUT_LINE('Salario < média');   END IF;   DBMS_OUTPUT.PUT_LINE('Checando o empregado 70');      IF (check_sal(70) IS NULL) THEN     DBMS_OUTPUT.PUT_LINE('A função retornou NULL devido     a exceção');   ELSIF (check_sal(70)) THEN     DBMS_OUTPUT.PUT_LINE('Salario > média');
  ELSE
    DBMS_OUTPUT.PUT_LINE('Salario < média');
  END IF;
END;
/

Exercícios

  1. Crie uma função, que passado 2 parâmetros do tipo number, (o valor do primeiro parâmetro deve ser menor que o segundo) retorne o valor do maior salário encontrado. Os parâmetros passados são correspondentes aos códigos dos empregados. Essa função deve tratar erro, caso o primeiro parâmetro seja maior que o segundo parâmetro. No ambiente chamador, mostre o valor encontrado;
  1. Crie uma função, que passado um parâmetro do tipo number e outro do tipo data, que retorne a quantidade de tempo que o empregado está na empresa em anos que o valor deve ser arredondado. Os parâmetros passados são correspondentes ao códigos do empregados e a data de admissão. No ambiente chamador, deve-se chamar a função através de um comando select;
  1. Crie uma função, que passado um parâmetro do tipo number, retorne se o funcionário tem o job_id igual a “IT_PROG” ou “PU_CLERCK”. O parâmetro passado é correspondente ao código do funcionário. No ambiente chamador, deve ser impresso se o funcionário tem ou não tem o job_id igual a “IT_PROG” ou “PU_CLERCK”;
  1. Crie uma função, que passado um parâmetro do tipo number, retorne a quantidade de funcionário que existem em um determinado departamento. O parâmetro passado é correspondente ao departamento. No ambiente chamador, é necessário estar impresso o código do departamento e a quantidade de funcionários;

Vídeo – Parte 1

Vídeo – Parte 2

Vídeo – Parte 3

 

 

 

 

Banco de Dados II – Aula 11

INTRODUÇÃO AO PL/SQL

  • PL/SQL é uma linguagem de programação em blocos;
  • Uma unidade de programa pode ser Nomeada ou Não Nomeada;
  • Blocos Não Nomeados também são conhecidos como blocos anônimos;

Sintaxe geral:

[DECLARE]
declaration_statements
BEGIN
execution_statements
[EXCEPTION]
exception_handling_statements
END;

  • Em uma declaração de blocos, podem ser definidos tipos de dados, estruturas, variáveis;
  • Estruturas também podem ser localmente chamadas de funções, procedimentos e cursores;
  • BEGIN e END são palavras reservadas, com o uso opcional da palavra EXCEPTION
  • O mínimo código de um bloco anônimo é:
BEGIN
NULL;
END;
/
  • A exceção do bloco de manipulação permite você gerenciar exceções; 
  • Blocos nomeados têm uma ligeira diferença dos blocos não nomeados, porque os blocos nomeados ficam armazenados no banco de dados;
  • Blocos nomeados tem também uma sessão de declaração, chamado como header (cabeçalho);
  • O nome e a lista de parâmetros são chamados de uma assinatura de uma sub-rotina;
  • As mesmas regras são aplicadas para os corpos dos objetos (bodies); 

Exemplo de bloco nomeado:

PROCEDURE procedure_name
( parameter1 [IN][OUT] [NOCOPY] sql_data_type | plsql_data_type
, parameter2 [IN][OUT] [NOCOPY] sql_data_type | plsql_data_type
, parameter(n+1) [IN][OUT] [NOCOPY] sql_data_type | plsql_data_type )
[ AUTHID {DEFINER | CURRENT_USER}]
declaration_statements
BEGIN
  execution_statements
[EXCEPTION]
  exception_handling_statements
END;
/

Habilitando OUTPUT em um bloco PL/SQL:

  • Escreva antes do bloco PL/SQL:
  SET SERVEROUTPUT ON;

Use o pacote (package) pré-definido DBMS_OUTPUT   
Exemplo do DBMS_OUTPUT  :

DBMS_OUTPUT.PUT_LINE ('O primeiro nome de funcionário é ' || v_fname);
... 
  • Escreva antes do bloco PL/SQL:
  SET SERVEROUTPUT ON;

Use o pacote (package) pré-definido DBMS_OUTPUT.PUT_LINE(‘string’) 

Exemplo:

SET SERVEROUTPUT ON
BEGIN
DBMS_OUTPUT.PUT_LINE  ('IMPRESSAO DE LINHA  USANDO PUT_LINE');
END;
/  

CONFIGURAÇÃO DO SERVEROUTPUT

–CONFIGURANDO O AMBIENTE, QTD DE BUFFER SET SERVEROUTPUT ON SIZE 1000000;

DBMS_OUTPUT.ENABLE(1000000); 
DBMS_OUTPUT.DISABLE; 

–EXEMPLO

BEGIN DBMS_OUTPUT.PUT('LINHA '); 
  DBMS_OUTPUT.PUT('UM.'); 
  DBMS_OUTPUT.NEW_LINE; 
  DBMS_OUTPUT.PUT_LINE('LINHA DOIS.'); 
END; 
/

TIPO BOLEANO

  • O tipo boleado de dados por ter três possibilidade de valores: TRUE, FALSE e NULL;
  • Pode ser declarado como e exemplo a seguir;
SET SERVEROUTPUT ON;
DECLARE
  var1 BOOLEAN;
  var2 BOOLEAN NOT NULL := TRUE;
  var3 BOOLEAN NOT NULL := FALSE;
BEGIN
  DBMS_OUTPUT.PUT_LINE(CASE WHEN var1 THEN 'TRUE'
                         WHEN var1 IS NULL THEN 'NULL'
                         ELSE 'FALSE'
                       END );

  DBMS_OUTPUT.PUT_LINE(CASE WHEN var2 THEN 'TRUE'
                       WHEN var2 IS NULL THEN 'NULL'
                       ELSE 'FALSE'
                     END);

  DBMS_OUTPUT.PUT_LINE(CASE WHEN var3 THEN 'TRUE'
                       WHEN var3 IS NULL THEN 'NULL'
                       ELSE 'FALSE'
                     END);
END;
/

CARACTERES E STRINGS

  • O tamanho da string é declarado pelo número de bytes ou caracteres;
  • Qualquer tentativa de armazenamento maior que o tamanho suportado, pode ser tratado com exceção;
SET SERVEROUTPUT ON;
DECLARE
  c CHAR(32767) := ' ';
  v VARCHAR2(32767) := ‘ ';
BEGIN
  DBMS_OUTPUT.PUT_LINE(' c é ['|| LENGTH(c)||']');
  DBMS_OUTPUT.PUT_LINE(' v é ['|| LENGTH(v)||']');
  v := v || ' ';
  DBMS_OUTPUT.PUT_LINE(' v é ['|| LENGTH(v)||']');
END;
/

O TIPO CHAR E VARCHAR

  • O tipo CHAR é baseado em um tamanho fixo de strings. O padrão é o tamanho de 1 byte, podendo chegar até a 32.767;
  • Em colunas CHAR, o máximo permitido são 4000 bytes;
  • A Oracle recomenda utilizar CLOB ou LONG para colunas;
  • O tipo VARCHAR2 tem base em tamanhos variados;
  • VARCHAR2 pode chegar até 32.767 bytes de tamanho;

EXEMPLO DO TIPO CHAR

--tipo char
SET SERVEROUTPUT ON;
DECLARE
  var1 CHAR;
  var2 CHAR(10);
  var3 CHAR(10 BYTE);
  var4 CHAR(10 CHAR);
BEGIN
  var1 := 'a'; var2 := 'b'; var3 := 'c'; var4 := 'd';
  DBMS_OUTPUT.PUT_LINE(' var1 é ['|| LENGTH(var1)||']');
  DBMS_OUTPUT.PUT_LINE(' var2 é ['|| LENGTH(var2)||']');
  DBMS_OUTPUT.PUT_LINE(' var3 é ['|| LENGTH(var3)||']');
  DBMS_OUTPUT.PUT_LINE(' var4 é ['|| LENGTH(var4)||']');
END;
/

EXEMPLO DO TIPO VARCHAR2
--tipo varchar2
SET SERVEROUTPUT ON;
DECLARE
  var1 VARCHAR2; --erro
  var2 VARCHAR2(10);
  var3 VARCHAR2(10 BYTE);
  var4 VARCHAR2(10 CHAR);
BEGIN
  var1 := 'A'; var2 := 'AB'; var3 := 'ABC'; var4 := 'ABCD';
  DBMS_OUTPUT.PUT_LINE(' var1 é ['|| LENGTH(var1)||']');
  DBMS_OUTPUT.PUT_LINE(' var2 é ['|| LENGTH(var2)||']');
  DBMS_OUTPUT.PUT_LINE(' var3 é ['|| LENGTH(var3)||']');
  DBMS_OUTPUT.PUT_LINE(' var4 é ['|| LENGTH(var4)||']');
END;
/

OS TIPOS DATE, TIME, INTERVAL

Sem título

EXEMPLO DO DATE

SET SERVEROUTPUT ON;
DECLARE
  var1 DATE;
  var2 DATE := SYSDATE;
  var3 DATE := SYSDATE +1;
  var4 DATE := '29-FEB-08';
BEGIN
  DBMS_OUTPUT.PUT_LINE(' var1 é ['|| var1 ||']');
  DBMS_OUTPUT.PUT_LINE(' var2 é ['|| var2 ||']');
  DBMS_OUTPUT.PUT_LINE(' var3 é ['|| var3 ||']');
  DBMS_OUTPUT.PUT_LINE(' var4 é ['|| var4 ||']');
END;
/

O TIPO TIMESTAMP

  • É um subtipo extendido de DATE, que oferece mais precisão no tempo;
  • SYSTIMESTAMP oferece o tempo mais preciso dependendo da plataforma;

EXEMPLO DO TIMESTAMP

SET SERVEROUTPUT ON;
DECLARE
  d DATE := SYSTIMESTAMP;
  t TIMESTAMP(3) := SYSTIMESTAMP;
BEGIN
  DBMS_OUTPUT.PUT_LINE('DATE      ['||d||']');
  DBMS_OUTPUT.PUT_LINE('TO_CHAR['||TO_CHAR(d,'DD-MON-YY HH24:MI:SS') ||']');
  DBMS_OUTPUT.PUT_LINE('TIMESTAMP ['||t||']');
END;
/

CARACTERES UNICODES

  • Caracteres unicodes servem para suportar globalização;
  • Globalização é a utilização de caracteres que suportam múltiplos conjuntos de caracteres;
  • A codificação AL16UTF16 ou UTF8 são oferecidas pelo Oracle;
  • AL16UTF16 utiliza 2 bytes por caracter;
  • UTF8 utiliza 3 bytes por caracter;
  • NCHAR é o tipo de dado UNICODE;
  • Pode armazenar até o tamanho de 16.383 (32.767 / 2);
  • NVARCHAR2 é o equivalente ao VARCHAR2;

Sem título2Ref: https://docs.oracle.com/cd/B19306_01/server.102/b14225/ch6unicode.htm

O TIPO NUMBER

  • Há 4 principais tipos de números no Oracle: BINARY_INTEGER, IEEE 754 (BINARY_DOUBLE e BINARY_FLOAT), O NUMBER e PLS_INTEGER;
  • BINARY_INTEGER e PLS_INTEGER são idênticos, suportando a -2.147.483.648 a 2.147.483.647;

ATRIBUINDO VALORES À VARIÁVEIS DINAMICAMENTE

  • No ambiente SQL Developer, podemos fazer a atribuição de variáveis através do símbolo “&” (e comercial sem aspas);
--EXEMPLO DE ATRIBUIÇÃO DE VARIÁVEIS
SET SERVEROUTPUT ON;
DECLARE
  var1  number;   var2  number;   soma  number;
BEGIN
  DBMS_OUTPUT.PUT_LINE('Digite valor 1:');
  var1 := &Valor1;
  
  DBMS_OUTPUT.PUT_LINE('Digite valor 2:');
  var2 := &Valor2;
  
  DBMS_OUTPUT.PUT_LINE('Valor 1:' || var1);
  
  DBMS_OUTPUT.PUT_LINE('Valor 2:' || var2);
  
  soma := var1 + var2;
  
  DBMS_OUTPUT.PUT_LINE('Soma:' || soma);
END;
/

EXEMPLO DE DECLARAÇÃO DE TIPOS DE VARIÁVEIS
SET serveroutput ON;
DECLARE
  nIdFuncionario binary_integer;
  nSalario NUMBER(10, 2);  nAcrescimo FLOAT;
BEGIN
  nidfuncionario := 25;
  nSalario       := 1500;
  nAcrescimo     := 0.25;
  dbms_output.put_line('O novo salário do funcionário: ' || nSalario * (1 + nAcrescimo));
END;

--VARIAVEIS NUMBER, FLOAT, BINARY_INTEGER

SET SERVEROUTPUT ON;
DECLARE
  v_FUNCIONARIO_ID  BINARY_INTEGER;
  v_SALARIO NUMBER(10,2); v_ACRESCIMO  FLOAT;
BEGIN
  v_FUNCIONARIO_ID := 10; v_SALARIO := 2000;
  v_ACRESCIMO := 0.10;
 
DBMS_OUTPUT.PUT_LINE('O novo salario do funcionario: '
  || v_FUNCIONARIO_ID || ' terá acrescimo de '
  || v_SALARIO * v_ACRESCIMO);
END;

--VARIAVEIS BOOLEAN
SET SERVEROUTPUT ON;
DECLARE
  v_FUNCIONARIO_ID  BINARY_INTEGER;
  v_SALARIO         NUMBER(10,2);
  v_SAL_EM_REAL     BOOLEAN;
BEGIN
  v_FUNCIONARIO_ID := 10;
  v_SALARIO := 2000;
  v_SAL_EM_REAL := TRUE;
  IF v_SAL_EM_REAL THEN
    DBMS_OUTPUT.PUT_LINE('O salario do funcionario: '
      || v_FUNCIONARIO_ID || ' é de  '
      || v_SALARIO || ' em reais');
  ELSE
    DBMS_OUTPUT.PUT_LINE('O salario do funcionario: '
      || v_FUNCIONARIO_ID || ' é de  '
      || v_SALARIO || ' em dolares');
  END IF;
END;
/

CONSTANTES

  • É similar a uma variável, porém valores não podem ser atribuídos durante o bloco de código;
  • A palavra CONSTANT reserva é colocada depois do nome da variável e antes do tipo da variável;
  • Pode ser definida por qualquer tipo de dados disponível para variáveis;
  • Para utiliza-la, tenha certeza de que o valor não será alterado;
EXEMPLO DE CONSTANTES
--irá gerar erro
SET SERVEROUTPUT ON;
DECLARE
  v_SALARIO CONSTANT number(4);
BEGIN
  v_SALARIO := 1000;
  dbms_output.put_line (v_SALARIO);
END;
/

 
--irá funcionar
SET SERVEROUTPUT ON;
DECLARE
  v_SALARIO CONSTANT number(4) := 1000;
BEGIN
  dbms_output.put_line (v_SALARIO);
END;
/

VARIÁVEIS NOT NULL

  • É possível declarar em PL/SQL variáveis NOT NULL;
  • No decorrer do código, esta variável deverá ter algum valor, não podendo ser nula;
  • É declarado na seção DECLARE, sendo que a variável precisa ter um valor associado;

EXEMPLO DE VARIÁVEIS NOT NULL

--erro
SET SERVEROUTPUT ON;
DECLARE
  v_FUNCIONARIO_ID BINARY_INTEGER NOT NULL := 10;
  v_SALARIO        NUMBER(10,2) := 1000;
BEGIN
  v_FUNCIONARIO_ID := NULL;
  DBMS_OUTPUT.PUT_LINE('Funcionario: ' || v_FUNCIONARIO_ID);
  v_SALARIO := NULL;
  DBMS_OUTPUT.PUT_LINE('Salario : ' || v_SALARIO);
END;
/ 

--correto
SET SERVEROUTPUT ON;
DECLARE
  v_FUNCIONARIO_ID BINARY_INTEGER NOT NULL := 10;
  v_SALARIO        NUMBER(10,2) := 1000;
BEGIN
  DBMS_OUTPUT.PUT_LINE('Funcionario: ' || v_FUNCIONARIO_ID);
  v_SALARIO := NULL;
  DBMS_OUTPUT.PUT_LINE('Salario : ' || v_SALARIO);
END;
/

EXEMPLO DE IF..THEN.. ELSE

-- IF THEN ELSE
SET SERVEROUTPUT ON;
DECLARE
  v_SALARIO         NUMBER(10,2);
BEGIN
  v_SALARIO := &Salario;
  IF v_SALARIO BETWEEN 0 AND 1000 THEN
    DBMS_OUTPUT.PUT_LINE('Salario baixo:  ' || v_SALARIO);
  ELSIF v_SALARIO BETWEEN 1001 AND 2000 THEN
    DBMS_OUTPUT.PUT_LINE('Salario médio:  ' || v_SALARIO);
  ELSE
    DBMS_OUTPUT.PUT_LINE('Salario alto:  ' || v_SALARIO);
  END IF;
END;
/

Exercícios

  1. Crie uma bloco anônimo que leia três variáveis do tipo number e aponte mostre os números digitados e o maior número dentre os três;
  1. Crie um bloco anônimo que leia 2 variáveis do tipo number, mostre os dois números digitados e mostre o resultado da soma, multiplicação, subtração e divisão desses dois números;
  1. Crie um bloco anônimo que leia 2 variáveis do tipo number, e leia qual operação o usuário deseja fazer, escolhendo entre os símbolos (+, -, /, *). O símbolo escolhido deve ser apresentado o resultado dentre os dois números;
  1. Crie um bloco anônimo que leia 3 frases de até 100 caracteres, mostre as frases digitadas, mostre quantos caracteres cada frase possui, e mostre a soma da quantidade de caracteres total das tres frases;
  1. Crie um bloco anônimo que leia 2 datas, mostrando a quantidade de dias, meses e anos dentre essas datas. (Pode fazer arredondamento caso necessário). Observação, a Data Inicial precisa ser menor que a data final;
  1. Crie um bloco nomeado que tenha 3 parametros de entrada do tipo number e que mostre o menor número dos 3 argumentos passados;
  1. Crie um bloco nomeado que tenha 2 parametros de entrada do tipo nvarchar, e mostre quantos bytes cada parâmetro está ocupando;
  1. Crie um bloco nomeado que tenha 2 parametros de entrada, uma do tipo number e outra do tipo date, e que mostre a data mais o parâmetro do tipo number e a data menos o parâmetro do tipo number;

PROCEDURES EM PL/SQL

  • São tipos de sub-programas que executam uma ação;
  • Pode ser armazenado em um banco como um objeto de schema;
  • Provê reusabilidade e fácil manutenção;
  • Pode aceitar parâmetros;
  • A procedure é compilada e armazenada no banco de dados como um schema de objeto;
  • Um bloco de comandos PL/SQL pode aceitar variáveis de substituição;
SET SERVEROUTPUT ON
DECLARE
  my_var VARCHAR2(30);
BEGIN
  my_var := '&input';
  dbms_output.put_line('Hello '|| my_var );
END;
/
  • O operador de atribuição é “:=” (sem aspas);
  • Strings são delimitadas por aspas simples;
  • Declara-se variáveis na seção DECLARE;
  • Os tipos de variáveis utilizadas são as mesmos tipos de variáveis utilizados nas tabelas do Oracle;
SET SERVEROUTPUT ON
DECLARE
  my_var VARCHAR2(10);
BEGIN
  my_var := '&input';
  dbms_output.put_line('Hello '|| my_var );
EXCEPTION
  WHEN others THEN
    dbms_output.put_line(SQLERRM);
END;
/
  • Em PL/SQL, é possível fazer tratamentos de erros com a cláusula EXCEPTION;
  • A função SQLERRM irá capturar o erro, e é possível mostrar os erros através do comando de impressão;
  • SQLERRM retorna a mensagem de erro associado ao número do erro;
  • Quando estamos codificando em linguagens de programação, é normal que tenhamos que seguir algumas regras de convenção de nomes;
  • Elas servem para que se tenha padronização em na codificação dos programas;
  • Não há uma regra clara sobre o uso de nomeações padrão. Caso não tenha, é importante adotar uma;

EXEMPLO DE CONVENSÃO DE NOMES EM PL/SQL

Sem título4

PARAMETROS E SEUS MODOS

  • São declaradas depois dos subprogramas no header da procedure;
  • Passa dados entre o ambiente de chamada e o subprograma;
  • São usados como variáveis locais, mas são dependentes do modo em que são tratados
  • IN é o modo padrão que passa os valores do ambiente de chamada para o subprograma;
  • OUT é o modo de retorno do valor para o ambiente chamador;
  • IN OUT é o modo que passa valores do ambiente de chamada, a qual pode retornar o valor modificado (o mesmo parâmetro);

Sem título5

PARAMETRO FORMAL

  • Variáveis locais declaradas na lista de parâmetros da especificação do subprograma;

PARAMETRO ATUAL

  • Ou também conhecidos como argumentos: Valores literais, variáveis e expressões são usadas na lista de parâmetros que chamam o subprograma (procedure)

MODOS DOS PARAMETROS

  • O tipo dos parâmetros pode ser especificado sem o tamanho do seu tipo;
  • Podem ser utilizados:
  • O tipo explicito do dado;
  • Usando a definição %TYPE;
  • Usando a definição %ROWTYPE;
  • Um ou mais parâmetros formais podem ser declarados, cada um separados por virgula;

COMPARAÇÃO DOS MODOS DOS PARAMETROS

  • IN é o padrão se não há especificação na declaração;
  • OUT e IN OUT precisam ser explicitamente especificados na declaração dos parâmetros;
  • No parâmetro formal IN não pode ser atribuído um valor e não pode ser modificado no corpo da procedure. Por padrão, o parâmetro IN é passado por referencia
  • Um parâmetro IN pode ser atribuído por um valor padrão na declaração do parâmetro formal, em caso do ambiente chamador não fornecer um valor para o parâmetro se o valor padrão é aplicado;
  • OUT ou IN OUT precisam ser atribuídos um valor antes do retorno do ambiente chamador.
  • OUT e IN OUT não podem ser atribuídos valores padrão;

COMPARAÇÃO DOS MODOS DOS PARAMETROS

Não pode ser atribuído um valor padrão

IN OUT IN OUT
Modo padrão Precisa ser especificado Precisa ser especificado
Valor é passado para o subprograma Valor é retornado para o ambiente chamador Valor é passado para o subprograma; valor é retornado para o ambiente chamador
Parâmetros formais e atuais como uma constante Variáveis não inicializáveis Variáveis inicializáveis
Parâmetro atual pode ser literal, expressão, constantes, ou variáveis inicializáveis Precisa ser uma variável Precisa ser uma variável
Pode ser atribuído um valor padrão Não pode ser atribuído um valor padrão

EXEMPLO DE USO DO PARÂMETRO IN

--EXEMPLO DO PARAMETRO IN
CREATE OR REPLACE PROCEDURE previsao_salario (p_id   in employees.employee_id%TYPE, p_percent in NUMBER)
IS
BEGIN
  UPDATE  EMPLOYEES
  SET     SALARY = SALARY * (1 + p_percent /100)
  WHERE  EMPLOYEE_ID = p_id;
END previsao_salario;
/
 
--CONFERINDO O VALOR ANTERIOR
SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID = 176;

--ESTA É A CHAMADA
EXECUTE previsao_salario(176,10);

--CONVERINDO O VALOR POSTERIOR
SELECT * FROM EMPLOYEES WHERE EMPLOYEE_ID = 176;

--ABANDOMANDO ALTERAÇÕES
ROLLBACK;

EXEMPLO DE USO DO PARÂMETRO OUT 
--EXEMPLO DO PARAMETRO OUT
CREATE OR REPLACE PROCEDURE QUERY_EMP (p_id     IN  employees.employee_id%TYPE,
                                       p_name   OUT employees.last_name%TYPE,
                                       p_salary OUT employees.salary%TYPE ) IS
BEGIN
  SELECT  last_name, salary
  INTO    p_name,    p_salary
  FROM    employees
  WHERE   employee_id = p_id;
END QUERY_EMP;
/

--CHAMADA DA PROCEDURE EXEMPLO OUT

SET SERVEROUTPUT ON
DECLARE
  v_emp_name employees.last_name%TYPE;
  v_emp_sal  employees.salary%TYPE;
BEGIN
  QUERY_EMP(171,v_emp_name, v_emp_sal);
  DBMS_OUTPUT.PUT_LINE(v_emp_name || ' ganha ' ||
    to_char(v_emp_sal, '$999,999.00'));
END;
/

PARÂMETRO IN OUT

  • O parametro IN OUT pode ser passado um valor para a procedure que pode ser atualizado, ou seja, o valor do mesmo parametro pode ser atualizado durante o processamento nas linhas da procedure;

EXEMPLO DE PARÂMETRO IN OUT

CREATE OR REPLACE PROCEDURE format_phone
(p_phone_no IN OUT VARCHAR2) IS
BEGIN
p_phone_no := '('   || SUBSTR(p_phone_no,1,3) ||
')  ' || SUBSTR(p_phone_no,4,3) ||
'-'   || SUBSTR(p_phone_no,7);
END format_phone;
/

–CHAMADA DA PROCEDURE IN OUT

VARIABLE b_phone_no VARCHAR2(15)
EXECUTE :b_phone_no := '8006330575'
PRINT b_phone_no
EXECUTE format_phone(:b_phone_no)
PRINT b_phone_no

PASSAGEM DE PARAMETROS

  • Quando chamamos um subprograma, você pode escrever os parâmetros atuais usando as seguintes notações:
    • Posicional: lista dos parâmetros atuais na mesma ordem do que os parâmetros formais;
    • Nomeado: Lista dos parâmetros atuais em ordem arbitrária, usando o operador => para associar a nomeação do parâmetro formal com o parâmetro atual;
    • Misto: Lista de alguns parâmetros atuais como posicionais e alguns como nomeados;
  • Antes do Oracle Database 11g, somente a notação posicional era suportada nas chamadas das SQL´s;
  • A partir da versa 11g, notações nomeadas e mistos podem ser usadas para especificar argumentos na chamada para sub-rotinas de declarações do PL/SQL;

–PASSAGEM DE PARAMETRO ATUAIS

CREATE OR REPLACE PROCEDURE add_dept(p_name in  departments.department_name%TYPE,
                                     p_loc  in  departments.location_id%TYPE) IS
BEGIN
  INSERT INTO departments(department_id,
                          department_name,
                          location_id)
  VALUES (departments_seq.NEXTVAL, p_name, p_loc);
END add_dept;


--PASSAGEM DE NOTAÇÃO POSICIONAL
EXECUTE add_dept('TRAINING',2500);

--PASSAGEM DE NOTAÇÃO NOMEADA
EXECUTE add_dept(p_loc=>2400, p_name=>'EDUCATION');

USANDO O PARAMETRO OPCIONAL DEFAULT

  • Define um valor padrão para o parâmetro;
  • Provê flexibilidade por combinação posicional e nomeada na sintaxe da passagem de parâmetros;

ALTERANDO A PROCEDURE add_dept

–PARAMETRO DEFAULT

CREATE OR REPLACE PROCEDURE add_dept
(p_name departments.department_name%TYPE :='Desconhecido',
p_loc  departments.location_id%TYPE DEFAULT 1700 )
IS
BEGIN
INSERT INTO departments  (department_id,
department_name,
location_id)
VALUES (departments_seq.NEXTVAL, p_name, p_loc);
END add_dept;
/

CHAMADA DA PROCEDURE add_dept

--chamando a procedure
EXECUTE add_dept;

EXECUTE add_dept('PROPAGANDA',p_loc=>1200);

EXECUTE add_dept(p_loc=>1200);

--conferindo os dados inseridos
select * from departments;
  • Você pode chamar procedures usando blocos anônimos;
  • Voce precisa ser dono da procedure ou ter privilégio de EXECUTE;

Exercícios

  1. Crie uma bloco nomeado (procedure), que passado 2 parâmetros do tipo number, (o valor do primeiro parâmetro deve ser menor que o segundo) retorne todos os funcionários código, nome concatenado com o sobrenome, salário e departamento que o salário esteja entre esses dois parametros
  2. Crie um bloco nomeado (procedure), que passado um parâmetro do tipo data, retorne o código, sobrenome, nome, data de admissão e departamento de funcionários, onde a data de admissão seja maior ou igual ao parâmetro passado. O parâmetro deve ser uma data válida;
  3. Crie um bloco nomeado (procedure), que passado um parâmetro do tipo string, retorne o código, nome concatenado com o sobrenome dos funcionários, onde a letra do parâmetro deve ser substituída pela string “STAR”; Exemplo: o usuário passa a letra A, todos as letras do nome e sobrenome QUE CONTENHAM A deve ser substituída por STAR.
  4. Crie um bloco nomeado (procedure), que passado um parâmetro do string, retorne o código e nome concatenado com o sobrenome dos funcionários, onde o nome deve ser iniciado com o parâmetro digitado. Deve-se mostrar quantos caracteres tem o nome e separar cada sílaba com o caracter “-“;
  5. Crie um bloco nomeado que não tenha passagem de parâmetros, que faça a inclusão automática de um departamento cada vez que for acionada; Observação: o nome do departamento pode ser concatenado com outro dado para não se repetir (mesmo que o nome não tenha tanto sentido);
  6. Crie um bloco nomeado que passe um parâmetro do tipo inteiro e outro do tipo string, e que esses parâmetros tenham os valores padrão 100 e ‘IP_PROG’, retornando os registros que tenham o employee_id e job_id iguais aos dos parâmetros passados. Caso o usuário passe valor aos parâmetros, é necessário respeitar o valor passado para se ter maior prioridade. Caso não sejam passados, os parâmetros padrões serão utilizados. Arrume a procedure para que pelo menos se tenha um registro retornado caso não seja passado nenhum parâmetro;

 

Referência:
ORACLE DATABASE 11g PL/SQL Programming
Develop Robust, Database-Driven
PL/SQL Application
Michael McLaughlin – Mc Graw Hill

Vídeo 1

Vídeo 2

 

Banco de Dados II – Aula 06

SUBQUERIES

  • Subqueries são divisões de uma instrução SELECT, a qual estarão separados entre parentes;
  • Servem geralmente para resolver problemas que teriam que ser feitas com 2 consultas;
  • Também utilizada quando um resultado encontrado é base de condição para uma outra consulta;
  • A ordem de execução da SUBQUERY depende de como ela é escrita;
  • Para as SUBQUERIES mais simples, são executadas as mais internas para depois ser executado a mais externa. Esse tipo de subquerie também é conhecida como NÃO-CORRELACIONADA;
  • Há também SUBQUERIES quer dependem tanto da query externa quando interna para ser executada.
  • É quando existe um relacionamento entre as QUERIES, ou seja, para cada linha da query mais externa, depende do resultado de uma linha (ou mais) de uma query mais interna. É também chamada de CORRELACIONADA;
  • Não é necessário utilizar order by em queries mais internas;
  • As subconsultas devem estar entre parênteses;
  • Tome cuidado com subconsultas que retornam várias linhas utilizando operadores que suporte somente uma única linha;
  • Exemplo de um problema que exigiria 2 consultas:
    • Qual(is) funcionário(s) que ganham igual ou mais que o funcionário Bruce do departamento 60?
SELECT    FIRST_NAME,
          SALARY,
          DEPARTMENT_ID
FROM      EMPLOYEES
WHERE     DEPARTMENT_ID = 60;
  • No método tradicional, primeiro precisamos saber o quanto o funcionário Bruce ganha:
SELECT  FIRST_NAME,
        SALARY,
        DEPARTMENT_ID
FROM      EMPLOYEES
WHERE   FIRST_NAME = 'Bruce';
  • Depois de encontrar o valor do salário de Bruce, colocamos o valor na cláusula SELECT:
SELECT    FIRST_NAME,
          SALARY,
          DEPARTMENT_ID
FROM      EMPLOYEES
WHERE     SALARY >= 6000
          AND DEPARTMENT_ID = 60;
  • Podemos resolver da seguinte forma:
SELECT    FIRST_NAME,
          SALARY,
          DEPARTMENT_ID
FROM      EMPLOYEES
WHERE     DEPARTMENT_ID = 60
          AND SALARY >= (SELECT  SALARY
                         FROM    EMPLOYEES
                         WHERE   FIRST_NAME = 'Bruce');

TIPOS DE SUBQUERIES

  • Subqueries podem retornar uma única linha, várias linhas e várias colunas;
  • Quando a subquerie retorna uma única linha, podemos utilizar os operadores =, <, >, <>, <= ou >=;
  • Quando a subquerie retorna várias linhas, temos que utilizar o IN, ALL ou ANY (uma ou mais linhas)
  • As subqueries (internas) podem também utilizar funções de grupo (min, max, avg, …), com isso, a subquerie retornará um única linha;
  • Subqueries são recursos poderosos do comando SELECT, que basicamente podemos ter retornar qualquer informação do banco de dados;
  • Basicamente, é possível utilizar subquerie em qualquer cláusula de uma SELECT;
  • Caso a subconsulta não retorna registros, nenhum valor será retornado para toda a SELECT;

EXEMPLO 1:

SELECT  FIRST_NAME, JOB_ID,SALARY,
        DEPARTMENT_ID
FROM    EMPLOYEES
WHERE   JOB_ID =     (SELECT JOB_ID
                      FROM EMPLOYEES
                      WHERE EMPLOYEE_ID = 111)
        AND SALARY > (SELECT SALARY
                      FROM   EMPLOYEES
                      WHERE  EMPLOYEE_ID = 110);

EXEMPLO 2:

SELECT  FIRST_NAME, JOB_ID,SALARY,
        DEPARTMENT_ID
        FROM    EMPLOYEES
        WHERE   JOB_ID      = (SELECT JOB_ID
                               FROM EMPLOYEES
                               WHERE EMPLOYEE_ID = 111)
                AND SALARY <= (SELECT SALARY
                               FROM   EMPLOYEES
                               WHERE  EMPLOYEE_ID = 110);

EXEMPLO 3

SELECT  FIRST_NAME,         JOB_ID,
        SALARY,         DEPARTMENT_ID
FROM    EMPLOYEES
WHERE   SALARY =  (SELECT MIN(SALARY)
                   FROM   EMPLOYEES);

EXEMPLO 4:

SELECT   JOB_ID, AVG(SALARY)
FROM     EMPLOYEES
GROUP BY JOB_ID
HAVING   AVG(SALARY) = (SELECT  MIN(AVG(SALARY))
                        FROM   EMPLOYEES
                        GROUP BY JOB_ID);

EXEMPLO 5 (ERRO)

SELECT  EMPLOYEE_ID, LAST_ANME
FROM    EMPLOYEES
WHERE   SALARY = (SELECT MIN(SALARY)
                  FROM    EMPLOYEES
                  GROUP BY DEPARTMENT_ID);

EXEMPLO 6 (RETORNO NULO)

SELECT  EMPLOYEE_ID, LAST_NAME
FROM    EMPLOYEES
WHERE   COMMISSION_PCT = (SELECT COMMISSION_PCT
                          FROM    EMPLOYEES
                          WHERE FIRST_NAME = 'Santiago');

SUBQUERIES DE VÁRIAS LINHAS

  • Quando temos em uma Subquerie que retorna várias linhas, temos que verificar qual o operador que podemos utilizar. O operador precisa ser compatível com a quantidade de retorno;
  • Quando temos essa situação, temos que utilizar os operadores IN, ANY e ALL;

EXEMPLO DE IN

SELECT  JOB_ID, FIRST_NAME, SALARY
FROM    EMPLOYEES
WHERE   SALARY IN (SELECT MIN(SALARY)
                   FROM EMPLOYEES
                   GROUP BY JOB_ID)
ORDER BY JOB_ID;

EXEMPLO DE ANY

SELECT    EMPLOYEE_ID,   FIRST_NAME,
          JOB_ID, SALARY
FROM    EMPLOYEES
WHERE   SALARY < ANY (SELECT SALARY
                      FROM EMPLOYEES
                      WHERE JOB_ID = 'IT_PROG')
        AND JOB_ID <> 'IT_PROG'
ORDER BY SALARY DESC;

EXEMPLO DE ALL

SELECT    EMPLOYEE_ID,   FIRST_NAME,
          JOB_ID,   SALARY
FROM      EMPLOYEES
WHERE     SALARY > ALL (SELECT SALARY
                        FROM EMPLOYEES
                        WHERE JOB_ID = 'IT_PROG')
              AND JOB_ID <> 'IT_PROG'
ORDER BY SALARY DESC;

OPERADORES DE CONJUNTO

  • São utilizados geralmente para se fazer a união de duas ou mais queries
  • Trará um único resultado da consulta obtida;
  • Geralmente, precisam ser compatíveis os tipos e quantidade de colunas;
  • Podemos utilizar os seguintes comandos de operadores de conjunto: UNION, UNION ALL, INTERSECT, MINUS;

UNION: Retorna todas as linhas distintas das consultas que estarão envolvidas, precisando ter quantidade de colunas e tipos iguais; UNION ALL: Retorna todas as linhas (inclusive as duplicadas) das consultas que estarão envolvidas, precisando ter quantidade de quantidade de colunas e tipos iguais; Se possível, utilize o UNION ALL ao invés de UNION, pois ele tem mais performance no retorno de dados;

INTERSECT: Retorna todas as linhas das consultas que estarão envolvidas, presentes em ambas consultas (ou demais consultas); MINUS: Retorna todas as linhas que estão na primeira consulta que não estão na segunda consulta;

ORDEM DE EXECUÇÃO DOS OPERADORES

  • Para o ORACLE, não há um operador que tenha prioridade de primeira execução;
  • A ordem padrão de execução é de cima para baixo;
  • A ordem de execução pode ter colocação de prioridade colocando parênteses;

UNION

  • Retorna o resultados de duas ou mais consultas, eliminando resultados repetidos;
  • A repetição de resultados é considerada toda a tupla;
  • Os tipos de dados e quantidade de colunas devem ser os mesmos entre as queries;
  • Não é necessário ter o mesmo nome de colunas entre as queries;
  • Valores duplicados não serão ignorados (o comando irá retirar valores repetidos)
  • O operador IN é executado antes do operador UNION;
  • Será feito um ORDER BY automático da primeira coluna;

EXEMPLO DE UNION

SELECT  EMPLOYEE_ID, JOB_ID
FROM    EMPLOYEES
UNION
SELECT  EMPLOYEE_ID, JOB_ID
FROM    JOB_HISTORY;

UNION ALL

  • Retorna o resultados de duas ou mais consultas, INCLUSIVE resultados repetidos;
  • Possui as mesmas diretivas do UNION;
  • NÃO ordena o resultado pela primeira coluna;
  • O operador DISTINCT não pode ser utilizado;
  • O retorno é mais rápido que a utilização do UNION;

EXEMPLO DE UNION ALL

SELECT  EMPLOYEE_ID, JOB_ID
FROM    EMPLOYEES
UNION ALL
SELECT  EMPLOYEE_ID, JOB_ID
FROM    JOB_HISTORY;

SELECT    EMPLOYEE_ID,
JOB_ID,
DEPARTMENT_ID
FROM    EMPLOYEES

UNION ALL
SELECT    EMPLOYEE_ID,
JOB_ID,
DEPARTMENT_ID
FROM    JOB_HISTORY;

INTERSECT

  • Retorna as linhas que estejam em duas ou mais consultas, ou seja, somente os resultados iguais das consultas são retornados pelo operador;
  • Faz a intersecção dos resultados de todas as consultas;
  • É necessário ter o mesmo número e tipos de colunas;
  • A ordem das consultas não influenciam no resultado;
  • O INTERSECT não ignora valores nulos;

EXEMPLO DE INTERSECT
pre class=”brush: sql; title: ; notranslate” title=””>
SELECT  EMPLOYEE_ID, JOB_ID
FROM    EMPLOYEES
INTERSECT SELECT  EMPLOYEE_ID, JOB_ID
FROM    JOB_HISTORY;

 

MINUS

  • Retorna as linhas da primeira consulta que NÃO estão na segunda consulta;
  • Faz a “subtração” de linhas entre a primeira e segunda consulta;
  • Caso tenha mais de duas consultas, a resolução é feita de cima para baixo;
  • É necessário ter o mesmo número e tipo de colunas nas consultas;
  • A alteração das consultas influencia no resultado final;
  • Todas as colunas da cláusula WHERE precisam estar na cláusula SELECT;
  • EXEMPLO DE MINUS
    SELECT  EMPLOYEE_ID, JOB_ID
    FROM    EMPLOYEES
    MINUS
    SELECT  EMPLOYEE_ID, JOB_ID
    FROM    JOB_HISTORY;
    

  • DIRETRIZES GERAIS

  • Para qualquer operador, o número de colunas e os tipos de dados devem ser equivalentes entre as consultas;
  • A utilização de parênteses altera a sequencia de execução dos operadores;
  • ORDER BY só pode ser usada no final da instrução;
  • ORDER BY aceitará somente os nomes das colunas da primeira consulta ou a notação posição;
  • O nome das colunas são considerados os da primeira consulta;
  • Tuplas duplicadas são eliminadas automaticamente, com exceção de UNION ALL;
  • Por padrão, as saídas são ordenadas em ordem crescente, com exceção de UNION ALL;
  • Quando o número de colunas não são correspondentes entre as consultas, é possível resolver com NULL, ou com uma constante do mesmo tipo equivalente;
  • É possível adicionar uma coluna virtual para ordenação de linhas entre as consultas;
  • EXEMPLO DE TIPOS DE DADOS
    SELECT  DEPARTMENT_ID, NULL AS LOCATION,
    HIRE_DATE
    FROM    EMPLOYEES
    UNION
    SELECT  DEPARTMENT_ID,  LOCATION_ID,
    TO_DATE(NULL)
    FROM    DEPARTMENTS;
    

    EXEMPLO DE ORDEM

    SELECT    DEPARTMENT_ID, HIRE_DATE,
    2 AS ORDEM
    FROM    EMPLOYEES
    UNION
    SELECT    DEPARTMENT_ID,  TO_DATE(NULL),
    1 AS ORDEM
    FROM    DEPARTMENTS
    ORDER BY ORDEM;
    

Banco de Dados II – Aula 05

JOINS

  • Utilizamos JOINS quando precisamos consultar tabelas relacionadas numa única sentença SELECT;
  • Os JOINS são muito utilizados em banco de dados relacionais, pois grande partes das consultas utilizam mais de uma tabela;
  • O ORALCE 11g utiliza o padrão SQL 99, possuindo algumas sintaxes para diferentes tipos de JOINS;

NATURAL JOINS

  • Une duas ou mais tabelas que tenham colunas do mesmo nome e do mesmo tipo;
  • Caso se tenha o tipo de dado diferente, o ORACLE irá retornar um erro;
  • Quando há mais de um campo com o mesmo nome e tipo de dados em tabelas diferentes que estão sendo avaliados pelo NATURAL JOIN, todos esses campos são considerados;
  • Quando utilizamos o USING, NÃO podemos usar ALIAS em nomes de colunas e tabelas
  • EXEMPLO DE NATURAL JOINS
SELECT  *
FROM    EMPLOYEES;

SELECT  *
FROM    DEPARTMENTS;

SELECT  FIRST_NAME, LAST_NAME, DEPARTMENT_NAME
FROM    EMPLOYEES
        NATURAL JOIN DEPARTMENTS
WHERE   DEPARTMENT_NAME IN ('IT','Finance','Sales');

JOIN COM USING

  • Utilizamos USING quando precisamos relacionar uma coluna entre diferentes tabelas (diferente do NATURAL, que irá obrigatoriamente fazer o relacionamento com todas);
  • Quando utilizamos o USING, NÃO podemos usar ALIAS em nomes de colunas e tabelas (DENTRO DO USING);
  • EQUIJOIN é um join interno, a qual é uma alternativa de utilização do USING e NATURAL JOIN, sendo muito utilizado para ligar tabelas com chaves primárias e estrangeiras;
  • Aconselhável utilização de ALIAS, mas não são obrigatórios;
  • ALIAS podem ter até 30 caracteres.
  • Se o ALIAS for especificado, é necessário utilizá-lo em todo comando;
  • EXEMPLO DE USING
SELECT  EMPLOYEES.EMPLOYEE_ID,
        EMPLOYEES.LAST_NAME,
        DEPARTMENTS.LOCATION_ID,
        DEPARTMENT_ID
FROM    EMPLOYEES
        JOIN DEPARTMENTS
            USING (department_id) ;

--ERRO
SELECT  EMPLOYEES.EMPLOYEE_ID,
        EMPLOYEES.LAST_NAME,
        DEPARTMENTS.LOCATION_ID,
        DEPARTMENTS.DEPARTMENT_ID
FROM EMPLOYEES
     JOIN DEPARTMENTS
         USING (department_id) ;

--ERRO
SELECT  E.EMPLOYEE_ID,
        E.LAST_NAME,
        D.LOCATION_ID,
        DEPARTMENT_ID
FROM    EMPLOYEES E
        JOIN DEPARTMENTS D
           USING (D.department_id);

--EQUIJOIN
SELECT L.CITY, D.DEPARTMENT_NAME
FROM   LOCATIONS L
       JOIN DEPARTMENTS D
           USING (LOCATION_ID)
WHERE  LOCATION_ID = 1400;

CLÁUSULA ON

  • Utilizado em conjunto com JOIN;
  • As colunas não precisam ter o mesmo nome entre tabelas, porém precisam ter o mesmo tipo (ou compatibilizar os tipos);
  • Deixa os códigos mais legíveis, comparando com outros comandos de JOIN;
  • Possível fazer SELF-JOIN, quando uma tabela precisa fazer referencia com ela mesma;
  • No SELF-JOIN, é necessário criar um alias na segunda tabela, para que seja possível fazer o auto-relacionamento;
  • É possível utilizar conectores AND ou OR em JOIN’s, possivelmente fazendo o mesmo papel da cláusula WHERE;
  • No padrão SQL 99, JOIN’s são executados da esquerda para a direita;
  • Quando unimos três ou mais tabelas, também são conhecidos como JOIN’s tridimensionais;

EXEMPLO DE CLÁUSULA ON

SELECT  E.EMPLOYEE_ID,
        E.FIRST_NAME,
        E.DEPARTMENT_ID,
        D.LOCATION_ID
FROM EMPLOYEES E
     JOIN DEPARTMENTS D
         ON (E.DEPARTMENT_ID =   D.DEPARTMENT_ID);

EXEMPLO DE SELF-JOIN

SELECT  E.LAST_NAME AS EMP,   M.LAST_NAME AS MGR
FROM    EMPLOYEES E
        JOIN EMPLOYEES M
            ON (E.MANAGER_ID =   M.EMPLOYEE_ID);

EXEMPLO DE RESTRIÇÃO NO ON

SELECT  E.EMPLOYEE_ID,
        E.FIRST_NAME,
        E.DEPARTMENT_ID,
        D.LOCATION_ID
FROM    EMPLOYEES E
        JOIN DEPARTMENTS D
          ON (E.DEPARTMENT_ID = D.DEPARTMENT_ID)
          AND E.MANAGER_ID = 149;

EXEMPLO DE LIGAÇÃO DE 3 TABELAS

SELECT  EMPLOYEE_ID,
        CITY,
        DEPARTMENT_NAME
FROM    EMPLOYEES E
        JOIN DEPARTMENTS D
          ON D.DEPARTMENT_ID = E.DEPARTMENT_ID
        JOIN LOCATIONS L
          ON D.LOCATION_ID = L.LOCATION_ID;

JOIN INTERNOS E EXTERNOS

  • NO EQUI-JOIN são quando temos que utilizar JOIN’s, porém não contém o operador de igualdade;
  • Não são muito utilizados, pois deixam o código menos legível;
  • EXEMPLO
SELECT      E.LAST_NAME,
            E.SALARY,
            J.JOB_TITLE
FROM        EMPLOYEES E
            JOIN  JOBS J
              ON E.SALARY BETWEEN   J.MIN_SALARY
              AND J.MAX_SALARY;
  • Sendo os JOIN’S INTERNOS, o NATURAL JOIN, USING e ON retornam o resultado de apenas linhas iguais entre as tabelas que estão envolvidas;
  • Sendo os JOIN’s EXTERNOS, LEFT, RIGHT e FULL JOIN, servem para retornar resultado que não tenham apenas linhas iguais;

LEFT OUTER JOIN ou LEFT JOIN

  • Retorna todas as linhas que estão na esquerda do JOIN (como se fosse a tabela principal), sem necessariamente ter uma linha correspondente no lado oposto do JOIN;
  • Para melhor visualizar, coloque em uma única linha as tabelas dos lados do JOIN;
  • EXEMPLO DE LEFT OUTER JOIN
SELECT  E.FIRST_NAME,
        E.LAST_NAME,
        E.DEPARTMENT_ID,
        D.DEPARTMENT_NAME
FROM    EMPLOYEES E
        LEFT OUTER JOIN DEPARTMENTS D
          ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;

RIGHT OUTER JOIN ou RIGHT JOIN

    • Retorna todas as linhas que estão na direita do JOIN (como se fosse a tabela principal), sem necessariamente ter uma linha correspondente no lado oposto do JOIN;
    • Para melhor visualizar, coloque em uma única linha as tabelas dos lados do JOIN;
    • EXEMPLO DE RIGHT OUTER JOIN
      SELECT  E.FIRST_NAME,
              E.LAST_NAME,
              E.DEPARTMENT_ID,
              D.DEPARTMENT_NAME
      FROM    EMPLOYEES E
              RIGHT OUTER JOIN DEPARTMENTS D
                ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;

FULL OUTER JOIN OU FULL JOIN

  • Retorna todas as linhas que estão na direita do JOIN e na esquerda do JOIN (ao mesmo tempo);
  • FULL OUTER JOIN é diferente de ter na mesma expressão SQL o LEFT e RIGHT JOIN;
  • EXEMPLO DE FULL OUTER JOIN
SELECT  E.FIRST_NAME,
        E.LAST_NAME,
        E.DEPARTMENT_ID,
        D.DEPARTMENT_NAME
FROM    EMPLOYEES E
        FULL OUTER JOIN DEPARTMENTS D
          ON E.DEPARTMENT_ID = D.DEPARTMENT_ID;

CROSS JOIN

    • Produtos cartesianos são quando todas as linhas da primeira tabela são relacionadas com todas as linhas da segunda tabela;
    • Tem pouca utilização no dia a dia;
    • Pode-se fazer massa de dados para testes, dependendo dos dados que a tabela tenha;
    • Irá retornar a quantidade de linhas resultado da multiplicação do número de linhas das duas tabelas;
    • Pode-se fazer CROSS JOIN com quaisquer tabelas, porém, a combinação dos dados não teria muito sentido;
    • EXEMPLO DE CROSS JOIN
      SELECT  E.FIRST_NAME,
              E.LAST_NAME,
              E.DEPARTMENT_ID,
              D.DEPARTMENT_NAME
      FROM    EMPLOYEES E
              CROSS JOIN DEPARTMENTS D;

 

EXERCÍCIOS

Utilize o schema HR do banco de dados Oracle 11g XE

  1. Selecione o código do departamento, nome do departamento e quantidade de funcionários que trabalham no respectivo departamento;
  2. Selecione o código do departamento, nome do departamento e a média de salário do respectivo departamento;
  3. Selecione o código do serviço (job_id), a descrição do serviço, o maior valor de salário, o menor valor de salário e a média de salário por job_id;
  4. Selecione a soma de todos os salários dos funcionários subordinados à Steven King (inclusive o próprio Steven King)
  5. Selecione o nome e sobrenome dos empregados a qual o seu salário seja maior que a média dos salários do departmamento de TI (IT_PROD)

 

Banco de Dados II – Aula 04

FUNÇÕES DE CONVERSÃO

  • Existem 2 tipos de funções de conversão: implícitas e explícitas;
  • Implícitas o ORACLE converte para o tipo apropriado;
  • Explicitas o usuário faz a utilização manualmente;
  • Sempre que possível, utilizar conversões explícitas;

CONVERSÃO IMPLÍCITAS:

  • O ORACLE automaticamente faz:
    • VARCHAR2 ou CHAR para NUMBER;
    • VARCHAR2 ou CHAR para DATE;
    • NUMBER para VARCHAR2;
    • DATE para VARCHAR2;
  • EXEMPLO:… WHERE NUMERO = ‘25’;… WHERE DATANASC = ’10/23/2000’;

conversoesoracle

http://oracledbagirl.blogspot.com.br/2014/11/funcoes-de-conversao.html

TO_CHAR PARA DATE

  • Tanto TO_CHAR quanto TO_DATE, tem praticamente a mesma formatação;
  • Necessário estar limitado entre aspas simples;
  • É CASE SENSITIVE;

FORMATOS DE DADOS MAIS UTILIZADOS

Formato Significado
YYYY Ano completo com 4 dígitos
YEAR Ano por extenso (em inglês)
MM Mês com 2 dígitos em formato numérico
MONTH Nome do mês por extenso (em inglês)
MON Mês abreviado com 2 dígitos (em inglês)
DY Dia da semana abreviado por extenso (em inglês)
DAY Dia da semana por extenso (em inglês)
DD Dia com 2 dígitos por extenso (em inglês)

OUTROS FORMATOS DE DATAS

Formato Significado
SCC ou CC Acrescenta o A.C. no século
Anos em datas YYYY ou SYYYY Ano; Acrescenta o A.C.
YYY, YY ou Y Últimos 3, 2 ou 1 dígito do ano
Y.YYY Ano com formatação de ponto
IYYY, IYY ou IY Últimos 3, 2 ou 1 dígito do ano no padrão ISSO
SYEAR ou YEAR Ano por extenso, quando tem o S inclui prefixo A.C.
BC ou AD Indica o ano AC ou DC
B.C. ou A.D. Indica o ano A.C. ou D.C. (com pontos)
Q Trimestre do ano
MM Mês com 2 dígitos

OUTROS FORMATOS DE DATAS

 Formato Significado
MONTH Mês por extenso, com 9 dígitos, preenchidos com espaços em branco
MON Mês com abreviação com 3 dígitos
RM Mês em numeral romano
WW ou W Semana do ano ou mês
DDD, DD ou D Dia do ano, do mês ou da semana
DAY Dia por extenso, com 9 dígitos, preenchidos com espaços em branco
DY Dia com abreviação com 3 dígitos
J Dia juliano, desde 31/12/4713 A.C. (número de dias)

FORMATOS DE HORÁRIO

 Formato Significado
AM ou PM Indica o meridiano
A.M. ou P.M. Indica o meridiano com pontos
HH ou HH12 ou HH24 Hora do dia, hora de 1-12 ou hora de 0 a 24
MI Minutos de 0-59
SS Segundos de 0-59
SSSSS Segundos após meia-noite de 0-86399

OUTROS FORMATOS DE DATAS

 Formato Significado
/ , . Pontuação será produzida no resultado
“of the” String será produzida no resultado
TH Numero ordinal (3TH, 4TH)
SP Número por extenso (FOUR, FIVE)
SPTH ou THSP Número ordinal por extenso (FORURTH, FIVETH)

TO_CHAR PARA DATE

  • O formato de data RR é semelhante ao formato YY, porém é específico para distinguir séculos diferentes;
  • Para o século atual, o ORACLE considera os anos de 00 a 49;
  • Para o século anterior, o ORACLE considera os anos de 50 a 99;
  • Exemplos
SELECT SYSDATE FROM DUAL;

SELECT TO_CHAR(SYSDATE,'mm/dd/yyyy') FROM DUAL;

SELECT TO_CHAR(SYSDATE,'dd/mm/yyyy') FROM DUAL;

SELECT TO_CHAR(SYSDATE,'DAY-MONTH-YEAR') FROM DUAL;

SELECT TO_CHAR(SYSDATE,'mm/dd/yyyy HH24:MI:SS') FROM DUAL;

 

alter session set nls_date_format = 'DD-MON-YYYY HH24:MI:SS';

SELECT TO_DATE('01/01/97','DD/MM/YY') FROM DUAL;

SELECT TO_DATE('01/01/97','DD/MM/RR') FROM DUAL;

SELECT TO_DATE('01/01/49','DD/MM/RR') FROM DUAL;

SELECT TO_DATE('01/01/50','DD/MM/RR') FROM DUAL;

select trunc(to_date('27-Jul-1987'),'YYYY') FROM dual;

select trunc(to_date('27-Jul-1987'),'RRRR') FROM dual;

TO_CHAR PARA NÚMEROS

  • O tipo de dados é de NUMBER para VARCHAR2;
  • Muito utilizado para concatenação de dados;
  • O ORACLE também faz conversão implícita de VARCHAR2 para NUMBER, quando possível;
  • Exemplos
SELECT FIRST_NAME, SALARY FROM   EMPLOYEES;

SELECT FIRST_NAME, TO_CHAR(SALARY,'L99999D99') AS SALARY FROM   EMPLOYEES;

SELECT TO_CHAR(1234,'099999') FROM DUAL;

SELECT TO_CHAR(-1234,'9999MI') FROM DUAL;

SELECT TO_CHAR(1234,'S9999') FROM DUAL;

SELECT TO_CHAR(-1234,'S9999') FROM DUAL;

TO_CHAR PARA DATE

  • PRINCIPAIS ELEMENTOS
Caracter Significado
9 Representa um número
0 Impõe a exibição de um zero
$ Insere um sinal de dólar
L Usa o símbolo da moeda local
. Imprime uma casa decimal
, Imprime uma virgula como indicador de milhar
D Retorna caracter especial na posição especificada (por padrão é ,)
MI Sinal de – à direita (valores negativos)

ORDEM DE EXECUÇÃO DAS FUNÇÕES

  • A ordem de execução é feita de dentro para fora, quando existe mais de uma função na mesma expressão;
  • Exemplo
SELECT INITCAP( CONCAT( SUBSTR( UPPER(FIRST_NAME),1,3),'_ORACLE') 
FROM EMPLOYEES

FUNÇÕES COM VALORES NULOS

  • Existem funções que podem fazer o tratamento de campos com valores nulos;
  • O valor NULO não é espaço em branco ou zeros, portanto, precisam ter funções especiais para que sem manipulados corretamente;

Comando NVL

  • Faz a conversão de um valor nulo em outro valor;
  • Sintaxe:
    • NVL(expr1,expr2)
  • Exemplo
SELECT first_name, 
       NVL(commission_pct,0), 
       commission_pct + 12 as "COMISSAO ANUAL" 
FROM   EMPLOYEES;

Comando NVL2

  • Compara se a expressão 1 não for nula, retorna a expressão 2; se a expressão 1 for nula, retorna a expressão 3;
  • Sintaxe:
    • NVL2(expr1,expr2, expr3)
  • Exemplo
SELECT first_name, 
       salary, 
       commission_pct, 
       NVL2(commission_pct, 'SALARIO / COMISSAO','SALARIO') 
FROM   employees;

Comando NULLIF

  • Compara se as duas expressões tem valores iguais. Caso sim retorna o valor NULL, e caso não, retorna o valor da expressão 1;
  • Sintaxe:
    • NULLIF(expr1,expr2)
  • Exemplo
SELECT first_name,
       last_name,
       LENGTH(first_name),   
       LENGTH(last_name),   
       NULLIF(LENGTH(first_name),        
       LENGTH(last_name))
FROM   employees;

Comando COALESCE

  • Retorna o primeiro valor NÃO NULO de uma lista de expressões;
  • Sintaxe:
    • COALESCE(expr1,expr2,expr3,… exprN);
  • Exemplo
SELECT last_name,
       manager_id,
       commission_pct,
       COALESCE(manager_id,
                commission_pct,
                -1)
FROM   employees
ORDER BY commission_pct DESC;

EXPRESSÕES CONDICIONAIS

  • Permitem utilizar IF.. THEN.. ELSE nas expressões SQL;
  • Podemos utilizar o CASE (padrão ANSI) e o DECODE (exclusivo do ORACLE)

Comando CASE

  • Praticamente tem a mesma função de expressões condicionais nas demais linguagens de programação (IF … THEN…ELSE)
  • Sintaxe do Comando CASECASE expr1WHEN comp_expr1 THEN retorno_expr1
    WHEN comp_expr2 THEN retorno_expr2
    WHEN comp_expr3 THEN retorno_expr3
    ELSE retorno_else
    END;
    
  • Exemplo de CASE
SELECT last_name, job_id, salary,
       CASE job_id
         WHEN 'IT_PROG' THEN salary * 1.20
         WHEN 'ST_CLERCK' THEN salary * 1.30
         WHEN 'SA_REP' THEN salary * 1.50
         ELSE salary
       END "NOVO SALARIO"
FROM   employees;

Comando DECODE

  • É uma versão simplificada do CASE (em termos de parâmetros), tendo a mesma finalidade;
  • Sintaxe: DECODE (expr1, busca1, resultado1, busca2, resultado2, …, retorno_default);
  • Exemplo
SELECT last_name, job_id, salary,
       DECODE (job_id, 'IT_PROG', salary * 1.20,
       'ST_CLERCK', salary * 1.30,
       'SA_REP', salary * 1.50,
       salary) "NOVO SALARIO"
FROM   employees;

FUNÇÕES DE GRUPO

  • Geralmente são utilizados para obter resultados sumarizados (resultados agrupados);
  • Pode ser aplicado na tabela inteira, ou em um determinado grupo;
  • Utiliza-se a função de grupo na sentença SELECT;
  • Na cláusula GROUP BY é onde será a determinação de qual dado será agrupado;

COMANDO AVG

  • Retorna a média aritmética de um determinado campo dividido pelo número de linhas de retorno da tabela;
  • Sintaxe: AVG([DISTINCT | ALL] n)
  • EXEMPLO DE COMANDO AVG
SELECT  AVG(SALARY)
FROM    EMPLOYEES;

SELECT  AVG(COMMISSION_PCT)
FROM    EMPLOYEES;

SELECT  AVG(NVL(COMMISSION_PCT,0))
FROM    EMPLOYEES;

COMANDO COUNT

  • Retorna o número de linhas ou quantidade de campos não nulos de uma tabela;
  • Sintaxe: COUNT(* | DISTINCT | ALL expr)
  • EXEMPLO DE COMANDO COUNT
SELECT  COUNT(*)
FROM    EMPLOYEES;

SELECT  COUNT(COMMISSION_PCT)
FROM    EMPLOYEES;

SELECT COUNT(DISTINCT JOB_ID)
FROM   EMPLOYEES;

COMANDO MAX

  • Retorna o valor máximo da expressão, ignorando os valores nulos;
  • Sintaxe: MAX([DISTINCT | ALL] expr)
  • EXEMPLO COMANDO MAX
SELECT    MIN(START_DATE),   MAX(START_DATE)
FROM      JOB_HISTORY;

COMANDO MIN

  • Retorna o valor mínimo da expressão, ignorando os valores nulos;
  • Sintaxe: MIN([DISTINCT | ALL] expr)
  • EXEMPLO COMANDO MIN E MAX
SELECT    MIN(FIRST_NAME),   MAX(FIRST_NAME)
FROM      EMPLOYEES;

COMANDO SUM

  • Retorna a soma de valores de uma expressão, ignorando os valores nulos;
  • Sintaxe: SUM([DISTINCT | ALL] expr)
  • EXEMPLO DE COMANDO SUM
SELECT  SUM(SALARY)
FROM      EMPLOYEES;

COMANDO STDDEV

  • Retorna o desvio padrão, ignorando os valores nulos;
  • Sintaxe: STDDEV([DISTINCT | ALL] expr)

COMANDO VARIANCE

  • Retorna a variação, ignorando os valores nulos;
  • Sintaxe: VARIANCE([DISTINCT | ALL] expr)

FUNÇÕES DE GRUPO COM AGRUPAMENTO

  • O agrupamento irá fazer com que dados sejam agrupados e geralmente terá uma função de grupo associada;
  • A cláusula GROUP BY precisa estar na sentença do comando SQL, contendo todos os campos que estão no SELECT, menos as próprias funções de grupo;
  • O agrupamento deve ser aplicado a dados que tenham repetição, ou que se consiga fazer operações matemáticas;
  • Não há muito sentido em fazer agrupamentos, por exemplo em campos que são chave primária, pois o conteúdo nunca se repete;
  • Os resultados retornarão uma ou mais linhas, com resultados sumarizados;
  • Não é possível utilizar apelidos das colunas na cláusula GROUP BY.
  • EXEMPLOS DE GROUP BY
SELECT    JOB_ID, COUNT(*)
FROM      EMPLOYEES
GROUP BY  JOB_ID
ORDER BY  COUNT(*) DESC;

SELECT    DEPARTMENT_ID, SUM(SALARY)
FROM      EMPLOYEES
GROUP BY  DEPARTMENT_ID
ORDER BY  DEPARTMENT_ID NULLS FIRST;

SELECT    DEPARTMENT_ID, AVG(SALARY)
FROM      EMPLOYEES
GROUP BY  DEPARTMENT_ID

SELECT    DEPARTMENT_ID, MAX(SALARY)
FROM      EMPLOYEES
GROUP BY  DEPARTMENT_ID;

SELECT    DEPARTMENT_ID, MIN(SALARY)
FROM      EMPLOYEES
GROUP BY  DEPARTMENT_ID;

FUNÇÕES DE GRUPO COM HAVING

  • A cláusula HAVING sempre será utilizada com GROUP BY;
  • Ela serve para fazer limitação de linhas, a qual é aplicada no GROUP BY;
  • Dê preferencia para fazer limitações de linhas sempre que possível na cláusula WHERE;
  • A sequencia que o ORACLE executa um comando SQL quando se tem um HAVING:
    • 1 – As linhas agrupadas;
    • 2 – A função de grupo é aplicada;
    • 3 – os grupos filtradas na cláusula HAVING são exibidos;
  • A ordem de função de grupo tem a mesma ordem das outras funções, ou seja, funções mais internas são executadas primeiro;
  • É possível ter no máximo 2 funções de grupos na mesma sentença;
  • EXEMPLO DE HAVING
SELECT    DEPARTMENT_ID, MAX(SALARY)
FROM      EMPLOYEES
GROUP BY  DEPARTMENT_ID
HAVING    MAX(SALARY) > 10000;

SELECT    DEPARTMENT_ID, AVG(SALARY)
FROM      EMPLOYEES
GROUP BY  DEPARTMENT_ID
HAVING    MAX(SALARY) > 10000;

SELECT    JOB_ID, SUM(SALARY)
FROM      EMPLOYEES
GROUP BY  JOB_ID
HAVING    SUM(SALARY) > 10000
ORDER BY  SUM(SALARY);

SELECT  MAX(AVG(SALARY))
FROM   EMPLOYEES
GROUP BY DEPARTMENT_ID;

SELECT  SUM(AVG(SALARY))
FROM   EMPLOYEES
GROUP BY JOB_ID;

 

Vídeo 01

Vídeo 02

Banco de Dados II – Aula 03

VARIÁVEIS DE SUBSTITUIÇÃO

  • Geralmente utilizadas para executar uma instrução SELECT mais de uma vez;
  • Servirá como se fosse parâmetro;
  • Somente utilizadas na cláusula WHERE, com o símbolo : (para apex);
  • O símbolo & para sqlplus, pode ser utilizado em mais cláusulas;
  • As variáveis de substituição servem para guardar temporariamente valores;
  • EXEMPLOS
Exemplo 01
SELECT 	* 
FROM 	employees
WHERE 	employee_id = :employee_id;

Exemplo 02
SELECT 	* 
FROM 	employees
WHERE	first_name = :first_name
    		AND salary >= :salary;
 

Exemplo 03
SELECT * 
FROM employees
WHERE last_name like '&last_name';

SELECT * 
FROM &tabela

(no SQLDeveloper, pressione  + , e ele pedirá o valor a ser digitado)

FUNÇÕES DE LINHAS

  • Podem ser utilizadas para tipos de dados character, data, números em uma instrução SELECT;
  • Funcionam como conversão, formatação de dados (datas e números), manipulam strings, podem ter ou não dados de entrada (ou parâmetros), mas sempre possuem dados de saída;
  • As maioria das funções apresentadas aqui são do Oracle;
  • Possuem 2 tipos:
    • por Linha: só retornam um resultado por linha (funções de character, número, data e conversão);
    • de Grupo: manipulam grupos de linhas para retornar apenas um resultado;
  • Caracteristicas das functions de linha;
    • Podem receber argumentos (podendo ser uma constant, variável, nome de coluna, expressão);
    • Podem ser usados na cláusulas SELECT, WHERE, ORDER BY;
    • Podem ser encadeadas;
    • Funções de data: entradas do tipo DATE e retornam um tipo DATE, exceto MONTHS_BETWEEN, que retorna um tipo número;
    • Funções numéricas: entradas do tipo NUMERIC e retornam um tipo NUMERIC;
    • Funções de character: entrada do tipo caracteres e retornam caracteres ou numeros;
    • Funções de conversão: convertem um tipo de dado em outro;
    • Outras funções: NVL, NVL2, NULLIF, COALESCE, CASE, DECODE;

FUNÇÕES DE LINHAS – CARACTERES

  • Manipulação de caixa alta e baixa (maiúsculo e minúsculo):
    • UPPER: retornar todos os valores em letras maiúsculas;
    • LOWER: retornar todos os valores em letras minúsculas;
    • INITCAP: a primeira letra de cada palavra em maiúscula e o restante minúsculas;
  • Manipulação de caracter:
    • CONCAT: Une dois valores;
    • SUBSTR: Extrai uma string de determinado tamanho;
    • LENGTH: Retorna o tamanho de uma string em um valor numérico;
    • INSTR: Localiza uma posição numérica de um character nomeado;
    • LPAD: Preenche com valor do character à esquerda;
    • RPAD: Preenche com valor do character à direita;
    • TRIM: Retira caracteres em branco à direita e à esquerda de uma string;
    • Exemplos
SELECT  UPPER('rodrigo saito') 
FROM    DUAL;

SELECT  LOWER('RODRIGO SAITO') 
FROM    DUAL;

SELECT  INITCAP('rodrigo saito') 
FROM    DUAL;

SELECT  CONCAT('Rodrigo','Saito') 
FROM    DUAL;

SELECT  SUBSTR('Teste de caracteres no Oracle',1,5) 
FROM    DUAL;

SELECT  SUBSTR('Teste de caracteres no Oracle',6) 
FROM    DUAL;

SELECT  LENGTH('Teste de caracteres no Oracle') 
FROM    DUAL;

SELECT  INSTR('Teste de caracteres no Oracle','s') 
FROM    DUAL;

SELECT  LPAD('Teste de caracteres no Oracle',40, '0')
FROM    DUAL;

SELECT  RPAD('Teste de caracteres no Oracle',40, '0')
FROM    DUAL;

SELECT REPLACE('rodrigo anchieta', 'anchieta', 'saito')
FROM DUAL;

SELECT TRIM('R' FROM 'RODRIGO') 
FROM DUAL;

FUNÇÕES DE NÚMEROS

  • Tem como entrada dados do tipo numérico e sempre retornam dados do tipo numérico;
  • ROUND: arredonda o valor para cima (caso o decimal seja maior que 5);
  • TRUNC: retorna o valor a ser truncado;
  • MOD: retorna o resto da divisão;

ROUND

  • SINTAXE: ROUND(VALOR,N): N é opcional, sendo o número de casas decimais a ser definido;
  • Exemplos
SELECT ROUND(10.5) 
FROM DUAL;

SELECT ROUND(10.5,1) 
FROM DUAL;

SELECT ROUND(10.51,1) 
FROM DUAL;

SELECT ROUND(10.55,1) 
FROM DUAL;

SELECT ROUND(10.60,1) 
FROM DUAL;

SELECT ROUND(10.554,2) 
FROM DUAL;

SELECT ROUND(10.555,2) 
FROM DUAL;

TRUNC

  • SINTAXE: TRUNC(VALOR,N): N é opcional, sendo o número de casas decimais a ser definido. O comando basicamente irá cortar o número definido;
  • Exemplos
SELECT TRUNC(10.1) FROM DUAL;

SELECT TRUNC(10.1,1) FROM DUAL;

SELECT TRUNC(10.15,1) FROM DUAL;

SELECT TRUNC(10.155,2) FROM DUAL;

SELECT TRUNC(10.155,-1) FROM DUAL;

SELECT TRUNC(10.155,-2) FROM DUAL;

SELECT TRUNC(100.155,-2) FROM DUAL;

MOD

  • SINTAXE: MOD(M,N): M PRIMEIRO VALOR, E N é o segundo valor. O comando retornar o resto de M por N.
  • Exemplos
SELECT MOD(10,2) FROM DUAL;

SELECT MOD(10,3) FROM DUAL;

SELECT MOD(11,3) FROM DUAL;

SELECT MOD(19,5) FROM DUAL;

FUNÇÕES DE DATA

  • Datas são armazenadas internamente em formato numérico, tendo a representação de século, ano, mês, dia, hora, minuto e segundos;
  • Padrão do Oracle é MM/DD/YYYY;
  • Data válidas são 01/01/4712 A.C. a 31/12/9999 D.C.;
  • Na inserção do dado do tipo data em um campo, internamente o Oracle armazena o século da função SYSDATE, nas para exibição esse dado é ocultado por padrão;
  • Date armazena internamente 4 dígitos para o ano (dois dígitos para século e dois dígitos para ano);
  • Apesar da exibição ser de 2 dígitos para o ano, internamente são 4 dígitos;
  • De 1951 a 2050 mostra os 2 últimos dígitos do século atual;

SYSDATE

  • Retorna a data e horário do século atual, podendo ser usado em qualquer coluna.
  • É possível utilizar na tabela de sistema DUAL;\
  • Exemplo
select SYSDATE from DUAL

(será exibido por padrão somente a data)

SELECT SYSDATE + 5 FROM DUAL;

SELECT SYSDATE - 5 FROM DUAL;

SELECT SYSDATE - (SYSDATE - 10) FROM DUAL;

SELECT SYSDATE - TO_DATE('01/01/2015','mm/dd/yyyy') FROM DUAL;

select TO_CHAR(sysdate,'mm/dd/yyyy hh:mi') from dual;

SELECT TO_CHAR(SYSDATE,'dd/mm/yyyy hh24:mi') FROM DUAL;

SELECT TO_CHAR(TO_DATE('01/01/2016 09:01','dd/mm/yyyy hh24:mi'),'dd/mm/yyyy hh24:mi') FROM DUAL;

SELECT TO_CHAR(TO_DATE('01/01/2016 09:01','dd/mm/yyyy hh24:mi') + 1/24,'dd/mm/yyyy hh24:mi') FROM DUAL;

SELECT TO_CHAR(TO_DATE('01/01/2016 09:01','dd/mm/yyyy hh24:mi') + 3/24,'dd/mm/yyyy hh24:mi') FROM DUAL;

SELECT TO_CHAR(TO_DATE('01/01/2016 09:01','dd/mm/yyyy hh24:mi') + 1/(24*60),'dd/mm/yyyy hh24:mi') FROM DUAL;

SELECT TO_CHAR(TO_DATE('01/01/2016 09:00:00','dd/mm/yyyy hh24:mi:ss') + 20/(24*60*60),'dd/mm/yyyy hh24:mi:ss') FROM DUAL;

SELECT TO_CHAR(SYSDATE + 20/(24*60*60),'dd/mm/yyyy hh24:mi:ss')  FROM DUAL;

SELECT TO_CHAR(SYSDATE,'dd/mm/yyyy hh24:mi') FROM DUAL;

CALCULOS DE DIAS COM DATA

  • É possível fazer adição e subtração de dias em datas, além de fazer a diferença de dias entre datas, considerando os dias, meses e anos;
  • Para se fazer operações com horas, é necessário dividir um dia pela quantidade de horas (ou seja, 24);
  • Para se fazer operações com minutos, é necessário saber o quanto 1 minuto representa em 1 dia (1440);

OUTRAS FUNÇÕES DE DATA

  • Tem como entrada de parâmetros do tipo data e retornam valores do tipo data ou numérico;

MONTHS_BETWEEN(data1,data2)

  • Retorna o número de meses entre as datas do parâmetro;
  • Exemplos
SELECT MONTHS_BETWEEN( TO_DATE('01/01/2016'), TO_DATE('01/01/2015')) FROM DUAL;

SELECT MONTHS_BETWEEN(SYSDATE, TO_DATE('01/01/2015')) FROM DUAL;

ADD_MONTHS(data1,n)

  • Retorna uma data, adicionando a quantidade de meses especificadas no parâmetro em data1;
  • Exemplos
SELECT ADD_MONTHS(SYSDATE, 3) FROM DUAL;

SELECT SYSDATE + 90 FROM DUAL;

NEXT_DAY (data1,numeric)

  • Retorna o próximo dia da semana, sendo representando pelos números de 1 a 7 (1 é domingo a 7 que é sábado);
  • Exemplos
SELECT NEXT_DAY(SYSDATE,1) FROM DUAL;

SELECT NEXT_DAY(SYSDATE,4) FROM DUAL;

SELECT NEXT_DAY(SYSDATE,-3) FROM DUAL;

LAST_DAY (data1)

  • Retorna o último dia do mês especificado;
SELECT LAST_DAY(SYSDATE) FROM DUAL;

SELECT LAST_DAY(TO_DATE('05/04/2015')) FROM DUAL;

ROUND (data1[,valor])

  • Retorna uma data arredondada, sendo o parâmetro valor opcional, e o padrão equivalente ao parâmetro ‘day’;
  • Exemplos
SELECT ROUND(SYSDATE) FROM DUAL;

SELECT ROUND(SYSDATE,'DAY') FROM DUAL;

SELECT ROUND(SYSDATE,'MONTH') FROM DUAL;

SELECT ROUND(SYSDATE,'YEAR') FROM DUAL;

SELECT ROUND(TO_DATE('01/15/2016 11:59:00','mm/dd/yyyy hh24:mi:ss')) FROM DUAL;

SELECT ROUND(TO_DATE('01/15/2016 12:01:00','mm/dd/yyyy hh24:mi:ss')) FROM DUAL;

SELECT ROUND( TO_DATE('01/15/2016','mm/dd/yyyy'),'MONTH') FROM DUAL;

SELECT ROUND( TO_DATE('01/16/2016','mm/dd/yyyy'),'MONTH') FROM DUAL;

SELECT ROUND(TO_DATE('06/30/2016','mm/dd/yyyy'),'YEAR') FROM DUAL;

SELECT ROUND(TO_DATE('07/01/2016','mm/dd/yyyy'),'YEAR') FROM DUAL;

TRUNC (data1[,valor])

  • Retorna uma data truncada (cortada), sendo o parâmetro valor opcional;
  • Exemplos
SELECT TRUNC(SYSDATE) FROM DUAL;

SELECT TRUNC(SYSDATE,'DAY') FROM DUAL;

SELECT TRUNC(SYSDATE,'MONTH') FROM DUAL;

SELECT TRUNC(SYSDATE,'YEAR') FROM DUAL;

SELECT TRUNC( TO_DATE('07/15/2016', 'mm/dd/yyyy')) FROM DUAL;

SELECT TRUNC( TO_DATE('07/15/2016', 'mm/dd/yyyy'),'MONTH') FROM DUAL;

SELECT TRUNC(TO_DATE('07/15/2016', 'mm/dd/yyyy'),'YEAR') FROM DUAL;

Vídeo 1

Vídeo 2

Banco de Dados II – Aula 02

LINHAS DUPLICADAS

  • Geralmente, o problema de linhas duplicadas (ou valores duplicados) no retorno da instrução SELECT deve-se à má modelagem de dados;
  • O ideal seria que não existissem valores duplicados em tabelas;
  • Podemos utilizar o commando DISTINCT para fazer a distinção desses valores;
  • Utilizamos quando temos valores repetidos entre as tuplas;
  • Não se coloca geralmente a chave primária na cláusula SELECT;
  • O DISTINCT é aplicado para todas as colunas na cláusula SELECT;
  • SINTAXE:
SELECT   DISTINC [NOME_COLUNA]
FROM   [NOME_TABELA]
  • EXEMPLO:
SELECT   DISTINCT DEPARTMENT_ID
FROM     employees

SELECT   DISTINCT DEPARTMENT_ID,   JOB_ID
FROM     employees
  • Aconselhado utilizar somente para análise de dados;
  • É um comando que consome muito processamento;
  • O uso intensivo pode causar degradação do processador;

RESTRINGINDO E CLASSIFICANDO DADOS

A CLÁUSULA WHERE SERVE PARA:

  • Limitar linhas recuperadas de uma consulta;
  • Aconselhado sempre utilizar o que for possível para se fazer os filtros de retorno de linhas;
  • É especificado após a cláusula FROM;
  • Suporta comparer colunas, literais, variáveis, expressões aritméticas ou funções;
  • É necessário ter: o nome_da_coluna, condição_de_comparação; Nome_da_coluna, constant ou lista de valores;
  • É opcional na SELECT, porém aconselhável utilizar;
  • Caso não seja utilizada, é tornado todas as linhas da tabela, podendo causar grande lentidão no retorno de dados;
  • EXEMPLO:
  • SELECT  * FROM  employees (será retornado todas linhas da tabela employees)
  • EXEMPLO:
  • SELECT  *FROM  employeesWHERE  department_id = 60;(será retornado somente as linhas que contém o department_id = 60)

CONDIÇÕES DE COMPARAÇÃO

  • Servem para fazer comparações de valores dentro da cláusula WHERE;
  • Os possíveis operadores que podem ser utilizados: =, >, =, <=, ou !=, BETWEEN AND, IN, LIKE, IS NULL
  • SINTAXE:Geralmente é utilizado:… WHERE [campo] [operador] [valor];
  • Podendo ser também:… WHERE [valor] [operador] [campo]; ou… WHERE [valor] [operador] [valor]; ou… WHERE [campo] [operador] [campo]; etc
  • EXEMPLOS:… WHERE job_id = ‘AD_VP’… WHERE1000 >= salary;… WHERE department_id != 80;… WHERE hire_date  < ’17-jun-03’;
  • BETWEEN
    • Serve para retornar linhas entre faixas de valores;
    • Os dados podem ser do tipo, numérico, data e caracteres;
    • Substitui as comparações “>= AND <=“
    • EXEMPLO:…WHERE employee_idBETWEEN 1 AND 200;seria o mesmo que:…WHERE employee_id >= 1AND employee_id <= 200;
    • EXEMPLO:…WHERE hire_date BETWEEN’15-JAN-03’ AND ’30-JAN-03’;… WHERE last_name BETWEEN‘A’ AND ‘E’;
  • CONDIÇÃO IN
    • Retorna os valores que estão dentro da lista do IN;
    • Pode ser usado por qualquer tipo de dado;
    • Substitui os comandos [CAMPO1] = [VALOR1] OR [CAMPO1] = [VALOR2] OR …;
    • EXEMPLO:SELECT  first_name, last_nameFROM   employeesWHERE   first_name IN (‘Steven’,’Neena’);
    • EXEMPLO:SELECT  first_name, last_name, employee_idFROM   employeesWHERE   employee_id IN (1, 100, 200, 300);
  • A CONDIÇÃO LIKE:
    • Serve para retornar linhas que sejam parecidas (fazendo parte) com a string desejada;
    • Geralmente usado quando não sabemos exatamente o que estamos procurando, mas sabemos pelo menos parte da string;
    • Possui 2 símbolos (coringas) que geralmente são utilizados em conjunto com o LIKE:
    • % –> representado por zero ou mais caracteres;
    • _ –> representado por um character;
    • Quando queremos procurar uma string que contenha um dos símbolos coringa, temos que utilizar a opção ESCAPE;
    • EXEMPLO:SELECT  first_name, last_nameFROM  employeesWHERE  first_name LIKE ‘A%’(retorna todos os first_name iniciados com A)
    • EXEMPLO:SELECT  first_name, last_nameFROM  employeesWHERE  last_name LIKE ‘%a’(retorna todos os last_name terminados com A)
    • EXEMPLO:SELECT  first_name, last_nameFROM  employeesWHERE  last_name LIKE ‘%th%’(retorna todos os last_name que tenham “th” em qualquer parte da string)
    • EXEMPLO:SELECT  first_name, last_nameFROM  employeesWHERE  first_name LIKE ‘_t%’(retorna todos os first_name que tenham qualquer character na primeira posição da string, contenham “t” na segunda posição da string e que terminem com qualquer caracter)
    • EXEMPLO:SELECT  first_name, last_name, job_idFROM  employeesWHERE  job_id LIKE ‘IT\_%’ ESCAPE ‘\’;(retorna todos os job_id tenham IT_ no inicio e terminem com qualquer/quaisquer character(es). O _ após o símbolo \ está sendo interpretado como um character comum, e não um character coringa)
  • CONDIÇÕES NULL
    • Não é possível utilizar = ou para se comparar NULL;
    • Utiliza-se IS NULL ou IS NOT NULL;
    • EXEMPLO:… WHERE commission_pct IS NOT NULL;… WHERE hire_date IS NULL;… WHERE phone_number IS NOT NULL;

OPERADORES LÓGICOS E REGRAS DE PRECEDÊNCIA

OPERADORES LÓGICOS

  • Combina duas ou mais condições na cláusula WHERE;
  • O retorno da SELECT será sempre o resultado verdadeiro;
  • São eles: AND, NOT e OR;

OPERADOR AND

  • Significa E;
  • Retornará linhas na SELECT se todas as condições forem verdadeiras;
  • Uma única condição falsa invalída esse operador;
  • EXEMPLO DE ANDSELECT   *FROM   employeesWHERE   salary >= 5000AND job_id = ‘AC_ACCOUNT’;

OPERADOR OR

  • Significa OU;
  • Retornará linhas na SELECT se todas ao menus uma condição for verdadeiras;
  • Uma única condição falsa talvez não invalíde esse operador;
  • EXEMPLO DE ANDSELECT   *FROM   employeesWHERE   salary >= 5000OR job_id = ‘AC_ACCOUNT’;

OPERADOR NOT

  • Significa NÃO;
  • Utiliza em conjunto com as condições de comparação BETWEEN, LIKE, IS NULL e IN;
  • O operador irá retornar o que NÃO for atendido pela condição dada na SELECT;
  • Pode ser interpretado como: o que não estiver em (IN), o que não estiver entre (BETWEEN), o que não for como (LIKE);
  • EXEMPLO DE NOTSELECT   *FROM   employeesWHERE   first_name NOT LIKE ‘Bruce’;SELECT   *FROM   employeesWHERE   job_id NOT IN   (‘IT_PROG’,’AD_VP’,’FI_ACCOUNT’);
  • EXEMPLO DE NOTSELECT   *FROM   employeesWHERE   salary NOT BETWEEN5000 AND 20000;
  • EXEMPLO DE NOTSELECT   *FROM   employeesWHERE   NOT salary  > 10000;

ORDEM DE PRECEDÊNCIA DE OPERADORES

  • Obedecem a sequencia na instrução SELECT que será resolvida as expressões;
  • Pode ser sobreposta a ordem com parenteses;
  • As expressões são resolvidas da esquerda para a direita;

ScreenHunter_316 Feb. 26 00.02

  • EXEMPLO DE ORDEM DE PRECEDÊNCIA:
  • SELECT   *FROM   employeesWHERE   salary  > 5000AND job_id = ‘IT_PROG’;
  • SELECT   *FROM   employeesWHERE   job_id = ‘IT_PROG’OR job_id = ‘SA_MAN’;
  • SELECT   *FROM   employeesWHERE   first_name = ‘Bruce’OR manager_id = 100AND job_id = ‘SA_MAN’;

CLÁUSULA ORDER BY

  • Serve para ordenar as linhas recuperadas;
  • O padrão é ordem crescente (ascendente);
  • A ordenação é a última cláusula de uma SELECT a ser executada;
  • Podem ser usados ASC (opcional), pois é o padrão, ou DESC (descendente) em conjunto com a cláusula ORDER BY;
  • Pode ser utilizado para ser ordenado mais de uma coluna, inclusive de diferente ordens na mesma instrução;
  • EXEMPLOS DE ORDER BY
  • SELECT   first_name,last_name,job_idFROM   employeesORDER BY   first_name;
  • SELECT   first_name,last_name,job_idFROM   employeesORDER BY   last_name DESC;
  • SELECT   first_name,last_name,job_idFROM   employeesORDER BY   first_name ASC,last_name DESC;

Vídeo 01

Video 02

Banco de Dados II – Aula 01

REVISÃO DE INSTRUÇÕES BÁSICAS DO COMANDO SELECT

SELECT POSSUI 3 RECURSOS BASICAMENTE:

  • PROJEÇÃO: Escolha das colunas que serão retornadas;
  • SELEÇÃO: Limitação de linhas que irão ser retornados;
  • JOIN: Junção entre tabelas de acordo com o modelo relacional;

SELECT BÁSICO PARA O ORACLE:

SELECT [NOME_DA_COLUNA]
FROM   [NOME_DA_TABELA]

(Obrigatório ter uma tabela para retorno)

INSTRUÇÕES BÁSICAS DO COMANDO SELECT

  • Ao utilizar o caracter “*” após o comando SELECT, será retornado todas as colunas da tabela;
  • Caso esteja utilizando JOIN, será retornado todas as colunas de todas as tabelas;

SELECIONANDO COLUNAS ESPECÍFICAS

  • Necessário declarar dentro do SELECT
SELECT [NOME_COL1], [NOME_COL2], …
FROM   [NOME_TABELA];

INSTRUÇÕES SELECT

  • NÃO SÃO CASE-SENSITIVE;
  • Os dados SÃO CASE-SENSITIVE;
  • Podem ocupar uma ou mais linhas;
  • Para melhor indentação, as cláusulas são colocadas em linhas diferentes;
  • Para o iSQL-Plus, o terminador é “;” (opcional) para um único comando;
  • Para o SQL-Plus, o terminador é “;” (obrigatório)

FORMATAÇÃO SUGESTIVA

SELECT   [NOME_COL1],
         [NOME_COL2],
         [NOME_COL3], …
FROM     [NOME_TABELA]
WHERE    [CONDIÇÃO1]
         AND  [CONDIÇÃO2]
         OR  [CONDIÇÃO3];

EXPRESSÕES ARITMÉTICAS

  • Podemos utilizar os operadores aritméticos dentro da instrução SELECT, basicamente para manipular dados do tipo numéricos e datas;
  • Basicamente são:
    • + –>  soma
    • – –> subtração
    • * –> multiplicação
    • / –> divisão
  • Utilizado para modificar (em uma SELECT, somente em visualização) os dados no retorno de uma SELECT;
  • Podem ser utilizadas na cláusula SELECT, WHERE, ORDER BY, GROUP BY (EXCETO na cláusula FROM)EXEMPLO DE UTILIZAÇÃO
SELECT   first_name,
         salary,
         salary + 300                    --> CAMPO VIRTUAL
FROM     employees;

ORDEM DOS OPERADORES

  • Caso ocorra de uma expressão aritmética conter vários operadores, a ordem é seguida pela regra matemática;
    • * e / –> primeira procedência;
    • + e – –> segunda procedência;
    • Operadores com a mesma prioridade, a operação é resolvida da esquerda para a direita;
    • Pode-se inverter a prioridade dos operadores utilizando os simbolos parênteses “(” e “)”;
    • EXEMPLOS
      10 + 300 / 50 = 16
      (10 + 300) / 50 = 6,2
      200 + 300 / 5 *4 = 440
      (200 + 300) / 5 * 4 = 400

 VALORES NULOS

  • É diferente do valor 0 (zero);
  • É diferente de “ ” (espaço em branco);
  • É a ausência total de um dado;
  • Não conseguimos fazer operações (soma, multiplicação, divisão) com valores nulos;
  • Qualquer tipo de dado pode ser nulo;
  • É possível impeder valores nulos com CONSTRAINTS (restrições);
  • As CONSTRAINTS são PRIMARY KEY e NOT NULL;
  • O ideal seria que não existisse valores nulos em nenhum campo, porém maioria das regras de negócio impedem essa teoria;
  • A utilização de campos com valores nulos em expressões aritméticas resultará em nulo;
  • Mesmo em tipos de variáveis booleanas, o nulo não pode ser comparado, ou seja, um valor nulo é diferente de TRUE e FALSE;

ALIAS

    • É um apelido que podemos dar para uma coluna, ou seja, renomeamos em tempo de execução os nomes de colunas para melhor serem apresentados ao usuário;
    • Utilizado geralmente em colunas que contém cálculo;
    • O ALIAS NÃO altera o nome real da coluna que está na tabela;
    • Coloca-se o ALIAS depois do nome da coluna e antes da virgula (que separa colunas na cláusula SELECT), opcionalmente com a palavra “AS”;
    • Em caso do alias precisar utilizer espaço em branco ou caracteres especiais (“#” ou “$”), é necessário colocar entre aspas duplas (“ ”);
    • EXEMPLO:
      SELECT  first_name AS Nome,
      salary * 12 "Salario Anual",   --> CONTÉM UM ESPAÇO NO TEXTO ENTRE ASPAS
      last_name as “sobre#nome”
      FROM   employees;

CONCATENAÇÃO

  • Serve para fazer a junção de colunas com outras colunas, e/ou variáveis, e/ou constantes;
  • É criado uma coluna virtual, que o retorno será uma string, resultando uma única coluna;
  • Concatentando uma string com nulo, o resultado será somente a string;
  • Utilize os caracteres PIPE “||” entre as colunas ou os valores que se deseja concatenar;
  • Pode-se concatenar campos com diferentes tipos (aconselhado fazer cast de dados para string);
  • EXEMPLO:
SELECT  first_name || ' ' || last_name
        AS NOME_COMPLETO
FROM    employees;

STRING / LITERAIS

  • É um campo de qualquer tipo (número, string, data) concatenado com uma string de uma SELECT;
  • Campos do tipo caractere ou data é necessário utilizar aspas simples;
  • Cada string de caractere é retornada em todas as linhas retornadas da SELECT;

DELIMITADORES

      • Quando queremos mostrar um character de comando dentro de uma string, utilizamos o delimitadores; Por exemplo, o caracter ” ‘ ” (aspas simples);
      • Para isso, utilizamos o (q), e um delimitador podendo ser [ ], , { }, (), etc.
      • EXEMPLO:
        SELECT first_name || ' tem o código da função ' || job_id
        FROM   employees;
        
        SELECT first_name || ' tem o código da função ' || job_id     
               as "Concatenação de string"
        • EXEMPLO COM QUOTA:
    SELECT job_id || q'['s]'
    FROM   employees;
    
    SELECT job_id || q'['s é a funcao de ]' || first_name
    FROM   employees;
    
  • Exercícios – Funções com Strings

    Utilize o schema HR do banco de dados Oracle 11g XE

    Exercícios – Funções com Strings
    Utilize o schema HR do banco de dados Oracle 11g XE

    1. Selecione o nome e sobrenome dos funcionários em um único campo chamado nome completo, o email todo em minusculo com a extensão @orcl.com.br chamado email_corporativo de todos os funcionários que estejam entre a letra A e M, considerando a primeira letra do nome, por ordem do nome completo;

    2. Selecione o sobrenome dos funcionários, a quantidade de caracteres do sobrenome, que a quantidade de caracteres do sobrenome esteja entre 3 a 6;

    3. Selecione o nome dos funcionários, o email do funcionário em minusculo, o salário do funcionário, a qual a primeia letra do email seja “a” e que tenha mais de 3 caracreres o email;

    4. Selecione o nome, o job_id e o salário de todos os funcionários que tenha o job_id st_man e st_clerk, mostrando a seguinte frase exemplo:Daniel, que tem a função de Fi_Account, tem o salário de $9.000,00, colocando um apelido mais amigável para esta coluna;

    5. Selecione o nome e sobrenome dos funcionários (em um único campo), a data de admissão adicionada mais 1 ano colocando um apelido de férias_previstas, mostrando a seguinte frase: Michael Rogers tem a previsão de férias programadas para 12/12/2008;

 

Vídeo1

Video 2

Video 3

Using T-SQL in a relational way

(P. 5) Como mencionado, o T-SQL é baseado em SQL, que por sua vez é baseado no modelo relacional. Contudo,há várias maneiras pelas quais o SQL e, portanto, o T-SQL, se desviam do modelo relacional. Mas o T-SQL oferece ferramentas suficientes para que, se você entenda o modelo relacional, e você pode usar a linguagem de forma relacional e, assim, escrever um código mais correto.

Lembre-se de que uma relação tem um título e um corpo. O título é um conjunto de atributos e o corpo é um conjunto de tuplas. Lembre-se de que um conjunto deve ser considerado como um todo.

(P. 6) O que isso se traduz em T-SQL é que você deveria escrever consultas que interagem com as tabelas como um todo. Você deve tentar evitar o uso de construções iterativas como cursores e loops que iteram pelas linhas uma de cada vez. Você também deve tentar evitar pensar em termos iterativos porque esse tipo de pensamento é o que leva a soluções iterativas.Para pessoas com um pouco de programação processual, a maneira natural de interagir com dados (em um arquivo, conjunto de registros ou leitor de dados) é com iterações. Então, usar cursores e outras construções iterativas no T-SQL é, de certo modo, uma extensão para o que eles já conhecem. No entanto, a maneira correta da perspectiva do modelo relacional não é interagir com as linhas uma de cada vez, em vez disso, usar operações relacionais e retornar um resultado relacional. Isso, no T-SQL, se traduz em questões da escrita.

Executando uma Select através do Excel

É possível utilizar o Excel para retornar resultados através de uma select.

No exemplo seguinte, iremos utilizar o banco de dados de exemplo AdventureWorks2008R2, que pode ser encontrado facilmente na internet.

No SSMS, executaremos a seguinte select (simples)

SELECT W.WorkOrderID, P.Name, W.OrderQty, P.StandardCost,  
       W.OrderQty * P.StandardCost as SubTotal 
FROM   Production.WorkOrder W
       INNER JOIN Production.Product P
         ON W.ProductID = P.ProductID

O resultado da consulta será o seguinte:

 

ScreenHunter_446 Jan. 23 10.58

No Excel 2013 ou 2016, abra uma nova planilha, clique no menu Dados, De Outas Fontes, Do SQL Server

ScreenHunter_447 Jan. 23 11.01

Preencha corretamente os dados de conexao, conforme o assistente de conexão pede:

Captura de tela 2018-01-23 11.03.05

Escolha do banco de dados AdventureWorks2008R2, tire a marcação de “Conectar a uma tabela específica”, e clique em [avançar]

Captura de tela 2018-01-23 11.04.27

Caso queira, altere o nome do arquivo de conexão, descricao e nome amigãvel, e clique em [Concluir]

Captura de tela 2018-01-23 11.06.32

Temporariamente, escolha uma visão a ser selecionada e clique em [OK]

Captura de tela 2018-01-23 11.08.25

Clique na opcao Proriedades, para que o Excel abra as Propriedades da Conxão.

Captura de tela 2018-01-23 11.08.50

Nas propriedades da Conexão, na aba Uso, é possível configurar por exemplo, a cada X minutos que irá ser atualizada.

Captura de tela 2018-01-23 11.14.29

Na aba Definição, altere o tipo de comando para SQL, e o Texto de comando, substitua para a Select que foi desenvolvida:

Captura de tela 2018-01-23 11.15.57

Clique em [OK] para finalizar.

A mensagem seguinte poderá ser exibida. CLique em [Sim]

Captura de tela 2018-01-23 11.16.31

O Excel voltará para a tela de inportar dados. Selecione a celula =$A$1

Captura de tela 2018-01-23 11.18.28

Dessa forma, temos os dados exibidos em planilha, a qual estes são atualizados dinamicamente, de tempos em tempos conforme configuração da conexão ou clicando sobre o botão Atualizar.

ScreenHunter_448 Jan. 23 11.20

O ideal é fazer a criação de uma View dentro do SQL Server e fazer com que o usário tenha acesso m´nimo de permissão, não deixando que usuários comuns tenham acesso a qualquer outro tipo de objeto (a não ser a view cirada)

Após importado os dados, é possível criar as formulas normalmente do Excel.

 

 

 

Utilizando CASE com IN no SQL Server

No SQL Server, é possível utilizar o recurso IN dentro de um Case.

Para ilustrar o exemplo, utilizamos o banco de dados Adventure Works 2008, e primeiro podemos observar o uso típico do case:

SELECT	ProductID, 
	Name, 
	Color,
	case Color 
	    when 'Red'    then 'Cor Primaria'
	    when 'Blue'   then 'Cor Primaria'
	    when 'Yellow' then 'Cor Primaria'
	    else 'Cor Secundaria'
	end as TesteCase
FROM	Production.Product
WHERE	Color is not null

Temos o seguinte resultado:

ScreenHunter_440 Jan. 17 08.49

Observamos que para o caso das cores serem Red, Blue e Yellow, os resultados seriam os mesmos.

Podemos fazer a alteração utilizando o comando IN dentro do Case, como o código seguinte:

SELECT	ProductID, 
	Name, 
	Color,
	case WHEN 
	    Color in ('Red','Blue','Yellow') then 'Cor Primaria'
	    else 'Cor Secundaria'
	end as TesteCase
FROM	Production.Product
WHERE	Color is not null

Observamos que conseguimos otimizar a escrita do código, não ficando tão repetitivo, tendo o mesmo resultado:

ScreenHunter_440 Jan. 17 08.49

Banco de Dados I – Aula 16A

Exercícios SQL

A empresa ABC VENDASCAR LTDA é uma emprea que atua em vendas de carros seminovos e usados multimarcas, principalmente em São Paulo (Capital) e no grande ABC.

Atualmente a empresa implantou o seguinte sistema para melhor controle seus orcamentos e suas vendas. Como a empresa NÃO faz vendas exclusiva de um fabricante, ela optou por trabalhar com veículos dos fabricantes Volkswagem, Chevrolet (GM), Ford e Fiat, para que não fique preso à uma única marca.

O cliente pode ser tanto pessoa física ou juridica, a qual na compra de mais de um carro em uma única negociação, é possível ter descontos mais vantajosos.

Primeiro é necessário que o cliente tenha um pré-cadastro no sistema para que os vendedores apresentem um orcamento prévio. Caso seja aprovado o orcamento, aí sim o orcamento se transforma em uma venda efetiva.

A empresa tem o seguinte esquema de tabelas em seu banco de dados:

FABRICANTE (COD_FAB, DESC_FAB)

MODELO (COD_MOD, DESC_MOD, COD_FAB)

COR (COD_COR, DESC_COR)

VEICULO (COD_VEI, COD_MOD, ANO_FABRICACAO, ANO_MODELO, VALOR_CUSTO, VALOR_VENDA, COD_COR)

CIDADE (COD_CID, DESC_CID, UF)

PLACA_VEICULO (COD_VEI, PLACA, COD_CID)

CLIENTE (COD_CLI, NOME_CLI, TIPO_PESSOA, COD_CID)

ORCAMENTO (COD_ORC, DATA_ORC, VALIDADE_ORC, COD_CLI)

ITEM_ORCAMENTO (COD_ORC, ITEM_ORC, COD_VEI, QUANTIDADE, VALOR_ORC, VALOR_DESCONTO)

VENDA (COD_VENDA, COD_ORC, DATA_VENDA)

ITEM_VENDA (COD_VENDA, ITEM_VENDA, COD_VEI, QUANTIDADE, VALOR_VENDA)

 

Baseado no cenário descrito, faça os exercícios em SQL e também crie o schema VENDASCAR, com as tabelas descritas acima. Por enquanto, as tabelas irão estar sem os relacionamentos necessários, porém tenha ciência de que os dados precisam ter relação entre si. Aconselhável fazer em dupla, onde 1 aluno pode fazer a criação do schema e tabelas e outro pode fazer as consultas SQL.

  1. Selecione o nome do veículo que tenha menor custo do estoque; (função de grupo)
  2. Liste todos os nomes de fabricantes de veículos que tiveram orcamentos feitos no período de 01/06/2017 a 30/06/2017;
  3. Selecione o cliente que mais orçou veículos no período de 01/01/2017 a 30/06/2017;
  4. Selecione as cores dos 5 veículos mais orçados período de 01/01/2017 a 30/06/2017; (pesquisar sobre limitação de registros)
  5. Liste as cidades dos carros vendidos dos fabricantes Volkswagem e Chevrolet (GM), no período de venda de 01/01/2017 a 31/12/2017;
  6. Liste os veículos (placa, cidade, fabricante, modelo) da cidade de Jundiaí, Campinas e São Paulo que foram vendidos entre 01/07/2017 a 31/12/2017;
  7. Selectione os orcamentos feitos (Código do orcamento, data, fabricante, modelo, quantidade, valor, desconto, subtotal (quantidade * valor – desconto) feitos no período do ano de 2016;
  8. Selecione os 5 veículos mais vendidos no período do ano de 2016; (use funções de Grupo)
  9. Selecione os orcamentos feitos no período de 01/01/2017 a 31/03/2017, porém que não foram fechados;
  10. Selecione a média de vendas de junho, julho e agosto de 2017; (função de grupo)

 

Vídeo 01

 

Vídeo 02

 

Banco de Dados I – Aula 15A

FUNÇÕES SQL

As funções são um recurso avançado do SQL e podem ser usadas para realizar:

– Executar cálculos usando dados;

– Modificar itens de dados individuais;

– Manipular saída para grupos de linhas;

– Formatar datas e números para exibição;

– Converter tipos de dados de coluna;

As funções SQL podem aceitar argumentos e sempre retornar um valor;

Há dois tipos de funções:

– Funções de uma única linha;

– Funções de várias linhas;

FUNÇÕES DE UMA ÚNICA LINHA

Essas funções operam somente linhas únicas e retornam um resultado por linha. Há dois tipos diferentes de funções de uma única linha.

– Caractere;

– Número;

– Data;

– Conversão;

Essas funções manipulam grupos de linha a fim de obter um resultado por grupo de linhas.

– Manipulam itens de dados;

– Aceitam argumentos e retornam um valor;

– Agem em cada linha retornada;

– Retornam um resultado por linha;

– Podem modificar o tipo de dados;

– Podem ser aninhadas;

Um argumento pode ser:

– Constante fornecida pelo usuário;

– Valor variável;

– Nome da coluna;

– Expressão;

Os recursos de funções de uma única linha:

– Atuam em cada linha retornada na consulta;

– Retornam um resultado por linha;

– Podem retornar um valor de dados de um tipo diferente do mencionado;

– Podem esperar um ou mais argumentos;

– Podem ser usados em cláusulas SELECT, WHERE e ORDER BY; podem ser aninhados;

– Funções de caractere: aceitam entrada de caractere e podem retornar valores de número e caractere;

– Funções numéricas: aceitam entrada numérica e reotrnam valores numéricos;

– Funções de data: operam sobre valores do tipo de dados data (todas as funções de data retornam data, exceto a função MONTHS_BETWEEN, que retorna um número)

– Funções de conversão: Convertem um valor de tipo de dados para outro;

– Funções gerais:

  • Função NVL;
  • Função DECODE;

FUNÇÕES DE CARACTERE

Podem ser divididas em duas características:

–Funções de conversão de maiúscula e minúscula;

  • LOWER, UPPER e INITCAP

–Funções de manipulação de caractere;

  • CONCAT, SUBSTR, LENGTH, INSTR, LPAD, TRIM

FUNÇÕES DE CONVERSÃO DE MAIÚSCULAS / MINÚSCULAS

– LOWER: Converte string de caracteres com letras maiúsculas e minúsculas ou só maiúsculas para letras minúsculas;

– UPPER: Converte string de caracteres com letras maiúculas e minúsculas ou só minúsculas para letras maiúsculas;

– INITCAP: Converte a primeira letra de cada palavra para maiúscula e mantém as outras letras em minúsculas;

SQL> SELECT UPPER(NMDEPTO)
2  FROM DEPTO;

SQL> SELECT LOWER(NMDEPTO)
2  FROM DEPTO;

SQL> SELECT INITCAP(NMDEPTO)
2  FROM DEPTO;

SQL> SELECT UPPER(NMDEPTO)
2  FROM DEPTO
3  WHERE UPPER(NMDEPTO) LIKE '%A%';

FUNÇÕES DE MANIPULAÇÃO DE CARACTERE

– CONCAT, SUBSTR, LENGTH, INSTR, LPAD e TRIM são as seis funções de manipulação de caractere;

– CONCAT: Une valores de junção (Voce está limitado a usar dois parâmetros com CONCAT);

– SUBSTR: Extrai uma string de determinado tamanho;

– LENGTH: Exibe o tamanho de uma string como um valor numérico;

– INSTR: Localiza a posição numérica do caractere nomeado;

– LPAD: Preenche o valor do caractere justificado à direita;

– RPAD: Preenche o valor de caractere justificado à esquerda;

– TRIM: Organiza cabeçalho ou caracteres de fim de linha (ou os dois) a partir de uma string de caractere;

SQL> SELECT CONCAT(NRMATRIC, NMFUNC),
2          LENGTH(NMFUNC),
3          INSTR(NMFUNC,’A’)
4  FROM FUNCIONARIO
5  WHERE SUBSTR(NMDEPTO,1,2) = 'JO';

FUNÇÕES NUMÉRICAS

ROUND: Arredonda valor para determinado decimal;

  •   ROUND(45.926,2) –> 45.93

TRUNC: Trunca valor para determinado decimal;

  •   ROUND(45.926,2) –> 45.92

MOD: Retorna o restante da divisão;

  •   MOD(1600,300) –> 100

USANDO A FUNÇÃO ROUND

SQL> SELECT ROUND(45.923,2),
2       ROUND(45.923,0),
3       ROUND(45.923,-1)
4  FROM DUAL;

USANDO A FUNÇÃO TRUNC

SQL> SELECT TRUNC(45.923,2),
2       TRUNC(45.923),
3       TRUNC(45.923,-1)
4  FROM DUAL;

USANDO A FUNÇÃO MOD

SQL> SELECT MOD(VRSALARIO,2)
2  FROM CARGO;

TRABALHANDO COM DATAS

O Oracle armazena datas em um formato numérico interno: século, ano, mês, dia, horas, minutos, Segundo;

O formato de data default é DD-MON-YY;

SYSDATE é uma função de retorno de data e hora;

DUAL é uma tabela fictícia usada para visualizar SYSDATE;

EXIBINDO A DATA ATUAL

SQL> SELECT SYSDATE
2  FROM DUAL;

ARITMÉTICA COM DATAS

Adicionar ou subtrair um número de, ou para, uma data para um valor de data resultante;

Subtrair duas datas a fim de localizer o número de dias entre estras datas;

Adicionar horas por uma data dividindo o número de horas por 24;

ARITMÉTICA COM DATAS

ScreenHunter_298 Nov. 11 19.31

USANDO OPERADORES ARITMÉTICOS COM DATAS

SQL> SELECT NMFUNC,
2    (SYSDATE – DTADM) / 7 SEMANA
3  FROM FUNCIONARIO;

FUNÇÕES COM DATAS

ScreenHunter_299 Nov. 11 19.32

FUNÇÕES COM DATAS

MONTHS_BETWEEN('01-SEP-95','11-JAN-94')
--> 19.6774194

ADD_MONTHS('11-JAN-96',6)
--> ’11-JUL-94’

NEXT_DAY('01-SEP-95','FRIDAY')
--> '08-SEP-95'

LAST_DAY('01-SEP-95')
--> '30-SEP-95'

ROUND('25-JUL-95','MONTH')
--> 01-AUG-95

ROUND('25-JUL-95','YEAR')
--> 01-JAN-96

TRUNC('25-JUL-95','MONTH')
--> 01-JUL-95

TRUNC('25-JUL-95','YEAR')
--> 01-JAN-95

 

Vídeo 01

Banco de Dados I – Aula 14C

EXERCÍCIOS: Utilize o Schema HR do Oracle para resolver os problemas abaixo:

hr

1 – Selecione todos os ids, nomes e sobrenomes de empregados, que estejam nas faixas de salários de 0 a 2000 e maiores ou iguais a 5000. Dê 3 tipos de consultas para resolver esse problema)

2 – Selecione todos os ids e nomes de departamentos, o id do gerente do departamento que estejam nos id de locais entre 1500 a 2000;

3 – Selecione todos os nomes de departamentos e nomes dos gerentes de departamentos onde a cidade de localização seja Sao Paulo (faça pela antiga e nova sintaxa. Se possível, resolva também em algebra relacional)

4 – Selecione todos os ids, nomes e sobrenome de empregados que possuem salario maior que 5000 (Dê duas soluções para este problema. Se possível, resolva também em algebra relacional)

5 – Selecione todos ids, nomes e sobrenomes (como um único campo – nome completo) de empregados, a data de admissao (hire date),data de inicio e fim (end_date) dos determinados serviços (jobs). Obs: um empregado pode ter trabalhado em mais de um servico em um período de tempo; (Dê 2 soluções para esse problema. Se possível, resolva também em algebra relacional)

6 – Selecione todos o nome da região, o nome do pais que os nomes de paises iniciem com as letras A,B,J (Dê 2 soluções para esse problema. Se possível, resolva também em algebra relacional)

7 – Selecione todos os id´s e nomes dos gerentes, ids e nomes de departamentos gerenciados por esses gerentes. (De 3 soluções para esse problema)

8 – Selecione todos os ids e nomes de departamentos, a qual não possuem nenhum empregado alocado (dê 2 soluções para esse problema);

9 – Selecione todos os ids e nomes de empregados, o nome do departamento, o nome do pais e o nome da região, onde as regiões devem ser iguais a Europe e Asia (dê 3 soluções para esse problema);

Vídeo 01

 

Banco de Dados I – Aula 14B

USANDO O SCHEMA HR DO ORACLE

hr

JUNÇÃO DE TABELA (SINTAXE ANTIGA)

SQL> SELECT tabela1.coluna, tabela2.coluna
  2  FROM tabela1, tabela2
  3  WHERE tabela1.coluna = tabela2.coluna;

 

JUNÇÃO DE TABELA (SINTAXE NOVA)

SQL> SELECT tabela1.coluna, tabela2.coluna
  2  FROM tabela1
  3    INNER JOIN tabela2
  4      ON tabela1.coluna =
  5                  tabela2.coluna;

 

GERANDO UM PRODUTO CARTESIANO (SINTAXE ANTIGA)

Gera-se um produto cartesiano caso uma condição de junção seja omitida.

SQL> SELECT FIRST_NAME,
  2         DEPARTMENT_NAME
  3  FROM   EMPLOYEES,
  4         DEPARTMENTS;

 

GERANDO UM PRODUTO CARTESIANO (SINTAXE NOVA)

SQL> SELECT FIRST_NAME,
  2         DEPARTMENT_NAME
  3  FROM   EMPLOYEES
  4         CROSS JOIN DEPARTMENTS;

 

GERANDO REGISTROS COM JUNÇÕES IDÊNTICAS (SINTAXE ANTIGA)

SELECT  FIRST_NAME,
        EMPLOYEES.DEPARTMENT_ID,
        DEPARTMENTS.DEPARTMENT_ID,
        DEPARTMENT_NAME
FROM    EMPLOYEES, DEPARTMENTS
WHERE   EMPLOYEES.DEPARTMENT_ID =
                  DEPARTMENTS.DEPARTMENT_ID

 

GERANDO REGISTROS COM JUNÇÕES IDÊNTICAS (SINTAXE NOVA)

SELECT  FIRST_NAME,
        EMPLOYEES.DEPARTMENT_ID,
        DEPARTMENTS.DEPARTMENT_ID,
        DEPARTMENT_NAME
FROM    EMPLOYEES
        INNER JOIN DEPARTMENTS
          ON EMPLOYEES.DEPARTMENT_ID =
            DEPARTMENTS.DEPARTMENT_ID

 

CONDIÇÕES DE PESQUISA ADICIONAIS USANDO O OPERADOR AND (SINTAXE ANTIGA)

SELECT   EMPLOYEE_ID, FIRST_NAME,
         DEPARTMENT_NAME
FROM     EMPLOYEES, DEPARTMENTS
WHERE    EMPLOYEES.DEPARTMENT_ID =
           DEPARTMENTS.DEPARTMENT_ID
         AND FIRST_NAME = 'Diana';

 

CONDIÇÕES DE PESQUISA ADICIONAIS USANDO O OPERADOR AND (SINTAXE NOVA)

SELECT   EMPLOYEE_ID, FIRST_NAME,
         DEPARTMENT_NAME
FROM     EMPLOYEES
         INNER JOIN DEPARTMENTS
           ON EMPLOYEES.DEPARTMENT_ID =
             DEPARTMENTS.DEPARTMENT_ID
WHERE   FIRST_NAME = 'Diana';

 

UNINDO MAIS DE DUAS TABELAS (SINTAXE ANTIGA)

SELECT   E.FIRST_NAME,
         J.JOB_TITLE,
         D.DEPARTMENT_NAME
FROM     EMPLOYEES E,
         JOBS J,
         DEPARTMENTS D
WHERE    E.JOB_ID = J.JOB_ID
         AND E.DEPARTMENT_ID =   D.DEPARTMENT_ID;

 

UNINDO MAIS DE DUAS TABELAS (SINTAXE NOVA)

SELECT   E.FIRST_NAME,
         J.JOB_TITLE,
         D.DEPARTMENT_NAME
FROM     EMPLOYEES E
         INNER JOIN JOBS J
           ON E.JOB_ID = J.JOB_ID
         INNER JOIN DEPARTMENTS D 
           ON E.DEPARTMENT_ID =   D.DEPARTMENT_ID;

 

JUNÇÕES NÃO-IDÊNTICAS (SINTAXE ANTIGA)

SELECT    E.FIRST_NAME, E.LAST_NAME,
          E.SALARY, J.MIN_SALARY,   J.MAX_SALARY, J.JOB_TITLE
FROM      EMPLOYEES E, JOBS J
WHERE     E.SALARY
          BETWEEN J.MIN_SALARY AND   J.MAX_SALARY;

 

JUNÇÕES NÃO-IDÊNTICAS (SINTAXE NOVA)

SELECT    E.FIRST_NAME, E.LAST_NAME,
          E.SALARY, J.MIN_SALARY,   J.MAX_SALARY, J.JOB_TITLE
FROM      EMPLOYEES E
            JOIN JOBS J
              ON E.SALARY BETWEEN      J.MIN_SALARY AND J.MAX_SALARY;

 

EXEMPLO DE JUNÇÕES EXTERNAS (SINTAXE ANTIGA)

SELECT   E.FIRST_NAME,
         D.DEPARTMENT_NAME
FROM     EMPLOYEES E,
         DEPARTMENTS D
WHERE    E.DEPARTMENT_ID(+) =
                       D.DEPARTMENT_ID;

 

EXEMPLO DE JUNÇÕES EXTERNAS (SINTAXE NOVA)

SELECT   E.FIRST_NAME,
         D.DEPARTMENT_NAME
FROM     EMPLOYEES E,
         LEFT JOIN DEPARTMENTS D
           ON E.DEPARTMENT_ID =
              D.DEPARTMENT_ID;

 

EXEMPLO DE JUNÇÕES EXTERNAS (SINTAXE ANTIGA)

SELECT   E.FIRST_NAME,
         D.DEPARTMENT_NAME
FROM     EMPLOYEES E,
         DEPARTMENTS D
WHERE    E.DEPARTMENT_ID =
           D.DEPARTMENT_ID(+);

 

EXEMPLO DE JUNÇÕES EXTERNAS (SINTAXE NOVA)

SELECT   E.FIRST_NAME,
         D.DEPARTMENT_NAME
FROM     EMPLOYEES E
           RIGHT JOIN DEPARTMENTS D
             ON E.DEPARTMENT_ID =
                           D.DEPARTMENT_ID;

 

EXEMPLO DE AUTOJUNÇÕES (SINTAXE ANTIGA)

SELECT   WORKER.FIRST_NAME
         ||' TRABALHA PARA ' ||
         MANAGER.FIRST_NAME
FROM     EMPLOYEES WORKER,
         EMPLOYEES MANAGER
WHERE    WORKER.MANAGER_ID =
                MANAGER.EMPLOYEE_ID;

 

EXEMPLO DE AUTOJUNÇÕES (SINTAXE NOVA)

SELECT   WORKER.FIRST_NAME
         ||' TRABALHA PARA ' ||
         MANAGER.FIRST_NAME
FROM     EMPLOYEES WORKER
           LEFT JOIN EMPLOYEES MANAGER
             ON WORKER.MANAGER_ID =
                MANAGER.EMPLOYEE_ID;

Video 01

Banco de Dados I – Aula 14A

EXIBINDO DADOS DE VÁRIAS TABELAS

Há situações em que precisamos buscar dados de várias tabelas, onde um select simples não consegue obter esses dados;

Nesses casos, é necessário utilizar dados a partir de uma ou mais tabelas;

Para isso, precisamos fazer junção de tabelas;

O QUE É JUNÇÃO?

Use a junção para consultar dados a partir de uma ou mais tabelas;

Criar uma condição de junção na cláusula WHERE;

Prefixar o nome da coluna com o nome da tabela quando o mesmo nome da coluna aparecer em mais de uma tabela

Exemplo de junção

SQL> SELECT tabela1.coluna, tabela2.coluna
2  FROM tabela1, tabela2
3  WHERE tabela1.coluna = tabela2.coluna;

 

USANDO O SCHEMA HR DO ORACLE

hr

PRODUTO CARTESIANO

Um produto cartesiano é formado quando:

– Uma condição de junção estiver omitida;

– Uma condição de junção estiver inválida;

– Todas as linhas na primeira tabela estão unidas a todas as linhas da segunda tabelas;

Para evitar um produto Cartesiano, sempre inclua uma condição de junção válida em uma cláusula WHERE;

GERANDO UM PRODUTO CARTESIANO

Gera-se um produto cartesiano caso uma condição de junção seja omitida.

SQL> SELECT FIRST_NAME,
  2           DEPARTMENT_NAME
  3    FROM   EMPLOYEES,
  4           DEPARTMENTS;

 

TIPOS DE JUNÇÃO

Há dois tipos principais de condições de junção:

– Junção idênticas;

– Junção não-idêntcias;

Métodos de junção adicional incluem:

– Junções externas;

– Autojunções;

– Operadores de conjunto;

 

JUNÇÃO IDÊNTICA

ScreenHunter_393 Nov. 06 12.59

RECUPERANDO REGISTROS COM JUNÇÕES IDÊNTICAS

SQL>SELECT  FIRST_NAME,
            EMPLOYEES.DEPARTMENT_ID,
            DEPARTMENTS.DEPARTMENT_ID,
            DEPARTMENT_NAME
    FROM    EMPLOYEES, DEPARTMENTS
    WHERE   EMPLOYEES.DEPARTMENT_ID =
                      DEPARTMENTS.DEPARTMENT_ID;

QUALIFICANDO NOMES DE COLUNA AMBÍGUAS

Use os prefixos de tabela para qualificar nomes de colunas que estão em várias tabelas;

Diferencie colunas que possuem nomes idênticos, mas que residam em tabelas diferentes usando apelidos de coluna;

CONDIÇÕES DE PESQUISA ADICIONAIS USANDO O OPERADOR AND

Além da junção, é possível ter critérios para a cláusula WHERE;

SELECT   EMPLOYEE_ID, FIRST_NAME,
         DEPARTMENT_NAME
FROM     EMPLOYEES, DEPARTMENTS
WHERE    EMPLOYEES.DEPARTMENT_ID =
                       DEPARTMENTS.DEPARTMENT_ID
         AND FIRST_NAME = 'Diana';

USANDO APELIDOS DE TABELA

Apelidos de tabelas podem ter um tamanho de até 30 caracteres;

Se um apelido de tabela for usado para um determinado nome de tabela na cláusula FROM, deve-se utilize-lo para toda a instrução SELECT;

Apelidos devem ser significativos;

O apelido de tabela é válido somente para a instrução SELECT atual;

 

USANDO APELIDOS DE TABELA

SELECT   E.FIRST_NAME,
         J.JOB_TITLE,
         D.DEPARTMENT_NAME
FROM     EMPLOYEES E,
         JOBS J,
         DEPARTMENTS D
WHERE    E.JOB_ID = J.JOB_ID
         AND E.DEPARTMENT_ID =   D.DEPARTMENT_ID;

 

JUNÇÕES NÃO-IDÊNTICAS

O relacionamento de junção não-idênticas  significa que não há nenhum coluna correspondente diretamente entre as duas tabelas;

SELECT    E.FIRST_NAME, E.LAST_NAME,
          E.SALARY, J.MIN_SALARY,   J.MAX_SALARY,
          J.JOB_TITLE
FROM      EMPLOYEES E, JOBS J
WHERE     E.SALARY
          BETWEEN J.MIN_SALARY AND   J.MAX_SALARY;

 
Se uma linha não satisfazer uma condição de junção, a linha não aparecerá no resultado da consulta.

ScreenHunter_394 Nov. 06 13.03

Use uma junção externa para consultar também todas as linhas que em geral não atendem à condição de junção.

O operador de junção externo é um sinal de adição (+);

EXEMPLO DE JUNÇÕES EXTERNAS

SELECT   E.FIRST_NAME,
         D.DEPARTMENT_NAME
FROM     EMPLOYEES E,
         DEPARTMENTS D
WHERE    E.DEPARTMENT_ID(+) =
                          D.DEPARTMENT_ID

 
O operador da junção externa pode aparecer somente de um lado da expressão – o lado que possui informações ausentes. Ele retorna estas linhas de uma tabela que não possui correspondênciadireta em outra tabela;

Uma condição envolvendo uma junção externa não pode usar o operador IN ou vincular a outra condição pelo operador OR;

 

AUTOJUNÇÕES

Algumas vezes será necessário unir uma tabela a ela mesma.

ScreenHunter_395 Nov. 06 13.05

EXEMPLO DE AUTOJUNÇÕES

SELECT   WORKER.FIRST_NAME
         ||' TRABALHA PARA ' ||
         MANAGER.FIRST_NAME
FROM     EMPLOYEES WORKER,
         EMPLOYEES MANAGER
WHERE    WORKER.MANAGER_ID =
                       MANAGER.EMPLOYEE_ID;

 

Vídeo 01

Banco de Dados I – Aula 12A

SOBRE O PL/SQL

O PL/SQL (Procedural Language/SQL) é uma extensão do SQL com recursos de design de linguagem de programação, sendo uma extensão de linguagem procedural da Oracle;

Incorpora muitos recursos avançados feitos em linguagem de programação projetadas durante as décadas de 70 e 80;

É uma tecnologia empregada pelo Oracle Server e por algumas ferramentas Oracle;

SCRIPT PARA SER EXECUTADO VIA LINHA DE COMANDO NO SQLPLUS

Salvar em arquivo texto dentro do linux e executar via sqlplus

create tablespace banco1 datafile '/u01/app/oracle/oradata/XE/banco1.dbf' size 10m autoextend on next 5m maxsize 50m online permanent extent management local autoallocate segment space management auto;

create user banco1 identified by banco1 default tablespace banco1 temporary tablespace temp;

grant create session, connect, resource to banco1;

alter user banco1 quota unlimited on banco1;

connect banco1/banco1;

CREATE TABLE DEPTO (
  CDDEPTO CHAR(02) PRIMARY KEY,
  NMDEPTO VARCHAR(30),
  RAMAL NUMBER(3)
);

CREATE TABLE CARGO (
  CDCARGO CHAR(02) PRIMARY KEY,
  NMCARGO VARCHAR(30),
  VRSALARIO NUMBER(8,2)
);

CREATE TABLE FUNCIONARIO (
  NRMATRIC NUMBER(04) PRIMARY KEY,
  NMFUNC   VARCHAR(30),
  DTADM    DATE,
  SEXO     CHAR(01),
  CDCARGO  CHAR(02),
  CDDEPTO  CHAR(02),
  CONSTRAINT FK_FUNC_CDCARGO FOREIGN KEY(CDCARGO) REFERENCES CARGO(CDCARGO),
  CONSTRAINT FK_FUNC_CDDEPTO FOREIGN KEY(CDDEPTO) REFERENCES DEPTO(CDDEPTO)
);

INSERT INTO CARGO (CDCARGO, NMCARGO, VRSALARIO) VALUES ('C1','COZINHEIRA',350);
INSERT INTO CARGO (CDCARGO, NMCARGO, VRSALARIO) VALUES ('C3','AUX ESCRITORIO',450);
INSERT INTO CARGO (CDCARGO, NMCARGO, VRSALARIO) VALUES ('C7','VIGIA',450);
INSERT INTO CARGO (CDCARGO, NMCARGO, VRSALARIO) VALUES ('C2','MECANICO',750);
INSERT INTO CARGO (CDCARGO, NMCARGO, VRSALARIO) VALUES ('C5','GERENTE',2300);
INSERT INTO CARGO (CDCARGO, NMCARGO, VRSALARIO) VALUES ('C4','ESCRITURARIO',600);
INSERT INTO CARGO (CDCARGO, NMCARGO, VRSALARIO) VALUES ('C8','PROGRAMADOR',NULL);
INSERT INTO CARGO (CDCARGO, NMCARGO, VRSALARIO) VALUES ('C9','ANALISTA_DE_SISTEMAS',2100);

COMMIT;

INSERT INTO DEPTO (CDDEPTO, NMDEPTO, RAMAL) VALUES ('D1','ADMINISTRACAO',221);
INSERT INTO DEPTO (CDDEPTO, NMDEPTO, RAMAL) VALUES ('D2','OFICINA',235);
INSERT INTO DEPTO (CDDEPTO, NMDEPTO, RAMAL) VALUES ('D3','SERVICOS GERAIS',243);
INSERT INTO DEPTO (CDDEPTO, NMDEPTO, RAMAL) VALUES ('D4','VENDAS',258);
COMMIT;

INSERT INTO FUNCIONARIO (NRMATRIC, NMFUNC, DTADM, SEXO, CDCARGO, CDDEPTO) VALUES (1001,'JOAO SAMPAIO','10-AUG-93','M','C2','D2');
INSERT INTO FUNCIONARIO (NRMATRIC, NMFUNC, DTADM, SEXO, CDCARGO, CDDEPTO) VALUES (1004,'LUCIO TORRES','02-MAR-94','M','C2','D2');
INSERT INTO FUNCIONARIO (NRMATRIC, NMFUNC, DTADM, SEXO, CDCARGO, CDDEPTO) VALUES (1034,'ROBERTO PEREIRA','23-MAY-92','M','C3','D1');
INSERT INTO FUNCIONARIO (NRMATRIC, NMFUNC, DTADM, SEXO, CDCARGO, CDDEPTO) VALUES (1021,'JOSE NOGUEIRA','10-NOV-94','M','C3','D1');
INSERT INTO FUNCIONARIO (NRMATRIC, NMFUNC, DTADM, SEXO, CDCARGO, CDDEPTO) VALUES (1029,'RUTH DE SOUZA','05-JAN-93','F','C1','D3');
INSERT INTO FUNCIONARIO (NRMATRIC, NMFUNC, DTADM, SEXO, CDCARGO, CDDEPTO) VALUES (1095,'MARIA DA SILVA','03-SEP-92','F','C4','D1');
INSERT INTO FUNCIONARIO (NRMATRIC, NMFUNC, DTADM, SEXO, CDCARGO, CDDEPTO) VALUES (1023,'LUIZ DE ALMEIDA','12-JAN-93','M','C2','D2');
INSERT INTO FUNCIONARIO (NRMATRIC, NMFUNC, DTADM, SEXO, CDCARGO, CDDEPTO) VALUES (1042,'PEDRO PINHEIRO','29-JUL-94','M','C4','D1');
INSERT INTO FUNCIONARIO (NRMATRIC, NMFUNC, DTADM, SEXO, CDCARGO, CDDEPTO) VALUES (1048,'ANA SILVEIRA','01-JUN-93','F','C5','D1');
INSERT INTO FUNCIONARIO (NRMATRIC, NMFUNC, DTADM, SEXO, CDCARGO, CDDEPTO) VALUES (1015,'PAULO RODRIGUES','17-AUG-92','M','C2','D2');
COMMIT;

INSTRUÇÃO SELECT BÁSICA

SELECT [DISTINCT] {*, coluna [apelido],…}
FROM tabela;

Uma cláusula SELECT especifica as colunas a serem exibidas;

Uma cláusula FROM especifica a tabela que contém as colunas listadas na cláusula SELECT

Na sintaxe:

SELECT –> é a lista de uma ou mais colunas

DISTINCT –> suprime os itens duplicados

* –> selectiona todas as colunas

coluna –> seleciona a coluna nomeada

apelido –> fornece cabeçalhos diferentes às   colunas selecionadas

FROM –> tabela especifica a tabela contend   as colunas

CRIANDO INSTRUÇÕES SQL

Instruções SQL sem distinção entre maiusculas / minusculas;

Instruções SQL podem estar em uma ou mais linhas;

Palavras-chave não podem ser abreviadas ou divididas entre as linhas;

Normalmente, as cláusulas são colocadas em linhas separadas;

Guias e indentações são usadas para aperfeiçoar a legibilidade;

SELECIONANDO COLUNAS

SQL> SELECT *
  2  FROM DEPTO;

SQL> SELECT CDDEPTO, NMDEPTO, RAMAL
  2  FROM DEPTO;

SQL> SELECT CDDEPTO, NMDEPTO
  2  FROM DEPTO;

AJUSTANDO CABEÇALHO DAS COLUNAS

SQL> COL "CDDEPTO" FORMAT "A15";

SQL> SELECT *
  2  FROM DEPTO;

A15 –>quantidade de caracteres a ser apresentado

DEFAULTS DE CABEÇALHOS DE COLUNA

Justificativa default

Esquerda: dados de caractere e data

Direita: Dados numéricos

Exibição default: Letra maiúscula

SQL> SELECT cddepto, nmdepto
  2  FROM DEPTO; 

Obs –> mesmo digitando os campos selecionandos em minúsculo, será exibido em maiúsculo

EXPRESSÕES ARITMÉTICAS

Criar expressões com dados NUMBER e DATE usando operadores aritméticos.

OPERADOR DESCRIÇÃO
+ Adicionar
Subtrair
* Multiplicar
/ Dividir

USANDO OPERADORES ARITMÉTICOS

SQL> SELECT CDCARGO, NMCARGO,
   2  VRSALARIO,
   3  VRSALARIO + 1000
   4  FROM CARGO;

PRECEDENCIA DE OPERADORES

A multiplicação e a divisão têm prioridade sobre a adição e a substração;

Os operadores com a mesma prioridade são avaliados da esquerda para a direita;

Os parênteses são usados para forçar a avaliação priorizada e para esclarecer as instruções;

Exemplo 1:

SQL> SELECT CDCARGO, NMCARGO,
   2  VRSALARIO,
   3  12 * VRSALARIO + 100
   4  FROM CARGO;

Exemplo 2:

SQL> SELECT CDCARGO, NMCARGO,
   2  VRSALARIO,
   3  12 * (VRSALARIO + 100)
   4  FROM CARGO;

DEFININDO UM VALOR NULO

Um valor nulo não está disponível, não é atribuído, é desconhecido ou não é aplicável;

Um valor nulo não é o mesmo que um zero ou um espaço em branco;

SQL> SQL> SELECT CDCARGO, NMCARGO, VRSALARIO
   2  FROM CARGO;

VALORES NULOS NAS EXPRESSÕES ARITMÉTICAS

Se qualquer valor da coluna em uma expressão aritmética for nulo, o resultado será nulo;

SQL> SELECT CDCARGO, NMCARGO, 
  2  VRSALARIO + 100
  3  FROM CARGO;

DEFININDO UM APELIDO (ALIAS) PARA COLUNA

Renomeia um cabeçalho de coluna;

É útil para cálculos;

Segue imediatamente o nome da coluna;

Palavra-chave “as” é opcional entre o nome da coluna e o apelido;

Necessita de aspas duplas caso contenha espaço ou caracteres especiais ou faça a distinção entre maiúscula e minúscula;

USANDO UM APELIDO DE COLUNA

SQL> SELECT CDCARGO AS CODIGO_DO_CARGO, 
   2 NMCARGO AS "Nome do Cargo", 
   3 VRSALARIO VALOR$SALARIO
   4 FROM CARGO;

Observação: Os caracteres especiais # e $ são permitidos serem utilizados em alias sem utilização das aspas duplas;

OPERADOR DE CONCATENAÇÃO

Concatena colunas ou strings de caractere a outras colunas;

É representado por duas barras verticais “||” (pipe);

Cria uma coluna resultante que é uma expressão de caracteres

USANDO UM OPERADOR DE CONCATENAÇÃO

SQL> SELECT CDCARGO || NMCARGO 
   2	AS codigo_nome 
   3  	FROM CARGO;

STRING LITERAIS DE CARACTERES

Uma literal é um caractere, um número ou uma data incluída na lista SELECT;

Valores literais de caractere e data devem estar entre aspas simples;

Cada string de caractere é gerada um vez para linha retornada;

LINHAS DUPLICADAS

A exibição das consultas é de todas as linhas, incluindo linhas duplicadas:

SQL> SELECT CDCARGO
   2  FROM FUNCIONARIO;

ELIMINANDO LINHAS DUPLICADAS

Elimine as linhas duplicadas usando a palavra chave DISTINC na cláusula SELECT:

SQL> SELECT DISTINCT CDCARGO
   2  FROM FUNCIONARIO;

O DISTINCT atua sobre a linha do select, não sendo possível ter 2 DISTINCTS na mesma SELECT

LIMITANDO LINHAS SELECIONADAS

Restringe as linhas retornadas usando a cláusula WHERE:

A cláusula WHERE pode comparer valores em colunas, valores literais, expressões aritméticas ou funções. É formada por tres elementos:

– Nome da coluna;
– Operadores de comparação;
– Nome da coluna, constant ou lista de valores;

USANDO A CLÁUSULA WHERE

SQL> SELECT NRMATRIC, NMFUNC
   2  FROM FUNCIONARIO
   3  WHERE CDCARGO = 'C2';

STRINGS DE CARACTERES E DATAS

As strings de caractere e valores de dados aparecem entre aspas simples;

Os valores de caractere fazem distinção entre maiusculas e minúculas e o valores de data diferenciam formatos;

O format de data default é DD-MON-YY.

Exemplo:

SQL> SELECT NRMATRIC, NMFUNC, DTADM
   2 FROM FUNCIONARIO
   3 WHERE SEXO = 'F' 
   4 AND DTADM = '01-JUN-93';

OPERADORES DE COMPARAÇÃO

OPERADOR SIGNIFICADO
= Igual
> Maior do que
>= Maior do que ou igual a
< Menor
<= Menor ou igual a
Diferente de

UTILIZAÇÃO DOS OPERADORES DE COMPARAÇÃO

Use os operadores de comparação em condições que comparam uma expressão a outra.

Eles são usados na cláusula WHERE seguindo os exemplos:

WHERE hiredate = '01-JAN-95'

WHERE SAL >= 500

WHERE ENAME = 'SMITH'

OUTROS OPERADORES DE COMPARAÇÃO

OPERADOR SIGNIFICADO
BETWEEN … AND… Entre dois valores (inclusive)
IN (list) Vincula qualquer um de uma lista de valores
LIKE Vincula um padrão de caracteres
IS NULL É um valor nulo

USANDO O OPERADOR BETWEEN

Use o operador BETWEEN apra exibir linhas baseadas em uma faixa de valores

SQL>SELECT NMCARGO, VRSALARIO
  2 FROM CARGO
  3 WHERE VRSALARIO BETWEEN 450 AND 750;

USANDO O OPERADOR IN

Use o operador IN para testar os valores de uma lista

SQL>SQL> SELECT NMFUNC, CDCARGO, CDDEPTO
  2 FROM FUNCIONARIO
  3 WHERE CDCARGO IN ('C1','C3','C4');

USANDO O OPERADOR LIKE

Use o operador LIKE para executar pesquisas curinga com valores de string válidas;

As condições de pesquisa podem conter caracteres literais ou números;

– % denota zero ou muitos caracteres;

– _ (underline) denota um caractere;

Voce pode combiner caracteres de vinculação de padrão;

SQL> SELECT NMFUNC, CDCARGO, CDDEPTO
   2 FROM FUNCIONARIO
   3 WHERE NMFUNC LIKE 'JO%';
SQL> SELECT NMFUNC, CDCARGO, CDDEPTO
   2 FROM FUNCIONARIO
   3 WHERE NMFUNC LIKE '%RO%'
SQL> SELECT NMFUNC, CDCARGO, CDDEPTO
   2 FROM FUNCIONARIO
   3 WHERE NMFUNC LIKE '_O%'

USANDO A OPÇÃO ESCAPE

Quando for necessário ter uma correspondencia exata para os caracteres ‘%’ e ‘_’, use a opção ESCAPE

SQL> SELECT CDCARGO, NMCARGO
   2 FROM CARGO
   3 WHERE NMCARGO LIKE '%@_%' ESCAPE '@';

USANDO O OPERADOR IS NULL

O operador IS NULL testa valores que são nulos. Um valor nulo significa que o valor não está disponível, não-atribuído, desconhecido ou não aplicável. Assim, não é possível testar com “=” porque um valor nulo não pode ser igual ou desigual a qualquer valor.

SQL> SELECT CDCARGO, NMCARGO, VRSALARIO
   2 FROM CARGO
   3 WHERE VRSALARIO IS NULL;

OPERADORES LÓGICOS

OPERADOR SIGNIFICADO
AND Retorna TRUE se as condições de componmentes forem TRUE
OR Retorna TRUE se cada condição de componente for TRUE
NOT Retorna TRUE se a condição seguinte for FALSE

Um operador lógico combina o resultado de duas condições de componente para produzir um único resultado com base neles ou inverter o resultado para a condição única. Três operadores lógicos estão disponíveis no SQL: AND, OR e NOT

USANDO O OPERADOR AND

AND exige que ambas as conduições sejam TRUE;

SQL> SELECT CDCARGO, NMCARGO, VRSALARIO
   2   FROM CARGO
   3   WHERE CDCARGO = 'C5'
   4   AND VRSALARIO >= 2000;

TABELA VERDADE AND

AND TRUE FALSE NULL
TRUE TRUE FALSE NULL
FALSE FALSE FALSE FALSE
NULL NULL FALSE NULL

USANDO O OPERADOR OR

OR exige que cada condição seja TRUE;

SQL> SELECT CDCARGO, NMCARGO, VRSALARIO
   2 FROM CARGO
   3 WHERE CDCARGO = 'C5'
   4 OR VRSALARIO >= 2000;

TABELA VERDADE OR

OR TRUE FALSE NULL
TRUE TRUE TRUE TRUE
FALSE TRUE FALSE NULL
NULL TRUE NULL NULL

USANDO O OPERADOR NOT

NOT nega o operador usado na operação

O operador NOT pode ser utilizado também com outros operadores SQL, como BETWEEN e LIKE;

SQL> SELECT CDCARGO, NMCARGO, VRSALARIO
   2 FROM CARGO
   3 WHERE VRSALARIO IS NOT NULL;

TABELA VERDADE NOT

NOT TRUE FALSE NULL
TRUE FALSE TRUE NULL

EXEMPLO DO OPERADOR NOT

... WHERE CDDEPTO NOT IN ('D1','D3');

... WHERE VRSALARIO NOT BETWEEN 50 AND 500;

... WHERE NMCARGO NOT LIKE 'VIG%';

... WHERE RAMAL IS NOT NULL;

REGRAS DE PRECEDÊNCIA

ORDEM DE AVALIAÇÃO OPERADOR
1 Todos os operadores de comparação
2 NOT
3 AND
4 OR

Sobreponha regras de precedência usando parênteses

REGRAS DE PRECEDÊNCIA

SQL> SELECT CDCARGO, NMCARGO, VRSALARIO
   2 FROM CARGO
   3 WHERE CDCARGO = 'C1'
   4 OR  CDCARGO = 'C7'
   5 AND VRSALARIO >= 350

A ordem de execução usando regras de precedencia é:

A primeira condição é que o CDCARGO seja igual a ‘C7’ e o VRSALARIO SEJA >= 350

A segunda condição é que o cargo CDCARGO seja igual a ‘C1’;

CLÁUSULA ORDER BY

ORDER BY Classifica as linhas de 2 formas:

–ASC: ordem crescente, default (do menor para o maior);

–DESC: ordem decrescente (do maior para o menor);

SQL> SELECT CDCARGO, NMCARGO, VRSALARIO
   2 FROM CARGO
   3 ORDER BY NMCARGO;
SQL> SELECT CDCARGO, NMCARGO, VRSALARIO
   2  FROM CARGO
   3  ORDER BY CDCARGO ASC;
SQL> SELECT CDCARGO, NMCARGO, VRSALARIO
   2 FROM CARGO
   3 ORDER BY VRSALARIO DESC;

CLASSIFICANDO POR APELIDO DE COLUNA

SQL> SELECT NMCARGO, VRSALARIO,
   2 VRSALARIO * 12 AS SAL_ANUAL
   3 FROM CARGO
   4 ORDER BY SAL_ANUAL

CLASSIFICANDO POR POSIÇÃO DE COLUNA

SQL> SELECT NMCARGO, VR_SALARIO,
   2 VRSALARIO * 12 AS SAL_ANUAL
   3 FROM CARGO
   4 ORDER BY 2

CLASSIFICANDO POR VÁRIAS COLUNAS

SQL> SELECT NMFUNC, SEXO, DTADM
   2 FROM FUNCIONARIO
   3 ORDER BY NMFUNC,DTADM DESC;

CONECTANDO DO SHELL DO LINUX PARA O SQL/PLUS

Como SYSDBA

[oracle@oracle ~]$ sqlplus / as sysdba

Como usuário comum

[oracle@oracle ~]$ sqlplus banco1/banco1

CONSULTANDO TABELAS DO SCHEMA NO SQL/PLUS

SQL> SELECT TABLE_NAME
   2 FROM USER_TABLES;

CONSULTANDO A ESTRUTURA DE UMA TABELA NO SQL/PLUS

SQL> DESC FUNCIONARIO;

SAINDO DO SQL/PLUS

SQL> exit;

 

Vídeo – Parte 01

 

Vídeo – Parte 02

 

Banco de Dados I – Aula 11A

INTRODUÇÃO À ÁLGEBRA RELACIONAL – RESUMO

  • Como o nome indica, a álgebra relacional (AR) é uma álgebra de expressões envolvendo relações. A partir de uma ou mais relações da BD tomadas como operandos, outras relações podem ser progressivamente construídas através de operadores especiais, sendo resultado da consulta sobre a BD.
  • Uma consulta é, portanto, uma expressão da consulta sobre a BD.
  • Alguns operadores básicos foram propostos por CODD. Se lembrarmos de que relações são conjuntos matemáticos (de tuplas) esses operadores essencialmente manipulam conjuntos e estão em quatro categorias:
    • Operadores convencionais sobre conjuntos: união, subtração, interseção e produto cartesiano;
    • Operadores que removem parte de uma relação; um operador que elimina linhas (seleção) e um operador que elimina colunas, ou seja, atributos (projeção)
    • Operadores que combinam linhas de duas relações de acordo com condições booleanas diversas (essas operações selecionam subconjuntos do produto cartesiano das duas relações);
    • Um operador especial p (Rô) permite renomear o esquema de uma relação, essencialmente para permitir expressar de forma não ambígua operações envolvendo auto-relacionamentos;

Notação

– Letras do final do alfabeto para denotar relações (R, S, T etc)

– Letras do inicio do alfabeto para denotar atributos (A, B, C etc)

– Letra grega ScreenHunter_253 Oct. 19 20.13 (téta) é  usada para denotar um dos seis operadores de comparação:

UNIÃO

ScreenHunter_254 Oct. 19 20.24: é uma relação que contém as tuplas que estão em R, em S ou em ambas; se uma tupla está presente em R e em S, ela só aparece uma vez na união.

Esta operação primitiva também requer como operandos tabelas união-compatíveis. Produz como resultado uma tabela que contém todas as linhas da primeira tabela seguidas de todas as linhas da segunda tabela. A tabela resultante possui a mesma quantidade de colunas que as tabelas originais, e tem um número de linhas que é no máximo igual à soma das linhas das tabelas fornecidas como operandos, já que as linhas que são comuns a ambas as tabelas aparecem uma única vez no resultado.

ScreenHunter_255 Oct. 19 20.26

INTERSECÇÃO

ScreenHunter_256 Oct. 19 20.27 : é a relação que contém as tuplas que estão em ambas R e S.

Esta é uma operação adicional que produz como resultado uma tabela que contém, sem repetições, todos os elementos que são comuns às duas tabelas fornecidas como operandos. As tabelas devem ser união-compatíveis.

ScreenHunter_257 Oct. 19 20.28

O mesmo efeito pode ser obtido fazendo-se uma combinação de diferenças entre conjuntos

ScreenHunter_258 Oct. 19 20.29

ou com uniões e diferenças

ScreenHunter_259 Oct. 19 20.30

Diferença

ScreenHunter_260 Oct. 19 20.31: contém as tuplas que estão em R porém não estão em S. Observe que R – S é diferente de S – R

É uma operação primitiva que requer como operandos duas tabelas união-compatíveis, ou seja, estruturalmente idênticas. O resultado é uma tabela que possui todas as linhas que existem na primeira tabela e não existem na segunda.

ScreenHunter_261 Oct. 19 20.32

EXEMPLO PARA ESSAS OPERAÇÕES

ScreenHunter_263 Oct. 19 21.38.jpg

PROJEÇÃO

Projeção: ScreenHunter_264 Oct. 19 21.40   constrói uma nova relação a partir de R contendo apenas os atributos  . Observe que tuplas duplicadas devem ser eliminadas ao se fazer a projeção. Exemplo:

ScreenHunter_265 Oct. 19 21.40.jpg

Geralmente indicada na literatura por ScreenHunter_266 Oct. 19 21.42.jpg  (a letra grega pi) produz um conjunto onde há um elemento para cada elemento do conjunto de entrada, sendo que a estrutura dos membros do conjunto resultante é definida nos argumentos da operação.

Pode ser entendida como uma operação que filtra as colunas de uma tabela. Por operar sobre apenas um conjunto de entrada, a projeção é classificada como uma  operação unária.

Ex.: ScreenHunter_266 Oct. 19 21.42  NmFunc (funcionário)

Essa expressão produz um conjunto contendo um elemento para cada funcionário, e cada elemento contém apenas a informação referente a NmFunc da relação funcionário original

ScreenHunter_267 Oct. 19 21.43

Agora estamos interessados em identificar todos os funcionários de sexo masculino existentes no banco de dados. É uma situação que não podemos resolver com projeções apenas, uma vez que deveremos descartar elementos do conjunto inicial. Para casos desse tipo existe uma operação relacional chamada Seleção.

 

SELEÇÃO (OU RESTRIÇÃO)

Seleção: seja uma expressão booleana C do tipo R.A ScreenHunter_253 Oct. 19 20.13C, onde C é uma constante do tipo de A que queremos comparar com o atributo A de uma linha de R. Então,

ScreenHunter_268 Oct. 19 21.45 c(R) é uma relação que inclui unicamente as linhas de R para as quais C é verdadeiro.

Exemplo:

ScreenHunter_269 Oct. 19 21.46

Expressões booleanas mais complexas envolvendo “ands” ou “ors” de operandos do tipo R.A  c podem ser avaliadas através de operações de união e interseção, mas, para simplificar a notação, vamos admitir em C expressões booleanas arbitrariamente complexas.

Se quisermos, podemos compor quaisquer operações, por exemplo:

ScreenHunter_270 Oct. 19 22.01

Indicada por   ScreenHunter_268 Oct. 19 21.45  (a letra grega sigma), é uma operação que para um conjunto inicial fornecido como argumento, produz um subconjunto estruturalmente idêntico, mas apenas com os elementos do conjunto original que atendem a uma determinada condição (também chamada de predicado). A seleção pode ser entendida como uma operação que filtra as linhas de uma tabela, e é também uma operação unária, já que opera sobre um único conjunto de dados.

Ex.:  ScreenHunter_268 Oct. 19 21.45 Sexo = ‘M’ (funcionário)

Produz o conjunto dos elementos de funcionário que atendem ao predicado [Sexo = ‘M’], ou seja, representa um subconjunto dos funcionários para o qual essa condição é avaliada como verdadeira.

ScreenHunter_271 Oct. 19 22.03.jpg

No caso de querermos descobrir o nome completo e a data de admissão de todos os funcionários do sexo feminino existentes na empresa, será necessário combinar uma projeção com uma seleção. Isso porque se decidirmos projetar as colunas desejadas diretamente a partir da relação funcionário, estaremos considerando também os elementos do sexo masculino, o que não queremos.

Como a projeção não permite descartar linhas, apenas colunas, deveremos fornecer a essa operação o subconjunto resultante de uma filtragem (seleção) da relação de funcionários original, como mostram as duas figuras a seguir, que representam as relações e as operações de duas maneiras diferentes.

ScreenHunter_272 Oct. 19 22.04.jpg

 

ScreenHunter_273 Oct. 19 22.05

Assim, a expressão que atende nossos objetivos nesse caso é

ScreenHunter_266 Oct. 19 21.42 NmFunc, DtAdm ( ScreenHunter_268 Oct. 19 21.45 Sexo = ‘F’ (funcionário))

cabendo observar que devido ao aninhamento das operações está implícito que primeiro será executada a seleção e depois a projeção, sendo que nesse exemplo não poderíamos inverter essa ordem.

Você poderia explicar porquê?

Por esse motivo, dizemos que a álgebra relacional é uma linguagem procedural, já que requer alguma definição quanto à ordem em que as operações serão realizadas. Linguagens em que apenas  mencionamos o resultado desejado, sem fazer menção alguma à forma como isso deve ser feito são chamadas de linguagens não-procedurais.

Suponha agora que precisamos obter o nome completo, a data de admissão e o salário de cada funcionário cadastrado.

Para essa consulta temos um fato novo, que é a referência a colunas de mais de uma tabela, uma vez que o nome e a data de admissão fazem parte da relação funcionário, enquanto que o salário existe apenas em cargos.

Isso é problemático, pois as duas operações que conhecemos até o momento são unárias, e temos necessidade de combinar os dados de mais de uma relação. Para situações como essa existe uma operação chamada Produto Cartesiano.

Produto Cartesiano

Produto Cartesiano: R x S : é uma relação obtida concatenando-se cada linha de R com cada linha de S, isto é, os atributos do produto cartesiano são os atributos de R, seguidos pelos atributos de S (se houver coincidência nos nomes de alguns atributos de R e S, a forma conveniente de distingui-los deve ser usada, como por exemplo R.C e S.C). Se R possui n atributos e K linhas e S possui m atributos e 1 linha então R x S possui n + m atributos e k x l linhas.

Exemplo de Produto Cartesiano

ScreenHunter_274 Oct. 19 22.08A notação geralmente adotada (na forma ‘conjunto1 x conjunto2’) para representar essa operação binária indica bem a sua natureza: o resultado do produto cartesiano de duas tabelas é uma terceira tabela contendo todas as combinações possíveis entre os elementos das tabelas originais.

Essa tabela resultante possuirá um número de colunas que é igual à soma das quantidades de colunas das duas tabelas iniciais, e um número de linhas igual ao produto do número de suas linhas.

Portanto, se fizermos o produto cartesiano de uma tabela A que possua 4 colunas e 10 linhas com uma tabela B onde existem 3 colunas e 7 linhas, a tabela resultante terá 4+3= 7 colunas e 10*7= 70 linhas. Assim, cada linha dessa tabela corresponderá à concatenação de uma linha da primeira tabela com uma linha da segunda.

O produto cartesiano não é muito usado como um fim em si mesmo, ou seja, dificilmente estaremos interessados em saber quais são todas as combinações possíveis entre as linhas de duas tabelas, pois a utilidade prática desse tipo de conhecimento é muito discutível.

Entretanto, é a única forma primitiva de que dispomos para fundir informações de duas tabelas heterogêneas para posterior processamento.

Nesse caso, tipicamente será necessário executar uma Seleção sobre o resultado do Produto Cartesiano, de maneira a descartar as combinações inválidas entre as linhas das tabelas originais.

Ex.: ScreenHunter_266 Oct. 19 21.42 NmFunc, DtAdm, VrSalário  ScreenHunter_268 Oct. 19 21.45(funcionário.CdCargo = cargo.CdCargo (funcionário x cargo))

Observe que primeiro é produzido o produto cartesiano correspondente a todas as combinações possíveis entre funcionários e cargos.

Essa relação vai conter linhas onde um funcionário estará associado a cargos que não são o seu, e devemos então aplicar um filtro (uma seleção) para gerar um subconjunto apenas com as combinações logicamente válidas (aquelas em que a chave estrangeira CdCargo de funcionário tem valor igual á chave primária CdCargo de cargo).

Como temos nesse subconjunto duas colunas com o mesmo nome (CdCargo que veio de funcionário e CdCargo proveniente de cargo), sempre que precisarmos mencionar uma delas será necessário especificar exatamente a qual das duas colunas estamos nos referindo, senão teremos uma situação ambígua, formalmente inaceitável.

Dizemos, nesse caso, que é necessário qualificar a coluna, e isso é feito escrevendo o nome da relação original antes do nome da coluna, separando-os por um ponto, ou seja, <nome-da-relação>.<nome-da-coluna>. É por esse motivo que escrevemos o predicado da seleção como sendo funcionário.CdCargo = cargo.CdCargo. Finalmente, a projeção é realizada a partir desse subconjunto, fornecendo os dados inicialmente desejados.

ScreenHunter_275 Oct. 19 22.11.jpg

ScreenHunter_276 Oct. 19 22.12.jpg

ScreenHunter_277 Oct. 19 22.13

ScreenHunter_278 Oct. 19 22.13.jpg

Caso desejemos obter uma variação ligeiramente diferente dessa consulta, acrescentando a restrição de que precisamos dos dados apenas dos funcionários do sexo masculino, teríamos a seguinte expressão algébrica:

ScreenHunter_279 Oct. 19 22.14.jpg

onde o símbolo “^” presente no predicado representa o conectivo lógico “E”. Portanto, com apenas 3 operações relacionais básicas foi possível extrair do banco de dados de exemplo várias informações importantes, representativas de uma grande parcela das consultas que um sistema gerenciador de bancos de dados deve processar.

As consultas realizadas foram:

  1. obter o nome completo de todos os funcionários;
  2. identificar todos os funcionários do sexo masculino;
  3. obter o nome completo e a data de admissão de todos os funcionários do sexo feminino;
  4. obter o nome completo, a data de admissão e o salário de todos os funcionários;
  5. descobrir o nome completo, a data de admissão e o salário de todos os funcionários do sexo masculino.

JUNÇÃO

Junção ScreenHunter_253 Oct. 19 20.13: nesta operação comparamos duas colunas do mesmo tipo de R e S, por exemplo R.A   S.B. Se a comparação der verdadeira, selecionamos a linha correspondente do produto cartesiano RxS. A junção ScreenHunter_253 Oct. 19 20.13é denotada por:

R | X | S

R.A ScreenHunter_253 Oct. 19 20.13S.B

A junção ScreenHunter_253 Oct. 19 20.13de duas relações é, portanto, um subconjunto do seu produto cartesiano e pode ser expressa pela identidade:

R | X | S = ScreenHunter_268 Oct. 19 21.45 (R.A ScreenHunter_253 Oct. 19 20.13S.B) (R X S)

R.A ScreenHunter_253 Oct. 19 20.13S.B

Exemplo: vamos utilizar outra relação para exemplificar a junção ScreenHunter_253 Oct. 19 20.13 Seja a relação T com esquema T(B,C,D) e uma instancia de T abaixo:

ScreenHunter_280 Oct. 19 22.18.jpg

ScreenHunter_281 Oct. 19 22.19

Para isso, temos a seguinte explicação:

Produto cartesiano entre R  X  T

ScreenHunter_282 Oct. 19 22.20

Posteriormente, comparamos as linhas de R.B que sejam >= a TD, tendo o resultado apresentado.

É uma operação que produz uma combinação entre as linhas de uma tabela com as linhas correspondentes de outra tabela, sendo em princípio correspondente a uma seleção pelos atributos de relacionamento sobre um produto cartesiano dessas tabelas:

ScreenHunter_283 Oct. 19 22.21

A operação de junção foi criada justamente porque esse tipo de combinação de tabelas é de uso muito comum, facilitando com isso a escrita de expressões.

A tabela resultante de uma junção tem todas as colunas da primeira tabela e todas da segunda tabela.

Isso faz com que os valores dos campos utilizados como critério para a correspondência entre as linhas apareça duplicado, já que um vem da primeira tabela e outro da segunda.

Existe uma variação da junção, chamada junção natural, que fornece o mesmo resultado, mas sem essa repetição de valores: uma das colunas correspondentes aos atributos de relacionamento é descartada.

JUNÇÃO NATURAL

Junção natural: quando ScreenHunter_253 Oct. 19 20.13é o operador de igualdade, o resultado do produto cartesiano terá duas colunas idênticas, R.A e S.B. Nesse caso é conveniente projetar fora uma dessas colunas e o resultado final é chamado de junção natural de R com S. Se as colunas sobre as quais fizermos a junção tiverem o mesmo nome em R e S, então se pode simplificar a notação escrevendo apenas:

R | X | S

Para indicar esta operação, ficando implícitas as colunas sobre as quais é feita a comparação. Exemplo: a junção das tabelas R e T acima, sobre as colunas R.B e T.B seria expressa por:

ScreenHunter_284 Oct. 19 22.23

Obs: A comparação é feita sobre o produto cartesiano.

 

RESUMO

ScreenHunter_285 Oct. 19 22.24

Exercícios – Parte 1

Com base nas tabelas Funcionário, Cargo e Depto apresentadas neste material, elaborar as expressões da álgebra relacional que obtenham:

ScreenHunter_286 Oct. 19 22.25

Exemplo de Dados:

ScreenHunter_287 Oct. 19 22.26

1 – Todos os funcionários do departamento ‘D1’.

2 – O nome e a matrícula de todos os funcionários do departamento ‘D1’.

3 – A matrícula e o nome do respectivo departamento de todos os funcionários.

4 – O nome dos funcionários que ganham mais de $500.

5 – O ramal do funcionário ‘ANA SILVEIRA’.

6 – Os nomes de todos os funcionários com cargo de ‘MECANICO’.

7 – Os nomes de todos os funcionários que trabalham no mesmo departamento que ‘JOSE NOGUEIRA’.

8 – Os nomes dos departamentos que possuem tanto funcionários como funcionárias.

 

Exercício – Parte 2

Considere as Relações F e D que representam os CEs Funcionários e Dependentes, respectivamente, com o seguinte esquema simplificado: F(fumf, nomef) e D(numf, nomef, par), onde numf: número do funcionário, nomef: nome do funcionário, nomed: nome do dependnete e par: parentesco, que pode ser um dentre: “filho”, “filha”, “esposa/o” etc. Observe que em D, numf é a chave estrangeira que referencia a chave primária numf de F. Abaixo é mostrada uma possível instância dessas relações:

ScreenHunter_288 Oct. 19 22.28

Vamos obter agora a junção natural F | x | D (ela vai usar a coluna numf para junção)

ScreenHunter_289 Oct. 19 22.29

Observe que a junção natural apresenta para cada funcionário que possui dependentes, os dados do funcionário e dos seus dependentes. Como o funcionário 04 não possui dependentes, ele não aparece no resultado da junção. Vamos agora obter expressões da álgebra relacional que respondem as seguintes consultas:

1.Quais os nomes e parentescos de todos os dependentes?

2.Quais os funcionários(numero de) possuem dependentes filhas?

3.Quais funcionários não possuem dependentes?

4.De os nomes dos funcionários que possuem algum dependente.

5.Dê o nome de cada funcionário que possui uma dependente chamada Alice

6.Quais funcionários possuem mais de um dependente?

Referência Bibliográfica

  • GUIMARÃES, Célio Cardoso.  FUNDAMENTOS DE BANCOS DE DADOS: modelagem, projeto e linguagem SQL. 1. ed. Campinas: Universidade de Campinas. 2003.

 

 

Vídeo

 

Banco de Dados I – Aula 10E

Crie no Microsoft Access para cada exercício um banco de dados dos exercícios resolvidos

Formas Normais – Formulário de manutenção técnica 

1FN (ITENS DE REPETICAO, OU MULTIVALORADOS TRANSFORMAR EM OUTRA TABELA)

EMPRESA (COD_EMP, RAZAO, ENDERECO, CIDADE, UF, CEP, FONE)

FUNCIONARIO (COD_FUN, NOME, …)

SITUACAO_SERV (TIPO)

FUNCIONARIO_CLI (RG_FUN_CLI, NOME_FUN_CLI, COD_EMP)

OBS (FUNCIONARIO_CLI. COD_EMP à CLIENTE.COD_EMP)

ACAO_SERV (TIPO, RG_FUN_CLI)

OBS (ACAO_SERV.TIPO à SITUACAO_SERV.TIPO)

OBS (ACAO_SERV.RG_FUN_CLI à FUNCIONARIO_CLI.RG_FUN_CLI)

CLIENTE (COD_EMP_CLI, RAZAO, ENDERECO, BAIRRO, COMPLEMENTO, CIDADE, UF, CEP)

TELEFONE_CLI (COD_EMP_CLI, TELEFONE)

OBS (TELEFONE_CLI.COD_EMP_CLI à CLIENTE.COD_EMP_CLI)

SOLUCAO (COD_SOL, DESC_SOL)

SERVICO (COD_SERV, DESC_SERV)

ATENDIMENTO (NR_ORDEM, DATA_ABERTURA, HORA_ABERTURA, DATA_PREVISTA, HORA_PREVISTA, DATA_SOL, HORA_SOL, COD_EMP_CLI, COD_EMP, COD_FUN)

OBS (ATENDIMENTO.COD_EMP_CLI à CLIENTE.COD_EMP_CLI)

OBS (ATENDIMENTO.COD_EMP à EMPRESA.COD_EMP)

OBS (ATENDIMENTO.COD_FUN à FUNCIONARIO.COD_FUN)

SOL_PRESTADA (NR_ORDEM, COD_SOL)

OBS (SOL_PRESTADA.NR_ORDEM à ATENDIMENTO.NR_ORDEM)

OBS (SOL_PRESTADA.COD_SOL à SOLUCAO.COD_SOL)

SERV_PRESTADO (NR_ORDEM, COD_SERV)

OBS (SERV_PRESTADO.NR_ORDEM à ATENDIMENTO.NR_ORDEM)

OBS (SERV_PRESTADO.COD_SERV à SERVICO.COD_SERV)

 

Banco de Dados I – Aula 10D

Crie no Microsoft Access para cada exercício um banco de dados dos exercícios resolvidos

 

Formas Normais – Pedido de Compras 

PEDIDO (NR_PEDIDO, DATA, DEPTO_ORIGEM, FUNC_SOLICITANTE, DEPTO_DESTINO, FUNC_RESPONSAVEL, TOTAL_QTD)

 ITEM_PEDIDO (NR_PEDIDO, ITEM, MATERIAL, QUANTIDADE)

 

2NF (DEPENDENCIA PARCIAL DOS CAMPOS NÃO CHAVE, TRANSFORMAR EM OUTRA TABELA)

PEDIDO (NR_PEDIDO, DATA, DEPTO_ORIGEM, FUNC_SOLICITANTE, DEPTO_DESTINO, FUNC_RESPONSAVEL, TOTAL_QTD)

ITEM_PEDIDO (NR_PEDIDO, ITEM, MATERIAL, QUANTIDADE)

OBS: ITEM_PEDIDO.COD_MATERIAL à MATERIAL.COD_MATERIAL)

 

3FN (ANALISAR OS CAMPOS NÃO CHAVES SE SÃO DEPENDENTES DE OUTROS CAMPOS NÃO CHAVE. CASO SIM, TRANSFORMAR EM OUTRA TABELA)

PEDIDO (NR_PEDIDO, DATA, COD_DEPTO_ORIGEM, COD_FUNC_SOL, COD_DEPTO_DESTINO, COD_FUNC_RESP)

OBS: PEDIDO.COD_DEPTO_ORIGEM à DEPARTAMENTO.COD_DEPTO)

OBS: PEDIDO.COD_FUNC_SOL à FUNCIONARIO.COD_FUNC)

OBS: PEDIDO.COD_DEPTO_DESTINO à DEPARTAMENTO.COD_DEPTO)

OBS: PEDIDO.COD_FUNC_RESP à FUNCIONARIO.COD_FUNC)

DEPARTAMENTO (COD_DEPTO, DEPARTAMENTO)

 FUNCIONARIO (COD_FUNC, FUNCIONARIO)

 ITEM_PEDIDO (NR_PEDIDO, ITEM, COD_MATERIAL, QUANTIDADE)

OBS: ITEM_PEDIDO.COD_MATERIAL à MATERIAL.COD_MATERIAL)

 MATERIAL (COD_MATERIAL, MATERIAL)

Video

Banco de Dados I – Aula 10C

Crie no Microsoft Access para cada exercício um banco de dados dos exercícios resolvidos

Estudo de Caso 2 – Gerência Acadêmica de uma Universidade 

PROFESSOR (COD_PROF, NOME, INSCRICAO_GA, COD_DEPTO)

OBS: PROFESSOR.COD_DEPTO à DEPARTAMENTO.COD_DEPTO

PROFESSOR_HABILITADO (COD_PROF, CFE)

DEPARTAMENTO (COD_DEPTO, NOME_DEPTO)

CURSO (COD_CURSO, NOME, NR_TOTAL_HORAS, COD_DEPTO)

OBS (CURSO.COD_DEPTO à DEPARTAMENTO.COD_DEPTO)

DISCIPLINA (COD_DISC, DESCRICAO, DESC_CURRICULAR, PRE_REQUISITO, COD_DEPTO, COD_PROF)

OBS (PRE_REQUISITO à COD_DISC)

OBS (DISCIPLINA.COD_DEPTO à DEPARTAMENTO.COD_DEPTO)

OBS (DISCIPLINA.COD_PROF à PROFESSOR_HABILITADO.COD_PROF)

DISCIPLINA_OBRIGATORIA (COD_DISC, HORA_OBRIGATORIA)

COMPOR (COD_CURSO, COD_DISC, TIPO_DISCIPLINA)

ALUNO (NR_MATRICULA, TIPO_ADMISSAO, NOME, ENDERECO, COD_CURSO)

OBS (ALUNO.COD_CURSO à CURSO.COD_CURSO)

HISTORICO (NR_MATRICULA, COD_DISC, DATA_DISC_CURSADA, NOTA)

OBS (HISTORICO.NR_MATRICULA à ALUNO.NR_MATRICULA)

OBS (HISTORICO.COD_DISC à DISCIPLINA.COD_DISC)

Video

Banco de Dados I – Aula 10B

Criando um banco de dados no Microsoft-Access

 

Para ilustrar a criação simples de banco de dados, iremos utilizar os exemplos normalizados:

Primeiramente, crie um banco de dados vazio no Microsoft Access;

Untitled

Dê um nome ao banco de dados:

Untitled2

Como criamos um banco de dados vazio, o MS-Access irá pedir os dados para a nova tabela;

Classificando o tipo de dados

 

Usaremos os tipos básicos de dados que o MS-Access oferece. Os tipos de dados servem para classificarmos os mesmos. Determinado dado tem certa característica(s). Por exemplo: “DQF-2134”, “15/07/2000”, “16”, “Ana Cristina da Silva”, “13.200-015”, “São Paulo”. Podemos observar que os dados possuem caracteres numéricos e alfanuméricos.  Observando os valores dos dados, podemos classificar o seu tipo.

O MS-Access possui alguns outros tipos de dados:

Untitled3

Iremos criar as tabelas abaixo, conforme exercício passado:

ESTOQUE_ITENS(NR_CONTROLE,ITEM, COD_PECA, QUANTIDADE, TIPO_MOVIMENTACAO, COD_SETOR)

PECA(COD_PECA, DESCRICAO_PECA)

SETOR(COD_SETOR, DESC_SETOR)

ESTOQUE(NR_CONTROLE, DATA, COD_FUNC_REP, COD_FUNC_RESP)

FUNCIONARIO(COD_FUNC, NOME_FUNC)

Criando tabelas no MS-ACCESS

Tabelas a serem criadas:

Untitled4

Untitled5

Untitled6

Untitled7

Realize após a construção das tabelas testes de inserção de dados. Perceba que ainda não haverá nada que impeça o usuário colocar um dado que não exista nas tabelas bases.

Relacionamento entre tabelas

Para fazer o relacionamento no ACCESS, vá no menu “Ferramentas de Banco de Dados” / Relações

Untitled8

Selecione todas as tabelas e pressione “Adicionar”

Untitled9

Após a inclusão de todas as tabelas, aparecerá as tabelas “não-relacionadas”, conforme figura abaixo:

Untitled10

Arraste o campo “NR_CONTROLE” da tabela “ESTOQUE” para o campo “NR_CONTROLE” da tabela “ESTOQUE_ITENS”. A seguinte tela aparecerá:

Untitled11

Faça o mesmo processo para os demais itens do banco de dados, deixando igual a figura abaixo:

Untitled12

Teste novamente a inserção de dados;

Vídeo

Banco de Dados I – Aula 10A

PROJETANDO BANCO DE DADOS

  • Segundo OLIVEIRA, (2002, p.21), antes de utilizarmos os comandos SQL, vamos identificar a forma de planejar a criação do banco de dados. Esse planejamento é extremamente importante para a estabilidade de todo o sistema. Estudos indicam que quanto maior o tempo despendido no projeto do banco de dados, menor será o tempo despendido na manutenção do modelo.
  • OLIVEIRA (2002, p.21) explica ainda que podemos comparar a criação de um sistema com a construção de um edifício. O projeto de banco de dado está para o sistema da mesma forma que a estrutura do prédio está para o edifício. Se não for dada a devida atenção ao desenho do banco de dados, pode-se comprometer todo o desenvolvimento do sistema.
  • É como construir um edifício utilizando uma base inadequada: um dia o edifício cairá. De outra forma, quanto maior for o tempo dedicado ao estudo das necessidades de informação do sistema em desenvolvimento, maior será o tempo economizado no desenvolvimento do sistema.
  • O sistema terá melhor qualidade, e será mais fácil, no futuro, implementar novas rotinas, procedimentos e agregar novas informações necessárias.
  • O processo de análise dos dados pressupõe três fases distintas e integradas, como apresenta a figura a seguir

ScreenHunter_249 Oct. 16 19.54

  • Segundo o autor e colunista Ricardo Rezende, da revista especializada em desenvolvimento da Devmedia, o sistema de banco de dados deve garantir uma visão totalmente abstrata do banco de dados para o usuário.
  • Para o usuário do banco de dados pouco importa qual unidade de armazenamento está sendo usada para guardar seus dados, contanto que os mesmos estejam disponíveis no momento necessário.

 

  • Esta abstração se dá em três níveis–Nível de visão do usuário: as partes do banco de dados que o usuário tem acesso de acordo com a necessidade individual de cada usuário ou grupo de usuários;–Nível conceitual: define quais os dados que estão armazenados e qual o relacionamento entre eles;–Nível físico: é o nível mais baixo de abstração, em que define efetivamente de que maneira os dados estão armazenados

ScreenHunter_250 Oct. 16 19.59

  • Todo bom sistema de banco de dados deve apresentar um projeto, que visa a organização das informações e utilização de técnicas para que o futuro sistema obtenha boa performance e também facilite infinitamente as manutenções que venham a acontecer.
  • O projeto de banco de dados se dá em duas fases:
    • Modelagem conceitual;
    • Projeto lógico.
  • Estas duas etapas se referem a um sistema de banco de dados ainda não implementado, ou seja, que ainda não exista, um novo projeto. Para os casos em que o banco de dados já exista, mas é um sistema legado, por exemplo, ou um sistema muito antigo sem documentação, o processo de projeto de banco de dados se dará através da utilização de uma técnica chamada de Engenharia Reversa, que será visto em outra oportunidade.

 

Modelo Conceitual

  • É a descrição do BD de maneira independente ao SGBD, ou seja, define quais os dados que aparecerão no BD, mas sem se importar com a implementação que se dará ao BD. Desta forma, há uma abstração em nível de SGBD.
  • Uma das técnicas mais utilizadas dentre os profissionais da área é a abordagem entidade-relacionamento (ER), onde o modelo é representado graficamente através do diagrama entidade-relacionamento (DER)

Exemplo 01

ScreenHunter_251 Oct. 16 20.15

O modelo acima, entre outras coisas, nos traz informações sobre Alunos e Turmas. Para cada Aluno, será armazenado seu número de matrícula, seu nome e endereço, enquanto para cada turma, teremos a informação de seu código, a sala utilizada e o período.

Já no modelo abaixo, exemplo de MER contendo assunto referente a locadora.

Exemplo 02

Untitled

Modelo Lógico

  • Descreve o BD no nível do SGBD, ou seja, depende do tipo particular de SGBD que será usado. Não podemos confundir com o Software que será usado. O tipo de SGBD que o modelo lógico trata é se o mesmo é relacional, orientado a objetos, hierárquico, etc.
  • Abordaremos o SGBD relacional, por serem os mais difundidos. Nele, os dados são organizados em tabelas

Untitled2

  • O modelo lógico do BD relacional deve definir quais as tabelas e o nome das colunas que compõem estas tabelas.

 

  • Para o nosso exemplo, poderíamos definir nosso modelo lógico conforme o seguinte:

Aluno(mat_aluno, nome, endereco)
Turma (cod_turma, sala, periodo)

  • É importante salientar que os detalhes internos de armazenamento, por exemplo, não são descritos no modelo lógico, pois estas informações fazem parte do modelo físico, que nada mais é que a tradução do modelo lógico para a linguagem do software escolhido para implementar o sistema.
  • GUIMARÃES (2003, p.32) defende que como muitas aplicações de engenharia, o projeto de uma base de dados através da técnica top down ou de refinamento sucessivos é largamente utilizado. Ele começa pela análise dos requisitos dos usuários finais da BD e da visão externa que eles têm sobre os dados.
  • Esta visão e requisitos dependem da aplicação pretendida da BD, variam de um usuário para outro dentro da organização, e refletem suas necessidades para o trabalho diário. Ela é comumente informal e incompleta, em graus que variam com o nível de informatização da aplicação (ou da organização).
  • Os objetivos finais dessa análise são: (i) obter uma visão unificada de todos os dados da aplicação, e (ii) definir os procedimentos funcionais para operar com os dados.
  • É portanto, uma sistemática similar à análise de sistemas convencional.
  • Esta visão unificada dos dados é comumente chamada de modelagem de dados e corresponde a uma abstração do mundo real contendo o conjunto de informações sobre o mesmo que julgamos importante armazenar e manipular.
  • O projeto top down da BD através de modelagem de dados consiste em especificar os dados através de refinamento sucessivos, mapeando os dados definidos num nível mais alto e abstrato para o nível seguinte, menos abstrato e mais detalhado.
  • No nível mais alto a visão e requisitos da BD ainda é informal e é normalmente apresentada sob a forma de documentos textuais. Vamos denominá-la de visão externa de dados.
  • O próximo nível consiste na especificação lógica dos dados num formato de projeto lógico de dados e, dependendo do SGBD escolhido, pode ser de nível suficientemente alto para esconder a maioria dos detalhes de implementação.
  • O último nível é denominado de projeto físico dos dados e corresponde à organização interna do armazenamento dos dados pelo SGBD e à definição de estruturas de dados auxiliares visando uma maior eficiência na recuperação e manipulação dos dados. Dependendo do SGBD uma parte considerável do nível físico fica escondida das aplicações.

ScreenHunter_252 Oct. 16 21.10

A linguagem SQL

  • Segundo GUIMARÃES (2003, p.99), o modelo relacional desenvolvido por [Codd70] definiu as metalinguagens álgebra relacional e cálculo relacional, que implementam os conceitos básicos do modelo. Elas tiveram grande influencia no desenvolvimento subseqüente de propótipos do modelo relacional.
  • SQL (Structured Query Language) é uma linguagem de definição e de manipulação de dados relacionais, desenvolvida nos laboratórios da IBM nos anos 70 e hoje padronizada pelos comitês ISO/ANSI.
  • OLIVEIRA (2002, p.18), complementa que SQL é um conjunto de comandos de manipulação de banco de dados utilizado para criar e manter a estrutura desse banco de dados, além de incluir, excluir, modificar e pesquisar informações nas tabelas dele. A linguagem SQL não é uma linguagem de programação autônoma; poderia ser chamada de “sublinguagem”.
  • A linguagem SQL não é procedural, logo é possível especificar o que deve ser feito, e não como deve ser feito. Dessa forma, um conjunto de linhas (set) será atingido pelo comando e não cada uma das linhas, como é feito no ambiente procedural. Portanto, não é necessário entender o funcionamento interno do banco de dados e como e onde estão armazenados fisicamente os dados.
  • Teoricamente deveria ser possível transferir facilmente os comandos SQL de um banco de dados para outro. Contudo, isso não é possível. Naturalmente, boa parte do trabalho poderá ser aproveitado, mas deve-se fazer adaptações em função do banco de dados que está sendo utilizado.

 

Divisão da linguagem SQL

  • DDL (Data Definition Language): permite a criação dos componentes do banco de dados, como tabelas, indicies, etc. Os principais comandos são: CREATE TABLE, ALTER TABLE, DROP TABLE, CREATE INDEX, ALTER INDEX, DROP INDEX;
  • DML (Data Manipulation Language): permite a manipulação dos dados armazenados no banco de dados. Comandos DML: INSERT, DELETE, UPDATE;
  • DQL (Data Query Language): permite extrair dados do banco de dados. Comando: SELECT
  • DCL (Data Control Language): provê segurança interna do banco de dados: Comandos: CREATE USER, ALTER USER, GRANT, REVOKE, CREATE SCHEMA;
  • Com o advento da SQL-99, a linguagem SQL passou a incorporar comandos procedurais (Begin, IF, funções, procedimentos) que, na prática, já existiam como extensões da linguagem.
  • Essas extensões, até hoje, são específicas de cada banco de dados e, portanto, a Oracle tem a sua própria linguagem procedural que estende a SQL, que é a PL/SQL.
  • A Microsoft incorporou no SQLServer o Transact-SQL com o mesmo objetivo. A idéia é que, num futuro próximo, exista um padrão de programação em todos os banco de dados.

Vídeo

Banco de Dados I – Aula 08B

FORMAS NORMAIS

  • Segundo BATTIST (2005, P. 16), o objetivo da normalização é evitar os problemas provocados por falhas no projeto do Banco de Dados, bem como eliminar a “mistura” de assuntos e as correspondentes redundâncias de dados.
  • A normalização de tabelas é utilizada para tentar detectar erros no projeto das tabelas e atributos de cada tabela e corrigir estes erros, antes da criação e utilização do Banco de Dados.
  • É bem mais fácil (e barato), corrigir os erros na fase de projeto do que depois que o Banco de Dados já estiver em uso.
  • Uma “Regra de ouro” que devemos observar quanto ao projeto de banco de dados é a de “não misturar assuntos em uma mesma tabela”.
  • GUIMARAES (2003, p.81) complementa que existe um considerável aparato teórico por trás dos conceitos de normalização de relações. As razões para estudá-los, no entanto, são de ordem prática. Eles nos vão ajudar a projetar base de dados com menos possibilidade de inconsistências e menos redundâncias de informação.
  • Eles também vão ajudar a determinar com mais precisão certos tipos de restrições sobre atributos de uma relação assim como a determinação das suas possíveis chaves.
  • Por exemplo, na tabela Clientes, devemos colocar somente campos relacionados com o assunto Clientes. Não devemos misturar campos relacionados com outros assuntos, tais como pedidos, produtos etc. Essa “mistura de assuntos” em uma mesma tabela acaba por gerar repetição desnecessária dos dados bem como inconsistências dos dados.
  • O processo de normalização aplica uma série de regras sobre as tabelas de banco de dados, para verificar se estas estão corretamente projetadas. Embora existam cinco formas normais (ou regras de normalização), na prática usamos um conjunto de três formas normais.
  • Frequentemente, após a aplicação das regras de normalização, algumas tabelas acabam sendo divididas em duas ou mais, o que no final gera um número maior de tabelas do que o número de tabelas originalmente projetado.
  • Este processo causa a simplificação dos atributos de uma tabela, colaborando significativamente para a estabilidade do projeto de banco de dados, reduzindo-se as necessidades de manutenção e alterações, após o banco ter sido colocado em produção.

Primeira Forma Normal

  • BATTIST diz que a Regra: “Uma tabela está na Primeira Forma Normal quando seus atributos não contem grupos de repetição”. Por isso dizemos que uma tabela que possui grupos de repetição não está na Primeira Forma Normal.
  • Exemplo de uma tabela que não está normalizada na 1 FN (BATTIST, 2005, p.17)

ScreenHunter_238 Sep. 26 21.36

  • GUIMARAES (p.84) diz que a 1FN é considerada como a própria definição do MR: Toda relação está em 1FN, isto é, não possui atributos multivalorados nem relações aninhadas e será tomada como implícita.
  • Podemos notar que uma tabela com esta estrutura apresenta diversos problemas. Por exemplo, se um casal tiver mais do que um filho, teríamos que digitar o nomes do pai e da mãe diversas vezes, tantas quantos forem os filhos. Isso forma um grupo de repetição.
  • Pode ser que, por erro de digitação, o nome dos pais não apareça exatamente igual todas as vezes, o que pode acarretar problemas na hora de fazer pesquisas ou emitir relatórios. Este problema ocorre porque misturamos assuntos em uma mesma tabela. Colocamos as informações dos pais e dos filhos em uma mesma tabela. (BATTIST, p. 17)
  • A solução para este problema é simples: criamos uma tabela separada para a informação dos pais e relacionamos a tabela Pais com a tabela Filhos através de um relacionamento do tipo Um para Muitos, ou seja, um casal pode ter vários filhos.
  • As Tabelas Pais e Filhos estão na Primeira Forma Normal (BATTIST, 2005, p.17)

ScreenHunter_239 Sep. 26 21.38

  • As duas tabelas resultantes da aplicação da Primeira Forma Normal, Pais e Filhos, estão na Primeira Forma Normal. A tabela original, a qual misturava informações de pais e filhos, não está na Primeira Forma Normal.
  • OLIVEIRA (2002, p.53) complementa que a solução para este caso é que devemos separar a informação que se repete em uma nova entidade. Devemos ainda levar a chave primaria da entidade original para a nova entidade gerada (caso contrário, não haverá como relacionar as informações das duas entidades). Feito isso, criaremos a nova chave para a nova entidade.
  • Normalmente podemos localizar um campo que, unido à chave da entidade original, formará a chave da nota tabela (nesse caso, chave concatenada), ou podemos criar um campo para esse fim, caso não exista, Há a possibilidade de criarmos simplesmente uma nova chave não concatenada e independente da entidade original. É uma questão de preferência.
  • Exemplo:

ScreenHunter_240 Sep. 26 21.39

  • Utiliza-se o campo Numero da Faixa como atributo-chave junto com o CodigoDoCD, pois não poderá haver duas faixas com o mesmo número em um único CD. Essa é, portanto, uma chave concatenada.

Segunda Forma Normal

  • Podemos aplicar a Segunda Forma Normal quando tivermos uma chave primária composta. Neste caso, devemos observar se todos os campos, que não fazem parte da chave primária composta, dependem de todos os campos que compõem a chave primária composta. Se algum campo depender somente de parte da chave primária composta, então este campo deve pertencer a outra tabela. (BATTIST, 2005, P.17)
  • Tabela que não está na segunda forma normal (BATTIST, 2005, p.18)

ScreenHunter_241 Sep. 26 21.41

  • A chave primária composta é formada pela combinação dos campos NúmeroDaMatricula e CódigoDoCurso.
  • O campo Avaliação depende tanto do CódigoDoCurso quanto Do NúmeroDaMatricula (cada aluno – representado por sua matricula, tem uma nota em cada disciplina – representada pelo campo CódigoDoCurso), porém o campo DescriçãoDoCurso depende apenas do CódigoDoCurso (a descrição do curso não tem relação com o NúmeroDaMatricula).
  • Com isso, temos um campo que não faz parte da chave primária composta e depende apenas de um dos campos que compõem a chave primária composta. Assim podemos dizer que esta tabela não está na Segunda Forma Normal. (BATTIST, 2005, P.18)
  • A resolução para este problema também é simples: dividimos a tabela, que não está na Segunda Forma Normal, em duas outras tabelas, conforme indicado pela figura abaixo, sendo que as duas tabelas resultantes estarão na segunda forma normal.
  • Duas tabelas que estão na Segunda Forma Normal:

ScreenHunter_242 Sep. 26 21.43

  • OLIVEIRA (2002, p.56) diz  que uma entidade está na segunda forma normal quando todos os seus atributos não chave dependem unicamente da chave. Assim, deve-se perguntar a cada atributo, que não seja a chave da entidade, se ele depende apenas da chave da entidade. O que se procura com isso é medir o grau de dependência entre os atributos.
  • Apenas coisas semelhantes podem ser unidas em grupos semelhantes (entidades nada mais são do que um grupo ou conjunto). A solução sugerida para esse problema é ao identificarmos uma situação como a descrita anteriormente, devemos separar os atributos independentes e criar ou identificar dentre os atributos separados uma nova chave para esta nova entidade.
  • Essa chave deve ser mantida na entidade original como o atributo de relacionamento entre ambas as entidades. Dessa forma, não se perde qualquer informação no modelo.
  • No exemplo anterior, a gravadora, o Autor e a Musica são independentes de suas entidades, CD e Item_CD. Veja que já uma enorme vantagem ao separarmos esses atributos independentes, visto quem se não o fizéssemos, cada alteração em uma das informações deveria ser estendida a todas as linhas da entidade.
  • É muito mais fácil fazer isso apenas na nova entidade criada. Como a relação se dá por meido do campo-chave, não há necessidade de alterar todas as ocorrências em CD ou Item_CD, apenas nas entidades Autor, Gravadora ou Musica.
  • A inclusão de novos atributos também é facilitdada. Atributos que venham a ser relavantes serão acrescentados direamente na entidade Autor (como Data de Nascimento) ou Gravadora (como Endereço e Home Page)

ScreenHunter_243 Sep. 26 21.46

Terceira Forma Normal

  • Segundo BATTIST (p.21), na definição dos campos de uma tabela podem ocorrer casos em que um campo não seja dependente diretamente da chave primária, ou de parte dela, mas sim dependente de um outro atributo constante na tabela, atributo este que não seja a chave primária.
  • Quando isso ocorre, dizemos que a tabela não está na Terceira Forma Normal, conforme indicado pela figura seguinte:
    • Uma tabela que não está na Terceira Forma Normal:

ScreenHunter_244 Sep. 26 21.47

  • Observe que o campo DescriçãoDoCurso depende apenas do campo CodigoDoCurso, o qual não faz parte da chave primária. Por isso dizemos que esta tabela não está na Terceira Forma Normal.
  • A solução para este caso também é simples. Novamente basta dividir a tabela em duas outras, conforme indicado pela figura abaixo. As duas tabelas resultantes estão na Terceira Forma Normal.
    • Duas tabelas que estão na Terceira Forma Normal:

ScreenHunter_245 Sep. 26 21.48

  • OLIVEIRA (p.60) diz que uma entidade está terceira forma normal quando todos os seus atributos não chave não dependem de nenhum outro atributo não chave. Utilizando palavras mais simples, pode-se dizer que um atributo não deve depender de outro atributo. Isso ocorre normalmente em cálculos matemáticos ou em atributos “perdidos” na entidade errada.
  • Se guardamos eles são resultados de uma operação entre dois atributos. Se guardarmos esse valor, estaremos apenas ocupando espaço e abrindo a possibilidade de termos uma informação inconsistente no banco de dados;
  • Exemplo: No nosso exemplo, o atributo TempoTotal é dependente de outro atributo não chave: Tempo, na entidade musica. Ao somarmos o tempo de cada faixa do CD, teremos o tempo total de gravação do CD. Esse campo deve ser eliminado, sem perda de informação para o modelo de dados.

ScreenHunter_246 Sep. 26 21.49

Exercício – Formas Normais

  • Dado a seguinte figura, defina as tabelas utilizando as seguintes formas normais: 1FN, 2FN e 3FN:

ScreenHunter_247 Sep. 26 21.50

Video

GitHub

https://github.com/rodrigoksaito/anchieta/tree/master/BancoDados_I/Aula08

 

Banco de Dados I – Aula 08A

ASPÉCTO TEMPORAL

 

Modelo deve refletir o aspecto temporal

  • Certas aplicações exigem que o BD guarde o histórico de alterações de informações. Por exemplo, um BD de uma seguradora.
  • Pode ser necessário conhecer não só o segurado atual de uma apólice, mas também os do passado.
  • O modelo de um BD que armazena somente os valores atuais de uma informação é diferente do modelo do BD que armazena o histórico da informação. Portanto, é necessário considerar o aspecto temporal na modelagem de dados.
  • Não há regras gerais de como proceder neste caso, mas é possível identificar alguns padrões que se repetem frequentemente na prática.

 

Atributos cujos valores modificam ao longo do tempo

  • Alguns atributos de uma entidade, normalmente aqueles que não são identificadores da entidade, podem ter seus valores alterados ao longo do tempo (por exemplo, o endereço de um cliente pode ser modificado).
  • Algumas vezes, por necessidades futuras de informações, ou até mesmo por questões legais, o banco de dados deve manter um registro histórico das informações.
  • Um exemplo é o valor do salário do empregado.
  • Num sistema de pagamento, não interessa saber apenas o estado atual, mas também o salário durante os últimos meses, por exemplo, para emitir uma declaração anual de rendimentos de cada empregado.
  • Assim, o salário não pode ser modelado como atributo, mas sim como uma entidade.
  • Exemplo

ScreenHunter_229 Sep. 26 20.32

 

ScreenHunter_231 Sep. 26 20.53

 

Relacionamentos que modificam ao longo do tempo

  • Assim como atributos podem ter seus valores modificados ao longo do tempo, também relacionamentos podem ser modificados (instâncias dos relacionamentos podem ser modificados, adicionadas/removidas) e também neste caso pode ser requerido que o banco de dados mantenha um registro histórico das alterações.
  • Quando é considerada a história de suas alterações, relacionamentos 1:1 ou 1:n são transformados n:n.

ScreenHunter_232 Sep. 26 21.05

ScreenHunter_233 Sep. 26 21.06

 

Modelando a dimensão temporal de relacionamentos 1:1

  • Para exemplificar, consideramos o relacionamento LOCAÇÃO (a). Este relacionamento possui cardinalidade 1:1, ou seja, cada empregado está alocado a no máximo uma mesa e cada mesa tem ela alocado no máximo um empregado.
  • Este modela está correto, caso deseje-se armazenar no banco de dados apenas a alocação atual de cada mesa. Entretanto, caso deseje-se armazenar também a história das alocações, isto é, que empregados estiveram alocados a que mesas ao longo do tempo, é necessário modificar o modelo para (b).
  • O relacionamento para a ter cardinalidade N:N, já que, ao longo do tempo um empregado pode ter sido alocado a diversas mesas e uma mesa pode ter sido a ela alocados a muitos empregados.
  • Como um mesmo empregado pode ter sido alocado a mesma mesa múltiplas vezes, torna-se necessário um atributo identificador do relacionamento, a fim de distinguir uma alocação de um determinado empregado a uma mesa, das demais alocações deste emprega à mesma mesa. Com isso surge o atributo identificador data.

ScreenHunter_234 Sep. 26 21.07

ScreenHunter_235 Sep. 26 21.08

  • A figura anterior apresenta uma situação semelhante agora considerando um relacionamento de cardinalidade 1:N. Se quisermos considerar a história das lotações de empregados ao longo do tempo, é necessário transformar o relacionamento para a cardinalidade N:N, já que ao longo do tempo um empregado pode ter atuado em diferentes departamentos.
  • Neste caso pode ocorrer também que atributos da entidade EMPREGADO migrem para o relacionamento. No caso do exemplo, isso ocorrer com o atributo nr doc lotação. Este atributo, que, na primeira versão, migra, na nova versão, para o relacionamento, já que na nova versão um empregado pode estar relacionado com múltiplos departamentos.

 

Modelando a dimensão temporal de relacionamentos N:N

  • Na figura seguinte apresenta mais outro exemplo relacionamento temporal, agora um relacionamento de cardinalidade N:N. Modela-se a inscrição de participantes nos cursos oferecidos por uma empresa de treinamento.
  • Na primeira versão, considera-se apenas os cursos nos quais uma pessoa está inscrita em um determinado instante no tempo. Na segunda versão, considera-se todas as inscrições, inclusive as do passado.
  • A modificação de uma versão para a outra consta da transformação do atrubuto data em atributo identificador. Isso ocorre porque, na segunda versão, um participante pode aparecer relacionamento múltiplas vezes a um determinado curso (caso ele tenha se inscrito múltiplas vezes no curso).
  • O atributo para a distinguir uma inscrição de uma pessoa em um curso, das demais inscrições desta pessoa no mesmo curso.

ScreenHunter_236 Sep. 26 21.10

ScreenHunter_237 Sep. 26 21.10

 

Consultas a dados referentes ao passado

  • Muitas vezes, para evitar o crescimento desmedido do banco de dados, informações referentes ao passado são eliminadas.
  • Entretanto, estas informações podem ser necessárias no futuro, por exemplo, por motivos legais, para realização de auditorias ou para tomada de decisões. Portanto, é necessário planejar, desde a modelagem, por quanto tempo as informações ficarão armazenadas no banco de dados.
  • Caso informações antigas fiquem no banco de dados, podem ser necessários atributos para indicar o status da informação, se atual ou antiga.

 

Planejar o arquivamento de informações antigas

  • Para as informações que serão retiradas do banco de dados e armazenadas em arquivos convencionais, é necessário fazer um planejamento de como estas informações serão acessadas no futuro, caso venham a ser necessárias.
  • Uma solução que poderia ser considerada, é a de reincluir as informações no banco de dados, quando elas forem necessárias no futuro. Isso permite que, para buscar as informações passadas, sejam usados os mesmos procedimentos que são usados para acessar as informações atuais.
  • Entretanto, é necessário considerar que as informações em um banco de dados estão normalmente relacionadas a outras. Casos as ocorrências de entidade que se deseja devolver à base de dados estejam relacionadas a outras ocorrências, é necessário que estas estejam presentes.
  • Se elas também tiverem sido excluídas, deverão ser igualmente devolvidas à base de dados. Essa inclusão pode ser propagada em cascata para outras entidades.

 

Planejar informações estatísticas

  • Em alguns casos, informações antigas são necessárias apenas para tomada de decições. Neste caso, muitas vezes deseja-se apenas dados resultantes de cálculos ou estatísticas sobre as informações, como totais, contagens, médias, etc.
  • Assim pode ser conveniente manter o banco de dados estas informações compiladas e eliminar as informações usadas na compilação.

GitHub

Banco de Dados II – Aula 15

BACKUP

  • Um membro do role de servidor sysadmin pode fazer backup de qualquer banco de dados da instancia e os membros do role de banco de dados db_owner podem fazer backup de seus banco de dados.
  • Voce também pode adicionar um usuário no role de banco de dados fixo db_backupoperator para permitir ao usuário fazer backup de um banco de dados, enquanto impede qualquer outro acesso ao banco de dados.

TIPOS DE BACKUP

  • O SQL Server apresenta quatro diferentes tipos de backup :
    • Completo;
    • Diferencial;
    • Log de Transação;
    • Grupo de arquivos (filegroups)

BACKUP COMPLETO

  • Um backup completo captura todas as páginas que contêm dados dentro de um banco de dados.
  • As páginas que não contém dados não são incluídas no backup.
  • Portanto, um backup nunca é maior (e, a maioria dos casos, é menor) do que o banco de dados para o qual é criado.
  • Um backup completo é a base para a recuperação de um banco de dados e deve existir antes que você possa usar um backup diferencial ou de log de transação;
  • Como é mais comum fazer backup do que restaurar um banco de dados, o mecanismo de backup é otimizado para o processo de backup.

BACKUP

  • Quando um backup é iniciado, o mecanismo de backup captura as páginas dos arquivos de dados o mais rapidamente possível, sem considerar a ordem das páginas, vários threads podem ser usados para gravar páginas em seu dispositivo de backup.
  • Um backup pode ser executado concomitantemente com outras operações do banco de dados.
  • Como pode ser feita alterações no banco de dados enquanto um backup está em execução, o SQL Server precisa acomodá-las ao passo que também garante que os backups sejam consistentes para propósitos de restauração.
  • O fator limitante para a velocidade de um backup é o desempenho do dispositivo onde o backup está sendo gravado.
  • As únicas operações que não são permitidas durante um backup completo são: adicionar ou remover um arquivo do banco de dados e reduzir um banco de dados;
  • Os dois únicos parâmetros exigidos para um backup são o nome do banco de dados e o dispositivo de backup.
  • Quando você especifica um dispositivo de disco para backup, um diretório e um nome de arquivo podem ser especificados;
  • Se não for especificado um diretório, o SQL Server fará o backup no disco e gravará o arquivo no diretório padrão configurado na instancia;
  • Embora a maioria dos backups seja gravada em um único arquivo em disco ou em um único dispositivo em fita, você pode especificar até 64 dispositivos de backup.
  • Quando você especifica mais de um dispositivo de backup, o SQL Server divide o striped backup (backup em faixas) por todos os dispositivos especificados.
  • Quando o SQL Server coloca um striped backup em vários dispositivos, é obrigatório que todos os dispositivos restaurem com sucesso.
  • O SQL Server não fornece failover ou tolerância à falhas dentro do conjunto de faixas. O conjunto de faixas é utilizado estritamente para propósitos de desempenho.

EXEMPLO DE STRIPED BACKUP

--striped backup

use master
go 

--Em Windows
BACKUP DATABASE AdventureWorks2012
  TO DISK = 'C:\temp\AWorks2012_1.bak',
  DISK = 'C:\emp\AWoks2012_2.bak'
GO

--Em Linux
BACKUP DATABASE [AdventureWorks2016CTP3]
  TO DISK = '/var/opt/mssql/AdvWorks2016_1.bak',
  DISK = '/var/opt/mssql/AdvWorks2016_2.bak'
GO

MIRROR TO

  • A cláusula MIRROR TO oferece um recurso interno para criar até quatro cópias de um backup em uma única operação.
  • Quando você inclui a cláusula MIRROR TO, o SQL Server recupera a página uma vez do banco de dados e grava uma cópia da página em cada espelho de backup.
  • Durante a restauração, os espelhos tem um pequeno número de requisitos:
    • Todos os dispositivos de backup devem ser o mesmo tipo de mídia;
    • Cada espelho deve ter o mesmo número de dispositivos de backup;
    • WITH FORMAT deve ser especificado no comando de backup;

DIMINUINDO TEMPOS DE BACKUP

  • A sobrecarga da compactação sempre vale a pena.
  • O tempo economizado por um backup compactado supera em muito a sobrecarga associada à operação de compactação.
  • O SQL Server tem uma opção de configuração chamada padrão de compactação de backup (backup compression default)
  • Você pode configurar de modo a sempre ter backups compactados, independente de especificar a compactação explicitamente, porém está disponível somente no SQL Server Enterprise.
  • Um único dispositivo de backup pode conter vários backups
  • As opções INIT/NOINIT de um comando BACKUP controlam se um arquivo de backup existente é sobrescrito ou recebe anexação.
  • Quando você especifica NOINIT e está fazendo backup em um arquivo já existente, o SQL Server anexa o novo backup no final do arquivo.
  • Se você especifica INIT e o arquivo já existe, o SQL Server sobrescreve o arquivo com o conteúdo do novo backup.
  • Quando CHECKSUM é especificado, o SQL Server confere a soma de verificação da página, se ela existir, antes de gravar a página do backup.
  • Além disso, é calculada uma soma de verificação para o backup inteiro, a qual pode ser usada para determinar se o backup foi corrompido.

BACKUP DE LOG DE TRANSAÇÃO

  • Cada alteração física feita em um banco de dados tem uma entrada inserida no log de transação.
  • Cada linha recebe um número exclusivo internamente, chamado LSN (Log Sequence Number).
  • O LSN é um numero inteiro que começa do 0 quando o banco de dados é criado e é incrementado até o infinito
  • Um LSN nunca é reutilizado para um banco de dados e é sempre incrementado.
  • Basicamente, um LSN fornece um número em sequencia para cada alteração feita em um banco de dados.
  • O conteúdo de um log de transação é dividido em 2 partes básicas – uma ativa e uma inativa.
  • A parte inativa contém todas as alterações efetivadas no banco de dados.
  • A parte ativa contém todas as transações ainda não efetivadas.Quando um backup de log de transação é executado, o SQL Server inicia no menor LSN do log de transação e começa a gravar cada registro de log de transação sucessivo no backup.
  • Assim que o SQL Server atinge o primeiro LSN que ainda não foi efetivado (isto é, a transação aberta mais antiga), o backup de log de transação termina.
  • Então, a parte do log de transação que teve o backup feito é removida, permitindo que o espaço seja reutilizado.
  • Com base no número de sequencia é possível restaurar um backup de log de transação após o outro para recuperar um banco de dados em qualquer ponto no tempo, simplesmente seguindo o encadeamento de transações, conforme identificado pelo LSN.
  • Como os backups de log de transação se destinam a ser restaurados um após o outro, as constraints sobre eles dependem de se ter a sequencia de LSNs inteira intacta.
  • Um backup de log de transação reúne todas as transações efetivadas no log desde o último backup de log de transação.
  • Conteúdo, como um backup de log de transações contém apenas as transações que foram executadas no banco de dados, você precisa de um ponto de partida para o encadeamento de logs de transação.
  • Antes de executar um backup de log de transação, você deve fazer um backup completo.
  • Após o primeiro backup você pode restaurar o banco de dados em qualquer ponto no tempo, desde o encadeamento de logs de transação não seja interrompido.
  • Backups completos adicionais podem ser criados para se ter um ponto de partida mais recente para uma operação de restauração.
  • Independente do número de backups completos criados, desde que você não tenha introduzido uma lacuna no encadeamento de LSNs, pode começar com qualquer backup completo e restaurar qualquer log de transação desse ponto em diante para recuperar um banco de dados.

SINTAXE DO BACKUP DE LOG DE TRANSAÇÃO

Sem título6

BACKUP DIFERENCIAIS

  • Um backup diferencial captura todas as extensões que mudaram desde o último backup completo.
  • O principal objetivo de um backup diferencial é reduzir o número de backups de log de transação que precisam ser restaurados.
  • Um backup diferencial precisa ser aplicado em um backup completo e não pode existir até que um backup completo seja criado.
  • O SQL Server controla cada extensão que foi alterada após um backup completo usando uma página especial no cabeçalho de um banco de dados, chamado DCM (Differential Change Map – mapa de alteração diferencial)
  • Um backup completo zera o conteúdo do DCM.
  • Quando são feitas alterações em extensões dentro do banco de dados, o SQL Server ajusta para 1 o bit correspondente à extensão.
  • Quando um backup diferencial é executado, o SQL Server lê o conteúdo do DCM para localizar todas as extensões que foram alteradas desde o último backup completo.
  • Um backup diferencial não é o mesmo que um backup de log de transação. Um backup diferencial contém todas as páginas alteradas desde o último backup completo.

OPÇÃO COPY ONLY

  • Uma das opções que podem ser especificadas para qualquer tipo de backup é a COPY_ONLY.
  • Cada backup executado em um banco de dados tem um efeito no ponto de partida de uma recuperação e em quais backups podem ser usados.
  • Os backups diferenciais contém todas as extensões que mudaram desde o ultimo backup completo; portanto, todo backup completo executado altera o ponto de partida em que um backup diferencial é baseado.
  • Quando um backup de log de transação é executado, as transações que tiveram o backup feito são removidas do log de transação.
  • Ocasionalmente você precisa gerar um backup para criar um banco de dados para um ambiente de desenvolvimento ou teste.
  • Voce quer ter o conjunto de dados mais recente, mas não quer afetar o conjunto de backup do ambiente de produção.
  • A opção COPY_ONLY permite gerar um backup que pode ser usado para criar o ambiente de desenvolvimento ou teste, mas não afeta o estado do banco de dados nem o conjunto de backups que está em produção.
  • Um backup completo com a opção COPY_ONLY não reinicia a página do mapa de alterações de diferencial e, portanto, não tem nenhum impacto nos backups diferenciais.
  • Um backup de log de transação com a opção COPY_ONLY não remove transações de log de transação.

BACKUP DE GRUPOS DE ARQUIVOS (FILE GROUPS)

  • Embora os backups completos capturem todas as páginas usadas no banco de dados inteiro, o backup completo de um banco de dados grande pode consumir uma quantidade significativa de espaço e tempo.
  • Se você precisa reduzir o tempo de backup, pode contar com o recurso de backups de grupo de arquivos, que permite ter como alvo parte de um banco de dados.
  • Backups de grupo de arquivos podem ser usados em conjunto com os backups diferenciais e de log de transação para recuperar uma parte do banco de dados no caso de uma falha.
  • Além disso, desde que você não precise restaurar o grupo de arquivos principal e esteja usando o SQL Server Enterprise, o banco de dados poderá permanecer online e acessível para os aplicativos durante a operação de restauração.
  • Somente a parte do banco de dados que está sendo restaurada fica offiline.

BACKUPS PARCIAIS

  • Os grupos de arquivo podem ser marcados como somente leitura.
  • Um grupo de arquivos somente leitura não pode ter alterações feitas nos objetos nele armazenados.
  • Como os objetivo dos backups é capturar as alterações para que você possa reconstruir um banco de dados no estado mais atual durante uma operação de recuperação, o backup de grupos de arquivo que não podem mudar consome espaço de forma desnecessária dentro do backup.
  • Para reduzir o tamanho de um backup para apenas os grupos de arquivo que podem mudar, você pode fazer um backup parcial. Os backups parciais são feitos especificando se a opção READ_WRITE_FILEGROUPS

Sem título7

  • Quando um backup parcial é executado, o SQL Server faz o backup do grupo de arquivos principal, de todos os grupos de arquivo de leitura/gravação e de todos os grupos de arquivos somente leitura especificados explicitamente.

CORRUPÇÃO DE PÁGINA

  • A partir do SQL Server 2005, houve a introdução da capacidade de colocar páginas corrompidas em quarentena, enquanto permitia ao banco de dados permanecer online.
  • Executando-se o comando abaixo, o SQL Server detecta páginas corrompidas e as coloca em quarentena.

Sem título8

  • Geralmente a corrupção de páginas são causadas por componentes de hardware que falham, especialmente controladoras e unidades de disco.
  • Antes de uma falha, as controladoras ou unidades de disco podem corromper páginas de dados realizando gravações incompletas;
  • Quando  o SQL Server grava uma página no disco, é calculada uma soma de verificação para a página.
  • Quando você ativa a verificação de página, sempre que uma página é lida do disco o SQL Server calcula uma nova soma de verificação e a compara com a soma de verificação armazenada na página.
  • Se as somas de verificação não corresponderem, o SQL Server retornará um erro e registrará a página em uma tabela no banco de dados msdb;
  • Embora páginas corrompidas possam ser colocadas em quarentena, o SQL Server tem um mecanismo de proteção em vigor para proteger seu banco de dados de uma corrupção generalizada.
  • Há um limite de 1.000 páginas corrompidas no total em um banco de dados.
  • Quando você atinge o limite de páginas corrompidas, o SQL Server tira o banco de dados do ar e coloca em um estado suspeito para protege-lo de danos maiores;

VALIDANDO BACKUP

  • Como os backups são sua apólice de seguro para um banco de dados, você precisa garantir que os backups criados sejam válidos e utilizáveis.
  • Para validar um backup, execute o seguinte comando:

Sem título9

  • Quando um backup é validado, o SQL Server realiza as seguintes verificações:
    • Calcula uma soma de verificação para o backup e compara com a soma de verificação armazenada no arquivo de backup;
    • Verifica se o cabeçalho do backup está gravado corretamente e é válido;
    • Percorre o encadeamento de páginas para certificar-se de que todas as páginas estejam no banco de dados e passam ser localizadas;

EXEMPLOS (MIRROR E COMPACTAÇÃO)

--backup com mirror e compactado

USE master
GO

--Em Windows
BACKUP DATABASE AdventureWorks2012
  TO DISK = 'c:\temp\AWorks_B1.bak'
  MIRROR TO DISK = 'c:\temp\AWorks_B2.bak'
  WITH COMPRESSION, INIT, FORMAT, CHECKSUM, STOP_ON_ERROR


--Em Linux
BACKUP DATABASE [AdventureWorks2016CTP3]
  TO DISK = '/var/opt/mssql/AdvWorks2016_compress.bak'
  MIRROR TO DISK = '/var/opt/mssql/AdvWorks2016_compress2.bak'
  WITH COMPRESSION, INIT, FORMAT, CHECKSUM, STOP_ON_ERROR

EXEMPLOS (BACKUP DE LOG DE TRANSAÇÃO)

--backups de transacao

USE AdventureWorks2012
GO

INSERT INTO HumanResources.Department (Name, GroupName)
VALUES ('TESTE1','Research and Development')
GO

BACKUP LOG AdventureWorks2012
TO DISK = 'c:\temp\AdventureWorks2012_1.trn'
WITH COMPRESSION, INIT, CHECKSUM, STOP_ON_ERROR
GO

--alteracao e backup de log novamente
INSERT INTO HumanResources.Department (Name, GroupName)
VALUES ('TESTE2','Research and Development')
GO

BACKUP LOG AdventureWorks2012
TO DISK = 'c:\temp\AdventureWorks2012_2.trn'
WITH COMPRESSION, INIT, CHECKSUM, STOP_ON_ERROR
GO

EXEMPLOS (BACKUP DIFERENCIAL)

--backup diferencial

USE AdventureWorks2012
GO

INSERT INTO HumanResources.Department (Name, GroupName)
VALUES ('TESTE3','Research and Development')
GO

BACKUP DATABASE AdventureWorks2012
TO DISK = 'c:\temp\AdventureWorks2012_1.dif'
MIRROR TO DISK = 'c:\temp\AdventureWorks2012_2.dif'
WITH DIFFERENTIAL, COMPRESSION, INIT, FORMAT, CHECKSUM, STOP_ON_ERROR
GO

EXEMPLOS (UTILIZANDO DISPOSITIVOS)

–criando um dispositivo de backup. mesmo que o caminho nao exista, ele vai
–criar,pois esta referenciando um dispositivo e nao um arquivo fisico

--teste de caminho inválido

exec sp_addumpdevice 'disk','meudispositivo','c:\a\backup.bak'
go


--caminho válido
exec sp_addumpdevice 'disk','meudispositivo','c:\temp\backup.bak'
go

-- excluindo um dispositivo
exec sp_dropdevice 'meudispositivo'
go

--até agora, foi apenas criado o dispositivo, mas nao o backup em si
backup database AdventureWorks2012 to meudispositivo
go

--para restaurar o banco de dados através do dispositivo
restore database AdventureWorks2012 from meudispositivo
go

--imaginando que seu banco corrompeu e voce nao consegue dar
-- drop no banco de dados
restore database AdventureWorks from meudispositivo with replace

--verificar sempre o modo de compatibilidade de restaurancao do bd
--FULL
--Simple - nao deixa fazer restore de um log
--Bulk log - somente guarda as transacoes do tipo bulk
-- o restore precisa ser compatível com o backup

--criando 2 dispositivos, um para backups full e outro para backup de log
exec sp_addumpdevice 'disk', 'meufull', 'c:\temp\MeuFull.bak'
go

exec sp_addumpdevice 'disk', 'meulog', 'c:\temp\MeuLog.bak'
go

--backup com with init, para nao deixar 2 arquivos no mesmo dispositivo
backup database AdventureWorks2012 to meufull with init

--backup do log
backup log AdventureWorks2012 to meulog
go

 
--simulando mais movimentacao no bd
use AdventureWorks
go

select * from Person.AddressType
go
insert into Person.AddressType (name, rowguid) 
values ('teste1',NewID())
go

 
--voltando ao banco master
use master
go

--backup do log, somente do log
backup log AdventureWorks2012 to meulog
go

 
--demonstrar em ambliente gráfico os arquivos dentro de um dispositivo

--restaurando o backup full e seus logs
--fez o restore somente do full, nao utilizando os logs

restore database AdventureWorks2012 from meufull
go

--fazendo backups novamente com init

backup database AdventureWorks2012 to meufull with init
go

backup log AdventureWorks2012 to meulog with init
go

--esperando pelos logs, em modo restoring
restore database AdventureWorks2012 from meufull with norecovery
Go

--restaurando o primeiro arquivo do log
restore log AdventureWorks2012 from meulog with file=1, recovery
go

-- exemplo de backup diferencial
exec sp_addumpdevice 'disk', 'meudiff', 'c:\temp\meudiff.bak'
go

backup database AdventureWorks2012 to meudiff with differential
go

Video 01

learningdatabase.com.br

Tecnologias em Banco de Dados Relacionais, Modelagem de dados dimencionais, tecnologias SQL Servere e Oracle

Aprendendo Programação

Algorítmos, C, C++,Pascal, Python, R

WikiDBA

by Virendra Yaduvanshi - Microsoft SQL Server Database Architect | Consultant | Blogger | Specialist | DBA | Speaker

Blog - Fabiano Neves Amorim

SELECT * FROM [Coisas Da Minha Cabeça] WHERE dbo.fn_TempoParaPost() < dbo.fn_TempoLivre()

Tércio Costa, Oracle Developer, OCE SQL, ACE Associate

Guia de estudos para certificação ORACLE SQL(1Z0-047, 1Z0-051, 1Z0-061 e 1Z0-071) e PL/SQL(1Z0-144, 1Z0-146 e 1Z0-148)

Strate SQL

Data Adventures with an Architect