Banco de Dados com Objetos

1. Banco de Dados com Objetos Jacques Robin CIn-UFPE

2. Banco de dados com objetos: diversidade dos modelos • Modelo puramente orientado a objetos (OO), ex., O2 • Modelo objeto-relacional (OR), ex., SQL3 • Modelo funcional orientado a objeto (FOO), ex, FQL • Modelo ativo orientado a objetos (AOO), ex., Chimera • Modelo dedutivo orientado a objetos (DOO), ex., F-Logic • Modelo com restrições e objetos (COO), ex., C3 • Modelo de componentes distribuídos orientado a objetos (DOOC), ex., CORBA objeto O2 FQL F-Logic C3 SLQ99 dados relacional SQL92 Datalog DISCO procedimental declarativo comportamentos imperativo funcional lógico por restrições

3. Orientação objetos para BD: motivação • Uniformidade: • codificar lógica da aplicação e o acesso aos dados no mesmo paradigma (impedance mismatch) • Completude computacional: • embutir no BD comportamentos ligados aos dados • Expressividade da modelagem: • estruturas complexas, recursivas e heterogêneas • Modularidade e reuso • hierarquia de classes com herança e encapsulamento permite prototipagem, personalização e extensão rápida • Integração em sistemas de componentes distribuídos • Novas aplicações de BD: • CAD/CAM, CASE, GIS, gerenciamento de workflows, groupware, bibliotecas digitais multimídia, comercio eletrónico, etc.

4. Orientação a objetos Identificação única Encapsulamento de estado e comportamento Construtores de estruturas complexas ortogonais e extensíveis Hierarquia de classes (esquema) com herança de estado e comportamento Estado inicial e comportamento default Sobrescrita, sobrecarga e ligação dinâmica Completude computacional Restrições, verificação e inferência de tipos Herança múltipla Acesso completo a recursos Gerenciamento de versões Banco de dados Persistência Otimização de acesso a memória segundaria Acesso concorrente Recuperação: terminação, exceções, transações Linguagem de manipulação: conciso, intuitivo, declarativo, interpretado, otimizável, independente da aplicação, formalmente bem fundamentado Visões e dados derivados Restrições de integridades Manipulação dinâmica de esquema Utilitários administrativos Serviços requeridos de um BDOO

5. Modelos puramente orientado a objetos • Extensões de LPOO para serviços de BD: • resolvem o “impedance mismatch” (com Java, C++, Smalltalk) • nenhum já fornece leque de serviços suficiente para constituir um autêntico SGBD (em geral apenas persistência e concorrência) • Implementações do padrão ODMG: • cobrem maioria dos serviços obrigatórios de BDOO • sintaxe: consultas SQL, definições SQL ( CORBA) • semântica: nada a ver com SQL, e de fato sem definição precisa • sem fundamentação nos princípios de engenharia de software • “padrão” comercial, ainda imaturo, e sem apoio dos gigantes • cada vez mais usadas para aplicações avançadas

6. Implementação de ODMG bastante completa e divulgada Tiposprimitivos: booleano, caráter, inteiro, real, string Tipos compostos:construtores ortgonais e recursivos de tupla, lista, bag e conjunto aplicados a tipos primitivos e/ou recursivamente classes definidas pelo usuário Consultas: via O2SQL Classes: definições de novos tipos compostos e assinaturas de métodos herança múltipla de tipos e métodos com sobrescrita, sobrecarga e ligação dinámica Métodos: implementações desligadas das suas assinaturas ou em O2C, subconjunto de C estendido para tipos do O2 ou em LPOO ligado (Java, C++, Smalltalk) via interface string Encapsulamento: por default métodos privados atributos acessíveis apenas via métodos de acesso get e set podem ser declarados públicos Objetos: id única persistente ou transitório persistência definida por alcançabilidade Características de O2

7. Esquema: 1. Uma pessoa tem um nome e uma data de nascimento. 2. Um departamento tem um nome e empregados, que podem ser professores, assistentes ou chefe. 3. Uma publicação tem um nome e um conjunto de autores. 4. Um empregado é uma pessoa que trabalha em um departamento por um salário. 5. Um professor é um empregado de meia idade, que produz publicações, ganha na media $50,000 por ano é tem algum diploma, geralmente um doutorado. 6. Professores e assistentes produzem publicações. 7. Alguém é considerado de meia idade entre 30 e 60 anos. 8. O chefe de um departamento tem que ser um professor. Dados: 1. Bob tem 40 anos e é o chefe do departamento de informática. 2. John e Sally são assistentes do departamento de informática. 3. Mary é mestre e professora no departamento de informática. 4. Mary publicou com seu chefe e com John e Sally um artigo sobre F-Logic no JACM. 5. Phil é um professor no departamento de informática e publicou com Bob e Mary, um artigo sobre Flora no CACM. Consultas: 1. Quem são os empregados do departamento de informática de meia idade que são seus próprio chefe? 2. Quem publicou com Mary no JACM? 3. Onde Mary publicou junto com Phil? Estudo de caso: o BD acadêmicoRequisitos em linguagem natural

8. BD acadêmico: modelo lógico ER

9. BD acadêmico: modelo físico ER

10. CREATE TABLE Pessoa ( Pessoa_CPF VARCHAR2(12) NOT NULL, Pessoa_Nome VARCHAR2(40) NULL, Pessoa_Nasc DATE NULL, PRIMARY KEY (Pessoa_CPF)); CREATE TABLE Depto ( Depto_CGC VARCHAR2(20) NOT NULL, Depto_Nome VARCHAR2(40) NULL, Chefe_CPF VARCHAR2(12) NULL, Chefe_Depto_CGC VARCHAR2(20) NOT NULL, PRIMARY KEY (Depto_CGC), FOREIGN KEY (Chefe_CPF, Chefe_Depto_CGC) REFERENCES Empreg(Pessoa_CPF, Depto_CGC)); CREATE TABLE Empreg_Publi ( Publi_Id VARCHAR2(20) NOT NULL, Depto_CGC VARCHAR2(20) NOT NULL, Pessoa_CPF VARCHAR2(12) NOT NULL, PRIMARY KEY (Publi_Id, Depto_CGC, Pessoa_CPF), FOREIGN KEY (Publi_Id) REFERENCES Publi, FOREIGN KEY (Depto_CGC, Pessoa_CPF) REFERENCES Empreg); CREATE TABLE Empreg ( Depto_CGC VARCHAR2(20) NOT NULL, Pessoa_CPF VARCHAR2(12) NOT NULL, Empreg_Salario NUMBER(5,2) NULL, Empreg_Cargo VARCHAR2(20) NULL CHECK (Empreg_Cargo IN ('Professor', 'Assistente')), Empreg_Titulação VARCHAR2(10) NULL, PRIMARY KEY (Depto_CGC, Pessoa_CPF), FOREIGN KEY (Pessoa_CPF) REFERENCES Pessoa ON DELETE CASCADE, FOREIGN KEY (Depto_CGC) REFERENCES Depto); CREATE TABLE Publi ( Publi_Id VARCHAR2(20) NOT NULL, Publi_Nome VARCHAR2(40) NULL, PRIMARY KEY (Publi_Id)); CREATE ASSERTION Restrição_Chefe CHECK (NOT EXISTS (SELECT * FROM Depto D, Empreg E, WHERE D.Chefe_CPF = E.Pessoa_CPF AND E.Cargo <> “Professor”)); BD acadêmico: esquema em SQL92

11. INSERT INTO Pessoa (Pessoa_CPF, Pessoa_Nome,Pessoa_Nasc) VALUES (“025440874-55”,”Bob”, 01021960); INSERT INTO Depto (Depto_CGC, Depto_Nome, Pessoa_CPF) VALUES (“001.002.33-44”,”DI”, “025440874-55”); INSERT INTO Empreg (Depto_CGC , Pessoa_CPF, Empreg_Cargo, Empreg_Titulação, Empreg_Salario) VALUES (“001.002.33-44”, “025440874-55”, “Professor”, “PhD”,5200); INSERT INTO Pessoa (Pessoa_CPF, Pessoa_Nome) VALUES (“020440994-50”, ”John”); INSERT INTO Empreg (Depto_CGC, Pessoa_CPF, Empreg_Cargo) VALUES (“001.002.33-44”, “020440994-50”, “Assist”); INSERT INTO Pessoa (Pessoa_CPF, Pessoa_Nome) VALUES (“040450964-10”, ”Sally”); INSERT INTO Empreg (Depto_CGC, Pessoa_CPF, Empreg_Cargo) VALUES (“001.002.33-44”, “040450964-10”, “Assist”); INSERT INTO Pessoa (Pessoa_CPF, Pessoa_Nome) VALUES (“020453924-11”, ”Mary”); INSERT INTO Empreg (Depto_CGC, Pessoa_CPF, Empreg_Cargo) VALUES (“001.002.33-44”, “020453924-11”, “Prof”, “Mestre”,5100); INSERT INTO Pessoa (Pessoa_CPF, Pessoa_Nome) VALUES (“044453424-41”, ”Phil”); INSERT INTO Empreg (Depto_CGC, Pessoa_CPF, Empreg_Cargo) VALUES (“001.002.33-44”, “044453424-41”, “Prof”, “Mestre”,5100); INSERT INTO Publi (Publi_Id, Publi_Nome) VALUES (“0001”, “Flora - CACM”); INSERT INTO Publi (Publi_Id, Publi_Nome) VALUES (“0002”, “F-Logic - JACM”); INSERT INTO Empreg_Publi (Depto_CGC, Pessoa_CPF, Publi_Id) VALUES (“001.002.33-44”, “025440874-55”, “0001”); INSERT INTO Empreg_Publi (Depto_CGC, Pessoa_CPF, Publi_Id) VALUES (“001.002.33-44”, “020440994-50”, “0001”); INSERT INTO Empreg_Publi (Depto_CGC, Pessoa_CPF, Publi_Id) VALUES (“001.002.33-44”, “044453424-41”, “0002”); INSERT INTO Empreg_Publi (Depto_CGC, Pessoa_CPF, Publi_Id) VALUES (“001.002.33-44”, “025440874-55”, “0002”); BD acadêmico: dados em SQL92

12. SELECT Depto. Pessoa_CPF, Empreg.Pessoa_CPF FROM Depto, Empreg GROUP BY Depto. Pessoa_CPF WHERE Depto.nome = “DI” AND Depto.Pessoa_Nasc < 01011970 AND Depto.Pessoa_Nasc > 01011950; SELECT Pessoa. Pessoa_Nome FROM Pessoa WHERE Pessoa. Pessoa_CPF = (SELECT Empreg_Publi. Depto_CGC, Empreg_Publi. Pessoa_CPF, Empreg_Publi. Publi_Id FROM Empreg_Publi WHERE Empreg_Publi. Pessoa_CPF = “020453924-11” AND Empreg_Publi. Pessoa_CPF = “0002”); SELECT Publi. Publi _Nome FROM Publi WHERE Publi. Publi _ID = (SELECT Empreg_Publi. Publi_Id FROM Empreg_Publi WHERE Empreg_Publi. Pessoa_CPF = “020453924-11” AND Empreg_Publi.Pessoa_CPF = “044453424-41”); BD acadêmico: consultas em SQL92

13. BD acadêmico: modelo UML Pessoa 1 chefia 1 Depto Publi Empreg n autor n n trabalha 1 Prof

14. Esquema: definição das classes class Pessoa tuple(nome: string, nasc: Date) method public idade: integer, meiaIdade: boolean end; class Empreg inherit Pessoa tuple(cargo: string, salario: real, titulação: string; depto: Depto, publi: set(Publi), method public setCargo(cargo: string) end; class Prof inherit Empreg method public setCargo(cargo: string), getCargo: string, getSalario: integer, getTitulacao: string, meiaIdade: string end; class Depto tuple(nome: string, chefe :Prof, empregs: set(Empreg)) method public addEmpreg(empreg: Empreg) end; class Publi tuple(nome: string, autores: set(Empreg)) end; BD acadêmico: esquema em O2

15. Esquema: definição dos métodos method body idade: integer in Pessoa { integer i; Date d; d = today(); i = d->year - self->nasc->year; if (d->month < self->nasc->month) || ((d->month == self->nasc->month) && (d->day < self->nasc->dat))) --i; return i;} method body meiaIdade: boolean in Pessoa { return (self->idade => 30 && self->idade <= 60);} method setCargo(cargo: string):boolean in Prof { if cargo == “prof” then {self->cargo = cargo; return 1;} else return 0;} method getCargo: string in Prof { if (self->cargo == null) then return “prof” else return self->cargo;} BD acadêmico: esquema em O2 method getSalario: integer in Prof { if (self->salario == null) then return 50,000 else return self->salario;}. method getTitulaçãp: string in Prof { if (self->titulacao == null) then return”PhD.” else return self->titulação;} method body MeiaIdade: boolean in Prof { return true}; method body addEmpreg(Empreg): boolean in Depto { if (Empreg->cargo == “prof”) || (Empreg->cargo == “assist”) then {self->empregados += set(Empreg); return true} else return false;}

16. Dados: conjuntos de objetos persistentes name Empregs: set(Empreg); name Publis: set(Publi); name DI: Depto Dados: criação de objetos por instanciação run body{ o2 Prof bob = new Prof; bob = tuple(nome: “Bob”, nasc: 01021960, cargo: “prof”, depto: DI); Empregs += set(bob); DI -> empregs += set(bob) DI -> chefe = bob; o2 Prof phil = new Prof; mary = tuple(nome: “Phil”, cargo: “prof”, depto: DI); Empregs += set(phil); DI -> empregs += set(phil) o2 Prof mary = new Prof; mary = tuple(nome: “Mary”, titulação: “mestre”; cargo: “prof”, depto: DI); Empregs += set(mary); DI -> empregs += set(mary) o2 Prof sally = new Empreg; mary = tuple(nome: “Sally”, cargo: “assist”, depto: DI); Empregs += set(sally); DI -> empregs += set(sally) BD acadêmico: dados em O2 o2 Prof john = new Empreg; mary = tuple(nome: “John”, cargo: “assist”, depto: DI); Empregs += set(john); DI -> empregs += set(john) o2 Publi jacm1 = new Publi; jacm1 = tuple(nome: “JACM”); jacm1->autores += set(phil); phil->publi += set(jacm1); jacm1->autores += set(bob); bob->publi += set(jacm1); jacm1->autores += set(mary); mary->publi += set(jacm1); o2 Publi cacm1 = new Publi; cacm1 = tuple(nome: “CACM”); cacm1->autores += set(mary); mary->publi += set(cacm1); cacm1->autores += set(bob); bob->publi += set(cacm1); cacm1->autores += set(sally); sally->publi += set(cacm1); cacm1->autores += set(john); sally->publi += set(cacm1);

17. select e.nome from e in Empregs where e.meiaIdade = 1 and e->Depto->chefe = e select e.nome from e in Empregs, f in Empregs, p in e->Publi, q in f->Publi where f = mary and p = q and p->nome = “JACM” select p.nome from p in Publis, e1 in p->autores, e2 in p->autores where e1 = mary and e2 = phil BD acadêmico: consultas em O2

18. Características de SQL99 • Extensão de SQL92 aprovada fim 1999 por ISO e ANSI: • Apesar de ainda chamar-se de SQL, • não é mais uma linguagem de consulta de SGBD relacional, mas • uma linguagem de programação de aplicações de BD integrando os modelos relacional, dedutivo, ativo e orientado a objetos • Objetivo: • Padronizar extensões proprietárias de SQL92 já implementadas nos SGBDR comerciais recentes (Oracle, IBM, Sybase, Informix) • Principais extensões: • Modelo objeto-relacional • Completude computacional • via integração no padrão de SLQ/PSM (Persistent Stored Modules) • uma linguagem de programação persistente inspirada de PASCAL • Regras ativas (gatilhos) e dedutivas (visões recursivas) • Operador SIMILAR TO de casamento string / expressão regular

19. Regras dedutivas recursivas em SQL99 • Regras dedutivas recursivas: • consultas recursivas via WITH RECURSIVE • visões recursivas via CREATE RECURSIVE VIEW • Exemplo: CREATE TABLE parent ( parent_CPF VARCHAR(20) NOT NULL, criança_CPF VARCHAR(20) NOT NULL, sexo_parent BOOLEAN, sexo_criança BOOLEAN); CREATE RECURSIVE view ancestral(Ancestral,Descendente) AS SELECT Parent Filho FROM parent UNION SELECT a.Ancestral, p.Filho FROM ancestral a, parent p WHERE a.Descendente = p.Parent; SELECT * FROM ancestral WITH RECURSIVE ancestral(Ancestral,Descendente) AS (SELECT Parent Filho FROM parent UNION SELECT a.Ancestral, p.Filho FROM ancestral a, parent p WHERE a.Descendente = p.Parent) SELECT * FROM ancestral

20. Regras ativas em SQL99 • Regras ativas: • Evento = modificação do BD (via UPDATE, INSERT, DELETE) • Condição = consulta (SELECT FROM WHERE) antes ou depois do evento • Ação = modificação do BD • via operação de manipulação de dados (UPDATE, INSERT, DELETE) • ou via chamada de procedimento ou função SQL/PSM • Exemplo: CREATE TRIGGER log_atualização_salario BEFORE UPDATE OF salario ON empregs REFERENCING OLD ROW as antigo NEW ROW as novo FOR EACH ROW INSERT INTO tabela_de_log VALUES (CURRENT_USER, antigo.salario, novo.salario)

21. Tiposprimitivos: os SQL92 + booleano Tipos compostos: conjuntos de atributos cada um de tipo primitivo ou recursivamente composto Classes: definições de novos tipos compostos e assinaturas de métodos Herança: simples com sobrescrita, sobrecarga e ligação dinámica classe instanciáveis ~ classes Java classes não instanciáveis ~ interface Java Métodos: implementações desligadas das suas assinaturas ou em SQL/PSM ou em LPOO ligado (ex, Java) via interface string (ex, JSQL) Encapsulamento: todos os atributos privados acessíveis apenas via métodos de acesso get e set fornecidas automaticamente pela declaração de um novo tipo composto todos os outros métodos são publicos Objetos: tabelas de novos tipo compostos id única criada automaticamente expressão de caminho com -> Orientação a objetos em SQL99

22. Esquema: definição das classes create type pessoa as (nome varchar(20), nasc date) instanciable not final ref pessoa_id instance method idade returns int instance method meiaIdade returns boolean; create type empreg under pessoa as (cargo varchar(20), salario real, titulação varchar(20), depto ref(depto), publi set(ref(publi)) instanciable not final ref empreg_id; create type prof under empreg as (cargo varchar(20) default professor, salario int default 50,000, titulação int default “PhD.”) instanciable not final ref prof_id instance method meiaIdade returns boolean; create type publi as (nome varchar(20), autores set(ref(empreg))) instanciable not final ref publi_id; create type depto as(nome varchar(20), chefe ref(prof), empregs set(ref(empreg))) instanciable not final ref depto_id; create table pessoas of pessoa create table empregs of empreg create table profs of prof create table deptos of depto create table publis of publi BD acadêmico: esquema em SQL99

23. Esquema: restrições de integridades create assertion restrição_chefe check (not exists (select * from deptos d, empregs e, where d.chefe->cargo <> “professor”)); create assertion restrição_prof check (not exists (select * from profs p where p.cargo <> “professor”)); BD acadêmico: esquema em SQL99 Esquema: definição dos métodos create method idade of pessoa ? begin declare i; declare date d; set d = today(); set i = d.year - self.nasc.year; if (d.month < self.nasc.month) || ((d.month = self.nasc.month) && (d.day < self.nasc.dat))) then return i - 1; else return i; endif; end; create method meiaIdade of pessoa return (self.idade => 30) && (self.idade <= 60);

24. insert into profs(nome,nasc) values(“Bob”, 01021960) ; insert into deptos (nome, chefe) values (”DI”, select ref from profs where nome = “Bob”); insert into profs(depto) values (select ref from deptos where nome = “DI”); insert into empregs(nome,depto,cargo) values (”John”, select ref from deptos where nome = “DI”,”assistente”); insert into empregs(nome,depto,cargo) values (”Sally”, select ref from deptos where nome = “DI”,”assistente”); insert into profs(nome,depto,cargo,titulação) values (“Mary”, select ref from deptos where nome = “DI”, ”assistente”, “mestre”); insert into profs(nome,depto,cargo,titulação) values (“Phil”, select ref from deptos where nome = “DI”, ”professor”); update depto set empregs = select ref from profs where nome = “Bob” union select ref from empregs where nome = “Mary” union select ref from profs where nome = “Phil” union select ref from profs where nome = “John” union select ref from profs where nome = “Sally” where nome = “DI”); insert into publis(nome,autores) values (“Florid - CACM”, select ref from empregs where nome = “Phil” union select ref from profs where nome = “Bob” union select ref from profs where nome = “Mary”); insert into publis(nome,autores) values (“F-Logic - JACM”, select ref from empregs where nome = “Mary” union select ref from profs where nome = “Bob” union select ref from profs where nome = “John” union select ref from profs where nome = “Sally”); BD acadêmico: dados em SQL99

25. select e.nome from empregs where e.meiaIdade = true and e = e.depto->chefe; select e.nome from empregs where “JACM” in e.publis->nome and “Mary” in e.publis->autores->nome; select p.nome from publis where “Mary” in p.autores->nome and “Phil” in p.autores->nome; BD acadêmico: consultas em SQL99

26. Aplicações: Integração de BD em sistemas maiores orientados a objetos BD espaciais e GIS BD espaço-temporais BD multimídia BD distribuídas heterogêneas BD de workflows BD para CAD/CAM e CASE BD OLTP clássica também, especialmente com SQL99 Limitações: Sem semântica formal definida Sem capacidade built-in para raciocínio Comportamentos implementados procedimentalmente Performance insuficiente para bases muito grandes (TB) Metodologia de projetos de BD Aplicações e limitações dos modelos OO e OR

27. Modelo OO x Modelo OR • Superficialmente muito convergente • ex, definição de classes em O2 e SQL99, consultas em O2SQL e SQL99, métodos em O2C e SQL/PSM • Fisicamente muito diferente, com conseqüências de performance ainda não clara • SGBDOR implementados (ex, Oracle8i) com várias vantagens sobre SGBDOO implementados (ex, O2): • escalabilidade de espaço e concorrência • (ex, BD da Nasqad: 30,000 acessos concorrentes a TB de dados) • declaratividade para criação e atualização de dados, restrições de integridades, comportamentos ativos e dedutivos (recursão, default) • sem ponteiros (segurança contra hackers) • facilidade para embrulhar BD relacionais de legado

28. BD dedutivo orientado a objetos: motivação • Serviços ortogonais e qualidades complementarias: • capacidade de inferência built-in (BDD +, BDOO -) • declaratividade (BDD +, BDOO -) • fundamentos formais (BDD +, BDOO -) • integração com BD relacionais (BDD+, BDOO -) • poder de modelagem (BDD -, BDOO +) • metodologia de projeto (BDD -, BDO ok) • extensibilidade (BDD -, BDO +) • integração em sistemas maiores (BDD -, BDO +) • divulgação e implementações comerciais (BDD -, BDO +)

29. BDDOO Serviços de um BD dedutivo orientado a objetos • Requisitos OO: • identidade de objetos • objetos complexos • classes • encapsulamento • herança • overriding, overloading • e ligação dinâmica • extensibilidade • Requisitos Raciocínio: • linguagem declarativa baseado na lógica • unificação de termos • com variáveis • mecanismo de dedução • fundamentos formais • Requisitos BD: • dados persistentes • gerenciamento de grandes conjuntos de dados • gerenciamento de memória secundária • gerenciamento de transações • linguagem de consulta declarativa

30. Tipologia e implementações dos modelos dedutivos orientados a objetos • Extensões de modelo dedutivo com facilidades OO • extensões de Datalog (ConceptBase, Logres, Logidata+, ROL) • extensões de Prolog (Quixote) • Extensões de modelo OO com regras dedutivas (?) • Extensões de SQL com objetos e regras dedutivas (ESQL2) • Acoplamento entre SGBDOO e SGBDD (Coral++, ROCK & ROLL, Chimera) • Construção de uma lógica formal orientada a objetos, seguida da sua implementação em um sistema (F-Logic, Florid, Flora e Orlog)

31. Fornecidos: Identificação única, inclusive funcionais Construtores de estruturas complexas ortogonais e extensíveis Hierarquia de classes (esquema) com herança múltipla de estado e comportamento Estado inicial e comportamento default Sobrescrita, sobrecarga e ligação dinâmica Restrições de tipos Parcialmente fornecidos: Completude computacional dependentemente da implementação Verificação e inferência de tipos indiretamente via regras de ordem superior Não fornecidos: Encapsulamento Acesso completo a recursos Gerenciamento de versões F-Logic: serviços de orientação a objetos

32. Serviços de dedução: Fundamentação em uma teoria da prova completa e correta Motor de inferência para regras dedutivas com: referências a objetos nas premissas e conclusões sintaxe de ordem superior semântica da 1a ordem unificação de descrições parciais de objetos Serviços de BD: Construtores de conjuntos com semântica de inclusão Operadores de agregação Consultas devolvem todas as respostas de uma vez Falta: Atualizações declarativas Persistência Gerenciamento de grandes conjuntos de dados Gerenciamento de memória secundária Gerenciamento de transações F-Logic: serviços de dedução e de BD

33. Esquema: titulacao(F,phd) :- trabalha(F,_,prof), not titulacao(F,ms). salario(P,50000) :- trabalha(F,_,prof), not salario(F,_). meiaIdade(F) :- idade(F,A), integer(A), A >= 30, A =< 60. meiaIdade(F) :- trabalha(F,_,prof). trabalha(B,D,prof) :- chefe(D,B), trabalha(E,D,prof). patrão(B,E) :- chefe(D,B), trabalha(E,D,_). Dados: idade(bob,40). trabalha(bob,di,prof). chefe(di,bob). trabalha(john,di,assist). trabalha(sally,di,assist). titulacao(mary,ms). trabalha(mary,di,prof). trabalha(phil,di,prof). publi(jacm,{john,sally,mary,bob}). publi(cacm,{phil,mary,bob}). BD acadêmico: em Relationlog Consultas: ? meiaIdade(<B>), trabalha(<B>,di,_), patrão(<B>,<B>). B = {bob}. ?- publi(jacm,<F,mary>), F \= mary. F = {bob}. ?- publi(P,<phil,mary>). P = {cacm}.

34. Esquema: hierarquia de classes empreg::pessoa. prof::empreg. assist::empreg. Esquema: assinatura de classes depto[nome => string; empregs =>> empreg; chefe => prof]. pessoa[nome => string; nasc => data; idade => int]. empreg[depto => depto; salario => int]. publi[nome => string, autores =>> {assist,prof}]. prof[publi =>> publi; titulação *-> PhD; salario -> 50000]. assist[publi =>> publi]. data[ano=>int; mes=>int; dia=>int]. Esquema: regras dedutivas D:data :- ... X:pessoa[idade -> I] :- ... meiaIdade(P) :- P:prof. meiaIdade(P) :- P.idade >= 30, P.idade <= 60. X:[jointPubli@Y->> P] :- X:{prof,assist}, Y:{prof,assist}, X[publi ->> P], Y[publi ->>P]. Dados bob:prof[nome -> “Bob”; nasc -> data[ano => 1960; mes => 01; dia => 02]; depto -> di, publi ->> {jacm,cacm}]. mary:prof[nome -> “mary”; titulacao -> mestre depto => di, publi ->> {jacm,cacm}]. phil:assist[nome -> “Phil”, depto => di, publi ->> {cacm}]. john:assist[nome -> “John”, depto => di, publi ->> {jacm}]. sally:assist[nome -> “Sally”, depto => di, publi ->> {jacm}]. jacm:publi[nome -> “JACM”; autores ->> {bob, mary, john, sally}]. cacm:publi[nome -> “CAC”, autores ->> {bob, mary, phil}]. BD acadêmico: esquema e dados em F-Logic

35. ?- meiaIdade(E), E:empreg[depto -> di[chefe -> E]]. E = bob. ?- mary[jointPubli@E ->> jacm]. E = bob E = john E = sally ?- mary[jointPubli@phil ->> P]. P = cacm BD acadêmico: consultas em F-Logic