The GORM mapping的数据库映射dsl介绍

在当前domain类的 HQL 查询中 Enable/disable auto import .

Usage: autoImport(boolean)

默认情况下，domain类在HQL查询是auto-imported，因此，您不需要指定整个类名（包括包），但是，如果在不同的包中有重复的domain类名，则名称不再是唯一的，会造成`org.hibernate.DuplicateMappingException`错误。禁用其中一个或两个domain类的自动导入来修复此错误，设置`autoImport` 为 false。记住，你需要在HQL的查询中使用完全的domain类名引用。

设置为false时，关闭自动时间戳功能

Usage: autoTimestamp(boolean)

缺省当domain类中的属性名为 dateCreated 和 lastUpdated , GORM会在数据库自定维护这两个字段。可以通过设置为false关闭此功能:

定制多少结果获取在懒加载执行时.

Usage: batchSize(integer)

针对`Author` 类拥有多个 Book`实例的延迟加载关联。GORM将执行一条查询`Author`和附加查询多条关联`Book`实例。 这就是著名的N+1问题，通常使用表连接处理，然而，关联表会消耗性能。 批量加载是针对延迟加载的一个优化方案，例如设置`batchSize`为10，并且当前作者拥有30本书. 系统将执行四次获取（一次`Author，3次批量10对象的获取），替换之前的31此获取:

也可以在关联端设置 batchSize :

配置domain类支持Hibernate二级缓存.

Usage: cache(boolean/string/map)

参数:

示例:

这将配置domain类使用’read-write' 缓存，需要提前确认配置的缓存政策被允许使用（缓存引擎提供支持）:

or

也可以在关联端设置缓存:

参照文档获取更多信息 Caching .

配置关联项的级联操作

Usage: association_name(cascade:string)

参数:

默认GORM会配置"belongs to"属性对象的级联操作为"all"，示例如下:

所以的持久化操作都会从`Author` 类传递到 Book 类。作者对象删除将导致关联的图书全部删除。

如果关联没有设置所有者("belongs to" 关联关系):

GORM默认使用"save-update"级联策略. 作者对象删除时，不会级联删除关联的图书。 使用`cascade`参数自定义级联行为:

以上配置，`Book`当成为孤儿(orphaned) 时会被删除。.

参看文档获取更多信息 transitive persistence .

自定义数据列的设置

Usage: property_name(map)

Arguments:

By default GORM uses the property name and type to determine how to map a property in the database. For example a String property is typically mapped as a varchar(255) column. You can customize these with column configuration arguments:

If you use a Hibernate type that requires multiple column definitions you can use the column method to define each column:

Note that if you have a static method that is the same name as one of your properties you are trying to configure or you use the same property name as one of the static GORM methods this can lead to conflicts. To avoid this scenario scope the mapping configuration using the delegate property:

设置生成表创建sql(DDL)时使用的注释.

Usage: comment(string)

参数:

Customizes the discriminator column used in table-per-hierarchy inheritance mapping. Has no effect when using table-per-subclass inheritance mapping.

Usage: discriminator(string/map)

Arguments:

By default when mapping inheritance Grails uses a single-table model where all classes share the same table. A discriminator column is used to determine the type for each row, by default the full class name. You can use the discriminator method to customize what’s stored:

You can also customize the discriminator column name:

Or you can use a formula:

Whether to dynamically build INSERT queries

Usage: dynamicInsert(boolean)

By default Hibernate generates all queries at startup and caches them. This helps performance since insert, update, and delete queries don’t have to be dynamically generated at runtime. However, there are certain circumstances where dynamic queries are useful.

For example if you were using custom UserType to hash passwords, every time an UPDATE occurred, the password would get re-hashed. The dynamicInsert method lets you turn off the dynamic creation of queries that uses only the properties that are needed to perform the insert.

Whether to dynamically build UPDATE queries

Usage: dynamicUpdate(boolean)

By default Hibernate generates all queries at startup and caches them. This helps performance since insert, update, and delete queries don’t have to be dynamically generated at runtime. However, there are certain circumstances where dynamic queries are useful.

For example if you were using custom UserType to hash passwords, every time an UPDATE occurred, the password would get re-hashed. The dynamicUpdate method lets you turn off the dynamic creation of queries that uses only the properties that are needed to perform the update.

Configures the fetching behavior of an association.

Usage: association_name(fetch:string)

Arguments:

By default GORM assumes fetching of associations is done using a SELECT when the association is accessed. If you prefer that the association be fetched eagerly at the same time then you can override the behavior:

Here the books association will be fetched using a join at the same time the author is retrieved, for example:

Note that excessive use of joins can be a performance bottleneck. See the section on Eager vs Lazing Fetching in the user guide.

Customizes the way the identifier for a domain class is generated

Usage: id(map)

Arguments:

By default GORM uses the native strategy to generate a database identifier for each entity (typically an auto-incrementing column or a sequence). You can alter this with the id methods generator argument:

You can also use the method to define a composite identifier:

or change the name of the property that defines the identifier:

You can also alter the column definition:

See the section on Custom Database Identity in the user guide for more information.

Specifies how foreign keys that reference missing rows are handled in many-to-one relationships.

Usage: association_name(ignoreNotFound: boolean)

When the data in the database is corrupt and a foreign key references a non existent record, Hibernate will complain with a "No row with the given identifier exists" message. For example, a LegacyCdDomain record may have a reference to a Thumbnail record with an ID of 1234, but the database may no longer contain a Thumbnail with that ID.

One possible way to load such corrupt data is to use the ignoreNotFound mapping option. If you set it to true, Hibernate will treat a missing row as a null association. So in the above example, our LegacyCdDomain instance would load but its thumbnail property would be null. Specifying a value of false for ignoreNotFound will result in Hibernate throwing an org.hibernate.ObjectNotFoundException.

The default value for this setting is false. It maps to Hibernate’s not-found property.

This settings can be useful if you have a legacy database with unusual behaviour when it comes to referential integrity.

Customizes the index column definition of an indexed collection such as a List or Map

Usage: association_name(indexColumn:map)

Arguments:

By default when mapping an indexed collection such as a Map or List the index is stored in a column called association_name_idx which is an integer type in the case of lists and a String in the case of maps. You can alter how the index column is mapped using the indexColumn argument:

Determines whether a property’s database column is set when a new instance is persisted.

Usage: association_name(insertable: boolean)

Useful in general where you don’t want to set an initial value (or include the column in the generated SQL) during an initial save().

In particular this is useful for one-to-many relationships. For example when you store the foreign key in the child table, it’s often efficient to save the child using only the foreign key of the parent. You do this by setting the parent object (and the parent foreign key) in the child entity. Setting the attributes insertable:false and updateable:false for the belongsTo parent object lets you insert and update using only the foreign key.

Customizes the join table used for undirectional one-to-many, many-to-many and primitive collection types.

Basic collection type:

Enum collection types:

Many-to-many:

Unidirectional One-to-many:

Usage: association_name(joinTable:map)

Arguments:

GORM has various strategies for mapping association types. Some of them, such as basic collection types and many-to-many associations, use a join table. You can customize how this join table is created using the joinTable argument.

Configures whether to use proxies and lazy loading for one-to-one and many-to-one associations.

Usage: association_name(lazy: boolean)

By default GORM single-ended associations are lazy in that when you load a domain instance, an associated domain is not loaded until accessed. Hibernate creates a dynamic proxy by subclassing the domain class and proxying all methods and property access.

This can have some strange side effects (see this page on proxies at the Hibernate site) particularly in relation to inheritance. You can tell Hibernate not use proxies for single-ended associations by using the lazy argument:

See the section on Eager vs Lazing Fetching in the user guide.

Customizes the default sort order of query results.

Usage: order(string)

Arguments:

By defaults results are sorted in ascending order. With the order method you can alter results to be sorted in descending order. See also the sort method.

Customizes the default property to sort by for query results.

Usage: sort(string/map)

By default results are sorted by creation date, and you can specify the column to order by in a query:

However, you can also configure the default sort property:

in which case the sort argument is no longer needed. You can also control the sort order:

自定义的domain类关联的数据库表的名称

Usage: table(string/map)

Arguments:

默认情况下，domain类的表的映射名字是基于类的名字。GORM将类名的java风格驼峰格式映射为表名时，使用下划线隔离。例如` productreview 成为 product_review `。你可以用`table`方法重写表名:

也可以指定 schema 和 catalog名称:

Configures the Hibernate type for a particular property.

Changing to a text type (CLOB or TEXT depending on database dialect):

User types with multiple columns:

Usage: association_name(type:string/class)

Hibernate will attempt to automatically select the appropriate database type from the field typed based on configuration in the Dialect class that is being used. But you can override the defaults if necessary. For example String values are mapped by default to varchar(255) columns. To store larger String values you can use a text type instead:

Hibernate also has the concept of custom UserType implementations. In this case you specify the UserType class. If the UserType maps to multiple columns you may need to specify a mapping for each column:

Determines whether a property’s database column is updated when persistent instances are updated.

Usage: association_name(updateable: boolean)

Useful in general where you don’t want to update a value (or include the column in the generated SQL) during a save().

In particular this is useful for one-to-many relationships. For example when you store the foreign key in the child table, it’s often efficient to save the child using only the foreign key of the parent. You do this by setting the parent object (and the parent foreign key) in the child entity. Setting the attributes insertable:false and updateable:false for the belongsTo parent object lets you insert and update using only the foreign key.

用于禁用乐观锁定或更改保持版本的列.

Usage: version(string/boolean)

默认情况下，GORM配置 optimistic locking 启用. 可以通过设置 version 方法的 `false`参数来禁用:

可以将名称传递到 `version`方法以更改数据库列的名称: