-- Escrita de comandos traduzidos das operações de AR para SQL.
Atualização: 2025-04-02 - 16h54
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Seleção
-- Definição...: Gera uma lista de linhas de uma tabela que obedecem uma condição
-- Sintaxe AR..: <tab> [[ condição ]]
-- Exemplo[AR].: funcionarios[[cedepto='A01' ou cedepto='E11']]
-- NOTA........: O resultado do comando pode ser 'direcionado' para uma tabela. com o simbolo '<tab destino> =...'
--               Na condição podemos usar operadores lógicos (ou, não, e, etc.) Escrito em português
-- Sintaxe SQL.: select [lista de campos ou *] from <tab> [where <cond> ou verdade];
-- Nota........: Os comandos podem ser escritos com maius ou minus o processamento é o mesmo.
--               Os Valores de <cond> DEVEM ser escritos como estão gravados nas tabelas.
-- Exemplo[SQL]:
-- Lendo todas as linhas de funcionarios
SELECT * FROM funcionarios WHERE 1=1;
-- Escrevendo um cmd equivalente ao anterior
SELECT * FROM funcionarios;
-- Lendo os registros de funcionarios onde cedepto='A01' ou cedepto='E11'
SELECT * FROM funcionarios WHERE cedepto='A01' OR cedepto='E11';
-- Trazendo os dados ordenados por idfuncionario
SELECT * FROM funcionarios WHERE cedepto='A01' OR cedepto='E11' ORDER BY cedepto, idfuncionario
-- Usando uma alternativa ao operador 'OR'
SELECT * FROM funcionarios WHERE cedepto IN ('A01','E11') ORDER BY cedepto, idfuncionario
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Projeção
-- Definição...: Gera uma lista de dados das campos da tabela.
-- Sintaxe AR..: <tab> [[ lista de campos ]]
-- Exemplo[AR].: funcionarios[[idfuncionario,txprenomes,txsobrenome,cedepto,dtnascimento]]
-- NOTA........: Todas as linhas da tabela terão seus dados copiados para a resposta do comando
-- Sintaxe SQL.: select [lista de campos ou *] from <tab>;
-- Nota........: 
-- Exemplo[SQL]:
-- Fazendo uma Projeção
select idfuncionario,txprenomes,txsobrenome,cedepto,dtnascimento from funcionarios;
-- Notas:
-- Os dados pode ser 'direcionados' para uma TABELA FISICAMENTE GRAVADA NO HD.
create table resfunc as
      (select idfuncionario,txprenomes,txsobrenome,cedepto,dtnascimento
	          from funcionarios);
-- O comando acima é a implementação da operação de AR na forma:
-- resfunc=funcionarios[[idfuncionario,txprenomes,txsobrenome,cedepto,dtnascimento]]
-- Os dados de resfunc podem ser consultados no comando...
select * from resfunc;
-- REMOVENDO a tabela da base de dados
DROP TABLE resfunc;
-- Esta ação de criar fisicamente uma tabela pode ser útil em algumas situações.
-- Porém, se dois usuários executarem o mesmo comando, o segundo receberá uma mensagem de erro
-- indicando a existência da tabela resfunc. 
-- Para resolver esta situação, em SQL podemos criar uma tabela em memória RAM.
-- Para criar uma 'versão' de resfunc para cada usuário... podemos usar
create temporary table resfunc as
      (select idfuncionario,txprenomes,txsobrenome,cedepto,dtnascimento
	          from funcionarios);
-- esta 'saída' é tecnológica. Na AR não existe este conceito.
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Produto Cartesiano
-- Definição...: Gera uma lista com as linhas de DUAS tabelas, emparelhando CADA LINHA da primeira tabela com
--               TODAS as LINHAS da segunda tabela.
-- Sintaxe AR..: <tab1> X <tab2>
-- Exemplo[AR].: paises X cursos
-- NOTA........: Se uma tabela estiver vazia (sem linhas) o resultado será uma tabela SEM linhas (a tabela existirá).
-- Sintaxe SQL.: select * from <tab1>, <tab2>; -- ANSI-87
--               select * from <tab1> CROSS JOIN <tab2>; -- ANSI-92
-- Nota........: Se uma das tabelas for NULA, o resultado será uma lista vazia (sem valor).
-- Exemplo[SQL]:
select * from paises CROSS JOIN cursos;  -- Este comando gera uma tabela NULA.
select * from palavraschaves CROSS JOIN cursos; -- Este cmd gera uma lista com 66 linhas.
--                                                 6 linhas de cursos e 11 linhas de palavraschaves.
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Junção Natural (Fechada)
-- Definição...: Gera uma lista com as linhas de DUAS tabelas, emparelhando CADA LINHA da primeira tabela com
--               TODAS as LINHAS da segunda tabela, DESDE QUE atendam a uma condição.
-- Sintaxe AR..: <tab1> [[ condição ]] <tab2>
-- Exemplo[AR].: funcionarios->f [[ f.cedepto=d.cpdepto ]] departamentos->d
-- NOTA........: Na maioria das condições compara-se uma chave primária com uma chave estrangeira.
-- Sintaxe SQL.: select * from <tab1>,<tab2> where <tab1>.<campo1>=<tab2>.<campo2>; -- ANSI-87
--               select * from <tab1> INNER JOIN <tab2> ON <condição>; -- ANSI-92
-- Nota........: 
-- Exemplo[SQL]:
select * from funcionarios as f, departamentos as d where f.cedepto=d.cpdepto; -- ANSI-87
select * from funcionarios as f INNER JOIN departamentos as d ON f.cedepto=d.cpdepto; -- ANSI-92
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Junção Aberta Pela Direita
-- Definição...: Gera uma lista com as linhas de DUAS tabelas, emparelhando CADA LINHA da primeira tabela com
--               TODAS as LINHAS da segunda tabela, DESDE QUE atendam a uma condição; mantendo todas as linhas da
--               Tabela da DIREITA do operador de junção.
-- Sintaxe AR..: <tab1> [[ condição ][ <tab2>
-- Exemplo[AR].: instituicoesdeensino -> i [[ m.ceinstituicao=i.cpinstituicao ][ medicos -> m
-- NOTA........: 
-- Sintaxe SQL.: select * from <tab1> RIGHT join <tab2> ON <tab1>.<campo1>=<tab2>.<campo2> -- ANSI-92
-- Nota........: 
-- Exemplo[SQL]:
select cpinstituicao, txnomeinstituicao, cpmedico, txnomemedico, ceinstituicao
       from instituicoesdeensino as i right JOIN medicos as m on m.ceinstituicao=i.cpinstituicao;
-- Nota........: Neste exemplo usou-se o ALIAS criando i e m para simplificar a declaração da condição da junção.
--               No exemplo foram combinados os cmds de PROJEÇÃO e JUNÇÃO ABERTA PELA DIREITA
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Junção Aberta Pela Esquerda
-- Definição...: Gera uma lista com as linhas de DUAS tabelas, emparelhando CADA LINHA da primeira tabela com
--               TODAS as LINHAS da segunda tabela, DESDE QUE atendam a uma condição; mantendo todas as linhas da
--               Tabela da ESQUERDA do operador de junção.
-- Sintaxe AR..: <tab1> ][ condição ]] <tab2>
-- Exemplo[AR].: instituicoesdeensino -> i ][ m.ceinstituicao=i.cpinstituicao ]] medicos -> m
-- NOTA........: 
-- Sintaxe SQL.: select * from <tab1> LEFT join <tab2> ON <tab1>.<campo1>=<tab2>.<campo2> -- ANSI-92
-- Exemplo[SQL]:
select cpinstituicao, txnomeinstituicao, cpmedico, txnomemedico, ceinstituicao
       from instituicoesdeensino as i left JOIN medicos as m on m.ceinstituicao=i.cpinstituicao;
-- Nota........: Neste exemplo usou-se o ALIAS criando i e m para simplificar a declaração da condição da junção.
--               No exemplo foram combinados os cmds de PROJEÇÃO e JUNÇÃO ABERTA PELA ESQUERDA
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Junção Completa (abertas pelos dois lados)
-- Definição...: Gera uma lista com as linhas de DUAS tabelas, emparelhando CADA LINHA da primeira tabela com
--               TODAS as LINHAS da segunda tabela, DESDE QUE atendam a uma condição; mantendo todas as linhas da
--               Tabela da ESQUERDA do operador de junção. Emparelhando as linhas que não à condição com linhas NULAS.
-- Sintaxe AR..: <tab1> ][ condição ][ <tab2>
-- Exemplo[AR].: instituicoesdeensino -> i ][ m.ceinstituicao=i.cpinstituicao ][ medicos -> m
-- NOTA........: 
-- Sintaxe SQL.: select * from <tab1> FULL OUTER join <tab2> ON <tab1>.<campo1>=<tab2>.<campo2> -- ANSI-92
-- Exemplo[SQL]:
select cpinstituicao, txnomeinstituicao, cpmedico, txnomemedico, ceinstituicao
       from instituicoesdeensino as i full outer JOIN medicos as m on m.ceinstituicao=i.cpinstituicao;
-- Nota........: Neste exemplo usou-se o ALIAS criando i e m para simplificar a declaração da condição da junção.
--               Alguns SGBDs aceitam o complemento do JOIN somente com o termo FULL.
--               No exemplo foram combinados os cmds de PROJEÇÃO e JUNÇÃO
-----------------------------------------------------------------------------------------------------------------------
-- Para completar as operações de AR, falta ver os comandos SQL para União, Subtração e Instersecção.
-- Para executar as operações de U (União), - (subtração) e ^ (Intersecção) deve-se criar duas UC
-- UC é o conceito de união compatível. EM MR... UC significa ter os mesmo tipos de dados em cada campo
-- correspondente. SE A(c1, c2, c3) e B(c4, c5, c6) então A e B são UC se
-- tipo de dado de c1 é o mesmo de c4,
-- tipo de dado de c2 é o mesmo de c5 E
-- tipo de dado de c3 é o mesmo de c6
-- Vamos criar estruturas (tabelas) UC
create temporary table f1 as (select idfuncionario, txprenomes, txsobrenome, dtnascimento, cedepto
                                     from funcionarios where cedepto in ('A01','E01','E11'));
create temporary table f2 as (select idfuncionario, txprenomes, txsobrenome, dtnascimento, cedepto
                                     from funcionarios where cedepto in ('D11','E11'));
-- Se for interessante consultar as tabelas antes de processar os comandos, use:
select * from f1;
select * from f2;
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: União
-- Definição...: Gera uma lista de linhas de duas tabelas UC, escrevendo as linhas da primeira tabela seguidas
--               das linhas da segunda tabela. Como as tabelas são UC os tipos de dados de cada coluna da tabela 1
--               devem ser iguais aos tipos de dados de cada coluna correspondente na tabela 2.
--               DE OUTRA FORMA: GERA UMA LISTA DE LINHAS COM AS LINHAS COMUNS E AS NÃO COMUNS sem repetição DE
--               DUAS TABELAS uc.
-- Sintaxe AR..: <tab1> ∪ <tab2>
-- Exemplo[AR].: f1 ∪ f2
-- NOTA........: 
-- Sintaxe SQL.: select * from <tab1> UNION [ALL] (select * from <tab2>);
-- Nota........: Na ANSI-87 o UNION levava para a resposta TODAS as linhas de ambas as tabelas
--               (linhas comuns e não comuns). Na ANSI-92 o UNION processa as linhas SEM a repetição.
--               Para ver TODAS as linhas o UNION precisa do complemento ALL
-- Exemplo[SQL]:
select * from f1 UNION (select * from f2);
-- nota: O operador UNION eliminou a repetição de dados das tabelas
--       SE quisermos ver todas as linhas, escreve-se:
select * from f1 UNION ALL (select * from f2);
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Subtração
-- Definição...: Gera uma lista de linhas de duas tabelas UC, escrevendo as linhas que estão na Primeira Tabela e
--               que não estão na Segunda Tabela
-- Sintaxe AR..: <tab1> - <tab2>
-- Exemplo[AR].: f1 - f2
-- NOTA........: Havera um resultado diferente se a ordem das tabelas for invertida.
-- Sintaxe SQL.: select * from <tab1> except (select * from <tab2>;
-- Exemplo[SQL]:
select * from f1 EXCEPT (select * from f2);
-- Nota........: Este comando não é COMUTATIVO. Trocando f1 por f2 o resultado se altera.
select * from f2 EXCEPT (select * from f1);
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Intersecção
-- Definição...: Gera uma lista de linhas de duas tabelas UC, escrevendo na resposta as linhas COMUNS das 2 tabelas
-- Sintaxe AR..: <tab1> ^ <tab2> - OU <tab1> ∩ <tab2>
-- Exemplo[AR].: f1 ∩ f2
-- NOTA........: o simbolo ^ foi adotado na revisão da AR por ser mais fácil de ser reproduzido em editores
--               de programação.
-- Sintaxe SQL.: select * from <tab1> intersect (select * from <tab2>);
-- Exemplo[SQL]:
select * from f1 intersect (select * from f2);
-- Nota........: Este comando é comutativo.
-----------------------------------------------------------------------------------------------------------------------
-- Comandos de Atualização das Linhas das Tabelas
--
-- Os cmds de atualização 'agem' ou 'atuam' em uma tabela de cada vez.
-- EMBORA existam SGBDs que permitem combinar tabelas (em junções) e ATUALIZAR
-- parte do conjunto formado, usando um cmd 'semelhante' ao SQL.
-- Estes comandos, entretanto, não foram 'implementados' nos padrões ANSI.
-- ---------------------------------------------------------------------
-- 
-- Antes de iniciar a apresentação dos comandos de atualização de linhas nas tabelas,
-- deve-se tratar o conceito de TRANSAÇÃO.
--
-- TRANSAÇÃO 
-- Segmento (ou sequência) de comandos de atualização de dados que devem ser todos executados ou cancelados.
-- Mas.... Esta seq. Pode estar em um Programa Aplicativo (PA) na camada cgi... Sendo executada por muitos usuários...
-- E... Como SGBD+PA controlam o "tudo ou nada"?
-- Nos PA se usa o trecho de transação (rever os PA-php de inc+exc+act - das disciplina Ling de Prog WEB)
-- Nos SGBD existe o recurso de "agendamento", onde os comandos do PA são copiados para os LOGS de TRANSAÇÃO
--    (rever: componentes do SGBD da disciplina "Banco de Dados").
-- No SGBD existem comandos que
-- * Iniciam transação: BEGIN TRANSACTIONS; 
-- * Concluem transação: COMMIT; 
-- * Cancelam transação: ROLLBACK;
-- 
-- Ainda neste assunto vale lembrar que os SGBDs têm comandos que são agrupados em:
-- Linguagens (ou grupos de cdms) de sgbd
-- * DDL <-> Linguagem de Definição de Dados -> São comandos voltados para "criação" das 'coisas' nas Bases de Dados 
-- * DCL <-> caracterização de usuários/grupos e seus privilégios de acesso sobre 'coisas' nas Bases.
-- * DML <-> Comandos de manipulação
--           'manipular' significar CONSULTAR [ Query Language: DQL - IBM considera esta subdivisão]
--                               ou ATUALIZAR [ Transaction Language: DTL - Cmds para TRANSAÇÃO de Dados]                             
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Inclusão de linhas
-- Definição...: permite a inclusão de registros em UMA tabela do Banco de Dados.
-- Sintaxe SQL.: insert into <tab> [(campos que recebem valor)] 
--                      values (Valores atribuídos aos campos)[,(),()..,())];
-- Onde........: campos que recebem valor - é uma lista de campos de <tab> aos quais serão atribuídos os valores
--               apresentados após VALUES.
--               Valores atribuídos aos campos - devem aparecer separados por virgula.
--               SENDO BOA PRÁTICA serem delimitados por "'".
-- Exemplo[SQL]:
begin transaction;
insert into autores (cpautor,txnomeautor,celogradouro,txcomplemento,nucep,dtnascimento,dtcadautor)
      values ('30','Ignácio de Loyola Brandão','10','Ap. 234','16345678','1956-05-20','2025-04-02');
select * from autores;
rollback; -- CANCELANDO a transação
commit;     -- CONCLUINDO a transação
-- criando outra linha com valores NULOs para celogradouro e txcomplemento
begin transaction;
insert into autores 
      values ('60','Ignácio de Loyola Brandão',null,null,'16345678','1956-05-20','2025-04-02'),
	         ('90','Ignácio de Loyola Brandão','20',null,'16345678','1956-05-20','2025-04-02');
select * from autores;
rollback; -- CANCELANDO a transação
commit;     -- CONCLUINDO a transação
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Exclusão de linhas
-- Definição...: permite a deleção de linhas de uma tabela.
-- Sintaxe SQL.: delete <tab> WHERE <condição>;
-- Exemplo[SQL]:
begin transaction;
delete from autores where txnomeautor like '%Brandão%';
select * from autores;
rollback; -- CANCELANDO a transação
commit;     -- CONCLUINDO a transação
-- Note: no exemplo acima foi usado o operador LIKE.
-- o operador ILKE (como sendo) pode receber uma quantidade de simbolos para:
-- % - Quantidade qualquer de caractere - é o 'curinga'.
-- '_' indica um Caractere variável
-- usando o operador LIKE para consultar registros de uma tabela.
select * from autores where txnomeautor like '%Brandão%'; -- o campo txnomeautor deve conter 'Brandão'
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Alteração de linhas
-- Definição...: permite a alteração de valores de campos em linhas de UMA tabela.
-- Sintaxe SQL.: update <tab> SET (Atribuições: campos recebem valores)
--                           [WHERE <condição>]; 
-- Onde........: Atribuições - Lista de campos recebendo valores no formato "campo='valor'", 
--               sendo que podem ser feitas mais de uma atribuição (separadas por ',')
-- Exemplo[SQL]:
begin transaction;
update autores set dtcadautor=current_date  where cpautor > 50;
select * from autores;
rollback; -- CANCELANDO a transação
commit;     -- CONCLUINDO a transação

-----------------------------------------------------------------------------------------------------------------------
-- https://symbl.cc/pt/collections/mathematical-signs/
-- Alguns Símbolos copiados
-- ∀∄∃∪