对原生 SQL 查询执行的控制是通过 SQLQuery 接口进行的，通过执行Session.createSQLQuery()获取这个接口。下面来描述如何使用这个 API 进行查询。

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();          

可以在映射文档中定义查询的名字,然后就可以象调用一个命名的 HQL 查询一样直接调用命名 SQL 查询.在这种情况下，我们不 需要调用 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();

<return-join> 和 <load-collection> 元素是用来连接关联以及将查询定义为预先初始化各个集合的。

<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

>

一个命名查询可能会返回一个标量值。你必须使用 <return-scalar> 元素来指定字段的别名和 Hibernate 类型：

<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

>

你可以把结果集映射的信息放在外部的 <resultset> 元素中，这样就可以在多个命名查询间，或者通过 setResultSetMapping() API 来访问。

<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

>

另外，你可以在 java 代码中直接使用 hbm 文件中的结果集定义信息。

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 第 5.7 节 “字段的读写表达式”.

Hibernate3 能够使用定制的 SQL 语句来执行 create，update 和 delete 操作。在 Hibernate 中，持久化的类和集合已经包含了一套配置期产生的语句（insertsql，deletesql，updatesql 等等），这些映射标记 <sql-insert>，<sql-delete> 和 <sql-update> 重载了这些语句。

<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

>

这些 SQL 直接在你的数据库里执行，所以你可以自由的使用你喜欢的任意语法。但如果你使用数据库特定的语法，这当然会降低你映射的可移植性。

如果设定 callable，则能够支持存储过程了。

<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

>

参数的位置顺序是非常重要的，他们必须和 Hibernate 所期待的顺序相同。

你能够通过设定日志调试级别为 org.hiberante.persister.entity 来查看 Hibernate 所期待的顺序。在这个级别下，Hibernate 将会打印出create，update 和 delete 实体的静态 SQL。（如果想看到预计的顺序。记得不要将定制 SQL 包含在映射文件里，因为他们会重载 Hibernate 生成的静态 SQL。）

在大多数情况下（最好这么做），存储过程需要返回插入／更新／删除的行数，因为 Hibernate 对语句的成功执行有些运行时的检查。Hibernate 常会把进行 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 第 5.7 节 “字段的读写表达式” 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

>

这只是一个前面讨论过的命名查询声明，你可以在类映射里引用这个命名查询。

<class name="Person">

    <id name="id">

        <generator class="increment"/>

    </id>

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

    <loader query-ref="person"/>

</class

>

这也可以用于存储过程

你甚至可以定一个用于集合装载的查询：

<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

>

你甚至还可以定义一个实体装载器，它通过连接抓取装载一个集合：

<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

>