C# ISessionImplementor.GetEntityPersister方法代码示例

        /// <summary>
        /// Generates a new identifier by getting the value of the identifier
        /// for the <c>obj</c> parameter.
        /// </summary>
        /// <param name="session">The <see cref="ISessionImplementor"/> this id is being generated in.</param>
        /// <param name="obj">The entity for which the id is being generated.</param>
        /// <returns>The value that was assigned to the mapped <c>id</c>'s property.</returns>
        /// <exception cref="IdentifierGenerationException">
        /// Thrown when a <see cref="IPersistentCollection"/> is passed in as the <c>obj</c> or
        /// if the identifier of <c>obj</c> is null.
        /// </exception>
        public object Generate(ISessionImplementor session, object obj)
        {
            if (obj is IPersistentCollection)
            {
                throw new IdentifierGenerationException("Illegal use of assigned id generation for a toplevel collection");
            }

            object id = session.GetEntityPersister(obj).GetIdentifier(obj, session.EntityMode);
            if (id == null)
            {
                throw new IdentifierGenerationException("ids for this class must be manually assigned before calling save(): "
                                                                                                + obj.GetType().FullName);
            }
            return id;
        }

        /// <summary>
        /// Generate a new identifier.
        /// </summary>
        /// <param name="session">The <see cref="ISessionImplementor"/> this id is being generated in.</param>
        /// <param name="obj">The entity for which the id is being generated.</param>
        /// <returns>The new identifier.</returns>
        public object Generate(ISessionImplementor session, object obj)
        {
            if (obj != null)
            {
                // If the object we're generating a GUID for already has a GUID,
                // then we won't change it. This is to facilitate exporting/importing between different systems.
                var perister = session.GetEntityPersister(null, obj);
                var property = obj.GetType().GetProperty(perister.IdentifierPropertyName);
                var id = property.GetValue(obj, null);

                if (id != null && id is Guid)
                {
                    var guid = (Guid)id;
                    if (!guid.Equals(Guid.Empty)) return guid;
                }
            }

            return GenerateComb();
        }

        /// <summary> 
        /// Return the identifier of the persistent or transient object, or throw
        /// an exception if the instance is "unsaved"
        /// </summary>
        /// <remarks>
        /// Used by OneToOneType and ManyToOneType to determine what id value should 
        /// be used for an object that may or may not be associated with the session. 
        /// This does a "best guess" using any/all info available to use (not just the 
        /// EntityEntry).
        /// </remarks>
        public static object GetEntityIdentifierIfNotUnsaved(string entityName, object entity, ISessionImplementor session)
        {
            if (entity == null)
            {
                return null;
            }
            else
            {
                object id = session.GetContextEntityIdentifier(entity);
                if (id == null)
                {
                    // context-entity-identifier returns null explicitly if the entity
                    // is not associated with the persistence context; so make some deeper checks...

                    /***********************************************/
                    // NH-479 (very dirty patch)
                    if (entity.GetType().IsPrimitive)
                        return entity;
                    /**********************************************/

                    if (IsTransient(entityName, entity, false, session))
                    {
                        /***********************************************/
                        // TODO NH verify the behavior of NH607 test
                        // these lines are only to pass test NH607 during PersistenceContext porting
                        // i'm not secure that NH607 is a test for a right behavior
                        EntityEntry entry = session.PersistenceContext.GetEntry(entity);
                        if (entry != null)
                            return entry.Id;
                        // the check was put here to have les possible impact
                        /**********************************************/

                        throw new TransientObjectException(
                            "object references an unsaved transient instance - save the transient instance before flushing: "
                            + (entityName ?? session.GuessEntityName(entity)));
                    }
                    id = session.GetEntityPersister(entityName, entity).GetIdentifier(entity, session.EntityMode);
                }
                return id;
            }
        }

		// Not ported: sequentialLoad, loadSequentialRowsForward, loadSequentialRowsReverse

		internal static EntityKey GetOptionalObjectKey(QueryParameters queryParameters, ISessionImplementor session)
		{
			object optionalObject = queryParameters.OptionalObject;
			object optionalId = queryParameters.OptionalId;
			string optionalEntityName = queryParameters.OptionalEntityName;

			if (optionalObject != null && !string.IsNullOrEmpty(optionalEntityName))
			{
				return new EntityKey(optionalId, session.GetEntityPersister(optionalEntityName, optionalObject), session.EntityMode);
			}
			else
			{
				return null;
			}
		}

		/// <summary> 
		/// Is this instance, which we know is not persistent, actually transient? 
		/// If <tt>assumed</tt> is non-null, don't hit the database to make the 
		/// determination, instead assume that value; the client code must be 
		/// prepared to "recover" in the case that this assumed result is incorrect.
		/// </summary>
		/// <remarks>
		/// If <paramref name="assumed"/> is non-null, don't hit the database to make the 
		/// determination, instead assume that value; the client code must be 
		/// prepared to "recover" in the case that this assumed result is incorrect.
		/// </remarks>
		public static bool IsTransient(string entityName, object entity, bool? assumed, ISessionImplementor session)
		{
			if (entity == Intercept.LazyPropertyInitializer.UnfetchedProperty)
			{
				// an unfetched association can only point to
				// an entity that already exists in the db
				return false;
			}

			// let the interceptor inspect the instance to decide
			bool? isUnsaved = session.Interceptor.IsTransient(entity);
			if (isUnsaved.HasValue)
				return isUnsaved.Value;

			// let the persister inspect the instance to decide
			IEntityPersister persister = session.GetEntityPersister(entityName, entity);
			isUnsaved = persister.IsTransient(entity, session);
			if (isUnsaved.HasValue)
				return isUnsaved.Value;

			// we use the assumed value, if there is one, to avoid hitting
			// the database
			if (assumed.HasValue)
				return assumed.Value;

			if (persister.IdentifierGenerator is Assigned)
			{
				// When using assigned identifiers we cannot tell if an entity
				// is transient or detached without querying the database.
				// This could potentially cause Select N+1 in cascaded saves, so warn the user.
				log.Warn("Unable to determine if " + entity.ToString()
					+ " with assigned identifier " + persister.GetIdentifier(entity, session.EntityMode)
					+ " is transient or detached; querying the database."
					+ " Use explicit Save() or Update() in session to prevent this.");
			}

			// hit the database, after checking the session cache for a snapshot
			System.Object[] snapshot =
				session.PersistenceContext.GetDatabaseSnapshot(persister.GetIdentifier(entity, session.EntityMode), persister);
			return snapshot == null;
		}

		public override object Hydrate(IDataReader rs, string[] names, ISessionImplementor session, object owner)
		{
			IType type = GetIdentifierOrUniqueKeyType(session.Factory);
			object identifier = session.GetContextEntityIdentifier(owner);

			//This ugly mess is only used when mapping one-to-one entities with component ID types
			EmbeddedComponentType componentType = type as EmbeddedComponentType;
			if (componentType != null)
			{
				EmbeddedComponentType ownerIdType = session.GetEntityPersister(null, owner).IdentifierType as EmbeddedComponentType;
				if (ownerIdType != null)
				{
					object[] values = ownerIdType.GetPropertyValues(identifier, session);
					object id = componentType.ResolveIdentifier(values, session, null);
					IEntityPersister persister = session.Factory.GetEntityPersister(type.ReturnedClass.FullName);
					var key = new EntityKey(id, persister, session.EntityMode);
					return session.PersistenceContext.GetEntity(key);
				}
			}
			return identifier;
		}

		// Not ported: sequentialLoad, loadSequentialRowsForward, loadSequentialRowsReverse

		internal static EntityKey GetOptionalObjectKey(QueryParameters queryParameters, ISessionImplementor session)
		{
			object optionalObject = queryParameters.OptionalObject;
			object optionalId = queryParameters.OptionalId;
			System.Type optionalEntityClass = queryParameters.OptionalEntityClass;

			if (optionalObject != null && optionalEntityClass != null)
			{
				return new EntityKey(
					optionalId,
					session.GetEntityPersister(optionalObject)
					// TODO H3: session.GetEntityPersister( optionalEntityName, optionalObject )
					// TODO H3: session.getEntityMode()
					);
			}
			else
			{
				return null;
			}
		}

        /// <summary> 
        /// Is this instance, which we know is not persistent, actually transient? 
        /// If <tt>assumed</tt> is non-null, don't hit the database to make the 
        /// determination, instead assume that value; the client code must be 
        /// prepared to "recover" in the case that this assumed result is incorrect.
        /// </summary>
        /// <remarks>
        /// If <paramref name="assumed"/> is non-null, don't hit the database to make the 
        /// determination, instead assume that value; the client code must be 
        /// prepared to "recover" in the case that this assumed result is incorrect.
        /// </remarks>
        public static bool IsTransient(string entityName, object entity, bool? assumed, ISessionImplementor session)
        {
            if (entity == Intercept.LazyPropertyInitializer.UnfetchedProperty)
            {
                // an unfetched association can only point to
                // an entity that already exists in the db
                return false;
            }

            // let the interceptor inspect the instance to decide
            bool? isUnsaved = session.Interceptor.IsTransient(entity);
            if (isUnsaved.HasValue)
                return isUnsaved.Value;

            // let the persister inspect the instance to decide
            IEntityPersister persister = session.GetEntityPersister(entity);
            isUnsaved = persister.IsTransient(entity, session);
            if (isUnsaved.HasValue)
                return isUnsaved.Value;

            // we use the assumed value, if there is one, to avoid hitting
            // the database
            if (assumed.HasValue)
                return assumed.Value;

            // hit the database, after checking the session cache for a snapshot
            System.Object[] snapshot =
                session.PersistenceContext.GetDatabaseSnapshot(persister.GetIdentifier(entity, session.EntityMode), persister);
            return snapshot == null;
        }