prolog

Operações Relacionais em Prolog

Por
filósofo
Seleção, Projeção e Negação — como em SQL, mas com poder lógico

O modelo relacional de dados — popularizado por SQL — é baseado em operações como seleção
(filtrar linhas), projeção (escolher colunas) e junção.
Em Prolog, essas operações surgem naturalmente com regras, variáveis e unificação.
Vamos explorar cada uma delas usando uma base de filmes.

1. Base de dados: filmes

Considere a tabela filme(Título, Gênero, Ano, Duração), com os seguintes fatos:


 

2. Seleção — filtrar linhas (WHERE)

A seleção corresponde ao WHERE do SQL: escolhemos apenas as tuplas que
satisfazem uma condição. Em Prolog, criamos uma regra que inclui a condição como uma meta adicional.

Regra: classico(T, G, A, D) — filmes até 1985


 

Consultando:


 

3. Projeção — escolher colunas (SELECT)

A projeção seleciona apenas algumas colunas. Em Prolog, basta incluir apenas as variáveis
que nos interessam na cabeça da regra e usar _ para ignorar as demais.

Regra: classico(T, G) — apenas título e gênero


 

Consultando:


 

🔍 Variável anônima _: Usamos _ para ignorar o ano e a duração.
O Prolog não unifica _ com nenhum valor específico — ele simplesmente “joga fora” a informação.

Em SQL: SELECT titulo, genero FROM filme WHERE ano <= 1985;

4. Consultas com seleção e projeção

Podemos combinar as regras para fazer perguntas mais específicas:

🎯 “Quais são os títulos dos filmes clássicos de comédia?”

 

🎯 “Quais filmes clássicos têm duração maior que 120 minutos?”

 

5. Negação por Falha — not / \+

A negação por falha é uma forma de dizer “não existe prova” para uma determinada meta.
Internamente, o Prolog tenta satisfazer a meta; se falha, not sucede.

Exemplo: filmes que não são clássicos (lançados após 1985)


 

Consultando:


 

O Prolog tenta provar A =< 1985; como falha (pois 2001 > 1985), not sucede.

⚠️ Limitação da negação por falha: Ela não é a negação lógica completa.
Ela só funciona quando a meta está totalmente instanciada. Se houver variáveis livres,
o comportamento pode ser inesperado. Por isso, sempre coloque a geração das variáveis antes do not.

6. Comparação com SQL

Veja como as operações relacionais se traduzem entre SQL e Prolog:

Operação SQL Prolog
Seleção (linhas) WHERE ano <= 1985 A =< 1985 na regra
Projeção (colunas) SELECT titulo, genero Cabeça da regra com T, G
Ignorar coluna (não selecionar) Usar _ no lugar
Negacao (não clássico) WHERE NOT (ano <= 1985) not (A =< 1985)

📝 Exercícios para praticar

  1. Seleção: Crie a regra comedia(T, A) que retorna título e ano dos filmes de comédia.
  2. Projeção: Crie a regra longo(T, G) que retorna título e gênero dos filmes com duração > 120 minutos.
  3. Combinação: Liste os títulos dos filmes de ficção lançados antes de 1980.
  4. Negacao: Crie a regra nao_classico(T) que retorna filmes que não são clássicos (ano > 1985).
  5. Desafio: Encontre os gêneros que não têm nenhum filme clássico (use not e findall/3 ou setof/3).
  6. Desafio 2: Crie uma regra filme_curto(T) que selecione filmes com duração < 120 e que não sejam de terror.

💡 Dica: Lembre-se de que a ordem das metas importa para o not.
Sempre instancie as variáveis antes de negar.

7. Conclusão: Prolog como extensão do modelo relacional

O Prolog implementa de forma elegante as operações fundamentais da álgebra relacional:

  • Seleção → condições em regras.
  • Projeção → escolha de variáveis na cabeça da regra.
  • Junção → variáveis compartilhadas entre predicados.
  • Negacao → not / \+.

Além disso, o Prolog vai além, permitindo recursão, geração de hipóteses
e raciocínio lógico que não são possíveis no SQL puro. É uma ferramenta poderosa para quem
quer explorar o lado lógico dos dados.

Relacionando Tabelas em Prolog

Por
filósofo

 

Consultas relacionais no estilo SQL, mas com a alma lógica

Assim como em SQL, frequentemente precisamos relacionar informações que estão em tabelas diferentes.
Em Prolog, fazemos isso de forma natural usando variáveis compartilhadas — que atuam como
“chaves estrangeiras”. Neste artigo, vamos construir um pequeno sistema de funcionários e dependentes,
e aprender a fazer joins, consultas com condições e até encontrar registros sem correspondência.

1. O problema: funcionários e dependentes

Imagine que temos duas tabelas em um banco de dados relacional:

  • Funcionários — com código, nome e salário.
  • Dependentes — com código do funcionário a quem estão vinculados e seu nome.

O campo código em funcionários é a chave primária; em dependentes,
é uma chave estrangeira que referencia o funcionário.

2. Modelando em Prolog

Em Prolog, cada “tabela” vira um conjunto de fatos com uma aridade fixa:


 

🔑 Chave de relacionamento: O campo Código é o elo entre as duas tabelas.
Em dep/2, o primeiro argumento é o código do funcionário, que deve existir em func/3.

3. O campo Código como chave relacional

Assim como em SQL, a integridade referencial é implícita: se um dependente tem código 2,
esperamos que exista func(2, ...). O Prolog não valida isso automaticamente, mas nossas
consultas vão explorar essa relação.

4. “Joins” com variáveis compartilhadas

Para fazer um join entre as duas tabelas, usamos a mesma variável no lugar
do código em ambas as chamadas. O Prolog unifica as ocorrências e encontra as combinações que satisfazem
todos os fatos.

Exemplo: “Quem são os dependentes do Ivo?”

Sabemos que Ivo tem código 2. Queremos os nomes dos dependentes associados a esse código.


 

Se não soubéssemos o código, poderíamos deixar o Prolog descobrir:

 

🔎 Leitura: “Encontre um código C tal que C seja funcionário
chamado Ivo, e depois encontre um dependente com esse mesmo C.”

Exemplo: “De quem o Ary é dependente?”

Agora partimos do dependente para o funcionário.


 

Na base, ary aparece como funcionário (código 4), mas não como dependente. A consulta retorna
false porque não há nenhum dependente chamado ary.

5. Consultas com condições adicionais

Podemos filtrar usando comparações numéricas, como em SQL com WHERE.

“Quem depende de funcionário com salário < 950?”

Funcionários com salário menor que 950: Eva (800).


 

Isso retorna o funcionário eva e seu dependente Nino.

6. Negação por falha: “Funcionários sem dependentes”

Em SQL, usaríamos LEFT JOIN ... WHERE dep.codigo IS NULL. Em Prolog, usamos
negação por falha com o predicado not (ou \+).


 

O Prolog tenta provar dep(C, _); se falha, a negação é bem-sucedida. O resultado mostra
que Lia (código 3) não tem dependentes.

⚠️ Cuidado com a instanciação! Para que not funcione corretamente,
a variável C deve estar instanciada no momento em que not
é chamado. Por isso, colocamos func(C, N, _) antes de not(dep(C, _)).
Se trocássemos a ordem, o Prolog poderia não encontrar soluções ou gerar erro.

8. Comparação com SQL

O mesmo “join” em SQL seria:


 

Em Prolog, a consulta equivalente é:


 

Abaixo, um resumo das principais correspondências:

SQL Prolog
FROM func JOIN dep ON func.codigo = dep.codigo func(C, ...), dep(C, ...)
WHERE salario > 1000 func(_, _, S), S > 1000
IS NULL (left join) not(dep(C, _))
SELECT nome Variável no lugar do campo (ex: N)

✅ O Prolog oferece uma maneira elegante e declarativa de relacionar dados, sem necessidade de sintaxe
especial para joins. Basta compartilhar variáveis e deixar o mecanismo de unificação fazer o trabalho
pesado. Combine isso com comparações e negação, e você terá todo o poder de um SGBD relacional —
com a flexibilidade da programação lógica.