From 765f27148ac6c70f0db5ff7f1abad427619f5334 Mon Sep 17 00:00:00 2001 From: Rodrigo Eloy Date: Fri, 22 May 2020 11:56:48 -0300 Subject: [PATCH 1/3] =?UTF-8?q?Adicionando=20conte=C3=BAdo=20sobre=20?= =?UTF-8?q?=C3=81lgebra=20Relacional=20da=20disciplina=20Banco=20de=20Dado?= =?UTF-8?q?s=20I?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bd/resumos/algebraRelacional.md | 457 ++++++++++++++++++++++++++++---- 1 file changed, 411 insertions(+), 46 deletions(-) diff --git a/bd/resumos/algebraRelacional.md b/bd/resumos/algebraRelacional.md index e05e07f6..b4398128 100644 --- a/bd/resumos/algebraRelacional.md +++ b/bd/resumos/algebraRelacional.md @@ -1,12 +1,13 @@ --- title: Álgebra Relacional --- +*Seção 8.5 - Fundamentals of DataBase Systems 7th edition.* ## Sumário - - [Álgebra Relacional](#%C3%A1lgebra-relacional) - [Sumário](#sum%C3%A1rio) - [Introdução](#Introduç%C3%A3o) + - [Expressões inline e relações intermediárias](#Expressões-inline-e-relações-intermediárias) - [Relações Unárias](#rela%C3%A7%C3%B5es-un%C3%A1rias) - [SELECT](#select) - [PROJECT](#project) @@ -21,6 +22,12 @@ title: Álgebra Relacional - [EQUIJOIN](#equijoin) - [NATURAL JOIN](#natural-join) - [DIVISION](#division) + - [Relacionais adicionais](#Operações-relacionais-adicionais) + - [GENERALIZED PROJECTION](#Generalized-Projection) + - [AGGREGATE FUNCTION](#Operação-de-funções-de-agregação-e-Agrupamento) + - [RECURSIVE CLOSURE](#Fechamento-Recursivo) + - [OUTER JOiN](#OUTER-JOiN) + - [OUTER UNION](#OUTER-UNION) ## Introdução @@ -39,17 +46,51 @@ Relacionais Adicionais | *OUTER JOINS*, *OUTER UNION* e *AGGREGATE FUNCTIONS* | Todos esses grupos de operações serão descritos a seguir. -## Relações Unárias +--- +## Expressões inline e relações intermediárias +--- + +Todas as operações previamente citadas podem ser escritas como uma única **expressão algébrica relacional(expressões in-line)** ou podem ser escritas com o auxílio de **relações intermediárias**. + +- **Expressão in-line:** + ``` + 𝛑 Name, age, sex(σ age > 18(R)) + ``` + +- **Utilizando relações intermediárias:** + ``` + rel_temp <- σ age > 18(R) + + 𝛑 Name, age, sex(rel_temp) + ``` + +--- +## Relações Unárias +--- ### SELECT -A operação **SELECT** é utilizada para selecionar um subconjunto das tuplas de uma relação. O funcionamento dessa operação se assemelha a um filtro, já que essas tuplas devem satisfazer a condição definida. +Representada pelo símbolo *sigma* (**σ**), a operação **SELECT** é utilizada para selecionar um subconjunto das tuplas de uma relação. O funcionamento dessa operação se assemelha a um filtro, já que essas tuplas devem satisfazer a condição definida. -Esta operação é representada pelo símbolo *sigma* (**σ**) e utiliza a estrutura `σ (R)`. A condição é uma expressão booleana, ou seja, deve retornar *verdadeiro* ou *falso*, de modo que apenas as tuplas que retornam *verdadeiro* para essa condição são selecionadas. *R* é o nome da relação que será filtrada. +O SELECT é estruturado da seguinte forma: -#### Exemplo +``` +σ ( R ) +``` -Para exemplificar, imagine a seguinte relação +Onde: + +- **σ** :Sigma, letra que representa a operação SELECT; +- **:** Expressão booleana que serve para filtrar as tuplas, ou seja, apenas as tuplas que satisfizerem a condição, retornam true, serão selecionadas; +- **(R)**: Relação na qual será feita a filtragem. + +Essa operação possui a propriedade da `Comutatividade`, ou seja: +``` + σ (σ ( R )) == σ (σ ( R )). +``` +#### Exemplos: + +Para todos os próximos exemplos, utilizaremos a seguinte relação **EMPREGADO** @@ -59,9 +100,12 @@ Maria | 15000 | 22 | José | 5000 | 22 | Mario | 13000 | 23 | +#### - Exemplo 01 -Pode-se selecionar os empregados (tuplas) que recebem salário maior que 10000 com a operação *SELECT* usando `σ Salário > 10000 (EMPREGADO)`. Essa operação irá retornar: - +Selecionar empregados cujo salário está acima de 10000 reais. +``` + σ Salário > 10000 (EMPREGADO) +``` **EMPREGADO** @@ -70,16 +114,33 @@ Pode-se selecionar os empregados (tuplas) que recebem salário maior que 10000 c Maria | 15000 | 22 | Mario | 13000 | 23 | -Uma outra operação poderia ser selecionar os empregados que tem 22 anos de idade usando `σ Idade = 22 (EMPREGADO)` e o resultado seria: +**Resultado:** A operação filtrou o empregado "José" já que ele recebe 5000 reais. + +#### - Exemplo 02 + +Selecionar empregados exatamente 22 anos. + +``` + σ Idade = 22 (EMPREGADO) +``` **Nome** | **Salário** | **Idade** | --- | --- | --- | Maria | 15000 | 22 | José | 5000 | 22 | -##### Comutativa +**Resultado:** A operação agora filtrou o empregado "Mario" já que ele tem 23 anos. + +#### - Exemplo 03 + +`Comutatividade`: Selecionar Empregados que tem um salário superior a 10000 reais e tem exatamente 22 anos. +``` + σ Salário > 10000(σ Idade = 22 (EMPREGADO)) + + ou -É possível aninhar diversas condições, no caso, aninhar SELECTS a outro SELECT. Por exemplo, pode-se selecionar os empregados que recebem salário maior que 10000 e que tenham 22 anos de idade. A operação vai ter a forma `σ Salário > 10000(σ Idade = 22 (EMPREGADO))` e resultará em: + σ Idade = 22 (σ Salário > 10000 (EMPREGADO)) +``` **EMPREGADO** @@ -87,25 +148,54 @@ José | 5000 | 22 | :---: | :---: | :---: | Maria | 15000 | 22 | +**Resultado:** A operação filtrou o empregado "Mário", ele ganha mais que 10000 reais, porém não tem 22 anos. O SELECT também filtrou o "José", uma vez que apesar de ter 22 anos ele não ganha mais que 10000 reais + +--- ### PROJECT -Pensando em uma relação como uma tabela, a operação *SELECT* seleciona *linhas* da tabela e descarta as demais. De maneira análoga, a operação **PROJECT** seleciona as *colunas* de uma tabela e descarta as demais. +Representada pelo símbolo do *pi* (**π**), a operação **PROJECT** funciona de forma análoga à operação *SELECT*, todavia, ao invés de selecionar tuplas(linhas), o PROJECT seleciona atributos(colunas). Sendo assim, o resultado dessa operação será uma *relação* contendo todas as tuplas da relação original na sua ordem original, porém apenas com as colunas que foram selecionadas. -A operação *PROJECT* é representada pelo símbolo do *pi* (**π**) e utiliza a estrutura `π (R)`. Na `` coloca-se a lista de colunas da relação que devem ser seleionadas. O resultado dessa operação será uma *relação* contendo todas as tuplas da relação original na mesma ordem, porém apenas com as colunas que selecionadas. +> :warning: **OBS:** Caso a seleção de atributos que não incluam atributos chave (*key*), ou seja, as tuplas poderão ter valores repetidos. Se isso ocorrer, a operação removerá automaticamente as tuplas repetidas. Isso não acontece no SQL, a operação análoga ao PROJECT mantém as tuplas repetidas. -#### Exemplo +O PROJECT utiliza a seguinte estrutura: -Dada a relação EMPREGADO utilizada previamente, serão selecionados apenas o nome e o salário dos empregados através de `π Nome, Salário (EMPREGADO)`. O resultado será: +``` +π ( R ) +``` + +Onde: +- **π:** PI, letra que representa a operação PROJECT; +- <**atributos**>: Lista de atributos (colunas) que estarão presentes na nova relação criada; +- **(R):** Relação na qual será feita a operação. + + +#### Exemplos: + +#### - Exemplo 01 + +Selecionar apenas o nome e salário dos empregados: + +``` + π Nome, Salário (EMPREGADO) +``` **EMPREGADO** **Nome** | **Salário** | ---- | --- | -Maria | 15000 | -José | 5000 | -Mario | 13000 | +--- | --- | +Maria | 15000 | +José | 5000 | +Mario | 13000 | + +**Resultado:** Uma nova relação empregado que possui apenas o nome e salário dos funcionários. + +#### - Exemplo 02 -Uma possível situação é a seleção de atributos que não incluam atributos chave (*key*), ou seja, as tuplas poderão ter valores repetidos. Se isso ocorrer, a operação removerá automaticamente as tuplas repetidas. Se fosse realizada a operação `π Idade (EMPREGADO)`, dado que Maria e José tem a mesma idade, a operação iria mostrar apenas uma tupla com valor *22* na idade, conforme apresentado abaixo. +Selecionar apenas a idade dos empregados: + +``` + π Idade (EMPREGADO) +``` **EMPREGADO** @@ -114,6 +204,9 @@ Uma possível situação é a seleção de atributos que não incluam atributos | 22 | | 23 | +**Resultado:** Dado que Maria e José tem a mesma idade, a operação mostrou apenas uma tupla com valor *22* na idade, já que a relação resultante da retirada dos nomes e salários possuiria duas tuplas repetidas, o que não é permitido pela álgebra relacional. + +--- ### RENAME É comum deparar-se com situações em que se precisa aplicar várias operações em sequência e, devido ao aninhamento desses vários passos, o código escrito pode tornar-se confuso. Para solurcionar esse problema, utiliza-se a operação **RENAME**. @@ -154,19 +247,14 @@ José | 5000 | **PS:** Em SQL, a operação *RENAME* é chamada de **ALIAS** (*AS*). +--- ## Teoria dos Conjuntos As operações desse grupo são aquelas também usadas na teoria dos conjuntos. -### UNION - -É uma operação binária, ou seja, aplicada a dois e somente dois conjuntos de tuplas que resulta em uma união de relações. As duas relações nessa operação devem ser compatíveis, ou seja, devem ter o mesmo número de atributos e esses atributos devem ser do mesmo tipo. +#### Exemplos: -Essa operação é representada por **∪**. - -#### Exemplo - -Imagine duas relações, **ESTUDANTE** e **INSTRUTOR** que devem ser unidas. Tem-se: +As duas relações a seguir, ESTUDANTE e INSTRUTOR, serão utilizadas nos próximos exemplos de Teoria dos Conjuntos. **ESTUDANTE** @@ -184,6 +272,18 @@ Maria | Alves | Carla | Yun | Mario | Olivedos | +--- +### UNION + +A operação de união junta as tuplas de uma relação R com as tuplas de uma relação S e cria uma nova relação `R ⋃ S`, onde não há tuplas duplicadas. As duas relações nessa operação devem ser compatíveis, ou seja, devem ter o mesmo número de atributos e esses atributos devem ser do mesmo tipo e domínio. + +Essa operação é representada por **∪** e possui as seguintes propriedades: + +- **Comutatividade:** R ⋃ S == S ⋃ R +- **Associatividade:** (R ⋃ S) ⋃ T == R ⋃ (S ⋃ T) + +#### Exemplo + Dado `ESTUDANTE ∪ INSTRUTOR `, tem-se: **Primeiro Nome**| **Último Nome** | @@ -193,14 +293,20 @@ José | Sousa | Mario | Olivedos | Carla | Yun | -Note que as tuplas repetidas foram removidas, gerando apenas valores únicos. +> Note que as tuplas repetidas foram removidas, gerando apenas valores únicos. +--- ### INTERSECTION Diferente da operação anterior, na **INTERSECTION** a operação irá incluir apenas as tuplas que estão em ambas as relações. Essa operação possui os mesmos requisitos da UNION, ou seja, as relações devem ter o mesmo número de atributos e esses atributos devem ser do mesmo tipo. Esta operação é representada por **∩** e utiliza a estrutura `R ∩ S`. Os atributos que estão na relação resultante terão os mesmos nomes dos atributos da relação *R*. +Essa operação possui as seguintes propriedades: + +- **Comutatividade** R ⋂ S == S ⋂ R +- **Associatividade** (R ⋂ S) ⋂ T == R ⋂ (S ⋂ T) + #### Exemplo Aplicando `ESTUDANTE ∩ INSTRUTOR`, tem-se: @@ -210,7 +316,8 @@ Aplicando `ESTUDANTE ∩ INSTRUTOR`, tem-se: Maria | Alves | Mario | Olivedos | -### DIFFERENCE +--- +### DIFFERENCE ou MINUS Também conhecida como *minus* ou *except*, esta é uma operação de exclusão e utiliza a estrutura `R - S`, resultando numa nova relação com todas as tuplas que estão em **R**, mas não em **S**. @@ -224,34 +331,65 @@ Aplicando `ESTUDANTE - INSTRUTOR`, o resultado será: --- | --- | José | Sousa | +--- ### CARTESIAN PRODUCT -Essa operação binária irá combinar todos os atributos e valores das duas relações envolvidas. Não há requisitos de compatibilidade de atributos. +Essa operação `R X S` produz uma nova relação Z formada pela combinação de todas as tuplas de R com as tuplas de S, resultando na relação Z que possui a quantidade de colunas de R somada a quantidade de colunas de S, ou seja, para `R(A1, A2, ... , An) × S(B1, B2, ... , Bn)`, o resultado será `Q(A1, A2, ... , An, B1, B2, ... , Bn)`. + +Essa operação é representada da seguinte forma: + +``` +Z <- R X S +``` + +Onde: +- **X:** Símbolo que representa a operação de produto cartesiano; +- **Z:** Relação produzida a partir do produto cartesiano; +- **R e S:** RElações participantes da operação. + +**n° tuplas:** n° tuplas de R * n° tuplas de S; + +**Ordem:** n° atributos de R + n° atributos de S. -Denotada por **×** e utilizando a estrutura `R × S`, essa operação resultará em uma combinação de todos os valores de cada tupla. Para `R(A1, A2, ... , An) × S(B1, B2, ... , Bn)`, o resultado será `Q(A1, A2, ... , An, B1, B2, ... , Bn)`. +> :warning: **OBS:** O produto cartesiano por si só *não* traz conhecimento **real** por si só, sendo necessária à utilização do SELECT, por exemplo, para filtrar os dados que podem ter algum significado. #### Exemplo Para `ESTUDANTE × INSTRUTOR`, tem-se: **ESTUDANTE.Primeiro Nome** | **ESTUDANTE.Último Nome** | **INSTRUTOR.Primeiro Nome** | **INSTRUTOR.Último Nome** | ---- | --- | --- | --- | -Maria | Alves | Maria | Alves | -Maria | Alves | Carla | Yun | -José | Sousa | Maria | Alves | -José | Sousa | Carla | Yun | -Maria | Alves | Maria | Alves | -Maria | Alves | José | Sousa | -Carla | Yun | Maria | Alves | -Carla | Yun | José | Sousa | +--- | --- | --- | --- | +Maria | Alves | Maria | Alves | +Maria | Alves | Carla | Yun | +Maria | Alves | Mario | Olivedos | +José | Sousa | Maria | Alves | +José | Sousa | Carla | Yun | +José | Sousa | Mario | Olivedos | +Carla | Yun | Maria | Alves | +Carla | Yun | José | Sousa | +Carla | Yun | Mario | Olivedos | +--- ## Relacionais Binárias - +--- ### JOIN Muito utilizada em bancos relacionais que possuem mais de uma relação e em que se faz necessário realizar operações que envolvam tuplas relacionadas de tabelas diferentes. A operação de **JOIN** funciona de maneira semelhante a um [SELECT](#select) seguido de um [CARTESIAN PRODUCT](#cartesian-product). -Essa operação é representada pelo símbolo **⋈** e utiliza a estrutura `R ⋈ S`. +Essa operação é representada da seguinte maneira: + +``` +DEPARTMENT ⋈ Mgr_ssn = Ssn EMPLOYEE +``` + +Onde: +- **⋈:** Símbolo que representa a operação de JOIN; +- **Mgr_ssn = Ssn:** Condição de seleção; +- **Department e employee:** Relações sobre as quais a operação será feita. + +**n° tuplas:** desde n° tuplas de R * n° tuplas tuplas S até 0, caso a *condição* imposta nunca seja satisfeita. + +**Ordem:** n° atributos de R + n° atributos atributos de S. #### Exemplo @@ -279,13 +417,31 @@ Para `DEPARTAMENTO ⋈ CPF_do_chefe = CPF EMPREGADO`, tem-se: 123.456.123-21 | Departamento X | Maria | 15000 | 22 | 789.392.858-56 | Departamento Y | Mario | 13000 | 23 | +--- #### EQUIJOIN Ocorre de maneira análoga ao JOIN, porém o operador da seleção é automaticamente um **=**. +> **OBS:** Como a condição de seleção é uma **=** o EQUIJOIN resulta em colunas repetidas, uma vez que ele não apaga colunas iguais. + +--- #### NATURAL JOIN -Denotada por `*`, essa operação junta duas relações com base em seus atributos, removendo repetições daqueles com nomes coincidentes. +Denotada por `*`, essa operação foi criada para excluir colunas repetidas ao se fazer um [EQUIJOIN](#equijoin). + +Essa operação se organiza da seguinte maneira: + +``` +NOVA_REL <- R * S +``` + +Onde: +- **NOVA_REL:** Relação resultante; +- **R e S:** Relações sobre as quais a operação será realzada; +- *: Símblo da operação natural join; +- <**condição1 AND condição2**>: Condições que ditarão como será feita a seleção das tuplas , chamado de `THETA_JOIN`. + +> :warning: **OBS:** Para que essa operação funcione é necessário que o nome dos atributos que vão ser comparados sejam iguais. ##### Exemplo @@ -293,11 +449,33 @@ Denotada por `*`, essa operação junta duas relações com base em seus atribut A condição de junção ímplicita é *R.A* = *S.A* e o resultado será `Q(A, B, C, D, E)`. +--- ### DIVISION -A operação **DIVISION** é denotada por **÷** e utiliza a estrutura `R(Z) ÷ S(X)`, indicando que se deseja as tuplas de *R* que contém todos os subconjuntos de *S*. +A operação R ÷ S funciona da seguinte maneira. sendo o conjunto de atributos de S um subconjunto dos atributos de R, R ÷ S pega todos os valores das tuplas de R que se conseguem abranger TODAS as tuplas de S e cria uma nova relação a partir disso. -#### Exemplo +#### Exemplo 01 + +FUNCIONÁRIO +| Nome | Proj_n | SSN | +| --- | --- | --- | +| regis | 1 | 1234 | +| regis | 2 | 1234 | +| Bia | 1 | 7410 | +| Bia | 3 | 7410 | + +PROJETOS +| Proj_n | +| --- | +| 1 | +| 2 | + +FUNCIONÁRIO ÷ PROJETOS +| Nome | SSN | +| --- | --- | +| Regis | 1234 | + +#### Exemplo 02 Imagine as relações **R** e **S**, tal que se deseja selecionar as tuplas de **R** que incluem todos os valores de **A** que estejam na tabela **S**. @@ -330,3 +508,190 @@ Para `RESULTADO ← R(Z) ÷ S(X) `, tem-se: | :---: | | b1 | | b2 | + +--- +## Operações relacionais adicionais +--- +São operações que realizam tarefas que as operações *originais* não conseguem resolver para a SGBDR (Sistema de gerenciamento de banco de dados Relacional) + +A relação a seguir será utilizada nos próximos exemplos. + +PESSOA + +| Nome | Salário | Netflix | Aluguel | +| --- | --- | --- | --- | +| José | 7000 | 22 | 2000 | +| Rodrigo | 8000 | 22 | 2500 | +| Evaristo | 34000 | 46 | 4000 | +| Joseana | 40000 | 46 | 5000 | + +--- +### **Generalized Projection** +A Generalized Projection (Projeção Generalizada) estende a operação [PROJECT](#PROJECT), permitindo que a lista de atributos selecionados incluam operações feitas sobre os atributos. + +Essa operação é estruturada da seguinte forma: + +``` +π (R) +``` + +Onde: +- **π:** Símbolo da operação PROJECT; +- **f1, f2, ..., fn:** Funções sobre os atributos da relação, podendo ser operações aritméticas ou valores constantes; +- **(R:)** Relação sobre a qual a operação será realizada. + +> :warning: **Atenção:** O nome dos atributos criados a partir das funções pode ficar sem sentido, por isso normalmente se utiliza a operação de [Rename](#rename) para complementar essa operação. + +**Exemplo:** + +Selecionar Nome, salário e a despesa totais, que é formada pela soma do preço da Netflix e dp aluguel: + +``` +RELACAO <- ρ(Nome, salário, despesas) (π Nome, Salário, Netflix + Aluguel (PESSOA)) +``` + +RELACAO +| Nome | Salário | despesas | +| --- | --- | --- | +| José | 7000 | 2022 | +| Rodrigo | 8000 | 2522 | +| Evaristo | 34000 | 4046 | +| Joseana | 40000 | 5046 | + +--- +### **Aggregate Functions and Grouping** +A operação de funções de agregação é uma operação que permite a utilização de [`Funções de agregação`](https://www.devmedia.com.br/sql-funcoes-de-agregacao/38463), funções essas que servem para sumarizar informações a partir de um conjunto de tuplas da base de dados, assim como permite o `agrupamento` de tuplas a partir dos valores de atributos especificados é outra necessidade. + +Essa operação se estrutura da seguinte maneira: + +``` +<`grouping attributes`> I (R) +``` + +Onde: +- <**grouping attributes**>: Atributos que servirão para fazer o agrupamento; +- **I:** Símbolo da operação de Funçoẽs de agregação; +- <**function list**>: Lista de tuplas (<`função`><`atributo`>), onde `função` é uma das funções permitidas (como SUM, AVERAGE, MAXIMUM, MINIMUM, COUNT) e `Atributo` é o atributo sobre o qual a função vai ser operada; +- **(R):** Relação sobre a qual ocorrerá a operação. + +> :warning: **OBS:** Caso a operação SELECT não seja utilizada em seguida, os nomes dos atributos criados na nova relação será uma concatenação `função_atributo`. + +**Exemplo:** + +Criar uma relação que seleciona a quantidade dos diferentes tipos preços da netflix e o salário médio das pessoas pra cada preço da netflix. + +``` + R <- ρ(Netflix, num_contas, sal_medio) (π Netflix, COUNT Netflix, AVERAGE salário (PESSOA)) +``` +R +| Netflix | num_contas | sal_medio | +| --- | --- | --- | +| 22 | 2 | 7500 | +| 46 | 2 | 37000 | + + +--- +### **Recursive Closure** + +O fechamento recursivo é uma operação em que existe um **relacionamento recursivo** entre as tuplas da mesma relação, como empregado e supervisor por exemplo. + +> :warning: **OBS:** Essa operação não é possível de ser implementada com operações básicas da álgebra realacional, todavia, é implementada na linguagem [`SQL`(colocar o link para o resumo de SQL)](). + +**Ex:** + +Caso seja requisitado os ids de todos os funcionários que estejam sendo supervisionados pelo funcionário X, ou por aqueles que ele supervisiona. Será necessário acessar os supervisionados do X, depois os supervisionados dos supervisionados de X e assim em diante. + +--- +### **OUTER JOiN** + +A operação `outer join` possui o mesmo princípio de um [`join`](#join) comum, todavia, ao fazer o "matching" das duas relações ela não descarta as tuplas que não possuem par, ao invés disso, associa essas tuplas a valores *NULL*. + +Essa operação é estruturada da seguinte forma: + +``` +DEPARTMENT ⋈ Mgr_ssn = Ssn EMPLOYEE +``` + +> obs: O símbolo acima possui perninhas dependendo do tipo, mas não achei do tamanho correto + +O outer join pode ser dividido em 3 variasções: + +- **LEFT OUTER JOIN:** As tuplas da relação à esquerda que não possuem par são associados a valores *NULL*, enquanto as tuplas que não possuem par na relação a direito são descartadas; + +- **RIGHT OUTER JOIN:** Mesma ideia do `left outer join`, porém, nesse caso as tuplas da relação à direita que não possuem par são associados a valores *NULL*, enquanto as tuplas que não possuem par na relação a esquerda são descartadas; + +- **FULL OUTER JOIN** Tanto as tuplas da relação a direita, quanto as tuplas da relação a esquerda que não possuirem um par quando for realizada a operação de `join` são associados a valores *NULL*. + +**Exemplos:** + +A relação a seguir será utilizada nos próximos exemplos: +EMPREGADO +| nome | id_dept | +| --- | --- | +| Josenildo | 1 | +| Joselanda | 2 | +| Joana | 1 | +| Jefferson | 4 | + +DEPARTAMENTO +| id | nome_dep | +| --- | --- | +| 1 | Administração | +| 2 | Financeiro | +| 3 | Marketing | + +**Exemplo 01 - LEFT OUTER JOIN** + +``` +REL <- π nome, id_dept, nome_dep (EMPREGADO ⋈ id_dept = id DEPARTAMENTO) +``` +REL +| nome | id_dept | nome_dep | +| --- | --- | --- | +| Josenildo | 1 | Administração | +| Joselanda | 2 | Financeiro | +| Joana | 1 | Administração | +| Jefferson | 4 | NULL | + +**Exemplo 02 - RIGHT OUTER JOIN** + +``` +REL <- π nome, id, nome_dep (EMPREGADO ⋈ id_dept = id DEPARTAMENTO) +``` + +REL +| nome | id | nome_dep | +| --- | --- | --- | +| Josenildo | 1 | Administração | +| Joselanda | 2 | Financeiro | +| Joana | 1 | Administração | +| NULL | 3 | marketing | + +**Exemplo 03 - FULL OUTER JOIN** + +``` +REL <- π nome, id, nome_dep (EMPREGADO ⋈ id_dept = id DEPARTAMENTO) +``` + +REL +| nome | id | nome_dep | +| --- | --- | --- | +| Josenildo | 1 | Administração | +| Joselanda | 2 | Financeiro | +| Joana | 1 | Administração | +| NULL | 3 | marketing | +| Jefferson | 4 | NULL | + +--- +### **OUTER UNION** + +Essa operação é a mesma do `FULL OUTER JOIN`. Sendo: + +- R(nome, id, dep) +- S(id_dept, nome_dept) + +REL <- R ⋃* S gera a seguinte relação: + +> REL(nome, id, dep, nome_dept) + +Onde, assim como no [`FULL OUTER JOIN`](#outer-join), as tuplas que não tinham par são associadas a valores *NULL*. From 56bde2f0c363c50b6f47fb8aedb9cd30ac4d88a4 Mon Sep 17 00:00:00 2001 From: Rodrigo Eloy Date: Sun, 24 May 2020 14:35:31 -0300 Subject: [PATCH 2/3] =?UTF-8?q?Adicionando=20resumo=20sobre=20C=C3=A1lculo?= =?UTF-8?q?=20Relacional?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- bd/resumos/calculoRelacional.md | 262 ++++++++++++++++++++++++++++++++ 1 file changed, 262 insertions(+) create mode 100644 bd/resumos/calculoRelacional.md diff --git a/bd/resumos/calculoRelacional.md b/bd/resumos/calculoRelacional.md new file mode 100644 index 00000000..55718c3f --- /dev/null +++ b/bd/resumos/calculoRelacional.md @@ -0,0 +1,262 @@ +# Cálculo Relacional +*Seções 8.6 - 8.7 - Fundamentals of DataBase Systems 7th edition.* + +## ìndice +- [Introdução](#introdução) +- [Cálculo Relacional de Tuplas](#cálculo-relacional-de-tuplas) + - [Expressões e fórmulas](#Expressões-e-fórmulas) + - [Quantificadores Universais e existenciais](#quantificadores) +- [Cálculo Relacional de domínio](#Cálculo-relacional-de-domínio) + - [Expressões e fórmulas](#outras-expressões-e-fórmulas) +--- +## Introdução + +### Cálculo relacional vs Álgebra relacional: + +| Cálculo Relacional | Álgebra Relacional | +| --- | --- | +| Não-procedimental | Procedimental | +| Poder de expressão | Poder de expressão | + +- **Linguagens não-procedimentais:** São linguagens que possuem expressões apenas `declarativas`, ou seja, expressões que focam apenas em informar qual o resultado esperado da requisição e não como que essa requisição deve acontecer. A álgebra relacional por ser uma `procedimental` especifica uma *sequência* na qual as operações devem ser realizadas. + +- **Poder de expressão:** O poder de expressão é o universo de todos os tipos de requisições que podem ser realizados pela linguagem. O cálculo e álgebra relacionais possuem o **mesmo** Poder de expressão. + +O cálculo relacional é a `base da Lógica Matemática` das linguagens de consulta como SQL, dessa maneira, linguagens que realiza quaisquer requisições que o cálculo relacional consegue fazer é chamada de **Linguagem Relacionalmente Completa**. + +> **OBS:** Como foi dito anteriormente, o Cálculo Relacional é a *base*, dessa forma, existem linguagens que possuem um `poder de expressão` ainda maior do que o cálculo relacional. + +Existem dois tipos de cálculos relacionais, o `cálculo relacional de tuplas` e o `cálculo relacional de Domínio`: + +--- +## Cálculo Relacional de tuplas + +O cálculo relacional de tuplas se baseia em especificar *variáveis*, que são tuplas de uma relação, onde a variável pode assumir qualquer valor da `amplitude relacional`, ou seja, ela pode assumir a forma de qualquer tupla da relação em que ela se encontra. + +A resposta da requisição é um conjunto de tuplas que `satisfazem` a condição imposta, ou seja, tuplas que sob a condição previamente determinada resultam no valor booleano TRUE. + +### **Expressões e fórmulas** + +Toda expressão do cálculo relacional de tuplas é estruturada da seguinte forma: + +``` +{T.A1, T.A2...T.An | Cond(T)} +``` + +Onde: +- `T` Variável T que assume a forma de todas as tuplas da relação; +- `A1, A2 e An` são os atributos de T1 e T2, respectivamente, que serão retornados como resposta +- `Cond(T)` é a condição envolvendo T que será julgada como verdadeira ou falsa. + +A condição (Cond(T)) pode ser de três tipos: + +- **R(T):** tuplas T que pertencerem a `amplitude relacional` de R serão avaliadas com *TRUE*, caso contrário como *FALSE*. + + **Ex:** Retornar nome e matrícula de pessoas que são estudantes. + ``` + {p.name, p.matricula | ESTUDANTE(p)} + ``` +- **t1.A oc t2.B:** Sendo "oc" um `operador de comparação`{=, <, ≤, >, ≥, ≠}. Essa condição retorna *TRUE* caso os dois atributos (A e B) satisfaçam a expressão, caso contrário, o valor *FALSE* é retornado. + + **Ex:** ID dos empregados que recebem mais do que 50000 reais. + ``` + {e.id | EMPREGADO(e) AND e.salario > 50000} + ``` +- **t1.A oc const. *OR* const. oc t2.B:** Sendo "oc" um `operador de comparação`{=, <, ≤, >, ≥, ≠}. Essa condição retorna *TRUE* caso algum dos dois atributos (A ou B) satisfaçam a expressão, caso contrário, o valor *FALSE* é retornado. + + **Ex:** ID dos empregados que recebem mais de 30000 reais ou menos de 1000 reais. + ``` + {e.id | EMPREGADO(e) AND (e.salario > 30000 OR e.salario < 1000)} + ``` + +#### Exemplos: + +Para os próximos exemplos considere a seguinte relação: + +FUNCIONÁRIO +| Nome | Id | Dept | Salário | +| --- | --- | --- | --- | +| Rodrigo | 3 | 1 | 5000 | +| Leandra | 2 | 1 | 5000 | +| Matheus | 4 | 1 | 7000 | +| Ana | 1 | 4 | 3000 | +| Carolyn | 0 | 2 | 10000 | + +#### Exemplo 01 + +Retornar o nome e id de todos os funcionários que trabalham no departamento 1. +``` + FUNC_DEPT1 <- {f.Nome, f.Id | FUNCIONÁRIO(f) AND Dept = 1} +``` + +FUNC_DEPT1 +| Nome | Id | Dept | Salário | +| --- | --- | --- | --- | +| Rodrigo | 3 | 1 | 5000 | +| Leandra | 2 | 1 | 5000 | +| Matheus | 4 | 1 | 7000 | + +#### Exemplo 02 + +Retornar o id e salário dos funcionários que recebem 5 mil ou 7 mil reais. +``` + SAL <- {f.Id, f.Salário | FUNCIONÁRIO(f) AND (f.Salário = 5000 OR f.Salário = 7000)} +``` + +SAL +| Nome | Id | Dept | Salário | +| --- | --- | --- | --- | +| Rodrigo | 3 | 1 | 5000 | +| Leandra | 2 | 1 | 5000 | +| Carolyn | 0 | 2 | 10000 | + +--- +### **Quantificadores** + +Existem dois tipos de quantificadores: + +- **Quantificador universal (∀t):** Em uma fórmula F, (∀t)(F) significa que a fórmula precisa ser verdade para **TODAS** as tuplas para que ela seja avaliada como *TRUE*, caso exista pelo menos uma tupla que não se encaixe ela é avaliada como *FALSE*. + +- **Quantificador existencial(∃t):** Em uma fórmula F, (∃t)(F) é avaliado como *TRUE* caso existe pelo menos uma tupla que satisfaça a fórmula, caso contrário, ela é avaliada como *FALSE*. + +E quando falamos de quantificadores nós podemos falar de dois tipos de variáveis: + +- **Variáveis livres:** São variáveis que não estão atreladas a nenhum quantificador; +- **Variáveis ligadas:** São as variáveis que são atreladas a um quantificador. + +#### Exemplos: +Para os próximos exemplos considere as seguintes relações: + +PROFESSOR +| Nome | id | id_disciplina | +| --- | --- | --- | +| Tiago | 45 | 101 | +| Dalton | 43 | 105 | +| Joseana | 63 | 103 | +| Elmar | 20 | 103 | +| Patrícia | 64 | 102 | + +DISCIPLINA +| Nome | id | andar | +| --- | --- | --- | +| Lógica | 101 | 1 | +| Grafos | 102 | 2 | +| LOAC | 103 | 1 | +| Cálculo | 104 | 4 | +| PSoft | 105 | 2 | + +#### Exemplo 01 + +Nome e id de todos os professores que lecionam em uma disciplinas do andar 2 +``` + PROFS_ANDAR2 <- {t.name, t.id | PROFESSOR(t) AND (∃w)(DISCIPLINA(w) AND t.id_disciplina = w.id AND w.andar = 2)} + + ou + + PROFS_ANDAR2 <- {t.name, t.id | PROFESSOR(t) AND (NOT (∀w)(NOT(DISCIPLINA(w)) OR NOT(t.id_disciplina = w.id) OR + NOT(w.andar=2))} +``` +> t é uma variável `livre` e w é uma variável `ligada`. + +PROFS_ANDAR2 +| Nome | id | +| --- | --- | +| Dalton | 43 | +| Patrícia | 64 | + +#### Exemplo 02 + +Nome e id da disciplina que não possui professor + +``` + DISCIPLINAS_SEM_PROF <- {d.Nome, d.id | DISCIPLINA(d) AND (NOT (∃p)(PROFESSOR(p) AND w.id = p.id_disciplina))} + + ou + + DISCIPLINAS_SEM_PROF <- {d.Nome, d.id | DISCIPLINA(d) AND (∀p)(NOT(PROFESSOR(p)) OR NOT(w.id = p.id_disciplina))} +``` + +DISCIPLINAS_SEM_PROF +| Nome | id | +| --- | --- | +| Cálculo | 104 | + +--- +## Cálculo relacional de domínio + +A diferença principal desse cálculo relacional para o de tuplas é o tipo de variável. No cálculo relacional de domínio as variáveis, agora chamadas de `variáveis de domínio`, são os **atributos**. + + +### Outras expressões e fórmulas +As fórmulas do Cálculo relacional de domínio se estruturam da seguinte forma: +``` + {x1, x2, ... , xn | Cond(x1, x2, ..., xn, xn+1, xn+2, xn+m )} +``` + +Onde: +- **x1...xn+m:** São os variáveis de domínio; +- **Cond:** Condição que envolvem os atributos e que serão avaliadas como *TRUE* ou *FALSE*. + +Assim como no cálculo relacional de tuplas, a *Cond* pode ser de 3 tipos: + +- **R(x1, x2, ..., xj):** Sendo R o nome da relação de grau j e (x1, x2, ... , xj) `todos` os atributos de R. Essa condição implica que cada uma dessas variáveis de domínio representa algum dos atributos da relação R. + + **Ex:** Retornar o nome e id de todas as pessoas que pertencem a relação EMPLOYEE. + ``` + {v, u | EMPLOYEE(vumnop)} + ``` + +- **x1 oc x2:** Sendo oc um `operador de comparação`, essa condição compara duas variáveis de domínio(atributos). + + **Ex:** Retornar nome e id de todos os empregados que ganham mais de 50000 reais. + ``` + {v, u | EMPLOYEE(vumnop) AND p > 50000} + ``` + +- **x1 oc k *OR* k oc x2:** Sendo oc um `operador de comparação` e k uma `constante` qualquer, essa condição compara duas variáveis de domínio com uma constante. + + **Ex:** Retornar o nome e id de todos os funcionários que ganham mais de 4000 reais ou menos de 1000 reais. + ``` + {v, u | (∃m)(∃n)(∃o)(∃p) ∃EMPLOYEE(vumnop) AND (p > 4000 OR p < 1000)} + ``` + +#### Exemplos: + +Para os seguintes exemplos considere as seguintes relações: + +PIZZA +| Sabor | preço | Tamanho | +| --- | --- | --- | +| Frango com catupiry | 59,90 | GG | +| Pepperoni | 49,90 | M | +| Aliche | 39,90 | M | +| Brigadeiro | 59,90 | GG | +| Quatro queijos | 59,90 | GG | + +#### Exemplo 01 + +Quero o nome de todas as pizzas que tenham o tamanho GG! + +``` + GULOSO <- {s | PIZZA(spt) AND t = GG} +``` + +GULOSO +| s | +| --- | +| Frango com catupiry | +| Brigadeiro | +| Quatro queijos | + +#### Exemplo 02 + +Quero o nome e preço de todas as pizzas que sejam com o preço limite de 50 reais. + +``` + PRECO_LIMITADO <- {s, b | PIZZA(spt) AND p < 50} +``` +PRECO_LIMTIADO +| s | b | +| --- | --- | +| Pepperoni | 49,90 | +| Aliche | 39,90 | From f14a6f4893ed2d5627fca7aac3fe58df16d1e956 Mon Sep 17 00:00:00 2001 From: Lucas de Medeiros Date: Sun, 2 Aug 2020 19:27:12 -0300 Subject: [PATCH 3/3] Update algebraRelacional.md --- bd/resumos/algebraRelacional.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/bd/resumos/algebraRelacional.md b/bd/resumos/algebraRelacional.md index b4398128..d29043d9 100644 --- a/bd/resumos/algebraRelacional.md +++ b/bd/resumos/algebraRelacional.md @@ -26,7 +26,7 @@ title: Álgebra Relacional - [GENERALIZED PROJECTION](#Generalized-Projection) - [AGGREGATE FUNCTION](#Operação-de-funções-de-agregação-e-Agrupamento) - [RECURSIVE CLOSURE](#Fechamento-Recursivo) - - [OUTER JOiN](#OUTER-JOiN) + - [OUTER JOIN](#OUTER-JOIN) - [OUTER UNION](#OUTER-UNION) ## Introdução @@ -602,7 +602,7 @@ O fechamento recursivo é uma operação em que existe um **relacionamento recur Caso seja requisitado os ids de todos os funcionários que estejam sendo supervisionados pelo funcionário X, ou por aqueles que ele supervisiona. Será necessário acessar os supervisionados do X, depois os supervisionados dos supervisionados de X e assim em diante. --- -### **OUTER JOiN** +### **OUTER JOIN** A operação `outer join` possui o mesmo princípio de um [`join`](#join) comum, todavia, ao fazer o "matching" das duas relações ela não descarta as tuplas que não possuem par, ao invés disso, associa essas tuplas a valores *NULL*.