singletableentitypersister.cs

NHibernate NET开发者所需的

			PostConstruct(mapping);
		}

		public override string DiscriminatorColumnName
		{
			get { return discriminatorColumnName; }
		}

		protected override string DiscriminatorFormulaTemplate
		{
			get { return discriminatorFormulaTemplate; }
		}

		public override IType DiscriminatorType
		{
			get { return discriminatorType; }
		}

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

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

		public virtual string[] SubclassClosure
		{
			get { return subclassClosure; }
		}

		public override string[] PropertySpaces
		{
			get { return spaces; }
		}

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

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

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

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

		public override bool IsMultiTable
		{
			get { return TableSpan > 1; }
		}

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

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

		protected override bool IsInverseTable(int j)
		{
			return isInverseTable[j];
		}

		protected override bool IsInverseSubclassTable(int j)
		{
			return isInverseSubclassTable[j];
		}

		protected internal override string DiscriminatorAlias
		{
			get { return discriminatorAlias; }
		}

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

		public override string GetSubclassForDiscriminatorValue(object value)
		{
			string result;
			if (value == null)
			{
				subclassesByDiscriminatorValue.TryGetValue(NullDiscriminator, out result);
			}
			else
			{
				if (!subclassesByDiscriminatorValue.TryGetValue(value, out result))
					subclassesByDiscriminatorValue.TryGetValue(NotNullDiscriminator, out result);
			}
			return result;
		}

		protected bool IsDiscriminatorFormula
		{
			get { return discriminatorColumnName == null; }
		}

		protected string DiscriminatorFormula
		{
			get { return discriminatorFormula; }
		}

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

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

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

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

		protected override bool IsSubclassTableSequentialSelect(int table)
		{
			return subclassTableSequentialSelect[table] && !isClassOrSuperclassTable[table];
		}

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

		public override string FilterFragment(string alias)
		{
			string result = DiscriminatorFilterFragment(alias);
			if (HasWhere)
				result += " and " + GetSQLWhereString(alias);

			return result;
		}

		public override string OneToManyFilterFragment(string alias)
		{
			return forceDiscriminator ? DiscriminatorFilterFragment(alias) : string.Empty;
		}

		private string DiscriminatorFilterFragment(string alias)
		{
			if (NeedsDiscriminator)
			{
				InFragment frag = new InFragment();

				if (IsDiscriminatorFormula)
				{
					frag.SetFormula(alias, DiscriminatorFormulaTemplate);
				}
				else
				{
					frag.SetColumn(alias, DiscriminatorColumnName);
				}

				string[] subclasses = SubclassClosure;
				for (int i = 0; i < subclasses.Length; i++)
				{
					IQueryable queryable = (IQueryable)Factory.GetEntityPersister(subclasses[i]);
					if (!queryable.IsAbstract)
						frag.AddValue(queryable.DiscriminatorSQLValue);
				}

				StringBuilder buf = new StringBuilder(50).Append(" and ").Append(frag.ToFragmentString().ToString());

				return buf.ToString();
			}
			else
			{
				return string.Empty;
			}
		}

		private bool NeedsDiscriminator
		{
			get { return forceDiscriminator || IsInherited; }
		}

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

		protected override void AddDiscriminatorToSelect(SelectFragment select, string name, string suffix)
		{
			if (IsDiscriminatorFormula)
				select.AddFormula(name, DiscriminatorFormulaTemplate, DiscriminatorAlias);
			else
				select.AddColumn(name, DiscriminatorColumnName, DiscriminatorAlias);
		}

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

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

		protected override void AddDiscriminatorToInsert(SqlInsertBuilder insert)
		{
			if (discriminatorInsertable)
				insert.AddColumn(DiscriminatorColumnName, DiscriminatorSQLValue);
		}

		protected override bool IsSubclassPropertyDeferred(string propertyName, string entityName)
		{
			return
				hasSequentialSelects && IsSubclassTableSequentialSelect(GetSubclassPropertyTableNumber(propertyName, entityName));
		}

		public override bool HasSequentialSelect
		{
			get { return hasSequentialSelects; }
		}

		public int GetSubclassPropertyTableNumber(string propertyName, string entityName)
		{
			IType type = propertyMapping.ToType(propertyName);
			if (type.IsAssociationType && ((IAssociationType)type).UseLHSPrimaryKey)
				return 0;
			int tabnum;
			propertyTableNumbersByNameAndSubclass.TryGetValue(entityName + '.' + propertyName, out tabnum);
			return tabnum;
		}

		protected override SqlString GetSequentialSelect(string entityName)
		{
			SqlString result;
			sequentialSelectStringsByEntityName.TryGetValue(entityName, out result);
			return result;
		}

		private SqlString GenerateSequentialSelect(ILoadable persister)
		{
			//note that this method could easily be moved up to BasicEntityPersister,
			//if we ever needed to reuse it from other subclasses

			//figure out which tables need to be fetched
			AbstractEntityPersister subclassPersister = (AbstractEntityPersister)persister;
			HashedSet<int> tableNumbers = new HashedSet<int>();
			string[] props = subclassPersister.PropertyNames;
			string[] classes = subclassPersister.PropertySubclassNames;
			for (int i = 0; i < props.Length; i++)
			{
				int propTableNumber = GetSubclassPropertyTableNumber(props[i], classes[i]);
				if (IsSubclassTableSequentialSelect(propTableNumber) && !IsSubclassTableLazy(propTableNumber))
				{
					tableNumbers.Add(propTableNumber);
				}
			}
			if ((tableNumbers.Count == 0))
				return null;

			//figure out which columns are needed
			List<int> columnNumbers = new List<int>();
			int[] columnTableNumbers = SubclassColumnTableNumberClosure;
			for (int i = 0; i < SubclassColumnClosure.Length; i++)
			{
				if (tableNumbers.Contains(columnTableNumbers[i]))
					columnNumbers.Add(i);
			}

			//figure out which formulas are needed
			List<int> formulaNumbers = new List<int>();
			int[] formulaTableNumbers = SubclassColumnTableNumberClosure;
			for (int i = 0; i < SubclassFormulaTemplateClosure.Length; i++)
			{
				if (tableNumbers.Contains(formulaTableNumbers[i]))
					formulaNumbers.Add(i);
			}

			//render the SQL
			return RenderSelect(ArrayHelper.ToIntArray(tableNumbers), columnNumbers.ToArray(), formulaNumbers.ToArray());
		}

		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];
		}

		protected internal override bool IsSubclassTableLazy(int j)
		{
			return subclassTableIsLazyClosure[j];
		}

		protected override bool IsNullableTable(int j)
		{
			return isNullableTable[j];
		}

		protected override bool IsNullableSubclassTable(int j)
		{
			return isNullableSubclassTable[j];
		}

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

		public override void PostInstantiate()
		{
			base.PostInstantiate();
			if (hasSequentialSelects)
			{
				string[] entityNames = SubclassClosure;
				for (int i = 1; i < entityNames.Length; i++)
				{
					ILoadable loadable = (ILoadable)Factory.GetEntityPersister(entityNames[i]);
					if (!loadable.IsAbstract)
					{
						//perhaps not really necessary...
						SqlString sequentialSelect = GenerateSequentialSelect(loadable);
						sequentialSelectStringsByEntityName[entityNames[i]] = sequentialSelect;
					}
				}
			}
		}
	}
}