joinedsubclassentitypersister.cs

NHibernate NET开发者所需的

				{
					if (persistentClass.IsPolymorphic)
					{
						// we now use subclass ids that are consistent across all
						// persisters for a class hierarchy, so that the use of 
						// "foo.class = Bar" works in HQL
						int subclassId = sc.SubclassId; //new Integer(k+1);
						subclassesByDiscriminatorValue[subclassId] = sc.EntityName;
						discriminatorValues[k2] = subclassId.ToString();
						int id =
							GetTableId(
								sc.Table.GetQualifiedName(factory.Dialect, factory.Settings.DefaultCatalogName,
								                          factory.Settings.DefaultSchemaName), subclassTableNameClosure);
						notNullColumnTableNumbers[k2] = id;
						notNullColumnNames[k2] = subclassTableKeyColumnClosure[id][0]; 
						//( (Column) sc.getTable().getPrimaryKey().getColumnIterator().next() ).getName();
					}
				}
				catch (Exception e)
				{
					throw new MappingException("Error parsing discriminator value", e);
				}
				k2++;				
			}

			#endregion

			InitLockers();

			InitSubclassPropertyAliasesMap(persistentClass);

			PostConstruct(mapping);
		}

		public override IType DiscriminatorType
		{
			get { return NHibernateUtil.Int32; }
		}

		public override string DiscriminatorSQLValue
		{
			get { return discriminatorSQLString; }
		}

		public override object DiscriminatorValue
		{
			get { return discriminatorValue; }
		}

		public override string[] PropertySpaces
		{
			get
			{
				// don't need subclass tables, because they can't appear in conditions
				return spaces;
			}
		}

		public override string[] IdentifierColumnNames
		{
			get { return tableKeyColumns[0]; }
		}

		protected internal override int[] PropertyTableNumbersInSelect
		{
			get { return propertyTableNumbers; }
		}

		public override bool IsMultiTable
		{
			get { return true; }
		}

		protected override int[] SubclassColumnTableNumberClosure
		{
			get { return subclassColumnTableNumberClosure; }
		}

		protected override int[] SubclassFormulaTableNumberClosure
		{
			get { return subclassFormulaTableNumberClosure; }
		}

		protected internal override int[] PropertyTableNumbers
		{
			get { return naturalOrderPropertyTableNumbers; }
		}

		public override string[] ConstraintOrderedTableNameClosure
		{
			get { return constraintOrderedTableNames; }
		}

		public override string[][] ContraintOrderedTableKeyColumnClosure
		{
			get { return constraintOrderedKeyColumnNames; }
		}

		public override string RootTableName
		{
			get { return naturalOrderTableNames[0]; }
		}

		public override string GetSubclassPropertyTableName(int i)
		{
			return subclassTableNameClosure[subclassPropertyTableNumberClosure[i]];
		}

		public override string GetSubclassForDiscriminatorValue(object value)
		{
			string result;
			subclassesByDiscriminatorValue.TryGetValue(value, out result);
			return result;
		}

		protected override string GetTableName(int table)
		{
			return naturalOrderTableNames[table];
		}

		protected override string[] GetKeyColumns(int table)
		{
			return naturalOrderTableKeyColumns[table];
		}

		protected override bool IsTableCascadeDeleteEnabled(int j)
		{
			return naturalOrderCascadeDeleteEnabled[j];
		}

		protected override bool IsPropertyOfTable(int property, int table)
		{
			return naturalOrderPropertyTableNumbers[property] == table;
		}

		private static void Reverse(object[] objects, int len)
		{
			object[] temp = new object[len];
			for (int i = 0; i < len; i++)
				temp[i] = objects[len - i - 1];

			for (int i = 0; i < len; i++)
				objects[i] = temp[i];
		}

		private static string[] Reverse(string[] objects)
		{
			int len = objects.Length;
			string[] temp = new string[len];
			for (int i = 0; i < len; i++)
				temp[i] = objects[len - i - 1];

			return temp;
		}

		private static string[][] Reverse(string[][] objects)
		{
			int len = objects.Length;
			string[][] temp = new string[len][];
			for (int i = 0; i < len; i++)
				temp[i] = objects[len - i - 1];

			return temp;
		}

		public override string FromTableFragment(string alias)
		{
			return TableName + ' ' + alias;
		}

		public override string TableName
		{
			get { return tableNames[0]; }
		}

		/// <summary>
		/// Find the Index of the table name from a list of table names.
		/// </summary>
		/// <param name="tableName">The name of the table to find.</param>
		/// <param name="tables">The array of table names</param>
		/// <returns>The Index of the table in the array.</returns>
		/// <exception cref="AssertionFailure">Thrown when the tableName specified can't be found</exception>
		private static int GetTableId(string tableName, string[] tables)
		{
			for (int i = 0; i < tables.Length; i++)
			{
				if (tableName.Equals(tables[i]))
					return i;
			}

			throw new AssertionFailure(string.Format("Table [{0}] not found", tableName));
		}

		protected override void AddDiscriminatorToSelect(SelectFragment select, string name, string suffix)
		{
			if (HasSubclasses)
			{
				select.SetExtraSelectList(DiscriminatorFragment(name), DiscriminatorAlias);
			}
		}

		private CaseFragment DiscriminatorFragment(string alias)
		{
			CaseFragment cases = Factory.Dialect.CreateCaseFragment();

			for (int i = 0; i < discriminatorValues.Length; i++)
			{
				cases.AddWhenColumnNotNull(GenerateTableAlias(alias, notNullColumnTableNumbers[i]), notNullColumnNames[i],
				                           discriminatorValues[i]);
			}
			return cases;
		}

		public override string FilterFragment(string alias)
		{
			return HasWhere ? " and " + GetSQLWhereString(GenerateFilterConditionAlias(alias)) : string.Empty;
		}

		public override string GenerateFilterConditionAlias(string rootAlias)
		{
			return GenerateTableAlias(rootAlias, tableSpan - 1);
		}

		public override string[] ToColumns(string alias, string propertyName)
		{
			if (EntityClass.Equals(propertyName))
			{
				// This doesn't actually seem to work but it *might* 
				// work on some dbs. Also it doesn't work if there 
				// are multiple columns of results because it 
				// is not accounting for the suffix: 
				// return new String[] { getDiscriminatorColumnName() }; 

				//TODO: this will need to be changed to return a SqlString but for now the SqlString
				// is being converted to a string for existing interfaces to work.
				return new string[] { DiscriminatorFragment(alias).ToSqlStringFragment() };
			}
			else
			{
				return base.ToColumns(alias, propertyName);
			}
		}

		protected override int GetSubclassPropertyTableNumber(int i)
		{
			return subclassPropertyTableNumberClosure[i];
		}

		protected override int TableSpan
		{
			get { return tableSpan; }
		}

		protected override string[] GetSubclassTableKeyColumns(int j)
		{
			return subclassTableKeyColumnClosure[j];
		}

		public override string GetSubclassTableName(int j)
		{
			return subclassTableNameClosure[j];
		}

		protected override int SubclassTableSpan
		{
			get { return subclassTableNameClosure.Length; }
		}

		protected override bool IsClassOrSuperclassTable(int j)
		{
			return isClassOrSuperclassTable[j];
		}

		public override string GetPropertyTableName(string propertyName)
		{
			int? index = EntityMetamodel.GetPropertyIndexOrNull(propertyName);
			if (!index.HasValue) return null;
			return tableNames[propertyTableNumbers[index.Value]];
		}

		public override string GetRootTableAlias(string drivingAlias)
		{
			return GenerateTableAlias(drivingAlias, GetTableId(RootTableName, tableNames));
		}

		public override Declarer GetSubclassPropertyDeclarer(string propertyPath)
		{
			if ("class".Equals(propertyPath))
			{
				// special case where we need to force include all subclass joins
				return Declarer.SubClass;
			}
			return base.GetSubclassPropertyDeclarer(propertyPath);
		}
	}
}