Beispiel #1
0
        /// <summary>
        /// For a composite element, add to a list of associations to be fetched by outerjoin
        /// </summary>
        /// <param name="compositeType"></param>
        /// <param name="cols"></param>
        /// <param name="persister"></param>
        /// <param name="alias"></param>
        /// <param name="associations"></param>
        /// <param name="visitedPersisters"></param>
        /// <param name="path"></param>
        /// <param name="currentDepth"></param>
        /// <param name="factory"></param>
        private void WalkCompositeElementTree(
            IAbstractComponentType compositeType,
            string[] cols,
            IQueryableCollection persister,
            string alias,
            IList associations,
            ISet visitedPersisters,
            string path,
            int currentDepth,
            ISessionFactoryImplementor factory)
        {
            IType[]  types         = compositeType.Subtypes;
            string[] propertyNames = compositeType.PropertyNames;
            int      begin         = 0;

            for (int i = 0; i < types.Length; i++)
            {
                int      length = types[i].GetColumnSpan(factory);
                string[] range  = ArrayHelper.Slice(cols, begin, length);

                if (types[i].IsAssociationType)
                {
                    IAssociationType associationType = types[i] as IAssociationType;

                    // simple, because we can't have a one-to-one or collection in a composite element:
                    string[] aliasedForeignKeyColumns = StringHelper.Qualify(alias, range);
                    string   subpath  = SubPath(path, propertyNames[i]);
                    JoinType joinType = GetJoinType(
                        associationType,
                        compositeType.EnableJoinedFetch(i),
                        subpath,
                        persister.TableName,
                        range,
                        factory
                        );

                    if (joinType != JoinType.None)
                    {
                        WalkAssociationTree(
                            associationType,
                            aliasedForeignKeyColumns,
                            persister,
                            alias,
                            associations,
                            visitedPersisters,
                            subpath,
                            currentDepth,
                            joinType,
                            factory
                            );
                    }
                }
                else if (types[i].IsComponentType)
                {
                    string subpath = SubPath(path, propertyNames[i]);
                    WalkCompositeElementTree(
                        ( IAbstractComponentType )types[i],
                        range,
                        persister,
                        alias,
                        associations,
                        visitedPersisters,
                        subpath,
                        currentDepth,
                        factory
                        );
                }
                begin += length;
            }
        }
		/// <summary>
		/// For a composite element, add to a list of associations to be fetched by outerjoin
		/// </summary>
		/// <param name="compositeType"></param>
		/// <param name="cols"></param>
		/// <param name="persister"></param>
		/// <param name="alias"></param>
		/// <param name="associations"></param>
		/// <param name="visitedPersisters"></param>
		/// <param name="path"></param>
		/// <param name="currentDepth"></param>
		/// <param name="factory"></param>
		private void WalkCompositeElementTree(
			IAbstractComponentType compositeType,
			string[ ] cols,
			IQueryableCollection persister,
			string alias,
			IList associations,
			ISet visitedPersisters,
			string path,
			int currentDepth,
			ISessionFactoryImplementor factory )
		{
			IType[ ] types = compositeType.Subtypes;
			string[ ] propertyNames = compositeType.PropertyNames;
			int begin = 0;
			for( int i = 0; i < types.Length; i++ )
			{
				int length = types[ i ].GetColumnSpan( factory );
				string[ ] range = ArrayHelper.Slice( cols, begin, length );

				if( types[ i ].IsAssociationType )
				{
					IAssociationType associationType = types[ i ] as IAssociationType;

					// simple, because we can't have a one-to-one or collection in a composite element:
					string[] aliasedForeignKeyColumns = StringHelper.Qualify( alias, range );
					string subpath = SubPath( path, propertyNames[ i ] );
					JoinType joinType = GetJoinType(
						associationType,
						compositeType.EnableJoinedFetch( i ),
						subpath,
						persister.TableName,
						range,
						factory
						);

					if ( joinType != JoinType.None )
					{
						WalkAssociationTree( 
							associationType, 
							aliasedForeignKeyColumns, 
							persister, 
							alias, 
							associations, 
							visitedPersisters, 
							subpath, 
							currentDepth,
							joinType,
							factory
							);
					}
				}
				else if( types[ i ].IsComponentType )
				{
					string subpath = SubPath( path, propertyNames[ i ] );
					WalkCompositeElementTree(
						( IAbstractComponentType ) types[ i ],
						range,
						persister,
						alias,
						associations,
						visitedPersisters,
						subpath,
						currentDepth,
						factory
						);

				}
				begin += length;
			}
		}
Beispiel #3
0
        /// <summary>
        /// For a component, add to a list of associations to be fetched by outerjoin
        /// </summary>
        /// <param name="componentType"></param>
        /// <param name="propertyNumber"></param>
        /// <param name="cols"></param>
        /// <param name="persister"></param>
        /// <param name="alias"></param>
        /// <param name="associations"></param>
        /// <param name="visitedPersisters"></param>
        /// <param name="aliasedCols"></param>
        /// <param name="path"></param>
        /// <param name="currentDepth"></param>
        /// <param name="factory"></param>
        private void WalkComponentTree(
            IAbstractComponentType componentType,
            int propertyNumber,
            string[] cols,
            string[] aliasedCols,
            IOuterJoinLoadable persister,
            string alias,
            IList associations,
            ISet visitedPersisters,
            string path,
            int currentDepth,
            ISessionFactoryImplementor factory)
        {
            IType[]  types         = componentType.Subtypes;
            string[] propertyNames = componentType.PropertyNames;
            int      begin         = 0;

            for (int i = 0; i < types.Length; i++)
            {
                int      length       = types[i].GetColumnSpan(factory);
                string[] range        = ArrayHelper.Slice(cols, begin, length);
                string[] aliasedRange = ArrayHelper.Slice(aliasedCols, begin, length);

                if (types[i].IsAssociationType)
                {
                    IAssociationType associationType = ( IAssociationType )types[i];

                    if (IsJoinedFetchAlwaysDisabled(persister, associationType, propertyNumber))
                    {
                        return;
                    }

                    string[] aliasedFkColumns = GetAliasedForeignKeyColumns(persister, alias, associationType, aliasedRange);
                    string[] fkColumns        = GetForeignKeyColumns(persister, associationType, range);
                    string   subpath          = SubPath(path, propertyNames[i]);
                    JoinType joinType         = GetJoinType(
                        associationType,
                        componentType.EnableJoinedFetch(i),
                        subpath,
                        persister.GetSubclassPropertyTableName(propertyNumber),
                        fkColumns,
                        factory
                        );

                    if (joinType != JoinType.None)
                    {
                        WalkAssociationTree(
                            associationType,
                            aliasedFkColumns,
                            persister,
                            alias,
                            associations,
                            visitedPersisters,
                            subpath,
                            currentDepth,
                            joinType,
                            factory
                            );
                    }
                }
                else if (types[i].IsComponentType)
                {
                    string subpath = SubPath(path, propertyNames[i]);

                    WalkComponentTree(
                        ( IAbstractComponentType )types[i],
                        propertyNumber,
                        range,
                        aliasedRange,
                        persister,
                        alias,
                        associations,
                        visitedPersisters,
                        subpath,
                        currentDepth,
                        factory
                        );
                }
                begin += length;
            }
        }
		/// <summary>
		/// For a component, add to a list of associations to be fetched by outerjoin
		/// </summary>
		/// <param name="componentType"></param>
		/// <param name="propertyNumber"></param>
		/// <param name="cols"></param>
		/// <param name="persister"></param>
		/// <param name="alias"></param>
		/// <param name="associations"></param>
		/// <param name="visitedPersisters"></param>
		/// <param name="aliasedCols"></param>
		/// <param name="path"></param>
		/// <param name="currentDepth"></param>
		/// <param name="factory"></param>
		private void WalkComponentTree(
			IAbstractComponentType componentType,
			int propertyNumber,
			string[ ] cols,
			string[ ] aliasedCols,
			IOuterJoinLoadable persister,
			string alias,
			IList associations,
			ISet visitedPersisters,
			string path,
			int currentDepth,
			ISessionFactoryImplementor factory )
		{
			IType[ ] types = componentType.Subtypes;
			string[ ] propertyNames = componentType.PropertyNames;
			int begin = 0;
			for( int i = 0; i < types.Length; i++ )
			{
				int length = types[ i ].GetColumnSpan( factory );
				string[ ] range = ArrayHelper.Slice( cols, begin, length );
				string[ ] aliasedRange = ArrayHelper.Slice( aliasedCols, begin, length );

				if( types[ i ].IsAssociationType )
				{
					IAssociationType associationType = ( IAssociationType ) types[ i ];

					if ( IsJoinedFetchAlwaysDisabled( persister, associationType, propertyNumber ) )
					{
						return;
					}

					string[] aliasedFkColumns = GetAliasedForeignKeyColumns( persister, alias, associationType, aliasedRange );
					string[] fkColumns = GetForeignKeyColumns( persister, associationType, range );
					string subpath = SubPath( path, propertyNames[ i ] );
					JoinType joinType = GetJoinType(
						associationType,
						componentType.EnableJoinedFetch( i ),
						subpath,
						persister.GetSubclassPropertyTableName( propertyNumber ),
						fkColumns,
						factory
						);

					if ( joinType != JoinType.None )
					{
						WalkAssociationTree(
							associationType,
							aliasedFkColumns,
							persister,
							alias,
							associations,
							visitedPersisters,
							subpath,
							currentDepth,
							joinType,
							factory
							);
					}
				}
				else if( types[ i ].IsComponentType )
				{
					string subpath = SubPath( path, propertyNames[ i ] );

					WalkComponentTree( 
						( IAbstractComponentType ) types[ i ], 
						propertyNumber, 
						range, 
						aliasedRange, 
						persister, 
						alias, 
						associations, 
						visitedPersisters, 
						subpath, 
						currentDepth,
						factory
						);
				}
				begin += length;
			}
		}