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
Exemplo.....: FuncA01 = funcionarios [[ cedepto = 'A01' ou cedepto='E11']]
Sintaxe SQL.: SELECT * FROM <tab> [WHERE <condição>];
Nota........: Se WHERE for omitido, será assumido verdadeiro para todas as linhas de <tab>
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
-- agora vamos criar uma tabela
-- primeiro uma FISICAMENTE que armazena os dados processados na seleção.
create table funca01 as (select * from funcionarios where cedepto='A01');
-- Nem sempre é bom ou necessário gerar tabelas fisicas.
-- EM SQL existe como gerar as tabelas em RAM (determinadas para cada usuário ao acessar o SGBD)
-- 'removendo' a tabela funca01
drop table funca01;
create TEMPORARY table funca01 as (SELECT * FROM funcionarios WHERE cedepto='A01' OR cedepto='E11');
select * from funca01;
-----------------------------------------------------------------------------------------------------------------------
Operação: Projeção
Definição: Gera uma lista de linhas que trazem dados de determinadas colunas
Sintaxe AR: <tab> [[ lista de campos ]]
Exemplo: funcionarios [[ idfuncionario,txprenomes,txsobrenome,cedepto,dtnascimento ]]
Sintaxe SQL: select field1 [,field2, field3,... , fieldn] from <tab>
Exemplo:
select idfuncionario,txprenomes,txsobrenome,dtnascimento from funcionarios;
-- Combinando comandos em SQL
-- Colocando um comando que executa uma seleção E uma projeção (não sabemos a ORDEM de exec.). 
select idfuncionario,txprenomes,txsobrenome,cedepto,dtnascimento from funcionarios 
         where cedepto='A01';
-- Escrevendo o mesmo cmd usando o conceito de tabelas temporárias.
create TEMPORARY table funca01 as (select * from funcionarios where cedepto='A01');
select idfuncionario,txprenomes,txsobrenome,cedepto,dtnascimento from funca01;
-----------------------------------------------------------------------------------------------------------------------
Operação: Produto Cartesiano
Definição: Gera uma lista de linhas de duas tabelas, emparelhando cada linha de uma tabela com todas as linhas da outra
Sintaxe AR: <tab1> X <tab2>
Exemplo: setoresdeatuacao x planosdesaude
Sintaxe SQL: select * from <tab1>, <tab2>; - ANSI-87
             select * from <tab1> CROSS JOIN <tab2>; - ANSI-92
Exemplo:
select * from setoresdeatuacao, planosdesaude; -- ANSI-87
select * from setoresdeatuacao CROSS JOIN planosdesaude; -- ANS-92
-- combinando comandos
select cpsetoratuacao, txnomesetordeatuacao, cpplanodesaude, txnomeplano
       from setoresdeatuacao CROSS JOIN planosdesaude
	     where txnomeplano in ('Unimed','SulAmericana');
-----------------------------------------------------------------------------------------------------------------------
Operação: Junção Natural (Fechada)
Definição...: Gera uma lista de linhas de duas tabelas, emparelhando cada linha de uma tabela com todas as linhas
              da outra, atendendo a uma condição
Sintaxe AR: <tab1> [[ condição ]] <tab2>
Exemplo:
funcionarios->f [[ f.cedepto=d.cpdepto ]] departamentos->d

Sintaxe SQL: select * from <tab1>, <tab2> where [[condição]] -- ANSI-87
             select * from <tab1> INNER JOIN <tab2> ON condição -- ANSI-92
Exemplo:
SELECT * FROM funcionarios AS f INNER JOIN departamentos AS d 
       ON f.cedepto=d.cpdepto; -- ANSI-92
-- combinando comandos
select idfuncionario,txprenomes,txsobrenome,dtnascimento, cpdepto, txnomedepto, vlsalario
       from funcionarios AS f INNER JOIN departamentos AS d 
            ON f.cedepto=d.cpdepto
	   where vlsalario>=75000
	   order by txnomedepto, vlsalario;
-- Nesse exemplo foi feita uma seleção, uma junção, uma projeção e uma ordenação de dados.
   -- NÃO existe a tradução desta combinação para UM comando de AR.
-----------------------------------------------------------------------------------------------------------------------
-- Para exemplificar os ccomandos complementares da junção (apresentados na ANSI-92), escrevemos:
-- Criando duas tabelas temporárias partindo de medicos (cpmedico, txnomemedico, nucrm, ceinstituicao)
-- e de instituicoesdeensino (cpinstituicao, txnomeinstituicao)
-- Em AR: med= medicos [[  cpmedico, txnomemedico, nucrm, ceinstituicao]]
create temporary table med as (select cpmedico, txnomemedico, nucrm, ceinstituicao from medicos);
-- Em AR: inst = instituicoesdeensino [[ cpinstituicao, txnomeinstituicao ]]
create temporary table inst as (select cpinstituicao, txnomeinstituicao from instituicoesdeensino);
-- Exibindo o conteúdo das tabelas criadas
select * from med;
select * from inst;
-----------------------------------------------------------------------------------------------------------------------
-- Vamos para as operações
-- Operação....: Junção Aberta Pela Direita
-- Definição...: Gera uma lista de linhas de duas tabelas, emparelhando cada linha de uma tabela com todas as linhas
--               da outra, atendendo a uma condição e trazendo na resposta todas as linhas da tabela da direita.
-- Sintaxe AR..: <tab1> [[ condição ][ <tab2>

-- Sintaxe em SQL: select * from <tab1> right join <tab2> on <condição>;
-- Exemplo med [[ med.ceinstituicao=inst.cpinstituicao ][ inst
-- 
-- Em SQL:
-- Sintaxe: select * from <tab1> right join <tab2> on <tab1>.<cp>=<tab2>.<ce>
-- Exemplo em SQL:
select * from med right join inst on med.ceinstituicao=inst.cpinstituicao;
-- Nota: Repare na execução a existência da NULA emparelhada no lado esquerdo dos dados apresentados.
--       A não existência da linha nula significa que a junção aberta pela DIREITA tem o mesmo
--       resultado da junção Natural
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Junção Aberta Pela Esquerda
-- Definição...: Gera uma lista de linhas de duas tabelas, emparelhando cada linha de uma tabela com todas as linhas
--               da outra, atendendo a uma condição e trazendo na resposta todas as linhas da tabela da ESQUERDA.
-- Sintaxe AR..: <tab1> ][ condição ]] <tab2>
-- Exemplo[AR].: med ][ med.ceinstituicao=inst.cpinstituicao ]] inst
-- NOTA........: As Linhas NULAS aparecem, agora, no lado da tabela inst (med deve estar completa).
-- Sintaxe SQL.: select * from <tab1> left join <tab2> on <tab1>.<cp>=<tab2>.<ce> 
-- Exemplo[SQL]:
select * from med left join inst on med.ceinstituicao=inst.cpinstituicao;
-----------------------------------------------------------------------------------------------------------------------
-- Operação....: Junção Completa (abertas pelos dois lados)
-- Definição...: Gera uma lista de linhas de duas tabelas, emparelhando cada linha de uma tabela com todas as linhas
--               da outra, atendendo a uma condição e trazendo na resposta todas as linhas de ambas as tabelas.
-- Sintaxe AR..: <tab1> ][ condição ][ <tab2>
-- Exemplo[AR].: med ][ med.ceinstituicao=inst.cpinstituicao ][ inst
-- NOTA........: Havera um empararelhamento com linhas NULAS de ambos os lados.
-- Sintaxe SQL.: select * from <tab1> full outer join <tab2> on <tab1>.<cp>=<tab2>.<ce>
-- Nota........: Repare no emeparelhamento de linhas nulas de ambos os lados.
-- Exemplo[SQL]:
select * from med full outer join inst on med.ceinstituicao=inst.cpinstituicao;
-----------------------------------------------------------------------------------------------------------------------
-- 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.
-- Sintaxe AR..: <tab1> U <tab2>
-- Exemplo[AR].: f1 U 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); -- linhas NÃO repetidas
select * from f1 UNION ALL  (select * from f2); -- TODAS as linhas.
-----------------------------------------------------------------------------------------------------------------------
-- 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>;
-- Nota........: 
-- Exemplo[SQL]:
select * from F1 except (select * from f2);
-- Invertendo as tabelas, altera o resultado.
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> "U Invertido" <tab2>
-- Exemplo[AR].: f1 ^ f2 - OU <tab1> ∩ <tab2>
-- NOTA........: 
-- Sintaxe SQL.: select * from <tab1> intersect (select * from <tab2>);
-- Nota........: 
-- Exemplo[SQL]:
select * from f1 intersect (select * from f2);
-----------------------------------------------------------------------------------------------------------------------
-- 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
-- ∀∄∃∪