O Hibernate Query Language (HQL) é uma linguagem de consulta orientada a objetos semelhante à SQL, mas não operações em tabelas e colunas. O HQL é adequado para objetos persistentes e suas propriedades. As consultas HQL são convertidas do Hibernate para as consultas SQL tradicionais, que executam operações no banco de dados no círculo.
Embora seja possível usar o SQL nativo diretamente com instruções SQL e hibernar, é recomendável usar o HQL para evitar o incômodo da portabilidade do banco de dados o máximo possível e adotar as vantagens da geração e das estratégias de cache do SQL do Hibernato.
Palavras-chave como selecionar, de e onde são sensíveis ao minúsculas, mas propriedades como nomes de tabela e nomes de colunas são distinguidas no HQL sensível.
Da declaração
Use a cláusula de From se desejar carregar um objeto persistente completo na memória. Aqui está uma sintaxe simples usando a cláusula de From:
String hql = "do funcionário"; Query Query = session.CreateQuery (HQL); List Results = query.List ();Se você precisar qualificar totalmente um nome de classe no HQL, basta especificar o seguinte pacote e nome da classe:
String hql = "de com.hibernatebook.criteria.employee"; query query = session.createquery (hql); list Results = query.list ();
Como declaração
A cláusula AS pode ser usada para alocar alocadas às consultas HQL em uma classe, especialmente quando há consultas muito longas. Por exemplo, nossos breves exemplos acima são os seguintes:
String hql = "do funcionário como e"; Query Query = session.createQuery (hQL); list Results = query.list ();
A palavra -chave AS é opcional e você também pode especificar um alias diretamente no nome da classe subsequente, como mostrado abaixo:
String hql = "do funcionário e"; Query Query = session.createQuery (hQL); list Results = query.list ();
Selecione Cláusula
A cláusula SELECT fornece mais controle do que o conjunto de resultados da cláusula From. Se você deseja obter várias propriedades do objeto em vez de todo o objeto, use a cláusula Select. Aqui está uma sintaxe simples para usar uma instrução SELECT para obter o objeto do funcionário apenas primeiro_name Field:
String hql = "Selecione e.FirstName do funcionário e"; Query Query = session.CreateQuery (HQL); List Results = query.List ();
Vale a pena notar que aqui, funcionário. Firstname é um atributo do objeto do funcionário, não um campo da tabela de funcionários.
Onde cláusula
Se você deseja restringir o objeto específico retornado do armazenamento, pode usar a cláusula WHERE. Aqui está uma sintaxe simples usando a cláusula WHERE:
String hql = "do funcionário e onde e.id = 10"; Query Query = session.createQuery (HQL); List Results = query.list ();
Ordem por cláusula
Para classificar os resultados de uma consulta HQL, você precisará usar o pedido por cláusula. Você pode classificar os resultados em ascensão (ASC) ou descendente (DEC) no conjunto de resultados, classificando os resultados em qualquer atributo do objeto. Aqui está uma sintaxe simples usando o pedido por cláusula:
String hql = "do funcionário e onde e.id> 10 pedidos por e.salary desc"; Query Query = session.createquery (hQL); list Results = query.list ();
Se você deseja classificar por mais de uma propriedade, basta adicionar propriedades adicionais ao final do comando separado por uma cláusula com vírgulas, como mostrado abaixo:
String hql = "do funcionário e onde e.id> 10" + "ordem de e.firstname desc, e.salary desc"; Query query = session.createquery (hql); list Results = query.list ();
Grupo por cláusula
Esta cláusula permite a extração de informações do banco de dados e do grupo de valores baseados em atributos da Hibernate e geralmente usa o resultado para incluir o valor total. Aqui está uma sintaxe simples usando o grupo por cláusula:
String hql = "Selecione Sum (e.salary), e.firtName do grupo E" + "Grupo por e.FirstName"; Query Query = Session.CreateQuery (HQL); List Results = query.List ();
Use parâmetros nomeados
O Hibernate é suportado em seus parâmetros de consulta HQL. Isso facilita escrever e aceitar informações dos usuários sem precisar se defender contra consultas HQL em ataques de injeção de SQL. Aqui está uma sintaxe simples usando parâmetros nomeados:
String hql = "do funcionário e onde e.id =: funcionário_id"; query query = session.createquery (hql); query.setParameter ("funcionário_id", 10); list Results = query.list (); Cláusula de atualização
As atualizações de lote são novas HQL com o Hibernate3 e o trabalho de exclusão diferente, o mesmo que o Hibernate 3 e o Hibernate2. A interface de consulta agora contém um método chamado ExecuteUpDate () para executar uma instrução HQL Update ou Excluir.
A cláusula de atualização pode ser usada para atualizar uma ou mais propriedades em um ou mais objetos. Aqui está uma sintaxe simples usando a cláusula de atualização:
String hql = "Atualizar salário do conjunto de funcionários =: Salário" + "onde id =: funcionário_id"; Query Query = session.createQuery (hQL); query.setParameter ("salário", 1000); consulso.fetParameter ("funcionário_id", 10); Cláusula de exclusão
A cláusula de exclusão pode ser usada para excluir um ou mais objetos. Aqui está uma sintaxe simples usando a cláusula de exclusão:
String hql = "Excluir do funcionário" + "onde id =: funcionário_id"; Query Query = session.createquery (hql); query.setParameter ("funcionário_id", 10); int resultado = query.executeUpdate (); system.out.println ("linhas afetadas:" + resultado); Inserir cláusula
O HQL suporta inserção em cláusulas onde apenas os registros podem ser inseridos de um objeto para outro. Aqui está uma sintaxe simples usando a inserção na cláusula:
String hql = "inserir em funcionário (primeiro nome, último nome, salário)" + "selecione primeiro nome, último nome, salário de Old_employee"; Query Query = session.CreateQuery (HQL); int resultado = query.executeUpdate (); System.out.Println ("ROWS AFFERTAS:" + Método de agregação
O HQL suporta vários métodos de agregação, semelhantes ao SQL. Eles trabalham no HQL da mesma maneira no SQL e na lista a seguir dos recursos disponíveis:
A palavra -chave distinta calcula apenas valores exclusivos definidos nesta linha. A consulta a seguir retornará apenas uma contagem única:
String hql = "Selecione contagem (distinto e.FirstName) do funcionário e"; Query Query = session.CreateQuery (HQL); List Results = query.List ();
Usando a paginação de consulta
Existem dois métodos para interfaces de consulta de paginação.
Juntos, você pode criar um componente de paginação em um site ou aplicativo de balanço. Aqui está um exemplo, você pode estendê -lo para obter 10 linhas:
String hql = "de funcionário"; query query = session.createquery (hql); query.setfirstresult (1); query.setMaxResults (10); list Results = query.list ();
Critérios de consulta
O Hibernate fornece uma maneira alternativa de operar objetos e dados sequencialmente disponíveis na tabela RDBMS. Um dos métodos é a API padrão, que permite estabelecer uma programação padrão de objeto de consulta que pode aplicar regras de filtragem e condições lógicas.
A interface da sessão do Hibernate fornece uma instância de uma classe que pode ser usada para criar um objeto persistente retornado, e o aplicativo executa uma consulta condicional para o método CreateCritereria ().
A seguir, é apresentado um exemplo de uma consulta condicional mais simples que simplesmente retornará cada objeto correspondente à classe de funcionários.
Critérios Cr = session.createcriteria (funcionário.class); list Results = cr.list ();
Limitações e padrões:
Você pode usar o método add () para adicionar consulta de restrição usando o objeto Critérios. Aqui está um exemplo de adicionar um limite com um registro de retorno salarial igual a 2000:
Critérios Cr = session.createcriteria (Employee.class); cr.add (restrições.eq ("Salário", 2000)); List Results = Cr.List ();Aqui estão alguns exemplos que cobrem diferentes cenários e podem ser usados conforme necessário:
Critérios cr = session.createcriteria (funcionário.class); // para obter registros com salário superior a 2000cr.add (restrições.gt ("salário", 2000)); // para obter registros com salário inferior a 2000cr.add (restrições.LT ("Salário", 2000)) // para obter registros de registros ("," Salário ", 2000); zaracr.add (restrições.like ("primeironame", "zara%")); // forma sensível ao caso da restrição acima. nullcr.add (restrições.isnull ("salário")); // para verificar se a propriedade especificada não é nullcr.add (restrições.isnotnull ("salário")); // para verificar se a propriedade fornecida se não é a dada propriedades (restrições. emptycr.add (restrições.isnotempty ("Salário")); Você pode criar e / ou ORS para usar o LogicalExpression para restringir as seguintes condições: Critérios Cr = session.createcriteria (employee.class); Salário do critério = restrições.gt ("Salário", 2000); Nome do critério = restrições. cr.list ();Embora todas as condições acima possam ser introduzidas diretamente usando o HQL no tutorial anterior.
Padrões de uso de paginação:
Existem também interfaces padrão, dois métodos de paginação.
Juntamente com os dois métodos acima, podemos criar um componente de paginação em nosso site ou aplicativo de swing. Aqui está um exemplo, que pode ser estendido para obter 10 linhas de cada vez:
Critérios Cr = session.createcriteria (Employee.class); cr.setfirstresult (1); cr.setMaxResults (10); List Results = Cr.List ();
Classificar os resultados:
A API padrão fornece a classe Org.Ibernate.Critrion.Erder Classing Classificação do seu conjunto de resultados em ordem ascendente ou descendente, de acordo com as propriedades do objeto. Este exemplo demonstra como classificar usando o conjunto de resultados da classe de ordem:
Critérios cr = session.createcriteria (funcionário.class); // para obter registros com vendas mais de 2000cr.add (restrições.gt ("salary", 2000)); // para classificar registros em ordem descendente); Previsão e agregação:
A API de critérios fornece uma classe org.hibernate.critriot.projeções que podem ser usadas para obter os valores de atributos médios, máximos ou mínimos. A classe de projeções é semelhante à limitação de classe, pois fornece vários métodos de fábrica estática para obter instâncias de projeção. Fornece o
Aqui estão alguns exemplos envolvendo diferentes esquemas que podem ser usados conforme prescrito:
Critérios cr = session.createcriteria (funcionário.class); // para obter contagem total de linhas.cr.setProjection (projection.rowCount ()); // para obter a média de uma propriedade.cr.setProjection (projection.avg ("Salary"); Property.cr.setProjecion (projections.max ("salário")); // para obter o mínimo de uma propriedade.cr.setProjection (projectionS.Min ("Salário")); // para obter a soma de uma propriedade.cr.setProjection (projection.sum ("Salary")); Exemplo de consultas de critérios:
Considere a seguinte aula de Pojo:
Public Class Funcionário {private Int ID; String privada primeiro nome; string privada stringname; salário privado int; public funcionário () {} funcionário público (string fname, string lname, int salário) {this.firstname = fname; this.LastName = lname; this.salary = salário; } public int getId () {return id; } public void setId (int id) {this.id = id; } public String getFirstName () {return FirstName; } public void setFirstName (String First_Name) {this.firstName = First_Name; } public string getLastName () {return lastName; } public void setLastName (string last_name) {this.lastName = last_name; } public int getSalary () {retornar salário; } public void SetSalary (salário int) {this.salary = salário; }}Vamos criar a seguinte tabela de funcionários para armazenar o objeto do funcionário:
Criar funcionário da tabela (ID int não nulo auto_increntle, primeiro_name varchar (20) nulo padrão, last_name varchar (20) nulo padrão, nulo padrão nulo padrão, chave primária (id));
O seguinte será arquivos mapeados.
<? xml versão = "1.0" coding = "utf-8"?> <! <meta attribute = "classe-descrição"> Esta classe contém os detalhes do funcionário. </meta> <id name = "id" type = "int" column = "id"> <gerator/> </id> <propriedade name = "primeironame" column = "First_name" type = "string"/> <names name = "Salary" column = "last_name" type = ""/> <names)
Por fim, criaremos o método principal () da classe de aplicativo para executar, e usaremos a consulta de critérios para o aplicativo:
importar java.util.list; importar java.util.date; importar java.util.iterator; importar org.hibernate.hibernateException; importar org.hibernate.session; importar org.hibernate.transaction; importar org.hibernate.SessionFactory; importar org.hibernate.criteria; importação org.hibernate.critriorion.restrictions; importação org.hibernate.criterion.projeções; {particular org.hibernate.cfg.configuratur; public static void main (string [] args) {try {factory = new Configuration (). Configure (). buildSessionFactory (); } Catch (ex -throwable ex) {System.err.println ("Falha ao criar o objeto SessionFactory." + Ex); lançar uma nova excepçãoininitializerError (ex); } Gerencia o empregado eu = new ManageEmployee (); / * Adicione poucos registros de funcionários no banco de dados */ inteiro empid1 = me.addemployee ("zara", "ali", 2000); Inteiro empid2 = me.addemployee ("Daisy", "Das", 5000); Inteiro empid3 = me.addemployee ("John", "Paul", 5000); Inteiro empid4 = me.addemployee ("mohd", "yasee", 3000); / * Liste todos os funcionários */ me.listemployee (); / * Imprima contagem total do funcionário */ me.countEmployee (); / * Imprima o salário Toatl */ me.totalsalário (); } / * Método para criar um funcionário no banco de dados * / public integer addEmployee (string fname, string lname, int salário) {session session = factory.openssion (); Transação tx = nulo; Inteiro funcionárioID = nulo; tente {tx = session.begIntransaction (); Funcionário do funcionário = novo funcionário (fname, lname, salário); empregado = (inteiro) session.save (funcionário); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); } retornar o funcionárioID; } / * Método para ler todos os funcionários com salário mais de 2000 * / public void listemployes () {session Session = factory.opensssion (); Transação tx = nulo; tente {tx = session.begIntransaction (); Critérios CR = session.createcriteria (funcionário.class); // Adicione restrição. Cr.Add (restrições.gt ("Salário", 2000)); Listar funcionários = cr.list (); for (iterator iterator = funcionário.iterator (); iterator.hasnext ();) {funcionário = (funcionário) iterator.next (); System.out.print ("primeiro nome:" + funcionário.getfirstname ()); System.out.print ("Sobrenome:" + Employee.getLastName ()); System.out.println ("Salário:" + Employee.getSalary ()); } tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para imprimir o número total de registros * / public void CountEmployee () {session Session = Factory.opensession (); Transação tx = nulo; tente {tx = session.begIntransaction (); Critérios CR = session.createcriteria (funcionário.class); // Para obter contagem total de linhas. cr.setProjeção (projection.rowCount ()); List RowCount = cr.list (); System.out.println ("Total Cont:" + RowCount.get (0)); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }} / * Método para imprimir a soma dos salários * / public void TotalSalary () {Session Session = Factory.opensession (); Transação tx = nulo; tente {tx = session.begIntransaction (); Critérios CR = session.createcriteria (funcionário.class); // para obter salário total. cr.setProjeção (projeção.sum ("salário")); Lista totalsalária = cr.list (); System.out.println ("Salário total:" + TotalSalary.get (0)); tx.Commit (); } catch (hibernateException e) {if (tx! = null) tx.rollback (); E.PrintStackTrace (); } finalmente {session.close (); }}} Compilar e executar:
Aqui estão as etapas para compilar e executar o aplicativo acima. Certifique -se de definir o caminho e o caminho de classe adequadamente antes de compilar e executar.
Os seguintes resultados serão obtidos e o registro será criado na tabela de funcionários.
$ java ManageEmployee
..... várias mensagens de log serão exibidas aqui ......... Nome: Daisy Sobrenome: Das Salário: 5000 Nome: John Sobrenome: Paul Salário: 5000 First Nome: Mohd Sobrenome: Yasee
Se você verificar a tabela de funcionários, ela deve ser registrada da seguinte maneira:
mysql> selecione * do funcionário;
+-------------------------------------+| id | primeiro_name | Último nome | salário |+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------