1. Introdução ao Oracle SQL/SQL*Plus

Índice

• 1. Introdução
• 2. Produtos Oracle:Uma Visão Geral
  • 2.1 Ferramentas de desenvolvimento de aplicativos
  • 2.2 Utilitários de banco de dados
  • 2.3 Produtos de conectividade
  • 2.4 Mecanismo de banco de dados principal
  • 2.5 Ambientes de desenvolvimento
• 3. Princípios Básicos do Oracle SQL*Plus
  • 3.1 Executando Oracle SQL*Plus e/ou SQL Developer
  • 3.2 Comandos SQL*Plus
  • 3.3 Recursos de ajuda do SQL*Plus
• 4. A linguagem SQL
  • 4.1 Instruções SQL
  • 4.2 Linguagem de definição de dados SQL
    • 4.2.1 Criar, alterar e descartar tabelas, visualizações, índices e sequências
    • 4.2.2 Declarações GRANT e REVOKE
    • 4.2.3 Sinônimos
  • 4.3 Linguagem de manipulação de dados SQL
    • 4.3.1 Selecionar, inserir, atualizar, excluir, confirmar e reverter dados
    • 4.3.2 Exibindo metadados de tabela
    • 4.3.3 Pseudo-colunas Oracle
    • 4.3.4 Funções Oracle SQL
    • 4.3.5 Exemplos de instruções SQL DML
      • Declarações básicas de seleção
      • Seleção de 2 ou mais tabelas
      • Consultas recursivas e aliases de tabela
      • Consultas em árvore
      • Expressões da cláusula WHERE
      • Exemplos de funções SQL
      • Instruções SQL DELETE
      • Instruções SQL UPDATE
• 5. Comandos SQL*Plus avançados
  • 5.1 Editando o buffer SQL
  • 5.2 Formatando a saída do SQL*Plus
  • 5.3 Salvando a saída do SQL*Plus usando o comando SPOOL
  • 5.4 Solicitando e aceitando a entrada do usuário
  • 5.5 Gerando saída HTML do SQL*Plus
  • 5.6 Coleta de estatísticas e criação de perfil de instruções SQL
  • 5.7 Uso da instrução ALTER SESSION para formatos de data
• 6. Stored Procedures e Triggers no Oracle
  • 6.1 Sintaxe do Acionador Oracle
  • 6.2 Exemplo de gatilho Oracle
  • 6.3 Exemplo de procedimento armazenado Oracle

2. Produtos Oracle:uma visão geral

2.1 Ferramentas de desenvolvimento de aplicativos

• SQL*Plus – Uma ferramenta de linha de comando usada para manipular tabelas e outros objetos de banco de dados em um banco de dados Oracle.
• Desenvolvedor SQL – Uma poderosa ferramenta GUI usada para manipular tabelas e outros objetos de banco de dados em um banco de dados Oracle.
• Formulários Oracle – Uma ferramenta baseada em GUI usada para desenvolver formulários de entrada de dados e menus que acessam tabelas em um banco de dados Oracle.
• Relatórios Oracle – Uma ferramenta baseada em GUI usada para desenvolver relatórios que acessam tabelas em um banco de dados Oracle.

O conjunto de ferramentas Developer foi inicialmente destinado ao desenvolvimento de aplicativos cliente/servidor tradicionais de duas camadas, onde o lado do cliente mantém as interfaces de usuário de formulários e relatórios, bem como a maior parte da lógica de negócios. A lógica de negócios é implementada usando a linguagem PL/SQL da Oracle. Essas ferramentas foram constantemente revisadas para se adequarem a uma arquitetura de três camadas, na qual o cliente processa apenas os elementos da interface do usuário, enquanto uma “camada intermediária” cuida do processamento da lógica de negócios. A versão atual (no outono de 2014) é o Oracle Developer Suite 11g.
• Oracle JDeveloper – Um ambiente de desenvolvimento integrado Java de propósito geral que foi pré-carregado com classes e métodos usados ​​para conectar e manipular esquemas em bancos de dados Oracle. Uma coleção de assistentes de desenvolvimento de código permite que o desenvolvedor crie rapidamente formulários de entrada de dados como aplicativos ou applets Java, bem como relatórios usando Java Server Pages (JSP).
• Designer Oracle – Uma ferramenta gráfica usada para criar e exibir modelos contidos no CASE*Dictionary. O CASE*Dictionary é um repositório de regras de negócios, modelos funcionais e modelos de dados usados ​​para organizar e documentar um esforço de desenvolvimento de aplicativos. CASE*Generator é uma ferramenta de geração de código que usa informações armazenadas no CASE*Dictionary para desenvolver formulários de entrada de dados, relatórios e gráficos.
• Programador – Incluindo os pré-compiladores Pro* – Bibliotecas de rotinas e utilitários que podem ser vinculados com “C”, C++, FORTRAN, Java, ADA, COBOL ou outras linguagens de host para permitir o acesso a bancos de dados Oracle.

2.2 Utilitários de banco de dados

• Gerente Empresarial – Uma coleção de utilitários baseada em GUI para gerenciar bancos de dados Oracle.
• SQL*DBA e SVRMGR – Um utilitário que permite que o administrador de banco de dados (DBA) monitore a atividade do banco de dados e ajuste o banco de dados para um desempenho ideal.
• Exportar/Importar – Utilitários de linha de comando que permitem que um usuário ou o DBA exporte dados de um banco de dados Oracle para um arquivo legível por máquina ou importe dados de um arquivo legível por máquina para um banco de dados Oracle.
• SQL*Loader – Um utilitário de linha de comando para carregar arquivos de dados ASCII ou binários em um banco de dados Oracle.
• Oracle*Terminal – Um programa utilitário usado para customizar a interface do usuário e os mapeamentos de teclado para todas as ferramentas Oracle. Esse utilitário permite que todas as ferramentas Oracle tenham uma “aparência e comportamento” semelhante em muitas plataformas diferentes de hardware e sistema operacional.

2.3 Conectividade e produtos de middleware

• SQL*Net e Net8 – Um driver de comunicação que permite que uma ferramenta Oracle executada em uma máquina cliente acesse dados Oracle em uma máquina servidora separada.
• SQL*Connect e Gateways Oracle – Um driver de comunicação que permite que uma ferramenta Oracle executada em uma máquina cliente acesse dados não Oracle em uma máquina servidora, como dados que residem em um banco de dados DB2 ou banco de dados MS SQL Server.
• Servidor ORACLE – Normalmente uma parte do Oracle RDBMS em execução em um servidor de banco de dados, esse componente recebe solicitações de máquinas clientes e as envia ao Oracle RDBMS. Os resultados são então passados ​​de volta para as máquinas clientes.
• Drivers ODBC da Oracle – Drivers Open DataBase Connectivity para conectar software a bancos de dados Oracle usando o padrão ODBC.

2.4 Mecanismo de banco de dados Oracle Core

• RDBMS ORACLE – O Oracle Relational Database Engine com várias opções além de gerenciar dados relacionais. Essas opções incluem:
  • Servidor de aplicativos da Web da Oracle – Um servidor WWW (servidor HTTP) vinculado ao Oracle RDBMS. Permite que aplicativos baseados na web usando formulários HTML e Java acessem e manipulem dados.
  • Dados espaciais – Permite o armazenamento de dados temporais e espaciais no Oracle RDBMS. Útil para Sistemas de Informações Geográficas (GIS).
  • Vídeo – Fornece armazenamento e serviço em tempo real de streaming de vídeo.
  • Contexto – Fornece armazenamento e recuperação de documentos de texto.
  • Mensagens – Uma arquitetura de groupware construída sobre o RDBMS.
  • OLAP – Ferramentas e suporte a banco de dados para Processamento Analítico On-Line.
  • Mineração de dados – Ferramentas e suporte a banco de dados para mineração de dados.
• Dicionário de dados integrado – Armazena e gerencia o acesso a todas as tabelas pertencentes a todos os usuários em um sistema.
• SQL – A linguagem usada para acessar e manipular dados do banco de dados.
• PL/SQL – Uma extensão procedural para a linguagem SQL exclusiva da linha de produtos Oracle.

2.5 Ambientes de desenvolvimento Oracle típicos

3. Noções básicas do SQL*Plus

3.1 Executando o SQL*Plus

3.1.1 Executando o SQL*Plus no Windows

Linha de comando SQL*Plus no Oracle 11g

Erros ao conectar a um banco de dados

• Você pode digitar incorretamente seu nome de usuário, senha e/ou Host String
• O SQL*Plus e o SQL*Net podem não estar configurados corretamente em seu cliente Windows.
• A rede entre o cliente Windows e o servidor Oracle pode ter um problema
• O servidor Oracle pode estar temporariamente desligado ou indisponível

ERRO:ORA-12154:TNS:não foi possível resolver o nome do serviço

A string do Host foi digitada incorretamente ou SQL*Net ou Net8 não está configurado corretamente. Saia do SQL*Plus e tente fazer login novamente. Se o erro persistir, tente outro PC.

ERRO:ORA-01017:nome de usuário/senha inválidos; logon negado

O nome de usuário ou a senha foram digitados incorretamente. Saia do SQL*Plus e tente novamente.

3.1.2 Executando SQL*Plus em UNIX/LINUX

unix% sqlplusSQL*Plus: Release 10.2.0.1.0 – Production on Tue Jan 8 10:40:06 2013

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

Enter user-name: holowczak

Enter password: ***************

Connected to: Oracle Database 10g Enterprise Edition Release 10.2.0.1.0 – Production

With the Partitioning, OLAP and Data Mining options

Desenvolvedor SQL

Websites com emuladores Oracle

3.2 Comandos SQL*Plus

• Inserir, editar, armazenar, recuperar e executar instruções SQL
• Liste as definições de coluna para qualquer tabela
• Formatar, realizar cálculos, armazenar e imprimir resultados de consulta na forma de relatórios
• Acessar e copiar dados entre bancos de dados SQL

• / – Executa a instrução SQL atual no buffer – igual a RUN
• ACEITAR – Aceitar um valor do usuário e colocá-lo em uma variável
• APPEND – Adiciona texto ao final da linha atual da instrução SQL no buffer
• AUTOTRACE – Rastreie o plano de execução da instrução SQL e colete estatísticas
• BREAK – Defina o comportamento de formatação para a saída de instruções SQL
• BTITLE – Coloque um título na parte inferior de cada página na impressão de uma instrução SQL
• CHANGE – Substitui o texto na linha atual da instrução SQL por um novo texto
• CLEAR – Limpa o buffer
• COLUMN – Alterar a aparência de uma coluna de saída de uma consulta
• COMPUTE – Faz cálculos em linhas retornadas de uma instrução SQL
• CONNECT – Conecte-se a outro banco de dados Oracle ou ao mesmo banco de dados Oracle com um nome de usuário diferente
• COPIAR – Copia dados de uma tabela para outra no mesmo banco de dados ou em bancos de dados diferentes
• DEL – Excluir a linha atual no buffer
• DESCRIBE – Lista as colunas com tipos de dados de uma tabela (pode ser abreviado como DESC)
• EDIT – Edite a instrução SQL atual no buffer usando um editor externo como vi ou emacs
• EXIT – Sair do programa SQL*Plus
• GET – Carrega uma instrução SQL no buffer, mas não a executa
• AJUDA – Obter ajuda para um comando SQL*Plus (em algumas instalações)
• HOST – Desça para o shell do sistema operacional
• INPUT – Adicione uma ou mais linhas à instrução SQL no buffer
• LIST – Lista a instrução SQL atual no buffer
• QUIT – Sair do programa SQL*Plus
• REMARK – Coloque um comentário após a palavra-chave REMARK
• EXECUTAR – Execute a instrução SQL atual no buffer
• SALVAR – Salve a instrução SQL atual em um arquivo de script
• SET – Defina uma variável de ambiente para um novo valor
• MOSTRAR – Mostra o valor atual de uma variável de ambiente
• CARRETEL – Envie a saída de uma instrução SQL para um arquivo
• INICIAR – Carregue uma instrução SQL localizada em um arquivo de script e execute essa instrução SQL
• TIMING – Usado para cronometrar a execução de instruções SQL para análise de desempenho
• TÍTULO – Coloque um título no topo de cada página na impressão de uma instrução SQL
• UNDEFINE – Excluir uma variável definida pelo usuário

3.3 Recursos de ajuda do SQL*Plus

3.3.1 Obtendo ajuda no Windows

3.3.2 Obtendo ajuda no UNIX

4. A linguagem SQL

• Definição de dados – Definindo tabelas e estruturas no banco de dados (DB).
• Manipulação de dados – Inserindo novos dados, Atualizando dados existentes, Excluindo dados existentes e Consultando o banco de dados (Recuperando dados existentes do banco de dados).

4.1 Instruções SQL

• ALTER – Alterar uma tabela, visualização ou definição de índice (DDL) existente
• AUDITORIA – Acompanhe as alterações feitas em uma tabela (DDL)
• COMMENT – Adicione um comentário a uma tabela ou coluna em uma tabela (DDL)
• COMMIT – Torna permanentes todas as alterações recentes (DML – transacional)
• CRIAR – Criar novos objetos de banco de dados, como tabelas ou visualizações (DDL)
• EXCLUIR – Excluir linhas de uma tabela de banco de dados (DML)
• DEIXAR – Solte um objeto de banco de dados, como uma tabela, exibição ou índice (DDL)
• GRANT – Permitir que outro usuário acesse objetos de banco de dados, como tabelas ou visualizações (DDL)
• INSERIR – Inserir novos dados em uma tabela de banco de dados (DML)
• Sem AUDITORIA – Desative a função de auditoria (DDL)
• REVOKE – Não permite o acesso de um usuário a objetos de banco de dados, como tabelas e exibições (DDL)
• ROLLBACK – Desfaz quaisquer alterações recentes no banco de dados (DML – Transacional)
• SELECIONAR – Recuperar dados de uma tabela de banco de dados (DML)
• TRUNCATE – Excluir todas as linhas de uma tabela de banco de dados (não pode ser revertida) (DML)
• ATUALIZAÇÃO – Alterar os valores de alguns itens de dados em uma tabela de banco de dados (DML)

   
CREATE TABLE employee     
(employeeid      VARCHAR2(9) NOT NULL,      
 fname           VARCHAR2(8),      
 minit           VARCHAR2(2),      
 lname           VARCHAR2(8),      
 bdate           DATE,      
 address         VARCHAR2(27),      
 sex             VARCHAR2(1),      
 salary          NUMBER(7) NOT NULL,      
 superempid      VARCHAR2(9),      
 dno             NUMBER(1) NOT NULL) ;

INSERT INTO employee  
VALUES ('132451122', 'BUD', 'T', 'WILLIAMS',         
        '24-JAN-1974', '987 Western Way, Plano, TX',        
        'M', 42000, NULL, 5);  

INSERT INTO employee
VALUES ('004321234', 'JANE', 'V', 'SMITH',         
        '04-JUL-1983', '44 Forth St., Easytown, WA',         
        'F', 56000, '132451122', 4);

SELECT fname, lname, salary            
FROM   employee            
WHERE  salary > 30000;

          UPDATE employee            
          SET    salary = salary * 1.04            
          WHERE  dno = 5;

          DELETE FROM employee            
          WHERE  employeeid  = '004321234' ;

4.2 SQL Data Definition Language

4.2.1 Create, Alter and Drop Tables, Views and Sequences

ALTER TABLE <table name>       
RENAME TO <new table name> ;

ALTER TABLE <table name>       
ADD ( <column name>  <data type> <[not]null> ) ;

ALTER TABLE <table name>       
MODIFY ( <column name>  <new data type> <[not]null> );

ALTER TABLE <table name>     
DROP ( <column name> ) ;

ALTER TABLE <table name>       
ADD CONSTRAINT <constraint-name>       
PRIMARY KEY (<column-name>);

ALTER TABLE <table-name>       
ADD CONSTRAINT <constraint-name>       
FOREIGN KEY (<column-name>)       
REFERENCES <parent-table-name> (column-name);

ALTER TABLE <table name>       
ADD CONSTRAINT <constraint-name> 
PRIMARY KEY (<column-name1>, <column-name2>);

CREATE TABLE <table_name>       
             ( <column1_name>  <data type> <[not]null>,       
               <column2_name>  <data type> <[not]null>,   . . .  ) ;

CREATE TABLE <table_name> 
AS           <sql select statement> ;

DROP TABLE <table name> ;

CREATE INDEX <index name>       
ON           <table name>       
             ( <column name>, <column name> ) ;

DROP INDEX <index name> ;

CREATE SEQUENCE <sequence name>       
INCREMENT BY    <increment number>       
START WITH      <start number>       
MAXVALUE        <maximum value>       
CYCLE ;

DROP SEQUENCE <sequence name> ;

CREATE VIEW <view name> 
AS       <sql select statement> ;

SELECT <column names>       
FROM   <table name>       
WHERE  <where clause>

DROP VIEW <view name> ;

4.2 SQL Data Definition Language – Continued

Creating, Altering and Dropping Tables

• VARCHAR2 – Character data type. Can contain letters, numbers and punctuation. The syntax for this data type is:VARCHAR2(size) where size is the maximum number of alphanumeric characters the column can hold. For example VARCHAR2(25) can hold up to 25 alphanumeric characters. In Oracle8, the maximum size of a VARCHAR2 column is 4,000 bytes.The VARCHAR data type is a synonym for VARCHAR2. It is recommended to use VARCHAR2 instead of VARCHAR.
• NUMBER – Numeric data type. Can contain integer or floating point numbers only. The syntax for this data type is:NUMBER(precision, scale) where precision is the total size of the number including decimal point and scale is the number of places to the right of the decimal. For example, NUMBER(6,2) can hold a number between -999.99 and 999.99.
• DATE – Date and Time data type. Can contain a date and time portion in the format:DD-MON-YY HH:MI:SS. No additional information is needed when specifying the DATE data type. If no time component is supplied when the date is inserted, the time of 00:00:00 is used as a default. The output format of the date and time can be modified to conform to local standards. In general, to manipulate the time portion of the DATE datatype, one must make use of the TO_DATE and TO_CHAR SQL functions.
• RAW – Free form binary data. Can contain binary data up to 255 characters. Data type LONG RAW can contain up to 2 gigabytes of binary data. RAW and LONG RAW data cannot be indexed and can not be displayed or queried in SQL*Plus. Only one RAW column is allowed per table.
• LOB – Large Object data types. These include BLOB (Binary Large OBject) and CLOB (Character Large OBject). More than one LOB column can appear in a table. These data types are the prefferred method for storing large objects such as text documents (CLOB), images, or video (BLOB).

SQL> CREATE TABLE employee
2  (employeeid VARCHAR2(9) NOT NULL,
3  fname VARCHAR2(8),
4  minit VARCHAR2(2),
5  lname VARCHAR2(8),
6  bdate DATE,
7  address VARCHAR2(27),
8  sex VARCHAR2(1),
9  salary NUMBER(7) NOT NULL,
10 superempid VARCHAR2(9),
11 dno NUMBER(1) NOT NULL) ; 

Table created.
SQL>

DESCRIBE <table name> ; 

SQL> DESCRIBE employee
Name                                      Null?    Type
----------------------------------------- -------- -------------------------
EMPLOYEEID                                NOT NULL VARCHAR2(9)
FNAME                                              VARCHAR2(8)
MINIT                                              VARCHAR2(2)
LNAME                                              VARCHAR2(8)
BDATE                                              DATE
ADDRESS                                            VARCHAR2(27)
SEX                                                VARCHAR2(1)
SALARY                                    NOT NULL NUMBER(7)
SUPEREMPID                                         VARCHAR2(9)
DNO                                       NOT NULL NUMBER(1) 

SQL> CREATE TABLE emp_department_1
AS SELECT fname, minit, lname, bdate
FROM employee WHERE dno = 1 ;
Table created. 

SQL> DESCRIBE emp_department_1
Name                            Null?    Type
------------------------------- -------- ------------
FNAME                                    VARCHAR2(8)
MINIT                                    VARCHAR2(2)
LNAME                                    VARCHAR2(8)
BDATE                                    DATE 

SQL>

SQL> CREATE TABLE high_pay_emp
AS SELECT *
   FROM employee
   WHERE salary > 50000 ;

Table created. 

SQL> CREATE TABLE copy_of_employee
AS SELECT *
   FROM employee
   WHERE 3=5 ;

Table created.

 

SQL> DESCRIBE copy_of_employee
 Name                                      Null?    Type
 ----------------------------------------- -------- -------------------------
 EMPLOYEEID                                NOT NULL VARCHAR2(9)
 FNAME                                              VARCHAR2(8)
 MINIT                                              VARCHAR2(2)
 LNAME                                              VARCHAR2(8)
 BDATE                                              DATE
 ADDRESS                                            VARCHAR2(27)
 SEX                                                VARCHAR2(1)
 SALARY                                    NOT NULL NUMBER(7)
 SUPEREMPID                                         VARCHAR2(9)
 DNO                                       NOT NULL NUMBER(1)

• Primary key and Unique key constraints.
• Foreign key constraints (for referential integrity).
• Check constraints – to ensure only certain values are supplied for a column.

SQL> DROP TABLE employee;
Table dropped. 
SQL> CREATE TABLE employee
 (employeeid VARCHAR2(9) NOT NULL,
  fname      VARCHAR2(8),
  minit      VARCHAR2(2),
  lname      VARCHAR2(8),
  bdate      DATE,
  address    VARCHAR2(27),
  sex        VARCHAR2(1),
  salary     NUMBER(7) NOT NULL,
  superempid VARCHAR2(9),
  dno        NUMBER(1) NOT NULL,
  CONSTRAINT pk_employee PRIMARY KEY (employeeid) );

Table created.

DROP TABLE department;
CREATE TABLE department
(dnumber NUMBER(1),
dname VARCHAR2(15),
mgrempid VARCHAR2(9),
mgrstartdate DATE,
CONSTRAINT pk_department PRIMARY KEY (dnumber) );

DROP TABLE employee;
CREATE TABLE employee
 (employeeid VARCHAR2(9) NOT NULL,
 fname VARCHAR2(8),
 minit VARCHAR2(2),
 lname VARCHAR2(8),
 bdate DATE,
 address VARCHAR2(27),
 sex VARCHAR2(1),
 salary NUMBER(7) NOT NULL,
 superempid VARCHAR2(9),
 dno NUMBER(1) NOT NULL,
 CONSTRAINT pk_employee PRIMARY KEY (employeeid),
 CONSTRAINT fk_department FOREIGN KEY (dno)
 REFERENCES department (dnumber) ON DELETE CASCADE);

CREATE TABLE employee
(employeeid VARCHAR2(9) NOT NULL,
fname       VARCHAR2(8),
minit       VARCHAR2(2),
lname       VARCHAR2(8),
bdate       DATE,
address     VARCHAR2(27),
sex         VARCHAR2(1) CONSTRAINT ck_sex CHECK (sex IN ('M', 'F')),
salary      NUMBER(7) NOT NULL CONSTRAINT ck_salary CHECK (salary > 10000),
superempid  VARCHAR2(9),
dno         NUMBER(1) NOT NULL,
CONSTRAINT pk_employee PRIMARY KEY (employeeid),
CONSTRAINT fk_dno FOREIGN KEY (dno)
REFERENCES department (dnumber)
ON DELETE CASCADE);

SQL> insert into employee  values
 ('123456789', 'Joe', 'M', 'Smith', '01-JUN-45',
 '123 Smith St.', 'm', 45000, '123456789', 1) ;
insert into employee values
* ERROR at line 1:
ORA-02290: check constraint (HOLOWCZAK.CK_SEX) violated

• Primary key constraints:pk_
• Foreign key constraints:fk_
• Check constraints:ck_

SQL> DESCRIBE emp_department_1
Name                            Null?    Type
------------------------------- -------- -----------
FNAME                                    VARCHAR2(8)
MINIT                                    VARCHAR2(2)
LNAME                                    VARCHAR2(8)
BDATE                                    DATE

SQL> ALTER TABLE emp_department_1
 ADD (manager VARCHAR2(8)) ;
 Table altered.

SQL> ALTER TABLE emp_department_1
 MODIFY (fname VARCHAR2(15));
 Table altered.

SQL> DESCRIBE emp_department_1
 Name                            Null?    Type
 ------------------------------- -------- ----------
 FNAME                                    VARCHAR2(15)
 MINIT                                    VARCHAR2(2)
 LNAME                                    VARCHAR2(8)
 BDATE                                    DATE
 MANAGER                                  VARCHAR2(8)

CREATE TABLE temp AS SELECT * FROM emp_department_1;
DELETE FROM emp_department_1;
ALTER TABLE emp_department_1
MODIFY (manager VARCHAR2(15));
INSERT INTO emp_department_1
SELECT * FROM temp;
DROP TABLE temp;

CREATE TABLE temp AS
SELECT employeeid, fname, minit, lname, bdate, address,
sex, superssn, dno FROM employee; 

DROP TABLE employee;

CREATE TABLE employee AS
 SELECT * FROM temp;

SQL> DROP TABLE emp_department_1 ;
Table dropped. 

SQL> SELECT table_name FROM USER_TABLES ;
TABLE_NAME
---------------
DEPARTMENT 
EMPLOYEE 
STUDENTS

SQL> SELECT constraint_name, constraint_type, table_name 
FROM user_constraints ;

CONSTRAINT_NAME                C TABLE_NAME
------------------------------ - ---------------
SYS_C004797                    C DEPARTMENT
PK_DEPARTMENT                  P DEPARTMENT
SYS_C004794                    C EMPLOYEE
SYS_C004795                    C EMPLOYEE
SYS_C004796                    C EMPLOYEE
PK_EMPLOYEE                    P EMPLOYEE
FK_DEPARTMENT                  R EMPLOYEE 

Exercise 2:Creating and Altering Tables

Creating and Dropping Views

     CREATE VIEW vw_emp_dno_1
     AS SELECT fname, lname, dno
     FROM employee
     WHERE dno = 1;

View created.

SELECT * FROM vw_emp_dno_1 ;

FNAME    LNAME          DNO
-------- -------- ---------
JAMES    BORG             1

DROP VIEW vw_emp_dno_1 ;

View dropped.

SQL> CREATE VIEW vw_dept_managers AS
     SELECT dnumber, dname, mgrempid, lname, fname
     FROM   employee, department
     WHERE  employee.ssn = department.mgrssn ;

View created.

SQL> SELECT * FROM vw_dept_managers ;

DNUMBER DNAME             MGREMPID LNAME    FNAME
------- --------------- ---------- -------- --------
      5 RESEARCH         333445555 WONG     FRANKLIN
      4 ADMINISTRATION   987654321 WALLACE  JENNIFER
      1 HEADQUARTERS     888665555 BORG     JAMES

SQL> CREATE VIEW vw_dept_average_salary AS
     SELECT dnumber, dname, AVG(salary) AS average_salary
     FROM   department, employee
     WHERE  employee.dno = department.dnumber
     GROUP BY dnumber, dname ;

 View created.

SQL> SELECT * FROM vw_dept_average_salary ;

   DNUMBER DNAME           AVERAGE_SALARY
---------- --------------- --------------
         1 HEADQUARTERS             55000
         4 ADMINISTRATION           31000
         5 RESEARCH                 33250

SQL> SELECT view_name FROM user_views ;

VIEW_NAME
--------------------------
VW_DEPT_AVERAGE_SALARY
VW_DEPT_MANAGERS
VW_EMP_DNO_1

Exercise 3:Creating Views

SELECT * FROM students WHERE major = 'CIS';

SELECT name, major, coursenumber, coursename,
       semester, year, grade
FROM   students, courses
WHERE  students.studentid = courses.studentid;

COLUMN name       FORMAT A8
COLUMN coursename FORMAT A15
COLUMN major      FORMAT A10
COLUMN year       FORMAT 9999

Creating, Altering and Dropping Sequences

      CREATE SEQUENCE seq_department_number
      START WITH  1
      MAXVALUE    9999
      NOCYCLE ;

Sequence created.

SELECT seq_department_number.nextval FROM dual ;

  NEXTVAL
---------
     6

     INSERT INTO department VALUES
       (seq_department_number.nextval, 'Finance',
        '123456789', '01'-JAN-1990');

    1 Row Created.

DROP SEQUENCE seq_department_number ;

Sequence dropped.

SQL> SELECT sequence_name, min_value, max_value, last_number
     FROM USER_SEQUENCES ;

SEQUENCE_NAME                   MIN_VALUE  MAX_VALUE LAST_NUMBER
------------------------------ ---------- ---------- -----------
SEQ_DEPARTMENT_NUMBER                   1        600           6

Exercise 4:Working with Sequences

Name:     Joe
Major:    CIS
GPA:      3.85
TutorID:  103

4.2.2 Grant and Revoke Statements

• SELECT – allows a subject to select rows from the object.
• INSERT – allows a subject to insert rows into the object.
• UPDATE – allows a subject to update rows in the object.
• DELETE – allows a subject to delete rows from the object.
• ALTER – allows a subject to alter the object. For example, add a column or change a constraint.
• INDEX – allows a subject to create an index on the object.
• EXECUTE – allows a subject to execute a stored procedure or trigger.

GRANT <action1>, <action2>, ...
ON    tablename
TO    subject;

GRANT SELECT
ON    employee
TO    BOB ;

SELECT fname, minit, lname, employeeid FROM ALICE.employee ;

FNAME    MI LNAME    EMPLOYEEID
-------- -- -------- ----------
JOHN     B  SMITH    123456789
FRANKLIN T  WONG     333445555
ALICIA   J  ZELAYA   999887777
JENNIFER S  WALLACE  987654321
RAMESH   K  NARAYAN  666884444
JOYCE    A  ENGLISH  453453453
AHMAD    V  JABBAR   987987987
JAMES    E  BORG     888665555
etc.

REVOKE <action>
ON     <object>
FROM   <subject>

REVOKE SELECT
ON     employee
FROM   BOB ;

GRANT SELECT, INSERT, UPDATE, DELETE
ON    department
TO    BOB ;

REVOKE INSERT, UPDATE, DELETE
ON     department
FROM   BOB ;

REVOKE ALL
ON     department
FROM   BOB;

GRANT SELECT
ON    employee
TO    PUBLIC;

 COLUMN grantee    FORMAT A10
 COLUMN grantor    FORMAT A10
 COLUMN owner      FORMAT A10
 COLUMN table_name FORMAT A10
 COLUMN privilege  FORMAT A10
 SELECT * FROM USER_TAB_PRIVS ;

GRANTEE    OWNER      TABLE_NAME GRANTOR    PRIVILEGE  GRA
---------- ---------- ---------- ---------- ---------- ---
BOB        ALICE       EMPLOYEE  ALICE      SELECT     NO

SELECT 'GRANT SELECT, INSERT, UPDATE, DELETE ON '
        || table_name ||  ' TO username;'
        FROM   cat
        WHERE  table_type = 'TABLE';

GRANT SELECT, INSERT, UPDATE, DELETE ON DEPARTMENT TO username;
GRANT SELECT, INSERT, UPDATE, DELETE ON DEPENDENT TO username;
GRANT SELECT, INSERT, UPDATE, DELETE ON DEPT_LOCATIONS TO username;
GRANT SELECT, INSERT, UPDATE, DELETE ON EMPLOYEE TO username;
GRANT SELECT, INSERT, UPDATE, DELETE ON PROJECT TO username;
GRANT SELECT, INSERT, UPDATE, DELETE ON WORKS_ON TO username;

SQL>  SELECT grantee, table_name, grantor, privilege FROM USER_TAB_PRIVS_MADE;

GRANTEE    TABLE_NAME      GRANTOR        PRIVILEGE
---------- --------------- -------------- ----------
SMITH      DEPARTMENT      HOLOWCZAK      INSERT
SMITH      DEPARTMENT      HOLOWCZAK      SELECT
SMITH      DEPARTMENT      HOLOWCZAK      UPDATE
SMITH      EMPLOYEE        HOLOWCZAK      SELECT

SQL> SELECT owner, table_name, grantor, privilege FROM USER_TAB_PRIVS_RECD;

OWNER        TABLE_NAME      GRANTOR        PRIVILEGE
------------ --------------- -------------- ----------
SMITH        STUDENT         SMITH          SELECT
SMITH        STUDENT         SMITH          INSERT
SMITH        STUDENT         SMITH          UPDATE
SMITH        STUDENT         SMITH          DELETE

Exercise 5:GRANT and REVOKE

4.2.3 Synonyms in Oracle

SELECT * FROM alice.employee;

CREATE SYNONYM <synonym_name> FOR  <schema>.<object> ;

 CREATE SYNONYM employee FOR alice.employee;

SELECT * FROM employee ;

SELECT 'CREATE SYNONYM ' || table_name ||
       ' FOR schema.' || table_name || ' ;'
FROM   cat
WHERE  table_type = 'TABLE' ;

CREATE SYNONYM DEPARTMENT FOR schema.DEPARTMENT ;
CREATE SYNONYM DEPENDENT FOR schema.DEPENDENT ;
CREATE SYNONYM DEPT_LOCATIONS FOR schema.DEPT_LOCATIONS ;
CREATE SYNONYM EMPLOYEE FOR schema.EMPLOYEE ;
CREATE SYNONYM PROJECT FOR schema.PROJECT ;
CREATE SYNONYM STUDENTS FOR schema.STUDENTS ;
CREATE SYNONYM WORKS_ON FOR schema.WORKS_ON ;

SQL> SELECT synonym_name, table_owner, table_name FROM USER_SYNONYMS ;

SYNONYM_NAME TABLE_OWNER  TABLE_NAME
------------ ------------ ------------
EMPLOYEE     SMITH        EMPLOYEE
DEPARTMENT   SMITH        DEPARTMENT

4.3 SQL Data Manipulation Language (DML)

4.3.1 Select, Insert, Update, Delete, Commit and Rollback Data

• COMMIT – Make all recent changes to the database permanent. Changes that have occurred since the last commit are made permanent. A commit can be done explicitly using the following syntax:
  

          COMMIT ;
  
  

  
  A commit is also done implicitly when the next SQL DDL statement is executed or the user exits SQL*Plus.
  
  
• DELETE – Delete one or more rows from a table. The syntax for this SQL statement is:
  

          DELETE FROM <table name>
          WHERE <where clause>
  
  

  
  If the WHERE clause is omitted, all rows in the table will be deleted.
  
  
• INSERT – Insert a row of data into a table. The syntax for this SQL statement is:
  

          INSERT INTO <table name>
          (column1, column2 . . .)
          VALUES (value1, value2, . . .)
  
  

  
  If a value for each column in the table is supplied, then the columns do not need to be listed in the first set of parenthesis. Values can be of 3 types:Character, Number or Date. Each one requires a slightly different format when inserting:
  
  • Character – Must be enclosed within single quotes
    For example:‘Bill Smith’
  • Number – No quotes are required
    For example:123, 44000.12
  • Date – Enclosed in single quotes in the format ‘DD-MON-YYYY’
    For example:’26-JUN-1996′
    Note that different versions of Oracle accept only 2 digit years
    for an INSERT statement. All newer versions (from Oracle8 on)
    appear to default to using 4 digit years.
    To insert TIME into a DATE column, use the TO_DATE function. For example,
    the following function will insert the 26th of June 1996 at 5:00pm:
    TO_DATE(’26-JUN-1996 17:00′, ‘DD-MON-YYYY HH24:MI’)
  
  All values, regardless of data type, must be separated by commas.
  
  Another option for the INSERT statement is to pull some data from another table. The syntax is:
  

          INSERT INTO <table name>
          SELECT <columns>
          FROM   <table>
          WHERE  <where-clause>
  
  

  
  For example, assume table1 and table2 have the same number of columns and the corresponding columns have the same data types. To insert all data currently in
  table1 into table2:
  

         INSERT INTO table2
         SELECT * FROM table1;
  
  

  
  
• ROLLBACK – Undo all recent changes to the database. A rollback can only undo changes made since the last commit. The syntax for the ROLLBACK command is:
  

           ROLLBACK ;
  
  

  
  
• SELECT – Retrieve existing rows from a table. If the table is empty, a message indicating that no rows were found will be displayed. A simplified syntax for the SELECT statement is:
  

           SELECT <column1, column2, . . .>
           FROM   <table1, table2, . . .>
           WHERE  <where clause>
           GROUP BY <column1, column2, . . .>
           HAVING   <having clause>
           ORDER BY <column1, column2, . . .>
  
  

  
  The WHERE clause, GROUP BY, HAVING and ORDER BY statements are optional. If a WHERE
  clause if omitted, all rows in the table will be retrieved. If the ORDER BY statement is omitted, there is no specific order in which the rows will be displayed. GROUP BY and HAVING are used in conjunction with aggregate functions (functions that operate
  on more than one record). If all columns in the table are to be retrieved, an asterisk (*) may be substituted for the entire list of columns after the SELECT key word.
  
  More than one table can be specified in the FROM clause. The WHERE clause typically contains logic expressions (such as WHERE salary > 40000 ) that are
  evaluated for each row in the table.
  
  A more complete syntax for the SELECT statement is:
  

  SELECT     <column1, column2, . . .>
  FROM       <schema.table1, schema.table2, . . .> | <view>
  WHERE      <where clause>
  CONNECT BY <connect by expression>
  GROUP BY   <group by expression>
  HAVING     <having clause>
  ORDER BY   <column1, column2, ....> ASC | DESC
  
  

  
  
• UPDATE – Change the values of existing rows in a table in the database. One or more rows must exist in the table in order to successfully update data. The syntax for this SQL statement is:
  

          UPDATE <table name>
          SET    <column name> = <expression>
          WHERE  <where clause>
  
  

  
  The expression can be either a single value or an arithmetic expression including another column in the table. More than one column can be updated at a time by adding additional column name =expression pairs separated by commas. If the WHERE clause is omitted, the update is applied to all rows in the table.
  
  For example, to give all employees in the marketing department a 3% raise:
  

        UPDATE employee
        SET    salary = salary * 1.03
        WHERE  dno =
        (SELECT dno
         FROM   department
         WHERE  dname = 'MARKETING');
  
  

 DESCRIBE employee ;
 Name                            Null?    Type
 ------------------------------- -------- ----
 EMPLOYEEID                      NOT NULL VARCHAR2(9)
 FNAME                                    VARCHAR2(8)
 MINIT                                    VARCHAR2(2)
 LNAME                                    VARCHAR2(8)
 BDATE                                    DATE
 ADDRESS                                  VARCHAR2(27)
 SEX                                      VARCHAR2(1)
 SALARY                          NOT NULL NUMBER(7)
 SUPEREMPID                               VARCHAR2(9)
 DNO                             NOT NULL NUMBER(1)

    INSERT INTO employee
     VALUES ('123456789', 'JOHN', 'B', 'SMITH', '09-JAN-1975',
             '731 FONDREN, HOUSTON, TX', 'M', 30000, '333445555', 5) ;

  1 row created.

 SELECT fname, minit, lname, employeeid, bdate,
        address, sex, superempid, dno
 FROM   employee;

FNAME    MI LNAME    EMPLOYEEID BDATE       ADDRESS                   S SALARY SUPEREMPID DNO
-------- -- -------- ---------- ----------- ------------------------- - ------ ---------- ---
JOHN     B  SMITH     123456789 09-JAN-1975 731 FONDREN, HOUSTON, TX  M  30000  333445555   5
FRANKLIN T  WONG      333445555 08-DEC-1965 638 VOSS,HOUSTON TX       M  40000  888665555   5
ALICIA   J  ZELAYA    999887777 19-JUL-1978 3321 CASTLE, SPRING, TX   F  25000  987654321   4
JENNIFER S  WALLACE   987654321 20-JUN-1951 291 BERRY, BELLAIRE, TX   F  43000  888665555   4
RAMESH   K  NARAYAN   666884444 15-SEP-1972 975 FIRE OAK, HUMBLE, TX  M  38000  333445555   5
JOYCE    A  ENGLISH   453453453 31-JUL-1982 5631 RICE, HOUSTON, TX    F  25000  333445555   5
AHMAD    V  JABBAR    987987987 29-MAR-1979 980 DALLAS, HOUSTON, TX   M  25000  987654321   4
JAMES    E  BORG      888665555 10-NOV-1947 450 STONE, HOUSTON, TX    M  55000              1

8 rows selected.

      UPDATE employee
      SET    salary = salary * 1.04
      WHERE  dno = 4;

3 rows updated.

SELECT fname, minit, lname, employeeid, bdate,
       address, sex, superempid, dno
FROM   employee ;

FNAME    MI LNAME    EMPLOYEEID BDATE       ADDRESS                   S SALARY SUPEREMPID DNO
-------- -- -------- ---------- ----------- ------------------------- - ------ ---------- ---
JOHN     B  SMITH     123456789 09-JAN-1975 731 FONDREN, HOUSTON, TX  M  30000  333445555   5
FRANKLIN T  WONG      333445555 08-DEC-1965 638 VOSS,HOUSTON TX       M  40000  888665555   5
ALICIA   J  ZELAYA    999887777 19-JUL-1978 3321 CASTLE, SPRING, TX   F  26000  987654321   4
JENNIFER S  WALLACE   987654321 20-JUN-1951 291 BERRY, BELLAIRE, TX   F  44720  888665555   4
RAMESH   K  NARAYAN   666884444 15-SEP-1972 975 FIRE OAK, HUMBLE, TX  M  38000  333445555   5
JOYCE    A  ENGLISH   453453453 31-JUL-1982 5631 RICE, HOUSTON, TX    F  25000  333445555   5
AHMAD    V  JABBAR    987987987 29-MAR-1979 980 DALLAS, HOUSTON, TX   M  26000  987654321   4
JAMES    E  BORG      888665555 10-NOV-1947 450 STONE, HOUSTON, TX    M  55000              1

8 rows selected.

SQL>  DELETE FROM employee
      WHERE dno = 5;

4 rows deleted.

SQL> COMMIT ;
Commit complete.

4.3.2 Displaying Oracle Table Metadata (Data about the data)

SELECT   colno, cname, coltype, 
         width, scale, precision, nulls
FROM     col
WHERE    tname = 'EMPLOYEE'
ORDER BY col.colno;

SELECT constraint_name, table_name, 
           search_condition 
FROM USER_CONSTRAINTS 
WHERE table_name = 'EMPLOYEE';

SELECT text 
FROM USER_SOURCE 
WHERE name = 'procedure_name' 
ORDER BY LINE;

 SQL>   SET LONG 4096

SET ARRAYSIZE 2

 
SELECT * FROM cat; 

SELECT * FROM cat ;

TABLE_NAME                     TABLE_TYPE
------------------------------ ----------
EMPLOYEE                       TABLE
DEPARTMENT                     TABLE
PROJECT                        TABLE
DEPENDENTS                     TABLE

 DESCRIBE employee ;
 Name                            Null?    Type
 ------------------------------- -------- ----
 EMPLOYEEID                      NOT NULL VARCHAR2(9)
 FNAME                                    VARCHAR2(8)
 MINIT                                    VARCHAR2(2)
 LNAME                                    VARCHAR2(8)
 BDATE                                    DATE
 ADDRESS                                  VARCHAR2(27)
 SEX                                      VARCHAR2(1)
 SALARY                          NOT NULL NUMBER(7)
 SUPEREMPID                               VARCHAR2(9)
 DNO                             NOT NULL NUMBER(1)

SQL> COLUMN coltype FORMAT A10
SQL> COLUMN cname FORMAT A15
SQL> SELECT   colno, cname, coltype, width, scale, precision, nulls
     FROM     col
     WHERE    tname = 'EMPLOYEE'
     ORDER BY col.colno;

COLNO CNAME           COLTYPE    WIDTH SCALE PRECISION NULLS
----- --------------- ---------- ----- ----- --------- ---------
    1 EMPLOYEEID      VARCHAR2       9                 NOT NULL
    2 FNAME           VARCHAR2       8                 NULL
    3 MINIT           VARCHAR2       2                 NULL
    4 LNAME           VARCHAR2       8                 NULL
    5 BDATE           DATE           7                 NULL
    6 ADDRESS         VARCHAR2      27                 NULL
    7 SEX             VARCHAR2       1                 NULL
    8 SALARY          NUMBER        22     0         7 NOT NULL
    9 SUPEREMPID      VARCHAR2       9     0         9 NULL
   10 DNO             NUMBER        22     0         1 NOT NULL

10 rows selected.

SQL> COLUMN search_condition FORMAT A21
SQL> SELECT constraint_name, constraint_type,
            search_condition, delete_rule
     FROM   user_constraints
     WHERE  table_name = 'EMPLOYEE';

CONSTRAINT_N CONSTRAINT_T SEARCH_CONDITION      DELETE_RULE
------------ ------------ --------------------- -----------
FK_DNO       R                                  CASCADE
SYS_C00886   C            EMPID IS NOT NULL
SYS_C00887   C            EMPLOYEEID IS NOT NULL
SYS_C00888   C            SALARY IS NOT NULL
SYS_C00889   C            DNO IS NOT NULL
CK_SEX       C            sex IN ('M', 'F')
CK_SALARY    C            salary > 10000
PK_EMPLOYEE  P

SQL> COLUMN table_owner FORMAT A12
SQL> SELECT index_name, table_owner, table_name FROM USER_INDEXES ;

INDEX_NAME                     TABLE_OWNER  TABLE_NAME
------------------------------ ------------ ------------------------------
ACCOUNTS_PK                    HOLOWCZA     ACCOUNTS
AT_PK                          HOLOWCZA     ACCOUNT_TYPES
COURSES_PK                     HOLOWCZA     COURSES
CUSTOMER_PK                    HOLOWCZA     CUSTOMERS
PK_DEPARTMENT                  HOLOWCZA     DEPARTMENT
PK_EMPLOYEE                    HOLOWCZA     EMPLOYEE
UNQ_RNAME                      HOLOWCZA     LOGREPORT

SQL> SET LONG 4096
SQL> SELECT view_name, text FROM USER_VIEWS;

VIEW_NAME
-------------------
TEXT
--------------------------------------------------------------
VACCOUNTS
SELECT c.fname, c.lname, ac.account_number, at.account_typeid,
       at.interest_rate, at.minimum_balance,
       ac.date_opened, ac.current_balance
FROM   customers c, accounts ac, account_types at
WHERE  c.customerid = ac.customerid
  AND  ac.account_typeid = at.account_typeid

V_COURSES_TAKEN
SELECT name, major, coursenumber, coursename,
       semester, year, grade
FROM   students, courses
WHERE  students.studentid = courses.studentid

4.3.3 Oracle Pseudo-Columns

• CURRVAL – Returns the current value of an Oracle sequence.
• NEXTVAL – Returns the current value of an Oracle sequence
  and then increments the sequence.
• LEVEL – The current level in a hierarchy
  for a query using STARTWITH and CONNECT BY.
• ROWID – An identifier (data file, block and row) for
  the physical storage of a row in a table.
• ROWNUM – The integer indicating the order in which
  a row is returned from a query.

Exercise 6:Displaying Metadata

• List the tables in the presently in the schema
• List the Indexes
• List the Views
• For the STUDENT and COURSES tables, display the columns in each table, their data types and whether or not they allow NULL values
• For the STUDENT and COURSES tables, display constraints on each table

4.3.4 Oracle SQL Functions

• Single row functions – Operate on column values for each row returned by a query.
• Group functions – Operate on a collection (group) of rows.

• Math functions include:
  

  ABS (x )	Absolute Value of x
  CEIL (x )	Smallest integer greater than or equal to x .
  COS (x )	Cosine of x
  FLOOR (x )	Largest integer less than or equal to x .
  LOG (x )	Log of x
  LN (x )	Natural Log of x
  ROUND (x , n )	Round x to n decimal places to the right of the decimal point.
  SIN (x )	Sine of x
  TAN (x )	Tangent of x
  TRUNC (x , n )	Truncate x to n decimal places to the right of the decimal point.

• Character functions include:
  

  CHR (x )	Character for ASCII value x .
  INITCAP (s )	String s with the first letter of each word capitalized.
  LOWER (s )	Converts string s to all lower case letters.
  LPAD (s , x )	Pads string s with x spaces to the left.
  LTRIM (s )	Removes leading spaces from s .
  REPLACE (s1 , s2 , s3 )	Replace occurrences of s2 with s3 in string s1 .
  RPAD (s , x )	Pads string s with x spaces to the right.
  RTRIM (s )	Removes trailing spaces from s .
  SUBSTR (s , x1 , x2 )	Return a portion of string s starting at position x1 and ending with position x2 . If x2 is omitted, it’s value defaults to the end of s .
  UPPER (s )	Converts string s to all upper case letters.
  s1 || s2	(two vertical bars or “pipe” symbols) Concatenates s1 with s2

• Character functions that return numbers include:
  

  ASCII (c )	Returns the ASCII value of c
  INSTR (s1 , s2 , x )	Returns the position of s2 in s1 where the search starts at position x .
  LENGTH (s )	Length of s

• Conversion functions include:
  

  TO_CHAR (date , format )	Converts a date column to a string of characters. format is a set of Date formatting codes where: YYYY is a 4 digit year. MM is a month number. MONTH is the full name of the month. MON is the abbreviated month. DDD is the day of the year. DD is the day of the month. D is the day of the week. DAY is the name of the day. HH is the hour of the day (12 hour clock) HH24 is the hour of the day (24 hour clock) AM is the morning or afternoon indicator (AM or PM). MI is the minutes. SS is the seconds.
  TO_CHAR (number , format )	Converts a numeric column to a string of characters. format is a set of number formatting codes where: 9 indicates a digit position. Blank if position value is 0. 0 indicates a digit position. Shows a 0 if the position value is 0. $ displays a leading currency indicator.
  TO_DATE (s , format )	Converts a character column (string s to a date. format is a set of Date formatting codes as above.
  TO_NUMBER (s , format )	Converts a character column (string s to a Number. format is a set of Number formatting codes as above.

• Date functions include:
  

  SYSDATE

  Returns the current date (and time if the TO_CHAR function is used) from the system clock. For example: SELECT TO_CHAR(SYSDATE, ‘DD-MON-YYYY HH:MM:SS’) FROM DUAL;

• Some additional function are:
  

  DECODE (s , search1 , result1 , search2 , result2 )	Compares s with search1 , search2 , etc. and returns the corresponding result when there is a match.
  NVL (s , expression )	If s is NULL, return expression . If s is not null, then return s .
  USER	Returns the username of the current user. For example:SELECT USER FROM DUAL;

Exercise 7:Functions

• Display the average, minimum, and maximum grade point average for all of the students
• For each student, write a sentence like the following:
  Congratulations Bill, your grade point average is 3.45
  You’ll need to use the TO_CHAR function to convert the
  GPA column (which is a NUMBER data type) to a set of characters.
• For each student, count the number of courses he or she has taken.
• Modify the above query to only count CIS courses.
  Hint:You’ll need to use the SUBSTR function on
  the COURSENUMBER column to extract the first three
  letters. Then compare this to ‘CIS’.

4.3.5 Examples of SQL DML Statements

Basic Select Statements

CREATE TABLE students (
      studentid NUMBER(5,0),
      name VARCHAR2(25),
      major VARCHAR2(15),
      gpa NUMBER(6,3),
      tutorid NUMBER(5,0)
      );

INSERT INTO students VALUES (101, 'Bill', 'CIS', 3.45,  102);
INSERT INTO students VALUES (102, 'Mary', 'CIS', 3.10,  NULL);
INSERT INTO students VALUES (103, 'Sue',  'Marketing', 2.95, 102);
INSERT INTO students VALUES (104, 'Tom',  'Finance', 3.5, 106);
INSERT INTO students VALUES (105, 'Alex', 'CIS', 2.75, 106);
INSERT INTO students VALUES (106, 'Sam',  'Marketing', 3.25, 103);
INSERT INTO students VALUES (107, 'Jane', 'Finance', 2.90, 102);

Example table COURSES:

CREATE TABLE courses(
      studentid  NUMBER(5,0) NOT NULL,
      coursenumber VARCHAR2(15) NOT NULL,
      coursename VARCHAR2(25),
      semester  VARCHAR2(10),
      year NUMBER(4,0),
      grade VARCHAR2(2)
      );

INSERT INTO courses VALUES (101, 'CIS3400', 'DBMS I', 'FALL', 1997, 'B+');
INSERT INTO courses VALUES (101, 'CIS3100', 'OOP I', 'SPRING', 1999, 'A-');
INSERT INTO courses VALUES (101, 'MKT3000', 'Marketing', 'FALL', 1997, 'A');
INSERT INTO courses VALUES (102, 'CIS3400', 'DBMS I', 'SPRING', 1997, 'A-');
INSERT INTO courses VALUES (102, 'CIS3500', 'Network I', 'SUMMER', 1997, 'B');
INSERT INTO courses VALUES (102, 'CIS4500', 'Network II', 'FALL', 1997, 'B+');
INSERT INTO courses VALUES (103, 'MKT3100', 'Advertizing', 'SPRING', 1998, 'A');
INSERT INTO courses VALUES (103, 'MKT3000', 'Marketing', 'FALL', 1997, 'A');
INSERT INTO courses VALUES (103, 'MKT4100', 'Marketing II', 'SUMMER', 1998, 'A-');

• Example query:Show all of the columns and all student records in the STUDENTS table:

  
  SELECT * FROM students;
  
  

  StudentID	Name	Major	GPA	TutorId
  101	Bill	CIS	3.45	102
  102	Mary	CIS	3.1
  103	Sue	Marketing	2.95	102
  104	Tom	Finance	3.5	106
  105	Alex	CIS	2.75	106
  106	Sam	Marketing	3.25	103
  107	Jane	Finance	2.9	102

• Show the Average GPA of all students:

   
   SELECT AVG(gpa)
    FROM   students;
  
  AVG(GPA)
  ----------
  3.12857143
  
  

• Average GPA of Finance and CIS students:

    SELECT AVG(gpa)
    FROM   students
    WHERE  major = 'CIS' OR major = 'Finance';
  
    AVG(GPA)
  ----------
        3.14
  
  

• Give the name of the student with the highest GPA:
  This is an example of a subquery . The SELECT MAX(gpa) FORM students part runs first and returns a single number that is then matched up to the WHERE clause.
  

  SELECT name, gpa
  FROM   students
  WHERE  gpa =
    (  SELECT MAX(gpa) FROM students  );
  
  NAME            GPA
  -------- ----------
  Tom             3.5
  
  

  
  Another option is to enclose some text in quotes and
  concatenate that text with the output of the SQL statement:
  

  SELECT 'The student with the highest GPA is ' || name
  FROM   students
  WHERE  gpa =
    (  SELECT MAX(gpa) FROM students   );
  
  
  NAME
  ------------------------------------------
  The student with the highest grade is Tom
  
  

  
  
• Show the students with the highest GPA in each major. Format the GPA with trailing 0 if necessary:

  SELECT    name, major, TO_CHAR(gpa, '9.00') AS GPA
  FROM      students s1
  WHERE     gpa =
     (
       SELECT max(gpa)
       FROM   students s2
       WHERE  s1.major = s2.major
     );
  
  NAME               MAJOR           GPA
  ------------------ --------------- -----
  Bill               CIS              3.45
  Tom                Finance          3.50
  Sam                Marketing        3.25
  
  

  
  Note the two aliases given to the students table:s1 and s2 . These allow us to refer to different views of the same table.
  

SELECT    name, major, gpa
FROM      students s1
WHERE     gpa =
   (
     SELECT max(gpa)
     FROM   students s2
     WHERE  s1.major = s2.major
   )
ORDER BY gpa DESC;

NAME     MAJOR             GPA
-------- ---------- ----------
Tom      Finance           3.5
Bill     CIS              3.45
Sam      Marketing        3.25

Selecting from 2 or More Tables

• In the FROM portion, list all tables separated by commas. Called a Join .
• The WHERE part becomes the Join Condition

Example table EMPLOYEE:
FNAME    MI LNAME   EMPLOYEEID BDATE     ADDRESS                   S SALARY SUPEREMPID DNO
-------- -- ------- ---------- --------- ------------------------- - ------ ---------- ---
JOHN     B  SMITH    123456789 09-JAN-75 731 FONDREN, HOUSTON, TX  M  30000  333445555 5
FRANKLIN T  WONG     333445555 08-DEC-65 638 VOSS,HOUSTON TX       M  40000  888665555 5
ALICIA   J  ZELAYA   999887777 19-JUL-78 3321 CASTLE, SPRING, TX   F  25000  987654321 4
JENNIFER S  WALLACE  987654321 20-JUN-51 291 BERRY, BELLAIRE, TX   F  43000  888665555 4
RAMESH   K  NARAYAN  666884444 15-SEP-72 975 FIRE OAK, HUMBLE, TX  M  38000  333445555 5
JOYCE    A  ENGLISH  453453453 31-JUL-82 5631 RICE, HOUSTON, TX    F  25000  333445555 5
AHMAD    V  JABBAR   987987987 29-MAR-79 980 DALLAS, HOUSTON, TX   M  25000  987654321 4
JAMES    E  BORG     888665555 10-NOV-47 450 STONE, HOUSTON, TX    M  55000            1

Example table DEPARTMENT:
DNAME             DNUMBER  MGREMPID MGRSTARTD
--------------- --------- --------- ---------
RESEARCH                5 333445555 22-MAY-98
ADMINISTRATION          4 987654321 01-JAN-05
HEADQUARTERS            1 888665555 19-JUN-91

Example Table DEPT_LOCATIONS:
DNUMBER DLOCATION
------- ---------------
      1 HOUSTON
      4 STAFFORD
      5 BELLAIRE
      5 SUGARLAND
      5 HOUSTON

Example table DEPENDENT:
EMPLOYEEID DEPENDENT_NAME  SEX BDATE     RELATIONSHIP
---------- --------------- --- --------- ------------
 333445555 ALICE           F   05-APR-96 DAUGHTER
 333445555 THEODORE        M   25-OCT-93 SON
 333445555 JOY             F   03-MAY-68 SPOUSE
 123456789 MICHAEL         M   01-JAN-98 SON
 123456789 ALICE           F   31-DEC-98 DAUGHTER
 123456789 ELIZABETH       F   05-MAY-77 SPOUSE
 987654321 ABNER           M   26-FEB-52 SPOUSE

• List all of the employees working in Houston:

  SELECT  employee.fname, employee.lname
  FROM    employee, dept_locations
  WHERE   employee.dno = dept_locations.dnumber
  AND     dept_locations.dlocation = 'HOUSTON' ;
  
  FNAME    LNAME
  -------- --------
  JOHN     SMITH
  FRANKLIN WONG
  RAMESH   NARAYAN
  JOYCE    ENGLISH
  JAMES    BORG
  

  
  
• List each employee name and the location they work in. List them in order of location and name:

  SELECT    dept_locations.dlocation, department.dname,
            employee.fname, employee.lname
  FROM      employee, department, dept_locations
  WHERE     employee.dno = department.dnumber
     AND    department.dnumber = dept_locations.dnumber
     AND    employee.dno = dept_locations.dnumber
  ORDER BY  dept_locations.dlocation, employee.lname;
  
  Results:
  DLOCATION       DNAME           FNAME    LNAME
  --------------- --------------- -------- --------
  BELLAIRE        RESEARCH        JOYCE    ENGLISH
  BELLAIRE        RESEARCH        RAMESH   NARAYAN
  BELLAIRE        RESEARCH        JOHN     SMITH
  BELLAIRE        RESEARCH        FRANKLIN WONG
  HOUSTON         HEADQUARTERS    JAMES    BORG
  HOUSTON         RESEARCH        JOYCE    ENGLISH
  HOUSTON         RESEARCH        RAMESH   NARAYAN
  HOUSTON         RESEARCH        JOHN     SMITH
  HOUSTON         RESEARCH        FRANKLIN WONG
  STAFFORD        ADMINISTRATION  AHMAD    JABBAR
  STAFFORD        ADMINISTRATION  JENNIFER WALLACE
  STAFFORD        ADMINISTRATION  ALICIA   ZELAYA
  SUGARLAND       RESEARCH        JOYCE    ENGLISH
  SUGARLAND       RESEARCH        RAMESH   NARAYAN
  SUGARLAND       RESEARCH        JOHN     SMITH
  SUGARLAND       RESEARCH        FRANKLIN WONG
  
  16 rows selected.
  

  
  
• What is the highest paid salary in Houston ?

  SELECT MAX(employee.salary)
  FROM   employee, dept_locations
  WHERE  employee.dno = dept_locations.dnumber
   AND   dept_locations.dlocation = 'HOUSTON';
  
  MAX(EMPLOYEE.SALARY)
  --------------------
                 55000
  

  
  
• To obtain the Cartesian Product of two tables, use a SELECT statement with no WHERE clause:

  SELECT *
  FROM department, dept_locations ;
  
  DNAME           DNUMBER    MGRSSN MGRSTARTD DNUMBER DLOCATION
  --------------- ------- --------- --------- ------- ----------
  RESEARCH              5 333445555 22-MAY-78       1 HOUSTON
  ADMINISTRATION        4 987654321 01-JAN-85       1 HOUSTON
  HEADQUARTERS          1 888665555 19-JUN-71       1 HOUSTON
  RESEARCH              5 333445555 22-MAY-78       4 STAFFORD
  ADMINISTRATION        4 987654321 01-JAN-85       4 STAFFORD
  HEADQUARTERS          1 888665555 19-JUN-71       4 STAFFORD
  RESEARCH              5 333445555 22-MAY-78       5 BELLAIRE
  ADMINISTRATION        4 987654321 01-JAN-85       5 BELLAIRE
  HEADQUARTERS          1 888665555 19-JUN-71       5 BELLAIRE
  RESEARCH              5 333445555 22-MAY-78       5 SUGARLAND
  ADMINISTRATION        4 987654321 01-JAN-85       5 SUGARLAND
  HEADQUARTERS          1 888665555 19-JUN-71       5 SUGARLAND
  RESEARCH              5 333445555 22-MAY-78       5 HOUSTON
  ADMINISTRATION        4 987654321 01-JAN-85       5 HOUSTON
  HEADQUARTERS          1 888665555 19-JUN-71       5 HOUSTON
                   15 rows selected.
  

  
  
• In which states do our employees work ?

  SELECT    DISTINCT dlocation
  FROM      dept_locations;
  
  DLOCATION
  ---------------
  BELLAIRE
  HOUSTON
  STAFFORD
  SUGARLAND
  

  
  
• List the Department name and the total salaries for each department:

  SELECT   department.dname, SUM( employee.salary )
  FROM     employee, department
  WHERE    employee.dno = department.dnumber
  GROUP BY department.dname
  
  Results:
  
  DNAME           SUM(EMPLOYEE.SALARY)
  --------------- --------------------
  ADMINISTRATION                 93000
  HEADQUARTERS                   55000
  RESEARCH                      133000
  

  
  
• We can also use a Column Alias to change the title of the columns

  SELECT   department.dname, SUM( employee.salary ) AS TotalSalaries
  FROM     employee, department
  WHERE    employee.dno = department.dnumber
  GROUP BY department.dname
  
  Results:
  
  DNAME           TOTALSALARIES
  --------------- -------------
  ADMINISTRATION          93000
  HEADQUARTERS            55000
  RESEARCH               133000
  

  
  
• Here is a combination of a function and
  a column alias:
  

  SELECT   fname, lname,
           salary  AS CurrentSalary,
           (salary * 1.03)  AS ProposedRaise
  FROM     employee;
  
  FNAME    LNAME    CURRENTSALARY PROPOSEDRAISE
  -------- -------- ------------- -------------
  JOHN     SMITH            30000         30900
  FRANKLIN WONG             40000         41200
  ALICIA   ZELAYA           25000         25750
  JENNIFER WALLACE          43000         44290
  RAMESH   NARAYAN          38000         39140
  JOYCE    ENGLISH          25000         25750
  AHMAD    JABBAR           25000         25750
  JAMES    BORG             55000         56650
  
  8 rows selected.
  

4.3.5 Examples of SQL DML Statements – Continued

Recursive Queries and Table Aliases

• Recall some of the E-R diagrams and relations we dealt with had a recursive relationship.
• For example:A student can tutor one or more other students. A student has only one tutor.
  STUDENTS (studentid, name, major, grade, student_tutorid)
  
• Provide a listing of each student and the name
  of their tutor:
  

  SELECT   s1.name AS Student,  tutors.name AS Tutor
  FROM     students s1,  students tutors
  WHERE    s1.tutorid = tutors.studentid;
  
  STUDENT                   TUTOR
  ------------------------- -----------
  Bill                      Mary
  Sue                       Mary
  Jane                      Mary
  Sam                       Sue
  Tom                       Sam
  Alex                      Sam
  

  
  
• The above is called a “recursive” query because it access the same table two times.
• We give the table two aliases called s1 and tutors so that we can compare different aspects of the same table.
  
• However, as is, the table is missing something:We don’t see who is tutoring Mary. Use a left outer join to see the rest of the information. In MS Access, we use the LEFT JOIN comando. In Oracle, we place a (+) after the join condition to indicate an outer join:
  In MS Access:
  

  SELECT   s1.name AS Student,  tutors.name AS Tutor
  FROM     students s1   LEFT JOIN   students tutors
  ON       s1.tutorid = tutors.studentid;
  

  
  In Oracle:
  

  SELECT   s1.name AS Student,  tutors.name AS Tutor
  FROM     students s1, students tutors
  WHERE    s1.tutorid = tutors.studentid (+) ;
  
  STUDENT                   TUTOR
  ------------------------- -------------
  Bill                      Mary
  Sue                       Mary
  Jane                      Mary
  Sam                       Sue
  Tom                       Sam
  Alex                      Sam
  Mary
  

  
  
• Suppose instead of printing a blank for Mary’s tutor, we would like to write something meaningful in the output. Use the NVL function:

  SELECT   s1.name AS Student,  NVL(tutors.name, 'No Tutor') AS Tutor
  FROM     students s1, students tutors
  WHERE    s1.tutorid = tutors.studentid (+) ;
  
  STUDENT                   TUTOR
  ------------------------- -------------------------
  Bill                      Mary
  Sue                       Mary
  Jane                      Mary
  Sam                       Sue
  Tom                       Sam
  Alex                      Sam
  Mary                      No Tutor
  

  
  
• Here is one more twist:Suppose we were interested in those students who do not tutor anyone? Use a right outer join (RIGHT JOIN in MS Access).
  
• How many students does each tutor work with ?

  SELECT   s1.name AS TutorName,
           COUNT(tutors.tutorid) AS NumberTutored
  FROM     students s1, students tutors
  WHERE    s1.studentid = tutors.tutorid
  GROUP BY s1.name;
  
  TUTORNAME                 NUMBERTUTORED
  ------------------------- -------------
  Mary                                  3
  Sam                                   2
  Sue                                   1
  

Tree Queries

• Bill tutors Alex, Mary and Sue.
• Mary tutors Liz and Ed
• Sue tutors Petra

• START WITH – indicates which row the tree should start with.
• CONNECT BY – indicates how successive related rows are to be identified and included in the result.
• LEVEL – a pseudo-column that indicates which level of the tree the current row is assigned to.

SELECT            LPAD(' ',3*(LEVEL-1)) || students.name
                  As TutorTree
FROM              students
START WITH        studentid = '102'
CONNECT BY PRIOR  studentid = tutorid;

TUTORTREE
-----------------------------------
Mary
  Bill
  Sue
    Sam
      Tom
      Alex
  Jane

7 rows selected.

Tree Query Exercise

SUPERVISORTREE
---------------
BORG
   WONG
      SMITH
      ENGLISH
      NARAYAN
   WALLACE
      JABBAR
      ZELAYA

4.3.5 Examples of SQL DML Statements – Continued

WHERE Clause Expressions

• There are a number of expressions one can use in a WHERE clause.
• Subqueries using =(equals) :
  These are used when we want to compare values from the outer query to the result of a sub query.
  

  SELECT name, grade
  FROM   students
  WHERE  grade =
    (  SELECT MAX(grade) FROM students   );
  
  
  

  
  This assumes the subquery returns only one tuple as a result. This is typically used when aggregate functions are in the subquery. For example, we know ahead of time that selecting MAX(grade will only ever return one number. So then we can compare this one number to the WHERE grade = cláusula.
  
  
• Subqueries using the IN operator . The IN operator is used whenever the value of a column should be found in a set of values. The set of values can be explicitly listed (as in the first example below) or they can be created on the fly using a subquery.

  SELECT    employee.fname, department.dname
  FROM      employee, department
  WHERE     employee.dno = department.dnumber
    AND     department.dname IN ('HEADQUARTERS', 'RESEARCH');
  
  FNAME    DNAME
  -------- ---------------
  JAMES    HEADQUARTERS
  JOHN     RESEARCH
  JOYCE    RESEARCH
  RAMESH   RESEARCH
  FRANKLIN RESEARCH
  
  
  SELECT    employee.fname
  FROM      employee
  WHERE     employee.dno IN
            (SELECT dept_locations.dnumber
             FROM dept_locations
             WHERE dept_locations.dlocation = 'STAFFORD');
  
  FNAME
  -------
  ALICIA
  JENNIFER
  AHMAD
  
  

  
  In the above case, the subquery returns a set of tuples. The IN clause returns true when a tuple matches a member of the set.
  
• Subqueries using EXISTS . EXISTS will return TRUE if there is at least one row resulting from the subquery.

  SELECT   fname, lname, salary
  FROM     employee
  WHERE    EXISTS
           (SELECT  fname
            FROM    EMPLOYEE e2
            WHERE   e2.salary > employee.salary)
       AND EXISTS
           (SELECT  fname
            FROM    EMPLOYEE e3
            WHERE   e3.salary < employee.salary);
  
  FNAME    LNAME       SALARY
  -------- -------- ---------
  JOHN     SMITH        30000
  FRANKLIN WONG         40000
  JENNIFER WALLACE      43000
  RAMESH   NARAYAN      38000
  
  

  
  The above query shows all employees names and salaries where there is at least one person who makes more money (the first exists) and at least one person who makes less money (second exists).
  
  
• Subqueries with NOT EXISTS . NOT EXISTS will return TRUE if there are no rows returned by the subquery.

  SELECT   fname, lname, salary
  FROM     employee
  WHERE    NOT EXISTS
           (SELECT  fname
            FROM    EMPLOYEE e2
            WHERE   e2.salary > employee.salary);
  
  FNAME    LNAME       SALARY
  -------- -------- ---------
  JAMES    BORG         55000
  
  

  
  The above query shows all employees for whom there does not exist an employee who is paid less. In other words, the highest paid employee.
  
  
• The HAVING clause is similar to the WHERE clause. The difference is that WHERE is used to filter individual rows while HAVING is used to filter groups according to the GROUP BY clause.
  Show the departments with average salary greater than 33000.
  
  

  SELECT    department.dname, AVG(salary)
  FROM      employee, department
  WHERE     employee.dno = department.dnumber
  GROUP BY  department.dname
  HAVING    AVG(salary) > 33000 ;
  
  DNAME           AVG(SALARY)
  --------------- -----------
  HEADQUARTERS          55000
  RESEARCH              33250
  
  

  
  Show departments with 3 or more employees:
  

  SELECT   department.dname, COUNT(employee.dno)
    FROM   department, employee
   WHERE   department.dnumber = employee.dno
  GROUP BY department.dname
  HAVING   COUNT(employee.dno) >= 3;
  
  DNAME           COUNT(EMPLOYEE.DNO)
  --------------- -------------------
  ADMINISTRATION                    3
  RESEARCH                          4
  
  

  
  
• LIKE operator :
  Use the LIKE operator to perform a partial string match. Generally, the % character is used as the wild card although in some DBMS, the * character is used.
  
  Show all employees whose name starts with ‘S’
  
  

  SELECT   fname, lname, salary
  FROM     employee
  WHERE    lname LIKE  'S%';
  
  
  Result:
  FNAME    LNAME        SALARY
  -------- -------- ----------
  JOHN     SMITH         30000
  
  

  
  Show all employees whose name contains the letters ‘AR’
  

  SELECT   fname, lname, salary
  FROM     employee
  WHERE    lname LIKE  '%AR%';
  
  Result:
  FNAME    LNAME        SALARY
  -------- -------- ----------
  RAMESH   NARAYAN       38000
  AHMAD    JABBAR        25000
  
  

  
  Note that characters within quotes are case sensitive.
  
  Show all employees whose name contains the letter ‘E’ and the letter ‘L’ in that order:
  

  SELECT   fname, lname, salary
  FROM     employee
  WHERE    lname LIKE  '%E%L%';
  
  Result:
  FNAME    LNAME        SALARY
  -------- -------- ----------
  JOYCE    ENGLISH       25000
  
  

  
  Show all employees whose name contains the letter ‘E’ and the letter ‘L’ in any order:
  
  

  SELECT   fname, lname, salary
  FROM     employee
  WHERE    lname LIKE  '%E%L%' OR
           lname LIKE  '%L%E%';
  
  Result:
  FNAME    LNAME        SALARY
  -------- -------- ----------
  JENNIFER WALLACE       43000
  JOYCE    ENGLISH       25000
  
  

4.3.5 Examples of SQL DML Statements – Continued

Examples of SQL Functions

• The TO_CHAR function can be used to extract specific parts of a Date or to format a Number.
  For example, to extract the Year and the month from the date of birth of each of the employees, use TO_CHAR with a “mask” of ‘YYYY-MM’
  

  SELECT lname, TO_CHAR(bdate, 'YYYY-MM') AS Birth_Year_Month
  FROM   employee;
  
  LNAME   BIRTH_YEAR_MONTH
  ------- -----------
  SMITH   1975-01
  WONG    1965-12
  ZELAYA  1978-07
  WALLACE 1951-06
  NARAYAN 1972-09
  ENGLISH 1982-07
  JABBAR  1979-03
  BORG    1947-11
  
  

• Show the employees who have a dependent born in the same month:

  
  SELECT employee.fname, 
         employee.lname, 
         dependent_name, 
         relationship,
         TO_CHAR(dependent.bdate, 'MM') AS Birth_Month
  FROM   employee, dependent
  WHERE  employee.employeeid = dependent.employeeid
    AND  TO_CHAR(dependent.bdate, 'MM') = 
         TO_CHAR(employee.bdate, 'MM');
         
  FNAME LNAME DEPENDENT_NAME  RELATIONSHIP  BIRTH_MONTH
  JOHN  SMITH MICHAEL         SON           01
  
  

• Text, dates and numbers can be combined using the various conversion functions. In the following example, the TO_CHAR function is used to convert the date BDATE into a character string.
  

  SELECT 'The oldest employee was born on ' ||
         TO_CHAR( MIN(bdate), 'DD/MM/YYYY')
         AS Sentence
  FROM   employee;
  
  SENTENCE
  ----------------------------------------
  The oldest employee was born on 10/11/1947
  
  

• Date math results in a numerical answer that must be converted to characters to concatenate with other character strings as in this next example:

SELECT 'The oldest employee was born on ' ||
       TO_CHAR( MIN(bdate), 'DD/MM/YYYY') || ' and is now' ||
       TO_CHAR( (SYSDATE - MIN(bdate)) / 365, '99') ||
       ' years old.'
       AS Sentence
FROM   employee;

SENTENCE
-----------------------------------------------------------------
The oldest employee was born on 10/11/1947 and is now 68 years old.

• The TO_DATE and TO_CHAR functions are extremely useful when working with dates and times.
  Oracle stores bother the date and time in one column using the DATE datatype. For example,
  Suppose you have a table MYDATES with two varchar columns:
  

  IMPORTANT_DATE   varchar2    -- example:  12/4/2015
  IMPORTANT_TIME   varchar2    -- example:  9:35:00 AM
  
  

  
  To get these formatted from a CHAR string to a DATE data type you might do something like:
  

  SELECT TO_DATE(IMPORTANT_DATE || ' ' || IMPORTANT_TIME, 
                 'MM/DD/YYYY HH24:MI:SS AM')
  FROM mydates;
  
  

  
  What this does is first is concatenates the value in the IMPORTANT_DATE column with a blank space and then with the IMPORTANT_TIME column using the concatenation || operador. The result will be a varchar string like:'12/4/2015 9:35:00 AM'
  
  Then the TO_DATE function take the format 'MM/DD/YYYY HH24:MI:SS AM' and applies it to the string. This lines up MM with the month 12 , then lines up the DD day with 4 e assim por diante. MI stands for minute. AM matches either AM or PM .
  The end result is this is output to an Oracle DATE data type.
  The result of this conversion can be stored back in to the table by adding a new column of DATE data type to store this:
  

  ALTER TABLE mydates ADD (important_datetime DATE);
  
  

  
  Then a SQL UPDATE statement can be used to populate this new important_datetime columns:
  

  UPDATE mydates
  SET important_dateimte = 
      TO_DATE(IMPORTANT_DATE || ' ' || IMPORTANT_TIME, 
              'MM/DD/YYYY HH24:MI:SS AM')
  
  

  
  Once the column is in DATE data type, the opposite function TO_CHAR can be used to pull apart the DATE and get specific parts of it. For example, to see just the hour:
  

  SELECT TO_CHAR(important_datetime, 'HH24') 
  FROM  mydates;
  
  

  
  Or, to get this isolated in its own column:
  

  ALTER TABLE MYDATES ADD (important_hour INTEGER );
  
  UPDATE mydates
  SET important_hour = TO_CHAR(important_datetime, 'HH24') ;
  
  

  
  If you don’t feel like making new columns, just nest TO_DATE inside of TO_CHAR for example:
  

  SELECT TO_CHAR(  
                    TO_DATE(IMPORTANT_DATE || ' ' || IMPORTANT_TIME, 
                            'MM/DD/YYYY HH24:MI:SS AM'),
                    'HH24'
                 )
  FROM mydates;
  
  

• The DECODE function can be used to provide a variety of lookup values. In the following example, the string concatenation operator || is used to put together a sentence about each employee. The DECODE command takes the COUNT of dependents as the first argument. Then, depending on the COUNT for a given employee, it returns an appropriate ending to the sentence.
  

  SELECT   fname || ' '|| lname || ' has ' ||
           DECODE(COUNT(dependent.employeeid),
                  0, 'no dependents.',
                  1, 'one dependent.',
                  2, 'two dependents.',
                  3, 'three dependents.')
          AS Sentence
  FROM     employee, dependent
  WHERE    employee.employeeid = dependent.employeeid (+)
  GROUP BY employee.fname, lname;
  
  SENTENCE
  ---------------------------------------
  AHMAD JABBAR has no dependents.
  ALICIA ZELAYA has no dependents.
  FRANKLIN WONG has three dependents.
  JAMES BORG has no dependents.
  JENNIFER WALLACE has one dependent.
  JOHN SMITH has three dependents.
  JOYCE ENGLISH has no dependents.
  RAMESH NARAYAN has no dependents.
  
  8 rows selected.
  
  

  
  The DECODE function can also be used to “invert” a table. That is, to transpose columns and rows. For example to show the department names along a single row we might use:
  

  SELECT MAX(DECODE(dnumber, 1, dname)) AS Department,
         MAX(DECODE(dnumber, 4, dname)) AS Department,
         MAX(DECODE(dnumber, 5, dname)) AS Department
  FROM department ;
  
  
  DEPARTMENT      DEPARTMENT      DEPARTMENT
  --------------- --------------- ---------------
  HEADQUARTERS    ADMINISTRATION  RESEARCH
  
  

Deleting Tuples with DELETE

• DELETE is used to remove tuples from a table.
• With no WHERE clause, DELETE will remove all tuples from a table.
• Remove all employees:

    DELETE employee;
  
    

• Remove only employees making more than $50,000

    DELETE employee
    WHERE  salary  > 50000;
  
    

  
  
• Remove all employees working in Houston:

    DELETE employee
    WHERE  employee.dno IN
      (SELECT dept_locations.dnumber
       FROM   dept_locations
       WHERE  dlocation = 'HOUSTON');
  
    

  
  
• DELETE will not be successful if a constraint would be violated.
  For example, consider the DNO attribute in the Employee table as a Foreign Key.
  Removing a department would then be contingent upon no employees working in that department.
  This is what we call enforcing Referential Integrity
  
• A relative of the DELETE statement is the TRUNCATE statement:

         TRUNCATE <table name> ;
  
  

  
  The TRUNCATE statement removes all records from a table but leaves the table structure in place. It is similar to:DELETE FROM table-name without a WHERE clause. However, whereas DELETE can be rolled back, TRUNCATE can not.
  

Change Values using UPDATE

• The UPDATE command is used to change attribute values in the database.
• UPDATE uses the SET clause to overwrite the value.
  
• Change the last name of an Employee:
  

  UPDATE employee
  SET    lname = 'SMITH'
  WHERE  lname = 'JONES';
  
  

  
  
• Give an Employee a raise:

  UPDATE employee
  SET    salary = salary * 1.05
  WHERE  fname = 'JOYCE' AND lname = 'ENGLISH' ;
  
  

  
  
• Give all employees over the age of 50
  a raise:
  

     UPDATE EMPLOYEE
     SET SALARY = SALARY * 1.02
     WHERE TO_NUMBER( ( SYSDATE - bdate) / 365) >= 50;
  
  

Exercise 8:Update and Delete

• Add .05 to all of the Marketing major’s GPA’s.
• Change Sam’s tutor from Sue to Jane
• For any student who is currently majoring in CIS and who has a GPA of less than 3.0, change their major to Marketing.

5. Advanced SQL*Plus Commands

5.1 Editing The SQL Buffer

• / – Execute the current SQL statement in the buffer
• APPEND – Add text to the end of the current line of the SQL statement in the buffer
• CHANGE – Replace text on the current line of the SQL statement with new text
• CLEAR – Clear the buffer
• DEL – Delete the current line in the buffer
• INPUT – Add one or more lines to the SQL statement in the buffer
• LIST – List the current SQL statement in the buffer
• RUN – Execute the current SQL statement in the buffer
• SAVE – Save the current SQL statement to a script file
• START – Load a SQL statement located in a script file and then run that SQL statement
  

   SQL> SELECT tname, tabtype
     2  FRO
     3  tab;
   FRO
   *
   ERROR at line 2:
   ORA-00923: FROM keyword not found where expected

   SQL> 2 FROM
   SQL> RUN

   TNAME                          TABTYPE
   ------------------------------ -------
   MACHINE                        TABLE
   EMPLOYEE                       TABLE

   SQL> LIST
     1  SELECT tname, tabtype
     2  FROM
     3* tab

   SQL> LIST
     1  SELECT tname, tabtype
     2  FROM
     3* tab

   SQL> APPEND xyz
     3* tabxyz

   SQL> LIST
     1  SELECT tname, tabtype
     2  FROM
     3* tabxyz

   SQL> LIST
     1  SELECT tname, tabtype
     2  FROM
     3* tabxyz

   SQL> CHANGE/xyz//
     3* tab

   SQL> LIST
     1  SELECT tname, tabtype
     2  FROM
     3* tab

   SQL> LIST
     1  SELECT tname, tabtype
     2  FROM
     3* tab

   SQL> 2
     2* FROM

   SQL> LIST
     1  SELECT tname, tabtype
     2* FROM
     3  tab

   SQL> LIST
     1  SELECT tname, tabtype
     2* FROM
     3  tab

   SQL> DEL
     2

   SQL> LIST
     1  SELECT tname, tabtype
     2* tab

   SQL> LIST
     1  SELECT tname, tabtype
     2* FROM
     3  tab

   SQL> SAVE query.sql

   SQL> SAVE d:\query.sql

   SQL> START query.sql

   TNAME                          TABTYPE
   ------------------------------ -------
   MACHINE                        TABLE
   EMPLOYEE                       TABLE

   SQL>

   SQL> START d:\query.sql

   SQL> START /home/holowczak/oracle/queries/query.sql

5.2 Formatting SQL*Plus Output

• BREAK – Set the formatting behavior for records that have the same values for some columns
• BTITLE – Place a title on the bottom of each page in the printout from a SQL statement
• COLUMN – Change the appearance of an output column from a query
• REMARK – Place a comment following the REMARK keyword
• SET – Set a SQL*Plus variable to a new value
• SHOW – Show the current value of a SQL*Plus variable
• TTITLE – Place a title on the top of each page in the printout from a SQL statement
• UNDEFINE – Delete a user defined variable

 COLUMN column_name option1 option2 ...

• FORMAT format – Changes the format for the column. For example, to only display the first 10 characters of an employee’s last name (column LNAME), use the following:

       COLUMN lname FORMAT A10     

  
  This indicates to format the lname column as an Ascii column with only 10 characters. Numbers can be formatted using “9” to indicate digits. Por exemplo:
  

       COLUMN salary FORMAT $9,999,990.99      
  

• HEADING heading_text
  – changes the heading for a column.
• JUSTIFY LEFT or JUSTIFY CENTER or JUSTIFY RIGHT – aligns the output with the left, center or right of the column.
• NULL text – Indicates the text that should be displayed in place of a NULL value.
• WRAPPED or WORD_WRAPPED or TRUNCATED – Indicates how text that is longer than the displayed column width should be handled. TRUNCATED means it will be cut off at the maximum width of the field. WRAPPED will wrap the value down to the
  next line of output. WORD_WRAPPED does the same as Wrapped but breaks the value up on white space.

SQL> show all
appinfo is ON and set to "SQL*Plus"
arraysize 15
autocommit OFF
autoprint OFF
autotrace OFF
shiftinout INVISIBLE
blockterminator "." (hex 2e)
btitle OFF and is the 1st few characters of the next SELECT
cmdsep OFF
colsep " "
compatibility version NATIVE
concat "." (hex 2e)
copycommit 0
copytypecheck is ON
define "&" (hex 26)
echo OFF
editfile "afiedt.buf"
embedded OFF
escape OFF
feedback ON for 6 or more rows
flagger OFF
flush ON
heading ON
headsep "|" (hex 7c)
linesize 100
lno 24
loboffset 1
long 80
longchunksize 80
newpage 1
null ""
numformat ""
numwidth 9
pagesize 24
pause is OFF
pno 0
recsep WRAP
recsepchar " " (hex 20)
release 800030000
repfooter OFF and is NULL
repheader OFF and is NULL
serveroutput OFF
showmode OFF
spool OFF
sqlcase MIXED
sqlcode 0
sqlcontinue "> "
sqlnumber ON
sqlprefix "#" (hex 23)
sqlprompt "SQL> "
sqlterminator ";" (hex 3b)
suffix "SQL"
tab ON
termout ON
time OFF
timing OFF
trimout ON
trimspool OFF
ttitle OFF and is the 1st few characters of the next SELECT
underline "-" (hex 2d)
user is "HOLOWCZAK"
verify ON
wrap : lines will be wrapped

• SET COLSEP – The separator characters between columns (default is a space)
• SET ECHO – Determines if SQL*Plus commands should be echoed or not. The default is OFF meaning SQL*Plus commands will not be echoed.
• SET HEADING – Determines if column headings should be displayed or not. Default is ON .
• SET LINESIZE – Determines the maximum number of characters in a line of output. The default is 80.
• SET LONG – Determines how much data in a LONG column will be displayed. The default is 80 bytes.
• SET MARKUP – Converts output of SQL*Plus to HTML markup (Oracle8i and above only). For example:SET MARKUP HTML ON
• SET NULL – Determines what value should be displayed in place of a NULL value.
• SET PAGESIZE – The number of lines for one page (before the headers repeat). The default is 24 lines.
• SET PAUSE – Determines if output should be paused after PAGESIZE lines have been displayed. The default is OFF .
• SET TRIMOUT – Determines if each line should be padded with blanks out to a length of LINESIZE . The default is ON meaning the output will be trimmed (e.g., will not be padded with spaces).
• SET WRAP – Determines if the output will be wrapped to the next line or truncated if the line is longer than LINESIZE . The default is ON meaning long output will be wrapped.

TTITLE 'Employees, Departments and Department Managers'
SET PAGESIZE 36
COLUMN address      FORMAT A20 WORD_WRAPPED
COLUMN dept_manager FORMAT A13 WORD_WRAPPED HEADING 'Dept. Manager'
COLUMN dno          FORMAT 999
SELECT employee.fname, employee.lname, employee.address,
       employee.dno, department.dname,
       employee2.fname || ' ' || employee2.lname  dept_manager
FROM   employee, department, employee employee2
WHERE  employee.dno = department.dnumber
   AND department.mgrempid = employee2.employeeid ;

SQL> START d:\myquery.sql

Mon Jan 05
                        Employees, Departments and Department Managers

FNAME    LNAME    ADDRESS              DNO DNAME          Dept. Manager
-------- -------- -------------------- --- -------------- -------------
JOHN     SMITH    731 FONDREN,           5 RESEARCH       FRANKLIN WONG
                  HOUSTON, TX

FRANKLIN WONG     638 VOSS,HOUSTON TX    5 RESEARCH       FRANKLIN WONG
RAMESH   NARAYAN  975 FIRE OAK,          5 RESEARCH       FRANKLIN WONG
                  HUMBLE, TX

JOYCE    ENGLISH  5631 RICE, HOUSTON,    5 RESEARCH       FRANKLIN WONG
                  TX

JAMES    BORG     450 STONE, HOUSTON,    1 HEADQUARTERS   JAMES BORG
                  TX

ALICIA   ZELAYA   3321 CASTLE, SPRING,   4 ADMINISTRATION JENNIFER
                  TX                                      WALLACE

JENNIFER WALLACE  291 BERRY, BELLAIRE,   4 ADMINISTRATION JENNIFER
                  TX                                      WALLACE

AHMAD    JABBAR   980 DALLAS, HOUSTON,   4 ADMINISTRATION JENNIFER
                  TX                                      WALLACE

8 rows selected.

SELECT salary, lname FROM employee ORDER BY salary;

BREAK ON salary

BREAK ON salary ON fname

Exercise 9:Creating a Report Script

SELECT employee.dno, department.dname,
       INITCAP(employee.fname) AS FNAME,
       INITCAP(employee.lname) AS LNAME,
       employee.salary
FROM   employee, department
WHERE  employee.dno = department.dnumber
ORDER BY dno;

Thu Aug 29                                   page    1
             Departments and Employees

Dept. Num Dept. Name      First    Last       Salary
--------- --------------- -------- -------- --------
        1 HEADQUARTERS    James    Borg      $25,000
        4 ADMINISTRATION  Alicia   Zelaya    $25,000
                          Jennifer Wallace   $43,000
                          Ahmad    Jabbar    $25,000
        5 RESEARCH        Joyce    English   $25,000
                          Ramesh   Narayan   $38,000
                          Franklin Wong      $40,000

5.3 Saving SQL*Plus Output using the SPOOL Comando

SQL> SPOOL d:\myfile.out

SQL> SELECT * from EMPLOYEE;

etc.    Any SQL statements typed here will show up in the output.

SQL> SPOOL OFF

Exercise 10:Creating a Report Script and Saving the output

5.4 Prompting and Accepting user Input

PROMPT Type the department you are looking for
ACCEPT dept NUMBER PROMPT "Department Number: "
SELECT fname, lname, dno
FROM   employee
WHERE  dno = &dept ;

SQL>  START a:\empquery.sql
Type the department you are looking for
Department Number: 5
old   3: WHERE dno = &dept
new   3: WHERE dno =         5

FNAME    LNAME          DNO
-------- -------- ---------
JOHN     SMITH            5
FRANKLIN WONG             5
RAMESH   NARAYAN          5
JOYCE    ENGLISH          5

REMARK   This script accepts a department number as
REMARK   input from the user and then displays the
REMARK   last name, first name, address and department number
REMARK   of the employees in that department
REMARK   Turn off VERIFY
SET VERIFY OFF

REMARK   Format some columns
COLUMN dno     FORMAT 99999 HEADING 'Dept.|Number'
COLUMN address FORMAT A25   HEADING 'Address'
COLUMN fname   FORMAT A10   HEADING 'First|Name'
COLUMN lname   FORMAT A12   HEADING 'Last|Name'

REMARK   Prompt the user and get a department number
PROMPT Type the department you are looking for
ACCEPT dept NUMBER PROMPT "Department Number: "

REMARK   Perform the query
SELECT fname, lname, address, dno
FROM   employee
WHERE  dno = &dept ;

SQL>  START d:\empquery.sql
Type the department you are looking for
Department Number: 4

First      Last                                    Dept.
Name       Name         Address                   Number
---------- ------------ ------------------------- ------
ALICIA     ZELAYA       3321 CASTLE, SPRING, TX        4
JENNIFER   WALLACE      291 BERRY, BELLAIRE, TX        4
AHMAD      JABBAR       980 DALLAS, HOUSTON, TX        4

PROMPT Type the last name of the employee you are looking for
ACCEPT name PROMPT "Employee last name: "
SELECT fname, lname, dno
FROM   employee
WHERE  UPPER(lname) like UPPER('%&name%');

Exercise 11:Prompting and Accepting User Input

Please provide a Salary
Salary: 30000

First      Last
Name       Name           Salary
---------- ------------ --------
FRANKLIN   WONG          $40,000
JENNIFER   WALLACE       $43,000
RAMESH     NARAYAN       $38,000

5.5 Generating HTML output from SQL*Plus

SQL> SET MARKUP HTML ON
SQL>

SQL> SELECT fname, lname, salary FROM employee
        WHERE employeeid = '123456789';
<br>
<p>
<table border="1" width="90%">
<tr>
<th>
FNAME
</th>
<th>
LNAME
</th>
<th>
SALARY
</th>
</tr>
<tr>
<td>
JOHN
</td>
<td>
SMITH
</td>
<td align="right">
     30000
</td>
</tr>
</table>
<p>

Exercise 12:Generating HTML output

5.6 Collecting Statistics On SQL Statements

create table PLAN_TABLE (
 statement_id    varchar2(30),
 timestamp       date,
 remarks         varchar2(80),
 operation       varchar2(30),
 options         varchar2(30),
 object_node     varchar2(128),
 object_owner    varchar2(30),
 object_name     varchar2(30),
 object_instance numeric,
 object_type     varchar2(30),
 optimizer       varchar2(255),
 search_columns  number,
 id              numeric,
 parent_id       numeric,
 position        numeric,
 cost            numeric,
 cardinality     numeric,
 bytes           numeric,
 other_tag       varchar2(255),
 partition_start varchar2(255),
 partition_stop  varchar2(255),
 partition_id    numeric,
 other           long);

   SET AUTOTRACE ON

SQL>  SELECT fname, minit, lname, employeeid, bdate, address
      FROM employee;
FNAME    MI LNAME    EMPLOYEEID BDATE     ADDRESS
-------- -- -------- ---------- --------- ------------------------
JOHN     B  SMITH    123456789  09-JAN-75 731 FONDREN, HOUSTON, TX
FRANKLIN T  WONG     333445555  08-DEC-65 638 VOSS,HOUSTON TX
ALICIA   J  ZELAYA   999887777  19-JUL-78 3321 CASTLE, SPRING, TX
JENNIFER S  WALLACE  987654321  20-JUN-51 291 BERRY, BELLAIRE, TX
RAMESH   K  NARAYAN  666884444  15-SEP-72 975 FIRE OAK, HUMBLE, TX
JOYCE    A  ENGLISH  453453453  31-JUL-82 5631 RICE, HOUSTON, TX
AHMAD    V  JABBAR   987987987  29-MAR-79 980 DALLAS, HOUSTON, TX
JAMES    E  BORG     888665555  10-NOV-47 450 STONE, HOUSTON, TX

Execution Plan
----------------------------------------------------------
   0      SELECT STATEMENT Optimizer=CHOOSE
   1    0   TABLE ACCESS (FULL) OF 'EMPLOYEE'

Statistics
----------------------------------------------------------
          0  recursive calls
          3  db block gets
          2  consistent gets
          0  physical reads
          0  redo size
       1891  bytes sent via SQL*Net to client
        651  bytes received via SQL*Net from client
          4  SQL*Net roundtrips to/from client
          1  sorts (memory)
          0  sorts (disk)
          8  rows processed

  SET AUTOTRACE OFF

SQL> TIMING START select_emp
SQL> SELECT fname, minit, lname, employeeid, bdate
     FROM   employee ;

FNAME    MI LNAME    EMPLOYEEID BDATE
-------- -- -------- ---------- ---------
JOHN     B  SMITH    123456789  09-JAN-75
FRANKLIN T  WONG     333445555  08-DEC-65
ALICIA   J  ZELAYA   999887777  19-JUL-78
JENNIFER S  WALLACE  987654321  20-JUN-41
RAMESH   K  NARAYAN  666884444  15-SEP-72
JOYCE    A  ENGLISH  453453453  31-JUL-82
AHMAD    V  JABBAR   987987987  29-MAR-79
JAMES    E  BORG     888665555  10-NOV-47

8 rows selected.

SQL> TIMING SHOW select_emp
timing for: select_emp
 real: 1760

Exercise 13:Generating Statistics

SELECT employee.fname, employee.lname, employee.address,
       employee.dno, department.dname,
       employee2.fname || ' ' || employee2.lname  dept_manager
FROM   employee, department, employee employee2
WHERE  employee.dno = department.dnumber
   AND department.mgrempid = employee2.employeeid;

5.7 Using the ALTER SESSION Statement for Date Formats

    ALTER SESSION
    SET NLS_DATE_FORMAT = <date_format>

    ALTER SESSION SET NLS_DATE_FORMAT = 'DD-MON-YYYY'

6. Oracle Stored Procedures and Triggers

BEGIN
  -- This is a comment line
  -- Now use the PUT_LINE produce to display something
  DBMS_OUTPUT.PUT_LINE('Hello World');
END;

DECLARE
  myname VARCHAR(100);
BEGIN
  -- Assign 'Joe Smith' as the name
  myname := 'Joe Smith';
  -- Now use the PUT_LINE produce to display the name
  DBMS_OUTPUT.PUT_LINE(myname);
END;

DECLARE
  -- Declare the mydept variable using the same data type as the
  -- dno column in the employee table.
  mydept employee.dno%TYPE;
BEGIN
  -- Assign 5 as the department
  mydept := 5;
  -- Now use the PUT_LINE produce to display the department
  DBMS_OUTPUT.PUT_LINE(mydept);
END;

Exercise 14:Basic PL/SQL Procedure

PL/SQL Statements

DECLARE
  deptnum department.dnumber%TYPE;
BEGIN
  deptnum := 5;
  IF (deptnum > 3) THEN
     DBMS_OUTPUT.PUT_LINE('Employees should be paid more than 25,000');
  ELSE
     DBMS_OUTPUT.PUT_LINE('Employees should be paid exactly 40,000');
  END IF;
END;

DECLARE
  i       INTEGER;
  message VARCHAR(180);
BEGIN
  message := 'Hello World  ';
  FOR i IN 1..10 LOOP
      DBMS_OUTPUT.PUT_LINE(message || i);
  END LOOP;
END;

         SELECT <column1, column2, . . .>
         INTO   <var1, var2, . . .>  
         FROM   <table1, table2, . . .>
         WHERE  <where clause>
         GROUP BY <column1, column2, . . .>
         HAVING   <having clause>
         ORDER BY <column1, column2, . . .>

DECLARE
   empsalary     NUMBER;
   empdepartment NUMBER;
BEGIN
   SELECT   employee.salary, employee.dno
   INTO     empsalary, empdepartment
   FROM     employee
   WHERE    employee.lname = 'SMITH';

   IF (empdepartment = 1) THEN
      UPDATE employee
      SET    salary = empsalary * 1.03
      WHERE  employee.lname = 'SMITH';
   END IF;
END;

 EXCEPTION
   WHEN <exception_name> THEN
   BEGIN
   ...
   END;
   WHEN <exception_name> THEN
   BEGIN
   ...
   END;
   WHEN OTHERS THEN
   BEGIN
   ...
   END;

EXCEPTION
   WHEN NO_DATA_FOUND THEN
   BEGIN
     RAISE_APPLICATION_ERROR(-20610,
           'No employee with last name SMITH found');
   END;
   WHEN TOO_MANY_ROWS THEN
   BEGIN
     RAISE_APPLICATION_ERROR(-20612,
           'More than one employee with last name SMITH found');

   END;

Creating Procedures and Triggers

6.1 Oracle Trigger Syntax

• The SQL statement (INSERT, UPDATE, DELETE, SELECT) that causes the event. An event can include more than one SQL statement per trigger.
  
• The timing when the trigger code is executed. Options here include
  • BEFORE – The trigger code is executed before the effects of the SQL statement are put into place.
  • INSTEAD OF – The trigger code is executed instead of the normal SQL statement.
  • AFTER – The trigger code is executed after the normal SQL statement is processed.
• Some SQL statements such as UPDATE, DELETE and SELECT may affect more than one row. Triggers may be specified to fire once for the entire SQL statement or once for each row affected by the SQL statement.

6.2 Trigger Example

CREATE OR REPLACE TRIGGER check_age
BEFORE INSERT OR UPDATE ON employee
FOR EACH ROW
DECLARE
   -- Declare two variables.
   years_old NUMBER;
   error_msg VARCHAR(180);
BEGIN
   --  The variable :new.bdate will be holding the new birth date
   --  of the record to be inserted or updated.  Subtract from
   --  the system date and divide by 365 to get years.
   years_old := ( (sysdate - :new.bdate) / 365);
   -- Now check to see if the new employee is under age.
   -- If so, then show an error.
   IF (years_old < 16) THEN
      error_msg :=  'Do not hire '  || :new.fname || ' ' ||
      :new.lname || '. They are only ' ||
      TO_CHAR(years_old, '99.9') || ' years old.';
      -- Signal the user there is a problem with this data.
      -- This also aborts the affects of the SQL statement
      -- for the current row.
      RAISE_APPLICATION_ERROR ( -20601, error_msg);
   END IF;
END;

1. If there are no syntax errors, the code will be compiled and the trigger will be stored in the user’s schema. In this case, SQL*Plus will respond with a message that the trigger was created.
2. If there are some minor syntax errors within the code itself (between DECLARE and the last END statement), the trigger will still be created and stored in the database, however a message will be returned:Trigger created with compilation errors .
   To view the compilation errors check the USER_ERRORS view:
   SELECT * FROM USER_ERRORS
   or use the SHOW ERRORS SQL*Plus command.
   
3. Finally, if there are syntax errors in the CREATE OR REPLACE TRIGGER statement itself (such as if the employee table does not exist or one of the key words was misspelled), then the entire statement will be rejected and the trigger code will not be saved in the schema.

SQL> SELECT * FROM user_errors;

  no rows selected

SQL> SET LONG 4096
SQL> SET PAGESIZE 90
SQL> SELECT * FROM user_triggers;

SQL> SELECT trigger_name, trigger_body
     FROM   user_triggers
     WHERE  trigger_name = 'CHECK_AGE';

SQL> INSERT INTO employee VALUES ('12332199', 'Joe', 'K', 'Smith',
  2  '08-JUN-1999', '123 Smith St,', 'M', 32000, 888665555, 1);
INSERT INTO employee VALUES ('12332199', 'Joe', 'K', 'Smith',
            *
ERROR at line 1:
ORA-20601: Do not hire Joe Smith. They are only  15.6 years old.
ORA-06512: at "HOLOWCZAK.CHECK_AGE", line 8
ORA-04088: error during execution of trigger 'HOLOWCZAK.CHECK_AGE'

6.3 Stored Procedure Example

CREATE TABLE inventory_locations (
  locationid    NUMBER(10) NOT NULL,
  aisle         NUMBER(10),
  tier          NUMBER(10),
  bin           NUMBER(10) );

ALTER TABLE inventory_locations
ADD CONSTRAINT il_pk PRIMARY KEY (locationid);

CREATE TABLE products (
   productid    VARCHAR(10) NOT NULL,
   description  VARCHAR(35) );

ALTER TABLE products ADD CONSTRAINT prod_pk
PRIMARY KEY (productid);

CREATE TABLE inventory (
    locationid  NUMBER(10) NOT NULL,
    productid   VARCHAR(10) NOT NULL,
    quantity    NUMBER(10) );

ALTER TABLE inventory ADD CONSTRAINT inventory_pk
PRIMARY KEY (locationid, productid);

INSERT INTO inventory_locations VALUES (101, 1, 1, 1);
INSERT INTO inventory_locations VALUES (102, 1, 1, 2);
INSERT INTO inventory_locations VALUES (103, 1, 1, 3);
INSERT INTO inventory_locations VALUES (104, 1, 2, 1);
INSERT INTO inventory_locations VALUES (105, 1, 2, 2);
INSERT INTO inventory_locations VALUES (106, 1, 2, 3);
INSERT INTO inventory_locations VALUES (107, 2, 1, 1);
INSERT INTO inventory_locations VALUES (108, 2, 1, 2);

INSERT INTO products VALUES ('P500', 'HP LaserJet 6L');
INSERT INTO products VALUES ('P510', 'HP DeskJet 855');
INSERT INTO products VALUES ('P520', 'IBM Aptiva');
INSERT INTO products VALUES ('P530', 'Compaq Presario');

INSERT INTO inventory VALUES (101, 'P500', 5);
INSERT INTO inventory VALUES (102, 'P510', 10);
INSERT INTO inventory VALUES (103, 'P500', 10);
INSERT INTO inventory VALUES (104, 'P520', 1);
INSERT INTO inventory VALUES (105, 'P530', 5);

SELECT i.locationid, aisle, tier, bin, i.productid, description, quantity
FROM   inventory i, inventory_locations il, products p
WHERE  i.locationid = il.locationid
  AND  i.productid = p.productid;

CREATE VIEW vw_inventory AS
SELECT i.locationid, aisle, tier, bin, i.productid, description, quantity
FROM   inventory i, inventory_locations il, products p
WHERE  i.locationid = il.locationid  AND  i.productid = p.productid;

SELECT * FROM vw_inventory;

SET SERVEROUTPUT ON
SET ARRAYSIZE 2

6.3 Stored Procedure Example – Continued

Stored Procedures to Add and Remove items From inventory

1. Check to see if some quantity of that product is already in the location. If so, then UPDATE the quantity already there.
2. If that product is not currently in the location, then INSERT a new inventory record with the locationid, productid and new quantity.

CREATE OR REPLACE PROCEDURE add_to_inventory (
    new_locationid IN NUMBER,
    new_productid  IN VARCHAR,
    new_quantity   IN NUMBER) AS
  -- Declare a new variable called 'current_quantity' that is of the same
  -- type as the column quantity in the inventory table
  current_quantity inventory.quantity%TYPE;

BEGIN
  -- Initialize current_quantity to 0
  current_quantity := 0;

  -- See if some quantity exists at the current location
  -- If not, then raise EXCEPTION and insert a new record
  -- If so, then continue on to the UPDATE statement
  SELECT inventory.quantity
  INTO   current_quantity
  FROM   inventory
  WHERE  inventory.locationid = new_locationid
   AND   inventory.productid  = new_productid;

  -- If we get this far, then there must already exist
  -- an inventory record with this locationid and productid
  -- So update the inventory by adding the new quantity.
  IF (current_quantity > 0) THEN
    UPDATE inventory
    SET    quantity = quantity + new_quantity
    WHERE  inventory.locationid = new_locationid
      AND  inventory.productid  = new_productid;
  END IF;

  -- If the first SELECT statement above fails to return any
  -- records at all, then the NO_DATA_FOUND exception will be
  -- signalled. The following code reacts to this exception.
  EXCEPTION
     WHEN NO_DATA_FOUND THEN
     BEGIN
       -- Since an inventory record matching the locationid and
       -- productid can not be found, we must INSERT a new
       -- inventory record.
       INSERT INTO inventory
       (locationid, productid, quantity)
       VALUES (new_locationid, new_productid, new_quantity);
     END;
END;

1. Check to see if the requested quantity of that product is available in the location. If so, then UPDATE the quantity.
2. If the resulting quantity falls to 0, then DELETE the inventory record.

CREATE OR REPLACE PROCEDURE remove_from_inventory (
    current_locationid IN NUMBER,
    current_productid  IN VARCHAR,
    quantity_to_remove IN NUMBER) AS
  -- Declare a new variable called 'current_quantity' that is of the same
  -- type as the column quantity in the inventory table
  current_quantity inventory.quantity%TYPE;
  -- Declare an error message string.
  error_msg VARCHAR(180);
BEGIN
  current_quantity := 0;

  -- See if some quantity exists at the current location
  -- If not, then raise EXCEPTION and exit the procedure.
  -- If so, then continue on to the UPDATE statement
  SELECT quantity
  INTO   current_quantity
  FROM   inventory
  WHERE  inventory.locationid = current_locationid
   AND   inventory.productid  = current_productid;

  -- If we get this far, then there must already exist
  -- an inventory record with this locationid and productid
  -- So update the inventory by removing the quantity.
  IF (current_quantity - quantity_to_remove > 0) THEN
    UPDATE inventory
    SET    quantity = quantity - quantity_to_remove
    WHERE  inventory.locationid = current_locationid
      AND  inventory.productid  = current_productid;
  END IF;
  -- If the quantity to remove is the same as the current
  -- quantity in the location, then simply delete the
  -- entire record.
  IF (current_quantity - quantity_to_remove = 0) THEN
    DELETE FROM inventory
    WHERE  inventory.locationid = current_locationid
      AND  inventory.productid  = current_productid;
  END IF;
  IF (current_quantity - quantity_to_remove < 0) THEN
    error_msg := 'ERROR: Insufficient quantity in that location';
    RAISE_APPLICATION_ERROR (-20602, error_msg);
  END IF;

  -- If the first SELECT statement above fails to return any
  -- records at all, then the NO_DATA_FOUND exception will be
  -- signalled. The following code reacts to this exception.
  EXCEPTION
     WHEN NO_DATA_FOUND THEN
     BEGIN
       error_msg := 'ERROR: Product ' || current_productid ||
                            ' not found at this location';
       RAISE_APPLICATION_ERROR (-20603, error_msg);
     END;
END;

      EXECUTE add_to_inventory(106, 'P500', 10)

      EXECUTE remove_from_inventory(106, 'P500', 10)

8. Acknowledgements