Você está na página 1de 51

Por

Ana Cláudia Cabral
Jul/2008

NHibernate – Persistência de Dados em Plataforma .NET 0

Súmario
1.Conceitos Gerais de Persistência .........................................................................03

2. Mapeamento Objeto Relacional ..........................................................................03
2.1 Mapeamento objeto relacional ...........................................................................04
2.1.1 Mapeamento de um objeto com tipos primitivos ................................04
2.1.2 Mapeamento de objetos que contém uma coleção de objetos .............05

3. Introdução ao Nhibernate .....................................................................................06
3.1 NHibernate x Hibernate .....................................................................................07

4. Arquitetura .................................................................................................................07
4.1 Definições das principais interfaces dos diagramas ...........................................09

5. Objetos Persistentes, Transientes e Detached ................................................10
5.1 Ciclo de Vida – Persistência ...............................................................................11
5.2 Sessões contextuais ............................................................................................12

6. Classes Persistentes .................................................................................................12
6.1 Considerações ....................................................................................................13
6.2 Identidade/Igualdade de Obetos (Equals () e GetHashCode () ) ........................13
6.3 Escolhendo Chaves Primárias ............................................................................15

7. Configurando o NHibernate ...............................................................................15

8. Manipulando Objetos Persistentes.....................................................................17
8.1 Criando um Objeto persistente ...........................................................................17
8.2 Carregando um objeto ........................................................................................17
8.3 Busca ..................................................................................................................18
8.4 Atualizando objetos ............................................................................................20
8.5 Deletando um objeto ..........................................................................................20
8.6 Flush ...................................................................................................................21
8.7 Encerrar uma sessão ...........................................................................................21

9. Mapeando O/R básico ............................................................................................22
9.1. Declaração de Mapeamento .............................................................................22
9.1.1. XML Namespace.................................................................................24
9.1.2. Hibernate-mapping.............................................................................24
9.1.3. Classes……........................................................................................25
9.1.4. Id ........................................................................................................25
9.1.4.1. Gerador.................................................................................26
9.1.5. Composite-ID.....................................................................................28
9.1.6. Discriminador ....................................................................................29

NHibernate – Persistência de Dados em Plataforma .NET 1

9.1.7. Propriedade.........................................................................................30
9.1.8. many-to-one.........................................................................................32
9.1.9. one-to-one............................................................................................33
9.1.10. subclass..............................................................................................34
9.2. NHibernate Types...............................................................................................34
9.2.1. Tipos Básicos ......................................................................................34
10. Mapeando coleções.................................................................................................37

11. Transações.................................................................................................................38
11.1 Modelos de Transações ....................................................................................40
11.2 Transações e Banco de Dados...........................................................................40

12. Concorrência............................................................................................................41

13. HQL – a linguagem de consulta hibernate....................................................42
13.1 Case-Sensitive...................................................................................................42
13.2 A cláusura FROM.............................................................................................42
13.3 Associações e junções ......................................................................................43
13.4 A cláusura select...............................................................................................43
13.5 Funções Agregadas...........................................................................................43
13.6 Consultas Polimórficas......................................................................................44
13.7 Cláusura WHERE.............................................................................................44
13.8 Expressões........................................................................................................45
13.9 A cláusura Group By........................................................................................46
13.10 A cláusura Order By.......................................................................................46
13.11 Subqueries......................................................................................................46

14. Criteria......................................................................................................................47
14.1 Criando uma instância ICriteria ......................................................................47
14.1.1 Criteria com restrição........................................................................47
14.1.2 Criteria com restrições Like .............................................................47
14.2 Ordenando o resultado.....................................................................................48
14.3 Associações .....................................................................................................48

15. Native SQL Queries.............................................................................................48
15.1 Criando uma consulta(IQuery) baseada em SQL ............................................48
15.2 Referências de alias e propriedade...................................................................48

16. Consultas nomeadas SQL....................................................................................49

Referências ......................................................................................................................50

NHibernate – Persistência de Dados em Plataforma .NET 2

1.Conceitos Gerais de Persistência
Imagine um usuário fazendo uso de uma aplicação, por exemplo, um
sistema para controlar suas finanças. Ele passa a fornecer como dados de entrada
todos os seus gastos mensais para que a aplicação lhe gere, por exemplo, gráficos
nos quais ele possa avaliar seus gastos. Finalizada, a sua análise financeira, o
usuário resolve desligar o computador em que a aplicação se encontra. Imagine
agora que o usuário teve novos gastos, voltou a ligar o computador, acessou
novamente o sistema de finanças e que gostaria de realizar novas análises com
todos os seus gastos acumulados. Se a aplicação não armazenar, de alguma
forma, os primeiros gastos fornecidos, o usuário teria que informá-los novamente
e em seguida, acrescentar os novos gastos para fazer a nova análise, causando
grande trabalho e o sistema não sendo eficiente.
Para resolver esse tipo de problema, uma solução seria armazenar (persistir)
os dados lançados a cada vez pelo usuário em um banco de dados relacional,
utilizando SQL (Structured Query Language).

2. Mapeamento Objeto Relacional
Por vários anos os projetos de aplicações corporativas tiveram uma forte
necessidade de se otimizar a comunicação da lógica de negócio com a base de
dados. Essa necessidade ganhou mais intensidade com o crescimento dessas
aplicações, crescimento esse, tanto em requisitos (funcionalidade) quanto em
volume de dados armazenados em seu banco de dados.

Na década de 80, foram criados os bancos de dados relacionais (BDR) que
substituíram as bases de dados de arquivos. Para esse tipo de base de dados foi
criada uma linguagem, a SQL. Essa linguagem foi toda baseada na lógica relacional
e por isso contava com diversas otimizações em suas tarefas se comparadas com
as outras tecnologias existentes. A partir de então foi diminuído o tempo gasto para
as operações de persistência, mesmo com um grande volume de dados. Entretanto,
essa linguagem não propiciava aos desenvolvedores uma facilidade para que a
produtividade fosse aumentada.

Uma solução que surgiu no início da década de 90 foi à criação de um
modelo de banco de dados baseado no conceito de orientação a objetos. Este
modelo visava facilitar, para os desenvolvedores, a implementação da camada de
persistência da aplicação, pois eles já estavam familiarizados com o paradigma de
orientação a objetos, consequentemente, a produtividade certamente aumentaria.

NHibernate – Persistência de Dados em Plataforma .NET 3

Na prática, esse modelo de dados não foi utilizado em grandes aplicações, visto que
elas tinham um volume de dados muito grande e esse modelo era ineficiente em
termos de tempo de resposta, pois ao contrário dos bancos de dados relacionais,
eles não tinham um modelo matemático que facilitasse as suas operações de
persistências.

Então a solução foi usar os BDR e desenvolver ferramentas para que o seu
uso seja facilitado. Uma dessas ferramentas é o framework NHibernate que usa o
conceito de mapeamento objeto relacional (MOR).
As subseções seguintes apresentam os conceitos relacionados ao
mapeamento objeto relacional.

2.1 Mapeamento objeto relacional

Como foi descrito anteriormente, mapeamento objeto relacional funciona
com a transformação dos dados de um objeto em uma linha de uma tabela de um
banco de dados, ou de forma inversa, com a transformação de uma linha da tabela
em um objeto da aplicação. Abordando essa idéia, alguns problemas poderão
existir, como, se um objeto tiver uma coleção de outros objetos. Nas próximas
subseções serão abordados os alguns tipos de mapeamentos básicos.

2.1.1 Mapeamento de um objeto com tipos primitivos

Esse é o mapeamento mais simples, onde um objeto tem apenas tipos de
dados básicos. Vale salientar que entendesse por tipos básicos aqueles que
possuem um correspondente em SQL, ou seja, o tipo String da linguagem Java é
considerado um tipo básico, pois ele possui um correspondente em SQL.
Na Figura 1, observa-se o mapeamento de três objetos do tipo Veiculo na
tabela de um banco de dados. Caso a aplicação deseje saber o veículo da cor
vermelha, por exemplo, então o objeto que tem o Pálio como modelo é retornado.

NHibernate – Persistência de Dados em Plataforma .NET 4

2 Mapeamento de objetos que contém uma coleção de objetos Esse tipo de mapeamento é quando um objeto possui um conjunto de outros objetos. ou seja.2.1. Faz-se necessário a adição de uma informação na classe Veiculo chamada de fabricante. Essa chave estrangeira será realizada entre a informação nome da classe Fabricante e o atributo fabricante da classe Veiculo. O atributo fabricante adicionado em Veiculo é simplesmente para relacionar um veículo ao seu fabricante. como mostrado na Figura 2. faz-se necessária uma alteração no modelo do banco de dados.NET 5 . um veículo possui apenas um fabricante e um fabricante possui vários (N) veículos. Como foram realizadas mudanças no domínio do exemplo orientado a objetos. pois em BDR não existe o conceito de coleções) que se localizará na tabela VEICULO. uma nova classe chamada de Fabricante que conterá as informações: nome. Primeiramente. ao exemplo da Figura 1. enquanto o veiculos de Fabricante referencia a classe Veiculo. o vínculo que foi realizado entre um fabricante e um veículo deverá ser implementado através de uma chave estrangeira (referência a uma outra tabela. Para obter esse conceito é necessário adicionar. caracterizando o mapeamento 1 para N. que armazenará o nome desse fabricante e o veículo. NHibernate – Persistência de Dados em Plataforma . que conterá o conjunto de veículos do fabricante (telefone e endereco não são informações relevantes no exemplo).

NET das tabelas da banco de dados (e dos tipos de dados . onde <fabricante> é o nome do fabricante que está na tabela VEICULO. visando facilitar a implementação da camada de persistência. por exemplo. Para recuperar os veículos inseridos o desenvolvedor terá que implementar uma busca que retorne além das informações do veículo as informações do seu fabricante. O NHibernate é um objeto/ferramenta de mapeamento relacional para ambientes . O NHibernate mapeia não somente as classes . a única diferença é que agora a consulta que buscará os veículos associados com o fabricante retornará uma coleção de veículos (SELECT * FROM veiculo WHERE fabricante = <nomeFabricante>). dentre elas o framework NHibernate. então para se buscar o fabricante a seguinte consulta será realizada: SELECT * FROM fabricante WHERE nome = 'Fiat'. caso a aplicação deseje as informações do veículo do modelo Pálio. O termo objeto de mapeamento relacional (ORM) refere à técnica de mapear uma representação de dados de um modelo de objeto a um modelo de dados relacional com um schema baseado em SQL. mas também fornece facilidades da pergunta e da recuperação dos dados e pode significativamente reduzir o tempo de NHibernate – Persistência de Dados em Plataforma . Pensando em termos práticos. isso implica dizer que na tabela de VEICULO existe uma referência para a tabela FABRICANTE. os fabricantes são buscados. Essa ferramenta será descrita nas próximas seções. Para um melhor entendimento. Esse tipo de mapeamento é muito utilizado em aplicações em que os objetos fazem muita referência a outros objetos. Introdução ao Nhibernate Trabalhar com software orientado a objeto e uma banco de dados relacional pode ser incômodo e demorado em ambientes empresariais de hoje.NET aos tipos de dados do SQL). que um software livre de código aberto e que está tendo uma forte adesão de novos projetos corporativos. Com a idéia do MOR vários projetos de ferramenta começaram a ser desenvolvidas.NET. ele será ligado ao seu respectivo fabricante. a Figura 3 mostra o mapeamento dos objetos para as tabelas no BDR. quando um veículo for inserido no banco de dados. Essa associação é feita através da coluna fabricante da tabela VEICULO. Nele observa-se que cada veículo está associado com um fabricante. no momento da inserção. 3. Utilizando a mesma idéia. isso poderá ser realizado fazendo a seguinte consulta SQL: SELECT * FROM fabricante WHERE nome = <fabricante>.NET 6 .

NET. ele é mais útil com modelos de domínio orientados a objeto e lógica de negócio middle-tier baseado em . a JBOSS. O NHibernate pode não ser a melhor solução para as aplicações data-centric que usam somente stored-procedures para executar a lógica de negócio na banco de dados. O objetivo de NHibernate é aliviar o desenvolvedor em 95 % das tarefas de programação relativas aos dados de persistência comum.0.NET. o NHibernate pode certamente ajudá-lo a remover ou encapsular o código SQL vendor-specific e o ajudará com tarefas comuns de tradução ajustada ao resultado de uma representação tabular para um gráfico de objetos. desenvolvimento fazendo de outra maneira a manipulação de dados manual no SQL e no ADO. deleção. 3.hibernate.0 do NHibernate. Esta versão do NHibernate é equivalente à versão 2. Se você acessar os sites www. Algumas particularidades das versões podem ser encontradas no link: http://www. De acordo com os diagramas abaixo. Entretanto. fazendo assim uma integração do conhecimento.NET. 4. Lifecycle e Validatable. o NHibernate encontra-se na versão 1. NHibernate – Persistência de Dados em Plataforma .hibernate.0 da plataforma . usuários e plataforma para um modelo de persistência de dados padrão entre as tecnologias.org/360. ITransaction e Query.1 e 2. as interfaces são classificadas como: • Interfaces responsáveis por executar operações de criação. A camada de negócio aparece acima da camada de persistência por atuar como uma cliente da camada de persistência.NET.html. Entretanto.org e www.1 do J2EE.NET 7 . Interfaces responsáveis por realizar a interação entre os eventos do NHibernate e a aplicação: Interceptor. • Interface utilizada pela aplicação para configurar o NHibernate: IConfiguration. a JBOSS vem trabalhando para tentar zerar todas as pendências. Arquitetura A arquitetura do NHibernate é formada basicamente por um conjunto de interfaces.1 NHibernate x Hibernate Atualmente. e toda a documentação utilizada na versão J2EE pode ser aplicada diretamente para a versão do . empresa responsável pelo Hibernate.nhibernate. Vale salientar que algumas aplicações podem não ter a separação clara entre as camadas de negócio e de persistência. consulta e atualização no banco de dados: ISession. comprou os direitos desta ferramenta. Os diagramas abaixo apresentam as interfaces mais importantes nas camadas de negócio e persistência. Uma curiosidade é que após o lançamento oficial da versão 1.org notará que ambos compartilham da mesma estrutura.2 e pode ser utilizado tanto nos Frameworks 1.

NET 8 . Essa abordagem usa um subconjunto mínimo de APIs do NHibernate: NHibernate – Persistência de Dados em Plataforma . Infelizmente. A arquitetura "Lite" fornece aos seus aplicativos suas próprias conexões do ADO. IdentifierGenerator. Mostraremos os dois extremos. Gostaríamos de mostrar um modo de exibição mais detalhado da arquitetura do tempo de execução. o NHibernate é flexível e oferece suporte a várias abordagens.NET e gerencia suas próprias transações. CompositeUserType. Uma (muitas) visão de alto nível da arquitetura do NHibernate: Este diagrama mostra o NHibernate usando os dados do banco de dados e a configuração para fornecer serviços de persistência (e objetos persistentes) para o aplicativo. • Interfaces que permitem a extensão das funcionalidades de mapeamento do NHibernate: UserType.

4. a partir dos quais os dados são acessados.NET 9 .ISessionFactory) O objeto ISessionFactory é aquele que mantém o mapeamento objeto relacional em memória.A arquitetura "full cream" abstrai o aplicativo para fora dos APIs ADO. Permite a criação de objetos ISession. Também denominado como fábrica de objetos ISessions. porém deve existir apenas uma NHibernate – Persistência de Dados em Plataforma . Um objeto SessionFactory é threadsafe.1 Definições das principais interfaces dos diagramas: • ISessionFactory ( NHibernate.NET subjacente e permite que o NHibernate cuide dos detalhes.ISessionFactory ) ISessionFactory (NHibernate.

Com ele é possível criar. pode haver também objetos transientes. O NHibernate define estes três tipos de estados: persistentes. remover. Em aplicações orientadas a objetos. Isto é feito. Objetos com esses estados são definidos como a seguir: NHibernate – Persistência de Dados em Plataforma . sempre que for necessário propagar o estado de um objeto que está em memória para o banco de dados ou vice-versa. O uso dessa interface em aplicações que usam NHibernate é opcional. Objetos transientes são aqueles que possuem um ciclo de vida limitado ao tempo de vida do processo que o instanciou. instância dele na aplicação. Um objeto ISession possui um cache local de objetos recuperados na sessão. pois é um objeto muito pesado para ser criado várias vezes. Em uma aplicação não há somente objetos persistentes. já que pode ser armazenado em disco e então. 5. no futuro. não deve ter tempo de vida por toda a aplicação e não é threadsafe.NET. nem todas as suas instâncias possuem necessariamente um estado persistente.ISession ) ISession (NHibernate. invocando o gerenciador de persistência e as interfaces de consultas do NHibernate. o que continua a existir é seu estado.NET. atualizar e recuperar objetos persistentes. Objetos Persistentes. • Interfaces Criteria e Query As interfaces Criteria e Query são utilizadas para realizar consultas ao banco de dados. • ISession ( NHibernate. transientes e detached. Na verdade. é necessário para a aplicação ter conhecimento sobre os estados do ciclo de vida da persistência.ISession) O objeto ISession é aquele que possibilita a comunicação entre a aplicação e a persistência. Quando interagindo com o mecanismo de persistência. Essa interface abstrai a aplicação dos detalhes das transações ADO. É um objeto leve de ser criado. há a necessidade de que a aplicação interaja com uma camada de persistência. • ITransaction ( NHibernate. Em relação às classes persistentes. a persistência permite que um objeto continue a existir mesmo após a destruição do processo que o criou. Elas também podem ter um estado transiente ou detached. através de uma conexão ADO.NET 10 . Transientes e Detached Nas diversas aplicações existentes.ITransaction) A interface iTransaction é utilizada para representar uma unidade indivisível de uma operação de manipulação de dados. ser recriado em um novo objeto.ITransaction ) ITransaction (NHibernate.

• Objetos Persistentes: são objetos que suas instâncias estão associadas a um contexto persistente. Um objeto em estado transiente se torna persistente se for criado ou atualizado no banco de dados. for atualizado no banco de dados. Tanto do estado detached quanto do estado transiente o objeto pode ser coletado para destruição. por fechamento de sessão. tem uma identidade de banco de dados. nem são transientes nem persistentes. pode retornar ao estado transiente se for apagado do banco de dados. o NHibernate não dá nenhuma garantia sobre a relação entre a identidade persistente e identidade do CLR O ciclo de vida de um objeto persistente pode ser resumido a partir da Figura abaixo. Para instâncias separadas. • Objetos detached: são objetos que tiveram suas instâncias associadas a um contexto persistente. por exemplo. se. a sessão com o banco de dados por fechada.NET 11 . Eles são instanciados. finalização de sessão. ou seja. Também pode passar ao estado detached.Persistência De acordo com a figura acima. o NHibernate garante que a identidade persistente é equivalente a identidade do CLR (na memória local do objeto). utilizados e após a sua destruição não podem ser reconstruídos automaticamente. NHibernate – Persistência de Dados em Plataforma . mas que por algum motivo deixaram de ser associadas. Para um contexto específico de persistência. Já um objeto em estado persistente. por exemplo. • Objetos Transientes: são objetos que suas instâncias não estão nem estiveram associados a algum contexto persistente. 5.1 Ciclo de Vida . o objeto pode ser criado e ter o estado transiente ou persistente. Um objeto no estado detached pode voltar ao estado persistente se. São objetos em um estado intermediário. por exemplo. inicialmente.

private DateTime _birthdate. } set { _name = value. onde uma determinada sessão está em vigor em todo o escopo de um determinado contexto.O processo por trás do método SessionFactory. O NHibernate apresenta um melhor desempenho se trabalhar com algumas regras simples conhecidas como Plain Old CLR Object (POCO). A Listagem abaixo apresenta a classe Cat representando uma classe POCO. } } public DateTime Birthdate { get { return _birthdate. uma nova interface (NHibernate. e contextos diferentes definem escopos diferentes. 6. private Cat _mate. public class Cat { private long _id.current_session_context_class) foram adicionados para possibilitar a compatibilidade do contexto e do escopo na definição de sessões correntes. Com isso.ICurrentSessionContext) e um novo parâmetro de configuração (HIBERNATE.2.Context. } set { _id = value.5. No entanto. NHibernate adicionou o método ISessionFactory. // identifier private string _name. } } NHibernate – Persistência de Dados em Plataforma . } set { _birthdate = value. Classes Persistentes As classes persistentes de uma aplicação são aquelas que implementam as entidades de domínio de negócio.GetCurrentSession(). A partir versão 1.NET 12 . todas as definições dos aplicativos que constituem um contexto são geralmente diferentes.GetCurrentSession() é plugáveis. public long Id { get { return _id.2 Sessões contextuais A maioria dos aplicativos que usam o NHibernate precisam de alguma forma de sessões "contextuais". } } public string Name { get { return _name.

6. protected. • O Nhibernate persiste propriedades usando os método get e set. A maneira mais óbvia de implementar Equals () / GetHashCode()é comparando o valor do identificador de ambos os objetos.SaveUpdate() 6. mas verificar se as duas são iguais utilizando o operador ==. Porém. O NHibernate pode persistir uma propriedade com uma visibilidade internal. a identidade de banco de dados. protected internal ou private.2 Identidade/Igualdade de Obetos (Equals () e GetHashCode () ) No Nhibernate o conceito de igualdade entre objetos é diferente.CreateInstance (). Se você tiver a intenção de unir objetos de classes persistentes deverá usar os métodos Equals() e GetHashCode(). a implementação do padrão Equals ()) dentro de uma única ISession! Mesmo que os dois objetos a e b estejam na mesma coluna do banco de dados (eles têm o seu identificador com mesmo valor de chave primária). Isso só se aplica se esses objetos são carregados em dois diferentes ISession s. um ISet). Como o NHibernate garante apenas a identidade (a == b. Dois objetos. Além do mais . passa a existir um novo conceito de identidade. Dois objetos armazenados em um banco de dados são idênticos se forem mapeados em uma mesma linha da tabela. algumas funcionalidades só estão disponíveis para classes que declaram uma propriedade identificadora: • Atualização em cascata Isession. duas Strings. pode retornar um resultado errado. Se o valor é o mesmo. todos os objetos persistentes possuam um identificador e que eles sejam independentes da lógica de negócio da aplicação.NET 13 . Incluindo o conceito de persistência. você pode deixá-lo de fora e deixar que o Nhibernate acompanhe os objetos internamente. por exemplo. não podemos garantir que eles são instância do mesmo objeto fora de um contexto particular ISession. o NHibernate pode instanciá-las simplesmente chamando Activator. podem ter o mesmo conteúdo. pois o operado == implicará em uma verificação da posição de memória e não do conteúdo. (por exemplo.1 Considerações: • O NHibernate requer que toda classe persistente possua um construtor padrão sem argumentos. • A classe Cat possui um atributo id que é o seu identificador único. ao utilizar NHibernate. ambos devem estar na mesma NHibernate – Persistência de Dados em Plataforma . assim. Observe que a classe Pessoa apresenta métodos setters e getters para acessar ou retornar todos os seus atributos. É importante que. Propriedades não pode ser declaradas como Públicas.

normalmente se aplica a uma chave primária real! NHibernate – Persistência de Dados em Plataforma . Cat cat = other as Cat. Infelizmente. return true. } public override int GetHashCode() { unchecked { int result. uma instância recém-criada não terá qualquer valor no identificador! Recomendamos a execução Equals() e GetHashCode() usando Business key equality. return result.Birthday)) return false.NET 14 .coluna do banco de dados. if (cat == null) return false.. public override bool Equals(object other) { if (this == other) return true. } } } Tenha em mente que a nossa chave candidata (neste caso. um composto de nome e data de aniversário) tem de ser válido apenas para uma determinada operação de comparação (talvez apenas em caso de utilização única).Equals(cat. result = Name. O NHibernate só irá atribuir valores aos identificador dos objetos que são persistentes.GetHashCode(). por isso. são iguais (se ambos são adicionados a um ISet. no mundo real (uma chave candidata natural): public class Cat { . vamos ter apenas um elemento no ISet). if (!Birthday. Não precisamos critérios de estabilidade. Business key equality (igualar chaves de negócios) significa que o método Equals()compara apenas as unidades que formam o chave de negócio. // null or not a cat if (Name != cat.. result = 29 * result + Birthday. Uma chave que permitiria identificar o nosso exemplo.Name) return false.GetHashCode(). não podemos usar essa abordagem.

Uma única tabela pode ter várias colunas ou combinações de colunas que satisfazem essas propriedades.cfg. se for desejado que a chave primária da tabela Cat seja uma outra ao invés do id. Se possuir várias chaves candidatas. ele é por definição a sua chave primária. deve-se configurar: • A URL de conexão com o banco de dados. Vários parâmetros podem ser configurados.NET 15 . Um problema que poderia acontecer seria a remoção do id da tabela.6. • Nunca ser nula. • Usar um arquivo . Ela deve satisfazer as seguintes propriedades: • Única.cfg. Se a tabela possui um único atributo que a identifique. Dessa forma. ou seja. • Usuário e senha do banco de dados. • Usar um arquivo XML (hibernate. 7.xml. Configurando o NHibernate Pode-se configurar o NHibernate de três maneiras distintas: • Instanciar um objeto de configuração (NHibernate. Muitas aplicações utilizam como chaves primárias chaves naturais. Será apresentada a configuração a partir do arquivo hibernate. Essa estratégia pode não ser muito boa em longo prazo. • Constante. Um exemplo deste arquivo de configuração pode ser visto na Listagem abaixo. Uma chave candidata é uma coluna ou um conjunto de colunas que identifica unicamente uma linha de uma tabela do banco de dados.properties com as suas configurações e indicar as classes mapeadas programaticamente. única e não nula. que têm significados de negócio. NHibernate – Persistência de Dados em Plataforma . uma deve ser escolhida para representar a chave primária e as demais serem definidas como chaves únicas.xml) com as propriedades de inicialização e os caminhos das classes mapeadas. • Dialeto. • Números máximo e mínimo de conexões no pool. já que uma chave primária adequada deve ser constante. podem surgir problemas já que provavelmente o id deve ser referenciado em outras tabelas.3 Escolhendo Chaves Primárias Um passo importante ao utilizar o NHibernate é informá-lo sobre a estratégia utilizada para a geração de chaves primárias.Configuration) e inserir suas propriedades programaticamente. Basicamente.Cfg.

properties --> <property name="connection.driver_class: nome da classe do driver JDBC do banco de dados que está sendo utilizado. • connection.xml" assembly="NHibernate.Connection.hbm.Driver.an ISessionFactory instance --> <session-factory> <!-.NET 16 .SqlClientDriver</property> <property name="connection.initial catalog=nhibernate.cfg. Usado para identificar as particularidades do banco de dados. • use_outer_join: Permite buscar associação externa.Item.0"> <!-.hbm. connection_string: é a seqüência de caracteres utilizados para obter conexão de conexão.0' encoding='utf-8'?> <hibernate-configuration xmlns="urn:nhibernate-configuration-2.Password=</property> <property name="show_sql">false</property> <property name="dialect">NHibernate. NHibernate – Persistência de Dados em Plataforma .Auction. use max_fetch_depth.connection_string">Server=localhost.Dialect.Bid.Auction" /> </session-factory> </hibernate-configuration> Arquivo de Configuração hibernate.provider">NHibernate.User Id=.Auction.DriverConnectionProvider</property > <property name="connection. • show_sql: utilizado para definir se os SQL’s gerados pelo NHibernate devem ou não ser exibidos (true | false).<?xml version='1. Substituído.mapping files --> <mapping resource="NHibernate.xml • dialect: implementação do dialeto SQL específico do banco de dados a ser utilizado.xml" assembly="NHibernate.Auction" /> <mapping resource="NHibernate.MsSql2000Dialect</property> <property name="use_outer_join">true</property> <!-.driver_class">NHibernate.

8. long generatedId = (long) sess. é transitória ou persistente.Kittens = new HashSet().Color = Color. fritz.Save(fritz). DomesticCat pk = new DomesticCat().2 Carregando um objeto Os métodos Load() da ISession oferecem uma maneira de recuperar uma instância persistente se você já souber seu identificador. Objetos Associados podem ser persistidos em qualquer ordem que você desejar a menos que você tenha uma restrição NOT NULL mediante uma coluna chave estrangeira. 1234L ).Name = "PK". pk.AddKitten(fritz).Color = Color. A sessão oferece serviços para a persistência de casos transitórios: DomesticCat fritz = new DomesticCat().Load(typeof(Cat). pk. pk.8. fritz. naturalmente. Manipulando Objetos Persistentes O NHibernate utiliza objetos ISession para persistir e recuperar objetos. generatedId). pk. fritz. transitórios. Cat fritz = (Cat) sess.1 Criando um Objeto persistente Um objeto (exemplo entidade). O formulário que usa uma instância é útil apenas em circunstâncias especiais (instância DIY pooling etc).Sex = 'F'.Tabby. no que diz respeito a um ISession particular. Uma versão pegará um objeto da classe e carregará o estado em um objeto recém-instanciado. pk. Não há qualquer risco de violar uma restrição da chave estrangeira.Name = "Fritz". 8.Ginger. NHibernate – Persistência de Dados em Plataforma . sess. No entanto. A segunda versão permite que você forneça uma instância no qual o estado será carregado. Objetos novos instanciados são.NET.Save( pk. você poderá violar um constrangimento NOT NULL se você salvar os objetos de forma incorreta. O single-argument Save() gera e atribui um identificador único para fritz. O two-argument cria formulários na tentativa de persistir pk usando o identificador dado.NET 17 . Um objeto ISession pode ser considerado como uma sessão de comunicação com o banco de dados através de uma conexão ADO.Sex = 'M'.

. if (cat==null) { cat = new Cat(). que atinge o banco de dados imediatamente e retorna nulo se não houver nenhuma linha correspondente. O NHibernate suporta uma simples.Load( cat.Kittens. id).3 Busca Se você não sabe o qual o identificador(s) do objeto(s) que você está procurando. LockMode.Upgrade). você deve usar o método Get(). pkId ). 8. // load pk's state into cat sess. Observe que o Load() apresentará uma exceção irrecuperável se não houver nenhuma linha do banco de dados correspondente. Se você não tiver certeza de que existe uma linha coincidente. Se a classe é mapeada com um proxy.NET 18 . mas poderosa linguagem orientada a objeto para consulta. DomesticCat pk = (DomesticCat) sess. id. pkId ). NHibernate – Persistência de Dados em Plataforma . } return cat.long pkId = 1234. Observe que quaisquer instâncias associadas ou coleções contidas não são selecionadas FOR UPDATE. ISet kittens = cat.. id).Load( typeof(Cat). Cat cat = new DomesticCat(). FOR UPDATE Cat cat = (Cat) sess. o Load() retorna um objeto proxy não inicializado e não atualizado do banco de dados até que você chame um método do objeto.Get(typeof(Cat). sess. Cat cat = (Cat) sess. use o método Find()da ISession. Você também pode carregar um objetos usando um SQL SELECT .Save(cat. Esse comportamento é muito útil se você deseja criar uma associação para um objeto sem realmente carregá-lo do banco de dados.Get(typeof(Cat).

Eg.IList cats = sess.id = ?". IList mates = sess. name.SetMaxResults(10). crit. • Criterias Queries HQL é extremamente poderoso. new object[] { id1. NHibernateUtil.Mate as mate " + "where cat.Eq("color". IList mates = sess.id = ? or cat.Color.Int64.String ).Int64 } ). NHibernateUtil.Entity(typeof(Cat)) ). NHibernateUtil.Name = 'Fritz' or cat.Birthdate = ?".Birthday > fish. crit.NET.Mate = ?". Para essas pessoas.Birthday is null" ).CreateCriteria(typeof(Cat)).List().Mate.name = ?".Find( "from Cat as cat where cat.Add( Expression. em vez de incorporar as seqüências de caracteres em seus códigos . o NHibernate fornece uma consulta ICriteria intuitiva API.NET 19 . id2 }.Find( "from Cat as cat where cat.Date ). new IType[] { NHibernateUtil. IList moreCats = sess.Deceased or fish. IList problems = sess. NHibernateUtil. ICriteria crit = session. IList cats = sess. mas algumas pessoas preferem criar consultas dinamicamente usando um objeto orientado a API. date.Find( "from Cat as cat where " + "cat. IList cats = crit.Find( "from Cat as cat where cat.Find( "from GoldFish as fish " + "where fish.Birthdate is null" ). izi.Black) ).Find( "select mate from Cat as cat join cat. NHibernate – Persistência de Dados em Plataforma .

IList cats = session. • SQL Native Você pode expressar uma consulta no SQL usando CreateSQLQuery().Delete() irá remover um objeto do banco de dados. .class}.Sex}.Delete(cat).CreateSQLQuery( "SELECT {cat}.SEX AS {cat.NET 20 ..SUBCLASS AS {cat. " + "{cat}. // save the new instance (mate has a null id) 8.MATE AS {cat. exatamente como consultas NHibernate.SaveOrUpdate(mate). sess. // in the first session Cat cat = (Cat) firstSession. {cat}. "cat". typeof(Cat)).List() As consultas SQL podem conter parâmetros nomeados e posicionais. typeof(Cat) ). {cat}.5 Deletando um objeto O ISession. " + "FROM CAT {cat} WHERE ROWNUM<10". IList cats = session.List(). catID).Id}.SaveOrUpdate(cat).4 Atualizando objetos Você pode Incluir um objeto na tabela caso ele ainda não exista (seja transiente) ou atualizar o objeto caso ele já exista (seja persistente) utilizando o método SaveOrUpdate ().Mate = mate. cat.CreateSQLQuery( "SELECT {cat. 8.Load(typeof(Cat). Você deve colocar os aliases SQL entre chaves.ID AS {cat.Mate}. // later. in a new session secondSession.*} FROM CAT {cat} WHERE ROWNUM<10".. // in a higher tier of the application Cat mate = new Cat(). "cat". NHibernate – Persistência de Dados em Plataforma . // update existing state (cat has a non-null id) secondSession.

//flush occurs 8..Load(typeof(Cat).ITransaction. 8. izi.6 Flush De tempos em tempos a ISession irá executar os comandos SQL necessários para sincronizar a conexão de Estado do ADO.Commit. flush. id)..Flush () As instruções SQL são emitidas na seguinte ordem: • todas as inserções na entidade.BeginTransaction().Delete () sess = sf.7 Encerrar uma sessão Terminar uma sessão envolve quatro fases distintas: • Liberar a sessão • confirmar a transação • fechar a sessão • tratar exceções NHibernate – Persistência de Dados em Plataforma .Kittens kitten"). sess.FlushMode = FlushMode. ITransaction tx = sess. //change to izi is not flushed! .Find("from Cat as cat left outer join cat... //allow queries to return stale state Cat izi = (Cat) sess. na mesma ordem que os objetos correspondentes foram salvos usando Save() • todas as atualizações na entidade • todas as coleções deletas • todosos elementos de coleções delatados. atualizados e inseridos • todas as inserções • todas as entidades delatadas.Name = "iznizi".NET com o estado dos objetos. em memória. // execute some queries.OpenSession(). nos seguintes pontos: • a partir de algumas invocações de Find() ou Enumerable() • a partir do NHibernate.Commit () • a partir da ISession. ocorre por omissão. na mesma ordem que os objetos correspondentes foram delatados usando ISession.NET 21 .. tx. sess. Este processo.Commit().

sess.Rollback(). Note que.NET 22 .1.ISession sess = factory.Close().openSession().. NHibernate – Persistência de Dados em Plataforma . currentTransaction.Mapping. throw. } catch (Exception e) { currentTransaction..Attributes e de vários modelos baseados em geradores de código (CodeSmith.Commit(). } 9. MyGeneration). Mapeando O/R básico 9. try { // do some work . e não declarações de tabelas. A linguagem de mapeamento é objeto-centric. existem uma série de ferramentas para gerar o mapeamento do documento. o que significa que os mapeamentos são construídos em torno de declarações de classes persistentes. apesar de muitos usuários NHibernate optarem por definir mapeamentos XML à mão.Flush(). Declaração de Mapeamento Os mapeamentos objeto / relacional são definidos em um documento XML. incluindo a biblioteca NHibernate. } finally { sess. O documento mapeado é projetado para ser legível e de mãos-editáveis.

Vamos iniciar com um exemplo de mapeamento: <?xml version="1.mapping for Dog could go here --> </class> </hibernate-mapping> NHibernate – Persistência de Dados em Plataforma .2" assembly="Eg" namespace="Eg"> <class name="Cat" table="CATS" discriminator-value="C"> <id name="Id" column="uid" type="Int64"> <generator class="hilo"/> </id> <discriminator column="subclass" type="Char"/> <property name="BirthDate" type="Date"/> <property name="Color" not-null="true"/> <property name="Sex" not-null="true" update="false"/> <property name="Weight"/> <many-to-one name="Mate" column="mate_id"/> <set name="Kittens"> <key column="mother_id"/> <one-to-many class="Cat"/> </set> <subclass name="DomesticCat" discriminator-value="D"> <property name="Name" type="String"/> </subclass> </class> <class name="Dog"> <!-.0"?> <hibernate-mapping xmlns="urn:nhibernate-mapping-2.NET 23 .

(5) NHibernate – Persistência de Dados em Plataforma . O atributo schema especifica a que tabelas referenciadas por este mapeamento pertencem o esquema nomeado. 9. O atributo default-cascade especifica qual o estilo de cascata que deve ser assumida pelas propriedades e coleções que não especificam um atributo cascade.1.2.1. O atributo auto-import permite-nos utilizar incondicionalmente nomes de classe na consulta. O documento de mapeamento contém ainda alguns atributos opcionais extras e elementos que afetam schemas de banco de dados exportados pelo schema da ferramenta de exportação.defaults para true): Especifica se podemos utilizar incondicionalmente nomes de classes (neste mapeamento de classes) na consulta.xsd na distribuição de NHibernate. (3) O auto-import (opcional . Hibernate-mapping Este elemento tem vários atributos opcionais. Vamos apenas descrever elementos e atributos do documento que são utilizados por NHibernate no decorrer do processo. XML Namespace Todos os mapeamentos XML devem declarar o namespace XML mostrado. assembly e namespace (opcional): Especificar assembly e namespace para assumir (4) incondicionalmente denominações para a classe no documento de mapeamento . Se faltar. <hibernate-mapping schema="schemaName" (1) default-cascade="none|save-update" (2) auto-import="true|false" (3) assembly="Eg" (4) namespace="Eg" (5) /> (1) schema (opcional): O nome do schema de um banco de dados.NET 24 . Os atributos assembly e namespace especificam o assembly onde classes persistentes estão localizadas e namespace que foram declaradas.) 9. Se especificado. (2) default-cascade (opcional . o atributo not-null.Vamos agora discutir o conteúdo do documento de mapeamento.defaults para none): Um estilo cascata padrão. o nome da tabela será incondicional. por default. A atual definição do schema pode ser encontrada no arquivo src\nhibernate-Mapping. not-null (Por exemplo. os nomes das tabelas serão qualificadas pelo nome dado schema.1.

4.1. A maioria das classes também terá uma propriedade que contém o identificador exclusivo de uma instância.1. incluindo o nome do assembly que as classes são declaradas. Classes Você pode declarar uma classe persistente utilizando o elemento class: <class name="ClassName" table="tableName" discriminator-value="discriminator_value" mutable="true|false" schema="owner" proxy="ProxyInterface" dynamic-update="true|false" dynamic-insert="true|false" select-before-update="true|false" polymorphism="implicit|explicit" where="arbitrary sql where condition" persister="PersisterClass" batch-size="N" optimistic-lock="none|version|dirty|all" lazy="true|false" /> Ele é perfeitamente aceitável pela classe persistente nomeada para ser uma interface . você deve definir auto-import = "false". se você tentar atribuir duas classes para os mesmos nomes "imported". Se você não estiver usando atributos assembly e namespace.NET 25 .3. Id Classes mapeadas devem declarar uma coluna chave primária na tabela do banco de dados. 9. O NHibernate irá lançar uma exceção. você precisará especificar nomes de classes totalmente qualificados. 9. Se você tem duas classes persistentes com o mesmo nome (incondicional). <id name="PropertyName" (1) type="typename" (2) column="column_name" (3) unsaved-value="any|none|null|id_value" (4) access="field|property|nosetter|ClassName(5)"> <generator class="generatorClass"/> </id> NHibernate – Persistência de Dados em Plataforma . O elemento <id> define o mapeamento a partir dessa propriedade para a coluna da chave primária.

1. (4) unsaved-value (opcional . algumas aplicações podem optar por prestar suas próprias implementações especializadas. Se alguns parâmetros são exigidos para configurar ou para inicializar a instância do gerador é utilizado o elemento <param>. incremento gera os identificadores de qualquer tipo integral que são originados somente quando nenhum outro processo está introduzindo dados na mesma tabela. distinguindo-a a partir de casos transitórios que foram salvas ou carregadas em uma sessão anterior. NHibernate – Persistência de Dados em Plataforma . Se o atributo name estiver faltando. (5) access (opcional .defaults para a propriedade name): O nome da coluna chave primária.Id.Id. 9. Nós desaconselhamos seu uso para qualquer outra coisa. o NHibernate prevê uma série implementações internas.defaults para um valor "sensible"):Valor da propriedade do identificador que indica que uma instância foi recém instanciada (não salvas).0. No entanto. (2) Type (opcional): Um nome que indica o tipo NHibernate. O atributo unsaved-value quase nunca é necessário no NHibernate 1. Há uma declaração alternativa <composite-id> para permitir o acesso a dados com chaves compostas.NET 26 . Não usar em um cluster.(1) Name (opcional): O nome da propriedade do identificador. <id name="Id" type="Int64" column="uid" unsaved-value="0"> <generator class="NHibernate.TableHiLoGenerator"> <param name="table"> uid_table </ param> <param name="column"> next_hi_value_column </ param> </ gerador> </ id> Todos os geradores implementam uma interface NHibernate. Gerador O elemento <generator> é usado para gerar identificadores originais para insatancias da classe persistente.1. (3) column (opcional .4.defaults de propriedade): O NHibernate deve usar uma estratégia para acessar o valor da propriedade. presume-se que a classe não tem propriedade no identificador .IIdentifierGenerator. Esta é uma interface muito simples.

O identificador retornado pelo banco de dados é convertido em um tipo de propriedade usando o Convert.string utiliza uma nova System.NET 27 . Sequência usa uma seqüência em DB2. dado uma seqüência nomeada da base de dados.ChangeType. guid.hex usa o método System. dada uma tabela e coluna (por padrão hibernate_unique_key e next_hi respectivamente) como uma fonte de valores hi. uuid. Qualquer tipo de propriedade integral é suportado. Não utilize este gerador em conxeções fornecidas pelo usuário. O algoritmo hi / lo gera identificadores que são exclusivos apenas para um determinado banco de dados. em PostgreSQL. seqhilo usa um algoritmo hi/lo para gerar identificadores eficientemente de qualquer tipo integral. uuid.Guid e o ToString(string format) para gerar identificadores tipo string . Hilo usa um algoritmo hi/lo de forma eficiente para gerar identificadores integrantes de qualquer tipo. O identificador retornado pela base de dados é convertido ao tipo de propriedade utilizando Convert.comb NHibernate – Persistência de Dados em Plataforma .Guid como o identificador. ORIENT utiliza uma nova System.O tamanho da string retornada depende do formato configurado.ChangeType. usuários do MS SQL e Sybase.Guid para criar um byte [] que é convertido para uma string.Identidade Suporta colunas identidade em DB2. MySQL. em Oracle ou em um gerador em Firebird. Qualquer tipo de propriedade integral é suportado.

asp?p=25862. 9.5.NET 28 . usa o algoritmo para gerar uma nova System. estrangeira usa o identificador de um outro objeto associado. O elemento <composite-id> aceita a propriedade de mapeamentos <key-property> e mapeamentos como elementos filhos <key- many-to-one>. ou Hilo dependendo dos recursos do banco de dados subjacente. </composite-id> Para uma tabela com uma chave composta.informit.1. ou sequence.Guid.. você pode mapear várias propriedades da classe como propriedades do identificador.. Descrito por Jimmy Nilsson no artigo http://www. atribuídas permite que a aplicação atribua um identificador para o objeto antes de salvar(Save()). Normalmente utilizada em conjunto com uma chave primária numa associação <one-to-one>. nativas escolhe identity. <composite-id> <key-property name="MedicareNumber"/> <key-property name="Dependent"/> </ composite-id> NHibernate – Persistência de Dados em Plataforma .. Composite-ID <composite-id name="PropertyName" class="ClassName" unsaved-value="any|none" access="field|property|nosetter|ClassName"> <key-property name="PropertyName" type="typename" column="column_name"/> <key-many-to-one name="PropertyName class="ClassName" column="column_name"/> ...com/articles/article.

defaults para false) "força" o NHibernate especificar os valores permitidos do discriminador mesmo quando estiver todas as instâncias da classe de raiz estiverem recuperadas. Um conjunto restrito de tipos pode ser utilizado: String.1.defaults para String) um nome que indica o tipo NHibernate (3) force (opcional . <discriminator column="discriminator_column" (1) type="discriminator_type" (2) force="true|false" (3) insert="true|false" (4) formula="arbitrary SQL expressi(5)on" /> (1) Column (opcional . (2) type (opcional . TrueFalse. (4) insert (opcional . Byte.6. 9. booleanos. Char. (5) formula (opcional) uma expressão SQL arbitraria é executado quando um tipo tem de ser avaliada. Discriminador O elemento <discriminator> é necessário para persistências polimórficas utilizando a tabela por classe de hierarquia que mapeia a estratégia e declara a coluna discriminador da tabela. Também deve ser Serializable.defaults de property): A estratégia que o NHibernate usa para acessar valor da propriedade. Sua classe persistente deve ter prioridade sobre Equals () e GetHashCode () para executar igualdade de identificador composto. Short. Permite conteúdo baseado em discriminação.NET 29 .defaults para class) o nome da coluna discriminador. Int32. • class (opcional ): Classe componente utilizada como um identificador de composição. Infelizmente. Não existe nenhum "handler(manipulador)" conveniente que não seja o próprio objeto. Você deve instanciar uma instância da classe persistente e povoar as suas próprias propriedades do identificador antes de associar ao estado de persistência load() a uma chave composta. NHibernate – Persistência de Dados em Plataforma . esta abordagem de identificadores composto significa que um objeto persistente é o seu próprio identificador. • name (opcional. A coluna do discriminador contém os valores do marcador que dizem a camada de persistência que instanciou uma subclasse de uma determinada linha. necessário para esta abordagem): Um tipo imóvel de componente que detém o identificadores compostos.defaults para true) é estabelecido o valor false se sua coluna discriminadora também fizer parte de um mapeamento de identificadores compostos. YesNo. • access (opcional .

O atributo force é (apenas) útil se a tabela contém linhas com valores de discriminadores "extras" que não são mapeados para uma classe persistente. NHibernate – Persistência de Dados em Plataforma .'b'.defaults para a propriedade nome): o nome da coluna do banco de dados da tabela mapeada.defaults a verdade): Especifica quais atualizações para esta propriedade exigem ou não uma aquisição de bloqueio otimista.NET 30 .'c').defaults para nunca): Especifica que valor da propriedade está na verdade sendo gerado pela banco de dados. Propriedade O elemento <property> declara uma propriedade da classe persistente . insert (opcional .1. Utilizando o atributo formula você pode declarar expressões arbitrárias SQL que serão utilizados para avaliar o tipo de uma linha: <discriminator formula="case where CLASS_TYPE in ('a'.then 0 else 1 end " type="Int32"/> 9. (6) access (opcional .defaults para true): especifica quais colunas mapeadas devem ser incluídas no SQL UPDATE e / ou declarações INSERT. (3) type (opcional): um nome que indica o tipo NHibernate. (8) generated (opcional . <property name="propertyName" (1) column="column_name" (2) type="typename" (3) update="true|false" (4) insert="true|false" (4) formula="arbitrary SQL expression" (5) access="field|property|ClassName" (6) optimistic-lock="true|false" (7) generated="never|insert|always" (8) /> (1) name: o nome da propriedade de sua classe. Isto normalmente não vai ser o caso.7. As propriedades computadas não têm um mapeamento de colunas próprias.Valores reais da coluna discriminadora são especificados pelo valor do atributo discriminator-value e pelos elementos <class> e <subclass>.defaults para property): Deve ser usada para acessar a valor da propriedade. (2) column (opcional . (5) formula (opcional): expressão SQL que define o valor de uma propriedade computed. (7) otimista-lock (opcional . (4) update.

O NHibernate acessará o campo diretamente ao definir o valor e usará a Nosetter propriedade obtendo o valor.CreateInstance(string NHibernate – Persistência de Dados em Plataforma . Object. você poderá criar sua própria estratégia através ClassName da interface de implementação NHibernate. por exemplo). O NHibernate usa get/set ajustado à propriedade. com exceção dos tipos de atributos (a menos que você defina os atributos assembly e/ou namespace do elemento <hibernate-mapping> ). Byte [].).naming-strategy. Se as estratégias de acesso construídas pelo Nhibernate não forem adequadas para a situação. • O nome de um tipo . Note que você tem que especificar nomes assembly-qualified para todos os tipos.Char. Nenhum estratégia de nomeação deve ser usada como a estratégia de property acesso porque o valor do atributo name é o nome da propriedade. • O nome de um tipo enumeração (por exemplo. System. timestamp. System. • O nome de um tipo SERIALIZABLE. • O nome da classe de tipos personalizados (ex.. String.MyCustomType). O NHibernate usa o valor do atributo name como o nome do campo.Property.NET 31 .Single. .. char.Byte [].. Illflow.typename poderia ser: • O nome de tipo básico NHibernate (por exemplo.Int16. System.Type.). System. O NHibernate acessará o campo diretamente. O valor do atributo de acesso dever ser um nome assembly-qualified que pode ser carregado com o Activator. Int32.NET com um padrão básico de tipo (por exemplo. NET 2. Isto pode ser usado quando os field métodos get e set de uma propriedade contêm ações extras que você não quer que ocorram quando o NHibernate estiver preenchendo ou lendo o objeto.DateTime. O valor do atributo access deve ser um texto formatado como access-strategy. .String. Eg..0 Nullabels. NET. A . O atributo access permite que você controle como o NHibernate terá acesso ao valor da propriedade no momento da execução. DateTime.naming-strategy nem sempre é necessária. System. O NHibernate suporta tipos . System. Tabela: Estratégias de Acesso Nome da estratégia de Descrição acesso Implementação Default. Single.IPropertyAccessor.Color.

. O atributo name é prefixado com o caracter m e um underline para underscore encontar o campo <property name="Foo" . >. Nome da estratégia de Descrição acesso assemblyQualifiedName). >. O atributo name é convertido para lowercase para encontrar o campo lowercase foobar usando <property name="FooBar" .. Tabela: Naming Strategies Naming Strategy Descrição Name O atributo name é convertido para camel case para localizar o campo camelcase usando o campo foo <property name="Foo" .) <many-to-one name="PropertyName" column="column_name" class="ClassName" cascade="all|none|save-update|delete" fetch="join|select" update="true|false" NHibernate – Persistência de Dados em Plataforma . O modelo relacional é uma associação many-to-one.. > O atributo name é convertido para pascalcase e prefixado com um pascalcase- underline para encontrar o campo foobar usando <property underscore name="FooBar" . 9....NET 32 .1.. O atributo name é prefixado com o caracter m para o campo <property pascalcase-m name="Foo" . many-to-one Uma associação comum para outra classe persistente é declarada usando um elemento de many-to-one. O atributo name é convertido para lowercase para encontrar o campo underscore foobar usando <property name="FooBar" ... (É apenas uma referência do objeto. > lowercase... pascalcase-m. >. > usando campo mFoo . O atributo name é convertido para camel case e prefixado com um camelcase- símbolo underline usando o campo _foo para localizar o <property underscore name="Foo" .... > usando campo m_Foo .8.

9.NET 33 . <one-to-one name="Person" class="Person"/> <one-to-one name="Employee" class="Employee" constrained="true"/> NHibernate – Persistência de Dados em Plataforma . insert="true|false" property-ref="PropertyNameFromAssociatedClass" access="field|property|nosetter|ClassName" unique="true|false" optimistic-lock="true|false" not-found="ignore|exception" /> 9. se duas linhas estão relacionadas pela associação. Portanto. one-to-one Uma associação um-para-um para outra classe persistente é declarada usando um elemento de um-para-um <one-to-one name="PropertyName" class="ClassName" cascade="all|none|save-update|delete" constrained="true|false" fetch="join|select" property-ref="PropertyNameFromAssociatedClass" access="field|property|nosetter|ClassName" /> Há duas variedades de associação um-para-um: • associação de chaves primárias • associações exclusivas de chave externas Para associações de chave primárias não é necessário uma coluna extra na tabela. adicione os seguintes mapeamentos para Employee e Person. então. as linhas das duas tabelas compartilham o mesmo valor de chave-primária. respectivamente. você deve certificar-se de que eles recebem o mesmo valor identificador! Para uma associação de chave primária.1. se você desejar ter dois objetos se relacionando por uma associação de chave primária.

2. Tipos System..Object podem armazenar valores nulos.Object e tipos System.1 char Default quando o tipo Boolean System. </subclass> 9. Para a estratégia de mapeamento table-per-class-hierarchy (recomendável) é usada a declaração <subclass>.. subclass Finalmente. <subclass name="ClassName" (1) discriminator-value="discriminator_value" (2) proxy="ProxyInterface" (3) lazy="true|false" (4) dynamic-update="true|false" dynamic-insert="true|false"> <property .ValueType NHibernate .NET 34 .1. tipos System.Object de objetos grandes.Byte DbType. Assim como os tipos .2.NET. NHibernate Types 9.NET Type Database Type Remarks Type DbType.Byte do atributo não for especificado. a persistência polimórfica requer a declaração de cada subclasse da classe persistente raiz.1. Tabela : Tipos de mapeamento System..ValueType não podem armazenar valores null ..AnsiStringFixedLeng AnsiChar System. Char System. Default quando o tipo NHibernate – Persistência de Dados em Plataforma . Tipos Básicos Os tipos básicos podem ser categorizados aproximadamente em três grupos . Default quando o tipo Byte System.10.Boolean do atributo não for especificado.Boolean DbType.Char th ..tipos System.ValueType. colunas para tipos System.. /> .Char DbType.StringFixedLength ..9.

.NET Type Database Type Remarks Type 1 char do atributo não for especificado. Default quando o tipo Decimal System. Default quando o tipo Int32 System. The UnderlyingType of the Enum is used to determine the correct DbType . Default quando o tipo Single System.Guid DbType.Single do atributo não for NHibernate – Persistência de Dados em Plataforma .Int64 DbType.Int32 do atributo não for especificado.Double DbType. Default quando o tipo Int16 System. Default quando o tipo Guid System. Instead specify the Assembly Qualified Name of the Enum or PersistentEnu The DbType for the A System. Default quando o tipo System.Double do atributo não for especificado.Int32 DbType.Int16 DbType. Do not specify type="PersistentEnu m" in the mapping.Single DbType. Default quando o tipo Double System.NHibernate . Reflection to "guess" the Type.Guid do atributo não for especificado.DateTim DbType.DateTime ..ignores DateTime do atributo não for e the milliseconds especificado.Int64 do atributo não for especificado.Decimal DbType. Default quando o tipo Int64 System..Int16 do atributo não for especificado.Decimal do atributo não for especificado.NET 35 .Enum let NHibernate use m underlying value.

Int64 e especificado Default quando o tipo System.String tipo do atributo Tipo System. Default quando o tipo do atributo Binary System.TimeSpa TimeSpan DbType.String DbType.as type="Timestamp" Timestamp e specific as database supports.DateTim type="Ticks" deve ser Ticks DbType.String não for especificado NHibernate – Persistência de Dados em Plataforma .NHibernate . System.5 tipo do atributo CultureInfo System.Int64 do atributo não for n especificado.Type holding Assembly não for Qualified Name.DateTime . System.1 char either 'T' or 'F' deve ser especificado.Globalization. DbType.Binary não for especificado.1 char either 'Y' or 'N' ser especificado Tabela Tipos de mapeamento System.AnsiStringFixedLeng type="TrueFalse" TrueFalse System. Default quando o DbType. DbType.NET Type Database Type Remarks Type type="AnsiString" AnsiString System.Byte[] DbType.Boolean th .AnsiStringFixedLeng type="YesNo" deve YesNo System.DateTim DbType.String DbType.String .Boolean th . Default quando o tipo do atributo String System. especificado.NET Type Database Type Remarks Type especificado.AnsiString deve ser especificado Default quando o DbType.CultureInfo chars for culture não for especificado.Object NHibernate .NET 36 . deve ser especificado.

String especificada.Binary especificada. NHibernate pode ser encontrado para a propriedade.NET 37 . private ISet parts = new HashedSet(). Este é o tipo de Serializable is marked with DbType.Object that especificado.String DbType. 10. } set { parts = value.Binary fallback se nenhum tipo SerializableAttribute.NET Type Database Type Remarks Type type="StringClob" deve ser StringClob System. } } } NHibernate – Persistência de Dados em Plataforma . O campo inteiro é lido na memória type="BinaryBlob" deve ser BinaryBlob System.Byte[] DbType. public ISet Parts { get { return parts. } } public string SerialNumber { get { return serialNumber. Mapeando coleções O NHibernate exige que campos collections-value persistentes sejam declarados como um tipo de interface. O campo inteiro é lido na memória type="Serializable" Deve ser Any System. } set { serialNumber = value. por exemplo: public class Product { private string serialNumber.Tabela: Tipos de mapeamento Large Object NHibernate .

. /> <index . System.Collections. Basicamente. System.. System.IList<T>.Collections.. /> <element ..IList. Para exemplificar o conceito de transações. System.Generic..IDictionary<K. <map>.Collections.ICollection. Isso significa dizer que todas as etapas pertencentes a uma transação são completamente finalizadas ou nenhuma delas termina. Transações Uma transação é uma unidade de execução indivisível (ou atômica). System. <list>.ICollection<T>. System.A interface real pode ser Iesi.Collections.Collections.NET 38 . O <map> é representativo: <map name="propertyName" table="table_name" schema="schema_name" lazy="true|false" inverse="true|false" cascade="all|none|save-update|delete|all-delete-orphan" sort="unsorted|natural|comparatorClass" order-by="column_name asc|desc" where="arbitrary sql where condition" fetch="select|join" batch-size="N" access="field|property|ClassName" optimistic-lock="true|false" generic="true|false" > <key ..Collections..Collections.00 da conta corrente do cliente A para a conta corrente do cliente B.. seria necessário seguir os seguintes passos: 1º) Ler o saldo da conta corrente A (xA) NHibernate – Persistência de Dados em Plataforma .Collections.00 da conta corrente do cliente A 2º) Creditar R$ 150.ISet. <array> e <primitive-array>..Generic.Generic. /> </map> 11.00 na conta corrente do cliente B Para a efetivação da transação descrita acima. Iesi. V>.IDictionary. as operações que compõem a transação são: 1º) Debitar R$ 150.ISet<T> ou… qualquer coisa que você gostar! As coleções são declaradas pelos elementos <set>.<bag>.Generic. considere um exemplo clássico de transferência entre contas bancárias: transferir R$ 150.

2º) Calcular o débito de R$ 150.00) 6º) Gravar na base de dados o novo saldo da conta corrente B (xB = dB) Caso ocorra algum problema (por exemplo: falta de energia. A transação pode ter dois fins: commit ou rollback.00 e ainda não teria sido creditado R$ 150. a unicidade do processo. todas as modificações nos dados realizadas pelas operações presentes na transação são salvas. nenhuma transação deve influenciar nas outras. Resumindo. esses seis passos devem ser executados dentro de uma transação. garantindo assim. Dessa maneira.00 na conta corrente B (dB = xB + 150. a execução dos passos anteriores pode ser interrompida. deve continuar com um estado válido. Quando a transação sofre commit. Para que um banco de dados garanta a integridade dos seus dados deve possuir quatro características. por exemplo. houvesse interrupção logo após a execução do 3º passo. Neste caso. R$ 150.NET 39 . todas as modificações nos dados realizadas pelas operações presentes na transação são desfeitas. deve-se garantir também que os passos já executados serão desfeitos. falha no programa. na ocorrência de erro em alguma das operações dentro da transação todas as operações realizadas desde o início podem ser revertidas e as alterações no banco de dados desfeitas. mesmo havendo falhas no sistema após a sua finalização. é de suma importância garantir que esses seis passos sejam totalmente executados. Para garantir a consistência do banco.).00) 3º) Gravar na base de dados o novo saldo da conta corrente A (xA = dA) 4º) Ler o saldo da conta corrente B (xB) 5º) Calcular o crédito de R$ 150.00 teriam “sumido” da conta A sem destino. etc. uma transação garante que a seqüência de operações dentro da mesma seja executada de forma única. o banco de dados estaria em um estado inconsistente. • Consistência: após a execução de uma transação. falha no computador. a conta A teria um débito de R$ 150. Resultados parciais de uma transação não devem ser “vistos” por outras transações executadas concorrentemente.00 da conta corrente A (dA = xA – 150. Se. Caso haja alguma falha antes da conclusão do último passo. afinal. ou seja. conhecidas como ACID: • Atomicidade: o banco de dados deve garantir que todas as transações sejam indivisíveis. de forma que ou todos os passos são executados ou todos os passos não são executados.00 na conta corrente B. Quando a transação sofre rollback. ou seja. NHibernate – Persistência de Dados em Plataforma . • Isolamento: mesmo que várias transações ocorram paralelamente (ou concorrentemente). o banco de dados deve continuar consistente. já que ela é uma unidade de execução atômica. • Durabilidade: após a finalização de uma transação. todas as alterações feitas por ela no banco de dados devem ser duráveis.

desfazer a sub-transação. Esse modelo permite que duas transações sejam unidas em uma só. são validadas e não podem mais ser desfeitas. iniciar uma outra sub-transação. Em outras palavras. • Nested Transaction. Os resultados do conjunto de transações só serão visíveis ao final da execução de todas elas. O contrário não é verdadeiro. A Figura abaixo ilustra esses conceitos. Se houver algum erro durante a execução de algumas das suas operações. de seu fim e das ações que devem ser tomadas na ocorrência de falhas são feitas através de um modelo de transação. ou seja. é possível saber a partir de qual operação a transação é iniciada e em qual operação ela finalizada. Também conhecido como Modelo de Transações Encadeadas. Este modelo. • Flat Transaction. Os limites das operações de uma transação devem ser demarcados. Nested Transactions. de forma que todos os recursos passam a ser compartilhados. Ao final da execução da última operação que pertence à transação.NET 40 .2 Transações e Banco de Dados Uma transação de banco de dados é formada por um conjunto de operações que manipulam os dados. A propriedade de atomicidade é válida para as sub-transações. também conhecido como Modelo de Transações Aninhadas. Uma transação encadeada consiste em um conjunto de sub-transações executadas seqüencialmente. Se uma transação for interrompida. um commit é realizado. Além disso. todas as alterações no banco de dados realizadas pelas operações que compõe a transação devem ser confirmadas. já que se uma sub-transação for abortada a transação que a engloba pode: ignorar o erro. ou seja. todas as suas sub-transações também serão. 11. todas as operações da transação que já foram executadas devem ser desfeitas. todas as operações dentro da transação são tratadas como uma única unidade de trabalho.11. possibilita que uma transação possa ser formada por várias sub-transações. Conhecida como modelo de transações planas por apresentar uma única camada de controle. Chained Transactions e Join Transactions. • Chained Transaction. Modelo mais utilizado pela maioria dos Sistemas Gerenciadores de Banco de Dados (SGBD) e Gerenciadores de Transações. Existem diversos modelos encontrados na literatura. uma transação não pode ser validada até que todas as suas sub-transações tenham sido finalizadas. ou seja. Assim. um rollback é realizado. em que à medida que as sub-transações vão sendo executadas. A atomicidade de uma transação é garantida por duas operações: commit e rollback. uma única transação pode ser dividida em diversas unidades de trabalho. • Join Transaction. Nesta seção serão abordados apenas quatro: Flat Transactions. esse modelo tem como objetivo desfazer as operações de uma transação em caso de erro com a menor perda de trabalho possível. com cada unidade operando independente uma das outras.1 Modelos de Transações As definições do início de uma transação. NHibernate – Persistência de Dados em Plataforma .

o seu valor final corresponderá a 5. significando que as alterações feitas por T1 foram descartadas. Em seguida. Estados do sistema durante uma transação 12. Para exemplificar. T1 soma o valor x que leu com 1 e o valor de x para T1 passa a ser 3 (2 + 1). Ambas as transações vão manipular esse mesmo dado com operações diferentes e atualizá-lo na base de dados. Como não há controle de concorrência de acesso ao dado x. ambas as transações lêem o dado x com o mesmo valor (2). respectivamente. Exemplo de Transações Concorrentes NHibernate – Persistência de Dados em Plataforma . o valor calculado por T2. Por fim. Concorrência Em algumas situações pode acontecer que duas ou mais transações que ocorrem paralelamente leiam e atualizem o mesmo dado. ambos T1 e T2 gravarão os novos valores de x calculados na base de dados.NET 41 . No primeiro passo. soma o valor de x lido a 3 e x passa a ter o valor 5 (2 + 3). Já T2. ou seja. a Listagem abaixo apresenta um exemplo de duas transações concorrentes manipulando o mesmo dado x. Considerando que duas transações leiam um mesmo dado x quase que simultaneamente.

Cat Na maioria das vezes. você precisará atribuir um alias.NET 42 . Mas Não seja enganado pela sintaxe: HQL é totalmente orientada a objeto. 13. Este manual usa palavras-chave HQL em minúsculo.Cat as cat NHibernate – Persistência de Dados em Plataforma . deve-se implementar o mecanismo de Locking. mas encontramos essa convenção quando incorporamos no código Java. 13. pois você irá deseja se referir à Cat em outras partes da consulta. esse dado será bloqueado (nenhuma outra transação poderá lê-lo) até que T1 o libere.Cat Esse script retorna todas as instâncias da classe Eg. from Eg. um erro de violação de concorrência deve ser gerado. normalmente após a sua atualização. HQL – a linguagem de consulta hibernate O Nhibernate é equipado com uma linguagem de consulta extremamente poderosa e que (intencionalmente) parece muito como SQL. Alguns usuários fazem consultas com palavras-chave maiúsculas. O gerenciamento de locking e da concorrência pode ser feito de duas formas: • Pessimista: utilizar o controle pessimista significa que se uma transação T1 lê um dado e tem a intenção de atualizá-lo. • Otimista: utilizar o controle otimista significa que se T1 lê e altera um dado ele não será bloqueado durante o intervalo entre a leitura e atualização.NET. Caso uma outra transação T2 tenha lido esse mesmo dado antes de T1 o atualizá-lo tente alterá-lo em seguida na base de dados. deve-se controlar o acesso concorrente ao dado. Para evitar a situação descrita anteriormente. polimorfismo e associação 13. e utiliza noções de herança.1 Case-Sensitive Consultas são case-sensitive. SeLeCT é o mesmo que SElect e o mesmo que selecT.2 A cláusura FROM A consulta mais simples possível do NHibernate é: from Eg. exceto para nomes de classes e propriedades . Portanto. ou seja.

Cat cat Coleções também podem aparecer dentro funções agregadas na cláusula select. select cat.5 Funções Agregadas Consultas HQL ainda podem retornar os resultados das funções agregadas nas propriedades: select avg(cat.Parameter param O tipos de associações join são suportados pelo ANSI SQL • inner join • left outer join • right outer join • full join 13.Cat cat group by cat NHibernate – Persistência de Dados em Plataforma .NET 43 .Cat as cat inner join cat.Kittens as kitten from Eg.Cat as cat left join cat. count(cat) from Eg.3 Associações e junções Nós também podemos atribuir aliases para entidades associadas.Weight).Weight). 13. count( elements(cat.Mate.Mate as mate 13.Mate as mate left outer join cat.Cat as cat inner join cat.Weight).4 A cláusura select A clausura select retorna todos os objetos e propiedades que foram definidos na consulta. ou mesmo a elementos de uma coleção de valores. select mate from Eg. sum(cat.Kittens as kittens from Formula form full join form. max(cat.Kittens) ) from Eg. usando um join. from Eg.

.Name 13. from Eg...Named m where n.Cat cat 13.. min(.Cat cat select count(distinct cat..NET 44 . max(.Name='Fritz' retorna instâncias do Cat chamado "Fritz"..Name).. sum(. Eg..)..) count(*) count(. A consulta irá retornar instâncias de todas as classes persistentes que estendem essa classe ou implementam a interface. from Eg..Object o A interface IName pode ser implentada por varias classes persistentes. mas também da subclasses DomesticCat.Named n.. As funções suportadas são: avg(.).7 Cláusura WHERE A cláusula where lhe permite estreitar a lista de instâncias retornadas.. Talvez as consultas Consultas NHibernate podem nomear algumas classes e interfaces .6 Consultas Polimórficas Uma consulta como: from Eg.Cat as cat where cat.) O distinct e all também podem ser usados e tem a mesma semântica do SQL.Cat as cat Retorna as instâncias não só do Cat.NET na cláusula FROM. count(all..Name = m. A seguinte consulta retornaria todos os objetos persistentes: from System. select distinct cat.)..Name from Eg. NHibernate – Persistência de Dados em Plataforma . count(cat) from Eg. count(distinct .).).

mas também casos: from Eg.Cat as cat where cat. há o suporte a operadores matemáticos (+.Cat cat.Name is not null Esta pergunta traduz em uma consulta SQL com uma tabela (inner) aderirida. como SQL.Foo foo.Mate. not between.Address. (Você também pode utilizar a propriedade name.City is not null você iria terminar com uma consulta que exigiria quatro tabelas agrupadas no SQL.Bar.Foo foo where foo. Não é necessário aderir uma tabela! 13.select foo from Eg. >=.Bar bar where foo.StartDate = bar.id = 123 from Eg.Customer.Mate. O operador “= “ pode ser usado para comparar não apenas propriedades. NHibernate – Persistência de Dados em Plataforma .Cat rival where cat. Se você for escrever algo como from Eg.id = 69 A segunda consulta é eficiente. and e parênteses para agrupar expressões).Cat as cat where cat. Eg. =.8 Expressões Em HQL. -.Cat mate where cat.Mate select cat. Considere: from Eg. operadores de comparação (<. * e /). o operador LIKE e o símbolo ‘%’ também podem ser utilizados para pesquisas em String.Mate = rival.Baz. mate from Eg. <>.Cat cat. between. Composto de expressões podem tornar a cláusula WHERE extremamente poderosa.) from Eg.Date irá retornar todas as instâncias do Foo para a qual existe um instância de Bar com uma propriedade data igual à propriedade StartDate do Foo. além de poder ordenar sua pesquisa em ordem descendente ou ascendente.Mate = mate A propriedade especial (lowercase) id pode ser utilizada para referenciar um identificador a um único objeto. operadores lógicos (or.NET 45 .Cat cat where cat. Eg. <=. >. Eg. in e not in).

o NHibernate suporta subconsultas em consultas. mesmo correlacionadas subconsultas (subconsultas que se referem a um alias na consulta externa). avg( elements(foo.Color.Birthdate Os indicadores ASC e DESC são opcionais 13.Name asc. max( indices(foo.DomesticCat as cat NHibernate – Persistência de Dados em Plataforma .9 A cláusura Group By A consulta que retorna valores agregados podem ser agrupados por propriedades de uma classe ou componentes.NET 46 .Cat cat group by cat.Name as name ) from Eg.Foo foo group by foo.Color select foo.Weight > ( select avg(cat.NickName from Eg. mesmo me bancos de dados sem subselects.Weight desc.Cat as fatcat where fatcat. 13.Names) ) from Eg.Name = some ( select name. Uma subconsulta deve estar entre parênteses (geralmente por uma chamada de função agregada SQL).11 Subqueries Para bancos de dados que oferecem suporte ao subselects.Cat as mate where mate.DomesticCat cat ) from Eg.Names) ). from Eg.Mate = cat ) from Eg.DomesticCat as cat where cat.id Nota: Você pode usar os contrutores elements e índices dentro da cláusura select. count(cat) from Eg.DomesticCat cat order by cat. cat. sum(cat.Cat as cat where not exists ( from eg.10 A cláusura Order By A lista retornada por uma consulta pode ser ordenada por qualquer propriedade de uma classe ou componentes from Eg.Weight) from Eg.13. cat. select cat.Weight).id.

NickName from Eg. "Fritz%") ) . NHibernateUtil. 14.List(). minWeight. crit. Esta abordagem permite definir restrições dinamicamente sem que haja manipulação de Strings. a sua flexibilidade e poder é bem menor do que HQL e não suporta agregações nem projeções.List().CreateCriteria(typeof(Cat)) . 14.Like("Name".SetMaxResults (50). O ISession é uma fábrica para ICriteria instâncias.where cat.1.Name as name ) 14.Add( Expression.List = (). Lista Cats crit.CreateCriteria (typeof (Cat)).NET 47 .Name) like lower(".String ).1 Criteria com restrição IList cats = sess. NHibernate – Persistência de Dados em Plataforma . 14.CreateCriteria(typeof(Cat)) .ICriteria representa uma consulta particular contra uma classe persistente. new StringSqlType()).2 Criteria com restrições Like // Create a string parameter for the SqlString below Parameter paramName = new Parameter("someName". Criteria A API Query By Criteria (QBC) permite realizar consultas por manipulação de critérios em tempo de execução. ICriteria crit = sess.1 Criando uma instância ICriteria A interface NHibernate.Add( Expression.1.Sql( new SqlString( new object[] { "lower({alias}. maxWeight) ) . paramName.Name not in ( select name. IList cats = sess.Add( Expression. ")" } ).Between("Weight". "Fritz%".

List(). Native SQL Queries Você também pode expressar consultas no dialeto SQL nativo de seu banco de dados.NET direto para NHibernate. sqlQuery.CreateSQLQuery(sql.CreateCriteria(typeof(Cat)) . 14.NET 48 .sex as {cat.name as {cat. Consultas nomeadas SQL NHibernate – Persistência de Dados em Plataforma .SetInt64("catId". IList cats = sess. 15.List().Mate}.SetMaxResults(50) .AddOrder( Order.Weight}.Add( Expression.Add( Expression.CreateCriteria(typeof(Cat)) . Isso também permite um caminho de migração de limpeza a partir de um aplicativo com base em SQL/ADO.Like("Name". "F%") ) . catId) .mateid as {cat.3 Associações Faça associações usando CreateCriteria().Like("Name".Add( Expression. " + " cat. Isso é útil se você deseja utilizar recursos específicos do banco de dados.CreateSQLQuery("select {cat.Expression. cat.1 Criando uma consulta(IQuery) baseada em SQL IQuery sqlQuery = sess.Name}" + " from cat_log cat where {cat.SetMaxResults(50).Desc("Age") ) . 16.originalId as {cat. " + " cat.AddOrder( Order.Like("Name". "F%") .CreateCriteria("Kittens") .Sex}. 15. "F%") . IList cats = sqlQuery. typeof(Cat)). como a palavra-chave CONNECT no Oracle.2 Referências de alias e propriedade string sql = "select cat.Order.*} from cats {cat}". IList cats = sess.2 Ordenando o resultado Você pode ordenar o resultado usando o Hibernate. typeof(Cat)) .List().List().weight*10 as {cat. 15. cat.Mate} = :catId" IList loggedCats = sess. "cat".Asc("Name") ) . "cat".14.Id}.

<sql-query name="mySqlQuery"> <return alias="person" class="Eg.NAME AS {person.GetNamedQuery("mySqlQuery") .Name}.NAME LIKE 'Hiber%' </sql-query> NHibernate – Persistência de Dados em Plataforma . {person}.Age}. {person}.NET 49 .AGE AS {person.Sex} FROM PERSON {person} WHERE {person}.Person. IList people = sess.SEX AS {person. Eg"/> SELECT {person}.SetMaxResults(50) .Consultas Nomeadas SQL podem ser definidas no documento de mapeamento e chamadas exatamente da mesma maneira como uma consulta HQL nomeada.List().

br/Artigo.hibernate.hibernate.ufrn.com.dca.Referências: http://www.NET 50 .linhadecodigo.aspx?id=546 NHibernate – Persistência de Dados em Plataforma .2/reference/en/html/ www.org ftp://raphaela:web@users.pdf Guia Inicial do Nhibernate: www.org/hib_docs/nhibernate/1.br/UnP2007/Hibernate_Anotacoes.