©Silberschatz, Korth and Sudarshan (modificado)9.1.1Database System Concepts Capítulo 9: BDs Objecto-Relacional Relações imbricadas Tipos complexos e objectos Criação de valores complexos e de objectos Funções, procedimentos e métodos em SQL Comparação entre os vários modelos

©Silberschatz, Korth and Sudarshan (modificado)9.1.2Database System Concepts Modelo de Dados Objecto-Relacional Parte do modelo relacional, e generaliza-o introduzindo noções de objectos e formas de lidar com tipos complexos. Permite que os atributos tenham valores de tipos complexos, incluindo valores não atómicos. Aumenta a expressividade, sem perder as principais vantagens do modelo relacional (incluindo o acesso declarativo aos dados). É compatível com as linguagens relacionais existentes (o que torna este modelo bastante apelativo para sistemas de bases de dados comerciais).

©Silberschatz, Korth and Sudarshan (modificado)9.1.3Database System Concepts Tipos complexos no SQL:1999 As extensões do SQL para suportar tipos complexos incluem:  Colecções e objectos de grande dimensão  Relação imbricadas são um exemplo de colecções  Tipos estruturados  Tipos com atributos composto (registos)  Herança  Orientação por objectos  Incluindo identificadores de objectos e referências

©Silberschatz, Korth and Sudarshan (modificado)9.1.4Database System Concepts Objectos grandes n Tipos para objectos grandes X clob: Character large objects book-review clob(10KB) X blob: binary large objects image blob(10MB) movie blob (2GB) n Quer o ODBC quer o JDBC fornecem mecanismos para aceder a grandes objectos por partes pequenas de cada vez

©Silberschatz, Korth and Sudarshan (modificado)9.1.5Database System Concepts Tipo complexos em Oracle Tipo complexos em Oracle  create type autor as object ( nome varchar(10) ); /  create type conj_autores as table of autor; /  create type editorT as object (nome varchar(10), branch varchar(20)); /  create type livro as object ( titulo varchar(20), autores conj_autores, data_publ date, editor editorT); /  create table livros of livro nested table autores store as tabaut;

©Silberschatz, Korth and Sudarshan (modificado)9.1.6Database System Concepts Tipos complexos em Oracle  create type Empregado as object ( nome varchar(20), salario number, member function anual return number); /  create type body Empregado is member function anual return number is begin return salario*14; end; /  create table empregados of Empregado;

©Silberschatz, Korth and Sudarshan (modificado)9.1.7Database System Concepts Inserção de dados complexos em Oracle  insert into livros values ( ‘Database Systems Concepts’, conj_autores( autor(‘Silberschatz’), autor(‘Korth’), autor(‘Sudarshan’) ), null, editorT(‘McGraw Hill’,’New York’) );

©Silberschatz, Korth and Sudarshan (modificado)9.1.8Database System ConceptsHerança Considere a seguinte definição de tipo para pessoas: create type Pessoa as object (nome varchar(20), morada varchar(20)) not final; Pode-se usar herança para definir os tipos para estudante e professor create type Estudante under Pessoa (grau varchar(20), departamento varchar(20)); create type Docente under Pessoa (salário integer, departamento varchar(20)); Os subtipos podem redefinir os métodos usando (explicitamente) na definição do tipo overriding method em vez de method

©Silberschatz, Korth and Sudarshan (modificado)9.1.9Database System Concepts Tipos referência As linguagens de objectos permitem criar e referenciar objectos. No SQL:1999  Podem-se referenciar tuplos  Cada referência diz respeito a tuplo de uma tabela específica. I.e. cada referência deve limitar o escopo a uma única tabela

©Silberschatz, Korth and Sudarshan (modificado)9.1.10Database System Concepts Declaração de Referências em SQL:1999 E.g. definir o tipo Departamento com atributo nome e atributo presidente que é uma referência para o tipo Pessoa, tendo a tabela pessoas como escopo create type Departamento as object ( nome varchar(20), presidente ref Pessoa scope pessoas) A tabela departamentos pode ser criada como usual: create table departamentos of Departamento Em SQL:1999 pode-se omitir a declaração de scope na definição do tipo, passando-a para a criação da tabela, da seguinte forma: create table departamentos of Departamento (presidente with options scope pessoas)

©Silberschatz, Korth and Sudarshan (modificado)9.1.11Database System Concepts Inicialização de referências no Oracle Para criar um tuplo com uma referência, cria-se primeiro o tuplo com uma referência null, actualizando depois a referência com a função ref(p): E.g. para criar um departamento com nome DI e presidente Pedro: insert into departamentos values (`DI’, null) update departamentos set presidente = (select ref(p) from pessoas as p where nome=`Pedro’) where nome = `DI’

©Silberschatz, Korth and Sudarshan (modificado)9.1.12Database System Concepts Inicialização de referências no SQL:1999 O SQL:1999 não suporta a função ref(). Em vez disso exige a declaração de um atributo especial para guardar o identificador dum objecto O atributo com o identificador é declarado usando ref is na criação da tabela: create table pessoas of Pessoa ref is oid system generated  Aqui, oid é um nome dum atributo. Para obter a referência para um tuplo usa-se esse atributos. Por exemplo: select p.oid (em vez de select ref(p))

©Silberschatz, Korth and Sudarshan (modificado)9.1.13Database System Concepts Geração de identificadores O SQL:1999 permite que os identificadores sejam gerados pelo utilizador  O tipo do identificador tem que ser declarado como para qualquer outro atributo da tabela  E.g. create type Pessoa (nome varchar(20) morada varchar(20)) ref using varchar(20) create table pessoas of Pessoa ref is oid user generated Quando se cria um tuplo, tem que se dizer qual o valor do identificador (que é sempre dado como primeiro atributo): insert into pessoas values (‘ ’, ‘Pedro’, `Lisboa’)

©Silberschatz, Korth and Sudarshan (modificado)9.1.14Database System Concepts Geração de identificadores (Cont.) Pode depois usar-se o valor inserido como referência, ao inserir tuplos noutras tabelas  Evita pergunta para saber qual o identificador: E.g. insert into departamentos values(`DI’, ` ’) Também é possível usar uma chave primária como identificador. Para isso usa-se ref from, e declara-se a referência como sendo derived create type Pessoa (nome varchar(20) primary key, morada varchar(20)) ref from(nome) create table pessoas of Pessoa ref is oid derived

©Silberschatz, Korth and Sudarshan (modificado)9.1.15Database System Concepts Path Expressions Quais os nomes e moradas de todos os presidentes de departamentos? select presidente –> nome, presidente –> morada from departamentos Uma expressão como “presidente –> nome” chama-se uma path expression No Oracle usa-se: “DEREF(presidente).nome” O uso de referências e path expressions evita operações de junção  Se presidente não fosse uma referência, para obter a morada era necessário fazer a junção de departamentos com pessoas  Facilita bastante a formulação de perguntas

©Silberschatz, Korth and Sudarshan (modificado)9.1.16Database System Concepts Perguntas em tipos estruturados Quais os títulos e respectivos nomes da editora de todos os livros. select título, editor.nome from livros Note que editor é um atributo (e não uma tabela). Tal como para aceder a atributos de uma tabela, também se usa o ponto para aceder a atributos de atributos com tipos estruturados. No Oracle, a função value() devolve o objecto. Pode-se aceder assim a tipos estruturados: select título, value(L).editor.nome from livros L

©Silberschatz, Korth and Sudarshan (modificado)9.1.17Database System Concepts Perguntas a métodos locais Para aceder a métodos usa-se o ponto e o nome do método seguido dos argumentos entre parêntesis. Os parêntesis devem lá estar mesmo que não haja argumentos. Em Oracle um método é chamado com. (, ) Quando não há tipo directamente associado, pode usar-se o value: select nome, value(e).anual() from empregados e

©Silberschatz, Korth and Sudarshan (modificado)9.1.18Database System Concepts Perguntas a colecções Os atributos com colecções são usados de forma semelhante tabelas, utilizando agora a keyword unnest Quais os títulos dos livros que têm database entre as palavras chave? select título from livros where ‘database’ in (unnest(conj-keyword)) Obter todos os pares (título,autor) em que autor é autor do livro com título título select B.título, A.nome from livros as B, unnest (B.array-autores) as A Pode-se aceder a elementos dum array da forma habitual: select array-autores[1], array-autores[2], array-autores[3] from livros where título = `Database System Concepts’

©Silberschatz, Korth and Sudarshan (modificado)9.1.19Database System Concepts Perguntas a colecções no Oracle Em vez de unnest o Oracle usa a função table que devolve que converte um atributo numa tabela: Quais os títulos dos livros e respectivos autores? select L.título, A.nome from livros L, table(L.autores) A;

©Silberschatz, Korth and Sudarshan (modificado)9.1.20Database System ConceptsNesting Agora as tabelas podem conter atributos com relações. Faz pois sentido que o resultado de um select possa conter atributos com relações - Nesting Isto pode ser feito de maneira semelhante às agregações  para criar um conjunto, usa-se a função set() em vez da função de agregação Para, em livros-flat, agrupar num atributo o conjunto das keywords: select título, autor, Editor(nome-pub, pub_branch) as editor, set(keyword) as conj-keyword from livros-flat group by título, autor, editor Para agrupar também os vários autores dum livro: select título, set(autor) as autores, Editor(nome-pub, pub_branch) as editor, set(keyword) as conj-keyword from livros-flat group by título, editor

©Silberschatz, Korth and Sudarshan (modificado)9.1.21Database System Concepts Nesting (Cont.) Outra abordagem consiste em usar sub-perguntas na cláusula select: select título, ( select M.autor from livros-flat as M where M.título =O.título) as autores, Editor(nome-pub, pub-branch) as editor, (select N.keyword from livros-flat as N where N.título = O.título) as conj-keyword from livros-flat as O Pode usar-se order by em perguntas nested para obter colecções ordenadas  Podem-se criar arrays desta forma

©Silberschatz, Korth and Sudarshan (modificado)9.1.22Database System Concepts Funções e Procedimentos O SQL:1999 suporta funções e procedimentos  As funções e procedimentos podem ser escritas directamente em SQL, ou em linguagens de programação externas (e.g. PL/SQL).  Alguns sistemas de bases de dados (entre eles o Oracle) permitem definir funções que devolvem tabelas Grande parte dos sistemas de bases de dados têm linguagens proprietárias onde se podem definir funções e procedimentos, e que diferem bastante do standard SQL:1999 No Oracle podem-se criar funções e procedimentos através da linguagem PL/SQL, ou directamente na base de dados.

©Silberschatz, Korth and Sudarshan (modificado)9.1.23Database System Concepts Funções SQL Definir uma função que devolve (no conjunto de relações na 4NF para livros-flat) o número de autores de um dado livro: create function conta_autores(nome varchar(20)) returns integer begin declare a_count integer; select count(autor) into a_count from autores where autores.título=nome; return a_count; end Quais os livros que têm mais que um autor? select título from livros-flat where conta_autores(título)> 1

©Silberschatz, Korth and Sudarshan (modificado)9.1.24Database System Concepts Métodos SQL Os métodos podem ser vistos como funções associadas a tipos estruturados  Têm um primeiro parâmetro (implícito) chamado self que “aponta” para o valor do tipo estruturado para o qual o método é chamado  O código do método pode-se referir aos atributos do tipo estruturado usando a variável self  E.g. self.a

©Silberschatz, Korth and Sudarshan (modificado)9.1.25Database System Concepts Funções e procedimentos SQL A função conta_autores poderia também ser escrita como um procedimento: create procedure conta_autores_proc(in nome varchar(20), out a_count integer) begin select count(autor) into a_count from autores where autores.título=nome; end; Os procedimentos podem ser chamados dentro de outros procedimentos SQL, ou de linguagens SQL embedded ou proprietárias.  E.g. num procedimento SQL declare a_count integer; call conta_autores_proc (`Database systems Concepts’, a_count); O SQL:1999 permite que haja mais que uma função ou procedimento com o mesmo nome, desde que o número de argumentos (ou, pelo menos, os seus tipos) sejam diferentes

©Silberschatz, Korth and Sudarshan (modificado)9.1.26Database System Concepts Funções e procedimentos externos O SQL:1999 permita o uso de funções e procedimentos escritos noutras linguagens (e.g. C ou C++) A declaração de funções e procedimentos externos faz-se da seguinte forma: create procedure conta-autores-proc(in nome varchar(20), out count integer) language C external name’ /usr/aluno111/bin/conta-autores-proc’ create function conta-autores(nome varchar(20)) returns integer language C external name ‘/usr/aluno111/bin/conta-autores’

©Silberschatz, Korth and Sudarshan (modificado)9.1.27Database System Concepts Funções e procedimentos externos (Cont.) Vantagens:  Mais eficiente para muitas operações  Mais poder expressivo Desvantagens  A código que implementa as rotinas externas pode ter que ser carregado no sistema de bases de dados e executado no espaço de endereços deste  risco de corromper acidentalmente a estrutura da base de dados  risco de segurança dos dados  Há alternativas que garante segurança (à custa, por vezes, da deterioração da performance)  A execução directa no sistema de bases de dados só é feita se a eficiência for bem mais importante que a segurança

©Silberschatz, Korth and Sudarshan (modificado)9.1.28Database System Concepts Segurança para rotinas externas Para lidar com estes problemas de segurança  Usar técnicas de sandbox  i.e. usar linguagem segura como o Java, que não permite o acesso a outras parte do código da base de dados  Ou executar rotinas externas em processo separado, sem acesso à memória usada por outros processos do sistema de bases de dados  Os parâmetro e resultados são passados via comunicação entre processos Ambas as alternativas têm custos de performance

©Silberschatz, Korth and Sudarshan (modificado)9.1.29Database System Concepts Construtores procedimentais O SQL:1999 suporta uma grande variedade de construtores procedimentais  O Oracle suporta aqueles que existem no PL/SQL Expressões com whiles e repeats declare n integer default 0; while n < 10 do set n = n+1; end while; repeat set n = n – 1; until n = 0; end repeat Em Oracle, em vez de set var =… usa-se var :=…

©Silberschatz, Korth and Sudarshan (modificado)9.1.30Database System Concepts Construtores procedimentais (Cont.) Ciclos  Iterações sobre o resultado de perguntas  E.g. soma de todos os saldos da agência Perryridge declare n integer default 0; for r as select balance from account where branch-name = ‘Perryridge’ do set n = n + r.balance; end for

©Silberschatz, Korth and Sudarshan (modificado)9.1.31Database System Concepts Construtores procedimentais (cont.) Expressões condicionais (if-then-else) E.g. Soma dos saldos por categorias de contas (com saldo 5000) if r.balance < 1000 then set l = l + r.balance elseif r.balance =< 5000 then set m = m + r.balance else set h = h + r.balance end if Assinalar condições de excepção e erros, e declaração de tratamento de excepções declare out_of_stock condition; declare exit handler for out_of_stock ; begin ….. signal out-of-stock; end  Neste exemplo o tratamento da excepção é exit – sai do bloco begin…end No Oracle em vez de signal usa-se raise

©Silberschatz, Korth and Sudarshan (modificado)9.1.32Database System Concepts Comparação entre os vários sistemas Sistemas relacionais  Simplicidade no tipo de dados, linguagens declarativa para perguntas, boa segurança. Linguagens persistentes  Tipos de dados complexos, fácil integração com linguagens de programação, eficientes. Sistemas Objecto-relacional  Tipos de dados complexos, linguagens declarativa para perguntas, boa segurança. Nota: Os sistemas reais, esbatem um pouco estas fronteiras.  E.g. linguagens persistentes que funcionem como wrapper sobre uma base de dados relacional, embora permitam tipos de dados complexos e facilidade de integração com linguagens imperativas, nem sempre são muito eficientes…