protected override object ProcessCollection(object collection, CollectionType type)
{
if (collection != null)
{
SessionImpl session = Session;
IPersistentCollection 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 AbstractPersistentCollection) ) ?
// true : SearchForDirtyCollections( (AbstractPersistentCollection) obj, type );
coll = (IPersistentCollection) collection;
}
if (coll.IsDirty)
{
_dirty = true;
return null; // NOTE: early exit
}
}
return null;
}
/// <summary>
/// Initialize the role of the collection.
/// </summary>
/// <param name="collection">The collection to be updated by reachibility. </param>
/// <param name="type">The type of the collection. </param>
/// <param name="entity">The owner of the collection. </param>
/// <param name="session">The session.</param>
public static void ProcessReachableCollection(IPersistentCollection collection, CollectionType type, object entity, ISessionImplementor session)
{
collection.Owner = entity;
CollectionEntry ce = session.PersistenceContext.GetCollectionEntry(collection);
if (ce == null)
{
// refer to comment in StatefulPersistenceContext.addCollection()
throw new HibernateException(string.Format("Found two representations of same collection: {0}", type.Role));
}
// The CollectionEntry.isReached() stuff is just to detect any silly users
// who set up circular or shared references between/to collections.
if (ce.IsReached)
{
// We've been here before
throw new HibernateException(string.Format("Found shared references to a collection: {0}", type.Role));
}
ce.IsReached = true;
ISessionFactoryImplementor factory = session.Factory;
ICollectionPersister persister = factory.GetCollectionPersister(type.Role);
ce.CurrentPersister = persister;
ce.CurrentKey = type.GetKeyOfOwner(entity, session); //TODO: better to pass the id in as an argument?
if (log.IsDebugEnabled)
{
log.Debug("Collection found: " +
MessageHelper.InfoString(persister, ce.CurrentKey, factory) + ", was: " +
MessageHelper.InfoString(ce.LoadedPersister, ce.LoadedKey, factory) +
(collection.WasInitialized ? " (initialized)" : " (uninitialized)"));
}
PrepareCollectionForUpdate(collection, ce);
}
internal override object ProcessCollection(object collection, CollectionType type)
{
if (collection != null)
{
ISessionImplementor session = Session;
IPersistentCollection persistentCollection;
if (type.IsArrayType)
{
persistentCollection = session.PersistenceContext.GetCollectionHolder(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 instanceof PersistentCollection) ) ?
//true : searchForDirtyCollections( (PersistentCollection) obj, type );
persistentCollection = (IPersistentCollection)collection;
}
if (persistentCollection.IsDirty)
{
//we need to check even if it was not initialized, because of delayed adds!
dirty = true;
return null; //NOTE: EARLY EXIT!
}
}
return null;
}
private object ProcessArrayOrNewCollection(object collection, CollectionType collectionType)
{
if (collection == null)
{
return null;
}
ICollectionPersister persister = Session.GetCollectionPersister(collectionType.Role);
if (collectionType.IsArrayType)
{
PersistentArrayHolder ah = Session.GetArrayHolder(collection);
if (ah == null)
{
ah = new PersistentArrayHolder(Session, collection);
Session.AddNewCollection(ah, persister);
Session.AddArrayHolder(ah);
}
return null;
}
else
{
IPersistentCollection 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, CollectionType type)
{
SessionImpl session = Session;
object key = Key;
ICollectionPersister persister = session.GetCollectionPersister(type.Role);
session.RemoveCollection(persister, key);
if (collection != null && (collection is IPersistentCollection))
{
IPersistentCollection wrapper = collection as IPersistentCollection;
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;
}
internal override object ProcessCollection(object collection, CollectionType type)
{
if (collection != null)
EvictCollection(collection, type);
return null;
}
protected override object ProcessCollection(object collection, CollectionType type)
{
if (collection != null)
{
Session.EvictCollection(collection, type);
}
return null;
}
internal override object ProcessCollection(object collection, CollectionType type)
{
ISessionImplementor session = Session;
ICollectionPersister persister = session.Factory.GetCollectionPersister(type.Role);
if (collection == null)
{
//do nothing
}
else
{
IPersistentCollection persistentCollection = collection as IPersistentCollection;
if (persistentCollection != null)
{
if (persistentCollection.SetCurrentSession(session))
{
ICollectionSnapshot snapshot = persistentCollection.CollectionSnapshot;
if (IsOwnerUnchanged(snapshot, persister, ExtractCollectionKeyFromOwner(persister)))
{
// a "detached" collection that originally belonged to the same entity
if (persistentCollection.IsDirty)
{
throw new HibernateException("reassociated object has dirty collection");
}
ReattachCollection(persistentCollection, snapshot);
}
else
{
// a "detached" collection that belonged to a different entity
throw new HibernateException("reassociated object has dirty collection reference");
}
}
else
{
// a collection loaded in the current session
// can not possibly be the collection belonging
// to the entity passed to update()
throw new HibernateException("reassociated object has dirty collection reference");
}
}
else
{
// brand new collection
//TODO: or an array!! we can't lock objects with arrays now??
throw new HibernateException("reassociated object has dirty collection reference (or an array)");
}
}
return null;
}
protected override object ProcessCollection(object collection, CollectionType collectionType)
{
if (collection != null && (collection is IPersistentCollection))
{
IPersistentCollection coll = collection as IPersistentCollection;
if (coll.SetCurrentSession(Session))
{
Session.ReattachCollection(coll, coll.CollectionSnapshot);
}
return null;
}
else
{
return ProcessArrayOrNewCollection(collection, collectionType);
}
}
protected override object ProcessCollection(object collection, CollectionType type)
{
ICollectionPersister persister = Session.GetCollectionPersister(type.Role);
if (collection == null)
{
// Do nothing
}
else if (collection is IPersistentCollection)
{
IPersistentCollection coll = (IPersistentCollection) collection;
if (coll.SetCurrentSession(Session))
{
ICollectionSnapshot snapshot = coll.CollectionSnapshot;
if (SessionImpl.IsOwnerUnchanged(snapshot, persister, this.Key))
{
// a "detached" collection that originally belonged to the same entity
if (coll.IsDirty)
{
throw new HibernateException("reassociated object has dirty collection");
}
Session.ReattachCollection(coll, snapshot);
}
else
{
// a "detached" collection that belonged to a different entity
throw new HibernateException("reassociated object has dirty collection reference");
}
}
else
{
// a collection loaded in the current session
// can not possibly be the collection belonging
// to the entity passed to update()
throw new HibernateException("reassociated object has dirty collection reference");
}
}
else
{
// brand new collection
//TODO: or an array!! we can't lock objects with arrays now??
throw new HibernateException("reassociated object has dirty collection reference");
}
return null;
}
internal override object ProcessCollection(object collection, CollectionType collectionType)
{
IPersistentCollection coll = collection as IPersistentCollection;
if (coll != null)
{
ISessionImplementor session = Session;
if (coll.SetCurrentSession(session))
{
ReattachCollection(coll, collectionType);
}
return null;
}
else
{
return ProcessArrayOrNewCollection(collection, collectionType);
}
}
/// <summary>
/// Reattach a detached (disassociated) initialized or uninitialized
/// collection wrapper, using a snapshot carried with the collection wrapper
/// </summary>
protected internal void ReattachCollection(IPersistentCollection collection, CollectionType type)
{
if (collection.WasInitialized)
{
ICollectionPersister collectionPersister = Session.Factory.GetCollectionPersister(type.Role);
Session.PersistenceContext.AddInitializedDetachedCollection(collectionPersister, collection);
}
else
{
if (!IsCollectionSnapshotValid(collection))
{
throw new HibernateException("could not reassociate uninitialized transient collection");
}
ICollectionPersister collectionPersister = Session.Factory.GetCollectionPersister(collection.Role);
Session.PersistenceContext.AddUninitializedDetachedCollection(collectionPersister, collection);
}
}
internal override object ProcessCollection(object collection, CollectionType type)
{
if (collection == CollectionType.UnfetchedCollection)
{
return null;
}
IEventSource session = Session;
ICollectionPersister persister = session.Factory.GetCollectionPersister(type.Role);
object collectionKey = ExtractCollectionKeyFromOwner(persister);
IPersistentCollection wrapper = collection as IPersistentCollection;
if (wrapper != null)
{
if (wrapper.SetCurrentSession(session))
{
//a "detached" collection!
ICollectionSnapshot snapshot = wrapper.CollectionSnapshot;
if (!IsOwnerUnchanged(snapshot, persister, collectionKey))
{
// if the collection belonged to a different entity,
// clean up the existing state of the collection
RemoveCollection(persister, collectionKey, 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()
RemoveCollection(persister, collectionKey, session);
}
}
else
{
// null or brand new collection
// this will also (inefficiently) handle arrays, which have
// no snapshot, so we can't do any better
RemoveCollection(persister, collectionKey, session);
}
return null;
}
public virtual void EvictCollection(object value, CollectionType type)
{
IPersistentCollection pc;
if (type.IsArrayType)
{
pc = Session.PersistenceContext.RemoveCollectionHolder(value);
}
else if (value is IPersistentCollection)
{
pc = (IPersistentCollection)value;
}
else
{
return; //EARLY EXIT!
}
IPersistentCollection collection = pc;
if (collection.UnsetSession(Session))
EvictCollection(collection);
}
protected override object ProcessCollection(object collection, CollectionType type)
{
ICollectionPersister persister = Session.GetCollectionPersister(type.Role);
if (collection is IPersistentCollection)
{
IPersistentCollection wrapper = (IPersistentCollection) 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;
}
private object ProcessArrayOrNewCollection(object collection, CollectionType collectionType)
{
if (collection == null)
{
//do nothing
return null;
}
ISessionImplementor session = Session;
ICollectionPersister persister = session.Factory.GetCollectionPersister(collectionType.Role);
IPersistenceContext persistenceContext = session.PersistenceContext;
//TODO: move into collection type, so we can use polymorphism!
if (collectionType.IsArrayType)
{
//if (collection == CollectionType.UNFETCHED_COLLECTION)
// return null;
PersistentArrayHolder ah = persistenceContext.GetCollectionHolder(collection) as PersistentArrayHolder;
if (ah == null)
{
//ah = collectionType.Wrap(session, collection);
ah = new PersistentArrayHolder(session, collection);
persistenceContext.AddNewCollection(persister, ah);
persistenceContext.AddCollectionHolder(ah);
}
return null;
}
else
{
IPersistentCollection persistentCollection = collectionType.Wrap(session, collection);
persistenceContext.AddNewCollection(persister, persistentCollection);
if (log.IsDebugEnabled)
log.Debug("Wrapped collection in role: " + collectionType.Role);
return persistentCollection; //Force a substitution!
}
}
protected override object ProcessCollection(object collection, CollectionType type)
{
if (log.IsDebugEnabled)
{
log.Debug(string.Format("Processing collection for role {0}", type.Role));
}
if (collection != null)
{
IPersistentCollection coll;
if (type.IsArrayType)
{
coll = Session.GetArrayHolder(collection);
}
else
{
coll = (IPersistentCollection) collection;
}
Session.UpdateReachableCollection(coll, type, _owner);
}
return null;
}
internal override object ProcessCollection(object collection, CollectionType type)
{
if (collection == CollectionType.UnfetchedCollection)
{
return null;
}
if (collection != null)
{
IPersistentCollection coll;
if (type.IsArrayType)
{
coll = Session.PersistenceContext.GetCollectionHolder(collection);
}
else
{
coll = (IPersistentCollection)collection;
}
Collections.ProcessReachableCollection(coll, type, owner, Session);
}
return null;
}
internal override object ProcessCollection(object collection, CollectionType type)
{
if (collection == CollectionType.UnfetchedCollection)
{
return null;
}
IEventSource session = Session;
ICollectionPersister persister = session.Factory.GetCollectionPersister(type.Role);
if (isUpdate)
{
RemoveCollection(persister, ExtractCollectionKeyFromOwner(persister), session);
}
IPersistentCollection wrapper = collection as IPersistentCollection;
if (wrapper != null)
{
wrapper.SetCurrentSession(session);
if (wrapper.WasInitialized)
{
session.PersistenceContext.AddNewCollection(persister, wrapper);
}
else
{
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;
}
public override IEnumerable GetCascadableChildrenIterator(IEventSource session, CollectionType collectionType, object collection)
{
return GetLoadedElementsIterator(session, collectionType, collection);
}
/// <summary>
/// Iterate just the elements of the collection that are already there. Don't load
/// any new elements from the database.
/// </summary>
public static IEnumerable GetLoadedElementsIterator(ISessionImplementor session, CollectionType collectionType, object collection)
{
if (CollectionIsInitialized(collection))
{
// handles arrays and newly instantiated collections
return collectionType.GetElementsIterator(collection, session);
}
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 ((IPersistentCollection)collection).QueuedAdditionIterator;
}
}
/// <summary>
/// Given a collection, get an iterator of all its children, loading them
/// from the database if necessary.
/// </summary>
/// <param name="session">The session within which the cascade is occurring. </param>
/// <param name="collectionType">The mapping type of the collection. </param>
/// <param name="collection">The collection instance. </param>
/// <returns> The children iterator. </returns>
private static IEnumerable GetAllElementsIterator(IEventSource session, CollectionType collectionType, object collection)
{
return collectionType.GetElementsIterator(collection, session);
}
public override IEnumerable GetCascadableChildrenIterator(IEventSource session, CollectionType collectionType, object collection)
{
// replicate does cascade to uninitialized collections
return GetLoadedElementsIterator(session, collectionType, collection);
}
/// <summary> /// Given a collection, get an iterator of the children upon which the /// current cascading action should be visited. /// </summary> /// <param name="session">The session within which the cascade is occurring. </param> /// <param name="collectionType">The mapping type of the collection. </param> /// <param name="collection">The collection instance. </param> /// <returns> The children iterator. </returns> public abstract IEnumerable GetCascadableChildrenIterator(IEventSource session, CollectionType collectionType, object collection);
public override IEnumerable GetCascadableChildrenIterator(IEventSource session, CollectionType collectionType, object collection)
{
// persists don't cascade to uninitialized collections
return GetAllElementsIterator(session, collectionType, collection);
}
public override IEnumerable GetCascadableChildrenIterator(IEventSource session, CollectionType collectionType, object collection)
{
// merges don't cascade to uninitialized collections
//TODO: perhaps this does need to cascade after all....
return GetLoadedElementsIterator(session, collectionType, collection);
}
public AbstractCollectionPersister(Mapping.Collection collection, ICacheConcurrencyStrategy cache, Configuration cfg,
ISessionFactoryImplementor factory)
{
this.factory = factory;
this.cache = cache;
if (factory.Settings.IsStructuredCacheEntriesEnabled)
{
cacheEntryStructure = collection.IsMap
? (ICacheEntryStructure) new StructuredMapCacheEntry()
: (ICacheEntryStructure) new StructuredCollectionCacheEntry();
}
else
{
cacheEntryStructure = new UnstructuredCacheEntry();
}
dialect = factory.Dialect;
sqlExceptionConverter = factory.SQLExceptionConverter;
collectionType = collection.CollectionType;
role = collection.Role;
entityName = collection.OwnerEntityName;
ownerPersister = factory.GetEntityPersister(entityName);
queryLoaderName = collection.LoaderName;
nodeName = collection.NodeName;
isMutable = collection.IsMutable;
Table table = collection.CollectionTable;
fetchMode = collection.Element.FetchMode;
elementType = collection.Element.Type;
isPrimitiveArray = collection.IsPrimitiveArray;
isArray = collection.IsArray;
subselectLoadable = collection.IsSubselectLoadable;
qualifiedTableName = table.GetQualifiedName(dialect, factory.Settings.DefaultCatalogName, factory.Settings.DefaultSchemaName);
int spacesSize = 1 + collection.SynchronizedTables.Count;
spaces = new string[spacesSize];
int ispa = 0;
spaces[ispa++] = qualifiedTableName;
foreach (string s in collection.SynchronizedTables)
{
spaces[ispa++] = s;
}
sqlOrderByString = collection.OrderBy;
hasOrder = sqlOrderByString != null;
sqlOrderByStringTemplate = hasOrder
? Template.RenderOrderByStringTemplate(sqlOrderByString, dialect,
factory.SQLFunctionRegistry)
: null;
sqlWhereString = !string.IsNullOrEmpty(collection.Where) ? '(' + collection.Where + ')' : null;
hasWhere = sqlWhereString != null;
sqlWhereStringTemplate = hasWhere
? Template.RenderWhereStringTemplate(sqlWhereString, dialect, factory.SQLFunctionRegistry)
: null;
hasOrphanDelete = collection.HasOrphanDelete;
int batch = collection.BatchSize;
if (batch == -1)
{
batch = factory.Settings.DefaultBatchFetchSize;
}
batchSize = batch;
isVersioned = collection.IsOptimisticLocked;
keyType = collection.Key.Type;
int keySpan = collection.Key.ColumnSpan;
keyColumnNames = new string[keySpan];
keyColumnAliases = new string[keySpan];
int k = 0;
foreach (Column col in collection.Key.ColumnIterator)
{
keyColumnNames[k] = col.GetQuotedName(dialect);
keyColumnAliases[k] = col.GetAlias(dialect);
k++;
}
ISet distinctColumns = new HashedSet();
CheckColumnDuplication(distinctColumns, collection.Key.ColumnIterator);
#region Element
IValue element = collection.Element;
if (!collection.IsOneToMany)
{
CheckColumnDuplication(distinctColumns, element.ColumnIterator);
}
string elemNode = collection.ElementNodeName;
if (elementType.IsEntityType)
{
string _entityName = ((EntityType) elementType).GetAssociatedEntityName();
elementPersister = factory.GetEntityPersister(_entityName);
if (elemNode == null)
{
elemNode = cfg.GetClassMapping(_entityName).NodeName;
}
// NativeSQL: collect element column and auto-aliases
}
else
{
elementPersister = null;
}
elementNodeName = elemNode;
int elementSpan = element.ColumnSpan;
elementColumnAliases = new string[elementSpan];
elementColumnNames = new string[elementSpan];
elementFormulaTemplates = new string[elementSpan];
elementFormulas = new string[elementSpan];
elementColumnIsSettable = new bool[elementSpan];
elementColumnIsInPrimaryKey = new bool[elementSpan];
bool isPureFormula = true;
bool hasNotNullableColumns = false;
int j = 0;
foreach (ISelectable selectable in element.ColumnIterator)
{
elementColumnAliases[j] = selectable.GetAlias(dialect);
if (selectable.IsFormula)
{
Formula form = (Formula) selectable;
elementFormulaTemplates[j] = form.GetTemplate(dialect, factory.SQLFunctionRegistry);
elementFormulas[j] = form.FormulaString;
}
else
{
Column col = (Column) selectable;
elementColumnNames[j] = col.GetQuotedName(dialect);
elementColumnIsSettable[j] = true;
elementColumnIsInPrimaryKey[j] = !col.IsNullable;
if (!col.IsNullable)
{
hasNotNullableColumns = true;
}
isPureFormula = false;
}
j++;
}
elementIsPureFormula = isPureFormula;
//workaround, for backward compatibility of sets with no
//not-null columns, assume all columns are used in the
//row locator SQL
if (!hasNotNullableColumns)
{
ArrayHelper.Fill(elementColumnIsInPrimaryKey, true);
}
#endregion
#region INDEX AND ROW SELECT
hasIndex = collection.IsIndexed;
if (hasIndex)
{
// NativeSQL: collect index column and auto-aliases
IndexedCollection indexedCollection = (IndexedCollection) collection;
indexType = indexedCollection.Index.Type;
int indexSpan = indexedCollection.Index.ColumnSpan;
indexColumnNames = new string[indexSpan];
indexFormulaTemplates = new string[indexSpan];
indexFormulas = new string[indexSpan];
indexColumnIsSettable = new bool[indexSpan];
indexColumnAliases = new string[indexSpan];
bool hasFormula = false;
int i = 0;
foreach (ISelectable selectable in indexedCollection.Index.ColumnIterator)
{
indexColumnAliases[i] = selectable.GetAlias(dialect);
if (selectable.IsFormula)
{
Formula indexForm = (Formula) selectable;
indexFormulaTemplates[i] = indexForm.GetTemplate(dialect, factory.SQLFunctionRegistry);
indexFormulas[i] = indexForm.FormulaString;
hasFormula = true;
}
else
{
Column indexCol = (Column) selectable;
indexColumnNames[i] = indexCol.GetQuotedName(dialect);
indexColumnIsSettable[i] = true;
}
i++;
}
indexContainsFormula = hasFormula;
baseIndex = indexedCollection.IsList ? ((List) indexedCollection).BaseIndex : 0;
indexNodeName = indexedCollection.IndexNodeName;
CheckColumnDuplication(distinctColumns, indexedCollection.Index.ColumnIterator);
}
else
{
indexContainsFormula = false;
indexColumnIsSettable = null;
indexFormulaTemplates = null;
indexFormulas = null;
indexType = null;
indexColumnNames = null;
indexColumnAliases = null;
baseIndex = 0;
indexNodeName = null;
}
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.ColumnIterator)
{
col = column;
break;
}
identifierColumnName = col.GetQuotedName(dialect);
identifierColumnAlias = col.GetAlias(dialect);
identifierGenerator =
idColl.Identifier.CreateIdentifierGenerator(factory.Dialect, factory.Settings.DefaultCatalogName,
factory.Settings.DefaultSchemaName, null);
// NH see : identityDelegate declaration
IPostInsertIdentifierGenerator pig = (identifierGenerator as IPostInsertIdentifierGenerator);
if (pig != null)
{
identityDelegate = pig.GetInsertGeneratedIdentifierDelegate(this, Factory, UseGetGeneratedKeys());
}
else
{
identityDelegate = null;
}
CheckColumnDuplication(distinctColumns, idColl.Identifier.ColumnIterator);
}
else
{
identifierType = null;
identifierColumnName = null;
identifierColumnAlias = null;
identifierGenerator = null;
identityDelegate = null;
}
#endregion
#region GENERATE THE SQL
// NH Different behavior : for the Insert SQL we are managing isPostInsertIdentifier (not supported in H3.2.5)
if (collection.CustomSQLInsert == null)
{
if (!IsIdentifierAssignedByInsert)
{
sqlInsertRowString = GenerateInsertRowString();
}
else
{
sqlInsertRowString = GenerateIdentityInsertRowString();
}
insertCallable = false;
insertCheckStyle = ExecuteUpdateResultCheckStyle.Count;
}
else
{
SqlType[] parmsTypes = GenerateInsertRowString().ParameterTypes;
sqlInsertRowString = new SqlCommandInfo(collection.CustomSQLInsert, parmsTypes);
insertCallable = collection.IsCustomInsertCallable;
insertCheckStyle = collection.CustomSQLInsertCheckStyle
?? ExecuteUpdateResultCheckStyle.DetermineDefault(collection.CustomSQLInsert, insertCallable);
}
sqlUpdateRowString = GenerateUpdateRowString();
if (collection.CustomSQLUpdate == null)
{
updateCallable = false;
updateCheckStyle = ExecuteUpdateResultCheckStyle.Count;
}
else
{
sqlUpdateRowString = new SqlCommandInfo(collection.CustomSQLUpdate, sqlUpdateRowString.ParameterTypes);
updateCallable = collection.IsCustomUpdateCallable;
updateCheckStyle = collection.CustomSQLUpdateCheckStyle
?? ExecuteUpdateResultCheckStyle.DetermineDefault(collection.CustomSQLUpdate, updateCallable);
}
sqlDeleteRowString = GenerateDeleteRowString();
if (collection.CustomSQLDelete == null)
{
deleteCallable = false;
deleteCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
else
{
sqlDeleteRowString = new SqlCommandInfo(collection.CustomSQLDelete, sqlDeleteRowString.ParameterTypes);
deleteCallable = collection.IsCustomDeleteCallable;
deleteCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
sqlDeleteString = GenerateDeleteString();
if (collection.CustomSQLDeleteAll == null)
{
deleteAllCallable = false;
deleteAllCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
else
{
sqlDeleteString = new SqlCommandInfo(collection.CustomSQLDeleteAll, sqlDeleteString.ParameterTypes);
deleteAllCallable = collection.IsCustomDeleteAllCallable;
deleteAllCheckStyle = ExecuteUpdateResultCheckStyle.None;
}
isCollectionIntegerIndex = collection.IsIndexed && !collection.IsMap;
sqlDetectRowByIndexString = GenerateDetectRowByIndexString();
sqlDetectRowByElementString = GenerateDetectRowByElementString();
sqlSelectRowByIndexString = GenerateSelectRowByIndexString();
LogStaticSQL();
#endregion
isLazy = collection.IsLazy;
isExtraLazy = collection.ExtraLazy;
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;
}
if (elementType.IsComponentType)
{
elementPropertyMapping =
new CompositeElementPropertyMapping(elementColumnNames, elementFormulaTemplates,
(IAbstractComponentType) elementType, factory);
}
else if (!elementType.IsEntityType)
{
elementPropertyMapping = new ElementPropertyMapping(elementColumnNames, elementType);
}
else
{
elementPropertyMapping = elementPersister as IPropertyMapping;
if (elementPropertyMapping == null)
{
elementPropertyMapping = new ElementPropertyMapping(elementColumnNames, elementType);
}
}
// Handle any filters applied to this collection
filterHelper = new FilterHelper(collection.FilterMap, dialect, factory.SQLFunctionRegistry);
// Handle any filters applied to this collection for many-to-many
manyToManyFilterHelper = new FilterHelper(collection.ManyToManyFilterMap, dialect, factory.SQLFunctionRegistry);
manyToManyWhereString = !string.IsNullOrEmpty(collection.ManyToManyWhere)
? "( " + collection.ManyToManyWhere + " )"
: null;
manyToManyWhereTemplate = manyToManyWhereString == null
? null
: Template.RenderWhereStringTemplate(manyToManyWhereString, factory.Dialect,
factory.SQLFunctionRegistry);
manyToManyOrderByString = collection.ManyToManyOrdering;
manyToManyOrderByTemplate = manyToManyOrderByString == null
? null
: Template.RenderOrderByStringTemplate(manyToManyOrderByString, factory.Dialect,
factory.SQLFunctionRegistry);
InitCollectionPropertyMap();
}
/// <summary> /// The children to whom we should cascade. /// </summary> public abstract ICollection CascadableChildrenCollection(CollectionType collectionType, object collection);
/// <summary>
/// Visit a collection. Default superclass implementation is a no-op.
/// </summary>
/// <param name="value"></param>
/// <param name="collectionType"></param>
/// <returns></returns>
internal virtual object ProcessCollection(object value, CollectionType collectionType)
{
return null;
}
public Collection(CollectionType type, ICollectionPersister persister)
{
if (type == null) throw new ArgumentNullException("type");
if (persister == null) throw new ArgumentNullException("persister");
Type = type;
Persister = persister;
}