Oracle SQL Essencial

Oracle 11G - SQL Essencial

Edgar R. Sandi
@edgarsandi
[email protected]
lk/edgar.r.sandi
fb/edgar.r.sandi


Oracle Essencial
24h
6 aulas
Aula 1 - 08/11
Aula 2 - 22/11
Aula 3 - 29/11
Aula 4 - 06/12
Aula 5 - 13/12
Aula 6 - 20/12

Alunos:
 - Leonardo
 - Anderson
 - Thiago
 - Mario
 - Amanda
 
--Starting
  - O que é o Oracle?
  - SGBD - Sistema de Gerenciamento de Banco de Dados
  - DBMS - Database Management System
  - RDBMS - Relational Database Management System
  
-- SQL ANSI'92  

  SGBD - O 'usuário' interage
    - Banco de dados / base de dados / database (categoria de informações)
      - Esquemas - Agrupamentos de tabelas (tablespaces, schema)
        - Tabelas - Especificação da informação
          - Colunas - Tamanho, tipo e nome da informação
            - Dados          

- Tipos de dados no Oracle
  - Numéricos
    - Inteiros -> integer -> int -> 38 dígitos
      - number -> ex.: idade number(3) -> 0 - 999
    - Decimais -> float -> 38 dígitos
      - number -> ex.: preco number(5,2) -> 999.99
  - Texto
    - char -> characters -> 2.000 bytes
      - UF char(2)     -> S P  -> 2 posições
      - nome char(10)  -> E D G A R _ _ _ _ _   -> 10 posições
    - varchar -> varchar2 -> varying characters -> 2.000 bytes
      - UF varchar(2)  -> S P ;                 -> 3 posições
      - nome varchar(10)  -> E D G A R ;        -> 6 posições
    - text -> long -> 2 Gb
  - Datas
    - date      -> dd-MON-yy -> NLS_DATE_FORMAT
    - interval  -> TIMESTAMP -> segundos desde 01/01/1969 - TIME UNIX
    - time      -> HH:MM:SS
  - Booleanos -> boolean -> bool -> 1 bit
    - 1 ou 0 -> TRUE ou FALSE

SELECT CURRENT_DATE FROM dual;  
SELECT SYSDATE FROM dual;  

ALTER SESSION SET NLS_DATE_FORMAT = 'YYYY-MM-DD';  
ALTER SESSION SET NLS_DATE_FORMAT = 'DD/MM/YY';  
ALTER SESSION SET NLS_DATE_FORMAT = 'dd/MON/YY';  
ALTER SESSION SET NLS_DATE_FORMAT = 'dd/MONTH/YY';    

-- no mysql  
1 byte => 8 bits => 256  
char    -> 255
varchar -> 255
-- / no mysql  
  
4 bytes = 11111111111111111111111111111111 => 4 294 967 295
  
  
MON => JAN FEB MAR MAY JUN JUL AGO SEP OCT NOV DEC

- SQL ANSI 92 -> Structured Query Language
  - DML -> Data Manipulation Language
    - INSERT -> inserir registros
    - UPDATE -> atualizar registros
    - DELETE -> deletar registros
  - DQL -> Data Query Language
    - SELECT -> Seleciona registros (REGISTROS)
    - SHOW   -> Mostra informação de definição (ESTRUTURA)
    - DESCRIBE / DESC -> Descreve tabelas (ESTRUTURA)
  - DDL -> Data Definition Language
    - CREATE   -> cria estrutura
    - ALTER    -> altera estrutura
    - DROP     -> remove estrutura
    - TRUNCATE -> trunca estrutura
  - DCL -> Data Control Language
    - GRANT  -> Garante uma permissão
    - REVOKE -> Revoga uma permissão

DESC tb_alunos;
-> HANDS ON!

-- SELECT
   -- ESCOPO básico do SELECT

SELECT <*, colunas, calculos>
  FROM <tabela, dual>;
SELECT 2+2 FROM dual;
SELECT UPPER('abvdde') FROM dual;
SELECT 2+2*2 FROM dual;
SELECT (2 +(3+5*(4-3))) FROM dual;

-- ESCOPO DO CREATE
CREATE <O QUE?> <NOME> [(
  [OPCOES]
)];

<O QUE?> -> TABLE, DATABASE, SCHEMA, TABLESPACE, TYPE, FUNCTION, VIEW, SEQUENCE

-- CRIANDO TABELAS
-- ESCOPO
CREATE TABLE <NOME>(
  <COLUNAS> => <NOME *> <TIPO *> <TAMANHO> <OPCOES>,
);

DROP TABLE <nome>;
<OPCOES ?>
  - DEFAULT -> define um valor padrão para a coluna
  - NULL / NOT NULL -> define se é ou não obrigatório
  - UNIQUE -> define que o dado é único
  - PRIMARY KEY -> define a coluna principal da tabela
  - INDEX -> define que a coluna é um índice
  - REFERENCES -> define a coluna que cria a chave estrangeira para outra
      tabela
CREATE TABLE teste (
  coluna1 integer PRIMARY KEY,
  coluna2 char(2) DEFAULT 'SP'
);
-- LAB 01
  -- Crie uma tabela chamada teste2
  -- Com n colunas que utilizem as opções:
     -- DEFAULT, NULL, NOT NULL, PRIMARY KEY

na linha de comando
conn sys as sysdba;
senha: season
ALTER USER ALUNO IDENTIFIED BY "season" ACCOUNT UNLOCK;

-- Para visualizar a estrutura da tabela
DESC teste;
DESC teste2;

-- Criar um banco de dados
CREATE DATABASE <db_name>;

-- MER - Modelo Entidade Relacional

-- Tipos de relacionamento
-- OTO - OneToOne
-- OTM - OneToMany
-- MTO - ManyToOne
-- MTM - ManyToMany

-- Relacionamento Identificado => PFK (Primary Foreign Key)
-- Relacionamento Não Identificado => FK (Foreign Key)

-- Lab02:
-- Criar todas as tabelas da modelagem

-- Criando a tabela já com a chave estrangeira
CREATE TABLE tb_turmas(
  cd_turma NUMBER(6) PRIMARY KEY,
  outras colunas .....
  cd_instrutor NUMBER(3) REFERENCES tb_instrutores(cd_instrutor) 
);
-- Criando a tabela sem a chave estrangeira
CREATE TABLE tb_turmas(
  cd_turma NUMBER(6) PRIMARY KEY,
  outras colunas .....
  cd_instrutor NUMBER(3) 
);
-- Criar a chave estrangeira entre duas tabelas
-- tb_turmas x tb_instrutores
ALTER TABLE tb_turmas 
  ADD CONSTRAINT fk_tb_turmas__tb_instrutores
  FOREIGN KEY (cd_instrutor)
  REFERENCES tb_instrutores(cd_instrutor);

-- Limpando a casa
DROP TABLE tb_alunos;
DROP TABLE tb_atores;
DROP TABLE tb_clientes;
DROP TABLE tb_filmes;
DROP TABLE tb_genero;
DROP TABLE tb_locacoes;
DROP TABLE tb_medias;
DROP TABLE tb_partic;
DROP TABLE tb_premios;
DROP TABLE tb_produtoras;
DROP TABLE tb_tipo_media;

-- SET FOREIGN_KEY_CHECKS=0; -- mysql apenas
SELECT * FROM USER_CONSTRAINTS WHERE TABLE_NAME = "tabnam";

-- Criando uma chave primária composta
CREATE TABLE xxxxx (
   coluna1 number(3),
   coluna2 number(4),
   ...
   PRIMARY KEY(coluna1, coluna2)
);

-- Resposta do lab
-- tabela categorias
CREATE TABLE tb_categorias(
  cd_categoria NUMBER(3) PRIMARY KEY,
  nm_categoria VARCHAR2(50) NOT NULL
);

-- Tabela cursos
CREATE TABLE tb_cursos(
  cd_curso NUMBER(5) PRIMARY KEY,
  nm_curso VARCHAR2(50) NOT NULL,
  vl_ch NUMBER(4),
  cd_categoria NUMBER(3) REFERENCES tb_categorias(cd_categoria)
);

-- Tabela salas
CREATE TABLE tb_salas(
  cd_sala CHAR(3) PRIMARY KEY,
  nm_sala VARCHAR2(50) NOT NULL,
  vl_capacidade NUMBER(3) NOT NULL
);

-- Tabela instrutores
CREATE TABLE tb_instrutores(
  cd_instrutor NUMBER(3) PRIMARY KEY,
  nm_instrutor VARCHAR2(50) NOT NULL
);

-- Tabela turmas
CREATE TABLE tb_turmas(
  cd_turma NUMBER(6),
  dt_inicio DATE NOT NULL,
  dt_fim DATE NOT NULL,
  tx_periodo CHAR(1) NOT NULL,
  cd_instrutor NUMBER(3) REFERENCES tb_instrutores(cd_instrutor),
  cd_curso NUMBER(3) REFERENCES tb_cursos(cd_curso),
  cd_sala CHAR(3) REFERENCES tb_salas(cd_sala)
);
-- Adicionando PRIMARY KEY em uma tabela existente
ALTER TABLE tb_turmas 
  ADD CONSTRAINT pk_tb_turmas
  PRIMARY KEY (cd_turma);

-- Tabela alunos
CREATE TABLE tb_alunos(
  cd_aluno NUMBER(5) PRIMARY KEY,
  nm_aluno VARCHAR2(50) NOT NULL,
  tx_sexo CHAR(1) NOT NULL,
  dt_nascimento DATE
);

-- Tabela inscrições
CREATE TABLE tb_inscricoes(
  cd_aluno NUMBER(5) REFERENCES tb_alunos(cd_aluno),
  cd_turma NUMBER(5) REFERENCES tb_turmas(cd_turma),
  dt_inscricao DATE NOT NULL,
  vl_inscricao NUMBER(10, 2) NOT NULL,
  PRIMARY KEY(cd_aluno, cd_turma)
);

-- Formatos de relacionamento
-- ON UPDATE e ON DELETE
   -- NO ACTION ->  Não faz nada e deixa executar o comando
   -- SET NULL  ->  Seta null nas colunas dependentes
   -- RESTRICT  ->  Não deixa executar o comando (se há dependências)
   -- CASCADE   ->  Executar o comando em cascata

CREATE TABLE tb_cursos(
  cd_curso NUMBER(5) PRIMARY KEY,
  nm_curso VARCHAR2(50) NOT NULL,
  vl_ch NUMBER(4),
  cd_categoria NUMBER(3) 
    REFERENCES tb_categorias(cd_categoria)
      ON UPDATE CASCADE
      ON DELETE RESTRICT
);
ALTER TABLE tb_turmas 
  ADD CONSTRAINT fk_tb_turmas__tb_instrutores
  FOREIGN KEY (cd_instrutor)
  REFERENCES tb_instrutores(cd_instrutor)
    ON UPDATE CASCADE
    ON DELETE RESTRICT;

-- DML -> Data Manipulation Language
-- Inserindo registros
-- Escopo padrão
  -- A quantidade de <colunas> e <values> tem que coincidir
  -- Tipos de dados tem que coincidir
INSERT INTO <tabela> (<colunas>,) VALUES (<valores>,);
INSERT INTO tb_alunos (cd_aluno, nm_aluno) VALUES('Edgar', 10); -- erro
INSERT INTO tb_alunos (cd_aluno, nm_aluno) VALUES(10, 'Edgar'); -- OK!
INSERT INTO tb_alunos (nm_aluno, cd_aluno) VALUES('Edgar', 10); -- OK!
INSERT INTO tb_alunos (nm_aluno) VALUES('Edgar'); -- OK!

INSERT INTO tb_alunos (cd_aluno, nm_aluno,tx_sexo) VALUES(10, 'Edgar','M'); -- Erro de duplicidade!

-- ex. 
INSERT INTO TESTE (COLUNA1, COLUNA2) VALUES (10,10);
SELECT * FROM TESTE;

-- Escopo omitindo colunas
  -- SE e APENAS SE, você adicionar em todas as colunas da tabela
  -- A ordem tem que ser idêntica à da tabela
INSERT INTO <tabela> VALUES (<valores>);
-- ex. 
INSERT INTO TESTE VALUES (20,20);
SELECT * FROM TESTE;

-- Escopo Multiplos INSERTS
-- No MySQL
-- INSERT INTO TESTE VALUES (20,20), (30,30), (40,40);
--INSERT INTO TESTE (COLUNA1, COLUNA2) VALUES (10,10), (20,20), (30,30), (40,40));

-- No Oracle
INSERT ALL
  INSERT INTO <tabela> (<colunas>,) VALUES (<valores>,)
  INSERT INTO <tabela> (<colunas>,) VALUES (<valores>,)
  INSERT INTO <tabela> (<colunas>,) VALUES (<valores>,)
  INSERT INTO <tabela> (<colunas>,) VALUES (<valores>,)
SELECT * FROM dual;

INSERT ALL ....
  LOOP
      INSERT  (variaveis)
  END LOOP
SELECT * FROM dual;

-- Atualizar registros
-- ESCOPO
UPDATE <tabela>
   SET <coluna> = <valor>,<coluna> = <valor>,
   WHERE <alguma coisa> = <algum valor>
    AND,;
    
UPDATE teste
  SET coluna1 =10, coluna2 = 'abcde'
  WHERE coluna1 = 1
    AND coluna2 = 'defgh';
   
-- Removendo os registros
DELETE FROM <tabela>
  WHERE <coluna> = <algum valor>;
  
DELETE FROM teste
  WHERE coluna1 = 5;
  
-- Inserir os registros nas tabelas  
http://bit.ly/1yuoxif   -- https://gist.github.com/edgarsandi/8444f3d81200a6818cbf
  
INSERT ALL
  INTO tb_categorias (cd_categoria, nm_categoria) VALUES (1,'Banco de dados')
  INTO tb_categorias (cd_categoria, nm_categoria) VALUES (2,'Programação')
  INTO tb_categorias (cd_categoria, nm_categoria) VALUES(3,'Design')
SELECT * FROM dual;
 
INSERT INTO tb_cursos VALUES(1,'Oracle Essencial',24,1);
INSERT INTO tb_cursos VALUES(2,'PHP',40,2);
INSERT INTO tb_cursos VALUES(3,'Oracle PL/SQL',24,3);
 
INSERT INTO tb_instrutores VALUES (1,'Ronaldo');
INSERT INTO tb_instrutores VALUES (2,'João');
INSERT INTO tb_instrutores VALUES (3,'Pedro');
 
INSERT INTO tb_salas VALUES ('S01','Sala 01',8);
INSERT INTO tb_salas VALUES ('S02','Sala 02',12);
 
ALTER SESSION SET NLS_DATE_FORMAT='DD/MM/YYYY';
 
SELECT CURRENT_DATE FROM dual;
 
INSERT INTO tb_alunos VALUES (1,'Marisa','F','27/03/1979');
INSERT INTO tb_alunos VALUES (2,'Rosana','F','27/03/1979');
INSERT INTO tb_alunos VALUES (3,'Carlos','M','15/06/1960');
INSERT INTO tb_alunos VALUES (4,'Fabio','M','20/09/1985');
INSERT INTO tb_alunos VALUES (5,'Fabiana','F','11/10/1986');
INSERT INTO tb_alunos VALUES (6,'Ana','F','11/12/1975');
INSERT INTO tb_alunos VALUES (7,'Clara','F','11/12/2000');
INSERT INTO tb_alunos VALUES (8,'Henrique','M','10/07/1996');
INSERT INTO tb_alunos VALUES (9,'Claudia','F','1/07/1993');
INSERT INTO tb_alunos VALUES (10,'Marta','F','8/04/1997');
 
 
INSERT INTO tb_turmas VALUES (1,'01/07/2008','10/10/2008','M',1,1,'S01');
INSERT INTO tb_turmas VALUES (2,'01/05/2008','10/6/2008','T',2,1,'S02');
INSERT INTO tb_turmas VALUES (3,'01/06/2008','10/8/2008','N',1,2,'S01');
INSERT INTO tb_turmas VALUES (4,'05/10/2008','09/11/2008','N',2,3,'S01');
INSERT INTO tb_turmas VALUES (5,'05/10/2008','09/11/2008','M',1,3,'S02');
 
INSERT INTO tb_inscricoes VALUES (1,1,'10/05/2008',500);
INSERT INTO tb_inscricoes VALUES (2,3,'10/06/2008',800);
INSERT INTO tb_inscricoes VALUES (3,4,'10/07/2008',900);
INSERT INTO tb_inscricoes VALUES (4,2,'10/05/2008',500);
INSERT INTO tb_inscricoes VALUES (4,3,'10/06/2008',600);
INSERT INTO tb_inscricoes VALUES (5,5,'10/04/2008',700);
INSERT INTO tb_inscricoes VALUES (6,1,'10/03/2008',1000.50);

-- Renomear uma coluna
ALTER TABLE <tabela> CHANGE COLUMN <nome> TO <nome> <tipo>; (mysql)
ALTER TABLE <tabela> RENAME COLUMN <nome> TO <novo nome>; (oracle)

-- Renomear uma tabela
RENAME <nome> TO <novo nome>;
RENAME TB_INCRICOES TO TB_INSCRICOES;

-- DQL - Data Query Language
-- Selecionando registros do Banco de dados
-- ESCOPO SELECT
SELECT <*|<colunas>>
  FROM <tabela>
  [WHERE] <filtros
  [GROUP BY] <colunas>
  [ORDER BY] <colunas>
  [HAVING] <filtros>

-- * == todas as colunas
*.doc
nome.*
*.*
SELECT * FROM tb_categorias;
SELECT * FROM tb_cursos;
SELECT * FROM tb_turmas;
SELECT * FROM tb_instrutores;
SELECT * FROM tb_salas;
SELECT * FROM tb_inscricoes;
SELECT * FROM tb_alunos;

-- Os alunos do sexo masculino
-- selecione todos os alunos onde o sexo seja igual a masculino
SELECT * FROM tb_alunos WHERE tx_sexo = 'M';

-- Os alunos do sexo feminino
-- selecione todos os alunos onde o sexo seja igual a feminino
SELECT * FROM tb_alunos WHERE tx_sexo = 'F';

SELECT * 
  FROM tb_alunos 
  WHERE tx_sexo = 'M'
    AND nm_aluno = 'Fabio';

' ---- "
'  => apostrofe
"  => aspas

-- Funções de agrupamento
  -- COUNT -> conta o numero de registros de uma consulta
  -- SUM   -> soma os valores de coluna na consulta
  -- MIN   -> retorna o menor valor entre os registros de uma coluna
  -- MAX   -> retorna o maior valor entre os registros de uma coluna
  -- AVG   -> retorna a média entre os registros de uma coluna

SELECT COUNT(*)
  FROM tb_alunos;

-- a soma das inscricoes
SELECT SUM(vl_inscricao)
  FROM tb_inscricoes;

-- a media das inscricoes
SELECT AVG(vl_inscricao)
  FROM tb_inscricoes;

SELECT * FROM tb_inscricoes;

SELECT 5000.5 / 7 FROM DUAL;

-- corrigindo a media v1.0
SELECT AVG(vl_inscricao), cd_aluno
  FROM tb_inscricoes
  GROUP BY cd_aluno;

SELECT * FROM tb_inscricoes;

-- Quantas alunas cadastradas
-- selecione a quantidade de alunos que são do sexo feminino
SELECT COUNT(*) 
  FROM tb_alunos
  WHERE tx_sexo = 'F';

-- Lab 04:
-- 1. Quantos alunos cadastrados por sexo no total?  
     -- a quantidade de alunos agrupados por sexo
-- 2. Valor total das inscricoes
     -- a soma de todas as inscricoes
-- 3. Quantidade de cursos por categoria
     -- a quantidade de cursos agrupado pela categoria 

-- Respostas do Lab 04:
--1 -> a quantidade de alunos agrupados por sexo
SELECT COUNT(*) AS qtd_alunos, tx_sexo
  FROM tb_alunos
  GROUP BY tx_sexo;

--2 -> a soma de todas as inscricoes
SELECT SUM(vl_inscricao) AS "total de inscrições"
  FROM tb_inscricoes;
  
--3 -> a quantidade de cursos agrupado pela categoria 
SELECT COUNT(*) AS qtd_cursos, cd_categoria
  FROM tb_cursos
  GROUP BY cd_categoria;

SELECT cd_aluno AS "Código do aluno", nm_aluno AS "Nome do aluno"
  FROM tb_alunos;

-- Ordenando os registros da consulta
ORDER BY [ASC] | DESC - Ordene por

ASC -> ascendente  A-Z ou 0-9
DESC -> descendente Z-A ou 9-0

-- ordenar por nome do aluno de forma ascendente
SELECT *  
  FROM tb_alunos
  ORDER BY nm_aluno;
  
-- ordenar por nome do aluno de forma descendente
SELECT *  
  FROM tb_alunos
  ORDER BY nm_aluno DESC;

-- ORDER BY -- multi colunas
SELECT *  
  FROM tb_alunos
  ORDER BY nm_aluno DESC, tx_sexo DESC;
  
INSERT INTO tb_alunos VALUES (11,'Marisa', 'M', '28/10/1978');

-- Concatenando registros  => || -> pipe
SELECT 'Código do aluno: ' || cd_aluno AS "Código", 
    'Nome do aluno: ' || nm_aluno AS "Nome"
  FROM tb_alunos;

-- CSV -> Commas Separated Values -- Valores separados por vírgula
SELECT cd_aluno || ',' || nm_aluno || ',' || tx_sexo
  FROM tb_alunos;

SELECT cd_aluno || ' ' || nm_aluno || ' ' || tx_sexo
  FROM tb_alunos;

# -> sustenido, jogo da velha, cerquilha, hashtag, tralha, sharp
.Net => C# VB.net Visual C
Java => J2SE, J2EE, J2ME, JFX

SELECT COUNT(*) AS qtd_cursos, cd_categoria
  FROM tb_cursos
  GROUP BY nm_categoria;
  
-- Junções interna de consultas  
-- INNER JOIN
  -- CROSS JOIN
SELECT *
  FROM tb_cursos, tb_categorias -- 9
  WHERE tb_cursos.cd_categoria = tb_categorias.cd_categoria -- 3
    AND tb_categorias.cd_categoria = 2; -- 1

  -- JOIN (juntar)
  -- sem usar apelidos
SELECT *
  FROM tb_cursos
  JOIN tb_categorias ON (tb_cursos.cd_categoria = tb_categorias.cd_categoria);
  -- usando apelidos
SELECT *
  FROM tb_cursos CUR
  JOIN tb_categorias CAT ON (CUR.cd_categoria = CAT.cd_categoria);
  -- non-sense
SELECT *
  FROM tb_cursos CUR
  JOIN tb_alunos ALU ON (CUR.cd_categoria = ALU.cd_aluno);
  -- filtrando resultados com join
SELECT *
  FROM tb_cursos CUR
  JOIN tb_categorias CAT ON (CUR.cd_categoria = CAT.cd_categoria) --3
  WHERE  CAT.cd_categoria = 2; --1

-- Lab 05 - Selecionar:
  -- 1. Nome do curso, carga horária e nome da categoria 
  -- 2. Nome do curso, carga horária, data de início, data de fim e período
  -- 3. Nome da categoria, nome do curso, data de início e nome do instrutor
  -- 4. Nome do aluno, sexo, data de início, nome do instrutor e nome da categoria

-- Respostas do Lab 05
-- 1. Nome do curso, carga horária e nome da categoria 
SELECT nm_curso, vl_ch, nm_categoria
  FROM tb_cursos CUR
  JOIN tb_categorias CAT ON (CUR.cd_categoria = CAT.cd_categoria);
  -- 2. Nome do curso, carga horária, data de início, data de fim e período
SELECT nm_curso, vl_ch, dt_inicio, dt_fim, tx_periodo
  FROM tb_cursos CUR
  JOIN tb_turmas TUR ON (CUR.cd_curso = TUR.cd_curso);
  -- 3. Nome da categoria, nome do curso, data de início e nome do instrutor
SELECT nm_categoria, nm_curso, dt_inicio, nm_instrutor
  FROM tb_categorias CAT
  JOIN tb_cursos CUR ON (CAT.cd_categoria = CUR.cd_categoria)
  JOIN tb_turmas TUR ON (CUR.cd_curso = TUR.cd_curso)
  JOIN tb_instrutores INST ON (TUR.cd_instrutor = INST.cd_instrutor);
  -- 4. Nome do aluno, sexo, data de início, nome do instrutor e nome da categoria
SELECT nm_aluno, tx_sexo, dt_inicio, nm_instrutor, nm_categoria
  FROM tb_alunos ALU
  JOIN tb_inscricoes INSC ON (ALU.cd_aluno = INSC.cd_aluno)
  JOIN tb_turmas TUR ON (INSC.cd_turma = TUR.cd_turma)
  JOIN tb_instrutores INST ON (TUR.cd_instrutor = INST.cd_instrutor)
  JOIN tb_cursos CUR ON (TUR.cd_curso = CUR.cd_curso)
  JOIN tb_categorias CAT ON (CUR.cd_categoria = CAT.cd_categoria);
  
  -- JOIN USING
-- ESCOPO
SELECT <*, colunas>
  FROM <tabela> A
  JOIN <tabela> B USING <coluna>;
  
SELECT *
  FROM tb_categorias
  JOIN tb_cursos USING (cd_categoria);

-- NATURAL JOIN 
   --> Foreign keys -  se tiver relacionamento
   --> Eles procuram colunas com nomes iguais para o JOIN

SELECT *
  FROM tb_categorias
  NATURAL JOIN tb_cursos;

-- OUTER JOIN
   -- LEFT JOIN
      -- Todos os registros da esquerda mesmo que não
         -- tenham relacionamento
   -- RIGHT JOIN
      -- Todos os registros da direita mesmo que não
         -- tenham relacionamento
   -- FULL JOIN
      -- Todos os registros mesmo que não
         -- tenham relacionamento

-- Inserindo categorias que não terão cursos
INSERT INTO tb_categorias (cd_categoria, nm_categoria)
  VALUES ('4', 'Eletrônica');
INSERT INTO tb_categorias (cd_categoria, nm_categoria)
  VALUES ('5', 'Mecânica');
  
-- Todas as categorias mesmo as que não tem cursos cadastrados
SELECT * 
  FROM tb_categorias 
  LEFT JOIN tb_cursos USING (cd_categoria);

-- Inserindo cursos sem categorias
INSERT INTO tb_cursos (cd_curso, nm_curso, vl_ch, cd_categoria)
  VALUES('4','Corte e costura', '50', null);

INSERT INTO tb_cursos (cd_curso, nm_curso, vl_ch, cd_categoria)
  VALUES('5','Artes plásticas', '64', null);
  
-- Todas os cursos mesmo os que não tem categoria
SELECT * 
  FROM tb_categorias 
  RIGHT JOIN tb_cursos USING (cd_categoria);
  
SELECT * FROM tb_cursos;  

-- Todas as categorias e cursos mesmo que não tenham relaciomentos
SELECT * 
  FROM tb_categorias 
  FULL JOIN tb_cursos USING (cd_categoria);  

-- Funções de conjuntos
UNION
INTERSECT
MINUS  -- mysql, postgresql : EXCEPT

-- Regras
   -- 1a: O número de colunas deve ser igual nas duas consultas
   -- 2a: O tipo de dados das colunas devem ser iguais
-- erro: número de colunas não equivalem CAT: 2 e CUR: 4   
SELECT * FROM tb_categorias
  UNION
SELECT * FROM tb_cursos;

-- erro: o tipo das colunas não equivalem       
SELECT cd_categoria, nm_categoria FROM tb_categorias
  UNION
SELECT nm_curso, vl_ch FROM tb_cursos;   
   
SELECT cd_categoria, nm_categoria FROM tb_categorias
  UNION
SELECT cd_curso, nm_curso FROM tb_cursos;   
   
SELECT *
  FROM tb_alunos
  WHERE tx_sexo = 'M'
UNION
SELECT *
  FROM tb_alunos
  WHERE tx_sexo = 'F';

-- INTERSECT
-- Os alunos que fizeram inscrição
SELECT cd_aluno FROM tb_alunos
  INTERSECT
SELECT cd_aluno FROM tb_inscricoes;

SELECT DISTINCT cd_aluno
  FROM tb_alunos
  NATURAL JOIN tb_inscricoes;

-- MINUS
-- Os alunos que não fizeram inscrição
SELECT cd_aluno FROM tb_alunos
  MINUS
SELECT cd_aluno FROM tb_inscricoes;

SELECT cd_aluno 
  FROM tb_alunos
  LEFT JOIN tb_inscricoes USING (cd_aluno)
  WHERE cd_turma IS NULL
  ORDER BY cd_aluno;

EC2 -> servidores
EIP -> IP estático

-- Lab. 06
   -- 1. Quais as alunas que não fizeram inscrição
   -- 2. Quais as turmas que não tem alunos do sexo M

-- Respostas:
   -- 1. Quais as alunas que não fizeram inscrição
SELECT cd_aluno FROM tb_alunos WHERE tx_sexo = 'F'
  MINUS
SELECT cd_aluno FROM tb_inscricoes;

   -- 2. Quais as turmas que não tem alunos do sexo M
SELECT cd_turma FROM tb_turmas
MINUS
SELECT cd_turma 
  FROM tb_inscricoes
  NATURAL JOIN tb_alunos
  WHERE tx_sexo = 'M';
  
-- As inscrições que não são do sexo masculino
SELECT cd_aluno FROM tb_inscricoes
  MINUS
SELECT cd_aluno FROM tb_alunos WHERE tx_sexo = 'M';

-- Operadores de comparação
  -- =, <, <=, >, >=, !=, <>

SELECT *
  FROM tb_alunos
  WHERE cd_aluno >= 3;

-- !=, <>
   -- != ---- não igual
   -- <>  ----- diferente

5 <> 7   =  5 != 7
'a' <> 'b'  =  'a' != 'b'
'a' <> 'A'  =  'a' != 'A'
'a' > 'A' - - - TRUE
ASCII

SELECT ASCII('a'), ASCII('A') FROM dual;
SELECT CHR(97), CHR(65) FROM dual;

1 ou 0
a ou A

-- DISTINCT  -> valores distintos
SELECT DISTINCT cd_aluno, cd_turma FROM tb_inscricoes;

SELECT * FROM tb_alunos;

-- WHERE IN / WHERE NOT IN
-- sem o WHERE IN
-- todos os alunos Fabio, Marisa, Carlos

SELECT * 
  FROM tb_alunos
  WHERE nm_aluno = 'Fabio' 
      OR nm_aluno = 'Marisa' 
      OR nm_aluno = 'Carlos';

-- usando o IN
SELECT * 
  FROM tb_alunos
  WHERE nm_aluno IN ('Fabio', 'Marisa', 'Carlos');

-- usando o NOT IN
SELECT * 
  FROM tb_alunos
  WHERE nm_aluno NOT IN ('Fabio', 'Marisa', 'Carlos');

-- alunos com o cd_aluno entre 3 e 9
-- BETWEEN -- entre uma faixa de valores
SELECT *
  FROM tb_alunos
  WHERE cd_aluno BETWEEN 3 AND 9;

SELECT *
  FROM tb_alunos
  WHERE dt_nascimento BETWEEN '01/01/1970' AND '31/12/1989';

SELECT *
  FROM tb_alunos
  WHERE nm_aluno BETWEEN 'A' AND 'D';

-- Lab 07.  -- IN / NOT IN / BETWEEN
-- 1. Todos os alunos que fizeram os cursos PHP ou Oracle PL/SQL
-- 2. Todos os alunos que não fizeram os cursos PHP ou Oracle PL/SQL
-- 3. Quais as mulheres que não fizeram inscrição
-- 4. Quais as turmas que não tem alunos do sexo M

-- Respostas
-- 1. Todos os alunos que fizeram os cursos PHP ou Oracle PL/SQL
SELECT *
  FROM tb_alunos
  NATURAL JOIN tb_inscricoes
  NATURAL JOIN tb_turmas
  NATURAL JOIN tb_cursos
  WHERE nm_curso IN ('PHP', 'Oracle PL/SQL');

-- 2. Todos os alunos que não fizeram os cursos PHP ou Oracle PL/SQL
SELECT *
  FROM tb_alunos
  NATURAL JOIN tb_inscricoes
  NATURAL JOIN tb_turmas
  NATURAL JOIN tb_cursos
  WHERE nm_curso NOT IN ('PHP', 'Oracle PL/SQL');

-- 3. Quais as mulheres que não fizeram inscrição
-- 1a forma
SELECT cd_aluno, nm_aluno, tx_sexo, dt_nascimento
  FROM tb_alunos
  NATURAL LEFT JOIN tb_inscricoes
  WHERE tx_sexo = 'F' AND cd_turma IS NULL;

-- 2a forma
SELECT * 
  FROM (
    SELECT *
      FROM tb_alunos
      WHERE cd_aluno IN (
            SELECT cd_aluno
              FROM tb_alunos
              WHERE tx_sexo = 'F' 
            MINUS
            SELECT cd_aluno
              FROM tb_inscricoes
              )
        ) tabela
    WHERE tabela.dt_nascimento BETWEEN '01/01/1990' AND '31/12/1999';

-- 4. Quais as turmas que não tem alunos do sexo M
SELECT *
  FROM tb_turmas
  NATURAL JOIN tb_inscricoes
  NATURAL JOIN tb_alunos
  WHERE cd_turma
  IN (
    SELECT cd_turma
      FROM tb_turmas
    MINUS
    SELECT cd_turma
      FROM tb_inscricoes
      NATURAL JOIN tb_alunos
      WHERE tx_sexo = 'M' 
    );
  
-- dissecando a consulta
-- 1a parte
SELECT cd_turma
      FROM tb_turmas
MINUS
SELECT cd_turma
  FROM tb_inscricoes
  NATURAL JOIN tb_alunos
  WHERE tx_sexo = 'M' ;

-- 2a parte
SELECT *
  FROM tb_turmas
  NATURAL JOIN tb_inscricoes
  NATURAL JOIN tb_alunos
  WHERE cd_turma = 1 OR cd_turma = 5;

-- EXISTS / NOT EXISTS
-- ESCOPO
SELECT <colunas>
  FROM <tabela>
  WHERE EXISTS / NOT EXISTS (<subquery>);

-- Todos os cursos vl_ch > 20 e que tenham turmas de manhã
-- 1a forma
SELECT *
  FROM tb_cursos
  NATURAL JOIN tb_turmas
  WHERE vl_ch > 20 AND tx_periodo = 'M';

-- 2a forma
SELECT * 
  FROM tb_cursos
  WHERE cd_curso IN (
        SELECT cd_curso
          FROM tb_cursos
          WHERE vl_ch > 20
        INTERSECT
        SELECT cd_curso
          FROM tb_turmas
          WHERE tx_periodo = 'M');

-- 3a forma: EXISTS
-- regra: É Interligar as consultas
SELECT *
    FROM tb_cursos
    WHERE vl_ch > 20
      AND EXISTS (
      SELECT *
          FROM tb_turmas
          WHERE tx_periodo = 'M'
            AND tb_cursos.cd_curso = tb_turmas.cd_curso);

-- Lab08. 
-- 1. Quais os alunos do sexo masculino que não tem inscrições?
-- 2. Quais são os instrutores que deram cursos no período M na sala01
-- 3. Quais os cursos que já tiveram inscricoes do sexo M e F

-- Respostas
-- 1. Quais os alunos do sexo masculino que não tem inscrições?
SELECT *
  FROM tb_alunos ALU
  WHERE tx_sexo = 'M'
    AND NOT EXISTS (  
          SELECT *
            FROM tb_inscricoes INSC
            WHERE ALU.cd_aluno = INSC.cd_aluno
    );
-- 2. Quais são os instrutores que deram cursos no período M na sala01
SELECT *
  FROM tb_instrutores INST
  WHERE EXISTS (
      SELECT *
        FROM tb_turmas TUR
        WHERE UPPER(tx_periodo) = UPPER('M') 
          AND LOWER(cd_sala) = LOWER('S01')
          AND INST.cd_instrutor = TUR.cd_instrutor);

-- 3. Quais os cursos que já tiveram inscricoes do sexo M e F
-- 1a forma falha:
SELECT *
  FROM tb_cursos
  NATURAL JOIN tb_turmas
  NATURAL JOIN tb_inscricoes
  NATURAL JOIN tb_alunos
  WHERE tx_sexo = 'M' 
    AND tx_sexo = 'F';

-- 2a forma correta:
SELECT *
  FROM tb_cursos CUR
  WHERE EXISTS (
          SELECT *
            FROM tb_turmas TUR
            NATURAL JOIN tb_inscricoes
            NATURAL JOIN tb_alunos
            WHERE tx_sexo = 'M'
              AND CUR.cd_curso = TUR.cd_curso
    ) AND EXISTS (
            SELECT *
              FROM tb_turmas TUR
              NATURAL JOIN tb_inscricoes
              NATURAL JOIN tb_alunos
              WHERE tx_sexo = 'F'
                 AND CUR.cd_curso = TUR.cd_curso
    );

-- 2a forma ++ (com os alunos):
SELECT * 
  FROM tb_alunos
  NATURAL JOIN tb_inscricoes
  NATURAL JOIN tb_turmas
  WHERE EXISTS (
          SELECT *
            FROM tb_cursos CUR
            WHERE EXISTS (
                    SELECT *
                      FROM tb_turmas TUR
                      NATURAL JOIN tb_inscricoes
                      NATURAL JOIN tb_alunos
                      WHERE tx_sexo = 'M'
                        AND CUR.cd_curso = TUR.cd_curso
              ) AND EXISTS (
                      SELECT *
                        FROM tb_turmas TUR
                        NATURAL JOIN tb_inscricoes
                        NATURAL JOIN tb_alunos
                        WHERE tx_sexo = 'F'
                           AND CUR.cd_curso = TUR.cd_curso
              )
      );

-- LIKE -> Pesquisa parcial
-- ESCOPO
SELECT <colunas>
  FROM <tabela>
  WHERE <coluna> LIKE <valor>;
  
SELECT *
  FROM tb_alunos
  WHERE UPPER(nm_aluno) LIKE UPPER('%a%');

SELECT *
  FROM tb_alunos
  WHERE nm_aluno LIKE ('_____ _____');
-- Variações: -- % (porcentagem - limitador)  _ (underline - coringa)
LIKE 'X'    => procurar exatamente a letra 'X' nesta coluna
LIKE 'X%'   => procurar a letra 'X' no início desta coluna
LIKE '%X'   => procurar a letra 'X' no final desta coluna
LIKE '%X%'  => procurar a letra 'X' em qualquer parte desta coluna
LIKE '_'    => procurar qualquer registro que tem 1 caracter apenas
LIKE '__X'  => procurar qualquer registro que tenha 3 caracteres e termine com 'X'
LIKE 'X__'  => procurar qualquer registro que tenha 3 caracteres e inicie com 'X'
LIKE '__X%' => procurar qualquer registro que tenha o 'X' na 3a posição

A B C D E
SELECT *
  FROM tb_alunos
  WHERE nm_aluno LIKE '%';
  
SELECT * 
  FROM tb_categorias
  NATURAL JOIN tb_cursos;
  
SELECT *
  FROM (
    SELECT * FROM tb_categorias CAT
  ) categorias,
  (
    SELECT * FROM tb_cursos CUR
  ) cursos
  WHERE categorias.cd_categoria = cursos.cd_categoria;
  
-- Subqueries no SELECT
   -- a subquery não pode retornar mais do que um registro
-- Escopo:
SELECT <*, colunas>, ( SELECT <qualquer coisa> FROM <qualquer lugar> ) AS colunaX
  FROM <tabela>
  WHERE <filtros>;

-- Valor total de inscrição por aluno.
SELECT cd_aluno,
    nm_aluno, 
    DECODE(tx_sexo,
                'M', 'Masculino',
                'F', 'Feminino',
                'São Paulino') AS tx_sexo, 
    (SELECT COUNT(cd_aluno) 
        FROM tb_inscricoes
        WHERE tb_alunos.cd_aluno = tb_inscricoes.cd_aluno
    ) AS qtd, -- quantidade de alunos
    (SELECT COALESCE(SUM(vl_inscricao), 0) 
        FROM tb_inscricoes
        WHERE tb_alunos.cd_aluno = tb_inscricoes.cd_aluno
      ) AS total, -- total de inscricoes por aluno
      (SELECT NVL(ROUND( SUM(vl_inscricao) / COUNT(cd_aluno) , 2 ), 0) 
        FROM tb_inscricoes
        WHERE tb_alunos.cd_aluno = tb_inscricoes.cd_aluno
    ) AS media
  FROM tb_alunos;

-- Funções
   -- ROUND  -- arredondar  (<numero>, <precisão>)
   -- CEIL   -- arredondar para cima
   -- FLOOR  -- arredondar para baixo
   -- COALESCE -- Transforma o NULL em outro valor
      COALESCE(<coluna>, <valor>)  -- OU NVL OU NVL2
   -- DECODE  -- IF-THEN-ELSE  (SE-ENTÃO-SENÃO)
      DECODE(<coluna>, 
                '<Se>', '<então>',
                '<Se>', '<então>',
                '<Se>', '<então>',
                'Senão')
      DECODE(status,
                'A', 'Ativo',
                'I', 'Inativo',
                'C', 'Cancelado',
                'O', 'OK',
                'Pendente')
SELECT nm_aluno, 
      DECODE(tx_sexo,
                'M', 'Masculino',
                'F', 'Feminino',
                'São Paulino') AS tx_sexo
  FROM tb_alunos;
     
-- CASE  (Estrutura de controle - operador de comparação)
-- ESCOPO
CASE
  WHEN <valorA> = <valorB> THEN <use este valor>
  WHEN <valorA> = <valorB> THEN <use este valor>
  WHEN <valorA> = <valorB> THEN <use este valor>
  ELSE <outro valor>
END;

SELECT nm_aluno,
        CASE  -- caso
          WHEN tx_sexo = 'F' THEN 'Feminino'  -- quando    -- entao
          WHEN tx_sexo = 'M' THEN 'Masculino'
          ELSE 'São Paulino'  -- senão
        END AS tx_sexo
    FROM tb_alunos;
   
   
SELECT CEIL(10/3) FROM dual;
SELECT FLOOR(10/3) FROM dual;

-- modo beginner
SELECT tb_alunos.cd_aluno, 
       nm_aluno, 
       COUNT(tb_alunos.cd_aluno) as qtd, 
       SUM(vl_inscricao) AS total, 
       ROUND(SUM(vl_inscricao)/ COUNT(tb_alunos.cd_aluno),2) AS media 
  FROM tb_alunos
  FULL JOIN tb_inscricoes ON (tb_alunos.cd_aluno = tb_inscricoes.cd_aluno)
  GROUP BY tb_alunos.cd_aluno, nm_aluno;

-- email não é obrigatório
SELECT nome, NVL(email,'Sem email') FROM usuarios;







-- quantidade de inscricoes por aluno
SELECT COUNT(cd_aluno) 
        FROM tb_inscricoes GROUP BY cd_aluno;
        
-- total de inscricoes por aluno
SELECT SUM(vl_inscricao) 
        FROM tb_inscricoes;

DESC tb_inscricoes;      

INSERT INTO tb_inscricoes VALUES (1,2,CURRENT_DATE, 500.00);
INSERT INTO tb_inscricoes VALUES (2,1,CURRENT_DATE, 800.00);
INSERT INTO tb_inscricoes VALUES (3,1,CURRENT_DATE, 1000.00);
INSERT INTO tb_inscricoes VALUES (4,4,CURRENT_DATE, 300.00);
INSERT INTO tb_inscricoes VALUES (5,1,CURRENT_DATE, 400.00);

        
SELECT cd_aluno, SUM(vl_inscricao) FROM tb_inscricoes GROUP BY cd_aluno;

SELECT * FROM tb_inscricoes;

-- HAVING
-- com a subquery
SELECT * FROM (
    SELECT COUNT(cd_aluno) QTD
      FROM tb_inscricoes
      GROUP BY cd_aluno ) todos
WHERE todos.QTD > 2;

-- com o having -- filtro para as funções de agrupamento
 SELECT COUNT(cd_aluno)
      FROM tb_inscricoes
      GROUP BY cd_aluno
      HAVING COUNT(cd_aluno) > 2;
  
-- Assunto mais ou menos Oracle Tunning
-- Qual é o mais rápido? Ou o melhor?
EXPLAIN PLAN FOR  -- Explique o plano de execução para:

EXPLAIN PLAN FOR
SELECT nm_aluno, AVG(vl_inscricao)
  FROM tb_alunos
  JOIN tb_inscricoes USING (cd_aluno)
  WHERE nm_aluno != 'Fabio'
  GROUP BY nm_aluno;
  
SELECT * FROM TABLE(DBMS_XPLAN.DISPLAY);  
  
EXPLAIN PLAN FOR
SELECT nm_aluno, AVG(vl_inscricao)
  FROM tb_alunos
  JOIN tb_inscricoes USING (cd_aluno)
  GROUP BY nm_aluno
  HAVING nm_aluno != 'Fabio';

SELECT * FROM tb_alunos;


-- OPEN YOUR MIND
-- REGEX  -- Expressões regulares

  -- localizar um determinado trecho no texto
  -- procurar sequencias alfa-numericas
  -- realizar busca com padrão complexo
  -- validar formatos de texto
  -- filtrar dados ou informações...

999.999.999-99
99999-999
POSIX  -> representação alfabetica de uma regex
   REGEX          POSIX
  [A-Za-z]       [:alpha:]           =>  valores alfabeticos
  [A-Za-z0-9]    [:alnum:]           =>  valores alfanumericos
  [A-Z]          [:upper:]           =>  letras maiúsculas
  [a-z]          [:lower:]           =>  letras minúsculas
  [0-9]          [:digit:]           =>  somente números

Metacaracteres   ==  meta
-- Meta  -> Função             -> Exemplo
    \    -> Escape             -> \\ Corresponde a \
    ^    -> Início da linha    -> ^A (strings que comecem com A maiusculo)
    $    -> Final da linha     -> $B (strings que terminem com B maiúsculo)
    [ ]  -> lista              -> [abc] a string deve conter os caracteres abc
    .    -> qualquer caracter  ->  n.o pode ser: nao, não, noo, nbo, nco
    {n}  -> Número de caracteres -> tem que obedecer o número n de caracteres 
    |    -> Alternativa ou similar  ->  ('Joao'|'Maria')

999.999.999-99
CPF: [0-9]{3}\.[0-9]{3}\.[0-9]{3}\-[0-9]{2}
REGEXP_LIKE(<coluna>, <expressão regular>, <parametro de busca>);

-- Parametro de busca:
c  ->  case sensitive
i  ->  case insensisitve
n  ->  qualquer caracter
m  ->  tratar os dados como uma linha multipla
x  ->  ignorar espaços em branco

-- todos os alunos que comecem com F e tenha a letra b na terceira posição
SELECT *
  FROM tb_alunos
  -- WHERE nm_aluno LIKE 'F_b%';
  -- WHERE REGEXP_LIKE(nm_aluno, '^F.b');
  -- WHERE REGEXP_LIKE(nm_aluno, '^f(a|á)b', 'i');
  WHERE REGEXP_LIKE(nm_aluno, '^f[aáãàâ]b', 'i');

--LIKE?
SELECT *
  FROM tb_alunos
  WHERE UPPER(nm_aluno) LIKE UPPER('%ana');

-- REGEXP_LIKE?
SELECT *
  FROM tb_alunos
  WHERE REGEXP_LIKE(nm_aluno, 'ana$', 'i');

-- Todos os aluno que tem 7 letras no nome
-- LIKE ?
SELECT *
  FROM tb_alunos
  WHERE nm_aluno LIKE '_______';

-- REGEXP_LIKE?
SELECT *
  FROM tb_alunos
  --WHERE REGEXP_LIKE(nm_aluno, '^.......$','i');
  WHERE REGEXP_LIKE(nm_aluno, '^.{7}$','i');

-- SOUNDEX
-- converte texto para código fonético

SELECT SOUNDEX('CAMILA') FROM dual;
SELECT SOUNDEX('KAMILA') FROM dual;
SELECT SOUNDEX('KAMILLA') FROM dual;
SELECT SOUNDEX('CAMELO') FROM dual;
SELECT SOUNDEX('CAMELA') FROM dual;
SELECT SOUNDEX('CAMEL') FROM dual;
SELECT SOUNDEX('CAMIL') FROM dual;
SELECT SOUNDEX('KARINA') FROM dual;
SELECT SOUNDEX('CARISMA') FROM dual;

SELECT * FROM tb_alunos;
SELECT *
  FROM tb_alunos
  WHERE SOUNDEX(nm_aluno) = SOUNDEX('marta');


123456
1234567890
SELECT * FROM tb_produtos
  WHERE codigo LIKE '12345_'


INSERT INTO tb_alunos (cd_aluno, nm_aluno, tx_sexo, dt_nascimento)
  VALUES (12, 'Mario Celso', 'M', '01/01/1990');

SELECT * 
  FROM tb_categorias 
  LEFT JOIN tb_cursos USING (cd_categoria)
UNION  
SELECT * 
  FROM tb_categorias 
  RIGHT JOIN tb_cursos USING (cd_categoria);
  
--- exemplo whatever
SELECT *
  FROM tb_carros CAR
  LEFT JOIN tb_lojas LOJ ON (CAR.cd_carro = LOJ.cd_loja);

-- ACID
   -- Atomicidade
   -- Consistência
   -- Isolabilidade
   -- Durabilidade

-- NATURAL JOIN
SELECT nm_aluno, tx_sexo, dt_inicio, nm_instrutor, nm_categoria
  FROM tb_alunos ALU
  NATURAL JOIN tb_inscricoes
  NATURAL JOIN tb_turmas
  NATURAL JOIN tb_instrutores
  NATURAL JOIN tb_cursos
  NATURAL JOIN tb_categorias;

-- UPPER ou LOWER (maiusculo ou minusculo)
SELECT * FROM tb_alunos WHERE UPPER(tx_sexo) = UPPER('m');

SELECT UPPER('m'), UPPER('M') FROM dual ;

UPDATE tb_alunos
  SET nm_aluno = UPPER(nm_aluno)
  WHERE cd_aluno = 1;