protected override object ProcessCollection( object collection, PersistentCollectionType type ) { SessionImpl session = Session; object key = Key; ICollectionPersister persister = session.GetCollectionPersister( type.Role ); session.RemoveCollection( persister, key ); if ( collection != null && ( collection is PersistentCollection ) ) { PersistentCollection wrapper = collection as PersistentCollection; wrapper.SetCurrentSession( session ); if ( wrapper.WasInitialized ) { session.AddNewCollection( wrapper, persister ); } else { session.ReattachCollection( wrapper, wrapper.CollectionSnapshot ) ; } } else { // otherwise a null or brand new collection // this will also (inefficiently) handle arrays, which // have no snapshot, so we can't do any better //processArrayOrNewCollection(collection, type); } return null; }
protected override object ProcessCollection(object collection, PersistentCollectionType type) { if( collection != null ) { SessionImpl session = Session; PersistentCollection coll; if( type.IsArrayType ) { coll = session.GetArrayHolder( collection ); // if no array holder we found an unwrappered array (this can't occur, // because we now always call wrap() before getting to here) // return (ah==null) ? true : searchForDirtyCollections(ah, type); } else { // if not wrappered yet, its dirty (this can't occur, because // we now always call wrap() before getting to here) // return ( ! (obj is PersistentCollection) ) ? // true : SearchForDirtyCollections( (PersistentCollection) obj, type ); coll = (PersistentCollection)collection; } if( session.CollectionIsDirty( coll ) ) { _dirty = true; return null; // NOTE: early exit } } return null; }
private object ProcessArrayOrNewCollection(object collection, PersistentCollectionType collectionType) { if( collection == null ) { return null; } ICollectionPersister persister = Session.GetCollectionPersister( collectionType.Role ); if( collectionType.IsArrayType ) { ArrayHolder ah = Session.GetArrayHolder( collection ); if( ah == null ) { ah = new ArrayHolder( Session, collection ); Session.AddNewCollection( ah, persister ); Session.AddArrayHolder( ah ); } return null; } else { PersistentCollection persistentCollection = collectionType.Wrap( Session, collection ); Session.AddNewCollection( persistentCollection, persister ); if( log.IsDebugEnabled ) { log.Debug( "Wrapped collection in role: " + collectionType.Role ); } return persistentCollection; //Force a substitution! } }
protected override object ProcessCollection(object collection, PersistentCollectionType type) { if( collection != null ) { Session.EvictCollection( collection, type ); } return null; }
protected override object ProcessCollection(object collection, PersistentCollectionType collectionType) { if( collection != null && (collection is PersistentCollection) ) { PersistentCollection coll = collection as PersistentCollection; if( coll.SetCurrentSession( Session ) ) { Session.ReattachCollection( coll, coll.CollectionSnapshot ); } return null; } else { return ProcessArrayOrNewCollection( collection, collectionType ); } }
protected override object ProcessCollection(object collection, PersistentCollectionType type) { ICollectionPersister persister = Session.GetCollectionPersister( type.Role ); if( collection is PersistentCollection ) { PersistentCollection wrapper = (PersistentCollection)collection; if( wrapper.SetCurrentSession( Session ) ) { //a "detached" collection! ICollectionSnapshot snapshot = wrapper.CollectionSnapshot; if( !SessionImpl.IsOwnerUnchanged( snapshot, persister, Key ) ) { // if the collection belonged to a different entity, // clean up the existing state of the collection Session.RemoveCollection( persister, Key ); } Session.ReattachCollection( wrapper, snapshot ); } else { // a collection loaded in the current session // can not possibly be the collection belonging // to the entity passed to update() Session.RemoveCollection( persister, Key ); } } else { // null or brand new collection // this will also (inefficiently) handle arrays, which have // no snapshot, so we can't do any better Session.RemoveCollection( persister, Key ); //processArrayOrNewCollection(collection, type); } return null; }
protected override object ProcessCollection(object collection, PersistentCollectionType type) { if( log.IsDebugEnabled ) { log.Debug( string.Format( "Processing collection for role {0}", type.Role ) ); } if( collection != null ) { PersistentCollection coll; if( type.IsArrayType ) { coll = Session.GetArrayHolder( collection ); } else { coll = (PersistentCollection)collection; } Session.UpdateReachableCollection( coll, type, _owner ); } return null; }
public AbstractCollectionPersister( Mapping.Collection collection, ISessionFactoryImplementor factory ) { this.factory = factory; dialect = factory.Dialect; //sqlExceptionConverter = factory.SQLExceptionConverter; collectionType = collection.CollectionType; role = collection.Role; ownerClass = collection.OwnerClass; Alias alias = new Alias( "__" ); sqlOrderByString = collection.OrderBy; hasOrder = sqlOrderByString != null; sqlOrderByStringTemplate = hasOrder ? Template.RenderOrderByStringTemplate( sqlOrderByString, dialect ) : null; sqlWhereString = collection.Where; hasWhere = sqlWhereString != null; sqlWhereStringTemplate = hasWhere ? Template.RenderWhereStringTemplate( sqlWhereString, dialect ) : null; hasOrphanDelete = collection.OrphanDelete; batchSize = collection.BatchSize; cache = collection.Cache; keyType = collection.Key.Type; int keySpan = collection.Key.ColumnSpan; keyColumnNames = new string[keySpan]; string[ ] keyAliases = new string[keySpan]; int k = 0; foreach( Column col in collection.Key.ColumnCollection ) { keyColumnNames[ k ] = col.GetQuotedName( dialect ); keyAliases[ k ] = col.Alias( dialect ); k++; } keyColumnAliases = alias.ToAliasStrings( keyAliases, dialect ); //unquotedKeyColumnNames = StringHelper.Unquote( keyColumnAliases ); ISet distinctColumns = new HashedSet(); CheckColumnDuplication( distinctColumns, collection.Key.ColumnCollection ); //isSet = collection.IsSet; //isSorted = collection.IsSorted; primitiveArray = collection.IsPrimitiveArray; array = collection.IsArray; IValue element = collection.Element; int elementSpan = element.ColumnSpan; ICollection iter = element.ColumnCollection; Table table = collection.CollectionTable; enableJoinedFetch = element.OuterJoinFetchSetting; elementType = element.Type; if( !collection.IsOneToMany ) { CheckColumnDuplication( distinctColumns, element.ColumnCollection ); } if( elementType.IsEntityType ) { elementPersister = factory.GetPersister( ( ( EntityType ) elementType ).AssociatedClass ); } else { elementPersister = null; } qualifiedTableName = table.GetQualifiedName( dialect, factory.DefaultSchema ); string[ ] aliases = new string[elementSpan]; elementColumnNames = new string[elementSpan]; int j = 0; foreach( Column col in iter ) { elementColumnNames[ j ] = col.GetQuotedName( dialect ); aliases[ j ] = col.Alias( dialect ); j++; } elementColumnAliases = alias.ToAliasStrings( aliases, dialect ); IType selectColumns; string[ ] selectType; hasIndex = collection.IsIndexed; if( hasIndex ) { IndexedCollection indexedCollection = ( IndexedCollection ) collection; indexType = indexedCollection.Index.Type; int indexSpan = indexedCollection.Index.ColumnSpan; indexColumnNames = new string[indexSpan]; string[ ] indexAliases = new string[indexSpan]; int i = 0; foreach( Column indexCol in indexedCollection.Index.ColumnCollection ) { indexAliases[ i ] = indexCol.Alias( dialect ); indexColumnNames[ i ] = indexCol.GetQuotedName( dialect ); i++; } selectType = indexColumnNames; selectColumns = indexType; indexColumnAliases = alias.ToAliasStrings( indexAliases, dialect ); CheckColumnDuplication( distinctColumns, indexedCollection.Index.ColumnCollection ); } else { indexType = null; indexColumnNames = null; indexColumnAliases = null; selectType = elementColumnNames; selectColumns = elementType; } hasIdentifier = collection.IsIdentified; if( hasIdentifier ) { if( collection.IsOneToMany ) { throw new MappingException( "one-to-many collections with identifiers are not supported." ); } IdentifierCollection idColl = ( IdentifierCollection ) collection; identifierType = idColl.Identifier.Type; Column col = null; foreach( Column column in idColl.Identifier.ColumnCollection ) { col = column; break; } identifierColumnName = col.GetQuotedName( dialect ); selectType = new string[ ] {identifierColumnName}; selectColumns = identifierType; identifierColumnAlias = alias.ToAliasString( col.Alias( dialect ), dialect ); unquotedIdentifierColumnName = identifierColumnAlias; identifierGenerator = idColl.Identifier.CreateIdentifierGenerator( dialect ); CheckColumnDuplication( distinctColumns, idColl.Identifier.ColumnCollection ); } else { identifierType = null; identifierColumnName = null; identifierColumnAlias = null; unquotedIdentifierColumnName = null; identifierGenerator = null; } rowSelectColumnNames = selectType; rowSelectType = selectColumns; sqlDeleteString = GenerateDeleteString(); sqlInsertRowString = GenerateInsertRowString(); sqlUpdateRowString = GenerateUpdateRowString(); sqlDeleteRowString = GenerateDeleteRowString(); isLazy = collection.IsLazy; isInverse = collection.IsInverse; if( collection.IsArray ) { elementClass = ( ( Array ) collection ).ElementClass; } else { // for non-arrays, we don't need to know the element class elementClass = null; } initializer = CreateCollectionInitializer( factory ); if( elementType.IsComponentType ) { elementPropertyMapping = new CompositeElementPropertyMapping( elementColumnNames, ( IAbstractComponentType ) elementType, factory ); } else if( !elementType.IsEntityType ) { elementPropertyMapping = new ElementPropertyMapping( elementColumnNames, elementType ); } else { IClassPersister persister = factory.GetPersister( ( ( EntityType ) elementType ).AssociatedClass ); // Not all classpersisters implement IPropertyMapping! if( persister is IPropertyMapping ) { elementPropertyMapping = ( IPropertyMapping ) persister; } else { elementPropertyMapping = new ElementPropertyMapping( elementColumnNames, elementType ); } } }
/// <summary> /// The children to whom we should cascade. /// </summary> public abstract ICollection CascadableChildrenCollection( PersistentCollectionType collectionType, object collection );
internal static ICollection GetAllElementsCollection( PersistentCollectionType collectionType, object collection ) { return collectionType.GetElementsCollection( collection ); }
internal static ICollection GetLoadedElementsCollection( PersistentCollectionType collectionType, object collection ) { if ( CollectionIsInitialized( collection ) ) { // handles arrays and newly instantiated collections return collectionType.GetElementsCollection( collection ); } else { // does not handle arrays (that's ok, cos they can't be lazy) // or newly instantiated collections so we can do the cast return ( (PersistentCollection) collection).QueuedAddsCollection; } }
/// <summary> /// Cascade to the collection elements /// </summary> /// <param name="action"></param> /// <param name="style"></param> /// <param name="collectionType"></param> /// <param name="elemType"></param> /// <param name="child"></param> /// <param name="cascadeVia"></param> /// <param name="session"></param> /// <param name="anything"></param> private static void CascadeCollection( CascadingAction action, CascadeStyle style, PersistentCollectionType collectionType, IType elemType, object child, CascadePoint cascadeVia, ISessionImplementor session, object anything ) { // cascade to current collection elements if( log.IsDebugEnabled ) { log.Debug( "cascading to collection: " + collectionType.Role ); } ICollection iter = action.CascadableChildrenCollection( collectionType, child ); foreach( object obj in iter ) { Cascade( session, obj, elemType, action, style, cascadeVia, anything ); } // handle oprhaned entities!! if( style.HasOrphanDelete && action.DeleteOrphans() && child is PersistentCollection ) { // We can do the cast since orphan-delete does not apply to: // 1. newly instatiated collections // 2. arrays ( we can't track orphans for detached arrays) DeleteOrphans( child as PersistentCollection, session ); } }
public override ICollection CascadableChildrenCollection( PersistentCollectionType collectionType, object collection ) { return Cascades.GetLoadedElementsCollection( collectionType, collection ); }
public override ICollection CascadableChildrenCollection( PersistentCollectionType collectionType, object collection ) { // saves / updates don't cascade to uninitialized collections return Cascades.GetLoadedElementsCollection( collectionType, collection ); }
/// <summary> /// Visit a collection. Default superclass implementation is a no-op. /// </summary> /// <param name="collection"></param> /// <param name="type"></param> /// <returns></returns> protected virtual object ProcessCollection(object collection, PersistentCollectionType type) { return null; }
internal void EvictCollection( object value, PersistentCollectionType type ) { object pc; if( type.IsArrayType ) { pc = arrayHolders[ value ]; arrayHolders.Remove( value ); } else if( value is PersistentCollection ) { pc = value; } else { return; //EARLY EXIT! } PersistentCollection collection = pc as PersistentCollection; if( collection.UnsetSession( this ) ) { EvictCollection( collection ); } }