C# ISessionFactoryImplementor.GetPersister方法代码示例

		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++;
				}
//.........这里部分代码省略.........

		protected void CreateUniqueKeyLoaders( ISessionFactoryImplementor factory )
		{
			// TODO: Does not handle components, or properties of a joined subclass
			for( int i = 0; i < propertyNames.Length; i++ )
			{
				string[ ] columns = ( string[ ] ) uniqueKeyColumns[ propertyNames[ i ] ];
				if( columns != null )
				{
					IType uniqueKeyType = propertyTypes[ i ];
					if( uniqueKeyType.IsEntityType )
					{
						System.Type clazz = ( ( EntityType ) uniqueKeyType ).AssociatedClass;
						uniqueKeyType = factory.GetPersister( clazz ).IdentifierType;
					}
					uniqueKeyLoaders.Add( propertyNames[ i ], new EntityLoader( this, columns, uniqueKeyType, 1, factory ) );
				}
			}
		}

		/// <summary>
		/// Does the mapping, and Hibernate default semantics, specify that
		/// this association should be fetched by outer joining
		/// </summary>
		/// <param name="config"></param>
		/// <param name="type"></param>
		/// <param name="factory"></param>
		/// <returns></returns>
		protected bool IsJoinedFetchEnabledByDefault( OuterJoinFetchStrategy config, IAssociationType type, ISessionFactoryImplementor factory )
		{
			if ( !type.IsEntityType && !type.IsPersistentCollectionType )
			{
				return false;
			}
			else
			{
				switch ( config )
				{
					case OuterJoinFetchStrategy.Eager:
						return true;

					case OuterJoinFetchStrategy.Lazy:
						return false;

					case OuterJoinFetchStrategy.Auto:
						if ( !factory.IsOuterJoinedFetchEnabled )
						{
							return false;
						}
						if ( type.IsEntityType )
						{
							EntityType entityType = type as EntityType;
							IClassPersister persister = factory.GetPersister( entityType.AssociatedClass );
							return !persister.HasProxy || (
								entityType.IsOneToOne &&
								( (OneToOneType) entityType).IsNullable
								);
						}
						else
						{
							return false;
						}

					default:
						throw new ArgumentOutOfRangeException( "config", config, "Unknown OJ strategy " + config.ToString() );
				}
			}
		}

		private static IQueryable GetPropertyMapping( System.Type persistentClass, ISessionFactoryImplementor sessionFactory )
		{
			return ( IQueryable ) sessionFactory.GetPersister( persistentClass );
		}