A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

Banco de Dados com Regras: Ativos e Dedutivos Jacques Robin & Frederico Fernandes CIn-UFPE.

Apresentações semelhantes


Apresentação em tema: "Banco de Dados com Regras: Ativos e Dedutivos Jacques Robin & Frederico Fernandes CIn-UFPE."— Transcrição da apresentação:

1 Banco de Dados com Regras: Ativos e Dedutivos Jacques Robin & Frederico Fernandes CIn-UFPE

2 BD ativos: definição e motivação * Modelar declarativamente interação complexa entre comportamentos e dados em grande quantidades * Diminuir custo do controle dos dados (ex, restrições) * Idéia: mover classes de comportamentos ativos comuns a várias aplicações para o BD * BD ativo deve oferecer: um modelo de conhecimento (uma descrição do mecanismo) um modelo de execução (estratégias à nível de execução) * Regras: Eventos, Condição, Ação (ECA)

3 BD ativos: aplicações práticas * Extensão para sistemas de BD: Restrições de integridade, visões materializadas, dados derivados Ex: t on insert into wire t if insert.voltage > any (select max-voltage t from wire-type t where type = insert.type) t do * Implementação no BD de aplicações fechadas: Comportamento interno dos dados da aplicação Ex:

4 BD ativos: aplicações práticas Ex: t On update to value of Holder t if new.value = 0 t do begin t delete from Holder where reg# = update.reg#; t insert into VoidHolder t values (update.reg#, update.name, update.address, today) t end * Implementação no BD de aplicações abertas: Respostas para dispositivos ou software fora do BD Ex: t on update to pos of aircraft t if exists (select * from aircraft Other t where distance (Other.pos, new.pos) < 5000 and t distance (Other.pos, old.pos) > 5000) t do

5 BD ativos: exemplo didático de aplicação on delete to Holder if delete.value > 0 do instead HolderStock Owns Stock# name qty price qty value coutry name Reg# M N

6 BD ativos: dimensões para caracterizar modelos de conhecimento * Evento Fonte {operação estruturada, invocação do comportamento, transação, abstrato, exceção, relógio, externo} Granularidade {membro, subconjunto, conjunto} Tipo {primitivo, composto} Operadores {or, and, seq, closure, times, not} Modo de Consumo {recente, crônico, acumulativo, contínuo} Papel {obrigatório, opcional, nenhum} * Condição Papel {obrigatório, opcional, nenhum} Contexto {DB T, Bind E, DB E, DB C } * Ação Opções {operação estruturada, invocação do comportamento, regras de atualização, notificação de aborto, externo, do instead} Context {DB T, Bind E, DB E, DB C, DB A }

7 BD ativos: agendamento da execução das regras * on update to value of Holder if new.value = 0 do DB T DB E DB C DB A EventoCondiçãoAção Bind E Bind C

8 BD ativos: dimensões para caracterizar modelo de execução * Modo de condição {imediato, adiado, desligado} * Modo de ação {imediato, adiado, desligado} * Granularidade de Transição {tupla, conjunto} * Net-effect policy {sim, não} * Cycle policy {interativo, recursivo} * Prioridades {dinâmico, numérico, relativo, nenhum} * Agendamento {paralelo, sequencial, saturação, algum } * Manipulação do Erro {abortar, ignorar, backtrack, contingência} Ocorrência do Evento Regras Disparadas Regras Avaliadas Regras Selecionadas Fonte do Evento Execução

9 BD ativos: dimensões para caracterizar gerenciamento de regras * Descrição {linguagem de programação, linguagem de consulta, objetos} * Operações {ativar, desativar, sinalizar} * Adaptabilidade {tempo de compilação, tempo de execução} * Modelo de Dados {relacional, relacional extendido, dedutivo, orientado a objeto} * Suporte para programador {consulta, trace}

10 BD ativos: arquitetura Monitora a Condição Detector de Evento Agenda- mento Avaliador da Consulta HistóriaBD Base de Regras Conjunto de Conflito eventos detectados regras disparadas leitura escrita leitura/escrita notificação Avaliação de condição leitura escrita leitura ação execução

11 BD ativos: análise de regras para segurança de execução * Terminação Posso garantir que uma regra irá terminar ? Ex: R1-R3 não, mas R1-R2-R4 sim * Confluência A ordem de processamento de duas regras simultâneas interfere no resultado ? Ex: R2 R3 R1 on insert to Owns or update to reg# of Owns or update to reg# of Holder if do on insert to Owns or update to reg# of Owns or update to reg# of Holder if do R4

12 BD ativos: análise de regras para segurança de execução (Cont.) * Determinismo observável O efeito observável de uma regra por um usuário do sistema, é independente da ordem em que as regras são disparadas ? Ex: * Depuração de regras Dificuldade em visualizar terminação, confluência e determinismo observável em grandes bases de regras. Necessita ferramentas sofisticadas de análise de interação entre regras, especialmente temporal on if do on if do

13 Criação de Regras em Oracle ::= CREATE TRIGGER { BEFORE | AFTER } ON [[ REFERENCING ] FOR EACH ROW [ WHEN ( ) ]] ::= INSERT | DELETE | UPDATE [ OF ] ::= OLD AS NEW AS

14 Exemplo de Regra em Oracle CREATE TRIGGER FazPedido AFTER UPDATE OF NumItens ON Estoque WHEN (New.NumItens < New.ValorMinimo) FOR EACH ROW DECLARE NUMBER X BEGIN SELECT COUNT (*) INTO X FROM PedidosPendentes WHERE ItemPedido = New.ItemPedido; IF X = 0 THEN INSERT INTO PedidosPendentes VALUES (New.ItemPedido, New.QuantidadePedida, SYSDATE) END IF; END;

15 Exemplo de Regra em Oracle (Cont.) T 1 : UPDATE Estoque SET NumItens = NumItens – 70 WHERE Item = QuantidadePedidaValorMinimoNumItens#Item Tabela1: Estoque DataQuant.#Item Tabela2: PedidosPendentes, antes de T 1 Tabela3: PedidosPendentes, antes de T 2 24/04/ DataQuant.#Item T 2 : UPDATE Estoque SET NumItens = NumItens – 60 WHERE Item >= 1 FazPedido 24/04/ DataQuant.#Item Tabela2: PedidosPendentes, após T 1 Tabela3: PedidosPendentes, após T 2 24/04/ DataQuant.#Item FazPedido

16 Origens dos BD dedutivos: programação em lógica * Metáfora da programação em lógica: Teoria lógica (TL) = especificação formal = programa executável = Base de conhecimento (BC) de agente inteligente = BD dedutivo Unifica: teoria da computação, engenharia de software, BD e IA * Axiomas da TL = fatos iniciais da BC = dados explícitos de um BD tradicional = parte extensional do BDD * Regras da TL = regras da BC = parte intencional do BDD * Teoremas da TL, deduzidos pela aplicações da regras sobre os axiomas (e teoremas) = fatos derivados da BC = dados implícitos do BDD * Programar = especificar = declarar axiomas e regras * Executar programa = provar teorema = disparar motor de inferência do agente sobre sua BC = consultar BDD

17 BD dedutivos: definição de Prolog * Prolog: Linguagem de programação de propósito geral (turing-complete) Primeira, mais simples e ainda mais usada do paradigma lógico * Programa Prolog: conjunto implicitamente conjuntivo de cláusulas de Horn, i.e., formulas da lógica da 1a ordem da forma: * Muitas mas nem todas das formulas da 1a ordem tem conjunto equivalente de cláusulas de Horn, cex: * Lógica de Horn: * Interpretador/Compilador Prolog: provador de teorema para lógica de Horn com hipótese do mundo fechado e negação por falha

18 BD dedutivos: unificação de termos Prolog * Substituição de variáveis de um termo (ou formula) f: conjunto de pares Var/termo * Unificação de 2 termos f e g: substituição S das variáveis de f e g tal que S(f)=S(g) 2 resultados: t S t r=S(f)=S(g) * Exemplos: ?- prof(X,disc(Y,dept(di,ufpe))) = prof(geber,disc(ia,Z)). X = geber, Y = ia, Z = dept(di,ufpe). ? prof(X,disc(X,dept(di,ufpe))) = prof(geber,disc(ia,Z)) fail * Unificador mais geral: com menor número de variáveis instanciadas * Substituição mínima: com menor número de pares Var/const

19 BD dedutivos: consulta West é criminoso? da lógica da 1a ordem para Prolog * Em L1: P,W,N american(P) weapon(W) nation(N) hostile(N) sells(P,N,W) criminal(P) 2. W owns(nono,W) missile(W) 3. W owns(nono,W) missile(W) sells(west,nono,W) 7. X missile(W) weapon(W) 8. X enemy(N,america) hostile(N) 4. american(west) 5. nation(nono) 6. enemy(nono,america) 9. nation(america) * Em Prolog: criminal(P) :- american(P), weapon(W), nation(N), hostile(N), sells(P,N,W). owns(nono,m1). missile(m1). sells(west,nono,W) :- owns(nono,W), missile(W). weapon(W) :- missile(W). hostile(N) :- enemy(N,america). american(west). nation(nono). enemy(nono,america). nation(america).

20 BD dedutivos: consulta West é criminoso? processada por Prolog criminal(P) :- american(P), weapon(W), nation(N), hostile(N), sells(P,N,W). owns(nono,m1). missile(m1). sells(west,nono,W) :- owns(nono,W), missile(W). weapon(W) :- missile(W). hostile(N) :- enemy(N,america). american(west). nation(america). enemy(nono,america). nation(nono). criminal(west)? <- yes. american(west)? -> yes. weapon(W)? <- W = m1. t missile(W)? -> W = m1. nation(N)? -> N = america. hostile(america)? <- no. t enemy(america,america)? -> no. backtrack: nation(N), N \ {america}? -> N = nono. hostile(nono)? <- yes. t enemy(nono,america)? -> yes. sells(west,nono,m1)? <- yes. t owns(nono,m1)? -> yes. t missile(nono,m1)? -> yes.

21 BD dedutivos: controle e busca de Prolog * Aplica regra de resolução: tupla por tupla com estratégia linear (sempre tenta unificar ultimo fato a provar com a conclusão de uma cláusula do programa), na ordem de escritura das cláusulas no programa, com encadeamento de regras para trás, busca em profundidade e da esquerda para direita das premissas das cláusulas, e com backtracking sistemático e linear quando a unificação falha, e sem occur-check na unificação.

22 Limitações de Prolog como SGDB dedutivo * Sem semântica declarativa para: negação por falha atualizações do BD manipulação de conjuntos consulta do esquema do BD resultado depende da ordem das cláusulas e das premissas * Não fornece built-in a maioria dos serviços de BD: persistência concorrência transações operadores de agregação * Pode entrar em loop infinita com algumas regras recursivas * Devolve respostas a consulta: uma por uma BD devolvem todas de uma vez * Conseqüêntemente: inadequado para otimização de consultas especialmente as envolvendo quantidade de dados que não cabe inteiramente na RAM

23 Datalog * Sub-linguagem de Prolog usado como modelo de dados padrão em BD dedutivos * Mais expressivo do que cálculo relacional mas menos expressivo do que cálculo do predicados da 1a ordem * Exclui maioria dos predicados built-in de Prolog com semântica declarativa fora da lógica da 1a ordem * Datalog básico adicionalmente exclui termos aninhados ex, person(name(FirstName,LastName),weight(Value,Unit)) * Datalog é apenas uma notação independente de qualquer estratégia de resolução * SGBD Datalog usam variedade de tais estratégias

24 Datalog x SQL: características * Predicado de base Datalog = tabela ou relação SQL * Predicado derivado Datalog = visão SQL * Fato Datalog = linha ou tuple SQL * Argumento de predicado Datalog = coluna ou atributo SQL * Regras Datalog permitem definições recursivas de visões * Interpretadores e compiladores Datalog diferem de Prolog por tentar: garantir independência dos resultados das consultas da ordem das cláusulas e premissas do BD Datalog garantir terminação de qualquer consulta sintaticamente correta

25 Datalog x SQL: exemplo firstreq(Name) :- student(Name,Major,junior), took(Name,cs101,Grade1), took(name,cs143,Grade2). ?- firstreq(Name). SELECT t.Name FROM took t, took u, student s WHERE t.Course = cs101 AND u.Coruse = `cs143 AND t.Name = u.Name AND s.Year = junior AND s.Name = t.Name

26 Semântica de Datalog baseada em modelos Universo de Herbrand: U(D) = const(D) U {f(..., c,...) | f func(D) c const(D)}. Base de Herbrand: B(D) = U(D) U {p(…, g, …) | p pred(D) g B(D)}. Modelo de Herbrand: M(D) = {g B(D) | D |= g}. Exemplo: D = {male(paulo). female(ana). male(joao). parent(paulo,joao). parent(ana,joao). father(F,C) :- parent(F,C), male(F). mother(M,C) :- parent(F,C), female(M).} U(D) = {paulo,ana,joao} B(D) = {male(paulo). male(ana). male(joao). female(paulo). female(ana). female(joao). father(paulo,ana). father(paulo,joao). father(ana,joao). father(ana,paulo). father(joao,paulo).father(joao,ana). mother(paulo,ana). mother(paulo,joao). mother(ana,joao). mother(ana,paulo). mother(joao,paulo).mother(joao,ana). parent(paulo,ana). parent(paulo,joao). parent(ana,joao). parent(ana,paulo). parent(joao,paulo).parent(joao,ana).} M(D) = {male(paulo). female(ana). male(joao). parent(paulo,joao). parent(ana,joao). father(paulo,joao). mother(ana,joao).}

27 Semântica de Datalog baseada em operador de ponto fixo * ground(D) = {regras de D instanciadas com elementos de U(D)}. * Operador de conseqüências imediatas: To(D) = B(D). Tn(D) = Tn-1(D) U {c B(D) | r: c :- p1,...pN ground(D) p1,...,pN Tn-1(D)}. * Exemplo: D = {anc(X,Y) :- parent(X,Y)., anc(X,Z) :- anc(X,Y), parent(Y,Z)., parent(X,Y) :- father(X,Y)., parent(X,Y) :- mother(X,Y)., mother(anne,silvia)., mother(anne,marc).} T1(D) = {anc(marc,silvia).,anc(anne,silvia)., mother(anne,silvia)., mother(anne,marc)., mother(anne,silvia).}

28 Limitações de DataLog básico como linguagem de consulta em BD * Negação por falha * Valores complexos: estruturas e conjuntos * Consulta ao esquema * Atualizações * Transações * Prolog: fornece predicados built-in para todas essas funcionalidades, exceto transações porém sem semântica declarativa lógica sem segurança sobre terminação e corretude das consultas * Desafios de BDD: definir e implementar extensões de DataLog básico fornecendo esses serviços com uma semântica declarativa

29 Prolog: problema da negação por falha * Permite raciocínio não monótono: ave(piupiu). papa_leguas(bipbip). ave(X) :- papa_leguas(X). voa1(X) :- ave(X), not papa_leguas(X). voa1(X)? -> X = piupiu ; no. * Sem semântica declarativa em L1 * Depende da ordem, ex: voa2(X) :- not papa_leguas(X), ave(X). voa2(X)? -> no. * Pode tornas resolução de Prolog inconsistente ex: edge(a,b). sink(X) :- not edge(X,Y). sink(a)? -> no. sink(b)? -> yes. sink(X)? -> no.

30 Grafo de dependência e estratificação partCost(topTube,cinelli,20.00,14). partCost(topTube,columbus,15.00,6).... assembly(bike,frame,1). assembly(bike,wheel,2).... basicSubparts(Bsp,Bsp) :- partCost(Bsp,_,_,_). basicSubparts(Part,Bsp) :- assembly(Part,Sp,_), basicSubparts(Sp,Bsp). fastest(Part,Time) :- partCost(Part,Sup,Cost,Time), not faster(Part,Time). faster(Part,Time) :- partCost(Part,Sup,Cost,Time), partCost(Part,Sup1,Cost1,Time1), Time1 < Time. time4basic(AssPart,BasicSub,Time) :- basicSubparts(AssPart,BasicSub), fastest(BasicSub,Time). howsoon(AssPart,Time) :- time4basic(AssPart,BasicSub,Time), not larger(AssPart,Time). larger(Part,Time) :- time4basic(Part,_,Time), time4basic(Part,_,Time1), Time1 > Time. howsoon larger time4basic fastestbasicSubpart faster assemblypartCost not Strata 3 Strata 2 Strata 1

31 HiLog * Extensão sintática de Prolog e Datalog permitindo variáveis em posição de predicados: internamente traduzido por expressão da 1a ordem e assim a semântica de HiLog permanece na lógica da 1a ordem. Útil para aplicações requerendo meta-programação, como consulta de esquema de BDD * Exemplos de expressões HiLog e suas traduções em termos da 1a ordem: X(Y, Z, Y(W)) traduzido para apply(X,Y,Z,apply(Y,W)) h(map(P)(A,B))(C) traduzido para apply(apply(h,apply(map(P),A,B)),C)

32 Limitação principal de HiLog: relações de aridade fixa, com elementos ordenados e acessíveis apenas por posição Consultar esquema de BDD com HiLog * hardware(joe,30,2200). * software(paulo,26,2200). * admin(magaly,29,1500). *... * p1(R) :- R(_,_,_). * ?- p1(R). * R = {hardware,software,admin} * ?- p2(R). * R = hardware * ?- p3(N). * N = {joe,paulo,magaly,...}

33 BD dedutivos: consultas declarativas para conjuntos * Datalog básico sem tuplas aninhadas, nem conjuntos * Prolog tem: funtores, ex, computador(dono(nome(Fernandes, Frederico))) predicado setof(X,Condição(X),ListaResultado) para conjuntos como listas, sem semântica declarativa na lógica da 1a ordem * RelationLog: extensão de Datalog com definição e acesso a tuplas aninhadas definição de conjuntos: t em extensão (semântica de igualdade via enumeração) t parcialmente (semântica de inclusão) agrupamento de elementos de conjuntos, mesmo em regras diferentes e recursivas semântica declarativa na lógica da 1a ordem

34 RelationLog: tuplas aninhadas e conjuntos enumerados * Operadores: [] para tuplas aninhadas, {} para definição em extensão de conjuntos <> para agrupamento em conjuntos especificado apenas por inclusão * Exemplo: dept_employees(cpsc,{[bob,{db,ai}], [joe,{os,pl,db}]}) dept_employees(math,{[sam,{gt,cm,si}], [tom,{ca}]}) ? - dept_employee(cpsc, ]>) Resposta:X = {bob, joe} ? - dept_employee(_, ]>) Resposta: yes Representação: Consulta: DeptEmployee NameAreas cpscbobdb ai joeos pl db mathsamgt cm si tomca

35 RelationLog: conjuntos com recursão BDD RelationalLog sobre família BDD RelationalLog sobre família: fatherof(bob,tom) motherof(bob,pam) fatherof(pam,john) motherof(john,becky) parentsof(X, ) :- fatherof(X,Y). parentsof(X, ) :- motherof(X,Y). ancestorof(X, ) :- parentsof(X, ) ancestorof(X, ) :- parentsof(X, ), ancestorsof(Z, ) Consultas: ? - parentsof(bob,P). P = {pam, tom}. ? - ancestorsof(bob,A). A = {becky, john, tom, pam} RelationLog e predecessores (LDL, COL, Hilog) não funcionam com valores nulos.

36 BD dedutivos: atualizações declarativas * Transaction Logic: atualizações e transações em linguagem dedutiva com semântica formal declarativa bem definida * operadores del:, ins: e conjunção serializada ? - del : employee(joe,toy,10K), ins : employee(joe,shoe,10K) ? - del : employee(joe,toy,Sal) ins : employee(joe,shoe,Sal) hire(Name, Dept, Sal) :- ins : employee(Name, Dept, Sal) avg_sal(Dept, Avg) Avg <= 50K.

37 Integração BDA / BDD: Questões * Como suportar eventos em um processamento de regras dedutivas ? * Como suportar transição de estado em um processamento de regras dedutiva ? * Como suportar interação com o gerenciamento de transação em um processamento de regra dedutiva ? * Como suportar uma visão baseada em lógica de um BD com processamento de regra ativa ?

38 Integração BDA / BDD: abordagens * Estender BDA com dedução * Estender BDD com ações * Problema: semântica formal e segurança das ações * loose-coupling usando histórias de eventos Eventos declarados com regras dedutivas. A detecção do evento tem uma semântica lógica; Estados do BD guardados em relação ao tempo. Em cima deles podem ser escritas regras dedutivas; Os eventos causado pela execução do componente ação em uma regra ativa precisa apenas ser adicionada no fim;


Carregar ppt "Banco de Dados com Regras: Ativos e Dedutivos Jacques Robin & Frederico Fernandes CIn-UFPE."

Apresentações semelhantes


Anúncios Google