查询可以在select子句中指定类的属性。甚至可以调用SQL的统计函数。属性或者统计值被称为“标量(scalar)”结果。

Iterator results = sess.iterate(
        "select cat.color, min(cat.birthdate), count(cat) from Cat cat " +
        "group by cat.color"
);
while ( results.hasNext() ) {
    Object[] row = results.next();
    Color type = (Color) row[0];
    Date oldest = (Date) row[1];
    Integer count = (Integer) row[2];
    .....
}

Iterator iter = sess.iterate(
    "select cat.type, cat.birthdate, cat.name from DomesticCat cat"
);

List list = sess.find(
    "select cat, cat.mate.name from DomesticCat cat"
);

如果你需要为你的结果集设置边界（你需要获取的最大行数与/或你希望获取的第一行），你应该得到一个net.sf.hibernate.Query的实例：

Query q = sess.createQuery("from DomesticCat cat");
q.setFirstResult(20);
q.setMaxResults(10);
List cats = q.list();

你甚至可以在映射文档中定义命名查询。（记得用一个CDATA块把你的查询包含起来，否则在分析的时候可能引起误解。）

<query name="eg.DomesticCat.by.name.and.minimum.weight"><![CDATA[
    from eg.DomesticCat as cat
        where cat.name = ?
        and cat.weight > ?
] ]></query>

Query q = sess.getNamedQuery("eg.DomesticCat.by.name.and.minimum.weight");
q.setString(0, name);
q.setInt(1, minWeight);
List cats = q.list();

查询界面支持使用命名参数。命名参数用:name的形式在查询字符串中表示。在Query中有方法把实际参数绑定到命名参数或者JDBC风格的?参数。 和JDBC不同，Hibernate的参数从0开始计数。 使用命名参数有一些好处：

//named parameter (preferred)
Query q = sess.createQuery("from DomesticCat cat where cat.name = :name");
q.setString("name", "Fritz");
Iterator cats = q.iterate();

//positional parameter
Query q = sess.createQuery("from DomesticCat cat where cat.name = ?");
q.setString(0, "Izi");
Iterator cats = q.iterate();

//named parameter list
List names = new ArrayList();
names.add("Izi");
names.add("Fritz");
Query q = sess.createQuery("from DomesticCat cat where cat.name in (:namesList)");
q.setParameterList("namesList", names);
List cats = q.list();

如果你的JDBC驱动支持可滚动的ResuleSet,Query接口可以获取一个ScrollableResults，允许你在查询结果中灵活游走。

Query q = sess.createQuery("select cat.name, cat from DomesticCat cat " +
                            "order by cat.name");
ScrollableResults cats = q.scroll();
if ( cats.first() ) {

    // find the first name on each page of an alphabetical list of cats by name
    firstNamesOfPages = new ArrayList();
    do {
        String name = cats.getString(0);
        firstNamesOfPages.add(name);
    }
    while ( cats.scroll(PAGE_SIZE) );

    // Now get the first page of cats
    pageOfCats = new ArrayList();
    cats.beforeFirst();
    int i=0;
    while( ( PAGE_SIZE > i++ ) && cats.next() ) pageOfCats.add( cats.get(1) );

}

scroll()的行为方式与iterate()很类似，除了对象可以有选择的用get(int)初始化，而非整个行都一次性被初始化。

集合filter是一种特殊的查询，用于一个持久化集合或者数组。查询字符串可以引用this,意为当前的数组元素。

Collection blackKittens = session.filter( 
    pk.getKittens(), "where this.color = ?", Color.BLACK, Hibernate.enum(Color.class)
);

返回的集合被认为是一个包(bag)。

请注意filter并不需要from 子句（当然需要的话它们也可以加上）。Filter不限定返回它们自己的集合元素。

Collection blackKittenMates = session.filter( 
    pk.getKittens(), "select this.mate where this.color = eg.Color.BLACK"
);

HQL极为强大，但是有些人希望能够动态的使用一种面向对象API创建查询，而非在他们的Java代码中嵌入字符串。对于那部分人来说，Hibernate提供了一种直观的Criteria查询API。

Criteria crit = session.createCriteria(Cat.class);
crit.add( Expression.eq("color", eg.Color.BLACK) );
crit.setMaxResults(10);
List cats = crit.list();

如果你对类似于SQL的语法不是感觉很舒服的话，用这种方法开始使用Hibernate可能更容易。这种API也比HQL更可扩展。程序可以提供它们自己的Criterion接口的实现。

你可以使用createSQLQuery()方法，用SQL来表达查询。你必须把SQL别名用大括号包围起来。

List cats = session.createSQLQuery(
    "SELECT {cat.*} FROM CAT {cat} WHERE ROWNUM<10",
    "cat",
    Cat.class
).list();

List cats = session.createSQLQuery(
    "SELECT {cat}.ID AS {cat.id}, {cat}.SEX AS {cat.sex}, " +
           "{cat}.MATE AS {cat.mate}, {cat}.SUBCLASS AS {cat.class}, ... " +
    "FROM CAT {cat} WHERE ROWNUM<10",
    "cat",
    Cat.class
).list()

和Hibernate查询一样，SQL查询也可以包含命名参数或者顺序参数。

事务中的持久化实例 （就是通过session装载、保存、创建或者查询出的对象）可以被程序操作，所做的任何修改都会在Session同步（flushed）的时候被持久化（本章后面会详细讨论）。所以最直接的更改一个对象的方法就是load()它，保持Session打开，然后直接修改即可：

DomesticCat cat = (DomesticCat) sess.load( Cat.class, new Long(69) );
cat.setName("PK");
sess.flush();  // changes to cat are automatically detected and persisted

有些时候这种编程模式显得效率不高，因为它需要在同一个session中先使用SQL SELECT(来装载对象),又有一个SQL UPDATE（来把修改的状态写回）。因此，Hibernate提供了另一种方式。

很多程序需要在一个事务中获取对象，然后发送到界面层去操作，用一个新的事务来保存修改。（在高同步访问的环境中使用这种方式，经常使用附带版本的数据来保证事务独立性。）这种方法需要和上一节所描述的略微不同的编程模型。Hibernate支持这种模型，因为它提供了Session.update()方法。

// in the first session
Cat cat = (Cat) firstSession.load(Cat.class, catId);
Cat potentialMate = new Cat();
firstSession.save(potentialMate);

// in a higher tier of the application
cat.setMate(potentialMate);

// later, in a new session
secondSession.update(cat);  // update cat
secondSession.update(mate); // update mate

如果拥有catId标识符的Cat在试图update它之前已经被secondSession装载了，会抛出一个异常。

对于给定的临时实例，当且仅当 它们触及的其他临时实例需要保存的时候， 应用程序应该对它们分别各自使用update()。（自动管理生命周期的对象(lifecycle object)除外，后面会讨论到。）

Hibernate用户曾经要求有一个通用的方法，可以为新建的临时实例生成标识符并保存，或者保存已经存在标识符的临时实例的改动。saveOrUpdate()方法就是用来提供这个功能的。

Hibernate通过对象的标识符的值（或version,或timestamp时间戳)来分辨这是一个“新”(未保存过的）实例，还是一个“已存在”（已经保存或者从先前的session中装载的）的实例。id映射中的unsaved-value(或<version>,或 <timestamp>)用来指定哪个值被用于表示“新”实例。

<id name="id" type="long" column="uid" unsaved-value="null">
    <generator class="hilo"/>
</id>

unsaved-value允许的取值包括：

// in the first session
Cat cat = (Cat) firstSession.load(Cat.class, catID);

// in a higher tier of the application
Cat mate = new Cat();
cat.setMate(mate);

// later, in a new session
secondSession.saveOrUpdate(cat);   // update existing state (cat has a non-null id)
secondSession.saveOrUpdate(mate);  // save the new instance (mate has a null id)

saveOrUpdate()的用法和语义看来对初学者来说容易造成困惑。首先，如果你还没有试图在另一个新session中使用来自原session的实例，你根本就不需要使用update()或者saveOrUpdate()方法。有一些程序完全不需要使用这些方法。

通常，update()或saveorUpdate()方法在下列情形下使用：

saveOrUpdate()完成了如下工作：

lock()方法是用来让应用程序把一个未修改的对象重新关联到新session的方法。

//just reassociate: 直接重新关联
sess.lock(fritz, LockMode.NONE);
//do a version check, then reassociate:  进行版本检查后关联
sess.lock(izi, LockMode.READ);
//do a version check, using SELECT ... FOR UPDATE, then reassociate: 使用SELECT ... FOR UPDATE进行版本检查后关联
sess.lock(pk, LockMode.UPGRADE);

如果你正在使用TransactionAPI，你就不用担心这个步骤。在事务提交的时候，隐含就会包括这一步。否则，你应该调用Session.flush()来确保你所有的修改都与数据库同步。

如果你正在使用Hibernate 的Transaction API,代码类似这样：

tx.commit(); // flush the Session and commit the transaction

如果你自行管理JDBC事务，你应该手工对JDBC 连接执行commit()。

sess.flush();
sess.connection().commit();  // not necessary for JTA datasource

如果你决定不提交你的更改：

tx.rollback();  // rollback the transaction

或者:

// not necessary for JTA datasource, important otherwise
sess.connection().rollback();

如果你回滚了事务,你应该立即关闭和取消当前session,确保Hibernate内部状态的完整性。

调用Session.close()就标志这个session进入了尾声。close()主要的含义就是与这个session相关的JDBC连接会被放弃。

tx.commit();
sess.close();

sess.flush();
sess.connection().commit();  // not necessary for JTA datasource
sess.close();

如果你自行管理连接，close()会返回连接的一个引用，你就可以手工把它关闭，或者返回它到连接池去。其他情况下，close()会把它返回到连接池去。

如果Session抛出了一个exception(包括任何SQLException),你应该立刻回滚这个事务，调用Session.close)()来取消这个Session实例。Session中的一些特定方式会确保session不会处于一个不稳定不完整的状态。

建议采用下面的异常处理片断：

Session sess = factory.openSession();
Transaction tx = null;
try {
    tx = sess.beginTransaction();
    // do some work
    ...
    tx.commit();
}
catch (Exception e) {
    if (tx!=null) tx.rollback();
    throw e;
}
finally {
    sess.close();
}

如果你是手工管理JDBC事务的，用下面这段:

Session sess = factory.openSession();
try {
    // do some work
    ...
    sess.flush();
    sess.connection().commit();
}
catch (Exception e) {
    sess.connection().rollback();
    throw e;
}
finally {
    sess.close();
}

如果你是从JTA中获得数据源的：

UserTransaction ut = .... ;
Session sess = factory.openSession();
try {
    // do some work
    ...
    sess.flush();
}
catch (Exception e) {
    ut.setRollbackOnly();
    throw e;
}
finally {
    sess.close();
}