Tech Community Register Log in. Asked in community. Nullable ; Any help? Insert ;. No Answers yet. IDs that would correspond to an enum or system user. Is there any way to force NHibernate to commit the record using the ID that I specify, rather than an auto-generated one?
Any other commits to the repository thereafter can be auto-generated. If you want the application to assign identifiers as opposed to having NHibernate generate them , you may use the assigned generator. This special generator will use the identifier value already assigned to the object's identifier property.
Be very careful when using this feature to assign keys with business meaning almost always a terrible design decision. Due to its inherent nature, entities that use this generator cannot be saved via the ISession's SaveOrUpdate method.
Instead you have to explicitly specify to NHibernate if the object should be saved or updated by calling either the Save or Update method of the ISession. Permalink master. Branches Tags. Could not load branches.
Could not load tags. Raw Blame. Open with Desktop View raw View blame. This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters. Learn more about bidirectional Unicode characters.
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. MappingModel ;. Identity ;. UserSupplied ;. Do not use in a cluster. Increment ;. Increment paramValues ;. Any integral property type is thus supported. The property-ref attribute should only be used for mapping legacy data where a foreign key refers to a unique key of the associated table other than the primary key.
This is a complicated and confusing relational model. For example, if the Product class had a unique serial number that is not the primary key, mapped as below:. Then the mapping for OrderItem might use:. If the referenced unique key is the property of a component, you can specify a property path:. A one-to-one association to another persistent class is declared using a one-to-one element.
This option affects the order in which Save and Delete are cascaded, and determines whether the association can be proxied. It is also used by the schema export tool. If this is not the case, you can specify another column or expression to join on using an SQL formula. Primary key associations don't need an extra table column; if two rows are related by the association then the two table rows share the same primary key value.
So if you want two objects to be related by a primary key association, you must make sure that they are assigned the same identifier value!
For a primary key association, add the following mappings to Employee and Person , respectively. We use a special NHibernate identifier generation strategy called foreign :. A newly saved instance of Person is then assigned the same primary key value as the Employee instance referred with the Employee property of that Person. Alternatively, a foreign key with a unique constraint, from Employee to Person , may be expressed as:.
And this association may be made bidirectional by adding the following to the Person mapping:. Even though we recommend the use of surrogate keys as primary keys, you should still try to identify natural keys for all entities. A natural key is a property or combination of properties that is unique and non-null. If it is also immutable, even better.
NHibernate will generate the necessary unique key and nullability constraints, and your mapping will be more self-documenting.
We strongly recommend that you implement Equals and GetHashCode to compare the natural key properties of the entity. Components may, in turn, declare their own properties, components or collections. See Chapter 8, Component Mapping.
For more informations, see lazy on property element. When a lazy property is accessed on an object, included when the property is a component, the other lazy properties of the lazy group are also loaded with it. When using dictionaries, the property names refer to keys of the dictionary. See Section 8. The most important use of the construct is that it allows a combination of properties to be the target of a property-ref. It is also a convenient way to define a multi-column unique constraint.
For example:. It is not an actual property name. It determines if a version increment should occur when these properties are dirty. You might have some legacy data association that refers to this unique key of the Person table, instead of to the primary key:. The use of this outside the context of mapping legacy data is not recommended. Polymorphic persistence requires the declaration of each subclass of the root persistent class. NET class name of the subclass, including its assembly name.
Each subclass should declare its own persistent properties and subclasses. Each subclass in a hierarchy must define a unique discriminator-value. If none is specified, the fully qualified. NET class name is used. For information about inheritance mappings, see Chapter 9, Inheritance Mapping.
Each subclass can also be mapped to its own table. This is called the table-per-subclass mapping strategy. An inherited state is retrieved by joining with the table of the superclass. No discriminator column is required for this mapping strategy. The mapping at the start of the chapter would be re-written as:. A third option is to map only the concrete classes of an inheritance hierarchy to tables, the table-per-concrete-class strategy where each table defines all persistent state of the class, including inherited state.
In NHibernate, it is not absolutely necessary to explicitly map such inheritance hierarchies. However, if you wish use polymorphic associations e.
This is useful if you want to have a view instead of a table. For example, the address information for a person can be mapped to a separate table while preserving value type semantics for all properties :. This feature is often only useful for legacy data models, we recommend fewer tables than classes and a fine-grained domain model. However, it is useful for switching between inheritance mapping strategies in a single hierarchy, as explained later.
It appears anywhere the parent mapping element defines a join to a new table that references the primary key of the original table. It also defines the foreign key in the joined table:.
It is provided for legacy data. This is implied whenever the foreign key is also part of the primary key. This is implied whenever the foreign key is also the primary key. Be aware that this feature bypasses NHibernate's usual optimistic locking strategy for versioned data. The not-null and update attributes are useful when mapping an unidirectional one-to-many association. Most of the attributes on column provide a means of tailoring the DDL during automatic schema generation.
The column and formula elements can even be combined within the same property or association mapping to express, for example, exotic join conditions.
Collections are discussed in Chapter 6, Collection Mapping. Suppose your application has two persistent classes with the same name, and you don't want to specify the fully qualified name in NHibernate queries. You may even import classes and interfaces that are not explicitly mapped. NET class, including its assembly name.
There is one more type of property mapping. This type of mapping requires more than one column. The first column contains the type of the associated entity. The remaining columns contain the identifier.
It is impossible to specify a foreign key constraint for this kind of association. This is not the usual way of mapping polymorphic associations and you should use this only in special cases.
For example, for audit logs, user session data, etc. The meta-type attribute allows the application to specify a custom type that maps database column values to persistent classes that have identifier properties of the type specified by id-type. If the meta-type is class , nothing else is required. The class full name will be persisted in the database as the type of the associated entity. On the other hand, if it is a basic type like int or char , you must specify the mapping from values to classes.
Here is an example with string. String types are a special case: they can be used without meta-values, in which case they will behave much like the class meta-type. It defines whether a version increment should occur if this property is dirty. To understand the behaviour of various. NET language-level objects with respect to the persistence service, we need to classify them into two groups:.
An entity exists independently of any other objects holding references to the entity. Contrast this with the usual. NET model where an unreferenced object is garbage collected.
Entities must be explicitly saved and deleted except that saves and deletions may be cascaded from a parent entity to its children. This is different from the ODMG model of object persistence by reachability - and corresponds more closely to how application objects are usually used in large systems. Entities support circular and shared references. They may also be versioned. An entity's persistent state consists of references to other entities and instances of value types.
Values are primitives, collections, components and certain immutable objects. Unlike entities, values in particular collections and components are persisted and deleted by reachability. Since value objects and primitives are persisted and deleted along with their containing entity they may not be independently versioned. Values have no independent identity, so they cannot be shared by two entities or collections.
All NHibernate types except collections support null semantics if the. NET type is nullable i. Up until now, we've been using the term "persistent class" to refer to entities. We will continue to do that. Strictly speaking, however, not all user-defined classes with persistent state are entities.
A component is a user defined class with value semantics. The challenge is to map the. The bridge between both systems is provided by NHibernate. The value of this attribute is the name of a NHibernate mapping type. NHibernate provides a range of mappings for standard. Net value types out of the box. You can write your own mapping types and implement your own custom conversion strategies.
The basic types may be roughly categorized into three groups - System. ValueType types, System. Object types, and System. Object types for large objects. Just like Columns for System. Otherwise null will be replaced by the default value for the type when reading, and then will be overwritten by it when persisting the entity, potentially leading to phantom updates.
Since NHibernate v5. DateTime2 is used instead of DbType. String types use by default. Net default string equality, which is case sensitive and culture insensitive. When a string type is used as an identifier, if the underlying database string equality semantic differs, it may cause issues. For example, loading a children collection by a string parent key stored in a case insensitive column may cause matching children having their parent key differing by the case to be ignored by NHibernate by default.
String types comparer can be set for matching the database or column behavior. To set the default comparer for all string types, affect by code a StringComparer to AbstractStringType. DefaultComparer static property. IgnoreCase : true for case insensitive comparisons. Any other value will result in case sensitive comparisons. ComparerCulture : Current for using the application current culture, Invariant for using the invariant culture, Ordinal for using ordinal comparison, or any valid culture name for using another culture.
By default, ordinal comparisons are used. These settings should be used in order to match the database or column behavior. They are not taken into account by the hbm2ddl tool for generating the database schema. In other words, it will not generate matching collate statements for SQL-Server.
NHibernate supports some additional type names for compatibility with Java's Hibernate useful for those coming over from Hibernate or using some of the tools to generate hbm. To see all of the conversions you can view the source of static constructor of the class NHibernate. Default NHibernate types used when no type attribute is specified can be overridden by using the NHibernate.
RegisterType static method before configuring and building session factories. It is relatively easy for developers to create their own value types. NHibernate does not provide a built-in type for this. But custom types are not limited to mapping a property or collection element to a single table column.
To implement a custom type, implement either NHibernate. IUserType or NHibernate. ICompositeUserType and declare properties using the fully qualified name of the type.
Check out NHibernate. DoubleStringType to see the kind of things that are possible. The later is to be used with collections, see Section 6.
0コメント