コレクションのインスタンスは、データベース内では、 そのコレクションを所有するエンティティの外部キーによって識別されます。 この外部キーはコレクションテーブルの コレクションキーカラム と呼ばれます。 コレクションキーカラムは <key> 要素によりマッピングします。

外部キーカラムにはnull設定制約があるかもしれません。 ほとんどのコレクションに当てはまるでしょう。 単方向の一対多関連において、外部キーカラムはデフォルトでnullを許す設定になっています。 よって、not-null="true" を指定する必要があるかもしれません。

<key column="productSerialNumber" not-null="true"/>

外部キーの制約が ON DELETE CASCADE を使うかもしれません。

<key column="productSerialNumber" on-delete="cascade"/>

<key> 要素のすべての定義については前の章を参照してください。

コレクションは他のHibernateの型のほとんど（すべての基本型、カスタム型、コンポーネント、 他のエンティティへの参照）を格納することができます。 次の点は重要な違いになります。 コレクションに格納されたオブジェクトが「値」セマンティクスとして扱われるのか （ライフサイクルはコレクションのオーナーに完全に依存します）、 もしくはそれ自身のライフサイクルを持った別のエンティティへの参照であるかのかという違いです。 後者は、2つのオブジェクト間の「リンク」をコレクションに保持していると見なしているだけです。

格納される型は コレクション要素型 と呼ばれます。 コレクション要素は、<element> または <composite-element> によりマッピングされ、エンティティへの参照の場合には <one-to-many> または <many-to-many> によりマッピングされます。 最初の二つは値として要素をマッピングし、次の二つはエンティティの関連をマッピングするのに使われます。

setとbagを除く全てのコレクションマッピングには、 コレクションテーブルの中に インデックス用のカラム が必要です。 そのカラムに、配列や List のインデックス、 もしくは Map のキーをマッピングします。 Map のインデックスは、 <map-key> によりマッピングされた基本型か、 <map-key-many-to-many> によりマッピングされたエンティティの関連か、 あるいは <composite-map-key> によりマッピングされたコンポジット型になります。 配列かリストのインデックスは、常に integer 型で、 <list-index> 要素によりマッピングします。 マッピングされたカラムにはシーケンシャルな整数を格納します（デフォルトでは0から番号が付けられます）。

<list-index 
        column="column_name"                (1)
        base="0|1|..."/>

<map-key 
        column="column_name"                (1)
        formula="any SQL expression"        (2)
        type="type_name"                    (3)
        node="@attribute-name"
        length="N"/>

<map-key-many-to-many
        column="column_name"                (1)
        formula="any SQL expression"        (2)
        class="ClassName"                   (3)
/>

もしテーブルにインデックスカラムがなくても、プロパティ型として List を使いたければ、 Hibernateの <bag> としてプロパティをマッピングします。 bagはデータベースから復元される時、順序を保持しません。 しかし、（メモリ上で）ソートしたり、（SQLで）順序付けしたり（order by）することもできます。

値のコレクションや多対多関連は、専用の コレクションテーブル が必要です。 このテーブルは、外部キーカラムと、 コレクション要素のカラム と、 場合によってはインデックスカラムを持ちます。

値のコレクションのために、<element>タグを使用します。

<element
        column="column_name"                     (1)
        formula="any SQL expression"             (2)
        type="typename"                          (3)
        length="L"
        precision="P"
        scale="S"
        not-null="true|false"
        unique="true|false"
        node="element-name"
/>

多対多関連 は <many-to-many> 要素で指定します。

<many-to-many
        column="column_name"                               (1)
        formula="any SQL expression"                       (2)
        class="ClassName"                                  (3)
        fetch="select|join"                                (4)
        unique="true|false"                                (5)
        not-found="ignore|exception"                       (6)
        entity-name="EntityName"                           (7)
        property-ref="propertyNameFromAssociatedClass"     (8)
        node="element-name"
        embed-xml="true|false"
    />

以下にいくつか例を示します。 まずはStringのsetに関しての例です。

<set name="names" table="person_names">
    <key column="person_id"/>
    <element column="person_name" type="string"/>
</set>

整数値を含むbag（bagは order-by 属性によって反復順序が定義されています）

<bag name="sizes" 
        table="item_sizes" 
        order-by="size asc">
    <key column="item_id"/>
    <element column="size" type="integer"/>
</bag>

エンティティの配列 - この場合、多対多の関連です。

<array name="addresses" 
        table="PersonAddress" 
        cascade="persist">
    <key column="personId"/>
    <list-index column="sortOrder"/>
    <many-to-many column="addressId" class="Address"/>
</array>

文字列と日付のmap

<map name="holidays" 
        table="holidays" 
        schema="dbo" 
        order-by="hol_name asc">
    <key column="id"/>
    <map-key column="hol_name" type="string"/>
    <element column="hol_date" type="date"/>
</map>

コンポーネントのlist（次の章で詳しく説明します）

<list name="carComponents" 
        table="CarComponents">
    <key column="carId"/>
    <list-index column="sortOrder"/>
    <composite-element class="CarComponent">
        <property name="price"/>
        <property name="type"/>
        <property name="serialNumber" column="serialNum"/>
    </composite-element>
</list>

一対多関連 は、コレクション･テーブルを介さず、 外部キーにより2つのクラスのテーブルを関連付けます。 このマッピングは標準的なJavaのコレクションのセマンティクスをいくつか失います。

Product から Part への関連は、 Part テーブルへの外部キーカラムと、場合によってはインデックスカラムが必要です。 <one-to-many> タグは、これが一対多関連であることを表しています。

<one-to-many 
        class="ClassName"                                  (1)
        not-found="ignore|exception"                       (2)
        entity-name="EntityName"                           (3)
        node="element-name"
        embed-xml="true|false"
    />

<one-to-many> 要素はカラムを宣言する必要がないことに注意してください。 同様に テーブル 名を指定する必要もありません。

とても重要な注意: もし <one-to-many> 関連の外部キーカラムが NOT NULLと宣言された場合、 <key> マッピングに not-null="true" を宣言するか、 コレクションマッピングに inverse="true" を付けた上で、 双方向関連を使う 必要があります。 双方向関連についてはこの章の後のほうで説明します。

次の例は、名称（Part の永続的なプロパティである partName） による Part エンティティのmapを表しています。 formulaによるインデックスを使っていることに注意してください。

<map name="parts"
        cascade="all">
    <key column="productId" not-null="true"/>
    <map-key formula="partName"/>
    <one-to-many class="Part"/>
</map>

Hibernateは java.util.SortedMap と java.util.SortedSet を実装したコレクションをサポートしています。 開発者はマッピング定義ファイルにコンパレータを指定しなければなりません。

<set name="aliases" 
            table="person_aliases" 
            sort="natural">
    <key column="person"/>
    <element column="name" type="string"/>
</set>

<map name="holidays" sort="my.custom.HolidayComparator">
    <key column="year_id"/>
    <map-key column="hol_name" type="string"/>
    <element column="hol_date" type="date"/>
</map>

sort 属性に設定できる値は unsorted と natural および、java.util.Comparator を実装したクラスの名前です。

ソートされたコレクションは実質的には java.util.TreeSet や java.util.TreeMap のように振舞います。

もしデータベース自身にコレクションの要素を並べさせたいなら、 set や bag、map の order-by 属性を使います。 この解決法はJDK1.4、もしくはそれ以上のバージョンで利用可能です （LinkedHashSet または LinkedHashMapを使って実装されています）。 整列はメモリ上ではなく、SQLクエリ内で実行されます。

<set name="aliases" table="person_aliases" order-by="lower(name) asc">
    <key column="person"/>
    <element column="name" type="string"/>
</set>

<map name="holidays" order-by="hol_date, hol_name">
    <key column="year_id"/>
    <map-key column="hol_name" type="string"/>
    <element column="hol_date" type="date"/>
</map>

order-by 属性の値がSQL命令であって、HQL命令ではないことに注意してください！

関連は、コレクションの filter() を使うことで、 実行時に任意のcriteriaによってソートすることも可能です。

sortedUsers = s.createFilter( group.getUsers(), "order by this.name" ).list();

双方向関連 は関連のどちら「側」からでもナビゲーションできます。 2種類の双方向関連がサポートされています。

2つの多対多関連で同じデータベーステーブルをマッピングし、 片方を inverse として宣言することで、 双方向の多対多関連を指定することが出来ます （どちらをinverseに選んだとしても、そちら側にはインデックス付きのコレクションは使えません）。

次に双方向の多対多関連の例を示します。 各カテゴリは多数のアイテムを持つことができ、各アイテムは多くのカテゴリに属することが出来ます。

<class name="Category">
    <id name="id" column="CATEGORY_ID"/>
    ...
    <bag name="items" table="CATEGORY_ITEM">
        <key column="CATEGORY_ID"/>
        <many-to-many class="Item" column="ITEM_ID"/>
    </bag>
</class>

<class name="Item">
    <id name="id" column="CATEGORY_ID"/>
    ...

    <!-- inverse end -->
    <bag name="categories" table="CATEGORY_ITEM" inverse="true">
        <key column="ITEM_ID"/>
        <many-to-many class="Category" column="CATEGORY_ID"/>
    </bag>
</class>

関連のinverse側にのみ行われた変更は永続化 されません。 これは、Hibernateは全ての双方向関連について、メモリ上に２つの表現を持っているという意味です。 つまり一つはAからBへのリンクで、もう一つはBからAへのリンクということです。 Javaのオブジェクトモデルについて考え、Javaで双方向関係をどうやって作るかを考えれば、 これは理解しやすいです。下記に、Javaでの双方向関連を示します。

category.getItems().add(item);          // The category now "knows" about the relationship
item.getCategories().add(category);     // The item now "knows" about the relationship

session.persist(item);                   // The relationship won't be saved!
session.persist(category);               // The relationship will be saved

関連のinverseではない側は、メモリ上の表現をデータベースに保存するのに使われます。

双方向の一対多関連を定義するには、 一対多関連を多対一関連と同じテーブルのカラムにマッピングし、 多側に inverse="true" と宣言します。

<class name="Parent">
    <id name="id" column="parent_id"/>
    ....
    <set name="children" inverse="true">
        <key column="parent_id"/>
        <one-to-many class="Child"/>
    </set>
</class>

<class name="Child">
    <id name="id" column="child_id"/>
    ....
    <many-to-one name="parent" 
        class="Parent" 
        column="parent_id"
        not-null="true"/>
</class>

関連の片側に inverse="true" を設定しても、 カスケード操作に影響を与えません。これらは直交した概念です！

片側が <list> や <map> である 双方向関連は、特によく考える必要があります。 インデックスカラムにマップされる子クラスのプロパティがある場合は、問題ないです。 コレクションのマッピングで inverse="true" を使い続けられます。

<class name="Parent">
    <id name="id" column="parent_id"/>
    ....
    <map name="children" inverse="true">
        <key column="parent_id"/>
        <map-key column="name" 
            type="string"/>
        <one-to-many class="Child"/>
    </map>
</class>

<class name="Child">
    <id name="id" column="child_id"/>
    ....
    <property name="name" 
        not-null="true"/>
    <many-to-one name="parent" 
        class="Parent" 
        column="parent_id"
        not-null="true"/>
</class>

しかし、子クラスにそのようなプロパティがない場合は、 関連を真に双方向であると考えることができません （関連の片側に利用できる情報がありますが、もう一方にはありません）。 この場合は、コレクションに inverse="true" をマッピングできません。 代わりに、次のようなマッピングが使えます。

<class name="Parent">
    <id name="id" column="parent_id"/>
    ....
    <map name="children">
        <key column="parent_id"
            not-null="true"/>
        <map-key column="name" 
            type="string"/>
        <one-to-many class="Child"/>
    </map>
</class>

<class name="Child">
    <id name="id" column="child_id"/>
    ....
    <many-to-one name="parent" 
        class="Parent" 
        column="parent_id"
        insert="false"
        update="false"
        not-null="true"/>
</class>

注意： このマッピングでは、関連のコレクション値の側は、 外部キーをアップデートする責任があります。

3項関連のマッピングには3つのアプローチがあります。 1つ目は関連をインデックスとして Map を使用するアプローチです。

<map name="contracts">
    <key column="employer_id" not-null="true"/>
    <map-key-many-to-many column="employee_id" class="Employee"/>
    <one-to-many class="Contract"/>
</map>

<map name="connections">
    <key column="incoming_node_id"/>
    <map-key-many-to-many column="outgoing_node_id" class="Node"/>
    <many-to-many column="connection_id" class="Connection"/>
</map>

2つ目は単純に関連をエンティティ･クラスとしてモデルを作り直すアプローチで、 頻繁に使われます。

最後はcomposite要素を使うアプローチです。これに関する議論は後ほど行います。

複合キーは悪いもので、エンティティは人工の識別子(代理キー)を持つべきであるという考え方からは、 多対多関連と値のコレクションを複合キーを用いたテーブルへマッピングするのは少し奇妙に感じるかもしれません！ 確かにこの考え方には議論の余地があります。 純粋な関連テーブルは代理キーを使っても利益を得られないように思えるからです （合成値のコレクションは利益がある かも しれませんが）。 とはいえ、Hibernateは代理キーを持つテーブルへ多対多関連と値のコレクションを マッピングする機能も備えています。

bagのセマンティックスを持った List（または Collection）を <idbag> 要素にマッピングできます。

<idbag name="lovers" table="LOVERS">
    <collection-id column="ID" type="long">
        <generator class="sequence"/>
    </collection-id>
    <key column="PERSON1"/>
    <many-to-many column="PERSON2" class="Person" fetch="join"/>
</idbag>

ご存知のように <idbag> はエンティティ･クラスのように 人工的なidジェネレータを持っています！ 異なる代理キーをそれぞれのコレクションの列に割り当てます。 しかしながら、Hibernateはある行の代理キーの値を見つけ出す機構を持っていません。

<idbag> を更新するパフォーマンスは 通常の <bag> よりも良いことに注目してください！ Hibernateは個々の行を効果的に見つけることができ、 listやmap、setのように個別にその行を更新、削除できます。

現在の実装では、native というid生成戦略を <idbag> コレクションの識別子に対して使えません。