Hibernate conceitos e consultas Jobson Ronan jrjscin ufpe
Hibernate – conceitos e consultas Jobson Ronan {jrjs@cin. ufpe. br}
Objetivos n n Aprender sobre os conceitos de persistência relacionados ao Hibernate Aprender como recuperar os dados e efetuar consultas de maneira eficientemente no Hibernate
Ciclo de vida da persistência n n Como Hibernate oferece um sistema transparente de persistência, as classes não sabem de sua capacidade de persistência Por outro lado, a aplicação que usa os objetos, os utiliza em estados diferentes ¡ ¡ ¡ Transientes, antes de serem gravados em meio persistente Persistentes, quando estão armazenados Desligados, quando suas instâncias são manipuladas sem afetar a base de dados
Diagrama de estados
Objetos transientes n Objetos que acabaram de ser criados (com new) ainda não são persistentes ¡ ¡ n Instâncias transientes são não-transacionais ¡ n n Seu estado é transiente (ainda não foram armazenados no banco e deixarão de existir assim que perderem sua referência) Session. delete() sobre um objeto persistente torna-o transiente Rollback não recupera seu estado anterior Objetos referenciados por instâncias transientes são (por default) também transientes Para mudar para o estado persistente é preciso ¡ ¡ Passar o objeto como argumento de um Session. save(), ou Criar a referência a partir de uma instância persistente
Objetos persistentes n Uma instância persistente é uma instância com uma identidade no banco de dados ¡ n Podem ser ¡ ¡ ¡ n n Tem uma chave primária como identificador Objeto criado com new e armazenado com Session. save() Objeto criado a partir da referência de uma instância persistente Objeto obtido a partir de um query no banco Estão sempre associados com uma Session São transacionais ¡ ¡ Seu estado é sincronizado com o banco ao fim da transação Automatic dirty checking (transparente ao usuário) é
Objetos desligados (detached) n Quando a sessão é fechada (Session. close()) todas as instâncias ainda mantém seu estado, mas não estão mais sincronizadas com o banco ¡ ¡ ¡ n Podem ficar obsoletas se houver mudança no banco Podem mudar de estado, que não será refletido no banco Mas, a qualquer momento, a sessão pode ser reativada, tornando o objeto persistente e sincronizando seu estado Objetos desligados são úteis para transportar o estado de objetos persistentes para outras camadas
Como tornar um objeto persistente n 1) Crie o objeto e inicialize suas propriedades User user = new User(); user. get. Name(). set. Firstname("John"); user. get. Name(). set. Lastname("Doe"); n 2) Abra uma sessão Session session = factory. open. Session(); n 3) Inicie uma transação Transaction tx = session. begin. Transaction(); n 4) Grave o objeto session. save(user); n 5) Cometa a transação tx. commit(); n 6) Feche a sessão session. close();
Como atualizar estado de instâncias desligadas n Quando a sessão for fechada, user torna-se uma instância desligada ¡ ¡ Qualquer alteração no seu estado não afeta o banco Para religá-lo pode-se usar update() user. set. Password("secret"); // objeto desligado Session session. Two = sessions. open. Session(); Transaction tx = session. Two. begin. Transaction(); session. Two. update(user); user. set. Username("jonny"); // objeto persistente tx. commit(); session. Two. close();
Como recuperar um objeto persistente n A forma mais simples de recuperar um objeto é pelo identificador, usando o comando get(): Session session = sessions. open. Session(); Transaction tx = session. begin. Transaction(); int user. ID = 1234; User user = (User) session. get(User. class, new Long(user. ID)); tx. commit(); session. close(); n Uma vez que a sessão foi fechada, o objeto é uma instância desligada, e pode ser repassada para outras camadas (apresentação, por exemplo)
Como atualizar um objeto persistente n Qualquer objeto retornado por get() é um objeto persistente Quaisquer modificações no seu estado serão sincronizadas com o banco de dados ¡ Hibernate automaticamente verifica e grava as mudanças ocorridas dentro de uma sessão (automatic dirty checking) ¡ As mudanças tornam-se permanentes ao cometer a Session session = sessions. open. Session(); transação Transaction tx = session. begin. Transaction(); int = 1234; ¡ user. ID O objeto torna-se desligado quando a sessão fecha ¡ User user = (User) session. get(User. class, new Long(user. ID)); user. set. Password("secret"); tx. commit(); session. close();
Como tornar transiente um objeto persistente n Um objeto persistente pode tornar-se transiente se for removido do banco Para isto é preciso usar o gerente de persistência e chamar o método delete() ¡ Quando a sessão terminar o objeto será considerado um mero objeto Java transiente (cujo estado será perdido assim que o coletor de session lixo atuar) Session = sessions. open. Session(); ¡ Transaction tx = session. begin. Transaction(); int user. ID = 1234; User user = (User) session. get(User. class, new Long(user. ID)); session. delete(user); tx. commit(); session. close();
Como tornar transiente um objeto desligado n n Para tornar um objeto desligado transiente, não é preciso ligá-lo ou fazer update() Basta chamar delete() sobre sua instância Session session = sessions. open. Session(); Transaction tx = session. begin. Transaction(); session. delete(user); tx. commit(); session. close();
API Session: ciclo de vida (Resumida) n begin. Transaction() ¡ n close() ¡ n Desconecta a sessão da conexão JDBC atual sem fechá-la. reconnect() ¡ n Fecha e desconecta a sessão disconnect() ¡ n Demarca o início de uma transação. Retorna um objeto Transaction que deve chamar commit() ou rollback() no final da transação. Obtém uma nova conexão JDBC para a sessão ou tenta conectar a uma conexão JDBC, se passada como argumento flush() ¡ Sincroniza a camada de objetos com a camada de dados. Este método é chamado automaticamente quando a transação é cometida.
Session: gerência de persistência (Resumida) n save(Object) ¡ n save. Or. Update(Object) ¡ n Carrega e retorna a instância de objeto identificado pela classe e identificador refresh(Object) ¡ n Remove os dados de um objeto do banco, tornando-o transiente load(classe, identificador) ¡ n Atualiza o objeto passado como argumento delete(Object instancia) ¡ n Insere (tornando persistente) ou atualiza o objeto passado como argumento update(Object) ¡ n Torna persistente o objeto passado como argumento Recarrega do banco os dados da instância passada como argumento evict(Object) ¡ Remove o objeto passado como argumento do cache do sistema
Recuperação de dados n Formas de recuperar objetos ¡ ¡ ¡ Pelo identificador Navegando na árvore de objetos [ ex: usuario. get. Endereco(). get. Cidade() ] Usando HQL Usando a API Criteria Usando SQL nativo
Recuperação por identificador n Há dois métodos de Session para recuperar objetos pelo identificador ¡ n Object get(Object id) ¡ n Ambos utilizam o cache, e evitam acessar o banco se não for necessário Devolve o objeto se existir e null se o objeto não for encontrado no banco ou no cache Object load(Object id) ¡ ¡ Devolve o objeto ou um proxy para o objeto se existirem, ou causa exceção se nenhum for encontrado no banco ou no cache O proxy pode apontar para objeto que ainda ou não mais existe
HQL n Hibernate Query Language é um dialeto orientado a objetos do SQL ¡ ¡ ¡ n Assemelha-se a ODMG OQL e EJB-QL mas é adaptado para uso em bancos de dados SQL Não é uma linguagem de manipulação de dados (como SQL); não serve para inserir, remover, atualizar É usada apenas para recuperação de objetos Exemplo Query q = session. create. Query("from User u where u. firstname = : fname"); q. set. String("fname", "Max"); List result = q. list();
HQL n HQL suporta vários recursos úteis e avançados; entre eles ¡ ¡ ¡ ¡ Pesquisas com navegação do grafo de objetos Recuperação seletiva de propriedades dos objetos selecionados (sem ter que carregar objeto inteiro) Ordenação de resultados Paginação de resultados Agregação com group by, having, e funções sobre agregados como sum, count, min e max Outer joins ao recuperar múltiplos objetos por registro Chamadas a funções SQL definidas pelo usuário Subqueries
Consulta usando Criteria (QBC) n n QBC = Query By Criteria Queries podem ser expressos usando uma API em vez de usar HQL ¡ ¡ n Evita uso de strings Validação é feita em tempo de compilação Enfoque mais orientado a objetos Mais difícil de ler (é Java e não HQL) Exemplo ¡ ¡ Em HQL: from User u where u. firstname = : fname Em QBC: Criteria criteria = session. create. Criteria(User. class); criteria. add( Expression. like("firstname", "Max") ); List result = criteria. list();
Como achar os dados? n n Talvez o problema mais difícil de solucionar em ORM: acesso eficiente a dados relacionais Aplicação prefere tratar os dados como um grafo de objetos interligados por associações ¡ ¡ n É mais fácil é fazer vários pequenos queries (performance baixa) Alternativa: escrever queries para cada associação (muito complexo e pouco flexível) Hibernate permite especificar uma estratégia de recuperação default (no
Estratégias de recuperação n n Fetching strategies Estratégias para qualquer associação (nos metadados e em tempo de execução) ¡ ¡ ¡ Lazy fetching – objeto associado só é recuperado quando chamado Eager fetching – objeto associado é recuperado através de SQL outer join Batch fetching – acessa uma coleção de objetos prédeterminada
Lazy fetching n Permite que apenas parte do grafo de objetos seja carregado inicialmente ¡ ¡ ¡ n O restante do grafo pode ser carregado à medida em que for necessário Vai requer mais chamadas ao banco posteriormente, mas pode ser que elas não sejam necessárias Pode ser otimizada com Batch Fetching Deve ser a estratégia inicial para todas as associações no arquivo de mapeamento ¡ A estratégia pode depois ser sobreposta em tempo de execução por estratégias mais
Lazy. Initialization. Exception n Erro comum, causado por inicialização lazy ¡ ¡ A forma mais simples de evitá-lo, é realizar tudo dentro da sessão (o commit() sincroniza os dados e evita a inconsistência) Sabendo-se do estado do objeto, os dados podem ser recuperados em outra sessão (quando voltar a ser persistente) s = sessions. open. Session(); User u = (User) s. create. Query("from User u where u. name=? “). set. String(user. Name). list(). get(0); Map permissions = u. get. Permissions(); s. connection(). commit(); s. close(); Integer access. Level = (Integer) permissions. get("accounts"); // Error!
Recuperação em lote (Batch fetching) n Na verdade não é uma outra estratégia ¡ ¡ n n É uma solução rápida para otimizar lazy fetching É um lazy menos lazy: usuário define quantos níveis de associações devem ser carregadas Hibernate procura as outras instâncias associadas à coleção e tenta carregá-las ao mesmo tempo Pode ser melhor que lazy simples ¡ Menos chamadas ao banco
Eager fetching n É uma solução que ajuda a reduzir a carga sobre o banco de dados de forma mais inteligente que Batch Fetching ¡ n n Permite que se especifique explicitamente quais objetos associados devem ser carregados juntos com o objeto que os referencia Os objetos associados podem então ser retornados em única requisição ¡ n Pode ser um a boa estratégia default Usa SQL outer join Otimização de performance em Hibernate freqüentemente usa esse tipo de estratégia em tempo de execução para um query em particular
Qual estratégia usar? n n A seleção de uma estratégia de recuperação de dados default é feita através de atributos no XML do arquivo de mapeamento. Mapeamentos de coleção diferem dependendo do tipo de associações. ¡ Coleções e associações de muitos para muitos comportam-se diferentemente de associações singulares “-to-one”.
outer-join em associações “-toone” n O atributo outer-join sobrepõe lazy fetching ¡ ¡ n Opções ¡ ¡ ¡ n Usado do lado oposto da associação O outro lado escolhe lazy fetching (ou immediate fetching por omissão) outer-join=“auto” (default). O comportamento é lazy, se o outro lado (singular) da associação especificar, ou eager, se não especificado. outer-join=“true” Comportamento é sempre eager para esta associação (logo diferentes associações para mesmo objeto podem ter estratégias diferentes) outer-join=“false” Se o objeto tiver sido mapeado como lazy, ocorre lazy fetching, caso contrário, immediate fetching (SQL select) Exemplo: <many-to-one name="item" class="Item" outer-join="true">
Em coleções n Lazy ¡ Use atributo lazy=“true” (não depende de proxy do outro lado) <set name="bids" lazy="true"> n Batched Lazy ¡ Acrescente o atributo batch-size=“tamanho” (refere-se ao número de coleções <set name="bids" lazy="true" batch-size="9"> n Eager ¡ ¡ Use atributo outer-join=“true” Evite usar como opção default
Consultas HQL n O query mais simples possível Query q 1 = session. create. Query("from User"); n n Os resultados de um query podem ser lidos em “páginas” O query abaixo lê 10 páginas, a partir da primeira página Query query = session. create. Query("from User u order by u. name asc"); query. set. First. Result(0); query. set. Max. Results(10); List results = query. list(); n Listagem de resultados List result = session. create. Query("from User"). list();
Passagem de parâmetros n Evite montar queries via concatenação de strings ¡ ¡ n n Risco de segurança: basta esquecer de fechar a aspa Longos queries ficam ilegíveis O ideal é passar parâmetros que serão ligados ao query Parâmetros podem ser passados duas formas ¡ ¡ Por nome de variável Por ordem (como Prepared. Statement em java. sql)
Passagem de parâmetros n Parâmetros passados por nome ¡ No query, o nome deve ser precedido de um “: ” String query. String = "from Item item where “ + “item. description like : search. String"; n Parâmetros por posição String query. String = "from Item item " + "where item. description like ? " + "and item. date > ? "; List result = session. create. Query(query. String). set. String(0, search. String). set. Date(1, min. Date). list();
Queries chamados pelo nome n Queries não precisam aparecer no código ¡ ¡ n Na verdade, muitas vezes é melhor que não apareçam Podem ficar nos metadados e serem chamados pelo nome Para chamar um query pelo nome, use List result = session. get. Named. Query("find. Items. By. Description"). set. String("description", get. Named. Query() n description). list(); Mas antes, é preciso que ele seja declarado em <query name="find. Items. By. Description"><![CDATA[ Item item. description algumfrom arquivo de where mapeamento (ex: like : description ]]></query> Item. hbm. xml):
Aliases n Aliases (apelidos) são usados para que se possa ter uma referência para acessar propriedades das instâncias recuperadas from Livro n é suficiente para recuperar todos os livros Um alias é declarado da seguinte forma from Livro as livro n Mas o as é opcional from Livro livro n Exemplo: para testar as propriedades em um where from Livro livro where livro. codigo = ‘ 005. 133’
Queries polimórficos n n Considere a hierarquia ao lado O query abaixo é polimórfico Billing. Details from Billing. Details n n pois os resultados são classes concretas Credit. Card Bank. Account e Credit. Card Queries polimórficos podem ser feitos em qualquer classe, não apenas em classes mapeadas O query abaixo retorna todas as instâncias mapeadas from java. lang. Object n Criteria também suporta polimorfismo List res = session. create. Criteria(java. lang. Object. class). list();
Mais HQL: Restrições (where) n n Como em SQL, HQL define restrições de um query através da cláusula where, que suporta várias expressões. Por exemplo, a expressão de equivalência: from User u where u. email = 'foo@hibernate. org‘ n A expressão where pode ter resultado true, false ou null ¡ n n HQL suporta os mesmos operadores que SQL Queries Criteria: expressões na classe Expression ¡ n lógica ternária Não há suporte para expressões aritméticas via API (só via HQL) Operadores do HQL: ¡ ¡ ¡ Comparação: =, <>, <, >, >=, <=, between, not between, in, not in Nulidade: is null, is not null Aritméticos: +, -, /, *, %, parênteses
Mais HQL: Restrições (where) n Exemplos from from Bid bid where bid. amount between 1 and 10 Bid bid where bid. amount > 100 User u where u. email in ( "foo@abc. org", "bar@abc. org" ) User u where u. email is null Bid bid where ( bid. amount / 0. 71 ) - 100. 0 > 0. 0
Mais HQL: strings n O operador like funciona da mesma forma que SQL ¡ ¡ n O símbolo _ representa um caractere O símbolo % representa vários caracteres Exemplos ¡ ¡ HQL: from User u where u. firstname like "G%" Criteria: session. create. Criteria(User. class) . add(Expression. like("firstname", "G%")) n Pode-se usar funções SQL se banco suportar from User u where lower(u. email) = 'foo@abc. org' n Não há um operador padrão de concatenação de strings ¡ ¡ É preciso usar recursos do banco nativo. Exemplo: where (u. fname || ' ' || u. lname) like 'G% K%'
Mais HQL n Operadores lógicos: and, or, parênteses, etc. servem para argupar expressões from User user where ( user. firstname like "G%" and user. lastname like "K%" ) or user. email in ( "foo@abc. org", "bar@abc. org" ) n Ordenação: Semelhante a SQL: order by ¡ ¡ asc – ascendente (default) desc – descendente from User u order by u. lname asc, u. fname asc
n . . . Pensou que acabou?
Joins n n Joins (junções) são usados para combinar dados de duas ou mais tabelas relacionadas Há quatro tipos de joins possíveis ¡ ¡ n Além disso, há dois estilos em SQL ¡ ¡ n Inner join Left outer join Right outer join Full join ANSI: junção de tabelas através de propriedade comum condição de join na cláusula on Theta: produto cartesiano de tabelas com condição de join na cláusula where Joins em HQL são bem mais simples que em SQL
SQL: ANSI inner join e left outer join § Inner join (ou simplesmente “join”) apenas Itens com Bids § Left outer join (ou “left join”) Inclui também Itens que não têm Bids n n Right outer join (“right join”) - permite valores nulos na tabela esquerda (inclui Bids sem Itens mas não itens sem Bids) – não faz sentido neste caso (lance sem item) Full join - permite valores nulos nas duas tabelas (inclui Bids que não têm Itens e itens que não têm Bids) – também não faz sentido neste caso
Joins em HQL n Em Hibernate, geralmente condições de join não são especificadas explicitamente ¡ ¡ n Elas podem ser deduzidas associações entre objetos automaticamente Queries ficam mais simples e legíveis Quatro maneiras de expressar joins em HQL ¡ ¡ ¡ Fetch join (outer, agressivo) na cláusula from Join comum (inner, lazy) na cláusula from Join theta-style (produto cartesiano) na cláusula where
Fetch join n n Recupera objeto inteiro (com associações inicializadas. ) Exemplo HQL: Retorna lista de from Item item left join fetch item. bids where item. description like '%gc%‘ objetos com coleções já inicializadas
Join simples (inner) com alias n n Freqüentemente é necessário aplicar restrições a tabelas combinadas com join. Isto pode ser feito atribuíndo um alias ao join: from Item item join item. bids bid where item. description like '%gc%‘ and bid. amount > 100 n O query acima é um inner join ¡ ¡ ¡ Em vez de uma lista de Item, retorna uma lista de Object[] Retorna uma lista de arrays {item, bid} (Se fosse um fetch join, retornaria uma lista de Item coleção de bids inicializada) Um Item pode aparecer múltiplas vezes (uma vez para cada Bid associado)
inner join x outer (fetch) join Como obter os dados usando um inner join Query q = session. create. Query("from Item item join item. bids bid"); Iterator pairs = q. list(). iterator(); Retorna while ( pairs. has. Next() ) { pares de Object[] pair = (Object[]) pairs. next(); Apenas Item item = (Item) pair[0]; referências Items que Bid bid = (Bid) pair[1]; } têm Bid E usando um left outer join com fetch Query q = session. create. Query("from Item item left join fetch item. bids"); Iterator items = q. list(). iterator(); Retorna while ( items. has. Next() ) { Items Item item = (Item) items. next(); Todos os Bid bid = (Bid) item. get. Bid(); Items } inclusive os que não têm Bid
Cláusula select n Pode-se restringir os objetos retornados com uma cláusula select ¡ ¡ n Select é opcional em HQL (mas não em SQL) A ausência do select equivale ao SQL select * Para que o inner join do exemplo anterior devolva apenas os itens (e não uma lista de Object[] com par item-bid) pode-se usar select: select item from Item item Query qjoin = session. create. Query("select i from Item i join i. bids b"); item. bids bid Iterator items = q. list(). iterator(); n while ( items. has. Next() ) { Item item = (Item) items. next(); } Exemplo Agora temos uma lista de Items contendo apenas os Items que têm
Joins implícitos n n Ocorrem em associações *-para-um (caminho convergente) e nunca em caminhos *-para-muitos O HQL a seguir causa três joins em SQL from Bid bid where bid. item. category. name like 'Laptop%' and bid. item. successful. Bid. amount > 100 n E pode ser expresso explicitamente, usando from Bid bid join bid. item where item. category. name like 'Laptop%‘ and item. successful. Bid. amount > 100 n Ou ainda from Bid as bid join bid. item as item join item. category as cat join item. successful. Bid as winning. Bid where cat. name like 'Laptop%‘ and winning. Bid. amount > 100 Joins implícitos sendo revelados
Produtos cartesianos (theta style joins) n n Permite recuperar todas as combinações possíveis de instâncias de duas ou mais classes Útil em classes não associadas ¡ ¡ n Condição de join deve estar na cláusula where Produto cartesiano Apenas inner-join pode ser usado neste caso Exemplo Query query = session. create. Query("from User user, Log. Record log " + "where username = log. username") Iterator i = query. list(). iterator(); while ( i. has. Next() ) { Object[] pair = (Object[]) i. next(); Condição de join User user = (User) pair[0]; Log. Record log = (Log. Record) pair[1]; } n Pode-se usar uma cláusula select para filtrar os resultados
Comparação de identificadores n Queries que comparam chaves-primárias são realizados implicitamente em HQL ¡ n Os dois queries. . ¡ ¡ n É o mesmo que comparar instâncias from Item i, User u where i. seller = u and u. username = 'steve' from Item i, Bid b where i. seller = b. bidder São respectivamente equivalentes aos queries: ¡ ¡ from Item i, User u where i. seller. id = u. id and u. username = 'steve' from Item i, Bid b where i. seller. id = b. bidder. id Esta última sintaxe permite que se passe parâmetros (tipo, o id) para comparação.
Queries de relatórios n Relatórios geralmente focam nos dados ¡ ¡ ¡ Instâncias não são importantes, mas valores selecionados, agrupados e organizados de certas instâncias Dependem de recursos de seleção e agrupamento Usa-se cláusulas select e group by / having.
Projeção: cláusula select n n Quais os dados desejados no resultado? O query abaixo seleciona três propriedades de dois objetos Os dados serão retornados em um vetor de Object[] de tamanho 3. ¡ Os resultados não são entidades (são valores) e não são Query transacionais query = (serão usados para leitura, apenas) ¡ session. create. Query("select item. id, item. description, bid. amount " + "from Item item join item. bids bid where bid. amount > 100"); Iterator i = query. list(). iterator(); while ( i. has. Next() ) { Object[] row = (Object[]) i. next(); Long id = (Long) row[0]; String description = (String) row[1]; Big. Decimal amount = (Big. Decimal) row[2]; Item. Row item. Row = new Item. Row(id, description, amount)“; }
Instanciamento dinâmico n Hibernate permite o instanciamento dinâmico de objetos que são povoados pelos resultados do query ¡ ¡ Evita o uso de vetores de objetos É necessário que exista uma classe e construtor previamente construída class Item. Row { public Item. Row(Long id, String description, Big. Decimal amount) {. . . } Query query = session. create. Query( "select new Item. Row(item. id, item. description, bid. amount)" + "from Item item join item. bids bid where bid. amount > 100"); Iterator i = query. list(). iterator(); while ( i. has. Next() ) { Item. Row row = (Item. Row) i. next(); //. . . fazer alguma coisa }
Distinct n n Com o uso da cláusula select, os resultados de um query não mais tem garantia de serem distintos A seguinte query pode retornar Items repetidos select item. description from Item item n Para evitar duplicação, use a cláusula distinct select distinct item. description from Item item
Funções agregadas n HQL suporta as seguintes funções na cláusula select count() – retorna Integer ¡ min(), sum() e avg() – retornam Big. Decimal Integer count max(), = (Integer) ¡ session. create. Query("select count(*) from Item"). unique. Result(); Big. Decimal sum = (Big. Decimal) session. create. Query("select sum(item. successful. Bid. amount) " +"from Item item"). unique. Result(); Big. Decimal[] minmax = (Big. Decimal[]) session. create. Query("select min(bid. amount), max(bid. amount) “ +"from Bid bid where bid. item. id = 1"). unique. Result(); Big. Decimal min = minmax[0]; Big. Decimal max = minmax[1];
Agrupamento n Se houver funções agregadas no select, não pode haver seleção de outros elementos, a menos que haja uma cláusula group by ¡ Neste caso, os elementos estar também no group select bid. item. id, count(bid), deverão avg(bid. amount) from Bid bid where bid. item. successful. Bid is null Um inner group by bid. item. id by join implícito select bid. Item. id, count(bid), avg(bid. amount) from Bid bid join bid. item bid. Item where bid. Item. successful. Bid is null group by bid. Item. id select item. id, count(bid), avg(bid. amount) from Item item fetch join item. bids bid where item. successful. Bid is null group by item. id Um inner join explícito Um fetch (outer) join; o agrupamento teve que ser feito usando item. id
Restrição de grupos com having n Pode-se aplicar restrições no agrupamento com a cláusula having select user. lastname, count(user) from User user group by user. lastname having user. lastname like 'A%‘ n n Grupos requerem o uso de pelo menos dois aliases no select (a função e a propriedade de agrupamento) Sempre que a cláusula select tem múltiplos aliases, o Hibernate devolve o resultado como (tuplas)vetores de Object ¡ ¡ n Chato de manipular; inseguro quanto ao tipo Ideal é usar select new e instanciar objetos dinamicamente Agrupamento com instanciamento dinâmico select new Usuario. Report(user. lastname, count(user)) from User user group by user. lastname having user. lastname like 'A%‘
n . . . agora acabo!
Referências n n Hibernate Reference Documentation Hibernate in Action
- Slides: 59