-- Escrita de comandos traduzidos das operações de AR para SQL.
-- Atualização: 2025-09-13 - 10h20
---------------------------------------------------------------------------------------------------
-- Operação.....: Seleção
-- Definição....: Cria uma lista dos dados de uma tabela que obedeçam a uma condição.
-- [AR]-Sintaxe.: tab [[ condição para as tuplas serem exibidas ]]
-- [AR]-Exemplo.: autores [[ dtnascimento<'1960-01-01' ]]
--          Nota: Existem autores que 'LÊM' este comando assim:
--                'autores' onde a Data de Nascimento é anterior à '1960-01-01'
--                Isso já dá uma indicação de como será a sintaxe do SQL
-- [SQL]-Sintaxe: select * from <tab> where <condição>
-- [SQL]-Exemplo: 
select * from autores where autores.dtnascimento < '1960-01-01';
--          Nota: Podemos usar a seleção para ler toda uma tabela, na forma:
select * from autores where 1=1;
--          Nota: Acima temos o comando que LE TODAS as LINHAS da tabela autores.
--                De outro modo: Em quantas linhas de autores a condição 1=1? retorna verdadeira,
--                a resposta em TODAS.
---------------------------------------------------------------------------------------------------
-- Operação.....: Projeção
-- Definição....: Cria uma lista dos dados de uma tabela levando todos os dados de campos
--                escolhidos na operação
-- [AR]-Sintaxe.: tab [[ Lista de Campos a Exibir ]]
-- [AR]-Exemplo.: autores [[ pkautor, txnomeautor ]]
--      NOTA....: TAMBÉM podemos escrever: autores [[ autores.pkautor, autores.txnomeautor ]]
--                onde o simbolo '.' indica a 'pertinência' do campo na tabela.
--                O campo pkautor 'pertence' à tabela autores.
-- [SQL]-Sintaxe: select <tab>.<campo1>, <tab>.<campo2>, ... <tab>.<campon> from <tab>;
-- [SQL]-Exemplo: 
select a.pkautor, a.txnomeautor from autores as a;
--      NOTA....: A tabela 'autores' foi renomeada em tempo de execução (NÃO ALTEROU A TABELA),
--                usando o comando 'as'. 
--                O simbolo '.' representa a 'pertinência à'...
--                Na forma pkautor PERTENCE à autores: a.pkautor indica isso.
--                COMBINANDO uma seleção e uma projeção
--                tab [[ lista de campos; condição para as tuplas serem exibidas ]], embora Isso
--                NÃO EXISTA em AR. 
--                autores [[ pkautor,txnomeautor,dtnascimento; dtnascimento < '1960-01-01' ]]
--                Em SQL é possível escrever:
select pkautor,txnomeautor,dtnascimento from autores where dtnascimento < '1960-01-01';
---------------------------------------------------------------------------------------------------
-- Operação.....: Produto Cartesiano
-- Definição....: Cria uma lista dos dados de  duas tabelas fazendo o 'emparelhamento' de cada
--                linha da primeira tabela com TODAS as linhas da segunda tabela.
-- [AR]-Sintaxe.: tab1 X tab2
--      NOTA....: 
-- [AR]-Exemplo.: autores X cores
--      NOTA....: Esta operação é uma das fundamentais da AR propostas por E.F. Cood, juntamente
--                com outras 5 (seleção, projeção, junção, união e subtração - diferença).
--                Pórem, quando começaram a escrever a SQL notaram que era necessário mais
--                operações; MAS, começaram a montar os comandos da SQL SEM a AR...
--                Daí precisaram desenvolver um padrão da SQL. O ANSI apresentou um padrão em 86,
--                que foi aceito pela ISO em 87 e passou a ser referenciado ANSI:87, SEM as
--                operações de junção aberta.
--                Como estas operações não existiam na AR, o ANSI resolveu adotar mesmo assim um
--                padrão e veio o ANSI:92. Deois disso os acadêmicos propuseram a revisão da AR.
--                Bom, mas e os SGBDs que usavam a ANSI:87? Bem, deveriam a passar a usar a ANSI:92
--                SEM a necessidade de alterar programas já escritos.
--                ENTÃO, a SQL tem duas formas de escrever o produto cartesiano e as junções.
--                Assim:
-- [SQL]-Sintaxe: select * from <tab1>, <tab2>; - ANSI:87
--                select * from <tab1> CROSS JOIN <tab2>; - ANSI:92
--      NOTA....: Este operador JOIN aceita 5 complementos, uma para cada operação:
--                CROSS - Produto Cartesiano
--                INNER - Junção Natural ou Fechada
--                LEFT - Junção Aberta Pela ESQUERDA
--                RIGHT - Junção Aberta Pela DIREITA  
--                FULL OUTER - Junção COMPLETA (Aberta pelos dois lados).
-- [SQL]-Exemplo: 
select * from autores , cores; -- ANSI:87

--      NOTA....: Podemos usar sub-queries para 'projetar' campos das duas tabelas gerando um
--                prodCartesiano 'menor', na forma:
select * from (select autores.pkautor, autores.txnomeautor from autores) ,
              (select cores.pkcor, cores.txnomecor from cores);-- Exemplo SQL: ANSI:92
-- [SQL]-Exemplo: Outro exemplo:
select * from autores CROSS JOIN cores; -- ANSI:92
--          Nota: Podemos usar sub-queries para 'projetar' campos das duas tabelas gerando um
--                prodCartesiano 'menor', na forma:
select * from 
         (select autores.pkautor, autores.txnomeautor from autores)
           CROSS JOIN
         (select cores.pkcor, cores.txnomecor from cores);
---------------------------------------------------------------------------------------------------
-- 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.
--          Nota: Em GERAL, a condição é a comparação de valores de uma chave primária com as
--                correspondentes chaves estrangeiras.
-- [AR]-Sintaxe.: <tab1> [[ condição ]] <tab2>
-- [AR]-Exemplo.: funcionarios->f [[ f.cedepto=d.cpdepto ]] departamentos->d
--          Nota: Na operação acima já se apresenta o sinal '->' que faz a troca de nome das
--                tabelas para facilitar a escrita da condição da Junção.
-- [SQL]-Sintaxe: select * from <tab1>, <tab2> where [[condição]] -- ANSI-87
--                select * from <tab1> INNER JOIN <tab2> ON condição -- ANSI-92
--       Nota...: No Padrão ANSI de 92 foi apresentado o operador JOIN. Na Junção Natural o
--                complemento do join é o 'INNER'.
-- [SQL]-Exemplo: 
select * from clientes order by pkcliente;
select * from armazens order by pkarmazem;
-- 'Ligando' as linhas de clientes e armazens
select * from clientes, armazens where clientes.pkcliente = armazens.fkcliente; -- ANSI:87
select * from clientes as c INNER JOIN armazens as a ON c.pkcliente=a.fkcliente; -- ANSI:92
-- Fazendo projeções de campos de clientes e armazens para ver 'melhor' os dados processados.
select c.pkcliente, c.txnomecliente from clientes as c;
select a.pkarmazem, a.txnomearmazem, a.fkcliente from armazens as a;
-- usando subqueries para melhorar a visão dos dados
select * from (select clientes.pkcliente, clientes.txnomecliente from clientes) as c
         INNER JOIN 
		      (select armazens.pkarmazem, armazens.txnomearmazem, armazens.fkcliente from armazens) as a 
		 ON c.pkcliente=a.fkcliente; -- ANSI:92
-- Fazendo uma projeção de uma junção SEM subqueries.
select c.pkcliente, c.txnomecliente,a.pkarmazem, a.txnomearmazem, a.fkcliente
       from clientes as c 
	        INNER JOIN
			armazens as a
	   ON c.pkcliente=a.fkcliente; -- ANSI:92

---------------------------------------------------------------------------------------------------
-- Para exemplificar os comandos 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 [[  pkmedico, txnomemedico, nucrm, fkinstituicao ]]
create temporary table med as (select pkmedico, txnomemedico, nucrm, fkespecialidade from medicos);
-- Em AR: inst = instituicoesdeensino [[ pkinstituicao, txnomeinstituicao ]]
create temporary table esp as (select pkespecialidade, txnomeespecialidade from especialidadesmedicas );
-- Exibindo o conteúdo das tabelas criadas
select * from med;
select * from esp;
---------------------------------------------------------------------------------------------------
-- Vamos para as operações
---------------------------------------------------------------------------------------------------
-- 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.
-- [AR]-Sintaxe.: <tab1> ][ condição ]] <tab2>
-- [AR]-Exemplo.: esp ][ med.fkespecialidade=esp.pkespecialidade ]] med
-- [SQL]-Sintaxe: select * from <tab1> left join <tab2> on <tab1>.<cp>=<tab2>.<ce>
-- [SQL]-Exemplo: 
select * from esp LEFT JOIN med on esp.pkespecialidade=med.fkespecialidade;
--          NOTA: As Linhas NULAS aparecem, agora, no lado da tabela inst (med deve estar completa).
--                A junção NATURAL continua a aparecer no resultado.
---------------------------------------------------------------------------------------------------
-- 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.
-- [AR]-Sintaxe.: <tab1> [[ condição ][ <tab2>
--          Nota: A diferença entre a Junção Natural e a JADireita é muito sutil (um colchete).
--                Quando propuseram esta sintaxe para a AR, alguns estudiosos propuseram outros
--                simbolos, tais como: [[ ]-> ou [[ ]{ ou ]-[.
--                Ou ainda, deixar ao consenso do grupo que está trabalhando em um projeto.
-- [AR]-Exemplo.: med [[ med.ceinstituicao=inst.cpinstituicao ][ inst
-- [SQL]-Sintaxe: select * from <tab1> right join <tab2> on <condição>;
--                ou (se considerarmos que SEMPRE se compara a PK de uma tabela com a FK de outra
--                select * from <tab1> right join <tab2> on <tab1>.<PK>=<tab2>.<FK>
--          Nota: Lá pelos 80~90 os SGBDs estavam melhorando os algoritmos de operações de linhas
--                de tabelas e a performance era sensivelmente diferentes quando se comparava PK=FK
--                contra FK=PK (hoje parece complicado o programador/analista ter que conhecer
--                estes detalhes dos SGBDs, mas era isso acontecia e que ao longo do tempo mudou).
-- [SQL]-Exemplo: 
select f.pkfuncionario, f.txprenomes, f.fklogradouro, l.pklogradouro, l.txnomelogradouro
       from funcionarios as f
	   RIGHT JOIN logradouros as l
	   ON f.fklogradouro = l.pklogradouro;
--          Nota: Repare no resultado da execução existem linhas NULAS emparelhada no lado esquerdo
--                dos dados apresentados. A existência da linha nula significa que as linhas da
--                tabela do lado direito, mesmo sem resultado na junção, estão aparecendo no
--                resultado, caracterizando uma Junção Aberta pela DIREITA. Veja também que as
--                linhas 'emparelhadas' tem o mesmo resultado da Junção NATURAL.

---------------------------------------------------------------------------------------------------
-- Operação.....: Junção Completa (Aberta pelos 2 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.
-- [AR]-Sintaxe.: <tab1> ][ condição ][ <tab2>
-- [AR]-Exemplo.: med ][ med.ceinstituicao=inst.cpinstituicao ][ inst
-- [SQL]-Sintaxe: select * from <tab1> FULL OUTER join <tab2> on <tab1>.<cp>=<tab2>.<ce>
-- [SQL]-Exemplo: 
-- Para estabelacer as condições para fazer uma Junção Completa execute os seguintes comandos:
insert into clientes (pkcliente,txnomecliente,txrazaosocial,fklogradouro,
                      txcomplemento,nucep,vllimitecompra,aosituacao,dtcadcliente)
       values (45,'Magazine Luiza','Magazine Luiza S.A.',null,null,'00000000',100000,'A','2025-09-06'),
              (60,'Casas Pernambucanas','Loja de Variedades Casas Pernambucanas S.A.',null,null,'00000000',120000,'A','2025-09-06');
-- Testando a Junção Natural
select pkcliente, txnomecliente,fklogradouro,pklogradouro,txnomelogradouro from clientes inner join logradouros on pklogradouro=fklogradouro;
-- Agora testando as Junções Abertas (já com a projeção adequada para a visualização da linhas nulas)
select pkcliente, txnomecliente,fklogradouro,pklogradouro,txnomelogradouro from clientes LEFT join logradouros on pklogradouro=fklogradouro;
select pkcliente, txnomecliente,fklogradouro,pklogradouro,txnomelogradouro from clientes RIGHT join logradouros on pklogradouro=fklogradouro;
-- Finalmente a Junção Aberta
select pkcliente, txnomecliente,fklogradouro,pklogradouro,txnomelogradouro from clientes FULL OUTER join logradouros on pklogradouro=fklogradouro;

--          NOTA: Haverá no resultado uma junção NATURAL e o empararelhamento com linhas NULAS
--                de ambos os lados (ou seja, as duas tabelas devem aparecer com TODAS as Linhas).
---------------------------------------------------------------------------------------------------
-- Para completar as operações de AR, devem ser vistos 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 pkfuncionario, txprenomes, txsobrenome, dtnascimento, fkdepto
                                     from funcionarios where fkdepto in ('A01','E01','E11'));
create temporary table f2 as (select pkfuncionario, txprenomes, txsobrenome, dtnascimento, fkdepto
                                     from funcionarios where fkdepto in ('D11','E11'));
-- Se for interessante consultar as tabelas antes de processar os comandos, use:
select * from f1;
select * from f2;
-- Na aula do dia 2025-09-10 analisamos outra tabela em sala de aula.
-- Consultando a tabela 'cidades' com os dados ordenados por qtpopulacao
select * from cidades order by qtpopulacao asc;
create temporary table tab1 as 
     ( select pkcidade, txnomecidade, qtpopulacao
              from cidades where qtpopulacao >= 900000
              order by qtpopulacao );
create temporary table tab2 as 
     ( select pkcidade, txnomecidade, qtpopulacao
              from cidades where qtpopulacao <= 1000000
              order by qtpopulacao );
select * from tab1;
select * from tab2;
-- 
---------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------
-- 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.
-- [AR]-Sintaxe.: <tab1> U <tab2>
-- [AR]-Exemplo.: f1 U f2
-- [SQL]-Sintaxe: select * from <tab1> UNION [ALL] (select * from <tab2>);
-- [SQL]-Exemplo: 
select * from tab1 UNION (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
-- Exibindo a mesma lista ordenada pelos valores de qtpopulacao (em order crescente) e com todas as
-- linhas das tabelas (mesmo as repetidas).
select * from tab1 UNION (select * from tab2);
-- Note que os conjuntos de dados tab1 e tab2 foram selecionados à partir de cidades levando em
-- consideração os valores do campo 'qtpopulacao'. Os dados exibidios foram processados lendo as
-- tab1 e tab2 sequencialmente e deste modo os dados finais não estão trazendo as linhas ordenadas
-- pelos valores de qtpopulacao. Podemos ordenar as linhas por qtpopulacao, escrevendo:
select * from tab1 UNION (select * from tab2) order by qtpopulacao;
-- Testamos escrever os comandos de leitura da cada tabela com a mesma ordenação do comando GERAL
-- observa-se que o resultado é o mesmo porém com uma sutil diferença na ordenação.
-- O comando com ordanações parciais fica assim:
(select * from tab1 order by qtpopulacao) UNION (select * from tab2 order by qtpopulacao);
-- Note como ficam os dados após a execução deste comando
---------------------------------------------------------------------------------------------------
-- 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
-- [AR]-Sintaxe.: <tab1> - <tab2>
-- [AR]-Exemplo.: f1 - f2
--          NOTA: Havera um resultado diferente se a ordem das tabelas for invertida.
-- [SQL]-Sintaxe: select * from <tab1> except (select * from <tab2>;
--          Nota: Alguns SGBDs adotam o operador MINUS ao invés de EXCEPT e existem SGBDs que usam
--                os dois operadores.
-- [SQL]-Exemplo: 
select * from tab1 EXCEPT (select * from tab2);
--          Nota: Invertendo as tabelas, percebe-se que altera o resultado.
--                A Intersecção é não comutativa
--                Embora não seja necessário NESSE exemplo a ordenação dos dados pode ser feita:
select * from tab1 EXCEPT (select * from tab2) order by qtpopulacao;
---------------------------------------------------------------------------------------------------
-- Operação.....: Intersecção
-- Definição....: Gera uma lista de linhas de duas tabelas UC, escrevendo na resposta as linhas
--                COMUNS das 2 tabelas.
--          Nota: Esta operação NÃO foi proposta na AR apresentada por Edgard F. Cood, porém desde
--                os primeiros desenvolvimentos da linguagem de implementação da AR, os estudiosos
--                propuseram a operação de intersecção (embora E.F Cood indicou que a intersecção
--                de dois conjuntos A e B (UC) seria obtida por A - (A - B) ).
-- [AR]-Sintaxe.: <tab1> ^ <tab2> - OU <tab1> ∩ <tab2>
-- [AR]-Exemplo.: f1 ^ f2 - OU f1 ∩ f2
--          Nota: O sinal '^' foi adotado inicial na sintaxe da AR, mesmo sendo incompatível com a
--                notação da teoria de conjuntos. Este sinal era mais fácil de ser emitido em
--                editores de texto. Com o aprimoramento dos editores, mais símbolos passaram a
--                estar disponíveis inclusive o "U invertido" da Intersecção. Sendo assim,
--                rapidamente aceito em livros e algoritmos.
-- [SQL]-Sintaxe: select * from <tab1> intersect (select * from <tab2>);
-- [SQL]-Exemplo: 
select * from tab1 INTERSECT (select * from tab2) order by qtpopulacao;
---------------------------------------------------------------------------------------------------
-- 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 "'".
-- [SQL]-Exemplo: 
select * from cores;
-- Fazendo algumas alterações na estrutura da Tabela...
ALTER TABLE IF EXISTS public.cores RENAME nupantone TO nucodhexadec;
ALTER TABLE public.cores ALTER COLUMN nucodhexadec TYPE character(7) COLLATE pg_catalog."default";
COMMENT ON COLUMN public.cores.nucodhexadec IS 'Número com o Código Hexadecimal da cor.';

-- Estes três comandos são comandos de DDL. Sendo que o 'ALTER TABLE...' tem a definição feita desde ANSI:87
-- Já o comando 'COMMNENT' pode apresentar diferenças de implementação entre os SGBDs.

/* - iniciando um bloco de comentário

begin transaction;
INSERT INTO cores (pkcor,txnomecor,nucodhexadec,dtcadcor) VALUES ('11','NavajoWhite','#FFDEAD','2025-09-03');
INSERT INTO cores VALUES 
commit;
rollback;

Terminando o bloco de comentário com */
-- vamos construir o exemplo de comando de INSERT de uma linha na tabela 'autores'
-- Iniciando a transação
BEGIN TRANSACTION;
-- Incluindo a linha em 'autores'
INSERT INTO autores (pkautor,txnomeautor,fklogradouro,txcomplemento,nucep,dtnascimento,dtcadautor)
            VALUES ('30','Luiz Inácio de Loyolla Brandão','50','750 ap. 74','45278542','1960-12-19','2025-09-13');
-- Verificando a condição da tabela
SELECT * FROM autores ORDER BY pkautor;
-- Se a inclusão está correta... pode-se CONCLUIR a transação com:
COMMIT;
-- Entretanto, se algo aconteceu que não deixou a linha corretamente gravada... pode-se CANCELAR com:
ROLLBACK;
-- 
-- Inserindo duas linhas com um comando
-- Iniciando a transação
BEGIN TRANSACTION;
-- Incluindo...
INSERT INTO autores (pkautor,txnomeautor,fklogradouro,txcomplemento,nucep,dtnascimento,dtcadautor)
            VALUES ('60','Almir Gustavo Brandão','150','750 ap. 74','45278542','1960-12-19','2025-09-13'),
         			       ('90','Carlos Tadeu Brandão','250','750 ap. 74','45278542','1960-12-19','2025-09-13');
-- Se a inclusão está correta... pode-se CONCLUIR a transação com:
COMMIT;
-- Entretanto, se algo aconteceu que não deixou a linha corretamente gravada... pode-se CANCELAR com:
ROLLBACK;
-- 
---------------------------------------------------------------------------------------------------
-- Operação.....: Exclusão de linhas
-- Definição....: permite a deleção de linhas de uma tabela.
-- Sintaxe SQL..: delete <tab> WHERE <condição>;
-- [SQL]-Exemplo: 
-- removendo as linhas que foram inseridas nos exemplos de comandos INSERT. Todos oa autores tem
-- nome termiando com 'Brandão'. Note o uso do operador de comparação LIKE.
-- Iniciando a transação
BEGIN TRANSACTION;
-- DELETANDO os registros
delete from autores where txnomeautor like '%brandão';
-- ESTE comando não deleta nenhuma linha pois o tipo de dado do campo (CHARACTER(90)) exige que
-- o operador like compare a procura de Brandão com o sinal de % no final do argumento.
-- ENTRATANTO se alterarmos o tipo de dado do campo para CHARACTER VARYING o comando localiza as
-- linhas corretamente para deletá-las. 
-- Se a exclusão está correta... pode-se CONCLUIR a transação com:
COMMIT;
-- Entretanto, se algo aconteceu que não deixou a linha corretamente gravada... pode-se CANCELAR com:
ROLLBACK;
-- Pode- deletar os mesmo registros com
DELETE FROM autores WHERE pkautor IN ('30','60','90');
-- O Operador 'IN' tem o mesmo efeito do Operador logico 'OU'.
---------------------------------------------------------------------------------------------------
-- 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 ',')
-- [SQL]-Exemplo: 
-- para alterar alguns registros vamos repetir a inclusão e depois trabalhar a alteração sobre os
-- registros incluidos
INSERT INTO autores (pkautor,txnomeautor,fklogradouro,txcomplemento,nucep,dtnascimento,dtcadautor)
            VALUES ('30','Luiz Inácio de Loyolla Brandão','50','750 ap. 74','45278542','1960-12-19','2025-09-13'),
			                ('60','Almir Gustavo Brandão','150','750 ap. 74','45278542','1960-12-19','2025-09-13'),
			                ('90','Carlos Tadeu Brandão','250','750 ap. 74','45278542','1960-12-19','2025-09-13');
-- Quando o PostgreSQL recebe um comando SEM os comandos de tratamento de transação, o SGBD
-- implementa uma TRANSAÇÃO IMPLICITA. Isso é, o SGBD inicia uma transação, executa o comando e se
-- nada ocorreu de errado CONCLUI a transação. Entretanto, em um aplicação que existam dois ou mais
-- comandos que devam ser executados atualizando tabelas distintas em uma banco de dados o cotrole
-- de efetividade de execução PRECISA USAR os comando de inicio, conclusão ou
-- cancelamento de transação.
-- Agora vamos executar os comandos de ALTERAÇÃO
SELECT * FROM autores WHERE pkautor IN ('30','60','90');
-- Iniciando a transação
BEGIN TRANSACTION;
UPDATE autores SET txcomplemento='959 casa 2';
-- o comando acima alterou todas as linhas da tabela autores (errado), então a transação deve ser cancelada
-- consultando a tabela
SELECT * FROM autores;
-- cancelando a transação
ROLLBACK;
-- consultando a tabela
SELECT * FROM autores;
-- Iniciando OUTRA transação
BEGIN TRANSACTION;
-- alterando a tabela. Note o uso do WHERE para 'selecionar' quais linhas são alteradas.
UPDATE autores SET txcomplemento='959 casa 2' WHERE pkautor='60';
-- consultando a tabela
SELECT * FROM autores;
-- Alteração OK! CONCLUIR a transação.
---------------------------------------------------------------------------------------------------
