private static void BindCache(HbmCache cacheSchema, RootClass rootClass)
{
if (cacheSchema != null)
{
rootClass.CacheConcurrencyStrategy = cacheSchema.usage.ToCacheConcurrencyStrategy();
rootClass.CacheRegionName = cacheSchema.region;
}
}
private static void BindCache(HbmCacheType cacheSchema, RootClass rootClass)
{
if (cacheSchema != null)
{
rootClass.CacheConcurrencyStrategy = GetXmlEnumAttribute(cacheSchema.usage);
rootClass.CacheRegionName = cacheSchema.region;
}
}
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 void Bind(System.Type entity)
{
var rootClass = new RootClass();
BindClass(entity, rootClass);
}
public IIdentifierGenerator CreateIdentifierGenerator(Dialect.Dialect dialect, string defaultCatalog,
string defaultSchema, RootClass rootClass)
{
Dictionary<string, string> @params = new Dictionary<string, string>();
//if the hibernate-mapping did not specify a schema/catalog, use the defaults
//specified by properties - but note that if the schema/catalog were specified
//in hibernate-mapping, or as params, they will already be initialized and
//will override the values set here (they are in identifierGeneratorProperties)
if (!string.IsNullOrEmpty(defaultSchema))
{
@params[PersistentIdGeneratorParmsNames.Schema] = defaultSchema;
}
if (!string.IsNullOrEmpty(defaultCatalog))
{
@params[PersistentIdGeneratorParmsNames.Catalog] = defaultCatalog;
}
//pass the entity-name, if not a collection-id
if (rootClass != null)
{
@params[IdGeneratorParmsNames.EntityName] = rootClass.EntityName;
}
//init the table here instead of earlier, so that we can get a quoted table name
//TODO: would it be better to simply pass the qualified table name, instead of
// splitting it up into schema/catalog/table names
string tableName = Table.GetQuotedName(dialect);
@params[PersistentIdGeneratorParmsNames.Table] = tableName;
//pass the column name (a generated id almost always has a single column and is not a formula)
IEnumerator enu = ColumnIterator.GetEnumerator();
enu.MoveNext();
string columnName = ((Column)enu.Current).GetQuotedName(dialect);
@params[PersistentIdGeneratorParmsNames.PK] = columnName;
if (rootClass != null)
{
StringBuilder tables = new StringBuilder();
bool commaNeeded = false;
foreach (Table identityTable in rootClass.IdentityTables)
{
if (commaNeeded)
tables.Append(StringHelper.CommaSpace);
commaNeeded = true;
tables.Append(identityTable.GetQuotedName(dialect));
}
@params[PersistentIdGeneratorParmsNames.Tables] = tables.ToString();
}
else
{
@params[PersistentIdGeneratorParmsNames.Tables] = tableName;
}
if (identifierGeneratorProperties != null)
{
ArrayHelper.AddAll(@params, identifierGeneratorProperties);
}
return IdentifierGeneratorFactory.Create(identifierGeneratorStrategy, Type, @params, dialect);
}
public IIdentifierGenerator CreateIdentifierGenerator(Dialect.Dialect dialect, string defaultCatalog,
string defaultSchema, RootClass rootClass)
{
Dictionary <string, string> @params = new Dictionary <string, string>();
//if the hibernate-mapping did not specify a schema/catalog, use the defaults
//specified by properties - but note that if the schema/catalog were specified
//in hibernate-mapping, or as params, they will already be initialized and
//will override the values set here (they are in identifierGeneratorProperties)
if (!string.IsNullOrEmpty(defaultSchema))
{
@params[PersistentIdGeneratorParmsNames.Schema] = defaultSchema;
}
if (!string.IsNullOrEmpty(defaultCatalog))
{
@params[PersistentIdGeneratorParmsNames.Catalog] = defaultCatalog;
}
//pass the entity-name, if not a collection-id
if (rootClass != null)
{
@params[IdGeneratorParmsNames.EntityName] = rootClass.EntityName;
}
//init the table here instead of earlier, so that we can get a quoted table name
//TODO: would it be better to simply pass the qualified table name, instead of
// splitting it up into schema/catalog/table names
string tableName = Table.GetQuotedName(dialect);
@params[PersistentIdGeneratorParmsNames.Table] = tableName;
//pass the column name (a generated id almost always has a single column and is not a formula)
IEnumerator enu = ColumnIterator.GetEnumerator();
enu.MoveNext();
string columnName = ((Column)enu.Current).GetQuotedName(dialect);
@params[PersistentIdGeneratorParmsNames.PK] = columnName;
if (rootClass != null)
{
StringBuilder tables = new StringBuilder();
bool commaNeeded = false;
foreach (Table identityTable in rootClass.IdentityTables)
{
if (commaNeeded)
{
tables.Append(StringHelper.CommaSpace);
}
commaNeeded = true;
tables.Append(identityTable.GetQuotedName(dialect));
}
@params[PersistentIdGeneratorParmsNames.Tables] = tables.ToString();
}
else
{
@params[PersistentIdGeneratorParmsNames.Tables] = tableName;
}
if (identifierGeneratorProperties != null)
{
ArrayHelper.AddAll(@params, identifierGeneratorProperties);
}
return(IdentifierGeneratorFactory.Create(identifierGeneratorStrategy, Type, @params, dialect));
}
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 );
}
public static void BindRoot( XmlDocument doc, Mappings model )
{
XmlNode hmNode = doc.DocumentElement;
XmlAttribute schemaNode = hmNode.Attributes[ "schema" ];
model.SchemaName = ( schemaNode == null ) ? null : schemaNode.Value;
XmlAttribute dcNode = hmNode.Attributes[ "default-cascade" ];
model.DefaultCascade = ( dcNode == null ) ? "none" : dcNode.Value;
XmlAttribute daNode = hmNode.Attributes[ "default-access" ];
model.DefaultAccess = ( daNode == null ) ? "property" : daNode.Value;
XmlAttribute aiNode = hmNode.Attributes[ "auto-import" ];
model.IsAutoImport = ( aiNode == null ) ? true : "true".Equals( aiNode.Value );
XmlAttribute nsNode = hmNode.Attributes[ "namespace" ];
model.DefaultNamespace = ( nsNode == null ) ? null : nsNode.Value;
XmlAttribute assemblyNode = hmNode.Attributes[ "assembly" ];
model.DefaultAssembly = ( assemblyNode == null ) ? null : assemblyNode.Value;
nsmgr = new XmlNamespaceManager( doc.NameTable );
// note that the prefix has absolutely nothing to do with what the user
// selects as their prefix in the document. It is the prefix we use to
// build the XPath and the nsmgr takes care of translating our prefix into
// the user defined prefix...
nsmgr.AddNamespace( nsPrefix, Configuration.MappingSchemaXMLNS );
foreach( XmlNode n in hmNode.SelectNodes( nsClass, nsmgr ) )
{
RootClass rootclass = new RootClass();
Binder.BindRootClass( n, rootclass, model );
model.AddClass( rootclass );
}
foreach( XmlNode n in hmNode.SelectNodes( nsSubclass, nsmgr ) )
{
PersistentClass superModel = GetSuperclass( model, n );
HandleSubclass( superModel, model, n );
}
foreach( XmlNode n in hmNode.SelectNodes( nsJoinedSubclass, nsmgr ) )
{
PersistentClass superModel = GetSuperclass( model, n );
HandleJoinedSubclass( superModel, model, n );
}
foreach( XmlNode n in hmNode.SelectNodes( nsQuery, nsmgr ) )
{
string qname = n.Attributes[ "name" ].Value;
string query = n.InnerText;
log.Debug( "Named query: " + qname + " -> " + query );
model.AddQuery( qname, query );
}
foreach( XmlNode n in hmNode.SelectNodes( nsSqlQuery, nsmgr ) )
{
string qname = n.Attributes[ "name" ].Value;
NamedSQLQuery namedQuery = new NamedSQLQuery( n.InnerText );
foreach( XmlNode returns in n.SelectNodes( nsReturn, nsmgr ) )
{
string alias = returns.Attributes[ "alias" ].Value;
System.Type clazz = ClassForNameChecked(
returns.Attributes[ "class" ].Value, model,
"class not found: {0} for alias " + alias );
namedQuery.AddAliasedClass( alias, clazz );
}
foreach( XmlNode table in n.SelectNodes( nsSynchronize, nsmgr ) )
{
namedQuery.AddSynchronizedTable( table.Attributes[ "table" ].Value );
}
log.Debug( "Named sql query: " + qname + " -> " + namedQuery.QueryString );
model.AddSQLQuery( qname, namedQuery );
}
foreach( XmlNode n in hmNode.SelectNodes( nsImport, nsmgr ) )
{
string className = FullClassName( n.Attributes[ "class" ].Value, model );
XmlAttribute renameNode = n.Attributes[ "rename" ];
string rename = ( renameNode == null ) ? StringHelper.GetClassname( className ) : renameNode.Value;
log.Debug( "Import: " + rename + " -> " + className );
model.AddImport( className, rename );
}
}
private static void AssertDeserializedMappingClasses(RootClass deserializedClassMapping)
{
var deserializedComponentPropertyMapping = deserializedClassMapping.GetProperty("ComponentPropertyInClass");
var deserializedComponentMapping = (NHibernate.Mapping.Component)deserializedComponentPropertyMapping.Value;
var deserializedComponentType = (IAbstractComponentType)deserializedComponentMapping.Type;
var deserializedStringPropertyInComponentMapping = deserializedComponentMapping.GetProperty("StringPropertyInComponent");
// Must be all the same objects since CascadeStyles are singletons and are
// compared with "==" and "!=" operators.
Assert.AreSame(CascadeStyle.None, deserializedStringPropertyInComponentMapping.CascadeStyle);
Assert.AreSame(CascadeStyle.None, deserializedComponentType.GetCascadeStyle(0));
Assert.AreSame(CascadeStyle.None, deserializedComponentPropertyMapping.CascadeStyle);
}
private static RootClass CreateMappingClasses()
{
var classMapping = new RootClass();
var componentMapping = new NHibernate.Mapping.Component(classMapping);
var componentPropertyMapping = new Property(componentMapping);
componentPropertyMapping.Name = "ComponentPropertyInClass";
classMapping.AddProperty(componentPropertyMapping);
var stringValue = new SimpleValue();
stringValue.TypeName = typeof(string).FullName;
var stringPropertyInComponentMapping = new Property(stringValue);
stringPropertyInComponentMapping.Name = "StringPropertyInComponent";
componentMapping.AddProperty(stringPropertyInComponentMapping);
var componentType = (IAbstractComponentType)componentMapping.Type;
Assume.That(CascadeStyle.None == stringPropertyInComponentMapping.CascadeStyle);
Assume.That(CascadeStyle.None == componentType.GetCascadeStyle(0));
Assume.That(CascadeStyle.None == componentPropertyMapping.CascadeStyle);
return classMapping;
}
public IPersistentClassInformation GetClassMapping(string path)
{
var rc = new RootClass();
foreach (string p in probe.GetProperties(path))
{
var ser = new JavaScriptSerializer();
var obj = ser.DeserializeObject(p) as IDictionary<string,object>;
var prop = new Property();
prop.Value = NHValueJSonHelper.JSonDeserialize(prop.GetType().Assembly, obj["Value"] as IDictionary<string,object>) as IValue;
prop.Name = obj["Name"] as string;
rc.AddProperty( prop);
}
return ConfigurationMapper.MapClass(rc);
}
public CreateKeySecondPass(RootClass rootClass)
{
this.rootClass = rootClass;
}
private static void BindVersioningProperty(Table table, XmlNode subnode, Mappings mappings, string name, RootClass entity)
{
string propertyName = subnode.Attributes["name"].Value;
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 prop = new Mapping.Property(val);
BindProperty(subnode, prop, mappings);
// for version properties marked as being generated, make sure they are "always"
// generated; "insert" is invalid. This is dis-allowed by the schema, but just to make
// sure...
if (prop.Generation == PropertyGeneration.Insert)
{
throw new MappingException("'generated' attribute cannot be 'insert' for versioning property");
}
MakeVersion(subnode, val);
entity.Version = prop;
entity.AddProperty(prop);
}
public static void BindRoot(XmlDocument doc, Mappings mappings)
{
nsmgr = BuildNamespaceManager(doc.NameTable);
XmlNode hmNode = doc.DocumentElement;
ExtractRootAttributes(hmNode, mappings);
foreach (XmlNode n in hmNode.SelectNodes(HbmConstants.nsFilterDef, nsmgr))
{
ParseFilterDef(n, mappings);
}
foreach (XmlNode n in hmNode.SelectNodes(HbmConstants.nsClass, nsmgr))
{
RootClass rootclass = new RootClass();
BindRootClass(n, rootclass, mappings);
mappings.AddClass(rootclass);
}
foreach (XmlNode n in hmNode.SelectNodes(HbmConstants.nsSubclass, nsmgr))
{
PersistentClass superModel = GetSuperclass(mappings, n);
HandleSubclass(superModel, mappings, n);
}
foreach (XmlNode n in hmNode.SelectNodes(HbmConstants.nsJoinedSubclass, nsmgr))
{
PersistentClass superModel = GetSuperclass(mappings, n);
HandleJoinedSubclass(superModel, mappings, n);
}
foreach (XmlNode n in hmNode.SelectNodes(HbmConstants.nsQuery, nsmgr))
{
BindNamedQuery(n, null, mappings);
}
foreach (XmlNode n in hmNode.SelectNodes(HbmConstants.nsSqlQuery, nsmgr))
{
BindNamedSQLQuery(n, null, mappings);
}
foreach (XmlNode n in hmNode.SelectNodes(HbmConstants.nsImport, nsmgr))
{
string className = FullClassName(n.Attributes["class"].Value, mappings);
XmlAttribute renameNode = n.Attributes["rename"];
string rename = (renameNode == null) ? StringHelper.GetClassname(className) : renameNode.Value;
log.Debug("Import: " + rename + " -> " + className);
mappings.AddImport(className, rename);
}
foreach (XmlNode n in hmNode.SelectNodes(HbmConstants.nsDatabaseObject, nsmgr))
{
BindAuxiliaryDatabaseObject(n, mappings);
}
foreach (XmlNode n in hmNode.SelectNodes(HbmConstants.nsResultset, nsmgr))
{
BindResultSetMappingDefinition(n, null, mappings);
}
}
