Hibernate: Consultas. Clodis Boscarioli

(1)

Hibernate: Consultas

(2)

Consultas - Introdução

_{Envolve alguns passos:}

_{Criar a consulta com as restrições necessárias;} _{Adicionar parâmetros à consulta;}

Executar a consulta e recuperar o resultado

_{A forma de execução da consulta e obtenção dos dados pode} ser configurada.

(3)

Consultas - Introdução

_{As consultas usando Hibernate podem ser feitas}

de três formas:

SQL Nativo (SQLQuery);

HQL (Hibernate Query Language) (Query);

(4)

Consultas - Introdução

Query query = session.createQuery("from User");

Criteria criteria = session.createCriteria(User.class);

_{Objetos Query e Criteria são obtidos através do}

Session

_{org.hibernate.Query} org.hibernate.Criteria

(5)

SQL Nativo

_{O Hibernate permite especificar SQL escrito}

manualmente:

_{Utilização da Interface SQLQuery;}

_{A partir do objeto Session:}

(6)

SQL Nativo – Consultas Escalares

//... Consultas Escalares (*)

Session session = sf.openSession();

SQLQuery sqlQuery = session.createSQLQuery(

"SELECT * FROM ANOTACOES.DEPARTAMENTO"); List resultado = sqlQuery.list();

for (int i = 0; i < resultado.size(); i++){ //Retorna cada linha da tabela

Object[] linha = (Object[]) resultado.get(i); System.out.print("ID = " + linha[0] + “ --> ”); System.out.println("NOME = " + linha[1] + “\n"); }

(7)

SQL Nativo – Consultas Escalares

Hibernate: SELECT * FROM DEPARTAMENTO

ID = 210 --> NOME = DEPARTAMENTO DE ENG. COMPUTACAO ID = 270 --> NOME = DEPARTAMENTO DE HISTORIA

ID = 300 --> NOME = DEPARTAMENTO DE MATEMATICA ID = 310 --> NOME = DEPARTAMENTO DIREITO

(8)

SQL Nativo – Consultas Escalares

//... Consultas Escalares (ESPECIFICANDO COLUNAS) Session session = sf.openSession();

"SELECT ID_DEPARTAMENTO, NOME FROM DEPARTAMENTO"); List resultado = sqlQuery.list();

for (int i = 0; i < resultado.size(); i++){ //Retorna cada linha da tabela

Object[] linha = (Object[]) resultado.get(i); System.out.print("ID = " + linha[0] + “ --> ”); System.out.println("NOME = " + linha[1] + “\n"); }

(9)

SQL Nativo – Consultas Escalares

Hibernate: SELECT ID_DEPARTAMENTO, NOME FROM DEPARTAMENTO

ID = 210 --> NOME = DEPARTAMENTO DE ENG. COMPUTACAO ID = 270 --> NOME = DEPARTAMENTO DE HISTORIA

ID = 300 --> NOME = DEPARTAMENTO DE MATEMATICA ID = 310 --> NOME = DEPARTAMENTO DIREITO

(10)

SQL Nativo – Entity Queries

//... Entity Queries – Especificando o Tipo de Retorno Session session = sf.openSession();

"SELECT * FROM DEPARTAMENTO WHERE ID_DEPARTAMENTO = ?"); sqlQuery.setInteger(0, 210); //Especificando parâmetros...

sqlQuery.addEntity(Departamento.class); //Especifica tipo do retorno

Departamento departamento = (Departamento) sqlQuery.uniqueResult(); //Retorna um resultado

session.close(); //...

(11)

SQL Nativo – Entity Queries

//... Entity Queries

SQLQuery sqlQuery = session.createSQLQuery( "SELECT * FROM DEPARTAMENTO");

sqlQuery.addEntity(Departamento.class); //Retorna todos os itens em uma coleção

Collection<Departamento> resultado = sqlQuery.list(); session.close();

(12)

SQL Nativo – Join’s

//... Entity Queries com Join

"SELECT * FROM DEPARTAMENTO D, CENTRO C WHERE D.ID_CENTRO = C.ID_CENTRO");

sqlQuery.addEntity("departamento", Departamento.class); sqlQuery.addJoin("centro", "departamento.centro");

List resultado = sqlQuery.list(); //...

(13)

SQL Nativo – Join’s

//... Entity Queries com Join

ArrayList<Departamento> departamentos = new ArrayList<Departamento>(); for (int i = 0; i < resultado.size(); i++) {

Object[] lista = (Object[]) resultado.get(i);

Departamento departamento = (Departamento) lista[0]; departamento.setCentro((Centro) lista[1]);

departamentos.add(departamento); }

session.close(); //...

(14)

HQL - Hibernate Query Language

_{O Hibernate possui uma linguagem própria para}

recuperação dos objetos armazenados no banco de dados, a HQL;

_{HQL não segue nenhuma especificação, mas acabou}

tornando-se referência na definição do padrão EJB3-QL, uma linguagem de objetos baseada na especificação

Enterprise JavaBeans 3;

_{Projetada para ser parecida com a SQL, mas com}

suporte ao conceito de objetos;

(15)

HQL – Características

_{HQL não é executada diretamente no banco de dados. Ela é}

executada sobre o serviço do Hibernate (Embora à primeira vista isso pode transparecer como sendo um processo mais lento, uma vez que mais uma camada existe entre a aplicação e o BD, na verdade isso não ocorre).

Durante a execução, os comandos HQL são mapeados para a versão SQL nativa do banco de dados utilizado, ou seja, o dialeto do próprio banco de dados é utilizado, o que se traduz em

desempenho, pois estruturas otimizadas de acesso podem ser utilizadas.

_{Com a execução sobre o serviço do Hibernate, os comandos HQL}

(16)

HQL – Características

_{Efetua consulta de objetos ou propriedades}

_{Possui suporte à herança (consultas polimórficas)}

_{Permite fácil navegação entre associações de objetos} _{Além dos tipos de usuário, opera sobre tipos java}

nativos ou wrappers

_{String, boolean, Date, etc.} _{Coleções Java e de usuário}

(17)

_{Possui funções como na SQL:} _Agregação SUM AVG MIN MAX COUNT _Expressões

IN, NOT IN, BETWEEN, IS NULL, IS EMPTY, etc.

Estruturas CASE (case ... when ... then ... else ... end) Funções de tempo: current_date(), minute(), etc.

(18)

_{Suporta qualquer operação definida pelo EJB3-QL}

substring(), trim(), lower(), upper(), etc.

Funções escalares

sign(), trunc(), rtrim(), sin(), etc.

_{Funções para coleções}

size(), minelement(), maxelement(), minindex(), etc.

_{Qualquer variável estática pública do Java}

Color.RED, com.minhaEmpresa.comum.Sexo.MASCULINO

(19)

_{Suporte a ORDER BY, GROUP BY e HAVING;}

_{Suporte a Subqueries (quando o BD suportar);}

_{Faz junções implícitas pelas associações (ao efetuar}

uma junção entre objetos (join) não é necessário especificar quais colunas devem fazer parte dessa

junção. Isso é automaticamente inferido pelo serviço do Hibernate, a partir das estruturas de chaves dos objetos relacionados.

(20)

_{HQL é case-insensitive, exceto para os nomes}

das classes Java e propriedades.

_{Exemplificando: "SeLeCt" é a mesma coisa de}

"SELECT", mas, "modelo.PESSOA" não é a

mesma coisa de "modelo.Pessoa" e "p.nome" é

diferente de "p.NOME".

_{É importante atentar a este detalhe para evitar}

erros.

(21)

Adicionando Parâmetros pelo Nome

String queryString = "from Item item where item.description like :search";

Query q = session.createQuery(queryString).setString("search", searchString);

String queryString = "from Item item"

+ " where item.description like :search"

+ " and item.date > :minDate";

Query q = session.createQuery(queryString).setString("search", searchString).setDate("minDate", mDate);

_{Nome do parâmetro é precedido de “:”}

_{O valores são adicionados através de métodos}

(22)

Executando a Consulta

_{Se mais de um objeto pode ser retornado,}

chama-se o método list()

List list = query.list();

_{Se somente um objeto pode ser retornado,}

chama-se o método uniqueResult()

User user = (User) query.uniqueResult();

O método retorna null se nenhum objeto for encontrado;

(23)

Executando a Consulta

Query query = session.createQuery("from User"); List<User> list = query.list();

for (User user : list) {

System.out_{.println(user.getName());}

}

Query query2 = session.createQuery(

"from User user where user.name =:name").setString("name",

"SUNSP");

User user = (User) query2.uniqueResult();

(24)

Consultas Básicas

_{A consulta mais simples tem somente a cláusula}

FROM

_{“from Item”}

_{Para se referenciar as propriedades de uma}

entidade, um ALIAS deve ser criado

“from Item as item”

“from Item item”

_{Palavra chave “as” é opcional}

(25)

_{Operador LIKE pode ser utilizado}

“%” representa qualquer seqüência de caracteres

_ (Under_Score) representa qualquer caractere

“from User u where u.firstname like 'G%'”

Negação pode ser utilizada

_{“from User u where u.firstname not like '%Foo B%'”}

_{Operadores lógicos e parênteses}

“from User user where user.firstname like 'G%' and user.lastname like 'K%'”

(26)

Comparações

_{Operadores lógicos e parênteses}

“from User u where (u.firstname like 'G%' and u.lastname like 'K%' ) or u.email in

('[email protected]', '[email protected]' )”

_Coleções

(27)

Comparações

_{Funções podem ser chamadas a partir do}

HQL

HQL permite a chamada de funções SQL na cláusula WHERE

Funções UPPER() e LOWER()

_{"from User u where lower(u.email) = '[email protected]'"}

Função SIZE()

_{from Item i where size(i.bids) > 3}

(28)

Comparações

Outras funções

CONCAT(s1, s2)

SUBSTRING(s, offset, length)

_{Offset começa a partir de 1}

TRIM( [[BOTH|LEADING|TRAILING] s)

_{"from Item i where TRIM(BOTH i.name) = 'Computador'"}

LENGTH(s)

LOCATE(search, s, offset)

(29)

Ordenando o Resultado

_{A Cláusula ORDER BY é utilizada para ordenar}

o resultado

"from User u order by u.name"

_{Ordem ascendente ou descendente}

Utiliza-se asc ou desc

from User u order by u.username desc

_{Ordenando por mais de uma propriedade}

“from User u order by u.lastname asc, u.firstname asc”

(30)

Junções

_{A habilidade de realizar junções é uma das}

principais forças do modelo relacional

_{Permite selecionar diferentes objetos associados}

(31)

Inner Join

_{Contém somente os registros que estão}

relacionados com o outro lado da junção

(32)

(left) Outer Join

_{Retorna todos os Itens}

Dados de Bid são preenchidos com NULL se não houver uma correspondência

(33)

Junção com HQL

_{Coluna de junção não precisar ser informada na}

consulta

Informação é extraída do mapeamento

_{É necessário ser informado somente o nome da}

associação

Nome do atributo que referencia a classe ou coleção de classes

_{Joins podem ser executados de duas maneiras}

Join implícitos na Associação

(34)

Join Implícito na Associação

_{O Join é realizado através da associação entre duas}

entidades

_Exemplo:

“from Bid bid where bid.item.description like '%Foo%'” Bid é associado a Item através do atributo “item”

Hibernate sabe que a associação está mapeada a partir da chave estrangeira ITEM_ID da tabela BID

_{Joins implícitos são sempre realizados através de}

(35)

Join Implícito na Associação

_{Múltiplos joins são possíveis}

from Bid bid where bid.item.category.name like 'Laptop%'

(36)

Join especificado na Cláusula FROM

_{Joins podem ser especificados explicitamente na}

cláusula FROM

_Exemplo

"select i from Item i join i.bids b where b.amount > 10"

_{Aliases devem ser especificados na cláusula FROM e}

utilizados na cláusula WHERE

_{Cláusula SELECT é utilizada para que somente Itens}

(37)

Join especificado na Cláusula FROM

_{Na consulta, um Item pode ser retornado mais de uma}

vez

Uma para cada Bid associado

Somente uma instância é utilizada

_{A consulta possui o mesmo formato para associações}

(38)

Outer Joins

_{Para a utilização de Outer Joins utiliza-se a cláusula}

LEFT JOIN

LEFT OUTER JOIN e RIGHT OUTER JOIN também podem ser utilizados

_{A cláusula WITH é utilizada para adicionar restrições} _{"select i from Item i left join i.bids b with b.amount >= 9"}

(39)

Comparando Identificadores

_{Na Orientação a Objetos não são os identificadores,}

mas as referências ao objetos que são comparadas

_{Comparações podem ser feitas através dos atributos}

das entidades

_{"select i from Item i join i.bids b where i.seller = b.bidder"}

i.seller e b.bidder representam referências para a entidade User Retorna os Itens em que o próprio vendedor deu um lance

(40)

Comparando Identificadores

_{Entidades também podem ser adicionadas como}

parâmetros de uma consulta

Query query = session.createQuery("from Item i where i.seller = :seller");

(41)

HQL – Exemplos

Q1: from Aluno //Busca todos

Q2: from Aluno as alu //Uso de alias

Q3: from Aluno aluno where aluno.matricula >= 35 Q4: from Endereco end

where

( end.rua in

("Bernardo Vieira", "Prudente de Morais") ) or ( end.numero between 1 and 100 )

Q5: from Professor p where p.nome like "João%“ Q6: from Aluno aluno order by aluno.nome asc

(42)

HQl – Exemplos (JOIN’s)

_{inner join;}

_{left outer join;}

_{right outer join;}

_{full join.}

(43)

from Cat as cat

inner join cat.mate as mate

left outer join cat.kittens as kitten

from Cat as cat left join cat.mate.kittens as kittens from Formula form full join form.parameter param from Cat as cat where cat.mate.name like '%s%'

(44)

HQL – Cláusula select

select mate from Cat as cat join cat.mate as mate select cat.mate from Cat cat

select cat.name from DomesticCat cat where cat.name like 'fri%' select cust.name.firstName from Customer as cust

//Retorno em um array de Object[] select mother, offspr, mate.name

from DomesticCat as mother

inner join mother.mate as mate

(45)

HQL – Cláusula where

from Cat where name='Fritz'

from Cat as cat where cat.name='Fritz'

select foo from Foo foo, Bar bar where foo.startDate = bar.date from Cat cat where cat.mate.name is not null

select cat, mate from Cat cat, Cat mate where cat.mate = mate from AuditLog log, Payment payment

(46)

HQL – Expressões

from DomesticCat cat where cat.name between 'A' and 'B' from DomesticCat cat

where cat.name in ( 'Foo', 'Bar', 'Baz' ) from Cat cat where cat.alive = true

(47)

Fontes Bibliográficas:

_{Java Persistence com Hibernate. Christian Bauer,}

Gavin King. Editora Ciência Moderna, 2007.

_{Hibernate: Manual de Referência. Disponível em:}