universidade federal de santa catarina - Projetos

UNIVERSIDADE FEDERAL DE SANTA CATARINA
CENTRO TECNOLÓGICO
DEPARTAMENTO DE INFORMÁTICA E ESTATÍSTICA
Curso de Bacharelado em Ciências da Computação
Autor: Ederson Luiz Paes
Responsável: Fábio Teixeira de Campos
Orientador: Fábio Teixeira de Campos
FERRAMENTA DIDÁTICA PARA O ENSINO DE ÁLGEBRA RELACIONAL
Trabalho apresentado à disciplina
Projeto I em Ciências da Computação,
como requisito de avaliação orientado pelo professor
Renato Cislaghi
Florianópolis
20051
Sumário
1. Fundamentação Teórica................................................................................. 3
1.1. Álgebra Relacional ................................................................................ 3
1.1.1. Operação Seleção .............................................................................. 3
1.1.2. Operação Projeção............................................................................. 4
1.1.3. Operação União ................................................................................. 4
1.1.4. Operação Diferença entre Conjuntos ................................................. 4
1.1.5. Operação Produto Cartesiano ............................................................ 5
1.1.6. Operação Renomeação ..................................................................... 5
1.1.7. Operação de Interseção ..................................................................... 5
1.1.8. Operação Junção ............................................................................... 6
1.1.9. Operação Junção Natural................................................................... 6
1.1.10. Operação Divisão ............................................................................. 6
1.2. Visões.................................................................................................... 7
1.3. SQL ....................................................................................................... 7
1.3.1. As partes da linguagem SQL .............................................................. 8
1.3.2. A Linguagem de Definição de Dados (SQL-DDL) .............................. 9
1.3.2. Linguagem de Manipulação de Dados - DML .................................. 11
1.4. Linguagens Formais e Compiladores ................................................. 13
1.4.1. Analisador Léxico ............................................................................. 14
1.4.2. Analisador Sintático .......................................................................... 14
1.4.3. Analisador Semântico....................................................................... 15
2. Ferramenta Didática para o Ensino de Álgebra Relacional .......................... 16
2.1. Desenvolvimento do Compilador ......................................................... 16
2.2. Desenvolvimento da Ferramenta de Manipulação de Relações e
Tuplas. 17
2.3. Desenvolvimento da Interface com o Usuário ..................................... 18
2.4. Integração dos Módulos do Sistema ................................................... 19
2.5. Realização de Testes .......................................................................... 19
3. Referência Bibliográfica ............................................................................... 20
2
1. Fundamentação Teórica
1.1. Álgebra Relacional
A álgebra relacional é uma linguagem de consultas procedural. Consiste em
um conjunto de operações tendo como operando uma ou duas relações e
produzindo, como resultado, uma nova relação. As operações fundamentais na
álgebra relacional são seleção, projeção, união, diferença, produto cartesiano.
Além dessas operações fundamentais existem algumas outras operações –
renomeação, interseção, junção natural, divisão, e atribuição, que são definidas
em termos das operações fundamentais.
As operações seleção, projeção e renomeação são chamadas de operações
unárias, pois operam uma única relação. As outras três operações
fundamentais operam um par de relações e são portanto chamadas de
operações binárias.
1.1.1. Operação Seleção
A operação seleção retorna um subconjunto de tuplas que satisfaçam um
determinado predicado, usando a letra grega sigma () para denotar seleção.
O predicado aparece subscrito a . O argumento da relação é dado entre
parênteses, seguindo o predicado.
3
1.1.2. Operação Projeção
A operação projeção é usada para obter determinados atributos de uma
relação. A operação é executada em apenas uma relação e o resultado é uma
nova relação contendo apenas os atributos especificados, eliminando-se as
eventuais duplicidades entre as tuplas. É denotada pela letra grega pi () e são
listados, subscritos em , os atributos exibidos no resultado. O argumento da
relação vem a seguir entre parênteses.
1.1.3. Operação União
A operação de união cria uma relação partindo de outras duas, levando as
tuplas comuns e não-comuns a ambas. Desta forma aparecerão no resultado
somente linhas únicas de uma ou outra relação e as informações duplicadas
aparecerão somente uma vez. A operação somente é possível caso as
relações de origem possuam compatibilidade de união, ou seja, possuam o o
mesmo grau e atributos correspondentes definidos num domínio comum.
Simbologia: 
Sintaxe: (Relação 1)  (Relação 2)
1.1.4. Operação Diferença entre Conjuntos
A operação diferença entre conjuntos, denotada por -, permite encontrar as
tuplas que estão no primeiro operando, mas não no outro. A operação de
diferença não é comutativa. Por exemplo, a operação r-s produz resultado
diferente da operação s-r.
4
1.1.5. Operação Produto Cartesiano
A operação produto cartesiano permite combinar informações de duas relações
quaisquer. No resultado para cada tupla da primeira relação haverá a
combinação com todas as tuplas da segunda relação ou vice-versa.
Simbologia: x
Sintaxe: (Relação 1) x (Relação 2)
1.1.6. Operação Renomeação
A operação rename, representada pela letra minúscula grega rho (), permite
nominar uma relação com outro nome, permitindo desta forma o uso desta
como primeiro e segundo operando de uma operação binária.
1.1.7. Operação de Interseção
A relação criada pela operação interseção será o resultado de todas as tuplas
que pertençam a ambas as relações presentes na operação. A operação de
interseção usa o símbolo  entre os nomes das relações envolvidas. Ela é
comutativa, isto é, r  s é equivalente a s  r. Porém, não é uma operação
fundamental e não imprime maior poder à álgebra relacional. Simplesmente é
mais conveniente escrever r  s que r – (r – s).
5
1.1.8. Operação Junção
A operação de junção é utilizada para combinar tuplas de duas relações
partindo dos atributos comuns a ambas. O resultado conterá os atributos das
duas relações que estão participando da junção. A operação é de extrema
importância em bancos de dados relacionais, pois é através dela que é
permitida a realização de relacionamentos.
Simbologia: |x|
Sintaxe: (Relação 1) <condição de junção> x (Relação 2)
1.1.9. Operação Junção Natural
A operação junção natural é uma operação binária que permite combinar as
operações de seleção e produto cartesiano dentro de uma única operação. Isto
é representado pelo símbolo de “join”
A operação de junção natural gera como resultado uma relação composta por
todos os atributos da primeira relação mais os atributos da segunda relação,
exceto aqueles usados na cláusula de junção.
1.1.10. Operação Divisão
A operação de divisão, simbolizada por , é usada nas consultas nas quais se
exige que todos os elementos do divisor estejam presentes no dividendo.
Produz como resultado a projeção de todos os atributos da primeira relação
6
exceto aqueles presentes no divisor. Não é um operador primitivo, mas pode
ter o resultado obtido por uma combinação de operadores primitivos.
1.2. Visões
Não é desejável que todos os usuários vejam o modelo lógico como um todo
de um banco de dados. Considerações sobre segurança podem exigir que
determinados dados não estejam disponíveis para alguns usuários. Com base
nessas
questões
pode-se
desejar
criar
uma
coleção
de
relações
personalizadas que se ajustam mais às necessidades do usuário do que ao
modelo lógico. Qualquer relação que não faça parte do modelo lógico mas é
visível para o usuário como uma relação virtual é chamada de visão.
Uma visão é definida usando o comando create view, seguido do nome da
visão e a expressão de consulta em álgebra relacional que define a visão.
1.3. SQL
Quando os Bancos de Dados Relacionais estavam sendo desenvolvidos, foram
criadas linguagens destinadas à sua manipulação. O Departamento de
Pesquisas da IBM, desenvolveu a SQL como forma de interface para o sistema
de BD relacional denominado SYSTEM R, início dos anos 70. Em 1986 o
American National Standard Institute ( ANSI ), publicou um padrão SQL.
Numerosos Sistemas Gerenciadores de Banco de Dados suportam a
linguagem SQL. A SQL estabeleceu-se como a linguagem padrão de banco de
7
dados relacional. Embora existam diversas versões, com algumas diferenças
entre elas, a estrutura da SQL se mantém inalterada desde a sua criação
1.3.1. As partes da linguagem SQL
A linguagem SQL pode ser dividida nas seguintes partes:
Data Definition Language (DDL) (Linguagem de Definição de Dados). A SQL
DDL fornece comandos para definição e modificação de esquemas de relação,
remoção de relações e criação de índices. Os principais comandos que fazem
parte da DDL são: CREATE, ALTER, DROP.
Data Manipulation Language (DML) (Linguagem de Manipulação de Dados). A
SQL DML inclui uma linguagem de consulta baseada na álgebra relacional e no
cálculo relacional. Compreende também comandos para inserir, remover e
modificar informações em um banco de dados. Os comandos básicos da DML
são: SELECT, INSERT, UPDATE, DELETE
Data Control Language (Linguagem de Controle de Dados). É o conjunto de
comandos que fazem o cadastramento de usuários e determina seu nível de
privilégio para os objetos do banco de dados. Os principais comandos são:
GRANT, REVOKE.
Transactions control (Controle de Transações). A SQL inclui comandos para
especificação do início e fim das transações. Diversas implementações
8
permitem o trancamento explícito de dados para o controle de concorrência.
(COMMIT, ROLLBACK, SAVEPOINT)
1.3.2. A Linguagem de Definição de Dados (SQL-DDL)
A Linguagem de Definição de Dados da SQL (SQL-DDL) é um conjunto
específico de instruções SQL que fornece meios para a definição e modificação
de esquemas de relação, remoção de relações e criação de índices.
1.3.2.1. Criando Tabelas
Uma tabela (ou relação) SQL é definida usando o comando create table:
create table r (A1 D1, A2 D2,...,An Dn)
onde r é o nome da relação, Ai é o nome de um atributo no esquema da
relação r e Di é o tipo do atributo Ai.
Exemplo:
create table cliente (nome char(30), sexo char(1), CPF
number(11), endereço char(30), cidade char(30) )
Uma relação é criada inicialmente vazia. O comando insert pode ser usado
para carregar os dados para a relação. Muitos produtos de banco de dados
relacionais possuem um grande volume de utilitários para carregar um conjunto
inicial de tuplas em uma relação.
9
1.3.2.2. Removendo uma Tabela
Para remover uma relação de um banco de dados SQL, usa-se o comando
drop table. O comando drop table remove todas as informações sobre a
relação. O comando
drop table r
onde r é o nome de uma relação (tabela) existente.
1.3.2.3. Alterando uma Tabela
O comando alter table é usado para adicionar, excluir ou alterar atributos em
uma relação existente.
Para inserir um novo atributo em uma tabela é usada a cláusula add. Todas as
tuplas na relação são assinaladas como null para o valor do novo atributo.
alter table r
add ( A1 D1, A2 D2, ... )
onde r é o nome de uma relação existente e A1 D1, A2 D2, ... é uma lista
contendo nome do atributo (A) a ser adicionado e o tipo do atributo (D),
respectivamente.
Para excluir colunas de uma tabela utiliza-se a cláusula drop.
alter table r
drop A1, A2, ...
onde r é o nome de uma relação existente e A1, A2, ... é uma lista dos atributos
a serem removidos.
Para alterar o nome de um atributo de uma tabela utiliza-se a cláusula rename.
10
alter table r
rename A NA
onde r é o nome de uma relação existente, A é o nome do atributo a ter o seu
nome alterado para NA.
Para alterar o tipo de um atributo utiliza-se a cláusula modify.
alter table r
modify A1 D1, A2 D2, ...
onde r é o nome de uma relação existente, A 1 D1, A2 D2,... é uma lista contendo
o nome do atributo (An) a ter o seu tipo alterado para (Dn).
1.3.2. Linguagem de Manipulação de Dados - DML
A principal estrutura da SQL DML consiste em três cláusulas: select, from e
where.
select A1, A2, A3, ..., An
from r1, r2, ..., rm
where P
onde Ai representa um atributo
ri é uma tabela
P é um predicado (condição/critério de seleção).
Exemplo:
select Fcodigo, status
from Fornecedor
where cidade = ‘Paris’
11
A condição (ou predicado) que segue where pode incluir operadores de
comparação =, <> (diferente), >, >=, < e <=; os operadores booleanos AND,
OR e NOT.
Exemplo:
Select Fcodigo, nome
from Fornecedor
where cidade = ‘Paris’
and status > 20
A lista A1, A2, ..., An de atributos pode ser substituída por um asterisco (*) para
selecionar todos os atributos de todas as relações presentes na cláusula from.
Exemplo:
select *
from Fornecedor
Linguagens de consultas formais são baseadas em noções matemáticas de
relação. Assim, nunca deveriam aparecem tuplas duplicadas nas relações. Na
prática, a eliminação de duplicação é uma relativa perda de tempo. Todavia, a
SQL permite duplicações em relações.
Nos casos em que queremos forçar a eliminação de duplicações, inserimos a
palavra distinct depois de select.
Exemplo:
select distinct status
from Fornecedor
A linguagem SQL oferece uma maneira de controlar a ordem que as tuplas de
uma relação serão dispostas. A cláusula ORDER BY ocasiona o aparecimento
de tuplas no resultado de uma consulta em uma ordem determinada.
SELECT A1, A2, ..., An
FROM ...r1, r2, ..., rn
WHERE ...p
12
ORDER BY A1 [ASC/DESC]
A2 [ASC/DESC]
...
An [ASC/DESC]
Onde An são nomes de atributos que servirão como parâmetro de ordenamento
da consulta.
A cláusula ORDER BY permite ordenar as linhas do resultado da consulta
segundo algum(s) atributo(s) indicado, em ordem crescentes ou decrescente.
Quando for necessário utilizar esta cláusula ela sempre deve aparecer na
última linha da consulta.
Não há limite quanto ao número de atributos utilizados para ordenação.
As palavras ASC e DESC determinam se a ordenação será ascendente ou
descendente. Caso nada seja especificado, é assumido a ordenação
ascendente (ASC).
Exemplo:
select distinct status
from Fornecedor
order by status
Exemplo:
select status, nome
from Fornecedor
order by status DESC, nome ASC
1.4. Linguagens Formais e Compiladores
O processo de compilação de um programa passa por duas partes: a análise e
a síntese. A parte da análise divide o programa-fonte nas partes constituintes e
13
cria uma representação intermediária do mesmo. A de síntese constrói o
programa-alvo desejado, a partir da representação intermediária. Das duas, a
síntese requer as técnicas mais especializadas. A análise do programa-fonte é
dividida em três fases:

Análise léxica;

Análise sintática;

Análise semântica.
1.4.1. Analisador Léxico
Faz a interface entre o programa-fonte e o compilador. Suas funções básicas
são:

Ler o programa-fonte;

Agrupar caracteres em itens léxicos (tokens), que são identificadores,
palavras reservadas da linguagem, constantes numéricas e literais e
símbolos especiais;

Ignorar elementos sem valor sintático, como espaços em branco,
comentários e caracteres de controle;

Detectar e diagnosticar erros léxicos, como símbolos inválidos, elementos
mal formados, tamanho inválido de constantes, literais e identificadores.
1.4.2. Analisador Sintático
Suas funções básicas são:
14

Agrupar
tokens
em
estruturas
sintáticas
(expressões,
comandos,
declarações, etc.);

Verificar se a sintaxe da linguagem na qual o programa foi escrito está
sendo respeitada;

Detectar/Diagnosticar erros sintáticos.
1.4.3. Analisador Semântico
Suas funções básicas são:

Verificar
se
as
construções
utilizadas
no
programa-fonte
estão
semanticamente corretas;

Detectar e diagnosticar erros semânticos;

Extrair informações do programa-fonte que permitam a geração de código;
Entre as verificações semânticas usuais no programa-fonte estão:

Análise de escopo;

Variáveis não declaradas;

Múltiplas declarações de uma mesma variável;

Compatibilidade de tipos;

Coerência entre declaração e uso de identificadores;

Correlação entre parâmetros formais e atuais;

Referências não resolvidas;

Procedimentos e desvios.
15
2. Ferramenta Didática para o Ensino de Álgebra Relacional
A seguir estão descritas as etapas de desenvolvimento do sistema.
2.1. Desenvolvimento do Compilador
Ao receber um comando em álgebra relacional, o sistema o coloca como
entrada em um compilador. O comando passa por analisadores léxico, sintático
e semântico, e se passar por essa fase é realizada a sua conversão para SQL.
Em razão do desenvolvimento do sistema ao mesmo tempo em que está sendo
cursada a disciplina de Construção de Compiladores, o cronograma de
desenvolvimento do compilador do sistema está condicionado ao aprendizado
do desenvolvimento das fases de um compilador na referida disciplina.
Para o desenvolvimento do compilador está sendo usado o GALS (Gerador de
Analisadores Léxicos e Sintáticos, desenvolvido por Carlos Eduardo Gesser
como trabalho de conclusão de curso de Ciências da Computação. Abaixo
segue gramática criada para entrada no GALS. A partir dela serão gerados os
procedimentos de análise léxica, sintática e semântica em linguagem Pascal,
para serem usados em ambiente de desenvolvimento Delphi. A gramática está
adaptada para o formato de entrada do GALS de forma que possa ser
identificada perfeitamente. Ainda não foi definido o tipo de analisador sintático a
ser utilizado dentre os disponíveis no GALS (Descendente Recursivo, LL(1),
SLR(1), LALR(1) ou LR(1)), de forma que dependendo do analisador escolhido
a gramática ainda precisa de algumas simplificações.
16
GRAMATICA ALGEBRA
Vn = { <COMANDO> <REL> <ATRIB> <CONDS> <COND> <COMP> <VALOR>
}
Vt = { sel "(" relacao ")" uniao "-" "," x jn njn div intr proj ren nome atributo and or "." "=" ">"
">=" "<" "<=" "<>" int bool string flutuante
}
S = <COMANDO>
P={
<COMANDO> ::=
<REL>
::=
<ATRIB>
<CONDS>
::=
<CONDS> ")" ;
<COND>
<COMP>
<VALOR>
}
::=
::=
sel <CONDS> "(" relacao ")" | sel <ATRIB> "(" <REL> ")" |
"(" relacao ")" uniao "(" relacao ")" | "(" relacao ")" uniao "(" <REL> ")" |
"(" relacao ")" "-" "(" relacao ")" | "(" relacao ")" "-" "(" <REL> ")" |
"(" relacao ")" x "(" relacao ")" | "(" relacao ")" x "(" <REL> ")" |
"(" relacao ")" njn "(" relacao ")" | "(" relacao ")" njn "(" <REL> ")" |
"(" relacao ")" <CONDS> jn "(" relacao ")" |
"(" relacao ")" div "(" relacao ")" |
"(" relacao ")" intr "(" relacao ")" |
proj <ATRIB> "(" relacao ")" | proj <ATRIB> "(" <REL> ")" |
ren nome "(" relacao ")" ;
sel <ATRIB> "(" relacao ")" | sel <ATRIB> "(" <REL> ")" |
"(" relacao ")" uniao "(" relacao ")" | "(" relacao ")" uniao "(" <REL> ")" |
"(" relacao ")" "-" "(" relacao ")" | "(" relacao ")" "-" "(" <REL> ")" |
"(" relacao ")" x "(" relacao ")" | "(" relacao ")" x "(" <REL> ")" |
"(" relacao ")" njn "(" relacao ")" | "(" relacao ")" njn "(" <REL> ")" |
"(" relacao ")" <CONDS> jn "(" relacao ")" |
"(" relacao ")" div "(" relacao ")" |
"(" relacao ")" intr "(" relacao ")" ;
::=
atributo | atributo "," <ATRIB> ;
"(" <COND> ")" | "(" <COND> and <CONDS> ")" | "(" <COND> or
::=
atributo <COMP> atributo |
relacao "." atributo <COMP> relacao "." atributo |
atributo <COMP> relacao "." atributo |
relacao "." atributo <COMP> atributo |
atributo <COMP> <VALOR> |
relacao "." atributo <COMP> <VALOR> ;
"=" | ">" | ">=" | "<" | "<=" | "<>" ;
int | bool | string | flutuante ;
2.2. Desenvolvimento da Ferramenta de Manipulação de Relações e
Tuplas.
Para a execução de comandos em álgebra relacional é preciso que
anteriormente sejam criadas relações e inseridas tuplas a serem manipuladas.
Essa etapa do desenvolvimento contempla a criação dessas ferramentas. São
17
disponibilizados ao usuário as opções de criar, alterar, visualizar e apagar
relações e tuplas. O desenvolvimento está sendo realizado em linguagem
Pascal e ambiente de desenvolvimento Delphi. As relações são criadas em
forma de tabelas do gerenciador de banco de dados Mysql para Windows. Para
acessar o banco de dados Mysql foi instalado o gerenciador na máquina onde
está sendo desenvolvido o projeto e o acesso ao banco de dados pelo sistema
é feito através de driver ODBC.
A escolha do ambiente de desenvolvimento Delphi par o projeto se dá em
razão da experiência de uso desde o início do curso e a escolha do banco de
dados Mysql se dá em razão da experiência de uso em alguns projetos
profissionais e também por ser livre.
Essa etapa do desenvolvimento está sendo feita em paralelo com a primeira
etapa, uma vez que não depende das informações geradas pelo compilador.
2.3. Desenvolvimento da Interface com o Usuário
Nesta etapa será desenvolvido o prompt de comando onde o usuário entra com
o comando a ser executado em álgebra relacional. Estarão disponíveis para o
usuário as letras gregas usadas nas operações da álgebra, e como as mesmas
não estão previstas na gramática criada, cada letra grega usada será
convertida em um comando com nome relacionado a cada operação ( σ vira
SEL, π vira PROJ, por exemplo). Esses comandos serão usados internamente
pelo sistema, não estando disponíveis ao usuário.
Os resultados da execução do comando de álgebra relacional será
apresentado em um grid e também estará disponível para visualização o
18
meesmo comando convertido para linguagem SQL através do compilador
usado internamente pelo sistema.
2.4. Integração dos Módulos do Sistema
Cada módulo desenvolvido, descritos nos itens 2.1, 2.2 e 2.3, pode ser
desenvolvido separadamente, e após a conclusão de todos os módulos será
feita a integração de modo a permitir o perfeito funcionamento do sistema.
2.5. Realização de Testes
Com o sistema concluído começa a realização dos testes, realizando as
seguintes operações do sistema:

Criação de relações;

Manipulação de relações (inclusão, alteração e exclusão de atributos);

Inclusão de tuplas;

Manipulação de tuplas (alteração dos valores dos atributos e exclusão
de tuplas);

Execução de comandos da álgebra relacional.
19
3. Referência Bibliográfica
1. Silberschatz, Abraham; Kort, Henry F. e Sudarshan, S. Sistema de Banco
de Dados. Makron Books, São Paulo, 1999. p. 69-100.
2. Aho, Alfred V.; Sethi, Ravi e Ullman, Jeffrey D. Compiladores, Princípios,
Técnicas e Ferramentas. LTC, Rio de Janeiro. Original: inglês.. p. 1-4.
3. Furtado, Olinto José Varela. Transparências das aulas de Linguagens
Formais e Compiladores. Departamento de Informática e Estatística, Curso
de Bacharelado em Ciências da Computação, UFSC. Cap. 1.
4. Rezende, Ricardo. Álgebra Relacional – Parte I. Linguagem de Consulta
Formal.
SQL
Magazine.
Disponível
em:
<
http://www.sqlmagazine.com.br/Colunistas/RicardoRezende/04_AlgebraRel
acional_P1.asp> Acesso em 24 nov. 2004.
5. Rezende, Ricardo. Álgebra Relacional – Parte II. Linguagem de Consulta
Formal.
SQL
Magazine.
Disponível
em:
<
http://www.sqlmagazine.com.br/Colunistas/RicardoRezende/04_AlgebraRel
acional_P2.asp> Acesso em 24 nov. 2004.
6. Cocco,
Adriana
Pereira.
A
Linguagem
SQL.
<http://main.unicruz.edu.br/~adriana/bd/aula11.html> Acesso em 27 maio
2005.
20
7. Cocco,
Adriana
Pereira.
A
Linguagem
SQL.
<http://main.unicruz.edu.br/~adriana/bd/aula12.html> Acesso em 27 maio
2005.
21