public void Bind(HbmClass classSchema, IDictionary<string, MetaAttribute> inheritedMetas)
{
var rootClass = new RootClass();
BindClass(classSchema, rootClass, inheritedMetas);
// OPTIMISTIC LOCK MODE
rootClass.OptimisticLockMode = classSchema.optimisticlock.ToOptimisticLock();
inheritedMetas = GetMetas(classSchema, inheritedMetas, true); // get meta's from <class>
//TABLENAME
string schema = classSchema.schema ?? mappings.SchemaName;
string catalog = classSchema.catalog ?? mappings.CatalogName;
string tableName = GetClassTableName(rootClass, classSchema);
if (string.IsNullOrEmpty(tableName))
{
throw new MappingException(
string.Format(
"Could not determine the name of the table for entity '{0}'; remove the 'table' attribute or assign a value to it.",
rootClass.EntityName));
}
Table table = mappings.AddTable(schema, catalog, tableName, classSchema.Subselect, rootClass.IsAbstract.GetValueOrDefault(), classSchema.schemaaction);
((ITableOwner) rootClass).Table = table;
log.InfoFormat("Mapping class: {0} -> {1}", rootClass.EntityName, rootClass.Table.Name);
rootClass.IsMutable = classSchema.mutable;
rootClass.Where = classSchema.where ?? rootClass.Where;
if (classSchema.check != null)
table.AddCheckConstraint(classSchema.check);
rootClass.IsExplicitPolymorphism = classSchema.polymorphism == HbmPolymorphismType.Explicit;
BindCache(classSchema.cache, rootClass);
new ClassIdBinder(this).BindId(classSchema.Id, rootClass, table);
new ClassCompositeIdBinder(this).BindCompositeId(classSchema.CompositeId, rootClass);
new ClassDiscriminatorBinder(rootClass, Mappings).BindDiscriminator(classSchema.discriminator, table);
BindTimestamp(classSchema.Timestamp, rootClass, table, inheritedMetas);
BindVersion(classSchema.Version, rootClass, table, inheritedMetas);
if (!String.IsNullOrEmpty(classSchema.primaryKeyName)) {
rootClass.PrimaryKeyName = classSchema.primaryKeyName;
table.PrimaryKeyName = classSchema.primaryKeyName;
}
rootClass.CreatePrimaryKey(dialect);
BindNaturalId(classSchema.naturalid, rootClass, inheritedMetas);
new PropertiesBinder(mappings, rootClass, dialect).Bind(classSchema.Properties, inheritedMetas);
BindJoins(classSchema.Joins, rootClass, inheritedMetas);
BindSubclasses(classSchema.Subclasses, rootClass, inheritedMetas);
BindJoinedSubclasses(classSchema.JoinedSubclasses, rootClass, inheritedMetas);
BindUnionSubclasses(classSchema.UnionSubclasses, rootClass, inheritedMetas);
new FiltersBinder(rootClass, Mappings).Bind(classSchema.filter);
mappings.AddClass(rootClass);
}
public void Bind(XmlNode node, HbmClass classSchema, IDictionary<string, MetaAttribute> inheritedMetas)
{
RootClass rootClass = new RootClass();
BindClass(node, classSchema, rootClass, inheritedMetas);
inheritedMetas = GetMetas(classSchema, inheritedMetas, true); // get meta's from <class>
//TABLENAME
string schema = classSchema.schema ?? mappings.SchemaName;
string catalog = classSchema.catalog ?? mappings.CatalogName;
string tableName = GetClassTableName(rootClass, classSchema);
if (string.IsNullOrEmpty(tableName))
{
throw new MappingException(
string.Format(
"Could not determine the name of the table for entity '{0}'; remove the 'table' attribute or assign a value to it.",
rootClass.EntityName));
}
Table table = mappings.AddTable(schema, catalog, tableName, null, rootClass.IsAbstract.GetValueOrDefault(), classSchema.schemaaction);
((ITableOwner) rootClass).Table = table;
log.InfoFormat("Mapping class: {0} -> {1}", rootClass.EntityName, rootClass.Table.Name);
rootClass.IsMutable = classSchema.mutable;
rootClass.Where = classSchema.where ?? rootClass.Where;
if (classSchema.check != null)
table.AddCheckConstraint(classSchema.check);
rootClass.IsExplicitPolymorphism = classSchema.polymorphism == HbmPolymorphismType.Explicit;
BindCache(classSchema.cache, rootClass);
new ClassIdBinder(this).BindId(classSchema.Id, rootClass, table);
new ClassCompositeIdBinder(this).BindCompositeId(classSchema.CompositeId, rootClass);
new ClassDiscriminatorBinder(this).BindDiscriminator(classSchema.discriminator, rootClass, table);
BindTimestamp(classSchema.Timestamp, rootClass, table, inheritedMetas);
BindVersion(classSchema.Version, rootClass, table, inheritedMetas);
rootClass.CreatePrimaryKey(dialect);
PropertiesFromXML(node, rootClass, inheritedMetas);
mappings.AddClass(rootClass);
}
public virtual void Bind(ClassMapping classMapping)
{
RootClass rootClass = new RootClass();
BindClass(classMapping, rootClass);
string schema = mappings.SchemaName;
string catalog = mappings.CatalogName;
string tableName = classMapping.Tablename.ValueOrDefault(
mappings.NamingStrategy.TableName(classMapping.Type.Name));
Table table = mappings
.AddTable(schema, catalog, tableName, null,
rootClass.IsAbstract.GetValueOrDefault());//Introduce SchemaAction
((ITableOwner)rootClass).Table = table;
rootClass.IsMutable = true;
rootClass.IsExplicitPolymorphism = false;
new ClassIdBinder(this).BindId(classMapping.Id as IdMapping, rootClass, table);
rootClass.CreatePrimaryKey(dialect);
base.BindProperties(rootClass, classMapping);
mappings.AddClass(rootClass);
}
public static void BindRootClass( XmlNode node, RootClass model, Mappings mappings )
{
BindClass( node, model, mappings );
//TABLENAME
XmlAttribute schemaNode = node.Attributes[ "schema" ];
string schema = schemaNode == null ? mappings.SchemaName : schemaNode.Value;
Table table = mappings.AddTable( schema, GetClassTableName( model, node, mappings ) );
model.Table = table;
log.Info( "Mapping class: " + model.Name + " -> " + model.Table.Name );
//MUTABLE
XmlAttribute mutableNode = node.Attributes[ "mutable" ];
model.IsMutable = ( mutableNode == null ) || mutableNode.Value.Equals( "true" );
//WHERE
XmlAttribute whereNode = node.Attributes[ "where" ];
if( whereNode != null )
{
model.Where = whereNode.Value;
}
//CHECK
XmlAttribute checkNode = node.Attributes[ "check" ];
if( checkNode != null )
{
table.AddCheckConstraint( checkNode.Value );
}
//POLYMORPHISM
XmlAttribute polyNode = node.Attributes[ "polymorphism" ];
model.IsExplicitPolymorphism = ( polyNode != null ) && polyNode.Value.Equals( "explicit" );
foreach( XmlNode subnode in node.ChildNodes )
{
string name = subnode.LocalName; //Name;
string propertyName = GetPropertyName( subnode );
//I am only concerned with elements that are from the nhibernate namespace
if( subnode.NamespaceURI != Configuration.MappingSchemaXMLNS )
{
continue;
}
switch( name )
{
case "id":
SimpleValue id = new SimpleValue( table );
model.Identifier = id;
if( propertyName == null )
{
BindSimpleValue( subnode, id, false, RootClass.DefaultIdentifierColumnName, mappings );
if( id.Type == null )
{
throw new MappingException( "must specify an identifier type: " + model.MappedClass.Name );
}
model.IdentifierProperty = null;
}
else
{
BindSimpleValue( subnode, id, false, propertyName, mappings );
id.SetTypeByReflection( model.MappedClass, propertyName, PropertyAccess( subnode, mappings ) );
Mapping.Property prop = new Mapping.Property( id );
BindProperty( subnode, prop, mappings );
model.IdentifierProperty = prop;
}
if( id.Type.ReturnedClass.IsArray )
{
throw new MappingException( "illegal use of an array as an identifier (arrays don't reimplement equals)" );
}
MakeIdentifier( subnode, id, mappings );
break;
case "composite-id":
Component compId = new Component( model );
model.Identifier = compId;
if( propertyName == null )
{
BindComponent( subnode, compId, null, model.Name, "id", false, mappings );
model.HasEmbeddedIdentifier = compId.IsEmbedded;
model.IdentifierProperty = null;
}
else
{
System.Type reflectedClass = GetPropertyType( subnode, mappings, model.MappedClass, propertyName );
BindComponent( subnode, compId, reflectedClass, model.Name, propertyName, false, mappings );
Mapping.Property prop = new Mapping.Property( compId );
BindProperty( subnode, prop, mappings );
model.IdentifierProperty = prop;
}
MakeIdentifier( subnode, compId, mappings );
System.Type compIdClass = compId.ComponentClass;
if( !ReflectHelper.OverridesEquals( compIdClass ) )
{
throw new MappingException(
"composite-id class must override Equals(): " + compIdClass.FullName
);
}
if( !ReflectHelper.OverridesGetHashCode( compIdClass ) )
{
throw new MappingException(
"composite-id class must override GetHashCode(): " + compIdClass.FullName
);
}
// Serializability check not ported
break;
case "version":
case "timestamp":
//VERSION
SimpleValue val = new SimpleValue( table );
BindSimpleValue( subnode, val, false, propertyName, mappings );
if( val.Type == null )
{
val.Type = ( ( "version".Equals( name ) ) ? NHibernateUtil.Int32 : NHibernateUtil.Timestamp );
}
Mapping.Property timestampProp = new Mapping.Property( val );
BindProperty( subnode, timestampProp, mappings );
MakeVersion( subnode, val );
model.Version = timestampProp;
model.AddNewProperty( timestampProp );
break;
case "discriminator":
//DISCRIMINATOR
SimpleValue discrim = new SimpleValue( table );
model.Discriminator = discrim;
BindSimpleValue( subnode, discrim, false, RootClass.DefaultDiscriminatorColumnName, mappings );
if( discrim.Type == null )
{
discrim.Type = NHibernateUtil.String;
foreach( Column col in discrim.ColumnCollection )
{
col.Type = NHibernateUtil.String;
break;
}
}
model.IsPolymorphic = true;
if( subnode.Attributes[ "force" ] != null && "true".Equals( subnode.Attributes[ "force" ].Value ) )
{
model.IsForceDiscriminator = true;
}
if( subnode.Attributes[ "insert" ] != null && "false".Equals( subnode.Attributes[ "insert" ].Value ) )
{
model.IsDiscriminatorInsertable = false;
}
break;
case "jcs-cache":
case "cache":
string className = model.MappedClass.FullName;
ICacheConcurrencyStrategy cache = CacheFactory.CreateCache( subnode, className, model.IsMutable );
mappings.AddCache( className, cache );
model.Cache = cache;
break;
}
}
model.CreatePrimaryKey( dialect );
PropertiesFromXML( node, model, mappings );
}
