Banco de Dados com ObjetosBanco de Dados com Objetos

Jacques RobinCIn-UFPE

Banco de dados com objetos: Banco de dados com objetos: diversidade dos modelosdiversidade 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

imperativo

procedimental

funcional lógico por restrições

declarativo

relacional

objeto C3F-Logic

SQL92

FQL

Datalog

SLQ99

O2

DISCO

dados

comportamentos

Orientação objetos para BD: motivaçãoOrientaçã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.

Serviços requeridos de um BDOOServiços requeridos de um BDOOOrientaçã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

Modelos puramente orientado a objetosModelos 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

Características de OCaracterísticas de O22

Implementação de ODMG bastante completa e divulgada

Tipos primitivos: 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

Estudo de caso: Estudo de caso: o BD acadêmicoo BD acadêmicoRequisitos em linguagem naturalRequisitos em linguagem natural

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?

BD acadêmico: modelo lógico ERBD acadêmico: modelo lógico ER

BD acadêmico: modelo físico ERBD acadêmico: modelo físico ER

BD acadêmico: esquema em SQL92BD acadêmico: esquema em SQL92CREATE 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: dados em SQL92BD acadêmico: dados em SQL92

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: consultas em SQL92BD acadêmico: consultas em SQL92

SELECT Depto. Pessoa_CPF, Empreg.Pessoa_CPFFROM Depto, EmpregGROUP BY Depto. Pessoa_CPFWHERE Depto.nome = “DI” AND Depto.Pessoa_Nasc < 01011970 AND Depto.Pessoa_Nasc > 01011950;

SELECT Pessoa. Pessoa_NomeFROM PessoaWHERE 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 _NomeFROM 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: modelo UMLBD acadêmico: modelo UML

Pessoa

Empreg DeptoPublitrabalhan 1

chefia1 1

Prof

autorn n

BD acadêmico: esquema em O2BD acadêmico: esquema em O2Esquema: definição das classesclass Pessoa tuple(nome: string, nasc: Date) method public idade: integer, meiaIdade:

booleanend;

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:

stringend;

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 OBD acadêmico: esquema em O22

Esquema: definição dos métodosmethod 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;}

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;}

BD acadêmico: dados em OBD acadêmico: dados em O22

Dados: conjuntos de objetos persistentesname Empregs: set(Empreg); name Publis: set(Publi); name DI: DeptoDados: criação de objetos por instanciaçãorun 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)

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);

BD acadêmico: consultas em OBD acadêmico: consultas em O22

select e.nome from e in Empregswhere e.meiaIdade = 1 and e->Depto->chefe = e

select e.nomefrom e in Empregs, f in Empregs, p in e->Publi, q in f->Publiwhere f = mary and p = q and p->nome = “JACM”

select p.nomefrom p in Publis, e1 in p->autores, e2 in p->autoreswhere e1 = mary and e2 = phil

Características de SQL99Caracterí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

Regras dedutivas recursivas em SQL99Regras 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

Regras ativas em SQL99Regras 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)

Orientação a objetos em SQL99Orientação a objetos em SQL99 Tipos primitivos:

• 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 ->

BD acadêmico: esquema em SQL99BD acadêmico: esquema em SQL99Esquema: definição das classescreate 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 pessoacreate table empregs of empregcreate table profs of profcreate table deptos of deptocreate table publis of publi

BD acadêmico: esquema em SQL99BD acadêmico: esquema em SQL99

Esquema: restrições de integridadescreate 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”));

Esquema: definição dos métodoscreate 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);

BD acadêmico: dados em SQL99BD acadêmico: dados em SQL99insert 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: consultas em SQL99BD acadêmico: consultas em SQL99

select e.nome from empregswhere e.meiaIdade = true and e = e.depto->chefe;

select e.nome from empregswhere “JACM” in e.publis->nome and “Mary” in e.publis->autores-

>nome;

select p.nome from publiswhere “Mary” in p.autores->nome and “Phil” in p.autores->nome;

Aplicações e limitações Aplicações e limitações dos modelos OO e ORdos modelos OO e OR

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

Modelo OO x Modelo ORModelo 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

BD dedutivo orientado a objetos: BD dedutivo orientado a objetos: motivaçãomotivaçã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 +)

Serviços de um BD Serviços de um BD dedutivo orientado a objetosdedutivo 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

BDDOOBDDOO

Tipologia e implementações dos modelos Tipologia e implementações dos modelos dedutivos orientados a objetosdedutivos 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)

F-Logic: serviços de orientação a objetosF-Logic: serviços de orientação a objetos

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 dedução e de BDF-Logic: serviços de dedução e de BD

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 objetosServiç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

BD acadêmico: em RelationlogBD acadêmico: em Relationlog

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}).

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}.

BD acadêmico: esquema e dados em F-BD acadêmico: esquema e dados em F-LogicLogic

Esquema: hierarquia de classesempreg::pessoa. prof::empreg. assist::empreg.Esquema: assinatura de classesdepto[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 dedutivasD: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].

Dadosbob: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: consultas em F-LogicBD acadêmico: consultas em F-Logic

?- meiaIdade(E), E:empreg[depto -> di[chefe -> E]].E = bob.?- mary[jointPubli@E ->> jacm].E = bobE = johnE = sally?- mary[jointPubli@phil ->> P].P = cacm