public ResultSetMappingSecondPass(XmlNode element, String path, Mappings mappings, XmlNamespaceManager nsmgr)
: base(nsmgr)
{
this.element = element;
this.path = path;
this.mappings = mappings;
}
public NamedSQLQuerySecondPass(XmlNode queryElem, string path, Mappings mappings, XmlNamespaceManager nsmgr)
: base(nsmgr)
{
this.queryElem = queryElem;
this.path = path;
this.mappings = mappings;
}
private static void SetDefaultMappingsProperties(Mappings mappings) {
mappings.SchemaName = null;
mappings.DefaultCascade = "none";
mappings.DefaultAccess = "property";
mappings.DefaultLazy = true;
mappings.IsAutoImport = true;
mappings.DefaultNamespace = null;
mappings.DefaultAssembly = null;
}
/// <summary>
/// Converts a partial class name into a fully qualified one
/// </summary>
/// <param name="className"></param>
/// <param name="mapping"></param>
/// <returns></returns>
public static string FullClassName(string className, Mappings mapping)
{
if (className == null)
{
return null;
}
return TypeNameParser.Parse(className, mapping.DefaultNamespace, mapping.DefaultAssembly)
.ToString();
}
private void AddAuditing(Mappings mappings)
{
var auditObjects = new List<IAuxiliaryDatabaseObject>();
foreach (var table in mappings.IterateTables.ToArray())
{
var auditTable = new AuditTable(
table, _namingStrategy, _columnSource);
mappings.AddAuxiliaryDatabaseObject(auditTable);
var insertTrigger = new AuditTrigger(table,
auditTable, _namingStrategy, TriggerActions.INSERT);
mappings.AddAuxiliaryDatabaseObject(insertTrigger);
var updateTrigger = new AuditTrigger(table,
auditTable, _namingStrategy, TriggerActions.UPDATE);
mappings.AddAuxiliaryDatabaseObject(updateTrigger);
var deleteTrigger = new AuditTrigger(table,
auditTable, _namingStrategy, TriggerActions.DELETE);
mappings.AddAuxiliaryDatabaseObject(deleteTrigger);
}
}
/// <summary>
/// Converts a partial class name into a fully qualified one
/// </summary>
/// <param name="className"></param>
/// <param name="mapping"></param>
/// <returns></returns>
public static string FullClassName( string className, Mappings mapping )
{
if( className == null )
{
return null;
}
int commaPosn = className.IndexOf( ',' );
int dotPosn = className.IndexOf( '.' );
// Check for namespace; ok to have a dot after the comma as it's part of the assembly name
bool needNamespace = ( dotPosn == -1 || ( commaPosn > -1 && dotPosn > commaPosn ) ) && mapping.DefaultNamespace != null;
// Add if we don't have any commas and a default exists
bool needAssembly = commaPosn == -1 && mapping.DefaultAssembly != null;
if( needNamespace == false && needAssembly == false )
{
return className;
}
else
{
StringBuilder sb = new StringBuilder();
if( needNamespace )
{
sb.Append( mapping.DefaultNamespace );
sb.Append( "." );
}
sb.Append( className );
if( needAssembly )
{
sb.Append( ", " );
sb.Append( mapping.DefaultAssembly );
}
return sb.ToString();
}
}
public static void BindIntegerValue( XmlNode node, IntegerValue model, string defaultColumnName, bool isNullable, Mappings mappings )
{
BindSimpleValue( node, model, isNullable, defaultColumnName, mappings );
if( model.ColumnCollection.Count > 1 )
{
log.Error( "This shouldn't happen, check BindIntegerValue" );
}
foreach( Column col in model.ColumnCollection )
{
col.Type = NHibernateUtil.Int32;
col.TypeIndex = 0;
break;
}
}
public static void BindColumns( XmlNode node, SimpleValue model, bool isNullable, bool autoColumn, string propertyPath, Mappings mappings )
{
//COLUMN(S)
XmlAttribute columnAttribute = node.Attributes[ "column" ];
if( columnAttribute == null )
{
int count = 0;
Table table = model.Table;
foreach( XmlNode columnElement in node.SelectNodes( nsColumn, nsmgr ) )
{
Column col = new Column( model.Type, count++ );
BindColumn( columnElement, col, isNullable );
string name = columnElement.Attributes[ "name" ].Value;
col.Name = mappings.NamingStrategy.ColumnName( name );
if( table != null )
{
table.AddColumn( col );
}
//table=null -> an association, fill it in later
model.AddColumn( col );
//column index
XmlAttribute indexNode = columnElement.Attributes[ "index" ];
if( indexNode != null && table != null )
{
table.GetIndex( indexNode.Value ).AddColumn( col );
}
//column group index (although it can serve as a separate column index)
XmlAttribute parentElementIndexAttr = node.Attributes[ "index" ];
if( parentElementIndexAttr != null && table != null )
{
table.GetIndex( parentElementIndexAttr.Value ).AddColumn( col );
}
XmlAttribute uniqueNode = columnElement.Attributes[ "unique-key" ];
if( uniqueNode != null && table != null )
{
table.GetUniqueKey( uniqueNode.Value ).AddColumn( col );
}
}
}
else
{
Column col = new Column( model.Type, 0 );
BindColumn( node, col, isNullable );
col.Name = mappings.NamingStrategy.ColumnName( columnAttribute.Value );
Table table = model.Table;
if( table != null )
{
table.AddColumn( col );
} //table=null -> an association - fill it in later
model.AddColumn( col );
//column group index (although can serve as a separate column index)
XmlAttribute indexAttr = node.Attributes[ "index" ];
if( indexAttr != null && table != null )
{
table.GetIndex( indexAttr.Value ).AddColumn( col );
}
}
if( autoColumn && model.ColumnSpan == 0 )
{
Column col = new Column( model.Type, 0 );
BindColumn( node, col, isNullable );
col.Name = mappings.NamingStrategy.PropertyToColumnName( propertyPath );
model.Table.AddColumn( col );
model.AddColumn( col );
}
}
//automatically makes a column with the default name if none is specifed by XML
public static void BindSimpleValue( XmlNode node, SimpleValue model, bool isNullable, string path, Mappings mappings )
{
model.Type = GetTypeFromXML( node );
XmlAttribute formulaNode = node.Attributes[ "formula" ];
if( formulaNode != null )
{
Formula f = new Formula();
f.FormulaString = formulaNode.InnerText;
model.Formula = f;
}
else
{
BindColumns( node, model, isNullable, true, path, mappings );
}
XmlAttribute fkNode = node.Attributes[ "foreign-key" ];
if( fkNode != null )
{
model.ForeignKeyName = fkNode.Value;
}
}
public override Mapping.Collection Create( XmlNode node, string prefix, string path, PersistentClass owner, Mappings mappings )
{
Map map = new Map( owner );
Binder.BindCollection( node, map, prefix, path, mappings );
return map;
}
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 BindOneToMany( XmlNode node, OneToMany model, Mappings mappings )
{
model.Type = ( EntityType ) NHibernateUtil.Entity(
ClassForNameChecked( node.Attributes[ "class" ].Value, mappings,
"associated class not found: {0}" ) );
}
public static void BindComponent( XmlNode node, Component model, System.Type reflectedClass, string className, string path, bool isNullable, Mappings mappings )
{
XmlAttribute classNode = node.Attributes[ "class" ];
if( "dynamic-component".Equals( node.Name ) )
{
model.IsEmbedded = false;
model.IsDynamic = true;
}
else if( classNode != null )
{
model.ComponentClass = ClassForNameChecked(
classNode.Value, mappings,
"component class not found: {0}" );
model.IsEmbedded = false;
}
else if( reflectedClass != null )
{
model.ComponentClass = reflectedClass;
model.IsEmbedded = false;
}
else
{
// an "embedded" component (ids only)
model.ComponentClass = model.Owner.MappedClass;
model.IsEmbedded = true;
}
foreach( XmlNode subnode in node.ChildNodes )
{
//I am only concerned with elements that are from the nhibernate namespace
if( subnode.NamespaceURI != Configuration.MappingSchemaXMLNS )
{
continue;
}
string name = subnode.LocalName; //.Name;
string propertyName = GetPropertyName( subnode );
string subpath = propertyName == null ? null : StringHelper.Qualify( path, propertyName );
CollectionType collectType = CollectionType.CollectionTypeFromString( name );
IValue value = null;
if( collectType != null )
{
Mapping.Collection collection = collectType.Create( subnode, className, subpath, model.Owner, mappings );
mappings.AddCollection( collection );
value = collection;
}
else if( "many-to-one".Equals( name ) || "key-many-to-one".Equals( name ) )
{
value = new ManyToOne( model.Table );
BindManyToOne( subnode, ( ManyToOne ) value, subpath, isNullable, mappings );
}
else if( "one-to-one".Equals( name ) )
{
value = new OneToOne( model.Table, model.Owner.Identifier );
BindOneToOne( subnode, ( OneToOne ) value, isNullable, mappings );
}
else if( "any".Equals( name ) )
{
value = new Any( model.Table );
BindAny( subnode, ( Any ) value, isNullable, mappings );
}
else if( "property".Equals( name ) || "key-property".Equals( name ) )
{
value = new SimpleValue( model.Table );
BindSimpleValue( subnode, ( SimpleValue ) value, isNullable, subpath, mappings );
}
else if( "component".Equals( name ) || "dynamic-component".Equals( name ) || "nested-composite-element".Equals( name ) )
{
System.Type subreflectedClass = model.ComponentClass == null ?
null :
GetPropertyType( subnode, mappings, model.ComponentClass, propertyName );
value = ( model.Owner != null ) ?
new Component( model.Owner ) : // a class component
new Component( model.Table ); // a composite element
BindComponent( subnode, ( Component ) value, subreflectedClass, className, subpath, isNullable, mappings );
}
else if( "parent".Equals( name ) )
{
model.ParentProperty = propertyName;
}
if( value != null )
{
model.AddProperty( CreateProperty( value, propertyName, model.ComponentClass, subnode, mappings ) );
}
}
int span = model.PropertySpan;
string[ ] names = new string[span];
IType[ ] types = new IType[span];
Cascades.CascadeStyle[ ] cascade = new Cascades.CascadeStyle[span];
OuterJoinFetchStrategy[ ] joinedFetch = new OuterJoinFetchStrategy[span];
int i = 0;
foreach( Mapping.Property prop in model.PropertyCollection )
{
if( prop.IsFormula )
{
throw new MappingException( "properties of components may not be formulas: " + prop.Name );
}
if( !prop.IsInsertable || !prop.IsUpdateable )
{
throw new MappingException( "insert=\"false\", update=\"false\" not supported for properties of components: " + prop.Name );
}
names[ i ] = prop.Name;
types[ i ] = prop.Type;
cascade[ i ] = prop.CascadeStyle;
joinedFetch[ i ] = prop.Value.OuterJoinFetchSetting;
i++;
}
IType componentType;
if( model.IsDynamic )
{
componentType = new DynamicComponentType( names, types, joinedFetch, cascade );
}
else
{
IGetter[ ] getters = new IGetter[span];
ISetter[ ] setters = new ISetter[span];
bool foundCustomAccessor = false;
i = 0;
foreach( Mapping.Property prop in model.PropertyCollection )
{
setters[ i ] = prop.GetSetter( model.ComponentClass );
getters[ i ] = prop.GetGetter( model.ComponentClass );
if( !prop.IsBasicPropertyAccessor )
{
foundCustomAccessor = true;
}
i++;
}
componentType = new ComponentType(
model.ComponentClass,
names,
getters,
setters,
foundCustomAccessor,
types,
joinedFetch,
cascade,
model.ParentProperty );
}
model.Type = componentType;
}
/// <remarks>
/// Called for all collections
/// </remarks>
public static void BindCollection( XmlNode node, Mapping.Collection model, string className, string path, Mappings mappings )
{
//ROLENAME
model.Role = StringHelper.Qualify( className, path );
XmlAttribute inverseNode = node.Attributes[ "inverse" ];
if( inverseNode != null )
{
model.IsInverse = StringHelper.BooleanValue( inverseNode.Value );
}
XmlAttribute orderNode = node.Attributes[ "order-by" ];
if( orderNode != null )
{
model.OrderBy = orderNode.Value;
}
XmlAttribute whereNode = node.Attributes[ "where" ];
if( whereNode != null )
{
model.Where = whereNode.Value;
}
XmlAttribute batchNode = node.Attributes[ "batch-size" ];
if( batchNode != null )
{
model.BatchSize = Int32.Parse( batchNode.Value );
}
//PERSISTER
XmlAttribute persisterNode = node.Attributes[ "persister" ];
if( persisterNode == null )
{
//persister = CollectionPersisterImpl.class;
}
else
{
model.CollectionPersisterClass = ClassForNameChecked(
persisterNode.Value, mappings,
"could not instantiate collection persister class: {0}" );
}
InitOuterJoinFetchSetting( node, model );
XmlNode oneToManyNode = node.SelectSingleNode( nsOneToMany, nsmgr );
if( oneToManyNode != null )
{
OneToMany oneToMany = new OneToMany( model.Owner );
model.Element = oneToMany;
BindOneToMany( oneToManyNode, oneToMany, mappings );
//we have to set up the table later!! yuck
}
else
{
//TABLE
XmlAttribute tableNode = node.Attributes[ "table" ];
string tableName;
if( tableNode != null )
{
tableName = mappings.NamingStrategy.TableName( tableNode.Value );
}
else
{
tableName = mappings.NamingStrategy.PropertyToTableName( className, path );
}
XmlAttribute schemaNode = node.Attributes[ "schema" ];
string schema = schemaNode == null ? mappings.SchemaName : schemaNode.Value;
model.CollectionTable = mappings.AddTable( schema, tableName );
log.Info( "Mapping collection: " + model.Role + " -> " + model.CollectionTable.Name );
}
//LAZINESS
XmlAttribute lazyNode = node.Attributes[ "lazy" ];
if( lazyNode != null )
{
model.IsLazy = StringHelper.BooleanValue( lazyNode.Value );
}
//SORT
XmlAttribute sortedAtt = node.Attributes[ "sort" ];
// unsorted, natural, comparator.class.name
if( sortedAtt == null || sortedAtt.Value.Equals( "unsorted" ) )
{
model.IsSorted = false;
}
else
{
model.IsSorted = true;
string comparatorClassName = FullClassName( sortedAtt.Value, mappings );
if( !comparatorClassName.Equals( "natural" ) )
{
try
{
model.Comparer = ( IComparer ) Activator.CreateInstance( ReflectHelper.ClassForName( comparatorClassName ) );
}
catch
{
throw new MappingException( "could not instantiate comparer class: " + comparatorClassName );
}
}
}
//ORPHAN DELETE (used for programmer error detection)
XmlAttribute cascadeAtt = node.Attributes[ "cascade" ];
if( cascadeAtt != null && cascadeAtt.Value.Equals( "all-delete-orphan" ) )
{
model.OrphanDelete = true;
}
//set up second pass
if( model is List )
{
mappings.AddSecondPass( new ListSecondPass( node, mappings, ( List ) model ) );
}
else if( model is Map )
{
mappings.AddSecondPass( new MapSecondPass( node, mappings, ( Map ) model ) );
}
else if( model is Set )
{
mappings.AddSecondPass( new SetSecondPass( node, mappings, ( Set ) model ) );
}
else if( model is IdentifierCollection )
{
mappings.AddSecondPass( new IdentifierCollectionSecondPass( node, mappings, ( IdentifierCollection ) model ) );
}
else
{
mappings.AddSecondPass( new CollectionSecondPass( node, mappings, model ) );
}
}
public static void BindAny( XmlNode node, Any model, bool isNullable, Mappings mappings )
{
model.IdentifierType = GetTypeFromXML( node );
XmlAttribute metaAttribute = node.Attributes[ "meta-type" ];
if( metaAttribute != null )
{
IType metaType = TypeFactory.HeuristicType( metaAttribute.Value );
if( metaType == null )
{
throw new MappingException( "could not interpret meta-type" );
}
model.MetaType = metaType;
Hashtable values = new Hashtable();
foreach( XmlNode metaValue in node.SelectNodes( nsMetaValue, nsmgr ) )
{
try
{
object value = ((IDiscriminatorType) model.MetaType).FromString( metaValue.Attributes["value"].Value );
System.Type clazz = ReflectHelper.ClassForName( FullClassName( metaValue.Attributes["class"].Value, mappings ) );
values[ value ] = clazz;
}
catch( InvalidCastException )
{
throw new MappingException( "meta-type was not an IDiscriminatorType: " + metaType.Name );
}
catch( HibernateException he )
{
throw new MappingException( "could not interpret meta-value", he );
}
catch( TypeLoadException cnfe )
{
throw new MappingException( "meta-value class not found", cnfe );
}
}
if( values.Count > 0 )
{
model.MetaType = new MetaType( values, model.MetaType );
}
}
BindColumns( node, model, isNullable, false, null, mappings );
}
private static string PropertyAccess( XmlNode node, Mappings mappings )
{
XmlAttribute accessNode = node.Attributes[ "access" ];
return accessNode != null ? accessNode.Value : mappings.DefaultAccess;
}
public override Mapping.Collection Create( XmlNode node, string prefix, string path, PersistentClass owner, Mappings mappings )
{
PrimitiveArray array = new PrimitiveArray( owner );
Binder.BindArray( node, array, prefix, path, mappings );
return array;
}
public override Mapping.Collection Create( XmlNode node, string prefix, string path, PersistentClass owner, Mappings mappings )
{
IdentifierBag bag = new IdentifierBag( owner );
Binder.BindCollection( node, bag, prefix, path, mappings );
return bag;
}
public override Mapping.Collection Create( XmlNode node, string prefix, string path, PersistentClass owner, Mappings mappings )
{
List list = new List( owner );
Binder.BindCollection( node, list, prefix, path, mappings );
return list;
}
public override Mapping.Collection Create( XmlNode node, string prefix, string path, PersistentClass owner, Mappings mappings )
{
Set setCollection = new Set( owner );
Binder.BindCollection( node, setCollection, prefix, path, mappings );
return setCollection;
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <param name="model"></param>
/// <param name="mappings"></param>
public static void BindProperty( XmlNode node, Mapping.Property model, Mappings mappings )
{
model.Name = GetPropertyName( node );
IType type = model.Value.Type;
if( type == null )
{
throw new MappingException( "could not determine a property type for: " + model.Name );
}
model.PropertyAccessorName = PropertyAccess( node, mappings );
XmlAttribute cascadeNode = node.Attributes[ "cascade" ];
model.Cascade = ( cascadeNode == null ) ? mappings.DefaultCascade : cascadeNode.Value;
XmlAttribute updateNode = node.Attributes[ "update" ];
model.IsUpdateable = ( updateNode == null ) ? true : "true".Equals( updateNode.Value );
XmlAttribute insertNode = node.Attributes[ "insert" ];
model.IsInsertable = ( insertNode == null ) ? true : "true".Equals( insertNode.Value );
if( log.IsDebugEnabled )
{
string msg = "Mapped property: " + model.Name;
string columns = Columns( model.Value );
if( columns.Length > 0 )
{
msg += " -> " + columns;
}
if( model.Type != null )
{
msg += ", type: " + model.Type.Name;
}
log.Debug( msg );
}
model.MetaAttributes = GetMetas( node );
}
private static System.Type GetPropertyType( XmlNode definingNode, Mappings mappings,
System.Type containingType, string propertyName )
{
if( definingNode.Attributes[ "class" ] != null )
{
return ClassForNameChecked( definingNode.Attributes[ "class" ].Value, mappings,
"could not find class: {0}" );
}
else if( containingType == null )
{
return null;
}
string access = PropertyAccess( definingNode, mappings );
return ReflectHelper.ReflectedPropertyClass( containingType, propertyName, access );
}
public static void BindManyToOne( XmlNode node, ManyToOne model, string defaultColumnName, bool isNullable, Mappings mappings )
{
BindColumns( node, model, isNullable, true, defaultColumnName, mappings );
InitOuterJoinFetchSetting( node, model );
XmlAttribute ukName = node.Attributes[ "property-ref" ];
if( ukName != null )
{
model.ReferencedPropertyName = ukName.Value;
}
XmlAttribute typeNode = node.Attributes[ "class" ];
if( typeNode != null )
{
model.Type = TypeFactory.ManyToOne(
ClassForNameChecked( typeNode.Value, mappings,
"could not find class: {0}" ),
model.ReferencedPropertyName );
}
XmlAttribute fkNode = node.Attributes[ "foreign-key" ];
if( fkNode != null )
{
model.ForeignKeyName = fkNode.Value;
}
}
public static void BindSetSecondPass( XmlNode node, Set model, IDictionary persistentClasses, Mappings mappings )
{
BindCollectionSecondPass( node, model, persistentClasses, mappings );
if( !model.IsOneToMany )
{
model.CreatePrimaryKey();
}
}
public static void BindOneToOne( XmlNode node, OneToOne model, bool isNullable, Mappings mappings )
{
//BindColumns( node, model, isNullable, false, null, mappings );
InitOuterJoinFetchSetting( node, model );
XmlAttribute constrNode = node.Attributes[ "constrained" ];
bool constrained = constrNode != null && constrNode.Value.Equals( "true" );
model.IsConstrained = constrained;
model.ForeignKeyType = ( constrained ? ForeignKeyType.ForeignKeyFromParent : ForeignKeyType.ForeignKeyToParent );
XmlAttribute fkNode = node.Attributes[ "foreign-key" ];
if( fkNode != null )
{
model.ForeignKeyName = fkNode.Value;
}
XmlAttribute ukName = node.Attributes[ "property-ref" ];
if( ukName != null )
{
model.ReferencedPropertyName = ukName.Value;
}
XmlAttribute classNode = node.Attributes[ "class" ];
if( classNode != null )
{
model.Type = TypeFactory.OneToOne(
ClassForNameChecked( classNode.Value, mappings, "could not find class: {0}" ),
model.ForeignKeyType, model.ReferencedPropertyName );
}
}
public static void BindSubclass( XmlNode node, Subclass model, Mappings mappings )
{
BindClass( node, model, mappings );
if( model.ClassPersisterClass == null )
{
model.RootClazz.ClassPersisterClass = typeof( EntityPersister );
}
model.Table = model.Superclass.Table;
log.Info( "Mapping subclass: " + model.Name + " -> " + model.Table.Name );
// properties
PropertiesFromXML( node, model, mappings );
}
/// <remarks>
/// Called for arrays and primitive arrays
/// </remarks>
public static void BindArray( XmlNode node, Array model, string prefix, string path, Mappings mappings )
{
BindCollection( node, model, prefix, path, mappings );
XmlAttribute att = node.Attributes[ "element-class" ];
if( att != null )
{
model.ElementClass = ClassForNameChecked( att.Value, mappings,
"could not find element class: {0}" );
}
else
{
foreach( XmlNode subnode in node.ChildNodes )
{
string name = subnode.LocalName; //.Name;
//I am only concerned with elements that are from the nhibernate namespace
if( subnode.NamespaceURI != Configuration.MappingSchemaXMLNS )
{
continue;
}
switch( name )
{
case "element":
IType type = GetTypeFromXML( subnode );
model.ElementClass = type.ReturnedClass;
break;
case "one-to-many":
case "many-to-many":
case "composite-element":
model.ElementClass = ClassForNameChecked(
subnode.Attributes[ "class" ].Value, mappings,
"element class not found: {0}" );
break;
}
}
}
}
private static string GetClassTableName( PersistentClass model, XmlNode node, Mappings mappings )
{
XmlAttribute tableNameNode = node.Attributes[ "table" ];
if( tableNameNode == null )
{
return mappings.NamingStrategy.ClassToTableName( model.Name );
}
else
{
return mappings.NamingStrategy.TableName( tableNameNode.Value );
}
}
public EntityMapper(Mappings mappings, Dialect.Dialect dialect)
{
this.mappings = mappings;
this.dialect = dialect;
}
public static void BindJoinedSubclass( XmlNode node, Subclass model, Mappings mappings )
{
BindClass( node, model, mappings );
// joined subclass
if( model.ClassPersisterClass == null )
{
model.RootClazz.ClassPersisterClass = typeof( NormalizedEntityPersister );
}
//table + schema names
XmlAttribute schemaNode = node.Attributes[ "schema" ];
string schema = schemaNode == null ? mappings.SchemaName : schemaNode.Value;
Table mytable = mappings.AddTable( schema, GetClassTableName( model, node, mappings ) );
model.Table = mytable;
log.Info( "Mapping joined-subclass: " + model.Name + " -> " + model.Table.Name );
XmlNode keyNode = node.SelectSingleNode( nsKey, nsmgr );
SimpleValue key = new SimpleValue( mytable );
model.Key = key;
BindSimpleValue( keyNode, key, false, model.Name, mappings );
model.Key.Type = model.Identifier.Type;
model.CreatePrimaryKey( dialect );
model.CreateForeignKey();
// CHECK
XmlAttribute chNode = node.Attributes[ "check" ];
if( chNode != null )
{
mytable.AddCheckConstraint( chNode.Value );
}
// properties
PropertiesFromXML( node, model, mappings );
}
