A execução de consultas SQL nativa é controlada através da interface SQLQuery que é obtido, chamando a Session.createSQLQuery(). As seções abaixo descrevem como usar este API para consultas.

sess.createSQLQuery("SELECT * FROM CATS").list();

sess.createSQLQuery("SELECT ID, NAME, BIRTHDATE FROM CATS").list();

sess.createSQLQuery("SELECT * FROM CATS")

 .addScalar("ID", Hibernate.LONG)

 .addScalar("NAME", Hibernate.STRING)

 .addScalar("BIRTHDATE", Hibernate.DATE)

sess.createSQLQuery("SELECT * FROM CATS")

 .addScalar("ID", Hibernate.LONG)

 .addScalar("NAME")

 .addScalar("BIRTHDATE")

sess.createSQLQuery("SELECT * FROM CATS").addEntity(Cat.class);

sess.createSQLQuery("SELECT ID, NAME, BIRTHDATE FROM CATS").addEntity(Cat.class);

sess.createSQLQuery("SELECT ID, NAME, BIRTHDATE, DOG_ID FROM CATS").addEntity(Cat.class);

sess.createSQLQuery("SELECT c.ID, NAME, BIRTHDATE, DOG_ID, D_ID, D_NAME FROM CATS c, DOGS d WHERE c.DOG_ID = d.D_ID")

 .addEntity("cat", Cat.class)

 .addJoin("cat.dog");

sess.createSQLQuery("SELECT ID, NAME, BIRTHDATE, D_ID, D_NAME, CAT_ID FROM CATS c, DOGS d WHERE c.ID = d.CAT_ID")

 .addEntity("cat", Cat.class)

 .addJoin("cat.dogs");

sess.createSQLQuery("SELECT c.*, m.*  FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID")

 .addEntity("cat", Cat.class)

 .addEntity("mother", Cat.class)

sess.createSQLQuery("SELECT {cat.*}, {mother.*}  FROM CATS c, CATS m WHERE c.MOTHER_ID = c.ID")

 .addEntity("cat", Cat.class)

 .addEntity("mother", Cat.class)

String sql = "SELECT ID as {c.id}, NAME as {c.name}, " +

         "BIRTHDATE as {c.birthDate}, MOTHER_ID as {c.mother}, {mother.*} " +

         "FROM CAT_LOG c, CAT_LOG m WHERE {c.mother} = c.ID";


List loggedCats = sess.createSQLQuery(sql)

        .addEntity("cat", Cat.class)

        .addEntity("mother", Cat.class).list()

sess.createSQLQuery("SELECT NAME, BIRTHDATE FROM CATS")

        .setResultTransformer(Transformers.aliasToBean(CatDTO.class))

Query query = sess.createSQLQuery("SELECT * FROM CATS WHERE NAME like ?").addEntity(Cat.class);

List pusList = query.setString(0, "Pus%").list();

     

query = sess.createSQLQuery("SELECT * FROM CATS WHERE NAME like :name").addEntity(Cat.class);

List pusList = query.setString("name", "Pus%").list();          

Consultas SQL Nomeadas podem ser definidas no documento de mapeamento e chamadas exatamente da mesma forma que uma consulta HQL nomeada. Neste caso nós não precisamos chamar o addEntity().

<sql-query name="persons">

    <return alias="person" class="eg.Person"/>

    SELECT person.NAME AS {person.name},

           person.AGE AS {person.age},

           person.SEX AS {person.sex}

    FROM PERSON person

    WHERE person.NAME LIKE :namePattern

</sql-query

>

List people = sess.getNamedQuery("persons")

    .setString("namePattern", namePattern)

    .setMaxResults(50)

    .list();

Os elementos <return-join> e <load-collection> são usados para unir associações e definir consultas que inicializam coleções,

<sql-query name="personsWith">

    <return alias="person" class="eg.Person"/>

    <return-join alias="address" property="person.mailingAddress"/>

    SELECT person.NAME AS {person.name},

           person.AGE AS {person.age},

           person.SEX AS {person.sex},

           address.STREET AS {address.street},

           address.CITY AS {address.city},

           address.STATE AS {address.state},

           address.ZIP AS {address.zip}

    FROM PERSON person

    JOIN ADDRESS address

        ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'

    WHERE person.NAME LIKE :namePattern

</sql-query

>

Uma consulta SQL nomeada pode devolver um valor escalar. Você deve declarar um alias de coluna e um tipo Hibernate usando o elemento <return-scalar>:

<sql-query name="mySqlQuery">

    <return-scalar column="name" type="string"/>

    <return-scalar column="age" type="long"/>

    SELECT p.NAME AS name,

           p.AGE AS age,

    FROM PERSON p WHERE p.NAME LIKE 'Hiber%'

</sql-query

>

Você pode externar as informações de mapeamento de conjunto de resultado em um elemento <resultset> tanto para reusá-los em diversas consultas nomeadas quanto através da API setResultSetMapping().

<resultset name="personAddress">

    <return alias="person" class="eg.Person"/>

    <return-join alias="address" property="person.mailingAddress"/>

</resultset>



<sql-query name="personsWith" resultset-ref="personAddress">

    SELECT person.NAME AS {person.name},

           person.AGE AS {person.age},

           person.SEX AS {person.sex},

           address.STREET AS {address.street},

           address.CITY AS {address.city},

           address.STATE AS {address.state},

           address.ZIP AS {address.zip}

    FROM PERSON person

    JOIN ADDRESS address

        ON person.ID = address.PERSON_ID AND address.TYPE='MAILING'

    WHERE person.NAME LIKE :namePattern

</sql-query

>

Você pode também, como forma alternativa, usar a informação de mapeamento de conjunto de resultado em seus arquivos hbm em código de java.

List cats = sess.createSQLQuery(

        "select {cat.*}, {kitten.*} from cats cat, cats kitten where kitten.mother = cat.id"

    )

    .setResultSetMapping("catAndKitten")

    .list();

<sql-query name="mySqlQuery">

    <return alias="person" class="eg.Person">

        <return-property name="name" column="myName"/>

        <return-property name="age" column="myAge"/>

        <return-property name="sex" column="mySex"/>

    </return>

    SELECT person.NAME AS myName,

           person.AGE AS myAge,

           person.SEX AS mySex,

    FROM PERSON person WHERE person.NAME LIKE :name

</sql-query>

<sql-query name="organizationCurrentEmployments">

    <return alias="emp" class="Employment">

        <return-property name="salary">

            <return-column name="VALUE"/>

            <return-column name="CURRENCY"/>

        </return-property>

        <return-property name="endDate" column="myEndDate"/>

    </return>

        SELECT EMPLOYEE AS {emp.employee}, EMPLOYER AS {emp.employer},

        STARTDATE AS {emp.startDate}, ENDDATE AS {emp.endDate},

        REGIONCODE as {emp.regionCode}, EID AS {emp.id}, VALUE, CURRENCY

        FROM EMPLOYMENT

        WHERE EMPLOYER = :id AND ENDDATE IS NULL

        ORDER BY STARTDATE ASC

</sql-query

>

CREATE OR REPLACE FUNCTION selectAllEmployments

    RETURN SYS_REFCURSOR

AS

    st_cursor SYS_REFCURSOR;

BEGIN

    OPEN st_cursor FOR

 SELECT EMPLOYEE, EMPLOYER,

 STARTDATE, ENDDATE,

 REGIONCODE, EID, VALUE, CURRENCY

 FROM EMPLOYMENT;

      RETURN  st_cursor;

 END;

<sql-query name="selectAllEmployees_SP" callable="true">

    <return alias="emp" class="Employment">

        <return-property name="employee" column="EMPLOYEE"/>

        <return-property name="employer" column="EMPLOYER"/>

        <return-property name="startDate" column="STARTDATE"/>

        <return-property name="endDate" column="ENDDATE"/>

        <return-property name="regionCode" column="REGIONCODE"/>

        <return-property name="id" column="EID"/>

        <return-property name="salary">

            <return-column name="VALUE"/>

            <return-column name="CURRENCY"/>

        </return-property>

    </return>

    { ? = call selectAllEmployments() }

</sql-query

>

Hibernate3 can use custom SQL for create, update, and delete operations. The SQL can be overridden at the statement level or inidividual column level. This section describes statement overrides. For columns, see Seção 5.7, “Coluna de expressöes de gravação e leitura”.

A persistência de classe e coleção no Hibernate já contém um conjunto de strings gerados por tempo de configuração (insertsql, deletesql, updatesql etc.). O mapeamento das tags <sql-insert>, <sql-delete>, e <sql-update> sobrescreve essas strings:

<class name="Person">

    <id name="id">

        <generator class="increment"/>

    </id>

    <property name="name" not-null="true"/>

    <sql-insert

>INSERT INTO PERSON (NAME, ID) VALUES ( UPPER(?), ? )</sql-insert>

    <sql-update

>UPDATE PERSON SET NAME=UPPER(?) WHERE ID=?</sql-update>

    <sql-delete

>DELETE FROM PERSON WHERE ID=?</sql-delete>

</class

>

O SQL é executado diretamente no seu banco de dados, então você pode usar qualquer linguagem que quiser. Isto com certeza reduzirá a portabilidade do seu mapeamento se você utilizar um SQL para um banco de dados específico.

Os procedimentos armazenados são suportados se a função callable estiver ativada:

<class name="Person">

    <id name="id">

        <generator class="increment"/>

    </id>

    <property name="name" not-null="true"/>

    <sql-insert callable="true"

>{call createPerson (?, ?)}</sql-insert>

    <sql-delete callable="true"

>{? = call deletePerson (?)}</sql-delete>

    <sql-update callable="true"

>{? = call updatePerson (?, ?)}</sql-update>

</class

>

A ordem de posições dos parâmetros são vitais, pois eles devem estar na mesma seqüência esperada pelo Hibernate.

Você pode ver a ordem esperada ativando o debug logging no ní­vel org.hibernate.persister.entity. Com este ní­vel ativado, o Hibernate irá imprimir o SQL estático que foi usado para criar, atualizar, deletar, etc., entidades. Para ver a seqüência esperada, lembre-se de não incluir seu SQL padronizado no arquivo de mapeamento, pois ele irá sobrescrever o SQL estático gerado pelo Hibernate.

Os procedimentos armazenados são na maioria dos casos requeridos para retornar o número de linhas inseridas/atualizadas/deletadas, uma vez que o Hibernate possui algumas verificações em tempo de espera para o sucesso das instruções. O Hibernate sempre registra o primeiro parâmetro da instrução como um parâmetro de saída numérica para as operações CUD:

CREATE OR REPLACE FUNCTION updatePerson (uid IN NUMBER, uname IN VARCHAR2)
    RETURN NUMBER IS
BEGIN

    update PERSON
    set
        NAME = uname,
    where
        ID = uid;

    return SQL%ROWCOUNT;

END updatePerson;

You can also declare your own SQL (or HQL) queries for entity loading. As with inserts, updates, and deletes, this can be done at the individual column level as described in Seção 5.7, “Coluna de expressöes de gravação e leitura” or at the statement level. Here is an example of a statement level override:

<sql-query name="person">

    <return alias="pers" class="Person" lock-mode="upgrade"/>

    SELECT NAME AS {pers.name}, ID AS {pers.id}

    FROM PERSON

    WHERE ID=?

    FOR UPDATE

</sql-query

>

Este é apenas uma instrução de consulta nomeada, como discutido anteriormente. Você pode referenciar esta consulta nomeada em um mapeamento de classe:

<class name="Person">

    <id name="id">

        <generator class="increment"/>

    </id>

    <property name="name" not-null="true"/>

    <loader query-ref="person"/>

</class

>

Este também funciona com procedimentos armazenados.

Você pode também definir uma consulta para carregar uma coleção:

<set name="employments" inverse="true">

    <key/>

    <one-to-many class="Employment"/>

    <loader query-ref="employments"/>

</set

>

<sql-query name="employments">

    <load-collection alias="emp" role="Person.employments"/>

    SELECT {emp.*}

    FROM EMPLOYMENT emp

    WHERE EMPLOYER = :id

    ORDER BY STARTDATE ASC, EMPLOYEE ASC

</sql-query

>

Você pode até definir um carregador de entidade que carregue uma coleção por busca de união:

<sql-query name="person">

    <return alias="pers" class="Person"/>

    <return-join alias="emp" property="pers.employments"/>

    SELECT NAME AS {pers.*}, {emp.*}

    FROM PERSON pers

    LEFT OUTER JOIN EMPLOYMENT emp

        ON pers.ID = emp.PERSON_ID

    WHERE ID=?

</sql-query

>