Programação Funcional e Programação Lógica Uma...

UNIVERSIDADE ESTADUAL DE MARINGÁ DEPARTAMENTO DE INFORMÁTICA

MESTRADO EM CIÊNCIA DA COMPUTAÇÃO

Programação Funcional e Programação Lógica

Uma Implementação Prática

Trabalho apresentado à disciplina de Linguagem de Programação do curso de Mestrado em Ciência da Computação, da Universidade Estadual de Maringá.

Docente: Profº Drº Sérgio Roberto Pereira da Silva

Dorival José Batista Késsia Rita da Costa Marchi

Roberto Pereira

MARINGÁ, Dezembro de 2006.

2

Sumário

Índice de Figuras ......................................................................................................... 3

Introdução ................................................................................................................... 6

Organização do Trabalho ........................................................................................... 6

1 - Definição do Problema ........................................................................................... 7

2 - PROLOG................................................................................................................ 8

2.1 - Conexão com Banco de Dados MySql ................................................................ 8

2.2 - Implementação. ................................................................................................... 9

2.2.3 - Questões pré-determinadas para a resolução do problema. ......................... 12

3 - Scheme .................................................................................................................. 21

3.1 - Conexão com Banco de Dados .......................................................................... 21

3.3 - Implementação .................................................................................................. 23

3.3.1 - Questões pré-determinadas para a resolução do problema. ......................... 25

4 - Conclusão ............................................................................................................. 35

5 – Referencias Bibliográficas................................................................................... 37

3

Índice de Figuras

Figura 1 – Diagrama Entidade Relacionamento ................................................................................. 07

Figura 2 – Gerenciador de Fontes de Dados ...................................................................................... 08

Figura 3 – Configuração da Fonte de Dados do Sistema .................................................................... 09

Figura 4 – Fonte de Dados para Access ............................................................................................. 22

Figura 5 – Seleção de Fonte de Dados ............................................................................................... 23

4

Índice de Tabelas

Tabela 1 – Conexão do Prolog ao BD Mysql ....................................................................................... 09

Tabela 2 – Predicado Conectado ......................................................................................................... 09

Tabela 3 – Predicado Departamento .................................................................................................... 10

Tabela 4 – Predicado Curso ................................................................................................................ 10

Tabela 5 – Predicado Professor ........................................................................................................... 10

Tabela 6 – Predicado Disciplina .......................................................................................................... 10 Tabela 7 – Predicado Turno ................................................................................................................ 10

Tabela 8 – Predicado Dia .................................................................................................................... 10

Tabela 9 – Predicado Horário.............................................................................................................. 10

Tabela 10 – Predicado Grupo de Pesquisa ........................................................................................... 10

Tabela 11 – Predicado Linha de Pesquisa ............................................................................................ 10

Tabela 12 – Predicado Aluno .............................................................................................................. 10

Tabela 13 – Predicado Projeto............................................................................................................. 10

Tabela 14 – Predicado Artigo.............................................................................................................. 12

Tabela 15 – Predicado Professor x Disciplina ...................................................................................... 12

Tabela 16 – Resposta – Professor x Disciplina .................................................................................... 12

Tabela 17 – Predicado Hora x Professor .............................................................................................. 13 Tabela 18 – Resposta – Hora x Professor ............................................................................................ 13

Tabela 19 – Resposta – Hora x Disciplina ........................................................................................... 14

Tabela 20 – Predicado Professor Pesquisador ...................................................................................... 14

Tabela 21 – Resposta – Professor Pesquisador..................................................................................... 15

Tabela 22 – Predicado Professor x Artigo ........................................................................................... 15

Tabela 23 – Resposta – Professor x Artigo .......................................................................................... 15

Tabela 24 – Resposta – Professor X Artigo Autoria ............................................................................. 16

Tabela 25 – Predicado Artigo.............................................................................................................. 17

Tabela 26 – Resposta Artigo Professor ................................................................................................ 18

Tabela 27 – Resposta Artigo Professor Autoria ................................................................................... 19

Tabela 28 – Predicado Professor x Departamento ............................................................................... 19 Tabela 29 – Resposta – Professor x Departamento............................................................................... 19

Tabela 30 – Predicado Professor x Curso ............................................................................................ 20

Tabela 31 – Resposta Professor x Curso .............................................................................................. 21

Tabela 32 – Predicado Professor x Projeto .......................................................................................... 21

Tabela 33 – Resposta Professor x Projeto ............................................................................................ 21

Tabela 34 – Função de conexão .......................................................................................................... 22

Tabela 35 – Alocação de 'Environment Handle' e um 'Connection Handle' ........................................... 22

Tabela 36 – Chamada externa ao drive ODBC .................................................................................... 23

Tabela 37 – Função União .................................................................................................................. 23

Tabela 38 – Função Pertence? ............................................................................................................. 24

Tabela 39 – Chamada e Execução do Script SQL ................................................................................ 24

Tabela 40 – Função HSTMT ............................................................................................................... 24 Tabela 41 – Chamada e Execução do Script SQL ................................................................................ 24

Tabela 42 – Chamada e Execução do Script SQL – 1ª questão ............................................................. 25

Tabela 43 – Buffers e Indicadores – 1ª questão. ................................................................................... 25

Tabela 44 – Chamada da função cônsul e o resultado – 1ª questão. ..................................................... 26

Tabela 45 – Buffer, indicadores e rotinas de execução – 2ª questão. .................................................... 26

Tabela 46 – Chamada da função cônsul e o resultado – 2ª questão. ..................................................... 27

Tabela 47 – Chamada e Execução do Script SQL – 3ª questão ............................................................. 27

Tabela 48 – Buffers e Indicadores – 3ª questão. ................................................................................... 28

Tabela 49 – Chamada da função cônsul e o resultado de professor – 3ª questão.................................... 28

Tabela 50– Buffer, indicadores e rotinas de execução – 4ª questão. ..................................................... 29

Tabela 51 – Chamada da função cônsul e o resultado – 4ª questão. ..................................................... 30 Tabela 52 – Buffer, indicadores e rotinas de execução – 5ª questão. .................................................... 30

Tabela 53– Chamada da função cônsul e o resultado – 5ª questão. ....................................................... 31


Tabela 55– Chamada da função cônsul e o resultado – 6ª questão. ...................................................... 32



5

Tabela 58 – Buffer, indicadores e rotinas de execução – 8ª questão. ..................................................... 34


6

Introdução

Neste trabalho realizaremos uma abordagem sobre Programação Lógica e sobre

Programação Funcional. A programação em lógica se desenvolveu no início dos anos

70, para atender alguns trabalhos sobre prova de teoremas. No decorrer de sua evolução,

manteve-se seu formalismo simples e poderoso, sendo igualmente eficiente tanto para a

representação do conhecimento, quanto como ferramenta para programação.

No contexto da Programação Lógica, a primeira linguagem de programação que

surgiu foi o PROLOG, uma linguagem orientada ao processamento simbólico que

representa uma implementação da lógica como linguagem de programação. O PROLOG

e o maior exemplo de linguagem de programação lógica, e será discutido neste trabalho.

Já a Programação Funcional foi desenvolvida principalmente a partir do final

dos anos 50. É um paradigma de programação que trata a computação como uma

avaliação de funções matemáticas, que pode ou não, apresentar parâmetros bem como

um simples valor de retorno, que são os valores de entrada e o resultado da função,

respectivamente. A primeira linguagem representante da programação funcional foi o

LISP, responsável pela introdução da maioria das características encontradas hoje nas

linguagens de programação funcional. O Scheme representou uma tentativa de melhorar

e simplificar o LISP, e será a linguagem utilizada para demonstrar o desenvolvimento

de um programa utilizando programação funcional.

A realização deste trabalho visa demonstrar a utilização da programação lógica e

da programação funcional, aplicadas a um mesmo domínio de problema. Busca-se

analisar as implementações realizadas e as formas de desenvolvê-las, para que seja

possível identificar claramente as diferenças existentes entre as abordagens utilizadas.

Organização do Trabalho

No item 1 apresenta-se a definição do problema que será abordado, uma breve

descrição do domínio e das questões que serão consideradas no desenvolver do trabalho.

No item 2, realiza-se a especificação das implementações realizadas com a linguagem

lógica PROLOG, uma breve descrição da mesma e alguns outros pontos importantes

para o contexto do trabalho. O item 3 abrange as implementações realizadas com a

linguagem funcional Scheme, demonstrando alguns blocos de código e os resultados

gerados pelos mesmos. No item 4, apresentam-se as conclusões obtidas pela realização

das implementações realizadas.

7

1 - Definição do Problema

Com o intuito de estabelecer métricas para comparação entre paradigmas de

linguagens de programação lógica e funcional, utilizamos como domínio do problema,

um departamento que precisa realizar a consulta de diversas informações referentes

pesquisas, professores, disciplinas, carga horária, entre outros. Para tal, definimos um

esquema em Banco de Dados representado no Diagrama de Entidade e Relacionamento

(figura 1), utilizando o Sistema de Gerenciamento MySql e Microsoft Access.

As implementações realizadas em PROLOG, apresentaram êxito tanto com o

banco de dados MySql, quanto com o gerenciador Access. Os acessos a dados

realizados pela linguagem Scheme foram compatíveis somente com o Access, devido a

conflitos na conexão com o banco de dados MySql. Assim sendo, o mesmo não será

considerado para a analise do problema com a linguagem Scheme, mas trabalha

normalmente com as implementações realizadas em PROLOG descritas neste trabalho.

Figura 1 – Diagrama Entidade Relacionamento

As implementações desenvolvidas nas linguagens PROLOG e Scheme, possuem como

objetivo encontrar uma resposta para as seguintes perguntas:

1. Em quais horários um professor ministra aula?

2. Qual é o horário de uma disciplina?

3. Quais professores são pesquisadores?

4. Quais artigos um professor já escreveu?

5. Quais artigos um professor já publicou?

6. Em qual departamento um professor trabalha?

7. Em quais cursos um professor trabalha?

8. Em quais projetos um professor participa?

Nos próximos itens serão demonstradas e explanadas, as implementações realizadas

para se obter a resolução do problema. Inicialmente, consideraremos a solução do

problema em PROLOG, para em seguida, apresentá-lo em Scheme.

8

2 - PROLOG

A linguagem PROLOG foi utilizada para demonstrar a implementação da

solução, por meio da utilização de uma linguagem lógica. Descrevemos neste tópico,

alguns aspectos importantes quanto a conexão com o banco de dados, e quanto a

implementação da solução para a busca das respostas especificadas.

2.1 - Conexão com Banco de Dados MySql

Para realizar a conexão do PROLOG com o banco de dados MySql, após o

banco ter sido criado, o driver de comunicação deve ser instalado e o ODBC precisa ser

configurado (as figuras 2 e 3 ilustram esta configuração).

Figura 2 – Gerenciador de Fontes de Dados

Para criar uma nova fonte de dados, deve-se adicionar uma nova, e selecionar o driver

MySQL ODBC 3.5.1 Driver. A configuração do mesmo deve ser realizada na tela

seguinte.

9

Figura 3 – Configuração da Fonte de Dados do Sistema

Nesta janela devem ser especificados os parâmetros solicitados para a configuração, tais

como: banco de dados, servidor, usuário, senha, etc. O status da conexão pode ser

testado com o botão “Test”.

Após realizado o processo detalhado acima, as seguintes linhas de código em PROLOG,

possibilitam a comunicação do mesmo com o banco de dados configurado:

Para a conexão ser efetuada, são passados os parâmetros para o driver ODBC, de acordo

com o que se demonstra na tabela 1.

% Conexão do Prolog ao BD MySql através do ODBC-MS

connecta :- odbc_connect('bdprolog', _,

[user(root),password('root'),alias(bdprolog),open(once)]).

Tabela 1 – Conexão do Prolog ao BD Mysql

O predicado `conectado`, tabela 2, foi desenvolvida para retornar se já existe conexão

ativa ou não, com a base de dados especificada.

% Checagem se conexão do Prolog ao BD MySQL está ativa.

conectado(NmBD, DSN) :-

odbc_current_connection(NmBD, DSN).

Tabela 2 – Predicado Conectado

2.2 - Implementação.

Baseados no esquema SQL representado no item 1, onde foram especificados os

aspectos relacionados ao problema abordado neste estudo de caso, foram desenvolvidos

através de scripts de consulta SQL, os predicados necessários para obtermos as

10

respostas em consultas através da linguagem de programação lógica Prolog. Os

atributos identificadores são utilizados para compor os relacionamentos entre os

predicados. Na seqüência, estaremos detalhando cada predicado criado para retornar

acessar as informações no banco e possibilitar a realização de consultas e

conseqüentemente a busca das respostas para as perguntas anteriormente definidas.

O predicado departamento é utilizado para selecionar os atributos “nome do

departamento” (NmDepto) e o “identificador do departamento” (IdDepto).

depto(NmDepto, IdDepto) :-

odbc_query(bdprolog, 'Select nome_dpto, iddepartamento from

departamento order by nome_dpto', row(NmDepto, IdDepto)).

Tabela 3 – Predicado Departamento

O predicado curso seleciona os atributos “Nome do Curso” (NmCurso),

“Identificador do Curso” (IdCurso) e “Identificador do Departamento” (IdDepto).

curso(NmCurso, IdCurso, IdDepto) :-

odbc_query(bdprolog, 'Select nome_cur, idcurso,

iddepartamento from curso order by nome_cur',row(NmCurso,

IdCurso, IdDepto)).

Tabela 4 – Predicado Curso

O predicado professor seleciona os atributos “Nome do Professor” (NmProf),

“Identificador do Professor” (IdProf) e “Identificador do Departamento” (IdDepto).

professor(NmProf, IdProf, IdDepto) :-

odbc_query(bdprolog, 'Select nome_prof, idprofessor,

iddepartamento from professor order by nome_prof',

row(NmProf, IdProf, IdDepto)).

Tabela 5 – Predicado Professor

O predicado disciplina é necessário para selecionar os atributos “Nome da

Disciplina” (NmDisc), “Identificador do Curso” (IdCurso) e “Identificador da

Disciplina” (IdDisc).

disciplina(NmDisc, IdCurso, IdDisc) :-

odbc_query(bdprolog, 'Select nome_disc, iddisciplina, idcurso

from disciplina order by nome_disc, idcurso',

row(NmDisc, IdDisc, IdCurso)).

Tabela 6 – Predicado Disciplina

O predicado turno é utilizado para a seleção dos atributos “Nome do Turno”

(NmTur) e “Identificador do Turno” (IdTur).

turno(NmTur, IdTur) :-

odbc_query(bdprolog, 'Select turno, idturno from turno',

row(NmTur, IdTur)).

Tabela 7 – Predicado Turno

11

O predicado dia seleciona atributos “Dia da Semana” (DiaSem), “Identificador

do Turno” (IdTur) e “Identificador do Dia”(IdDia).

dia(DiaSem, IdTur, IdDia) :-

odbc_query(bdprolog, 'Select dia_sem, idturno, iddia from

dia', row(DiaSem, IdTur, IdDia)).

Tabela 8 – Predicado Dia

O predicado horario é necessário para selecionar os atributos “Hora” (Hora),

“Identificador do Dia” (IdDia) e “Identificador da Hora”(IdHora).

horario(Hora, IdDia, IdHora) :-

odbc_query(bdprolog, 'Select horario, iddia, idhorario from

horario', row(Hora, IdDia, IdHora)).

Tabela 9 – Predicado Horário

O predicado grupo_pesq é utilizado para selecionar os atributos referentes ao

grupo de pesquisa, sendo, “Nome do Grupo” (NmGrupo) e “Identificador do Grupo”

(IdGrupo).

grupo_pesq(NmGrupo, IdGrupo) :-

odbc_query(bdprolog, 'Select nome_grupo, idgrupo_pesq from

grupo_pesq', row(NmGrupo, IdGrupo)).

Tabela 10 – Predicado Grupo de Pesquisa

O predicado linha_pesq seleciona os atributos “Nome da Linha” (NmLinha),

“Área da Linha” (AreaL) e “Identificador da Linha” (IdLinha) utilizados nas consultas

referentes à “linha de pesquisa”.

linha_pesq(NmLinha, AreaL, IdLinha) :-

odbc_query(bdprolog, 'Select nome_lin, area_lin,

idlinha_pesquisa from linha_pesquisa', row(NmLinha, AreaL,

IdLinha)).

Tabela 11 – Predicado Linha de Pesquisa

O predicado aluno é utilizado na seleção do “Nome do Aluno” (NmAluno) e

“Identificados do Aluno” (IdAluno).

aluno(NmAluno, IdAluno) :-

odbc_query(bdprolog, 'Select nome_aluno, idaluno from aluno',

row(NmAluno, IdAluno)).

Tabela 12 – Predicado Aluno

O predicado projeto seleciona os atributos “Nome do Projeto” (NmProj), “Nome

do Tema” (NmTema), “Nome da Área” (NmArea) e “Identificados do projeto” (IdProj).

projeto(NmProj, NmTema, NmArea, IdProj) :-

odbc_query(bdprolog, 'Select nome_proj, tema_proj, area_proj,

idprojeto from projeto', row(NmProj, NmTema, NmArea,

IdProj)).

Tabela 13 – Predicado Projeto

12

O predicado artigo é necessário para selecionar os atributos “Título do Artigo”

(TitArt), “Resumo do Artigo” (resArt), “Ano do Artigo” (AnoArt), “Identificador da

Linha” (IdLinha) e “Identificados do Artigo” (IdArt).

artigo(TitArt, ResArt, AnoArt, IdLinha, IdArt) :-

odbc_query(bdprolog, 'Select titulo_art, resumo_art, ano_art,

idlinha_pesquisa, idartigo from artigo', row(TitArt,

ResArt, AnoArt, IdLinha, IdArt)).

Tabela 14 – Predicado Artigo

2.2.3 - Questões pré-determinadas para a resolução do problema.

Na seqüência, serão apresentadas as implementações construídas com base nos

predicados anteriormente especificados, de modo que seja possível responder às

questões definidas no inicio do projeto.

1. Qual professor ensina uma determinada disciplina?

Para encontrar os professores que ministram uma determinada disciplina,

utilizamos o predicado prof_disc, que é composto pelos atributos “Nome do

Professor”(NmProf), “Nome do Departamento” (NmDepto), “Nome do

Curso”(NmCurso) e “Nome da Disciplina” (NmDisc).

prof_disc( NmProf, IdProf, NmDisc, IdDisc, IdHora):-

odbc_query(bdprolog, 'Select idprofessor, iddisciplina,

idhorario from professor_disciplina', row(IdProf, IdDisc , IdHora)),

professor(NmProf, IdProf, IdDepto),

disciplina(NmDisc, IdCurso, IdDisc).

Tabela 15 – Predicado Professor x Disciplina

A consulta prof_disc seleciona o atributo “Nome do Professor” (NmProf), com

base no parâmetro de entrada “Nome da disciplina”. O objeto “_”, utilizado na consulta,

tem a finalidade de ocultar os atributos que não são necessários para esta questão.

1 ?- prof_disc(NmProf, _, 'Linguagem de Programação', _, _).

NmProf = 'Sérgio' ;

Yes

2 ?-

Tabela 16 – Resposta – Professor x Disciplina

No exemplo acima, o nome da disciplina foi passado como parâmetro, e o retorno

solicitado foi o nome do professor que a ministra.


Para esta questão, foi necessário utilizar o predicado prof_disc devido ao

modelo relacional armazenar o horário de aulas na tabela “professor_disciplina”,

estabelecendo assim um relacionamento ternário entre professor, disciplina e hora.

Foram utilizados ainda, os predicados dia, turno e horário. Os atributos mostrados

13

neste predicado são o “Nome do Professor” (NmProf), “Nome da Disciplina”

(NmDisc), “Dia da Semana” (DiaSem), “Turno” (Turno) e “Hora” (Hora).

hora_prof(NmProf, NmDisc, DiaSem, Turno, Hora) :-

prof_disc( NmProf, IdProf, NmDisc, IdHora),

dia(DiaSem, IdTur, IdDia),

turno(NmTur, IdTur),

horario(Hora, IdDia, IdHora).

Tabela 17 – Predicado Hora x Professor

A execução desta consulta permite que seja exibido todos os horários de todos os

professores, como segue o exemplo, ou passar por parâmetro qualquer um dos atributos

aplicando um filtro para a execução da consulta.

1 ?- hora_prof(NmProf, NmDisc, DiaSem, Turno, Hora).

NmProf = 'Sérgio'

NmDisc = 'Linguagem de Programação'

DiaSem = 'Seg'

Hora = '07:30 s 08:20' ;

NmProf = 'Sérgio'

NmDisc = 'Engenharia de Software'

DiaSem = 'Seg'

Hora = '08:20 s 09:10' ;

NmProf = 'Maria'

NmDisc = 'Engenharia de Software'

DiaSem = 'Seg'

Hora = '09:40 s 10:30' ;

NmProf = 'Luiz'

NmDisc = 'Algoritmo e Programação'

DiaSem = 'Seg'

Hora = '10:30 s 11:20' ;

NmProf = 'Antonio'

NmDisc = 'Contabilidade'

DiaSem = 'Seg'

Hora = '13:30 s 14:20' ;

NmProf = 'Joaquim'

NmDisc = 'Banco de Dados'

DiaSem = 'Seg'

Hora = '14:20 s 15:10' ;

NmProf = 'Gervásio'


DiaSem = 'Seg'

Hora = '15:40 s 16:30' ;

NmProf = 'Luiz'


DiaSem = 'Seg'

Hora = '16:30 s 17:20' ;

NmProf = 'Antonio'


DiaSem = 'Seg'

14

Hora = '19:20 s 20:10' ;

NmProf = 'Luiz'

NmDisc = 'História da Administração'

DiaSem = 'Seg'

Hora = '20:10 s 21:00' ;


NmDisc = 'Direito Penal'

DiaSem = 'Seg'

Hora = '21:20 s 22:10' ;

NmProf = 'Maria'

NmDisc = 'Direito Civil'

DiaSem = 'Seg'

Hora = '22:10 s 23:00' ;

NmProf = 'Antonio'

NmDisc = 'História'

DiaSem = 'Ter'

Hora = '07:30 s 08:20' ;

Yes

2 ?-

Tabela 18 – Resposta – Hora x Professor


Para consultar o horário de uma disciplina, utilizamos o predicado hora_prof

ocultando o atributo “Nome do Professor” (NmProf) e passando como parâmetro a

disciplina específica no atributo “Nome da Disciplina” (NmDisc).

1 ?- hora_prof(_, 'Linguagem de Programação', DiaSem, Turno,

Hora).

DiaSem = 'Seg'

Hora = '07:30 s 08:20' ;

Yes

2 ?-

Tabela 19 – Resposta – Hora x Disciplina

No exemplo, o nome da disciplina foi passado como parâmetro, recebendo o dia da

semana e o horário da mesma.


O predicado professor_pesq permite consultar os Professores que estejam

classificados como pesquisadores, exibindo os atributos “Nome do Professor” (NmProf)

e “Pesquisador” (Pesq).

professor_pesq(NmProf, Pesq) :-

odbc_query(bdprolog, 'Select nome_prof, pesquisador from

professor order by nome_prof', row(NmProf, Pesq)).

Tabela 20 – Predicado Professor Pesquisador

15

Para encontrar os professores pesquisadores, realizamos a consulta passando o

parâmetro „S‟ no atributo “Pesquisador”.

1 ?- professor_pesq(NmProf,'S').

NmProf = 'Gervásio' ;

NmProf = 'Joaquim' ;

NmProf = 'Maria' ;

NmProf = 'Sérgio' ;

Yes

2 ?-

Tabela 21 – Resposta – Professor Pesquisador

Também é possível que seja passado determinado professor como parâmetro, para

consultar se o mesmo é pesquisador ou não.


O predicado prof_artigo realiza a consulta referente aos artigos que cada

professor escreveu, mostrando os atributos “Nome do Professor” (NmProf), “Título do

Artigo” (TitArt), “Resumo do Artigo” (ResArt), “Tipo de Autoria” (TpAutoria) e

“Identificador do Artigo” (IdArt).

prof_artigo(NmProf, TitArt, ResArt, TpAutoria, IdArt) :-

odbc_query(bdprolog, 'Select tipo_autoria, idartigo,

idprofessor from professor_artigo',

row(TpAutoria, IdArt, IdProf)),

professor(NmProf, IdProf, _),

artigo(TitArt, ResArt, _, _, IdArt).

Tabela 22 – Predicado Professor x Artigo

Consultando o predicado prof_artigo, estamos exibindo o “Nome do Professor”

(NmProf), o “Título do Artigo” (TitArt) e o “Resumo do Artigo” (ResArt). Para mostrar

apenas os Autores dos artigos, estamos passando o parâmetro “A”, que define o tipo de

autoria do artigo como Autor e assim, ocultamos os Co-autores.

1 ?- prof_artigo(NmProf, TitArt, ResArt, 'A', _).

NmProf = 'Sérgio'

TitArt = 'Titulo 4'

ResArt = 'Resumo do Titulo 4' ;

NmProf = 'Luiz'

TitArt = 'Titulo 6'


NmProf = 'Antonio'

TitArt = 'Titulo 5'

ResArt = 'Resumo do titulo 5' ;


TitArt = 'Titulo 2'

16


Yes

2 ?-

Tabela 23 – Resposta – Professor x Artigo

Caso não seja passado o parâmetro de autoria, são exibidas todas as autorias ou co-

autorias dos artigos, como segue o exemplo:

1 ?- prof_artigo(NmProf, TitArt, ResArt, TpAutoria, _).

NmProf = 'Sérgio'

TitArt = 'Titulo 4'

ResArt = 'Resumo do Titulo 4'

TpAutoria = 'A' ;

NmProf = 'Maria'

TitArt = 'Tittulo 3'


TpAutoria = 'C' ;

NmProf = 'Maria'

TitArt = 'Titulo 4'


TpAutoria = 'C' ;

NmProf = 'Luiz'

TitArt = 'Titulo 5'

ResArt = 'Resumo do titulo 5'

TpAutoria = 'C' ;

NmProf = 'Luiz'

TitArt = 'Titulo 6'


TpAutoria = 'A' ;

NmProf = 'Antonio'

TitArt = 'Titulo 5'


TpAutoria = 'A' ;

NmProf = 'Joaquim'

TitArt = 'Titulo 1'


TpAutoria = 'C' ;

NmProf = 'Joaquim'

TitArt = 'Titulo 2'


TpAutoria = 'C' ;


TitArt = 'Titulo 2'


TpAutoria = 'A' ;

Yes

2 ?-

Tabela 24 – Resposta – Professor X Artigo Autoria

17


Para encontrar os artigos publicados pelos professores, utilizamos dois

predicados, sendo eles:

O predicado artigo2 tem a finalidade de relacionar o artigo ao ano de submissão,

utilizando os atributos “Titulo do Artigo” (TitArt), “Resumo do Artigo” (ResArt), “Ano

de Submissão do Artigo” (AnoArt), “Nome da Linha de Pesquisa” (NmLinha), “Área

de Pesquisa” (AreaL), “Evento em que o artigo foi submetido” (Evento), “Aceitação do

Artigo” (Aceito), “Ano de Submissão” (AnoSub) e “Identificador do Artigo” (IdArt).

O segundo é o predicado artigo3 que estabelece o relacionamento entre o

predicado artigo2 e o predicado prof_artigo. O predicado artigo3 apresenta os atributos

“Nome do Professor” (NmProf), “Tipo de Autoria” (TpAutoria), “Título do Artigo”

(TitArt), “Resumo do Artigo” (ResArt), “Ano em que o artigo foi escrito” (AnoArt),

“Evento em que foi submetido” (Evento), “Aceite do Artigo” (Aceito) e “Ano de

submissão” (AnoSub).

artigo2(TitArt, ResArt, AnoArt, NmLinha, AreaL, Evento, Aceito,

AnoSub, IdArt) :-

odbc_query(bdprolog, 'Select titulo_art, resumo_art, ano_art,

idlinha_pesquisa, idartigo from artigo',

row(TitArt, ResArt, AnoArt, IdLinha, IdArt)),

odbc_query(bdprolog, 'Select evento, aceito, ano, idartigo

from submissao',row(Evento, Aceito, AnoSub, IdArt)),

linha_pesq(NmLinha, AreaL, IdLinha).

artigo3(NmProf, TpAutoria, TitArt, ResArt, AnoArt, Evento, Aceito,

AnoSub) :-

artigo2(TitArt, ResArt, AnoArt, _, _, Evento, Aceito, AnoSub,

IdArt),

prof_artigo(NmProf, _, _, TpAutoria, IdArt).

Tabela 25 – Predicado Artigo

Para encontrar os artigos publicados por um professor, utilizamos o predicado

artigo3 para realizar a consulta. Estamos passando como parâmetro o atributo “Aceito”

(Aceito) como „S‟, para que no resultado seja exibido apenas os artigos que foram

publicados, onde o professor seja autor ou co-autor.

1 ?- artigo3(NmProf, TpAutoria, TitArt, ResArt, AnoArt, Evento,

'S', AnoSub).

NmProf = 'Joaquim'

TpAutoria = 'C'

TitArt = 'Titulo 1'


AnoArt = '2005'

Evento = '3o Sei lá'

AnoSub = '2005' ;

NmProf = 'Joaquim'

TpAutoria = 'C'

TitArt = 'Titulo 2'


18

AnoArt = '2006'

Evento = 'Simpósio Nacional de Blá Blá Blá'

AnoSub = '2006' ;


TpAutoria = 'A'

TitArt = 'Titulo 2'


AnoArt = '2006'


AnoSub = '2006' ;

NmProf = 'Maria'

TpAutoria = 'C'

TitArt = 'Tittulo 3'


AnoArt = '2004'

Evento = '4o Encontro de Blá Blá'

AnoSub = '2004' ;

NmProf = 'Sérgio'

TpAutoria = 'A'

TitArt = 'Titulo 4'


AnoArt = '2005'

Evento = 'Semana do Saco Cheio'

AnoSub = '2004' ;

NmProf = 'Maria'

TpAutoria = 'C'

TitArt = 'Titulo 4'


AnoArt = '2005'


AnoSub = '2004' ;

NmProf = 'Luiz'

TpAutoria = 'C'

TitArt = 'Titulo 5'


AnoArt = '2003'

Evento = 'Congresso de ETs'

AnoSub = '2003' ;

NmProf = 'Antonio'

TpAutoria = 'A'

TitArt = 'Titulo 5'


AnoArt = '2003'


AnoSub = '2003' ;

Yes

2 ?-

Tabela 26 – Resposta Artigo Professor

Na execução abaixo, passamos também o parâmetro “Tipo de Autoria”

(TpAutoria) como „A‟ para limitar os resultados em apenas os artigos publicados dos

professores que foram autores destes artigos.

19

1 ?- artigo3(NmProf, 'A',TitArt,ResArt,AnoArt,Evento,'S',AnoSub).


TitArt = 'Titulo 2'


AnoArt = '2006'


AnoSub = '2006' ;

NmProf = 'Sérgio'

TitArt = 'Titulo 4'


AnoArt = '2005'


AnoSub = '2004' ;

NmProf = 'Antonio'

TitArt = 'Titulo 5'


AnoArt = '2003'


AnoSub = '2003' ;

Yes

2 ?-

Tabela 27 – Resposta Artigo Professor Autoria


O predicado prof_depto é utilizado na consulta que resulta em qual

departamento um professor trabalha. Este predicado apresenta o atributo “Nome do

Professor” (NmProf) e “Nome do Departamento” (NmDepto).

prof_depto(NmProf, NmDepto) :-

professor(NmProf, _, IdDepto),

depto(NmDepto, IdDepto). Tabela 28 – Predicado Professor x Departamento

Ao realizar a consulta com o predicado pro_depto, foram exibidos apenas os

atributos “Nome do Professor” (NmProf) e “Nome do Departamento” (NmDepto). No

caso de uma consulta específica, podemos passar como parâmetros tanto o Nome do

Professor como o Nome do Departamento, filtrando as informações de acordo com a

necessidade.

1 ?- prof_depto(NmProf, NmDepto).

NmProf = 'Antonio'

NmDepto = 'Departamento de Administração' ;


NmDepto = 'Departamento de Ciências Humanas' ;

NmProf = 'Joaquim'

NmDepto = 'Departamento de Ciências Humanas' ;

NmProf = 'Luiz'

NmDepto = 'Departamento de Administração' ;

20

NmProf = 'Maria'

NmDepto = 'Departamento de Informática' ;

NmProf = 'Sérgio'

NmDepto = 'Departamento de Informática' ;

Yes

2 ?-

Tabela 29 – Resposta – Professor x Departamento


Para o predicado prof_curso foi utilizados os predicados prof_disc, disciplina e

curso, estabelecendo os relacionamentos que são necessários. O predicado prof_curso

está exibindo os atributos “Nome do Professor”(NmProf) e “Nome do Curso”

(NmCurso).

prof_curso(NmCurso, NmProf) :-

prof_disc( NmProf, IdProf, NmDisc, IdDisc, IdHora),

disciplina(NmDisc, IdCurso, IdDisc),

curso(NmCurso, IdCurso, IdDepto).

Tabela 30 – Predicado Professor x Curso

Na execução da consulta no predicado prof_curso, estamos passando por

parâmetro o nome do professor para filtrar os cursos que o mesmo participa.

1 ?- prof_curso(NmCurso, 'Sérgio').

NmCurso = 'Ciência da Computação' ;

Yes

2 ?-

Tabela 31 – Resposta Professor x Curso


O predicado prof_projeto apresenta os atributos “Nome do Professor”

(NmProf), “Nome do Projeto” (NmProj), “Nome do Tema” (NmTema) e “Nome da

Área” (NmArea) e utiliza os predicados professor e projeto para obter o resultado quais

projetos um professor participa.

prof_projeto(NmProf, NmProj, NmTema, NmArea) :-

odbc_query(bdprolog, 'Select idprofessor, idprojeto from

professor_projeto', row(IdProf, IdProj)),

professor(NmProf, IdProf, _),

projeto(NmProj, NmTema, NmArea, IdProj).

Tabela 32 – Predicado Professor x Projeto

Podemos passar como parâmetro qualquer um dos atributos para estabelecer

algum filtro.

1 ?- prof_projeto(NmProf, NmProj, NmTema, NmArea).

NmProf = 'Sérgio'

21

NmProj = 'Projeto 1 - Grupo 1'

NmTema = 'Tema 1'

NmArea = 'Area 1' ;

NmProf = 'Maria'

NmProj = 'Projeto 1 - Grupo 1'

NmTema = 'Tema 1'

NmArea = 'Area 1' ;

Yes

2 ?-

Tabela 33 – Resposta Professor x Projeto

Pode-se verificar nos predicados e nas regras criadas, que o PROLOG é uma

linguagem eficiente e prática para a realização de consultas. Essa facilidade é uma das

causas que torna a linguagem muito utilizada na área de inteligência artificial entre

outras aplicações. Os predicados foram desenvolvidos e possibilitaram a realização de

todas as consultas. Em uma linguagem imperativa, tenderíamos a concentrar os esforços

diretamente nas cláusulas SQL, para que estas já retornassem os dados solicitados, de

acordo com os filtros repassados para a mesma. A linguagem lógica possibilita que os

predicados trabalhem para retornar a informação desejada, e se mostra muito eficiente

neste processo.

3 - Scheme

As implementações em uma linguagem funcional serão desenvolvidas em Scheme. Nos

próximos itens estaremos descrevendo como foi realizado o acesso ao banco de dados,

como foram obtidas algumas respostas para as questões mencionadas, e também

algumas limitações que não foram contornadas utilizando este linguagem.

3.1 - Conexão com Banco de Dados

Para a implementação utilizando a linguagem Scheme, utilizou-se um banco de

dados com a mesma estrutura do banco utilizado em MySql para o PROLOG (este

banco em Access também pode ser utilizado normalmente com os códigos PROLOG

detalhados no item anterior). A configuração da fonte de dados segue basicamente os

mesmos passos descritos na configuração para o PROLOG, no qual deve-se adicionar a

fonte desejada e especificar o banco a que ela deverá estar relacionada.

22

Figura 4 – Fonte de Dados para Access

Para a conexão do Scheme com o banco de dados, a seguinte cláusula deverá ser

incluída no código:

;; Carga do srpersist

(require (lib "srpersist.ss" "srpersist"))

Tabela 34 – Função de conexão

Este comando relaciona o arquivo srpersist.ss, que estará possibilitando a comunicação

com a base de dados utilizada. Sem o relacionamento com este arquivo, não é possível

realizar operações com acesso ao banco. Após isso, também exige-se a inclusão da

seguinte cláusula:

;; Antes de connectar-se a um banco, é necessário alocar um

'Environment Handle' e um 'Connection Handle'

(define henv (alloc-env))

(define hdbc (alloc-connect henv))

Tabela 35 – Alocação de 'Environment Handle' e um 'Connection Handle'

Por fim, deve-se incluir um comando que realizará uma chamada externa para que o

usuário esteja selecionando a fonte de dados à qual deseja se conectar (figura 5). Após

selecionada a fonte de dados, o programa encontra-se pronto para utilização.

23

Figura 5 – Seleção de Fonte de Dados

O comando que realiza esta chamada, é descrito abaixo: ; Chamada externa para identificar o drive ODBC

(driver-connect hdbc " " 'sql-driver-complete)

Tabela 36 – Chamada externa ao drive ODBC

3.3 - Implementação

Para a implementação com Scheme, também foi utilizado o esquema SQL

representado no item 1. Assim como em Prolog, as listas necessárias para a resolução

dos problemas vistos neste estudo de caso, foram criadas também através de scripts de

consulta SQL.

A função União, foi definida com a finalidade de auxiliar na construção das

listas a partir das consultas sql. A lista é criada a partir de uma varredura em todas as

tuplas resultantes da consulta, onde cada tupla, é criada uma nova lista, incluída na lista

ancestral. Na tabela abaixo, mostramos o código da função união.

(define (uniao a b)

(if (null? a)

b

(cons (car a) (uniao (cdr a) b))))

Tabela 37 – Função União

24

Para verificar quais os elementos que existem na lista, utilizamos a função

pertence?.

(define (pertence? x l)

(if (null? l)

#f

(if (equal? x (car l))

#t

(pertence? x (cdr l)))))

Tabela 38 – Função Pertence?

A função consul é utilizada em todas as questões para criar as listas de respostas. Esta

função trabalha de forma genérica, removendo todos os elementos que não fazem parte

da resposta.

(define consul

(lambda (chave tabela)

(cond

((null? tabela) '())

((pertence? chave (car tabela))

(cons (car tabela) (consul chave (cdr tabela))))

(else (consul chave (cdr tabela))) )))

Tabela 39 – Chamada e Execução do Script SQL

Para a realização de consultas em cada tabela criada em SQL, é utilizada a

função hstmt, exibida na tabela abaixo, que tem por objetivo retornar a conexão com o

banco para a execução da consulta. É repetida a definição desta função em cada

consulta realizada.

(define hstmt (alloc-stmt hdbc))

Tabela 40 – Função HSTMT

A chamada ao script SQL é realizada através da função prepare hstm, onde é

passada a consulta em SQL e é executada pela função sql-execute, conforme o exemplo

exibido na tabela 41.

(prepare hstmt "Select pesquisador, nome_prof from Professor order

by nome_prof")

(sql-execute hstmt)

Tabela 41 – Chamada e Execução do Script SQL

Para cada questão pré-definida, fizemos o uso de funções para a criação de

buffers para cada atributo resultante das consultas SQL, com seus respectivos tipos

associados. E também, utilizamos funções para a criação de indicadores para cada

atributo. E ainda, para a execução das rotinas fizemos uso de códigos semelhantes, onde

alterou apenas os buffers e os indicadores, criados para cada consulta, como poderá ser

visto nas especificações de cada questão.

25

3.3.1 - Questões pré-determinadas para a resolução do problema.

Na seqüência, são exibidos os códigos para geração impressão das listas criadas para

responder as perguntas definidas neste estudo de caso. Estas implementações fazem uso

das funções anteriormente especificadas.


Para criar a lista que responde a questão acima, a função prepare, para receber a

consulta SQL desta questão e a função sql-execute para executar esta consulta, como já

foi explicado. Estes códigos estão exibidos na tabela 42.

; Chamada para SQL

(prepare hstmt "SELECT p.nome_prof, h.horario, d.dia_sem

FROM professor AS p, professor_disciplina AS pd, horario AS h,

dia d WHERE (((p.idprofessor)=[pd].[idprofessor]) AND

((pd.idhorario)=[h].[idhorario]))and h.iddia=d.iddia

order by p.nome_prof")

(sql-execute hstmt)

Tabela 42 – Chamada e Execução do Script SQL – 1ª questão

Criação dos buffers e indicadores.

; Criação de buffer para cada atributo do SQL com respectivo

formato (colocar na sequencia)

(define nmprof-buf (make-buffer 'sql-c-char 50))

(define nmhora-buf (make-buffer 'sql-c-char 50))

(define nmdia-buf (make-buffer 'sql-c-char 50))

; --- comando obrigatório

; Criação de indicador para cada atributo do SQL

(define nmprof-ind (make-indicator))

(define nmhora-ind (make-indicator))

(define nmdia-ind (make-indicator))

(define-struct r_prof (pesqui nmprof nmdia))

(define cria-lista (lambda (lista-i lista-c)

(cons lista-i (cria-lista ))))

(define resul_hora '())

; Rotina de execução

(with-handlers

([(lambda (exn)

(exn-no-data? exn))

(lambda (exn)

(printf "~n*** Fim dos dados ***~n"))])

(let loop ()

(fetch hstmt)

(get-data hstmt 1 nmprof-buf nmprof-ind)

(get-data hstmt 2 nmhora-buf nmhora-ind)

(get-data hstmt 3 nmdia-buf nmdia-ind)

; Display dos atributos de professor em formatto de lista.

(display (list

(read-buffer nmprof-buf 0)

26

(read-buffer nmhora-buf 0)

(read-buffer nmdia-buf 0)))

(newline)

(list (read-buffer nmprof-buf 0)


(read-buffer nmdia-buf 0))

(set! resul_hora (uniao resul_hora (list(list



(read-buffer nmdia-buf 0)))))

(free-buffer! nmprof-buf)

(free-buffer! nmhora-buf)

(free-buffer! nmdia-buf)

(loop)))

Tabela 43 – Buffers e Indicadores – 1ª questão.

Para obter a resposta a questão, executamos a função cônsul, onde são passados

os parâmetros o nome do professor “Sérgio” que será a chave para a consulta e a

função resul_hora que armazena, em formato de lista, todas as tuplas resultantes da

consulta SQL. A chamada a função e o resultado são exibidos na tabela 44.

> (consul "Sérgio" resul_hora)

(("Sérgio" "08:20 s 09:10" "Seg") ("Sérgio" "07:30 s 08:20" "Seg"))

>

Tabela 44 – Chamada da função cônsul e o resultado – 1ª questão.


Na tabela 45, mostramos as funções prepare, a criação dos buffers e indicadores,

e a rotina de execução.

; Chamada para SQL

(prepare hstmt "SELECT d.nome_disc, h.horario FROM disciplina AS d,

horario AS h, professor_disciplina AS pd WHERE

(((d.iddisciplina)=[d].[iddisciplina]) AND

((pd.idhorario)=[h].[idhorario])) ORDER BY d.nome_disc")

(sql-execute hstmt)

; Informa o nro de colunas resultado do sql

(display (num-result-cols hstmt)) (newline)(newline)



(define nmdisc-buf (make-buffer 'sql-c-char 50))

(define nmhora-buf (make-buffer 'sql-c-char 50))



(define nmdisc-ind (make-indicator))

(define nmhora-ind (make-indicator))

(define resul_dischora '())


(with-handlers

27

([(lambda (exn)

(exn-no-data? exn))

(lambda (exn)


(let loop ()

(fetch hstmt)

(get-data hstmt 1 nmdisc-buf nmdisc-ind)

(get-data hstmt 2 nmhora-buf nmhora-ind)


(display (list

(read-buffer nmdisc-buf 0)

(read-buffer nmhora-buf 0)))

(newline)

(list (read-buffer nmdisc-buf 0)

(read-buffer nmhora-buf 0))

(set! resul_dischora (uniao resul_dischora (list(list

(read-buffer nmdisc-buf 0)

(read-buffer nmhora-buf 0)))))

(free-buffer! nmdisc-buf)

(free-buffer! nmhora-buf)

(loop)))

Tabela 45 – Buffer, indicadores e rotinas de execução – 2ª questão.

Na execução da função consul, mostrada na tabela 46, passamos como

parâmetro “Linguagem” que faz a busca na lista resul_dischora resultante da

consulta SQL.

> (consul "Linguagem" resul_dischora)

(("Linguagem" "07:30 s 08:20")

("Linguagem" "20:10 s 21:00")

("Linguagem" "16:30 s 17:20")

("Linguagem" "07:30 s 08:20")

("Linguagem" "08:20 s 09:10")

("Linguagem" "22:10 s 23:00")

("Linguagem" "19:20 s 20:10")

("Linguagem" "10:30 s 11:20")

("Linguagem" "14:20 s 15:10")

("Linguagem" "09:40 s 10:30")

("Linguagem" "21:20 s 22:10 ")

("Linguagem" "13:30 s 14:20")

("Linguagem" "15:40 s 16:30"))

>



Função prepare e chamada a execução do SQL.

(prepare hstmt "Select pesquisador, nome_prof from Professor order

by nome_prof")

(sql-execute hstmt)

Tabela 47 – Chamada e Execução do Script SQL – 3ª questão

A tabela 48 mostra o código de criação do buffer e indicadores.

28



(define pesqui-buf (make-buffer 'sql-c-char 2))




(define pesqui-ind (make-indicator))


(define-struct r_prof (pesqui nmprof))



(define resul_professor '())


(with-handlers

([(lambda (exn)

(exn-no-data? exn))

(lambda (exn)


(let loop ()

(fetch hstmt)

(get-data hstmt 1 pesqui-buf pesqui-ind)



(display (list

(read-buffer pesqui-buf 0)

(read-buffer nmprof-buf 0)))

(newline)

(list (read-buffer pesqui-buf 0)

(read-buffer nmprof-buf 0))

(set! resul_professor (uniao resul_professor (list(list

(read-buffer pesqui-buf 0)

(read-buffer nmprof-buf 0)))))

(free-buffer! pesqui-buf)


(loop)))

Tabela 48 – Buffers e Indicadores – 3ª questão.

Para obter a resposta a questão, executamos a função cônsul, onde são passados

os parâmetros “S”. A função resul_professor que é utilizada para guardar os armazenar

os valores durante a varredura em todas as tuplas da tabela. A chamada a função e o

resultado é exibido na tabela 49.

> (consul "S" resul_professor)

(("S" "Maria Conceição") ("S" "Sérgio"))

>

Tabela 49 – Chamada da função cônsul e o resultado de professor – 3ª questão.

29




; Chamada para SQL

(prepare hstmt "SELECT professor.nome_prof, artigo.titulo_art,

professor_artigo.tipo_autoria

FROM artigo, professor, professor_artigo

WHERE professor_artigo.idprofessor = professor.idprofessor and

professor_artigo.idartigo = artigo.idartigo and

professor_artigo.tipo_autoria='A' ORDER BY professor.nome_prof")

(sql-execute hstmt)






(define nmarti-buf (make-buffer 'sql-c-char 50))




(define nmarti-ind (make-indicator))




(define resul_artigo '())


(with-handlers

([(lambda (exn)

(exn-no-data? exn))

(lambda (exn)


(let loop ()

(fetch hstmt)


(get-data hstmt 2 nmarti-buf nmarti-ind)


(display (list


(read-buffer nmarti-buf 0)))

(newline)


(read-buffer nmarti-buf 0))

(set! resul_artigo (uniao resul_artigo (list(list


(read-buffer nmarti-buf 0)))))


30

(free-buffer! nmarti-buf)

(loop)))

Tabela 50– Buffer, indicadores e rotinas de execução – 4ª questão.

Na execução da função consul, mostrada na tabela 51, passamos como

parâmetro “Linguagem” que faz a busca na lista resul_artigo resultante da consulta

SQL.

> (consul "Sérgio" resul_artigo)

(("Sérgio" "Titulo 4"))

>





; Chamada para SQL

(prepare hstmt "SELECT professor.nome_prof, artigo.titulo_art FROM

artigo, professor, professor_artigo WHERE

professor_artigo.idprofessor = professor.idprofessor and

professor_artigo.idartigo = artigo.idartigo ORDER BY

professor.nome_prof")

(sql-execute hstmt)






(define nmarti-buf (make-buffer 'sql-c-char 50))




(define nmarti-ind (make-indicator))




(define resul_artigo '())


(with-handlers

([(lambda (exn)

(exn-no-data? exn))

(lambda (exn)


(let loop ()

(fetch hstmt)


(get-data hstmt 2 nmarti-buf nmarti-ind)

31


(display (list


(read-buffer nmarti-buf 0)))

(newline)


(read-buffer nmarti-buf 0))

(set! resul_artigo (uniao resul_artigo (list(list


(read-buffer nmarti-buf 0)))))


(free-buffer! nmarti-buf)

(loop)))


Na tabela 53 mostra a execução da função consul, passamos como parâmetro

“Sérgio” que faz a busca na lista resul_artigo resultante da consulta SQL.

> (consul "Sérgio" resul_artigo)

(("Sérgio" "Titulo 4"))

>

Tabela 53– Chamada da função cônsul e o resultado – 5ª questão.




; Chamada para SQL

(prepare hstmt "select p.nome_prof, d.nome_dpto from departamento

d, professor p where p.iddepartamento=d.iddepartamento order by

d.nome_dpto")

(sql-execute hstmt)






(define nmdpto-buf (make-buffer 'sql-c-char 50))




(define nmdpto-ind (make-indicator))

(define resul_depto '())


(with-handlers

([(lambda (exn)

(exn-no-data? exn))

(lambda (exn)


32

(let loop ()

(fetch hstmt)


(get-data hstmt 2 nmdpto-buf nmdpto-ind)

; Display dos atributos de professor e departamento em formatto de

lista.

(display (list


(read-buffer nmdpto-buf 0)))

(newline)


(read-buffer nmdpto-buf 0))

(set! resul_depto (uniao resul_depto (list(list


(read-buffer nmdpto-buf 0)))))


(free-buffer! nmdpto-buf)

(loop)))



“Sérgio” que faz a busca na lista resul_depto resultante da consulta SQL.

> (consul "Sérgio" resul_depto)

(("Sérgio" "DepartamentoInformtica"))

>




e a rotina de execução para a questão 7.

; Chamada para SQL

(prepare hstmt "select p.nome_prof, c.nome_cur from professor p,

curso c, disciplina d, professor_disciplina pd where

pd.iddisciplina=d.iddisciplina and pd.idprofessor=p.idprofessor and

d.idcurso=c.idcurso order by p.nome_prof")

(sql-execute hstmt)






(define nmcurs-buf (make-buffer 'sql-c-char 50))




(define nmcurs-ind (make-indicator))

(define resul_curso '())

33


(with-handlers

([(lambda (exn)

(exn-no-data? exn))

(lambda (exn)


(let loop ()

(fetch hstmt)


(get-data hstmt 2 nmcurs-buf nmcurs-ind)

; Display dos atributos de professor e departamento em formatto de

lista.

(display (list


(read-buffer nmcurs-buf 0)))

(newline)


(read-buffer nmcurs-buf 0))

(set! resul_curso (uniao resul_curso (list(list


(read-buffer nmcurs-buf 0)))))


(free-buffer! nmcurs-buf)

(loop)))



“Sérgio” que faz a busca na lista resul_curso resultante da consulta SQL.

> (consul "Sérgio" resul_curso)

(("Sérgio" "CiênciaComputação") ("Sérgio" "CiênciaComputação"))

>





; Chamada para SQL

(prepare hstmt "SELECT p.nome_prof, pj.nome_proj FROM professor AS

p, projeto AS pj, professor_projeto AS pp WHERE

p.idprofessor=pp.idprofessor and pj.idprojeto=pp.idprojeto ORDER BY

p.nome_prof")

(sql-execute hstmt)






(define nmproj-buf (make-buffer 'sql-c-char 50))

34




(define nmproj-ind (make-indicator))

(define resul_proj '())


(with-handlers

([(lambda (exn)

(exn-no-data? exn))

(lambda (exn)


(let loop ()

(fetch hstmt)


(get-data hstmt 2 nmproj-buf nmproj-ind)

; Display dos atributos de professor e do projeto.

(display (list


(read-buffer nmproj-buf 0)))

(newline)


(read-buffer nmproj-buf 0))

(set! resul_proj (uniao resul_proj (list(list


(read-buffer nmproj-buf 0)))))


(free-buffer! nmproj-buf)

(loop)))



“Sérgio” que faz a busca na lista resul_ proj resultante da consulta SQL.

> (consul "Sérgio" resul_proj)

(("Sérgio" "Projeto1Grupo1"))

>


35

4 - Conclusão

Trabalhar na busca de solução para um problema específico utilizando os

paradigmas lógico e funcional, permitiu pela prática, a inferência de muitos itens

que dizem respeito à importância, às diferenças, às dificuldades, facilidades e

características próprias de cada abordagem. No decorrer deste trabalho, percebemos

que mudar de paradigma é muito mais do que simplesmente aprender e

compreender uma nova linguagem de programação; a forma de pensar, de

raciocinar, de buscar a solução para um problema também tem de ser modificada.

Cada paradigma distinto, corresponde à uma forma particular de resolver e

representar um problema, e isto exige que a nossa capacidade de pensamento ajuste-

se às formas de cada um.

Essa questão de „pensar diferente‟ contribui para que estejamos, não só

aprendendo a ver de várias formas a mesma solução para um problema, mas

também, a construir e elaborar estruturas de raciocínio, que nos permitam ver várias

soluções para um mesmo problema. Torna-se possível evoluir na forma como

costumamos abordar e propor soluções para os problemas de uma forma geral.

Nas experiências realizadas utilizando o paradigma funcional, a busca pela solução

ocasionou uma alteração radical em nossa forma „comum‟ de tratar um problema.

Foi necessária a definição de funções, a utilização de mecanismos de controle

recursivos ao invés de iterativos, e também, uma série de procedimentos

completamente diferentes dos métodos utilizados nas linguagens imperativas (como

a não utilização de variáveis e de comandos de atribuição). No contexto do

problema, a linguagem funcional Scheme apresentou-se mais complexa para se

aprender e implementar, porém, as respostas para as perguntas realizadas puderam

ser obtidas através da criação de uma única função, criada para trabalhar com uma

lista que disponibiliza as informações acessadas na base de dados.

Considerando-se as implementações efetuadas utilizando o paradigma da

programação em lógica, o seu desenvolvimento exigiu um meio totalmente diferente

de codificação, porém, menos conflitante com nossa capacidade e com nosso

costume de raciocinar sobre os problemas do mundo real. Na abordagem lógica, a

representação do problema a ser resolvido deve ser expressa na forma de lógica

simbólica, e um programa não é caracterizado por uma seqüência de operações

como é o caso das linguagens imperativas, e sim por uma „base de conhecimento‟

relacionada ao domínio do problema, juntamente com as perguntas realizadas para a

mesma. As implementações realizadas em Prolog foram mais facilmente elaboradas

e construídas que em Scheme, porém, exigiram um volume de codificação

significativamente maior, visto que não é possível definir perguntas tão genéricas,

numa mesma proporção em que é possível criar funções deste tipo em uma

linguagem funcional.

Uma avaliação sobre as duas abordagens, exigiria a análise de um complexo

conjunto de fatores como domínio do problema, propósito da implementação,

conhecimento e experiência dos programadores etc, para então ser possível optar

por qual delas utilizar. Uma linguagem lógica é mais prática para retornar respostas

às perguntas realizadas (o caso do nosso problema), enquanto que uma linguagem

funcional seria mais indicada para implementações que exigem cálculo e operações

matemáticas mais complexas. Assim, no contexto da realização do trabalho,

podemos mencionar que as principais representações de cada paradigma são: as

"funções" aplicadas aos argumentos e que retornam os valores no caso do paradigma

36

funcional, e as "proposições", aceitas como verdadeiras em um certo domínio no

caso do paradigma lógico.

37

5 – Referencias Bibliográficas

BARANAUSKAS, Maria Cecília Calani; Procedimento, Função, Objeto ou Lógica?

Linguagens de Programação Vistas Pelos Seus Paradigmas; NIED UNICAMP; 1998.

CASANOVA, Marco A; GIORNO, Fernando A. C.; FURTADO, Antonio L.;

Programação em Lógica e a Linguagem Prolog; São Paulo, Ed. Edgard Blücher Ltda;

1987.

GHEZZI, Carlo; JAZAYERI, Mehdi. Programminf Language Concepts. 3 ed –

USA;1997.

PUC-RJ; http://www.inf.puc-rio.br/~roberto/icc/texto/icc.html; acessado em

novembro/2006.

SEBESTA, Robert W; Conceitos de linguagens de programação; 5 ed. – Porto Alegre,

Bookman; 2003.

VICENTE, André Abe; Apostila Prolog; http://www.inf.unioeste.br/~abvicente;

acessado em outubro/2006.

http://www.inf.puc-rio.br/~roberto/icc/texto/icc.html

http://www.inf.unioeste.br/~abvicente

Programação Funcional e Programação Lógica Uma...

Documents

Transcript of Programação Funcional e Programação Lógica Uma...