條件查詢&SQL查詢

條件查詢是更具面向對象特色的數據查詢方式，通過如下3個類完成：
Criteria：代表一次查詢
Criterion：代表一個查詢條件
Restrictions：產生查詢條件的工具類
執行條件查詢的步驟如下：
(1)獲得Hibernate的Session對象
(2)以Session對象創建Criteria對象
(3)增加Criterion查詢條件
(4)執行Criteria的list等方法返回結果集
請看示例：
private void test()
...{
    Session session = HibernateUtil.currentSession();
    Transaction tx = session.beginTransaction();
    //創建Criteria和添加查詢條件同步完成
    //最後調用list方法，返回查詢到的結果集
    List l = session.createCriteria(Student.class)
        //此處增加到限制條件必須是Student已經存在的屬性
        .add(Restritions.gt("studentNumber", new Long(20071127)))
        //如果要增加對Student關聯類的屬性限制，則必須重新創建
        //如果此關聯屬性是集合，則只要集合裏任意一個對象的屬性滿足下麪條件即可
        .createCriteria("enrolments")
        .add(Restritions.gt("semester", new Short("2")))
        .list();
        Iterator it = l.iterator();
    //遍歷查詢到的記錄
    while (it.hasNext())
    ...{
        Student s = (Student)it.next();
        System.out.println(s.getName());
        Set enrolments = s.getEnrolments();
        Iterator iter = enrolments.iterator();
        while (iter.hasNext())
        ...{
            Enrolment e = (Enrolment)iter.next();
            System.out.println(e.getCourse().getName());
        }
    }
    tx.commit();
    HibernateUtil.closeSession();
}

session.createCriteria(Person.class)
    .add(Restrictions.like("name", "dd%"))
    .createCriteria("address")
    .add(Restrictions.like("addressdetail", "福州%"))
    .list();

 

SQL查詢
比Query多了兩個重載的構造方法
addEntity:將查詢到的記錄與特定的實體關聯
addScalar:將查詢到的記錄關聯成標量值
執行SQL查詢的步驟如下：
(1)獲取Hibernate Session對象
(2)編寫SQL語句
(3)以SQL語句作爲參數，調用Session的createSQLQuery方法創建查詢對象
(4)如果SQL語句包含參數，則調用Query的setXxx方法爲參數賦值
(5)調用SQLQuery對象的addEntiy或addScalar方法，將選出的結果與實體或標量值關聯
(6)調用Query的list方法返回查詢的結果集
請看SQL的查詢示例：
private void test() ...{
    Session session = HibernateUtil.currentSession();
    Transaction tx = session.beginTransaction();
    //編寫SQL語句
    String sqlString = "select {s.*} from student s where s.name like '李四'";
    //以SQL語句創建SQLQuery對象
    List l = session.createSQLQuery(sqlString)
                    //將查詢到的記錄與特定實體關聯起來
                    .addEntity("s", Student.class)
                    //返回全部的記錄集
                    .list();
    Iterator it = l.iterator();
    while (it.hasNext())
    ...{
        //因爲將查詢的結果與Student類關聯，因此返回時Student的集合
        Student s = (Student)it.next();
        Set enrolments = s.getEnrolmens();
        Iterator iter = enrolments.iterator();
        while (iter.hasNext())
        ...{
            Enrolment e = (Enrolment)iter.next();
            System.out.println("=====================================");
            System.out.println(e.getCourse().getName());
            System.out.println("=====================================");
        }
    }
    tx.commit();
    HibernateUtil.closeSession();
}

Double max = (Double)session.createSQLQuery("select max(cat.weight) as
maxWeight from cats cat")
        .addScalar("maxWeight", Hibernate.DOUBLE);
        .uniqueResult();
實例名.屬性名
//依次將多個選出的字段命名別名，命名別名時都以ss作爲前綴，ss是關聯實體的別名
String sqlStr = "select stu.studentId as {ss.studentNumber}, "
        + "stu.name as {ss.name} from" 
        + "student as stu where stu.name like '張大勇'";
List l = session.createSQLQuery(sqlStr)
                //將查詢出的ss實例，關聯到Student類
                .addEntity("ss", Student.class)
                .list();

1.命名SQL查詢
配置片段：
<!--每個sql-query元素定義一個命名SQL查詢-->
<sql-query name="mySQLQuery">
    <!--關聯返回的結果與實體類-->
    <return alias="s" class="Student"/>
        <!--定義命名SQL查詢的SQL語句-->
        SELECT ...{s.*}
        FROM student s WHERE s.name like '張大勇'
</sql-query>
使用該命名SQL查詢的示例代碼：
private void testNamedSQL() ...{
    Session session = HibernateUtil.currentSession();
    Transaction tx = session.beginTransaction();
    //調用命名查詢，直接返回結果
    List l = session.getNamedQuery("mySQLQuery").list();
    while (it.hasNext())
    ...{
        //在定義SQL查詢時，已經將結果集與Student類關聯起來
        //因此，集合裏的每個元素都是Student實例
        Student s = (Student)it.next();
        Set enrolments = s.getEnrolmens();
        Iterator iter = enrolments.iterator();
        while (iter.hasNext())
        ...{
            Enrolment e = (Enrolment)iter.next();
            System.out.println("=====================================");
            System.out.println(e.getCourse().getName());
            System.out.println("=====================================");
        }
    }
    tx.commit();
    HibernateUtil.closeSession();
}

2.調用存儲過程
Oracle9i存儲過程示例：
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查詢，例如：
<!--定義命名SQL查詢，name屬性指定命名SQL查詢名-->
<sql-query name="selectAllEmployees_SP" callabe="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"/>
        </retrun-property>
    </return>
</sql-query>

$數據過濾
過濾器的使用分三步：
(1)定義過濾器，使用filter-def元素定義過濾器
(2)使用過濾器，使用filter元素使用過濾器
(3)在代碼中啓用過濾器
請看下面的映射文件示例：
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping
    PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <class name="Category" table="category">
        <id name="id" column="category_id">
            <generator class="native"/>
        </id>
        <property name="name" type="string"/>
        <property name="effectiveStartDate" column="eff_start_date"
            type="java.util.Date"/>
        <property name="effectiveEndDate" column="eff_end_date"
            type="java.util.Date"/>
        <!--映射N-N關聯屬性-->
        <set cascade="none" inverse="true" name="products" table="
            product_category>
            <!--定義關聯屬性的key，對應連接表中的外鍵列-->
            <key column="category_id"/>
            <!--定義關聯屬性-->
            <many-to-many column="product_id" class="Product"/>
        </set>
        <!--使用過濾器，並設置過濾條件-->
        <filter name="effectiveDate" condition=":asOfDate BETWEEN eff_start
        _date and eff_end_date"/>
    </class>
    <class name="Product" table="product">
        <id name="id" column="product_id">
            <generator class="native"/>
        </id>
        <property name="name" type="string"/>
        <property name="stockNumber" column="stock_number"
            type="int"/>
        <property name="effectiveStartDate" column="eff_start_date"
            type="java.util.Date"/>
        <property name="effectiveEndDate" column="eff_end_date"
            type="java.util.Date"/>
        <!--映射N-N關聯屬性-->
        <set cascade="all" name="catagories" fetch="join" table="
            product_category>
            <!--定義關聯屬性的key，對應連接表中的外鍵列-->
            <key column="product_id"/>
            <!--定義關聯屬性-->
            <many-to-many column="category_id" class="Category"
                fetch="join">
                <!--對關聯屬性使用第一個過濾器-->
                <filter name="effectiveDate"
                    condition=":asOfDate BETWEEN eff_start_date
                    and eff_end_date"/>
                <!--對關聯屬性使用第二個過濾器-->
                <filter name="category" condition="category_id = : catId"/>
            </many-to-many>
        </set>
        <filter name="effectiveDate"
            condition=":asOfDate BETWEEN eff_start_date
        and eff_end_date"/>
    </class>
    <!--定義第一個過濾器，該過濾器包含一個date類型的參數-->
    <filter-def name="effectiveDate">
        <filter-param name="asOfDate" type="date"/>
    </flter-def>
    <!--定義第二個過濾器，該過濾器包含一個long類型的參數-->
    <filter-def name="category">
        <filter-param name="catId" type="long"/>
    </flter-def>
</hibernate-mapping>
下面是使用過濾器的示例代碼：
private void test() ...{
    Session session = HibernateUtil.currentSession();
    Transaction tx = session.beginTransaction();
    //啓用第一個過濾器
    session.enableFilter("effectiveDate")
            //爲過濾器設置參數
            .setParameter("asOfDate", new Date());
    //啓用第二個過濾器
    session.enableFilter("categor")
            //爲過濾器設置參數
            .setParameter("catId", new Long(2));
    //執行查詢，該查詢沒有任何的查詢條件
    Iterator results = session.createQuery("form Product as p").iterate();
    while (results.hasNext())
    ...{
        Product p = (Product)results.next();
        System.out.println(p.getName());
        //此處獲取Product關聯的種類，過濾器也將自動應用過濾
        Iterator it = p.getCategories().iterator();
        System.out.println(p.getCategories().size());
        while (it.hasNext())
        ...{
            Category c = (Category)it.next();
            System.out.println(c.getName());
        }
    }
    tx.commit();
    HibernateUtil.closeSession();
}