tcc ii - vinicius luiz webber - IIS Windows Server

UNIVERSIDADE DO VALE DO ITAJAÍ
CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
FERRAMENTA PARA A CORREÇÃO AUTOMÁTICA DE EXERCÍCIOS
DA LINGUAGEM SQL - QuicklySQL
Área de Informática na Educação e Banco de Dados
por
Vinicius Luiz Webber
Benjamin Grando Moreira, M. Eng.
Orientador
Júlia Marques Carvalho da Silva, M. Sc.
Co-orientadora
Itajaí (SC), novembro de 2009
UNIVERSIDADE DO VALE DO ITAJAÍ
CENTRO DE CIÊNCIAS TECNOLÓGICAS DA TERRA E DO MAR
CURSO DE CIÊNCIA DA COMPUTAÇÃO
FERRAMENTA PARA A CORREÇÃO AUTOMÁTICA DE EXERCÍCIOS
DA LINGUAGEM SQL - QuicklySQL
Área de Informática na Educação e Banco de Dados
por
Vinicius Luiz Webber
Relatório apresentado à Banca Examinadora do
Trabalho de Conclusão do Curso de Ciência da
Computação para análise e aprovação.
Orientador: Benjamin Grando Moreira, M. Eng.
Itajaí (SC), novembro de 2009
AGRADECIMENTOS
Gostaria de agradecer a Deus, que me deu forças para conseguir finalizar mais esta etapa da minha
vida.
Aos meus pais, Darcilo Luiz Webber e Eluzane Salete Webber, que sempre me incentivaram, deram
apoio e me compreenderam durante a minha vida.
A minha Esposa Alessandra pelo apoio, ajuda, dedicação, carinho e compreensão no decorrer desta
jornada.
E a todos familiares e amigos que de forma direta ou indireta contribuíram para que este sonho se
realizasse.
Gostaria de agradecer ao Tim Hunt, membro da comunidade de desenvolvedores do Moodle e um
dos responsáveis pelas atualizações do ambiente, pela ajuda nos momentos de dificuldade.
Um agradecimento especial a todos os mestres que participaram da minha formação acadêmica.
ii
SUMÁRIO
LISTA DE ABREVIATURAS................................................................... v
LISTA DE FIGURAS................................................................................vi
LISTA DE TABELAS .............................................................................viii
RESUMO....................................................................................................ix
ABSTRACT................................................................................................. x
1 INTRODUÇÃO .................................................................................... 11
1.1 PROBLEMATIZAÇÃO ................................................................................... 14
1.1.1 Formulação do Problema ............................................................................... 14
1.1.2 Solução Proposta ............................................................................................. 15
1.2 OBJETIVOS ...................................................................................................... 15
1.2.1 Objetivo Geral ................................................................................................. 15
1.2.2 Objetivos Específicos ...................................................................................... 15
1.3 METODOLOGIA.............................................................................................. 16
1.4 ESTRUTURA DO TRABALHO ..................................................................... 16
2 FUNDAMENTAÇÃO TEÓRICA ...................................................... 18
2.1 A LINGUAGEM SQL....................................................................................... 18
2.1.1 Sublinguagens e componentes da linguagem SQL ...................................... 18
2.2 TÉCNICAS PARA A CORREÇÃO AUTOMÁTICA................................... 28
2.2.1 Autômatos ........................................................................................................ 28
2.2.2 Expressões Regulares...................................................................................... 36
2.3 APLICAÇÕES SIMILARES ........................................................................... 40
2.3.1 SQL WEB ........................................................................................................ 40
2.3.2 LabSQL............................................................................................................ 44
2.3.3 SQL-Tutor ....................................................................................................... 47
2.3.4 Comparativo das Ferramentas ...................................................................... 51
2.4 O AMBIENTE MOODLE ................................................................................ 52
2.4.1 Estrutura básica e características do Moodle .............................................. 53
2.4.2 Desenvolvendo para o Moodle ....................................................................... 56
3 DESENVOLVIMENTO ...................................................................... 62
3.1 SISTEMA DESENVOLVIDO.......................................................................... 62
3.1.1 Análise de Requisitos ...................................................................................... 63
3.1.1.1 Requisitos Funcionais ................................................................................... 63
3.1.1.2 Requisitos Não Funcionais ........................................................................... 64
3.1.1.3 Regras de Negócio ......................................................................................... 65
3.1.2 Diagrama de Classes ....................................................................................... 65
3.2 INTERFACES DO SISTEMA ......................................................................... 69
3.2.1 Telas do professor ........................................................................................... 69
iii
3.2.2 Telas do aluno.................................................................................................. 75
3.3 IMPLEMENTAÇÃO ........................................................................................ 77
3.3.1 Etapas da correção automática...................................................................... 80
3.4 LIMITAÇÕES ................................................................................................... 81
3.5 TESTES E AVALIAÇÃO................................................................................. 82
4 CONCLUSÃO ...................................................................................... 85
4.1 TRABALHOS FUTUROS................................................................................ 86
REFERÊNCIAS BIBLIOGRÁFICAS ................................................... 87
A FUNÇÕES DE GRUPO DA DML ..................................................... 90
B DIAGRAMAS....................................................................................... 93
Diagrama de Atividades............................................................................................ 93
Diagrama ER ............................................................................................................. 95
C INSTALANDO O QUICKLY SQL NO MOODLE ......................... 97
iv
LISTA DE ABREVIATURAS
CBM
Constraint-Based Modeling
DCL
Data Control Language
DDL
Data Definition Language
DER
Diagrama Entidade-Relacionamento
DML
Data Manipulation Language
DQL
Data Query Language
FAZU
Faculdades Associadas de Uberaba
HTML
Hyper Text Markup Language
IBM
International Business Machines
LMS
Learning Management System
MOODLE
Modular Object-Oriented Dynamic Learning Environment
PHP
Hypertext Preprocessor
SEQUEL
Structured English Query Language
SISNET
Tecnologia em Sistemas para a Internet
SGDB
Sistema Gerenciador de Banco de Dados
SQL
Structured Query Language
TCC
Trabalho de Conclusão de Curso
UFPA
Universidade Federal do Pará
UML
Unified Modeling Language
UNIBE
Universidade de Uberaba
UNIVALI
Universidade do Vale do Itajaí
URL
Uniform Resource Location
v
LISTA DE FIGURAS
Figura 1. Gráfico das médias finais do ano de 2007 dos alunos da disciplina de banco de dados do
curso SISNET.............................................................................................................................13
Figura 2. Sintaxe básica do comando SELECT..................................................................................19
Figura 3. Sintaxe do comando SELECT usando o ORDER BY..........................................................20
Figura 4. Exemplo de ordenação ascendente e descendente. .............................................................21
Figura 5. Sintaxe do comando SELECT utilizando-se o argumento WHERE. ..................................21
Figura 6. Exemplo da combinação dos operadores AND e OR..........................................................22
Figura 7. Exemplo de uso do operador IS NULL. ..............................................................................23
Figura 8. Sintaxe básica do comando BETWEEN..............................................................................23
Figura 9. Exemplos de utilização do operador LIKE. ........................................................................24
Figura 10. Sintaxe básica do operador IN. .........................................................................................25
Figura 11. Sintaxe básica para fazer uma junção de tabelas. .............................................................25
Figura 12. Exemplo de uma junção CROSS JOIN. ............................................................................26
Figura 13. Exemplo de uma junção INNER JOIN. ............................................................................27
Figura 14. Exemplo da junção INNER JOIN utilizando as cláusulas USING e ON. .........................27
Figura 15. Utilizando ALIASES..........................................................................................................28
Figura 16. Autômato finito determinístico.........................................................................................30
Figura 17. Diagrama de um autômato finito determinístico para reconhecimento de seqüência de
dois símbolos iguais. ..................................................................................................................32
Figura 18. Transição de um autômato finito não determinístico........................................................33
Figura 19. Diagrama de um autômato finito não determinístico para reconhecimento de seqüência
de dois símbolos iguais. .............................................................................................................34
Figura 20. Autômato finito não determinístico com movimentos vazios. .........................................35
Figura 21. Página inicial do SQL WEB, contendo o menu de opções na parte superior da página. .42
Figura 22. Tela de cadastro de exercício – SQL WEB. .....................................................................43
Figura 23. Tela de resolução de exercício – SQL WEB. ...................................................................43
Figura 24. Visão geral da arquitetura do LabSQL utilizando métricas para avaliação automática. ..45
Figura 25. Interface onde o aluno testa seus códigos e visualiza dados estatísticos - LabSQL. ........46
Figura 26. Relatório de acompanhamento do aprendiz em exercícios de SQL - LabSQL. ...............47
Figura 27. Arquitetura da versão stand-alone do SQL-Tutor. ...........................................................48
Figura 28. Arquitetura da versão web do SQL-Tutor.........................................................................49
Figura 29. Interface do usuário - SQL-Tutor. ....................................................................................51
Figura 30. Diagrama das classes para elaboração das telas do sistema. ............................................67
Figura 31. Diagrama das classes utilizadas para criar o tipo de questão SQL_Exercises. .................68
Figura 32. Tela de administração do curso. .......................................................................................69
Figura 33. Tela para a escolha do tipo de questão a ser criada. .........................................................70
Figura 34. Tela de edição da questão a ser criada. .............................................................................71
Figura 35. Tela com o relatório das notas da turma. ..........................................................................72
Figura 36. Tela do professor com dados sobre as tentativas da turma...............................................73
Figura 37. Tela do professor com a revisão das tentativas de cada aluno..........................................74
Figura 38. Tela do inicial do curso.....................................................................................................75
Figura 39. Tela para o aluno responder o questionário. .....................................................................76
Figura 40. Autômato padrão gerado por um select genérico. ............................................................77
Figura 41. Exemplo de um autômato gerado por uma resposta padrão. ............................................78
Figura 42. Exemplo de uma resposta do aluno. .................................................................................80
Figura 43. Exemplo de resposta padrão. ............................................................................................83
vi
Figura 44. Primeira tentativa do aluno. ..............................................................................................83
Figura 45. Segunda tentativa do aluno. ..............................................................................................84
Figura 46. Terceira tentativa do aluno. ..............................................................................................84
Figura 47. Exemplos da utilização da função COUNT. .....................................................................90
Figura 48. Cláusula DISTINCT da função COUNT. ..........................................................................91
Figura 49. Sintaxe básica do comando GROUP BY...........................................................................92
Figura 50. Exemplo da cláusula HAVING do comando GROUP BY.................................................93
Figura 51. Diagrama de atividades do aluno......................................................................................94
Figura 52. Diagrama ER para o sistema proposto..............................................................................95
Figura 53. Tela de administração do sistema. ....................................................................................97
vii
LISTA DE TABELAS
Tabela 1. Descrição da sintaxe básica do comando SELECT. ...........................................................20
Tabela 2. Relação dos operados relacionais.......................................................................................21
Tabela 3. Relação dos operados lógicos.............................................................................................22
Tabela 4. Combinações do operador LIKE. .......................................................................................23
Tabela 5. Função programa para reconhecer seqüência de dois símbolos iguais. .............................31
Tabela 6. Função programa de um autômato finito não determinístico, para reconhecer seqüência de
dois símbolos iguais. ..................................................................................................................34
Tabela 7. Tabela de transições do autômato finito não determinístico com movimentos vazios. .....35
Tabela 8. Exemplo de expressões regulares e as linguagens geradas. ...............................................37
Tabela 9. Comparativo das ferramentas pesquisadas com a ferramenta proposta por este trabalho. 51
Tabela 10. Penalidades. ......................................................................................................................81
Tabela 11. Funções de grupo..............................................................................................................90
Tabela 12. Descrição das cláusulas da sintaxe do comando GROUP BY. .........................................92
viii
RESUMO
WEBBER, Vinicius Luiz. Ferramenta para a Correção Automática de Exercícios da
Linguagem SQL. Itajaí, 2009. 98 f. Trabalho de Conclusão de Curso (Graduação em Ciência da
Computação)–Centro de Ciências Tecnológicas da Terra e do Mar, Universidade do Vale do Itajaí,
Itajaí, 2009.
As disciplinas de banco de dados, geralmente ministradas em cursos da área tecnológica, possuem
como um dos seus principais objetivos, introduzir os alunos na linguagem SQL (Structured Query
Language). A linguagem SQL surgiu na década de 70 e se tornou a linguagem padrão para se
trabalhar com banco de dados, devido a vários fatores. Por se tratar de uma linguagem complexa,
exige-se muita prática por parte do aprendiz, tal prática é exercida através de exercícios de fixação
passados pelo professor. Como durante a disciplina de banco de dados também são vistos outros
tópicos e a quantidade de exercícios necessária para fixação do conteúdo é alta, o professor acaba
encontrando dificuldades em corrigir todos os exercícios, limitando assim a quantidade dos
mesmos. Pensando nesses problemas, foi criada uma ferramenta que realiza a correção automática
dos exercícios passados pelo professor, gerando relatórios sobre o desempenho de cada aluno.
Pensando em atingir um público grande, esta ferramenta foi desenvolvida como um módulo para o
ambiente de aprendizagem Moodle, utilizado em instituições de todo o mundo. Durante este
trabalho utilizou-se como fundamentação teórica os seguintes tópicos: (I) O ambiente Moodle, suas
características e estruturas básicas; (II) A linguagem SQL, abordando as principais estruturas
utilizadas no desenvolvimento desta ferramenta; (III) Técnicas para realizar a correção automática;
e (IV) Pesquisa de aplicações similares, para se ter um entendimento do que existe na área. Devido
a complexidade do código fonte do Moodle, o qual demandou-se muito tempo para compreensão, e
da própria correção automática, o presente trabalho, consegue atender somente consultas básicas
com algumas limitações descritas no item desenvolvimento.
Palavras-chave: Correção automática. SQL. Moodle.
ix
ABSTRACT
The disciplines of database, usually taught in courses of technological area, have as one of its main
objectives to introduce students in Structured Query Language (SQL). The SQL Language emerged
in 70´s, and became the default language to work with databases, because several factors. As it is a
complex language, it is requires much practice by the student, such practice is exercised through
fixing exercises passed by the teacher. As during the database discipline are also seen other topics
and the number of exercises to fix the content is high, the teacher founds difficulties to correct all
the exercises, so the quantity of them are limited. Thinking these problems, this work developed a
tool that performs the automatic correction of the exercises passed by the teacher, generating
reports on the performance of each student. Thinking of reaching a large audience, this tool was
developed as a module to the learning environment Moodle, used by institutions around the world.
During this work was used as theoretical foundation the following topics: (I) The environment
Moodle, this features and basic structures; (II) The SQL Language, containing the main structures
used in developing this tool; (III) techniques to perform the automatic correction; and (IV) The
research of similar applications, to known what exists in the area. Due to the complexity of the
source code of Moodle, which demanded a lot of time for understanding, and the automatic
correction itself, the present work accepts only basic queries with some limitations described in the
development item.
Keywords: Automatic Correction. SQL. Moodle.
x
1 INTRODUÇÃO
O objetivo de uma disciplina de banco de dados é fornecer ao aluno conceitos que permitam
o mesmo a usar, projetar e implementar um sistema de banco de dados. Date (2004) define um
sistema de banco de dados como “um sistema computadorizado de manutenção de registros”, ou
seja, é um repositório para se armazenar dados computadorizados. Os usuários de um sistema de
banco de dados podem executar diversas operações no sistema, através destas os usuários podem
gerenciar um banco de dados, essas operações podem ser:
•
Acrescentar novos registros ao banco de dados;
•
Alterar dados de um registro existente;
•
Buscar por dados de registros armazenados no banco de dados;
•
Excluir dados de um registro existente;
•
Acrescentar dados em um registro existente; e
•
Remover registros do banco de dados.
Um banco de dados é especificado por uma linguagem de definição de dados (Data
Definition Language – DDL), o resultado de uma compilação de uma DDL é um conjunto de
tabelas que são armazenadas em um arquivo especial chamado de dicionário de dados. Já para
realizar as operações de manipulação do banco de dados, necessita-se de uma linguagem de
manipulação de dados (Data Manipulation Language – DML), a qual permite os usuários a
acessar e manipular os dados contidos no banco de dados.
Com o tempo verificou-se a necessidade de uma linguagem padrão, foi quando em junho de
1970, E.F.Codd, membro do Laboratório de Pesquisa da IBM (International Business Machines)
em San Jose, na Califórnia, publicou um trabalho intitulado “A Relational Model os Data for Large
Shared Data Banks” (Um Modelo Relacional de Dados para Grandes Bancos de Dados
Compartilhados), Codd estabeleceu princípios sobre gerência de banco de dados, denominando-os
com o termo relacional, esse trabalho foi a base para a criação da linguagem SQL (Structured
Query Language) (OLIVEIRA, 2002) .
Inicialmente a SQL era chamada de SEQUEL (Structured English Query Language), a
linguagem SQL foi concebida e desenvolvida pela IBM, utilizando os conceitos de Codd, em 1979
a Relational Software Inc., hoje Oracle Corporation, lançou a primeira versão comercial da
linguagem SQL (OLIVEIRA, 2002).
A linguagem SQL fornece tanto uma DDL quanto uma DML muito ricas, com isso ela se
tornou a linguagem padrão e a maioria dos sistemas de banco de dados a utiliza. Durante as
disciplinas de banco de dados os alunos conhecem a linguagem SQL e a utilizam para a criação e
manipulação de bancos de dados, como essa linguagem é muito complexa, é necessário a prática
intensa para a fixação da mesma.
Ao longo do ano letivo os professores passam exercícios curriculares e extracurriculares
para os alunos resolverem, geralmente a quantidade de exercícios é alta, com isso o professor tem
dificuldade em corrigir os exercícios, pois demanda-se muito tempo com a correção. Mesmo com
esses exercícios alguns alunos podem não conseguir fixar todo o conteúdo obtendo médias baixas,
como mostram os dois gráficos, referente ao primeiro e segundo semestre letivo, do ano de 2007, da
disciplina de banco de dados do curso de Tecnologia em Sistemas para a Internet (SISNET),
oferecido por esta universidade, e que são representados pela Figura 1.
Os gráficos representados pela Figura 1 são referentes às notas dos alunos no que diz
respeito ao aprendizado da linguagem SQL por parte dos mesmos, não tendo ligação com o índice
de aprovação e reprovação da disciplina, representando assim somente as notas dos alunos.
12
Figura 1. Gráfico das médias finais do ano de 2007 dos alunos da disciplina de banco de dados do
curso SISNET.
Pensando nesses problemas desenvolveu-se um sistema para auxiliar o professor na correção
dos exercícios, ou seja, o sistema permite que o professor cadastre exercícios, e corrige
automaticamente os exercícios resolvidos pelos alunos.
Quando o professor cadastra alguma atividade o Moodle avisa os alunos via e-mail de forma
a complementar o aviso do professor, de que eles devem fazer os exercícios, uma vez feito isso o
aluno pode acessar o sistema através de um nome de usuário e senha e realizar os exercícios.
Uma vez que os exercícios tenham sido feitos pelos alunos, o sistema faz a correção dos
mesmos, através de técnicas de comparação, tais como autômatos e expressões regulares,
registrando a quantidade de acertos, a quantidade de erros, que tipo de erro que o aluno mais
cometeu, entre outros dados, através desses dados o sistema gera relatórios para que o professor
consiga acompanhar o andamento do aprendizado dos alunos.
Com esses relatórios em mãos o professor pode decidir como serão direcionadas as aulas, ou
seja, essa ferramenta além de ajudar na aprendizagem dos alunos, acaba se tornando uma
ferramenta de auxílio para o professor ministrar suas aulas de forma eficaz e eficiente, tentando
suprir a dificuldade de cada aluno.
13
Esta ferramenta foi desenvolvida como um módulo (novo tipo de questão), para o ambiente
de aprendizagem Moodle, assim esse trabalho não se restringe apenas a esta universidade, mas a
todo o público deste ambiente.
O Moodle (Modular Object-Oriented Dynamic Learning Environment) é um ambiente de
aprendizagem a distância que foi desenvolvido pelo australiano Martin Dougiamas no ano de 1999.
O Moodle é um software livre desenvolvido em HTML e PHP, e ainda encontra-se em
desenvolvimento, o ambiente fornece funções para que programadores continuem desenvolvendo
módulos para o mesmo (MOODLE, 2008b).
Este ambiente vem sendo utilizado por diversas instituições no mundo todo, existindo uma
grande comunidade que está sempre envolvida em atividades que abrangem desde correções de
erros e o desenvolvimento de novas ferramentas à discussão de estratégias pedagógicas de
utilização do ambiente e suas interfaces.
Como qualquer outro LMS (Learning Management System), o Moodle dispõe de um
conjunto de ferramentas que podem ser selecionadas pelo professor de acordo com seus objetivos
pedagógicos, assim permitindo que cursos que utilizem fóruns, diários, chats, questionários, etc.,
sejam oferecidos de forma mais flexibilizada, pois o professor, além de poder definir a sua
disposição na interface, poderá utilizar metáforas que imputem a estas ferramentas diferentes
perspectivas, tornando-se um espaço didático único (MOODLE, 2008b).
1.1 PROBLEMATIZAÇÃO
1.1.1 Formulação do Problema
A linguagem SQL exige uma prática intensa para a sua devida compreensão, para suprir essa
necessidade durante as disciplinas de banco de dados, lecionadas geralmente em cursos de áreas
tecnológicas, o professor passa exercícios para os alunos resolverem.
Como a quantidade de exercícios geralmente é alta o professor encontra dificuldades em
corrigir os exercícios, pois demanda-se muito tempo com a correção, limitando o tempo de prática
do aluno e ocasionando médias baixas.
14
1.1.2 Solução Proposta
A partir dos problemas aqui expostos surgiu a idéia desse trabalho, o qual desenvolveu um
sistema para auxiliar o professor na correção dos exercícios, ou seja, o sistema permite que o
professor cadastre exercícios, e corrige automaticamente os exercícios resolvidos pelos alunos,
retornando uma resposta imediata para o aluno e gerando relatórios de desempenho dos alunos e da
turma para o professor.
1.2 OBJETIVOS
1.2.1 Objetivo Geral
O objetivo geral deste trabalho foi desenvolver uma ferramenta que visa auxiliar o professor
a corrigir os exercícios de SQL resolvidos pelos alunos da disciplina de banco de dados, através da
correção automatizada.
1.2.2 Objetivos Específicos
Foram considerados objetivos específicos para este trabalho:
•
Pesquisar e analisar soluções similares;
•
Determinar os requisitos exigidos pelo sistema;
•
Compreender a metodologia de desenvolvimento para o ambiente Moodle;
•
Modelar o sistema;
•
Implementar o sistema;
•
Testar e avaliar a implementação do sistema; e
•
Documentar o sistema desenvolvido.
15
1.3 Metodologia
A metodologia utilizada para a realização deste Trabalho de Conclusão de Curso (TCC) está
dividida em etapas para melhor compreensão, onde ao final de cada uma delas, as mesmas podem
ser avaliadas e revisadas.
A etapa pertinente à fundamentação teórica constituiu em pesquisar e estudar alguns
conceitos como: fornecer uma introdução ao sistema Moodle, mostrando como desenvolver
módulos para o mesmo; descrever à linguagem SQL, apresentando suas estruturas básicas; definir
as técnicas de comparação de respostas que são: autômatos e expressões regulares; e apresentar o
estudo comparativo entre os sistemas similares pesquisados e o sistema proposto neste trabalho.
A etapa que compreende o desenvolvimento do sistema proposto tem como objetivo
apresentar a análise e modelagem conceitual seguindo os conceitos da UML (Unified Modeling
Language). Nesta etapa foi realizada a análise de requisitos funcionais, requisitos não funcionais e
regras de negócio, além da elaboração dos diagramas de classes, de atividades e do diagrama ER do
sistema desenvolvido, para complementar descreveu-se as telas do sistema, para melhor entender o
funcionamento do mesmo.
A última etapa apresenta as conclusões, apresentando o aprendizado durante o
desenvolvimento do sistema, as dificuldades encontradas e sugestões para trabalhos futuros.
1.4 Estrutura do trabalho
Este trabalho esta dividido em quatro capítulos, dispostos de forma lógica, sendo:
introdução, fundamentação teórica, desenvolvimento e conclusão.
A introdução contempla uma descrição geral e introdutória ao trabalho, o problema
identificado, sua solução, objetivos gerais e específicos a serem alcançados, além da metodologia
aplicada e a estrutura utilizada para disposição do trabalho.
A fundamentação teórica esta dividida em vários sub–capítulos, abordando conceitos sobre a
linguagem SQL, técnicas de comparação: Autômatos e expressões regulares, sistemas similares
com um comparativo entre eles e a ferramenta desenvolvida, e para finalizar, conceitos sobre o
sistema Moodle.
16
Já o desenvolvimento compreende a descrição do sistema desenvolvido, apresentando a sua
modelagem seguindo os conceitos da UML. A conclusão apresenta um apanhado do trabalho
realizado, onde é avaliada a metodologia aplicada, problemas encontrados, soluções empregadas,
dentre outras.
17
2 FUNDAMENTAÇÃO TEÓRICA
A fundamentação teórica deste trabalho aborda os seguintes temas: (i) introdução à
linguagem SQL, apresentando suas sublinguagens e as estruturas dos comandos; (ii) apresentação
das técnicas que foram utilizadas para realizar a correção automática dos exercícios respondidos
pelos alunos; (iii) apresentação de ferramentas similares já existentes; e (iv) apresentação do
ambiente Moodle, suas funcionalidades e como desenvolver para o Moodle
2.1 A Linguagem SQL
Em junho de 1970, E.F.Codd, membro do Laboratório de Pesquisa da IBM em San Jose, na
Califórnia, publicou um trabalho intitulado “A Relational Model os Data for Large Shared Data
Banks” (Um Modelo Relacional de Dados para Grandes Bancos de Dados Compartilhados), Codd
estabeleceu princípios sobre gerência de banco de dados, denominando-os com o termo relacional,
esse trabalho foi a base para a criação da linguagem SQL (Structured Query Language)
(OLIVEIRA, 2002) .
Inicialmente a SQL era chamada de SEQUEL (Structured English Query Language), a
linguagem SQL foi concebida e desenvolvida pela IBM, utilizando os conceitos de Codd, em 1979
a Relational Software Inc., hoje Oracle Corporation, lançou a primeira versão comercial da
linguagem SQL. Atualmente a SQL é considerada a linguagem padrão entre os sistemas de banco
de dados, pois a maioria deles a utiliza (OLIVEIRA, 2002).
Ainda segundo Oliveira (2002) a linguagem SQL é um conjunto de comandos de
manipulação de banco de dados utilizado para criar e manter a estrutura desse banco de dados,
podendo incluir, excluir, modificar e pesquisar informações nas tabelas dele. Damas (2007) afirma
que utilizando a linguagem SQL não é necessário conhecer o funcionamento interno do banco de
dados e como e onde estão armazenados fisicamente os dados, pois a linguagem não é
procedimental, ou seja, um conjunto de linhas será atingido pelo comando e não cada uma das
linhas, como é feito no ambiente procedimental.
2.1.1 Sublinguagens e componentes da linguagem SQL
Segundo Damas (2007), a linguagem SQL é constituída por três sublinguagens:
•
DDL – Data Definition Language;
•
DML – Data Manipulation Language; e
•
DCL – Data Control Language.
Alguns autores como Oliveira (2002) ainda consideram mais um tipo de sublinguagem a
DQL – Data Query Language, a qual é responsável por extrair dados do banco de dados, na
abordagem adotada neste trabalho os comandos dessa linguagem estarão contidos na linguagem
DML. Para a implementação da ferramenta proposta neste trabalho não serão utilizadas as
sublinguagens DCL e DDL.
2.1.1.1
Data Definition Language – DDL
A sublinguagem DDL é responsável pela criação dos componentes de um banco de dados,
como tabelas, índices, etc (OLIVEIRA, 2002). Na seção A do apêndice deste trabalho encontram-se
mais informações sobre esta linguagem.
2.1.1.2
Data Manipulation Language – DML
Como se pode notar a DDL permite apenas criar um banco de dados e suas estruturas, mas
para poder acessar e manipular essas estruturas necessita-se de mais uma sublinguagem. A DML
desempenha esse papel, e também é fornecida pela SQL. Segundo Damas (2007), “a DML é a parte
da linguagem SQL responsável pela manipulação de dados”. A DML contém um conjunto de
comandos que permitem movimentar os dados em um banco de dados, podendo incluir, excluir,
modificar e excluir dados em uma determinada tabela (OLIVEIRA, 2002).
Pesquisa básica em tabelas
Uma vez tendo registros gravados no banco de dados pode-se querer recuperá-los, para isso
a DML fornece o comando SELECT, o qual permite efetuar desde uma simples consulta até
consultas mais detalhadas podendo conter cálculos no código para obter uma melhor filtragem
(OLIVEIRA, 2002). A Figura 2 apresenta a sintaxe mais simples desse comando e a Tabela 1 a
descrição de cada campo da sintaxe.
Figura 2. Sintaxe básica do comando SELECT.
19
Fonte Oliveira (2002).
Tabela 1. Descrição da sintaxe básica do comando SELECT.
Cláusula
Descrição
DISTINCT Não mostra eventuais valores repetidos de colunas.
ALL
Mostra todos os valores, mesmo que repetidos. Esse é o padrão se DISTINCT não for
definido.
*
Indica que devem ser mostradas todas as colunas da tabela.
coluna
Lista de colunas que devem ser mostradas.
tabela
Nome da tabela em que será realizada a busca.
Fonte: Oliveira (2002).
Quando deseja-se mostrar as linhas ordenadas por uma determinada coluna, mesmo que
especifique a ordem das colunas no código o resultado pode não vir ordenado, para efetuar a
ordenação existe o comando ORDER BY, esse comando determina a ordem em que são mostradas
as linhas de uma tabela. A Figura 3 mostra a sintaxe básica desse comando, o campo coluna-ord
representa a lista de colunas na ordem de precedência de classificação.
Figura 3. Sintaxe do comando SELECT usando o ORDER BY.
Fonte: Oliveira (2002).
Especificando-se mais de uma coluna para ser ordenada, o gerenciado ordenará
primeiramente pela primeira coluna, em seguida pela segunda e assim por diante (OLIVEIRA,
2002). Damas (2007) cita que por padrão o gerenciador ordena de forma ascendente, caso deseja-se
ordenar de forma descendente deve-se utilizar o argumento DESC, para voltar a ordenar de forma
ascendente usa-se o argumento ASC. A Figura 4 mostra dois exemplos, um ordenando de forma
ascendente e outro descendente.
20
Figura 4. Exemplo de ordenação ascendente e descendente.
Fonte: Damas (2007).
Através do comando SELECT também é possível definir regras para a filtragem das linhas,
ou seja, para que seja retornado somente o que se deseja. Para poder efetuar essa filtragem utiliza-se
o argumento WHERE, o qual é seguido da condição imposta para a filtragem, que será avaliada e
mostrará apenas as linhas que atenderem ao critério estabelecido. A Figura 5 mostra a sintaxe do
comando SELECT utilizando o argumento WHERE, a cláusula condição representa a condição que
define o escopo (limite) de apresentação dos resultados.
Figura 5. Sintaxe do comando SELECT utilizando-se o argumento WHERE.
Fonte: Oliveira (2002).
Uma maneira de se criar uma condição básica é utilizando operadores relacionais na
cláusula condição na sintaxe do código, a Tabela 2 apresenta os operadores relacionais.
Tabela 2. Relação dos operados relacionais.
Operador Significado
Igual
=
Menor que
<
Menor ou igual a
<=
Maior que
>
Maior ou igual a
>=
! = ou < >
Diferente
Exemplo
CODIGO_AUTOR = 2
PRECO_VENDA < 10
PRECO_VENDA <= 10
PRECO_VENDA > 10
PRECO_VENDA > = 10
CODIGO_AUTOR ! = 2 ou CODIGO_AUTOR < > 2
Fonte Oliveira (2002).
21
Nem sempre os operadores relacionais irão permitir uma boa filtragem na pesquisa, para
suprir essa deficiência a DML fornece uma série de outros operadores. Os operadores lógicos são
mais um tipo de operadores e funcionam sempre com operandos lógicos ou com expressões que
devolvam valores lógicos (DAMAS, 2007). A Tabela 3 relaciona os operadores lógicos utilizados.
Tabela 3. Relação dos operados lógicos.
Operador Significado
AND
e
OR
ou
NOT ou ! não/negação
Exemplo
condição-1 AND condição-2
condição-1 OR condição-2
NOT condição
Fonte: Oliveira (2002).
O operador AND indica que as duas condições devem ser verdadeiras para que seja
mostrada a linha. Já o operador OR é utilizado quando se quer que o resultado final seja verdadeiro
sempre que uma das duas condições for verdadeiras ou ambas. Não existem limitações quanto ao
uso e na combinação de condições utilizando operadores AND e OR, mas deve-se ter cuidado com
a combinação dos dois comandos.
Geralmente a avaliação deste tipo de combinação é realizada da esquerda para direita, então
para definir o que deve ser analisado primeiro é conveniente utilizar parênteses, separando assim as
combinações das condições (OLIVEIRA, 2002). A Figura 6 mostra um exemplo do uso dos
parênteses para separar as combinações de condições.
Figura 6. Exemplo da combinação dos operadores AND e OR.
Fonte: Oliveira (2002).
Neste caso primeiramente é analisado e retornadas as linhas que satisfazem a condição entre
parênteses, depois é analisado o preço de venda das linhas retornadas anteriormente e assim tem-se
o que deve ser apresentado. Já o operador NOT ou ! é utilizado para inverter o resultado de uma
expressão lógica, negando o resultado da condição, ou seja, caso a condição seja verdadeira será
retornado falso e vice-versa.
22
Para uma filtragem mais detalhada existe mais um conjunto de operadores especiais que
visam aproximar, ainda mais, o SQL da linguagem falada. Segundo Damas (2007) “estes
operadores simplificam de forma significativa a forma como as condições, existentes na cláusula
WHERE, são escritas”.
O operador IS NULL é um desses operadores, este comando visa encontrar as colunas que
não foram inicializadas, ou seja, que são nulas (OLIVEIRA, 2002). A Figura 7 mostra um exemplo
de uso desse operador, neste caso serão retornadas as linhas em que o campo endereço for nulo.
Figura 7. Exemplo de uso do operador IS NULL.
Fonte: Oliveira (2002).
O operador IS NOT NULL serve para fazer a negação do operador anterior, assim,
retornando somente os campos com valor atribuído (OLIVEIRA, 2002). Já o operador BETWEEN
permite especificar intervalos de valores, sendo utilizado para simplificar a forma de escrever o
comando e a utilização do operador AND (DAMAS, 2007). A Figura 8 mostra a sintaxe básica
desse operador.
Figura 8. Sintaxe básica do comando BETWEEN.
Fonte: Damas (2007).
Para poder comparar cadeias de caracteres utilizando padrões de comparação para um ou
mais caracteres, a DML fornece o operador LIKE. A Tabela 4 mostra as combinações possíveis
deste operador.
Tabela 4. Combinações do operador LIKE.
Expressão
LIKE ‘A%’
LIKE ‘%A’
LIKE ‘%A%’
Explicação
Todas as palavras que iniciem com a letra A.
Todas as palavras que terminem com a letra A.
Todas as palavras que tenham a letra A em qualquer posição.
23
LIKE ‘A_’
LIKE ‘_A’
LIKE ‘_A_’
LIKE ‘%A_’
LIKE ‘_A%’
String de dois caracteres que tenham a primeira letra A e o segundo caractere seja
qualquer outro.
String de dois caracteres cujo primeiro caractere seja qualquer um e a última letra
seja A.
String de três caracteres cuja segunda letra seja A , independentemente do
primeiro ou do último caractere.
Todos que tenham a letra A na penúltima posição e a ultima seja qualquer outro
caractere.
Todos que tenham a letra A na segunda posição e o primeiro caractere seja
qualquer um.
Fonte: Oliveira (2002).
Segundo Oliveira (2002) “geralmente o caractere percentual (%) substitui o zero, um ou
mais caracteres e sublinha (_) substitui um caractere. Utilizando a combinação desses caracteres
especiais com o que se quer localizar, pode-se conseguir uma variedade muito grande de
expressões”. A Figura 9 mostra alguns exemplos de utilização deste operador.
Figura 9. Exemplos de utilização do operador LIKE.
Fonte: Oliveira (2002).
O operador IN é mais um operador especial, segundo Damas (2007) “o operador IN permite
verificar se algo faz ou não parte de um conjunto de valores especificado entre parênteses”. Já
Oliveira (2002) afirma que o operador IN geralmente é utilizado para substituir uma série de
comparações seguidas da cláusula OR. A Figura 10 mostra a sintaxe básica deste operador.
24
Figura 10. Sintaxe básica do operador IN.
Fonte: Damas (2007).
Funções de grupo e agrupamento
Segundo Oliveira (2002) “funções de grupo operam conjuntos de linhas visando fornecer
um resultado para o grupo”. Ao invés de tratar apenas uma linha de cada vez as funções de grupos
tratam grupos de linhas, que podem ser constituídos desde toda a tabela até subgrupos da tabela.
Essas funções visam auxiliar a computar uma variedade de medidas baseadas em valores das
colunas do banco de dados. A seção C do apêndice traz mais informações sobre este conteúdo.
Junções de tabelas (Pesquisa em múltiplas tabelas)
Segundo Damas (2007) a junção de tabelas ou Join “permite extrair, através de um único
SELECT, informações contidas em diferentes tabelas”. No modelo relacional são estabelecidas as
regras para a divisão da informação entre as tabelas, de forma a evitar a duplicação de informação.
Oliveira (2002) complementa “a união entre as entidades do modelo lógico se dá por meio de
chaves primárias e estrangeiras”, ou seja, são essas chaves que determinam as colunas que as
tabelas tem em comum.
Segundo Damas (2007) “uma chave estrangeira é um campo ou conjunto de campos
existente em uma tabela que permite ligar os dados desta tabela a uma outra, onde este mesmo
conjunto de campos existe como chave primária”. A Figura 11 mostra a sintaxe básica de uma
junção de tabelas.
Figura 11. Sintaxe básica para fazer uma junção de tabelas.
Fonte: Oliveira (2002).
A colocação do nome da tabela antes do nome da coluna é opcional, mas é recomendado
para auxiliar na compreensão do código, sendo que quando se tem o mesmo nome para colunas de
25
diferentes tabelas é necessário colocar o nome da tabela para indicar de qual tabela se quer a
informação (DAMAS, 2007).
Segundo Oliveira (2002) quando a cláusula WHERE não contiver todo o canal de
relacionamento entre as tabelas listadas na cláusula FROM, ocorrerá o Produto cartesiano. O
produto cartesiano também é conhecido como CROSS JOIN, e ocorrerá um produto cartesiano
sempre que:
•
A condição de união entre as tabelas for omitida (não houver cláusula WHERE);
•
A condição de união entre as tabelas for inválida (cláusula WHERE incorreta); e
•
Todas as linhas da primeira tabela estiverem unidas a todas as linhas da segunda
tabela.
Esse tipo de junção combina todas as linhas da primeira tabela com as linhas da segunda,
gerando um resultado muito grande na maioria das vezes, sendo muito utilizada somente quando se
quer fazer testes de performance. A Figura 12 mostra um exemplo de uma junção CROSS JOIN,
neste exemplo a tabela Gravadora possui 4 linhas e a tabela CD 7 linhas, com isso o resultado chega
em 28 linhas.
Figura 12. Exemplo de uma junção CROSS JOIN.
Fonte: Oliveira (2002).
Neste exemplo existe uma linha de CD para cada Gravadora, sendo um resultado
indesejável, caso deseja-se mostrar qual é a gravadora de cada CD, deve-se acrescentar ao comando
a cláusula WHERE, realizando assim uma união regular entre as tabelas.
Uma união regular entre tabelas ou INNER JOIN ou EQUI-JOIN como também é
chamado, corresponde a junção de duas ou mais tabelas, ligando-as através da chave primária de
uma e da chave estrangeira da outra, onde são apresentados somente os registros em que exista
ligação entre as tabelas (DAMAS, 2007). Segundo Oliveira (2002) “denomina-se união regular as
uniões que têm a cláusula WHERE unindo a chave primária à estrangeira das tabelas afetadas pelo
comando SELECT”. A Figura 13 mostra um exemplo deste tipo de junção.
26
Figura 13. Exemplo de uma junção INNER JOIN.
Fonte: Oliveira (2002).
Quando a chave primária e a chave estrangeira tiverem o mesmo nome em ambas as tabelas,
é possível simplificar o comando utilizando a cláusula NATURAL JOIN dentro da cláusula
FROM, ou seja, entre a declaração das tabelas que serão consultadas. A DML fornece outras duas
maneiras de efetuar esse tipo de união, a primeira é utilizando a cláusula USING para determinar
qual(is) coluna(s) utilizar na união, e a cláusula ON para determinar as colunas, quando o nome das
colunas não seja igual (OLIVEIRA, 2002). A Figura 14 mostra a utilização das duas opções.
Figura 14. Exemplo da junção INNER JOIN utilizando as cláusulas USING e ON.
Fonte: Oliveira (2002).
A DML abrange outros tipos de junções tais como NON-EQUIJOI, OUTER-JOIN, LEFT
OUTER JOIN, RIGHT OUTER JOIN, FULL OUTER JOIN e SELF JOIN, mas neste trabalho
não há necessidade de apresenta-lás, pois o foco deste é a pesquisa básica em tabelas.
Normalmente o número de tabelas utilizadas em uma consulta passa de duas, com isso o
código pode ficar extenso, e também pode ocorrer a ambigüidade nas referencias aos campos das
tabelas quando utiliza-se esta tabela duas ou mais vezes em um SELECT. Para solucionar este
problema a DML permite criar ALIASES, também chamados de apelidos, colocando este apelido
após o nome da tabela na cláusula FROM (DAMAS, 2007). A Figura 15 mostra o mesmo exemplo
da Figura 14 utilizando ALIASES.
27
Figura 15. Utilizando ALIASES.
Fonte: Oliveira (2002).
2.1.1.3
Data Control Language – DCL
A Data Control Language ou DCL é mais um tipo de sublinguagem da SQL, ela é a
responsável pela segurança do banco de dados, concebendo ou não permissões para usuários
poderem acessar as informações do banco de dados através de comandos e técnicas específicas para
isso (DAMAS, 2007). A seção B no apêndice traz mais informações sobre a DCL.
2.2 Técnicas para a correção automática
O algoritmo que realiza a correção automática dos exercícios resolvidos pelos alunos,
utilizou-se de técnicas para poder funcionar corretamente. Este capítulo apresenta as duas técnicas
que foram utilizadas no desenvolvimento desta ferramenta, são elas: autômatos e expressões
regulares, ambas utilizadas no desenvolvimento de compiladores.
2.2.1 Autômatos
Um autômato é um modelo matemático de uma máquina de estados finitos, que por sua vez
possui entradas e saídas discretas, podendo assumir um número finito e pré-definido de estados,
onde cada estado resume somente as informações do passado necessárias para determinar as ações
para a próxima entrada (MENEZES, 2005).
Um autômato finito como também é chamado, possui um controle que se desloca de estado
para estado em resposta a entradas externas, este controle pode ser determinístico ou não
determinístico, onde no determinístico o autômato pode estar somente em um estado em qualquer
instante e no não determinístico o autômato pode estar em vários estados ao mesmo tempo
(HOPCROFT, ULLMAN & MOTWANI, 2003).
Segundo Menezes (2005), um autômato finito determinístico é constituído por três partes:
•
Fita: Dispositivo de entrada que contém a informação a ser processada;
28
•
Unidade de controle: Reflete o estado corrente da máquina. Possui uma unidade de
leitura a qual acessa uma célula da fita de cada vez e movimenta-se exclusivamente
para a direita; e
•
Programa, Função Programa ou Função de Transição: Função que comanda as
leituras e define o estado da máquina.
A teoria de autômatos engloba alguns conceitos importantes, tais como, alfabetos, strings e
linguagem. Segundo Hopcroft, Ullman & Motwani (2003), “um alfabeto é um conjunto de símbolos
finito e não-vazio”. O símbolo Σ é utilizado para representar o alfabeto, os alfabetos comuns
incluem:
•
Σ = {0, 1}, o alfabeto binário;
•
Σ = {a, b, ...., z}, o conjunto de todas as letras minúsculas; e
•
O conjunto de todos os caracteres ASCII, ou o conjunto de todos os caracteres
ASCII imprimíveis.
Já um string, palavra ou cadeia, é uma seqüência de símbolos escolhidos de algum alfabeto
e é representado pelo símbolo ω. O string vazio possui nenhuma ocorrência de símbolos, podendo
ser escolhido de qualquer alfabeto, e é representado pelo símbolo ε (HOPCROFT, ULLMAN &
MOTWANI, 2003).
Linguagem é um conjunto de strings escolhidos a partir de um alfabeto, é representada pelo
símbolo L, uma linguagem sobre algum alfabeto não precisa incluir strings com todos os símbolos
do alfabeto. Como todos os alfabetos são finitos as linguagens são restritas a strings tirados de um
alfabeto fixo e finito, mesmo podendo ter um número infinito de strings (HOPCROFT, ULLMAN
& MOTWANI, 2003).
Funcionamento de um autômato.
Ao receber uma entrada, a mesma passa por uma série de estados de acordo com uma
função de transição, que pode ser expressa por uma tabela, a entrada é lida símbolo a símbolo pela
cabeça de leitura do autômato até que se esgote. Uma vez lida toda a entrada, diz-se que o autômato
esta parado, se o autômato parar no estado de aceitação podemos dizer que o autômato aceitou a
palavra, já se ele parar no estado não-aceitação a palavra foi rejeitada, agrupando todas as palavras
29
aceitas temos a linguagem aceita por um autômato (WIKIPÉDIA, 2008). A Figura 16 mostra um
autômato finito determinístico para reconhecimento da palavra chave then.
Figura 16. Autômato finito determinístico.
Fonte: Hopcroft, Ullman & Motwani (2003).
No exemplo mostrado pela Figura 16, as entradas correspondem a letras, o estado inicial
corresponde a um string vazio, e cada estado tem uma transição na próxima letra de then para o
estado que corresponde ao prefixo seguinte, quando a entrada grafa a palavra completa, o estado
denominado then é atingido. Como neste exemplo o objetivo é reconhecer o momento em que then
é visto, pode-se considerar esse estado como o único estado de aceitação, ou estado final,
representado por um circulo duplo (HOPCROFT, ULLMAN & MOTWANI, 2003).
Segundo Menezes (2005), um autômato finito determinístico consiste em:
•
Um alfabeto de entrada (Σ);
•
Um conjunto de estados possíveis (Q);
•
Uma função de transição, a qual é parcial: Uma função programa definida para um
estado p e um símbolo a, resultando no estado q, pode ser representada por: σ (p, a)
=q;
•
Um estado inicial (q0); e
•
Um conjunto de estados finais (F).
Portanto um autômato finito determinístico M é uma 5-upla ordenada e pode ser
representado por M = (Σ, Q, σ, q0, F). Segundo Menezes (2005), “a computação de um autômato
finito, para uma palavra de entrada ω, consiste na sucessiva aplicação da função programa para
cada símbolo de ω (da esquerda para a direita) até ocorrer uma condição de parada”.
30
Supondo que deseja-se ter aa ou bb como sub-palavra, temos uma linguagem sobre o
alfabeto {a,b}, onde L = { ω | ω possui aa ou bb como sub-palavra}, o autômato para este caso pode
ser representado por M1 = ({a,b}, {q0, q1, q2, qf}, σ, q0, {qf}), este algoritmo usa os estados q1 e
q2 para memorizar o símbolo anterior lido, então:
•
q1 representa que o símbolo anterior é a; e
•
q2 representa que o símbolo anterior é b.
Quando o autômato identificar dois a ou dois b consecutivos, assume-se o estado qf (estado
final) e varre o sufixo da palavra de entrada, somente para terminar o processamento (MENEZES,
2005). Supondo que a entrada seja ω = abba, a Tabela 5 representa a função programa para este
caso, já a Figura 17 representa o diagrama do autômato para este caso.
Tabela 5. Função programa para reconhecer seqüência de dois símbolos iguais.
σ
a
b
q0
q1
q2
qf
q1
qf
q1
qf
q2
q2
qf
qf
Fonte: Menezes (2005).
31
Figura 17. Diagrama de um autômato finito determinístico para reconhecimento de seqüência de
dois símbolos iguais.
Fonte: Menezes (2005).
Autômatos finitos não determinísticos
Segundo Hopcroft, Ullman & Motwani (2003), “um autômato finito não determinístico,
pode estar em vários estados ao mesmo tempo, tendo essa habilidade expressa com freqüência
como a capacidade de adivinhar algo sobre a sua entrada”. Os autômatos não determinísticos
aceitam as linguagens regulares, da mesma maneira que os autômatos determinísticos aceitam.
Segundo Menezes (2005), “qualquer autômato finito não determinístico pode ser simulado
por um autômato finito determinístico”, diferenciando-se na unidade de controle, a qual é uma
função parcial que dependendo do estado corrente e do símbolo lido, determina um conjunto de
estados do autômato. De acordo com Menezes (2005), um autômato finito não determinístico é uma
máquina composta por fita, unidade de controle e programa, como um autômato determinístico um
autômato não determinístico consiste em:
•
Um alfabeto de entrada (Σ);
•
Um conjunto de estados possíveis do autômato, o qual é finito (Q);
•
Uma função de transição, a qual é parcial: Supondo que uma função programa é
definida para um estado p e um símbolo a, que resulta no conjunto de estados {q1,
32
q2,..., qn}, pode ser representada por: σ (p, a) = {q1, q2,..., qn}, que pode ser
considerada como uma transição no autômato;
•
Um estado inicial (q0); e
•
Um conjunto de estados finais (F).
Portanto um autômato finito não determinístico M é uma 5-upla ordenada e pode ser
representado por M = (Σ, Q, σ, q0, F). Uma função programa com uma transição do tipo σ (p, a) =
{q1, q2,..., qn), resulta em diversas arestas etiquetadas por a, com origem em p, e com destino em
cada estado q1, q2,..., qn, a qual é representada pela Figura 18.
Figura 18. Transição de um autômato finito não determinístico.
Fonte: Menezes (2005).
Segundo Menezes (2005), “a computação de um autômato finito, para uma palavra de
entrada ω, consiste na sucessiva aplicação da função programa para cada símbolo de ω (da esquerda
para a direita) até ocorrer uma condição de parada. Como cada transição de um autômato finito não
determinístico resulta em um conjunto de estados, é necessário estender a definição da função
programa, usando como argumento um conjunto finito de estados e uma palavra”.
Supondo que deseja-se ter aa ou bb como sub-palavra, temos uma linguagem sobre o
alfabeto {a,b}, onde L = { ω | ω possui aa ou bb como sub-palavra}, o autômato para este caso pode
ser representado por M2 = ({a,b}, {q0, q1, q2, qf}, σ, q0, {qf}), este algoritmo possui três caminhos
alternativos de processamento:
•
O ciclo em q0 realiza uma varredura em toda a entrada;
33
•
O caminho q0/q1/qf garante a ocorrência de aa; e
•
O caminho q1/q2/qf garante a ocorrência de bb.
O algoritmo faz realiza uma varredura sobre a palavra de entrada, a cada ocorrência de a
(respectivamente, de b) uma alternativa é iniciada, para verificar se o símbolo seguinte também é a
(respectivamente, b) (MENEZES, 2005). A Tabela 6 representa a função programa para este caso,
já a Figura 19 representa o diagrama do autômato para este caso.
Tabela 6. Função programa de um autômato finito não determinístico, para reconhecer seqüência de
dois símbolos iguais.
σ
a
b
q0
q1
q2
qf
{q0, q1}
{qf}
{qf}
{q0, q2}
{qf}
{qf}
Fonte: Menezes (2005).
Figura 19. Diagrama de um autômato finito não determinístico para reconhecimento de seqüência
de dois símbolos iguais.
Fonte: Menezes (2005).
Autômatos finitos com epsílon-transições
Epsílon-transições ou movimentos vazios são transições sem leitura de símbolo algum da
fita. Cada transição desse tipo encontrado no caminho do autômato passa despercebido, não
34
contribuindo com nada para o string formado ao longo do caminho, mas facilitam algumas
construções e demonstrações relacionadas com os autômatos (HOPCROFT, ULLMAN &
MOTWANI, 2003).
A definição de um autômato finito não determinístico com movimentos vazios é a mesma
que a de um autômato finito não determinístico, ou seja, o processamento de uma transição para
uma entrada vazia também é não determinístico. Assim um autômato finito não determinístico com
movimentos vazios, ao processar uma entrada vazia, assume simultaneamente os estados destino e
origem, com isso a origem de um movimento vazio será sempre um caminho alternativo
(MENEZES, 2005). A Figura 20 mostra um exemplo de um autômato finito não determinístico com
movimentos vazios e a Tabela 7 mostra as transições do mesmo.
Figura 20. Autômato finito não determinístico com movimentos vazios.
Fonte: Hopcroft, Ullman & Motwani (2003).
Tabela 7. Tabela de transições do autômato finito não determinístico com movimentos vazios.
σ
q0
q1
q2
q3
q4
q5
ε
{q1}
0
0
{q5}
0
0
+, {q1}
0
0
0
0
0
.
0
{q2}
0
0
{q3}
0
0, 1, ..., 9
0
{q1, q4}
{q3}
{q3}
0
0
Fonte: Hopcroft, Ullman & Motwani (2003).
35
A Figura 20 representa um autômato finito não determinístico com movimentos vazios, que
aceita números decimais constituindo em:
•
Um sinal + ou – opcional;
•
Um string de dígitos;
•
Um ponto decimal; e
•
Outro string de dígitos. Esse string de dígitos ou o string (2) podem ser vazios, mas
pelo menos um dos dois strings deve ser não vazio.
Neste caso o estado q1, representa a situação em que se vê o sinal, e talvez alguns dígitos,
somente no estado q2 pode ocorrer o ponto decimal, podendo ter ou não dígitos anteriores. No
estado q4 pelo menos um dígito ocorre, sem a ocorrência de um ponto decimal. Assim no estado q3
ocorre pelo menos um ponto decimal e um dígito, esteja ele antes ou depois do ponto decimal.
Pode-se permanecer em q3 lendo outros dígitos, ou pode-se “adivinhar” que o string de dígitos esta
completo e ir para o estado q5, ou seja, o estado de aceitação (HOPCROFT, ULLMAN &
MOTWANI, 2003).
Um autômato finito não determinístico com movimentos vazios pode ser transformado em
um autômato finito determinístico, aceitando a mesma linguagem. Tanto o autômato finito não
determinístico quanto o autômato finito não determinístico com movimentos vazios são uma forma
útil de representar um comparador de padrões, podendo examinar um grande corpo de texto em
busca de uma ou mais palavras chaves, podendo ser simulados diretamente em software ou são
convertidos primeiro em um autômato finito determinístico, o qual é simulado (HOPCROFT,
ULLMAN & MOTWANI, 2003).
2.2.2 Expressões Regulares
Segundo Hopcroft, Ullman & Motwani (2003), “as expressões regulares também podem ser
consideradas uma linguagem de programação, na qual expressamos algumas aplicações
importantes, como aplicações de pesquisa em textos ou componentes de compiladores. As
expressões regulares estão intimamente relacionadas aos autômatos finitos não determinísticos e
podem ser consideradas uma alternativa amigável para o usuário para a notação dos autômatos
finitos não determinísticos, a fim de descrever componentes de software”.
36
Segundo Menezes (2005), as expressões regulares podem inferir como construir as palavras
de uma linguagem. Sendo definida a partir de conjuntos (linguagens) básicos e operações de
concatenação e de união, as expressões regulares são adequadas para a comunicação humano x
humano e, principalmente, para a comunicação humano x máquina.
Segundo Menezes (2005), uma expressão regular sobre um alfabeto Σ é indutivamente
definida da seguinte maneira:
•
Base de Indução.
o A expressão: Ø denota a linguagem vazia: Ø ;
o A expressão: ε, denota a linguagem que contém exclusivamente a palavra
vazia: { ε }; e
o Para qualquer símbolo x Є Σ, a expressão x, denota a linguagem que contém
exclusivamente a palavra constituída pelo símbolo x: { x }.
•
Passo de indução. Se r e s são expressões regulares e denotam as linguagens R e S,
respectivamente, então:
o União: A expressão ( r + s ), denota a linguagem: R U S;
o Concatenação: A expressão ( rs ), denota a linguagem: R S = { uv | u Є R e v
Є S} ; e
o Concatenação sucessiva: A expressão ( r*), denota a linguagem: R* .
Se r é uma expressão regular, a correspondente linguagem denotada é dita a linguagem
gerada por r, sendo representada por: L ( r ) ou GERA ( r ). A Tabela 8 mostra exemplos de
expressões regulares e as linguagens geradas por elas.
Tabela 8. Exemplo de expressões regulares e as linguagens geradas.
Expressão Regular
Linguagem Gerada
aa
Somente a palavra aa.
ba*
Todas as palavras que iniciam por b, seguido por zero ou mais a.
(a + b ) *
Todas as palavras sobre { a, b }.
(a + b )* aa (a + b)*
Todas as palavras contendo aa como subpalavra.
37
a * ba * ba
( a + b) * (aa + bb )
(a + ε ) ( b + ba )*
Todas as palavras contendo exatamente dois b.
Todas as palavras que terminam com aa ou bb.
Todas as palavras que não possuem dois a consecutivos.
Fonte: Menezes (2005).
Segundo Hopcroft, Ullman & Motwani (2003), “os operadores nas expressões regulares têm
uma ordem de precedência predefinida, o que significa que os operadores estão associados com
seus operandos em uma ordem específica”. A ordem de precedência para os operadores em uma
expressão regular baseia-se na seguinte ordem:
•
O operador estrela ( * ) é o de precedência, mais alta, aplicando-se apenas à menor
seqüência de símbolos à sua esquerda que seja uma expressão regular bem formada;
•
O operador de concatenação ( . ), vem em seguida, onde para formar o resultado da
concatenação de um par de strings, pode-se por um string seguido pelo outro, já na
concatenação de linguagens pode-se utilizar um ponto ou sem nenhum operador, por
exemplo, L.M, ou LM; e
•
O operador de união ( + ) é o ultimo na ordem de precedência , após de agrupar todas
as estrelas e seus operandos e ter agrupado os operadores de concatenação a seus
operandos, são agrupadas as uniões consecutivas, independendo de ordem, mas por
padrão a partir da esquerda.
Quando deseja-se definir uma outra ordem de precedência, ou seja, que não seja pelas regras
de precedência, pode-se utilizar parênteses para definir a ordem de precedência desejada
(HOPCROFT, ULLMAN & MOTWANI, 2003).
Busca de padrões em textos
Assim como os autômatos podem ser usados para procurar de forma eficiente um conjunto
de palavras em um grande repositório como a web, as expressões regulares também são uma
ferramenta interessante para descrever pesquisas de padrões (HOPCROFT, ULLMAN &
MOTWANI, 2003).
Utilizando-se a notação de expressões regulares torna-se fácil descrever os padrões em alto
nível, com pouco esforço e modificar a descrição com rapidez quando algo der errado
38
(HOPCROFT, ULLMAN & MOTWANI, 2003). Supondo que deseja-se localizar o endereço de
algum restaurante através da internet, pode-se utilizar como inicio da expressão regular algo como:
Rua|R\.|Avenida|Av\.Estrada|Estr\.
Segundo Hopcroft, Ullman & Motwani (2003), a expressão regular apresentada serve como
base para procurar um endereço na internet, considerando que dados como a rua, avenida ou estrada
onde se localizaria o restaurante, poderiam estar abreviados. A expressão regular apresentada utiliza
a denotação do sistema operacional UNIX, onde a barra vertical substitui o operador de união ( + ).
Já a barra invertida antes do ponto significa que deseja-se o caractere de escape, ou seja, o ponto
final que denota o fim da abreviatura.
Geralmente a designação da rua é seguida pelo nome da rua, onde normalmente o nome
começa como uma letra maiúscula seguida por algumas minúsculas e pode ter mais de uma palavra,
que pode ser representada pela expressão:
‘[ A – Z ] [ a – z ] * ( [ A – Z ] [ a – z ] * )*’
Como próximo passo deve-se incluir o numero da casa como parte do endereço, a maioria
dos números de casas é um string de dígitos, mas existem alguns que terão uma letra em seguida. A
expressão para esse caso deve considerar uma letra maiúscula opcional no fim, com isso a
expressão utiliza o operador + para indicar um ou mais dígitos e o operador ? para indicar zero ou
uma letra maiúscula, a expressão regular para endereços residências pode ser representada por:
‘(Rua | R \. | Avenida | Av \. | Estrada | Estr \. )
[ A – Z ] [ a –z ] * ( [ A – Z ] [ a – z ] * ) * [ 0 – 9 ] + [ A – Z ] ?’
Segundo Hopcroft, Ullman & Motwani (2003), a expressão regular apresentada não
considera:
•
Endereços representados por algo diferente de uma rua, avenida ou estrada;
•
Nomes de ruas que são numéricos ou parcialmente numéricos;
•
Caixas postais e roteiros de entrega rural;
39
Nomes de ruas que não têm nenhuma relação com algo como Rua, por exemplo
•
“Trevo da Cunha”; e
Todos os tipos de itens estranhos que se possa imaginar.
•
Dessa maneira um compilador de expressões regulares tornaria mais fácil o processo de
convergência para o identificador completo de endereços, do que recodificar cada mudança
diretamente em uma linguagem de programação convencional (HOPCROFT, ULLMAN &
MOTWANI, 2003).
2.3 Aplicações Similares
Com intuito de desenvolver a ferramenta proposta neste trabalho da melhor forma possível,
foram pesquisadas soluções similares para servirem de base no desenvolvimento desta, e para
encontrar funcionalidades não oferecidas pelas soluções encontradas. A pesquisa encontrou as
seguintes ferramentas: SQL WEB, LabSql e SQL-Tutor.
2.3.1 SQL WEB
O SQL WEB é uma ferramenta que foi desenvolvida pelo professor André Luiz Souza, o
qual ministra a disciplina de banco de dados nos cursos de sistemas de informação e engenharia de
computação da Universidade de Uberaba – Unibe, e licenciatura em computação da Faculdades
Associadas de Uberaba - Fazu , ambas localizadas na cidade de Uberaba – MG (SQL WEB, 2009).
O objetivo geral desta ferramenta é proporcionar um ambiente de apoio ao ensino de banco
de dados. Sua idealização surgiu no ano de 2003, com a criação de um banco de dados de exercícios
para os alunos estudarem para as provas das disciplinas, em 2004 foi implementado um algoritmo
para corrigir automaticamente os exercícios, sendo implantado nas duas universidades em que seu
desenvolvedor trabalha e em 2005 foi criada a avaliação online, encontrada no site
http://www.sqlweb.com.br (SQL WEB, 2009).
Segundo Souza (2008) os objetivos desta ferramenta são:
•
Manter um banco de dados de exercícios classificados de acordo com o grau de
complexidade;
40
•
Ter um ambiente interativo para o estudo de SQL capaz de disponibilizar e corrigir
exercícios com alta disponibilidade e fácil acesso;
•
Registrar todas as respostas enviadas pelos alunos, possibilitando uma análise
histórica e estatística das questões e respostas;
•
Manter um sistema de pontuação que de acordo com o grau de complexidade do
exercício, registre pontos para os alunos permitindo uma classificação e premiação
dos primeiros colocados;
•
Permitir que o aluno escolha o nível de complexidade de exercícios que deseja
fazer;
•
Mostrar um quadro com todos os dados estatísticos, permitindo ao aluno verificar
quantos exercícios fez por nível, quantos acertou ou errou; e
•
Mostrar a classificação geral de acordo com os pontos obtidos, para que o aluno
possa avaliar o seu desempenho em relação aos colegas.
Para atender os objetivos a ferramenta fornece um menu com várias opções, mostrado na
Figura 21, onde qualquer pessoa seja ela aluno ou professor de qualquer instituição pode se
cadastrar e utilizar a ferramenta.
41
Figura 21. Página inicial do SQL WEB, contendo o menu de opções na parte superior da página.
Fonte: SQL WEB (2009).
Após efetuar o cadastro caso o usuário seja professor ele pode acessar o menu professor e
informar seus dados tais como instituição que trabalha, cursos que ministra, entre outros dados,
podendo também criar turmas, exercícios e provas (SOUZA, 2008).
Quando o professor for cadastrar exercícios o SQL WEB permite que ele insira um modelo
gráfico do banco de dados tratado pelo exercício ou utilize os modelos fornecidos pela ferramenta
clicando em cima da imagem, como mostra a Figura 22 (SOUZA, 2008).
42
Figura 22. Tela de cadastro de exercício – SQL WEB.
Fonte: SQL WEB (2009).
Estando devidamente cadastrado o aluno pode então responder os exercícios através de uma
tela de questões, mostrado pela Figura 23.
Figura 23. Tela de resolução de exercício – SQL WEB.
Fonte: SQL WEB (2009).
43
O SQL WEB foi desenvolvido utilizando a linguagem PHP e o sistema gerenciador de
banco de dados MySQL, para corrigir os exercícios o SQL WEB utiliza a técnica de correção pelo
retorno, ou seja, a ferramenta compara os resultados produzidos pela resposta do aluno com os
resultados da resposta correta cadastrada. Sendo assim a ferramenta analisa somente se a resposta
do aluno retornou os dados desejados, caso o aluno cometa algum erro a ferramenta simplesmente
informa que ocorreu um erro, não indicando onde o mesmo ocorreu. (SOUZA, 2008).
2.3.2 LabSQL
O LabSQL é uma ferramenta interativa para auxiliar os alunos no aprendizado da linguagem
SQL, podendo ser utilizado como ferramenta de apoio ao professor para realizar automaticamente
as avaliações e suas correções. O LabSQL foi desenvolvido e incorporado a ferramenta AmAm que
é um ambiente virtual de aprendizagem, o AmAm permite a gestão de ferramentas de apoio ao
ensino presencial e a distância e esta sendo utilizado na Universidade Federal do Pará – UFPA
(LINO et al., 2007).
O LabSQL oferece interatividade nos tópicos de programação, ou seja, todo exemplo que
aparece no texto explicativo dos comandos SQL, disponibilizados pela ferramenta, pode ser
executado para o aluno analisar o comportamento do comando. O aluno também não precisa seguir
linearmente o conteúdo ou a execução dos exercícios, oferecendo assim uma flexibilidade no
sequenciamento do conteúdo. O LabSQL também permite que o professor faça o monitoramento de
cada aluno, como também o monitoramento da turma como um todo (LINO et al., 2007).
As respostas dos alunos são analisadas automaticamente e o mesmo recebe uma resposta
imediata sobre o seu código, a analise é feita através de técnicas de complexidade de algoritmos,
mais propriamente dito com o uso de métricas, ou seja, são utilizadas formulas que calculam a
complexidade da resposta do aluno em relação à resposta cadastrada pelo professor em relação ao
exercício em questão, ou seja, é uma técnica que esta entre as técnicas de um sistema tutor
inteligente e de um sistema baseado em correção pelo retorno (LINO et al., 2007).
Nesse tipo de técnica são considerados as seguintes variáveis: número de tabelas, número de
comparações, número de atributos, número de tokens, número de chaves estrangeiras, entre outras.
Quanto menor a complexidade da resposta do aluno mais próxima da resposta considerada certa
pelo professor estará. A arquitetura do LabSQL utilizando métricas esta representada pela Figura 24
(LINO et al., 2007).
44
Figura 24. Visão geral da arquitetura do LabSQL utilizando métricas para avaliação automática.
Fonte: Lino et al. (2007).
No módulo aluno, o aprendiz tem acesso a materiais didáticos acompanhado de exemplos
executáveis, junto com os exercícios o aluno tem acesso a listas de exercícios para que o mesmo
treine suas habilidades. A interface onde o aluno realiza os exercícios é mostrada na Figura 25
(LINO et al., 2007).
45
Figura 25. Interface onde o aluno testa seus códigos e visualiza dados estatísticos - LabSQL.
Fonte: Lino et al. (2007).
Como pode-se ver a Figura 25 esta dividida em partes (a), (b), (c), (d), (e) e (f), onde (a) é a
janela de exercícios que contêm uma lista linear das questões de uma determinada avaliação; (b)
link da janela que apresenta o resultado esperado; (c) consulta submetida pelo aluno; (d) link para o
schema do banco de dados como uma figura do modelo ER; (e) feedback do sistema no caso: “Obs:
Seu código está 91,00% correto – Tente novamente para alcançar a solução ótima”; (f) histórico de
respostas fornecendo um link para visualizar cada uma das respostas submetidas e avaliadas pelo
LabSQL (LINO et al., 2007).
No módulo professor, o professor pode visualizar gráficos detalhados que apresentam os
dados de cada aluno e da turma como um todo, permitindo que o professor visualize a avaliação de
cada questão resolvida pelos alunos, assim o professor tem uma visão geral do andamento da turma,
como é mostrado na Figura 26 (LINO et al., 2007).
46
Figura 26. Relatório de acompanhamento do aprendiz em exercícios de SQL - LabSQL.
Fonte: Lino et al. (2007).
Nem toda resposta cadastrada pelo professor pode ser considerada como “ótima”, caso
algum aluno submeta uma resposta e a ferramenta perceba que o grau de complexidade da mesma é
menor que o grau de complexidade da resposta cadastrada pelo professor, a reposta do aluno é
armazenada para poder ser avaliada, para possibilitar que sejam incluídas como respostas válidas
(LINO et al., 2007).
2.3.3 SQL-Tutor
O SQL-Tutor é um sistema tutor inteligente utilizado para auxiliar os alunos na
aprendizagem da linguagem SQL. A primeira versão do SQL Tutor foi desenvolvida para
plataformas stand-alone, tendo uma versão para MS Windows e outra para Solaris. Primeiramente
utilizado por alunos do curso de ciência da computação da universidade Canterbury na Nova
Zelândia, o SQL Tutor se mostrou um sistema de fácil uso e atraente (MITROVIC, 2003). A Figura
27 mostra a arquitetura da versão stand-alone do SQL-Tutor.
47
Figura 27. Arquitetura da versão stand-alone do SQL-Tutor.
Fonte: Mitrovic (2003).
Segundo Mitrovic (2003), o SQL-Tutor consiste em uma interface, um módulo pedagógico e
um modelo CBM (Constraint-Based Modeling). No módulo pedagógico o professor pode
determinar as ações pedagógicas (exercícios, calendário, etc.), já o modelo CBM é uma abordagem
que se concentra sobre as violações dos princípios básicos do domínio da instrução, ou seja, utiliza
uma teoria de aprendizagem a partir de erros.
O modelo CBM é responsável por analisar as respostas dos alunos. O sistema possui uma
definição de vários bancos de dados, implementados em um SGBD, e uma série de problemas e as
soluções ideais para eles. O SQL-Tutor compara a solução do estudante com a solução correta para
o exercício em questão, cadastrada pelo professor. Essa comparação é feita com base em uma base
de conhecimento representada na forma de restrições, ou seja, um modelo CBM (MITROVIC,
2003).
Segundo Mitrovic (2003), no começo da sessão o sistema seleciona um problema para o
aluno resolver, quando o aluno escreve a sua solução o módulo pedagógico envia a solução para o
módulo CBM, o qual analisa o código e identifica erros, caso eles existirem, e atualiza o modelo do
estudante. Com base no modelo do aluno o módulo pedagógico gera um feedback para o aluno. O
SQL-Tutor trata somente do comando SELECT, ou seja, apenas de consultas.
48
Para se adaptar a cada aluno, o SQL-Tutor mantém um modelo para cada aluno. Um modelo
de um aluno contém informações sobre o histórico das sessões anteriores (como uma lista de
problemas resolvidos corretamente, etc) e também contém um modelo do conhecimento do aluno,
expresso em termos de restrições (MITROVIC, 2003).
Para facilitar o acesso dos estudantes, foi desenvolvido uma versão do SQL-Tutor para a
web, sendo chamado de SQLT-Web, com o objetivo de permitir que os alunos acessassem o sistema
de qualquer computador com acesso a internet. O acesso ao servidor da universidade é destinado
apenas aos alunos da mesma, mas qualquer pessoa pode baixar os arquivos e rodar em um servidor
localhost (MITROVIC, 2003). A Figura 28 mostra a arquitetura da versão para a web do SQLTutor.
Figura 28. Arquitetura da versão web do SQL-Tutor.
Fonte: Mitrovic (2003).
49
A versão web do SQL-Tutor utiliza como base a versão stand-alone, tendo sido feitas
somente algumas adaptações, para poder funcionar para a internet. Na versão web, os alunos podem
selecionar o nível de feedback a ser recebido. Segundo Mitrovic (2003), as mensagens de feedback
se dividem em:
•
Positivo / negativo, o feedback simplesmente informa o estudante se a sua solução
está correta ou não;
•
Uma flag de erro informa ao estudante sobre qual cláusula do SELECT ocorreu
um erro;
•
Uma dica fornecendo uma descrição geral do erro;
•
Uma dica mais detalhada, fornecendo mais informações sobre o erro;
•
Solução parcial informa a versão correta da cláusula onde ocorreu um erro; e
•
Solução completa apresentando a solução ideal para o problema.
A Figura 29 mostra a interface do aluno, para responder exercícios, na qual além de
responder as questões, ele escolhe o nível de feedback, recebe a mensagem de feedback, entre outras
opções. Como o acesso gratuito ao sistema restringe-se apenas a interface do aluno, este trabalho
não teve acesso às telas do módulo pedagógico.
50
Figura 29. Interface do usuário - SQL-Tutor.
Fonte: Mitrovic (2003).
2.3.4 Comparativo das Ferramentas
Para poder entender melhor as ferramentas mostradas nesta pesquisa, foi criada uma tabela
de comparação entre as ferramentas pesquisadas e a ferramenta desenvolvida neste trabalho,
levando em conta o que a ferramenta desenvolvida integrada ao ambiente Moodle realiza. A Tabela
9 apresenta o comparativo.
Tabela 9. Comparativo das ferramentas pesquisadas com a ferramenta proposta por este trabalho.
SQLONLINE
FERRAMENTA/
FUNCIONALIDADE
NÃO
Integrada a outro ambiente de
aprendizagem?
SIM
Faz correção automática da solução do
aluno?
SIM
Compara a resposta do aluno com uma
resposta padrão?
Oferece materiais de apoio?
NÃO
51
LABSQL
SQL-Tutor
Moodle /
QuicklySql
SIM
NÃO
SIM
SIM
SIM
SIM
SIM
SIM
SIM
SIM
NÃO
SIM
(moodle)
Oferece relatórios sobre o desempenho
do aluno?
O aluno pode escolher a questão a ser
respondida?
Informa ao aluno em que parte da
solução ele errou?
Permite que o professor crie turmas?
Possui o código-fonte aberto?
Permite adicionar a imagem do modelo
ER da questão?
Aborda outros comandos além do
SELECT ?
SIM
SIM
SIM
SIM
SIM
SIM
SIM
NÃO
NÃO
NÃO
SIM
SIM
SIM
SIM
NÃO
NÃO
SIM
NÃO
NÃO
NÃO
NÃO
SIM
(moodle)
SIM
SIM
SIM
SIM
NÃO
NÃO
Todos os itens relacionados na Tabela 9 representam algumas funcionalidades que este
trabalho realiza juntamente com o ambiente Moodle, tendo algumas já atendidas pelo Moodle. Um
diferencial importante da ferramenta proposta é o fato de ela ter sido desenvolvida para integrar-se
ao ambiente Moodle, mundialmente utilizado.
Outra característica importante em relação às outras é que a mesma mostra para o aluno em
que parte de sua solução ele errou, no caso da ferramenta SQL-Tutor também é fornecido esse
feedback detalhado, mas o mesmo fixa as principais cláusulas do comando, ou seja, o aluno só
precisa informar as colunas e tabelas que serão consultadas juntamente com restrições, facilitando a
resposta do mesmo.
A ferramenta proposta utilizou autômatos para comparar a resposta do aluno com a resposta
padrão, o que permitiu informar o que o aluno errou, ao contrário da ferramenta SQL WEB que
somente verifica se a resposta do aluno retornou os mesmos dados da resposta padrão, não
indicando em que parte da solução esta o erro e quando o mesmo ocorre.
E por ter sido desenvolvida para um ambiente de código-fonte aberto, a ferramenta tem seu
código-fonte aberto, que de acordo com a pesquisa realizada as demais não possuem o mesmo.
2.4 O Ambiente Moodle
O Moodle (Modular Object-Oriented Dynamic Learning Environment), ou ambiente
modular dinâmico de aprendizagem orientado a objeto, é um software livre e gratuito que consiste
em um ambiente de aprendizagem à distância, tendo seu desenvolvimento iniciado na década de 90
52
pelo australiano Martin Dougiamas, quando trabalhava como webmaster na Curtin University of
Technology, na Austrália (MOODLE, 2008b).
Somente no ano de 2002 após vários protótipos foi lançada a versão 1.0, a qual se restringia
a pequenos grupos de pessoas de nível universitário. Desde então, uma série de novas versões vem
sendo disponibilizadas sempre oferecendo novos recursos, melhor escalabilidade e melhor
desempenho. Hoje sua comunidade engloba desde escolas primárias e secundárias até
universidades, organizações sem fins lucrativos e empresas privadas. A filosofia pedagógica
utilizada pelo Moodle é a sócio-construcionista, a qual visa um modelo de ensino mais centrado no
aluno, baseando-se no que ele faz, no seu papel enquanto solucionador de problemas e individuo
social que aprende com os outros (MOODLE, 2008b).
O Moodle é um sistema modular e livre. Qualquer pessoa pode desenvolver módulos para
ele, desde que sejam seguidas as regras para desenvolvimento. Além de ser um sistema de fácil
instalação em qualquer plataforma que suporte a linguagem PHP, o Moodle é um sistema simples,
leve, eficiente e com a interface baseada em navegadores de tecnologia simples. Possui
independência total da base de dados, ou seja, suporta todas as principais marcas de base de dados e
possui grande ênfase em segurança, onde todos os formulários são sempre checados (MOODLE,
2008b).
2.4.1 Estrutura básica e características do Moodle
Segundo Moodle (2008c), a estrutura básica e as principais características do Moodle são:
•
Administração do site;
•
Administração dos usuários;
•
Administração de curso;
•
Módulo Tarefa;
•
Módulo Chat;
•
Módulo Pesquisa de Opinião;
•
Módulo Fórum;
53
•
Módulo Questionário;
•
Módulo Recursos;
•
Modulo Pesquisa de Avaliação; e
•
Módulo Laboratório de Avaliação.
A administração do site é feita por um usuário escolhido durante a instalação do sistema, o
qual pode ajustar a aparência do site através da extensão Temas, adicionar atividades através da
extensão atividades, selecionar o idioma do site através da extensão pacotes de idiomas e quando
necessário pode modificar o código PHP para se ajustar às suas necessidades (MOODLE, 2008c).
A administração dos usuários é realizada na maior parte do tempo pelo próprio sistema,
onde os usuários podem criar suas próprias contas de acesso, os acessos às contas são checados
através de um servidor de correio ou de notícias, SSL, certificados e TLS são suportados. Cada
pessoa necessita apenas de uma conta para todo o servidor e cada conta pode ter diferentes acessos.
Uma conta de administrador controla a criação de cursos e cria professores através da inscrição de
usuários aos cursos, a uma conta de criador de cursos somente é permitido criar e dar aula nos
cursos, entre outras tecnicas, a intenção é de reduzir o envolvimento do administrador (MOODLE,
2008c).
Já na administração de cursos, um professor tem total controle sobre todos os parâmetros de
um curso, podendo restringir outros professores, escolher o formato do curso tais como, semanais,
por tópico ou um formato social centrada na discussão, acompanhar e rastrear os usuários através de
relatórios de atividade de cada aluno e da turma como um todo, entre outras opções (MOODLE,
2008c).
No módulo Tarefa as tarefas podem ser marcadas com uma data de cumprimento e uma nota
máxima. Os alunos podem enviar suas tarefas para o servidor, onde as tarefas atrasadas podem ser
permitidas, mas a quantidade de atraso é mostrada claramente ao professor. Para cada tarefa pode-se
avaliar a turma inteira em um único formulário, o feedback do professor é anexado à página de
tarefa de cada aluno, recebendo a notificação por e-mail e o professor pode permitir a
reapresentação de tarefas após a atribuição das notas (MOODLE, 2008c).
54
No módulo Chat pode-se interagir através de texto, de forma síncrona, figuras do perfil são
incluídas na tela, aceita URLs, símbolos gráficos (smiles), HTML embutidos, imagens, etc., e todas
as sessões são documentadas para verificação posterior e estas também podem ser disponibilizadas
para os alunos (MOODLE, 2008c).
O módulo de Pesquisa de Opinião é semelhante a uma eleição, pode ser usado para votar em
alguma coisa ou para obter o feedback do aluno, o professor vê uma tabela com uma visão intuitiva
de quem escolheu o que os alunos podem, opcionalmente, ter permissão para ver um gráfico
atualizado de resultados (MOODLE, 2008c).
No módulo Fórum diferentes tipos de fóruns estão disponíveis tais como, fórum reservado
aos professores, news, fórum para uso geral, fórum com ações limitadas. Todas as postagens têm a
foto do autor anexada, existem diversos modos de visualizar as discussões, cada pessoa pode-se
inscrever em cada um dos fóruns e cópias são enviadas via e-mail, o professor também pode forçar
a inscrição de todos. O professor pode mover facilmente tópicos de discussão entre fóruns, também
podendo não permitir réplicas dos mesmos (MOODLE, 2008c).
Segundo Moodle (2008c), no módulo Questionário os professores podem definir uma base
de dados de questões que podem ser reutilizadas em diferentes questionários, os questionários são
avaliados automaticamente, os questionários podem ter um prazo limitado de disponibilidade, o
professor pode também decidir mostrar o feedback e/ou as respostas corretas para os alunos. Este
módulo também permite que o professor ative o embaralhamento das questões, ou seja, o
questionário de cada aluno será aleatório, para reduzir as trapaças, também é permitido importar as
questões de arquivos-texto externos. Os tipos de questionários que são instalados com o Moodle
são:
•
Questionários de múltipla escolha com resposta única ou respostas múltiplas;
•
Questões de Resposta Breve (palavras ou frases);
•
Questões Verdadeiro-Falso;
•
Questões de associação;
•
Questões aleatórias;
•
Questões numéricas (com escalas permissíveis);
55
•
Questões com resposta embutida (estilo fechado) com respostas dentro de passagens
do texto; e
•
Texto e graficos descritivos embutidos.
O módulo recursos suporta o acesso a qualquer conteúdo eletrônico (Word, Powerpoint,
flash, vídeos, sons, etc.), os arquivos podem ser enviados e administradores do servidor podem
validá-los usando formulários web. Este módulo também permite que aplicações externas da web
possam ser interligadas com dados passados para elas (MOODLE, 2008c).
Já no módulo Pesquisa de Avaliação as pesquisas incorporadas no sistema são utilizadas
para análise das classes nos cursos on-line, gerando relatórios de pesquisa on-line incluindo
gráficos, que estão sempre disponíveis, podendo ser baixados como um planilha Excel ou arquivo
de texto CSV. A interface deste módulo evita o registro de pesquisa parcialmente completadas e o
feedback sobre os resultados do aluno é fornecido para realizar a comparação com os resultados
médios da turma (MOODLE, 2008c).
O módulo laboratório de avaliação permite avaliar documentos por parceiros, e o professor
pode administrar e atribuir notas à avaliação, este módulo também suporta uma grande variedade de
critérios de avaliação. O professor também pode fornecer documentos como exemplo para que os
alunos pratiquem a avaliação (MOODLE, 2008c).
2.4.2 Desenvolvendo para o Moodle
Como o Moodle é um sistema modular, existe diversos tipos de módulos para ele e para
cada módulo um modelo de desenvolvimento. Neste trabalho será apresentado como criar um novo
tipo de questão para o módulo de questões do Moodle.
Segundo Moodle (2008a), para desenvolver um novo tipo de questionário para o ambiente
Moodle, deve-se primeiramente ter a versão 1.7 ou posterior instalada, sendo atendido este
requisito, pode-se fazer o download de um template (modelo de desenvolvimento para
questionários), através da página de módulos e plugins do Moodle.
Este template foi criado e é mantido atualizado por Tim Hunt um programador da Open
University localizada em Milton Keynes leste da Inglaterra, postado na página de módulos e plugins
em 26 de agosto de 2006. Neste template existem 12 arquivos:
56
•
edit_TEMPLATE_form.PHP;
•
script.js;
•
styles.css;
•
questiontype.PHP;
•
version.PHP;
•
icon.GIF;
•
testquestiontype.PHP;
•
install.XML;
•
qtype_TEMPLATE.PHP;
•
TEMPLATE.HTML;
•
Display.HTML; e
•
README.TXT.
Antes de começar a implementar, Hunt (2006) faz algumas observações referente aos
arquivos, todas essas observações servem para que o Moodle reconheça o novo tipo de questão e
que o autor receba os créditos, são elas:
•
Criar um identificador para o novo tipo de questão;
•
Criar um nome para o tipo de questão;
•
Renomear o diretório TEMPLATE com o identificador criado para o novo tipo de
questão;
•
Todos os arquivos que contiverem a palavra TEMPLATE como parte de seu nome,
devem ser alterados mantendo o nome e substituindo a palavra TEMPLATE com o
identificador criado anteriormente;
57
•
Abrir os arquivos, procurar e substituir a palavra QTYPEID pelo identificador do
tipo de questão;
•
Abrir os arquivos, procurar e substituir a palavra QTYPENAME pelo nome criado
para o tipo de questão;
•
Abrir os arquivos, procurar e substituir a palavra YOURNAME com o nome do autor
do novo tipo de questão;
•
Abrir os arquivos, procurar e substituir a palavra YOUREMAILADDRESS com o email do autor do novo tipo de questão;
•
Abrir os arquivos, procurar e substituir a palavra YOURPACKAGENAME com um
nome para o código fonte, neste caso QuicklySQL;
•
Editar o arquivo icon.GIF com um ícone que represente o tipo de questão criado; e
•
Mover o diretório contendo os arquivos para o diretório question/type no servidor
moodle.
Editando os arquivos
Segundo Hunt (2006), o arquivo edit_TEMPLATE_form.PHP que encontra-se na pasta raiz
do template, serve para editar o formulário da questão, ou seja, adicionar campos, botões etc., para
isso existem algumas funções da classe de edição, tais como:
•
definition_inner(&$mform): responsável por adicionar qualquer campo que se
necessite no formulário, através da função addElement do objeto $mform, sintaxe:
$mform->addElement(‘.....’);
•
set_data($question): faz um pré-processamento da definição da questão assim os
dados ficam prontos para serem carregados no formulário;
•
validation($data): realiza uma validação extra nos dados que são retornados pelo
formulário; e
•
qtype(): retorna o nome do tipo de questão.
58
Já no arquivo script.js, são especificados os códigos Javascript, caso o seu código necessite,
o arquivo styles.css serve para se especificar códigos referentes à folha de estilo, ou seja, fontes,
cores, espaçamentos, etc., No arquivo version.PHP é informado somente a data e o número da
versão do código. Já o arquivo icon.GIF é uma imagem que representa o tipo de questão que está
sendo criado (HUNT, 2006).
A classe do novo tipo de questão é definida no arquivo questiontype.PHP, o qual já vem
com a estrutura básica definida, basta renomear o nome da classe com o nome do tipo de questão e
editar as funções da classe. A classe em questão herda da classe default_questiontype, ou seja,
existe uma estrutura padrão de questão que o novo tipo de questão pode e deve utilizar (HUNT,
2006). As funções que pertencem a esta classe são:
•
name (): retorna o identificador do tipo de questão;
•
get_question_options (&$question): retorna dados extras que foram adicionados no
banco de dados;
•
save_question_options ($question): salva dados extras no banco de dados, salva as
units e respostas associadas a questão;
•
delete_question ($questionid): exclui a questão do banco de dados, recebendo como
parâmetro o identificador da questão;
•
create_session_and_responses (&$question, &$state, $cmoptions, $attempt): cria
respostas nulas no vetor de respostas, que representa a situação da questão antes do
aluno responder a mesma;
•
restore_session_and_responses (&$question, &$state): descompacta o vetor $state>responses[´´], ou seja as respostas que acabaram de serem carregadas do campo
question_states.answer do banco de dados;
•
save_session_and_responses (&$question, &$state): salva as respostas do aluno no
banco de dados;
•
print_question_formulation_and_controls
(&$question,
&$state,
$options): mostra o enunciado da questão e outras opções de controle;
59
$cmoptions,
•
grade_responses ( &$question, &$state, $cmoptions): atribui um nível para a
resposta do aluno;
•
compare_responses ($question, $state, $teststate): compara duas respostas do aluno
e retornas as duas, se forem consideradas iguais;
•
test_response (&$question, &$state, $answer): caso o código do novo tipo de
questão usar a tabela question_answer, deve-se criar um método nesta função que
determine se a resposta do aluno corresponde a resposta que se encontra na tabela;
•
check_response (&$question, &$state): verifica a resposta do aluno;
•
get_correct_responses (&$question, &$state): retorna as respostas certas;
•
get_all_responses (&$question, &$state): retorna todas as respostas;
•
get_actual_response ($question, $state): retorna a resposta atual;
•
backup ($bf, $preferences, $question, $level=6): cria um backup da instância do tipo
de questão; e
•
restore ($old_question_id, $new_question_id, $info, $restore): recupera uma
instância do tipo de questão.
Já no arquivo display.HTML deve-se especificar quais componentes de formulário o aluno
utilizará para fornecer a sua resposta e o arquivo README.TXT contem informações para editar os
outros arquivos. Caso o novo tipo de questão necessite criar tabelas no banco de dados, deve-se
especifica-las no arquivo install.XML que esta dentro da pasta db (HUNT, 2006).
O arquivo de ajuda (help) deve ser especificado no arquivo TEMPLATE.HTML, que esta
dentro da pasta \lang\en_ut8\help\template. No arquivo qtype_TEMPLATE.PHP é informado a
string que representa o identificar do tipo de questão, ou seja, o nome, neste caso SQL Exercises. Já
no arquivo testquestiontype.PHP que esta dentro da pasta \simpletest, deve-se criar unidades de
teste para a classe que defini o novo tipo de questão (HUNT, 2006).
Após fazer as mudanças nos arquivos e ter criado o algoritmo para o novo tipo de questão
pode-se oferecer suporte para importar e exportar questões para o novo tipo de questão. Hunt (2006)
60
faz outra importante observação, “se o seu tipo de questão for similar a algum já existente, seria
mais fácil adaptar o tipo já existente ao invés de começar pelo template”. Após ter sido efetuado
testes no novo tipo de questão, pode-se adiciona-lo na página de módulos e plugins do Moodle.
61
3 DESENVOLVIMENTO
O processo de aprendizagem da linguagem SQL dentro das universidades é um processo
complexo, pois a linguagem, por ter uma estrutura ampla exige muita prática por parte dos alunos.
Tal prática é feita através de exercícios de fixação, geralmente passados pelo professor. Tais
exercícios tentam englobar a maior parte possível da linguagem, com isso a quantidade de
exercícios se torna elevada.
Como a linguagem SQL não é o único foco das disciplinas de banco de dados, o professor
acaba tendo dificuldades em corrigir todos os exercícios, com isso nem sempre consegue-se passar
os exercícios desejados para os alunos, os quais para uma grande parte dos alunos acaba fazendo
falta e acarretando em médias baixas nas provas.
Na disciplina de banco de dados do curso de Tecnologia em Sistemas para a Internet,
oferecido por esta universidade não é diferente. Visando auxiliar tanto os professores das disciplinas
de banco de dados desta universidade, quanto qualquer professor desta área, este sistema foi
desenvolvido como um módulo do ambiente de aprendizagem Moodle. Nesta ferramenta o
professor pode passar exercícios da linguagem SQL, referente ao comando select com algumas
restrições descritas no item limitações, e a mesma corrige automaticamente esses exercícios,
fornecendo para os professores relatórios contendo o desempenho de cada aluno e das turmas em
geral.
3.1 SISTEMA DESENVOLVIDO
Este sistema tem como finalidade auxiliar os professores que ministram cursos da linguagem
SQL, na correção dos exercícios resolvidos pelos alunos. Ao mesmo tempo também auxilia os
alunos, pois quando se tratar de exercícios de fixação, os mesmos receberão um feedback imediato
referente a sua solução. Já quando os exercícios em questão fizerem parte de uma avaliação,
somente o professor receberá um feedback referente a solução de cada aluno. A ferramenta
desenvolvida rendeu duas publicações sendo uma delas na quarta edição do Congresso Sul
Brasileiro de Computação – SULCOMP (WEBBER, MOREIRA & SILVA, 2008b) e a outra no
segundo MoodleMoot Brasil um evento direcionado aos interessados pelo ambiente moodle
(WEBBER, MOREIRA & SILVA, 2008a)
62
Apesar da linguagem SQL ter uma estrutura ampla, este sistema processa somente o
comando de seleção de dados (select), não processando comandos tais como: inclusão de dados em
tabelas, alteração de dados em tabelas e exclusão de dados em tabelas, uma vez que encontrou-se
dificuldades no desenvolvimento desse sistema, descritos no item limitações.
A linguagem de programação que foi utilizada foi o PHP aliado ao HTML. A interface
adotada para escrever o código-fonte foi o DreamWeaver 8. O banco de dados utilizado foi o
MySQL, devido a facilidade de interação com o PHP e por ser tratado pelo ambiente Moodle. Como
servidor de aplicação foi utilizado a aplicação XAMPP, a qual fornece todos os componentes
necessários tais como, motor PHP, banco de dados MySQL e o sistema administrador de banco de
dados PHPMyAdmin.
Esta primeira etapa de projeto compreendeu a modelagem do sistema proposto, através da
UML (Unified Modeling Language), compreendendo análise de requisitos (funcionais, não
funcionais), regras de negócio, diagramas de classes, descritas nos itens a seguir. Já o diagrama de
atividades e o diagrama ER do sistema desenvolvido encontram-se no apêndice B e as instruções
referente a instalação da ferramenta no ambiente moodle estão no apêndice C. As ferramentas
utilizadas para realizar a modelagem do sistema, utilizando os conceitos de UML, foram a
Enterprise Architect 6.0 e o DBDesigner 4.
3.1.1 Análise de Requisitos
Foram levantados através de estudos e junto aos professores que orientam este projeto, quais
seriam os requisitos básicos para garantir o funcionamento do sistema, documentando-os da
maneira devida.
3.1.1.1 Requisitos Funcionais
O levantamento dos requisitos funcionais foi dividido em requisitos funcionais atendidos
pelo ambiente Moodle e requisitos funcionais que serão atendidos pela ferramenta proposta.
•
Requisitos funcionais atendidos pelo Moodle:
o O sistema deve permitir que o aluno se cadastre no mesmo e participe das
turmas e cursos oferecidos;
63
o O sistema deve permitir que o professor crie cursos;
o O sistema deve permitir que o professor crie turmas;
o O sistema deve permitir que o professor cadastre alunos;
o O sistema deve armazenar os exercícios que o professor criou, para poderem
ser utilizados outras vezes e por turmas diferentes;
o O sistema deve permitir que o professor visualize o desempenho de cada
aluno;
o O sistema deve permitir que o professor visualize o desempenho de cada
turma;
o O sistema deve permitir que o professor crie avaliações; e
o O sistema deve permitir que o aluno responda as avaliações.
•
Requisitos funcionais que deverão ser atendidos pela ferramenta proposta:
o O sistema deve permitir que o professor crie exercícios de SQL para as
turmas;
o O sistema deve permitir que o professor inclua uma imagem do modelo do
banco de dados utilizado em cada exercício;
o O sistema deve permitir que o aluno pratique exercícios de SQL; e
o O sistema deve corrigir automaticamente os exercícios respondidos pelos
alunos.
3.1.1.2 Requisitos Não Funcionais
O levantamento dos requisitos não funcionais foi dividido em requisitos não funcionais
atendidos pelo ambiente Moodle e requisitos não funcionais que serão atendidos pela ferramenta
proposta.
•
Requisitos não funcionais atendidos pelo Moodle:
64
o O sistema deve utilizar o banco de dados MySQL;
o O sistema deve ser implementado na linguagem PHP;
o O sistema deve poder ser acessado de qualquer computador com acesso a
internet; e
o Os perfis de usuário para o sistema são professor e aluno.
•
Requisitos não funcionais atendidos pela ferramenta proposta:
o Para efetuar a correção automática dos exercícios o sistema deve utilizar as
técnicas de autômatos finitos e expressões regulares.
3.1.1.3 Regras de Negócio
Esta seção apresenta as regras de negócio levantadas, onde as mesmas são:
•
Nenhum aluno pode ter acesso à resposta de outro aluno;
•
Nos exercícios de avaliação o aluno possui somente uma tentativa para cada
exercício;
•
Nos exercícios de prática o FeedBack deve ser direcionado para o aluno;
•
Nos exercícios de avaliação o FeedBack deve ser direcionado para o professor; e
•
O FeedBack deve ser detalhado, informando onde o aluno errou, ou informando que
a resposta está correta.
3.1.2 Diagrama de Classes
Segundo Booch, Jacobson & Rumbaugh (2000), “um diagrama de classes é um diagrama
que mostra um conjunto de classes, interfaces e colaborações e seus relacionamentos”. A Figura 30
e a Figura 31 apresentam o diagrama de classes, que representa as classes que foram utilizadas para
desenvolver o sistema proposto. No caso da Figura 30, as classes que são apresentadas, são as
classes que foram utilizadas para a criação das telas do sistema proposto, tais classes fazem parte da
estrutura do sistema Moodle. Sendo assim a classe que trabalhou-se foi a classe
question_edit_SQL_Exercises_form. Já a Figura 31 apresenta as classes utilizadas para a elaboração
65
do novo tipo de questão para o ambiente Moodle, onde a classe utilizada foi a classe
SQL_Exercises_qtype.
66
Figura 30. Diagrama das classes para elaboração das telas do sistema.
67
Figura 31. Diagrama das classes utilizadas para criar o tipo de questão SQL_Exercises.
68
3.2 INTERFACES DO SISTEMA
Nesta seção serão apresentadas as principais interfaces do sistema desenvolvido, sendo as
telas do professor, referentes a administração do curso, criação de questões e geração de relatórios,
e as telas do aluno referente a página inicial do curso e a tela para responder as questões.
3.2.1 Telas do professor
A Figura 32 apresenta a tela de administração do curso, apresentada ao professor. A tela de
administração do curso permite que o professor crie questionários, adicione questões aos
questionários, crie avaliações, exercícios de fixação, visualize o desempenho dos alunos, crie
turmas, entre outras opções referentes à administração do curso.
Figura 32. Tela de administração do curso.
A Figura 33 apresenta a tela onde o professor pode adicionar questões no banco de questões
do ambiente moodle, nesta tela o professor escolhe o tipo de questão que será criada, neste caso
exercícios de SQL, e o sistema apresenta outra tela com os campos necessários para a criação da
questão, para cada tipo de questão tem-se campos diferentes.
69
Figura 33. Tela para a escolha do tipo de questão a ser criada.
Já a Figura 34 apresenta a tela onde o professor pode criar a questão, ou seja, o professor
pode criar o nome da questão, adicionar o enunciado da questão, adicionar a imagem do modelo ER
utilizado na questão, a nota máxima que a questão pode ter e a resposta padrão que será utilizada
para a correção automática. Quanto a imagem do modelo ER, o professor pode cadastrar-la uma vez
e usá-la em mais de uma questão. Para diminuir a poluição visual pode-se criar uma questão com a
imagem do modelo ER e referenciá-la nas demais questões que baseiam-se nela. Porém fazendo
isso não pode-se embaralhar as questões. Os campos nome da pergunta, texto da pergunta,
avaliação predefinida e resposta padrão são de preenchimento obrigatório.
70
Figura 34. Tela de edição da questão a ser criada.
A Figura 35 apresenta a tela onde o professor recebe o relatório das notas da turma,
apresentando a nota individual de cada aluno e o total de pontuação do curso.
71
Figura 35. Tela com o relatório das notas da turma.
A Figura 36 apresenta a tela onde o professor verifica as tentativas da turma, nesta tela são
apresentados dados como o tempo que cada aluno levou para responder a questão, suas notas e o
gráfico da quantidade de alunos por faixa de nota.
72
Figura 36. Tela do professor com dados sobre as tentativas da turma.
Já a Figura 37 apresenta a tela onde o professor pode revisar a tentativa de cada aluno. Nesta
tela o professor pode visualizar todo o histórico de respostas do aluno para cada questão, juntamente
com o feedback recebido, até o momento em que o aluno resolveu finalizar o questionário.
73
Figura 37. Tela do professor com a revisão das tentativas de cada aluno.
74
3.2.2 Telas do aluno
A Figura 38 apresenta a tela inicial do curso escolhido pelo aluno, onde ele pode responder
questionários, visualizar mensagens do professor, notícias, eventos, participar de fóruns, chats,
visualizar suas notas, entre outras opções.
Figura 38. Tela do inicial do curso.
A Figura 39 apresenta a tela onde o aluno pode responder um questionário, neste caso um
questionário de SQL, e onde ele recebe o feedback de sua tentativa.
75
Figura 39. Tela para o aluno responder o questionário.
76
3.3 IMPLEMENTAÇÃO
Além das telas implementadas, que são o meio de interagir com o usuário, existem scripts
php responsáveis pela conexão e operações com o banco de dados, interação com o ambiente
Moodle, e o mais importante a correção automática dos exercícios.
A ferramenta desenvolvida utiliza a técnica de autômatos para realizar a comparação da
resposta do aluno com a resposta padrão da questão. A ferramenta em questão adota a técnica de
autômatos finitos determinísticos. A Figura 40 apresenta um como seria uma autômato padrão
gerado por um comando select.
Figura 40. Autômato padrão gerado por um select genérico.
No caso da Figura 40 foi gerado um autômato através de um comando de consulta genérico,
na ferramenta desenvolvida cada questão gera um autômato de sua resposta padrão, o qual recebe a
resposta do aluno para realizar as comparações. O autômato recebe a resposta do aluno como
entrada, se a resposta do aluno atingir o estado final, significa que a mesma está correta, caso
contrário o autômato retorna os estados em que houve erros, o que permitirá gerar um feedback
informando onde o aluno errou. A Figura 41 apresenta um exemplo de um autômato gerado por
uma resposta padrão.
77
Figura 41. Exemplo de um autômato gerado por uma resposta padrão.
O algoritmo desenvolvido, além de utilizar as funções fornecidas pelo ambiente Moodle e
algumas funções desenvolvidas para realizar tratamentos de variáveis, possui como principais os
seguintes métodos:
•
Função grade_responses: é uma função que todo tipo de questão do Moodle deve
possuir, ela é responsável por avaliar as respostas. Na ferramenta desenvolvida ela
recebe dois vetores de estados, sendo a resposta padrão e a resposta do aluno, realiza
algumas comparações necessárias para invocar os demais métodos, após isso é
invocado o método test_response. Após os procedimentos contidos na função
mencionada terem sido realizados, a função em questão recebe a soma das
penalidades, as mensagens de erro e os tipos de erros ocorridos, então ela avalia a
questão e armazena esses dados no banco de dados para futuros relatórios;
•
Função print_question_formulation_and_controls: verifica-se o tipo de ação a ser
realizada, se é para gerar a tela para o aluno responder a questão ou se é para
imprimir a tela com as informações sobre a avaliação;
•
Função print_question_grading_details: serve como complemento da função acima
citada, este procedimento é responsável por apresentar o histórico das tentativas do
aluno, juntamente com os respectivos feedbacks;
•
Função test_response: realiza alguns tratamentos em ambos os vetores de estados
para poder submetê-los as próximas funções, feito isso ele invoca o método select;
•
Função select: verifica se o primeiro elemento do vetor de estados do aluno refere-se
ao comando select, caso não for, é gerado um erro informando que o comando
78
fornecido pelo aluno não foi reconhecido. Após isso verifica se a cláusula FROM
existe na resposta do aluno, se não existir é gerado um erro. Após a execução desses
passos, invocam-se os demais procedimentos, na seqüência descrita abaixo;
•
Função check_cols: submete a resposta do aluno ao autômato gerado pela resposta
padrão, o qual verifica se o aluno declarou em sua reposta as colunas contidas na
resposta padrão, se o aluno declarou alguma coluna que não encontra-se na resposta
padrão ou esqueceu de declarar alguma coluna, é gerado um erro informando a
coluna que o mesmo esqueceu ou declarou a mais, mesmo que as colunas na resposta
do aluno estejam em ordem diferente das da resposta do professor. Nesta função
também são analisadas as funções de grupo, o algoritmo desenvolvido considera as
funções como colunas, se o aluno esquecer de utilizar uma dessas funções, o sistema
gera um erro informando que o aluno esqueceu de declarar uma coluna, informando
qual foi esquecida ;
•
Função check_tables: realiza os mesmos procedimentos que a função check_cols,
mas referindo-se as tabelas da consulta, caso o aluno esqueça ou declare uma tabela
que não exista na resposta padrão é gerado um erro informando onde que o aluno
errou;
•
Função where: verifica se a resposta padrão contém a cláusula where, caso exista é
verificado se a mesma esta declarada na resposta do aluno, se não estiver é gerado
um erro informando a ausência desta. Este método também é responsável por
analisar as expressões pertinentes a esta cláusula, realizando comparações para
verificar se as expressões do comando do aluno estão na resposta padrão e vice e
versa, mesmo que estejam em ordens diferentes, caso falte ou não exista na resposta
padrão alguma expressão fornecida pelo aluno, é gerado um erro informando cada
expressão incorreta ou faltante; e
•
Função ending: neste método são realizadas as últimas comparações entre a resposta
do aluno e a resposta padrão, onde são verificadas as cláusulas GROUP BY, ORDER
BY e LIMIT, caso alguma destas esteja presente na resposta padrão e falte ou esteja
incorreta na resposta do aluno, é gerado um erro reportando as faltas cometidas pelo
aluno;
79
3.3.1 Etapas da correção automática
Esta seção visa demonstrar de uma forma geral como funciona a estrutura da ferramenta
desenvolvida, ou seja, os passos que o algoritmo realiza quando recebe a resposta do aluno. A
Figura 42 representa a resposta do aluno:
Figura 42. Exemplo de uma resposta do aluno.
Primeiramente o sistema realiza uma série de tratamentos referentes aos apelidos, vírgulas,
parênteses, entre outros. Após isso é analisado o tipo de operação, no caso acima têm-se uma
consulta, como o sistema só atende consultas qualquer outro comando é considerado inválido. Caso
seja uma consulta o sistema invoca o método responsável pela análise das colunas que devem ser
retornadas (check_cols).
Neste método são realizadas comparações entre a resposta do aluno e a resposta padrão, caso
faltar alguma coluna na resposta do aluno ou não existir a coluna declarada na resposta padrão, o
sistema gera um erro e uma penalidade para o aluno. Após analisadas todas as colunas realiza-se os
mesmos passos para o tratamento das tabelas através do método check_tables.
O próximo passo refere-se à cláusula WHERE, verifica-se se a mesma existe na resposta
padrão, caso existir o sistema verifica se a mesma existe na resposta do aluno, caso não exista o
sistema gera um erro e uma penalidade para a resposta do aluno. Existindo, o sistema passa a
analisar as expressões da cláusula, comparando seus operadores lógicos e aritméticos com as
expressões da resposta padrão. O método responsável por esta etapa é o where.
Para finalizar o método ending é chamado, como descrito anteriormente ele é responsável
pelas últimas verificações, analisando as cláusulas ORDER BY, GROUP BY e LIMIT, neste exemplo
como não existe nenhuma dessas cláusulas, este método não realiza nenhuma ação.
Realizadas todas estas etapas a função grade, realiza avaliação da questão, levando em conta
a soma das penalizações, feito o cálculo esta função salva o feedback, os tipos de erros ocorridos e
as notas obtidas pelo aluno no banco de dados, estes dados serão utilizados na hora de gerar os
80
relatórios para o professor. As penalizações foram definidas com o professor orientador deste
trabalho levando-se em conta cada tipo de erro, assim criou-se uma tabela de penalidades onde para
cada tipo de erro é descontado um percentual da nota máxima da questão, essa tabela é representada
pela Tabela 10.
Tabela 10. Penalidades.
Tipo de Erro
Aluno esqueceu terminador de comando (;)
Aluno deixou em branco
Aluno colocou vírgula antes do FROM
Aluno colocou mais de uma vírgula entre as colunas
Aluno esqueceu de colocar vírgula entre as colunas
Coluna declarada pelo aluno não encontrada
Coluna declarada mais de uma vez
Aluno esqueceu de declarar uma coluna
Aluno colocou mais de uma vírgula entre as tabelas
Tabela declarada pelo aluno não encontrada
Aluno esqueceu de declarar tabela
Aluno errou operador lógico para expressão (and | or)
Aluno deixou um operador lógico no final do WHERE (where a=1 and)
Aluno não declarou alguma expressão do WHERE
Expressão do WHERE do aluno não encontrada
Aluno esqueceu cláusula WHERE
Aluno colocou o GROUP BY depois do ORDER BY
Aluno declarou LIMIT em local errado
Aluno esqueceu o GROUP BY
Aluno esqueceu o ORDER BY
Expressão do GROUP BY incorreta
Expressão do ORDER BY incorreta
Aluno esqueceu o LIMIT
Expressão do LIMIT incorreta
Comando não reconhecido, errou o SELECT no caso
Cláusula FROM não declarada
Penalidade (%)
1%
100%
1%
1%
5%
5%
5%
5%
1%
10%
20%
10%
5%
15%
15%
25%
10%
5%
10%
10%
10%
10%
10%
10%
20%
30%
3.4 LIMITAÇÕES
O sistema desenvolvido possui certas limitações. Devido a complexidade do código-fonte do
Moodle e complicações encontradas no template utilizado para desenvolver esta ferramenta,
demandou-se muito tempo para realizar a integração do sistema proposto com o Moodle, com isso
conseguiu-se que a ferramenta desenvolvida processe somente seleção de dados, não processando:
sub-consultas, a sub-linguagem DDL, responsável por criar banco de dados e tabelas, alterar
tabelas, excluir tabelas, e os comandos INSERT, DELETE,UPDATE, da sub-linguagem DML.
81
Outra limitação encontrada foi que aluno só poderá usar o asterisco (*) como caractere de
seleção de todas as colunas de determinada tabela, quando o professor indicar no enunciado da
questão que o mesmo poderá usá-lo, se não o aluno é obrigado a declarar todas as colunas. O
sistema trabalha normalmente com as funções de grupo.
O sistema atende somente junções cruzadas (CROSS JOIN), com isso é necessário que o
professor indique no enunciado informando ao aluno que o mesmo deve utilizar somente junções
cruzadas. Para evitar que o aluno seja penalizado por responder uma questão corretamente, mas de
uma maneira diferente da resposta cadastrada pelo professor o ambiente Moodle permite que o
professor altere a avaliação. Já nas expressões da cláusula WHERE, por se tratar da maior
dificuldade encontrada em implementar esta ferramenta, também existem algumas restrições e
permissões tais como:
•
O sistema não aceita conjunto de expressões entre parênteses, exemplo: “SELECT A,
B, C FROM CLIENTE WHERE (A<10 AND B>5) OR C = 2;”;
•
Trabalha normalmente com os operadores relacionais (<, >, <=, >=, !=);
•
Aceita os operadores lógicos AND e OR;
•
Aceita os comandos BETWEEN, IN, IS NULL, IS NOT NULL; e
•
Trabalha com os comandos GROUP BY, HAVING, ORDER BY (ASC, DESC), LIMIT
(OFFSET);
3.5 TESTES E AVALIAÇÃO
Durante a fase de desenvolvimento foram realizados testes individuais, visando a qualidade
do sistema desenvolvido, e sua usabilidade. Nestes testes foram identificados alguns erros de
programação que foram corrigidos. Teste com usuários serão realizados e apresentados durante a
banca de avaliação deste trabalho e posteriormente adicionados neste documento.
Neste item será apresentado um teste individual, com uma resposta padrão cadastrada pelo
usuário professor e três tentativas realizadas pelo usuário aluno, apresentando o feedback recebido
pelo aluno. A Figura 43 representa uma resposta padrão.
82
Figura 43. Exemplo de resposta padrão.
A Figura 44 apresenta a primeira tentativa do aluno. Neste caso o aluno cometeu uma série
de erros, apresentados no menu Erros/ Avisos, o que acarretou em uma penalidade de 100%.
Figura 44. Primeira tentativa do aluno.
Já a Figura 45 apresenta a segunda tentativa do aluno. Percebe-se que nesta tentativa o aluno
cometeu menos erros devido o feedback obtido na primeira tentativa, o que gerou uma penalidade
de 21% da nota máxima.
83
Figura 45. Segunda tentativa do aluno.
A Figura 46 mostra a terceira tentativa do aluno. Neste caso, baseando-se nos feedbacks
obtidos nas outras tentativas o aluno conseguiu chegar na resposta correta.
Figura 46. Terceira tentativa do aluno.
Durante os testes não foram encontrados problemas referentes a integridade do sistema, mas
como citado nas limitações do sistema, podem existir cláusulas e ou comandos não testados, que
possam vir a gerar algum erro durante a correção automática das respostas.
84
4 CONCLUSÃO
Este trabalho teve como principal objetivo desenvolver uma ferramenta que através das
técnicas de autômatos e expressões regulares, pudesse corrigir automaticamente exercícios da
linguagem de banco de dados SQL, usando uma resposta padrão cadastrada pelo professor como
base de comparação. Outra característica importante deste trabalho foi a de desenvolver a
ferramenta para executar como um novo tipo de questão para o ambiente de aprendizagem Moodle.
Ao final da implementação e testes da ferramenta, foi possível observar que a maior parte
dos objetivos inicialmente propostos foram alcançados, devido a problemas encontrados durante a
implementação desta ferramenta, a complexidade do código fonte do ambiente Moodle, o qual
demandou muito tempo para realizar a integração entre as ferramentas, e a dificuldade na
elaboração do algoritmo responsável pela análise das expressões pertencentes a cláusula WHERE do
comando SELECT, necessitou-se reduzir o escopo do trabalho.
Assim somente o comando de seleção de dados é processado pelo sistema com algumas
limitações citadas no durante o trabalho, ou seja, operações como inserções de dados, modificações
de dados, exclusão de dados e a utilização de sub-consultas não são tratados pelo sistema. Quanto a
integração com o ambiente Moodle, deu-se de maneira satisfatória.
Vale ressaltar que o bom funcionamento do sistema, no aspecto que tange os resultados
obtidos com a correção automática das respostas, está diretamente ligado com o correto
cadastramento da resposta padrão pelo professor, pois não existe tratamento referente a esta.
Durante o processo de desenvolvimento desta ferramenta percebeu-se que as técnicas utilizadas
possuem diversas limitações e que o ideal para poder atingir os objetivos inicialmente propostos
seria a utilização da técnica de comparação por retorno como técnica auxiliar, tendo assim uma
solução hibrida para os problemas encontrados, uma vez que nas ferramentas pesquisadas nenhuma
delas traz em seu feedback onde ocorreu o erro cometido pelo aluno.
Espera-se que a ferramenta possa realmente auxiliar os alunos e professores que estudam/
ensinam a linguagem SQL, e que se possa dar continuidade a este trabalho uma vez que percebeu-se
grande interesse por parte de professores e participantes dos eventos onde a ferramenta foi
apresentada, em utilizá-la.
85
4.1 TRABALHOS FUTUROS
Nesta seção são apresentadas algumas idéias de trabalhos futuros para a ferramenta
desenvolvida neste trabalho. Uma proposta seria tratar as limitações atuais do sistema tais como:
•
O uso do caractere “*” para seleção de todas as colunas de uma determinada tabela,
quando o mesmo não constar na resposta padrão;
•
As limitações referentes as expressões da cláusula WHERE;
•
A aceitação de sub-consultas; e
•
Processar os demais comandos das sub-linguagens da SQL;
Outra sugestão é a criação de um módulo para o presente trabalho no qual o professor possa
criar fisicamente o banco de dados utilizados nas questões e que além da correção automática
utilizar como base a resposta padrão, o sistema submeta a reposta do aluno ao banco criado,
utilizando o retorno dessa submissão como base de comparação.
86
REFERÊNCIAS BIBLIOGRÁFICAS
BOOCH, Grady; JACOBSON, Ivar; RUMBAUGH, James. UML guia do usuário. Rio de Janeiro:
Elsevier, 2000.
DAMAS, Luís. SQL structured query language. Rio de Janeiro: LTC, 2007.
DATE, C.J. Introdução a sistemas de bancos de dados. Rio de Janeiro: Elsevier, 2004.
HOPCROFT, John E; ULLMAN, Jeffrey D; MOTWANI, Rajeev. Introdução à teoria de
autômatos, linguagens e computação. Rio de Janeiro: Editora Campos, 2003.
HUNT, Tim. Question Type: New question type template. 2006. Disponível em:
<http://moodle.org/mod/data/view.php?d=13&rid=443>. Acesso em: 19 mai. 2008.
LINO, Adriano D. P; SILVA, Aleksandra S; FAVERO, Eloi L; BRITO, Silvana R; HARB, Maria
da Penha A. Avaliação automática de consultas SQL em ambiente virtual de ensinoaprendizagem. Disponível em: <http://www.labead.ufpa.br/gped/publicacoes/?C=S;O=D>. Acesso
em: 21 mar. 2008.
MENEZES, Paulo Blauth. Linguagens formais e autômatos. Porto Alegre: Sagra Luzzatto, 2005.
MITROVIC, Antonija. An Intelligent SQL Tutor on the Web. 2003. Disponível em:
<http://aied.inf.ed.ac.uk/members02/archive/Vol_13/mitrovic/paper.pdf>. Acesso em: 20 mar.
2008.
MOODLE. Development: Question Type plugin how to. Disponível em:
<http://docs.moodle.org/en/Development:Question_type_plugin_how_to>. Acesso em: 19 mai.
2008a.
MOODLE. História do Moodle. Disponível em:
<http://docs.moodle.org/pt/Hist%C3%B3ria_do_Moodle>. Acesso em: 17 mai. 2008b.
MOODLE. Moodle Docs. Disponível em:
<http://docs.moodle.org/pt_br/P%C3%A1gina_principal>. Acesso em: 09 mar. 2008c.
OLIVEIRA, Celso Henrique Poderoso. SQL curso prático. São Paulo: Novatec, 2002.
SOUZA, André Luiz. SQL WEB, ambiente de apoio ao ensino de banco de dados. Disponível
em: <http://galileu.fundanet.br/jornada/artigos/computacao/andre_souza.pdf>. Acesso em: 21 mar.
2008.
SQL WEB. SQL WEB. Disponível em: <http://www.sqlweb.com.br>. Acesso em: 30 nov.2009.
TEOREY, Toby; LIGHTSTONE, Sam; NADEAU, Tom. Projeto e modelagem de banco de
dados. Rio de Janeiro: Elsevier, 2007.
WIKIPÉDIA. Teoria dos Autômatos. Disponível em:
<http://pt.wikipedia.org/wiki/Teoria_dos_aut%C3%B4matos>. Acesso em: 26 mar. 2008.
WEBBER, Vinicius Luiz; MOREIRA, Benjamin Grando; SILVA, Julia Marques Carvalho da.
QuicklySQL: Tipo de Questionário para a Correção Automática de SQL Utilizando o
Ambiente Moodle. MoodleMoot Brasil, São Paulo, Out 2008a.
WEBBER, Vinicius Luiz; MOREIRA, Benjamin Grando; SILVA, Julia Marques Carvalho da.
Ferramenta para a Correção Automática de Exercícios da Linguagem SQL QuicklySQL.
SULCOMP, Criciúma, Out 2008b.
88
APÊNDICES
A FUNÇÕES DE GRUPO DA DML
A Tabela 11 mostra a relação das funções de grupo.
Tabela 11. Funções de grupo.
Função
COUNT
SUM
AVG
MIN
MAX
STDDEV
VARIANCE
Ação
Retorna o número de linhas afetadas pelo comando.
Retorna o somatório do valor das colunas especificadas.
Retorna a média aritmética dos valores das colunas.
Retorna o menor valor da coluna de um grupo de linhas.
Retorna o maior valor da coluna de um grupo de linhas.
Retorna o desvio-padrão da coluna.
Retorna a variância da coluna.
Fonte: Oliveira (2002).
O COUNT é uma função que retorna o número de linhas que atende uma determinada
condição, podendo ser utilizado com um asterisco entre parênteses para indicar que o que deseja-se
é a quantidade total de linhas, independentemente de existir linhas com colunas nulas ou não
(OLIVEIRA, 2002). A Figura 47 mostra alguns exemplos da utilização dessa função.
Figura 47. Exemplos da utilização da função COUNT.
Fonte: Oliveira (2002).
No caso do exemplo 1 será retornado o total de registros da tabela gravadora, já no exemplo
2 será retornado o total de registros que possuem endereço, o exemplo 3 mostra uma outra maneira
de executar o exemplo 2, selecionando todas as linhas que não tiverem o campo endereço como
nulo. A função COUNT possui uma cláusula que permite saber quantos registros são distintos uns
dos outros, ou seja, registros que não repetem, essa cláusula é a DISTINCT, a Figura 48 mostra um
exemplo do uso dessa cláusula.
Figura 48. Cláusula DISTINCT da função COUNT.
Fonte: Damas (2007).
Neste caso será retornada a quantidade de músicas distintas, ou seja, sem repetições, já que
pode existir mais de um autor para uma mesma música.
A função SUM retorna o valor total de uma determinada coluna em um determinado grupo
de linhas, por exemplo, se quer saber o total do preço de venda dos CDs, utiliza-se o comando:
SELECT SUM (PRECO_VENDA) FROM CD;
Um exemplo para função AVG, que extrai a média aritmética de um determinado grupo de
linhas, seria:
SELECT AVG ( PRECO_VENDA ) FROM CD;
Neste caso será retornado o preço médio dos CDs da loja. Para saber o menor valor de uma
coluna em um grupo de linhas é utilizado a função MIN, podendo ser utilizada para colunas do tipo
data ou alfanumérica. Por exemplo, se quer obter o preço de venda do CD mais barato da loja,
pode-se usar o seguinte comando:
SELECT MIN ( PRECO_VENDA ) FROM CD;
Já para saber o maior valor de uma coluna em um grupo de linhas é utilizado a função MAX,
também podendo ser utilizada para colunas do tipo data ou alfanumérica. Por exemplo, se quer
saber o CD mais caro da loja, pode-se usar o seguinte comando:
SELECT MAX ( PRECO_VENDA ) FROM CD;
A função STDDEV retorna o desvio-padrão de uma determina coluna, no caso para saber o
desvio-padrão do preço dos CDs da loja, pode-se usar o seguinte comando:
SELECT STDDEV ( PRECO_VENDA) FROM CD;
91
Já a função VARIANCE, retorna a variância de uma determinada coluna, neste caso para
saber a variância do preço dos CDs da loja, pode-se usar o seguinte comando:
SELECT VARIANCE ( PRECO_VENDA ) FROM CD;
A DML também permite agrupar linhas com base em valores de determinadas colunas,
podendo não estar trabalhando na pesquisa de todas as linhas da tabela, mas em grupos menores,
para isso utiliza-se as funções de grupo com a cláusula GROUP BY no comando SELECT, essa
cláusula deve vir antes da cláusula ORDER BY e depois do WHERE quando for necessário utilizálos (OLIVEIRA, 2002). A Figura 49 mostra a sintaxe desse comando e a Tabela 12 a descrição das
cláusulas.
Figura 49. Sintaxe básica do comando GROUP BY.
Fonte: Oliveira (2002).
Tabela 12. Descrição das cláusulas da sintaxe do comando GROUP BY.
Cláusula
coluna
Descrição
Lista de colunas pela qual se quer agrupar (deve corresponder à mesma
seqüência da cláusula GROUP BY).
função_de_grupo COUNT, SUM, AVG, MIN ou MAX.
Fonte: Oliveira (2002).
O comando GROUP BY afeta toda a tabela, mas em alguns casos pode-se não querer que
isso ocorra. Para isso o comando GROUP BY pode ser utilizado juntamente com a cláusula
WHERE ou com a cláusula HAVING, ambas produzem resultados semelhantes, diferindo somente
na sintaxe, onde a cláusula WHERE vem antes do comando GROUP BY e a cláusula HAVING
vem após o mesmo (OLIVEIRA, 2002). Segundo Damas (2007) a cláusula HAVING é utilizada
para “fazer restrições ao nível dos grupos que são processados”, atuando unicamente sobre o
resultado dos grupos, já a cláusula WHERE destina-se à restrição das linhas. A Figura 50 mostra
um exemplo para a cláusula HAVING, neste caso serão selecionados somente os Id com comissões
totais superiores a 1000.
92
Figura 50. Exemplo da cláusula HAVING do comando GROUP BY.
Fonte: Damas (2007).
B DIAGRAMAS
Diagrama de Atividades
Segundo Booch, Jacobson & Rumbaugh (2000), “Um diagrama de atividades mostra o
fluxo de uma atividade para a outra”, onde uma atividade é uma execução em andamento nãoatômica em uma máquina de estados. As atividades resultam em ações, formadas pelas executáveis
atômicas que resultam em uma mudança de estado do sistema ou o retorno de um valor. A Figura
51 apresenta o diagrama de atividades do usuário aluno para o sistema desenvolvido. Como as
atividades mais complexas que o professor realizará no sistema são atendidas pelo sistema Moodle,
não foi necessário a elaboração do diagrama de atividades para o professor.
93
Figura 51. Diagrama de atividades do aluno.
94
Diagrama ER
Segundo Teorey, Lightstone & Nadeau (2007) um Diagrama Entidade-Relacionamento
(DER), é um diagrama composto por três classes de objetos, sendo eles: entidades, relacionamentos
e atributos.
Segundo Teorey, Lightstone & Nadeau (2007) as entidades “são os principais objetos de
dados sobre os quais informações devem ser coletadas”. As entidades podem representar uma
pessoa, lugar, algum evento, etc.
Já os relacionamentos representam associações do mundo real entre uma ou mais entidades,
não possuindo existência física ou conceitual, apenas sua dependência das entidades associadas. E
os atributos representam as características de entidades que oferecem detalhes descritivos sobre elas
(TEOREY, LIGHTSTONE & NADEAU, 2007). A Figura 52 mostra o Diagrama de EntidadeRelacionamento (DER) para o sistema proposto.
Figura 52. Diagrama ER para o sistema proposto.
95
A Figura 52 apresenta o diagrama ER abstraído da ferramenta proposta, existem outras
tabelas envolvidas, mas como o foco deste trabalho é apenas criar um novo tipo de questão para o
Moodle, foram apresentadas as tabelas mais importantes para o processo de desenvolvimento.
No caso da tabela user, foram abstraídas algumas colunas, para efeito de melhor
visualização do diagrama, uma vez que tais colunas são referentes a dados cadastrais dos usuários
do sistema.
Já a tabela question é a tabela responsável por armazenar a questão criada, guardando dados
como: nome da questão, categoria, tipo de questão (neste caso questões de SQL), imagem a ser
mostrada com o enunciado, o enunciado da questão, entre outros dados complementares.
A tabela question_answers, armazena a resposta padrão para cada questão, incluindo uma
nota fracionária de 0 a 1 para cada questão e o feedback de cada questão a ser apresentado para o
aluno.
O Moodle utiliza a tabela question_categories para agrupar questões, ou seja, nessa tabela
são armazenados questionários padrões. É esta tabela que informa de qual curso a questão faz parte.
Já os questionários criados são armazenados na tabela quiz, que foi abstraída do modelo ER
apresentado neste capítulo.
Na tabela question_states são armazenadas as respostas do aluno para cada tentativa de
resposta para as questões, juntamente com o tempo levado para responder, notas percentuais, entre
outras informações de controle. Esta tabela utiliza a tabela question_attempts para saber de qual
módulo as tentativas do aluno pertencem.
A tabela question_sql_exercises armazena o feedback para cada tentativa do aluno, para
revisão do questionário tanto pelo aluno quanto pelo professor. Já a tabela question_sql_error_type
armazena todos os tipos de erro que o aluno cometeu, para gerar relatórios futuros tais como: qual o
erro mais comum entre os alunos, em que data determinado erro mais ocorreu, entre outros. Para
tais relatórios o professor ou administrador do curso, deverá utilizar ferramentas de extração de
dados, ou seja, neste trabalho não foi desenvolvido uma interface para o professor visualizar estes
dados.
96
C INSTALANDO O QUICKLY SQL NO MOODLE
Nesta seção são apresentadas as duas maneiras existentes para instalar a ferramenta
desenvolvida no ambiente Moodle. Caso o ambiente Moodle já estiver instalado e executando em
um servidor, deve-se copiar a pasta SQL_Exercises e colá-la no seguinte diretório:
moodle\question\type\. Feito isso o administrador do sistema deve clicar no link avisos na página
de administração do sistema como mostra a Figura 53.
Figura 53. Tela de administração do sistema.
Caso o Moodle não estiver instalado deve-se copiar a pasta SQL_Exercises e colá-la no
seguinte diretório: moodle\question\type\. Assim quando executar a instalação do Moodle, a
ferramenta será instalada automaticamente.
97