public NativeSQLQuerySpecification(
			string queryString,
			INativeSQLQueryReturn[] sqlQueryReturns,
			ICollection<string> querySpaces)
		{
			this.queryString = queryString;
			this.sqlQueryReturns = sqlQueryReturns;

			if (querySpaces == null)
			{
                this.querySpaces = new IESI.HashedSet<string>();
			}
			else
			{
                var tmp = new IESI.HashedSet<string>();
				tmp.AddAll(querySpaces);
				// Can't use ImmutableSet here because it doesn't implement GetHashCode properly.
				this.querySpaces = tmp;
			}

			// pre-determine and cache the hashcode
			int hCode = queryString.GetHashCode();
			unchecked
			{
				hCode = 29 * hCode + CollectionHelper.GetHashCode(this.querySpaces);
				if (this.sqlQueryReturns != null)
				{
					hCode = 29 * hCode + CollectionHelper.GetHashCode(this.sqlQueryReturns);
				}
			}

			hashCode = hCode;
		}
		public void UpdateReservedWordsInDialect()
		{
			var reservedDb = new IESI.HashedSet<string>();
			var configuration = TestConfigurationHelper.GetDefaultConfiguration();
			var dialect = Dialect.Dialect.GetDialect(configuration.Properties);
			var connectionHelper = new ManagedProviderConnectionHelper(configuration.Properties);
			connectionHelper.Prepare();
			try
			{
				var metaData = dialect.GetDataBaseSchema(connectionHelper.Connection);
				foreach (var rw in metaData.GetReservedWords())
				{
					reservedDb.Add(rw.ToLowerInvariant());
				}
			}
			finally
			{
				connectionHelper.Release();
			}

			var sf = (ISessionFactoryImplementor) configuration.BuildSessionFactory();
			SchemaMetadataUpdater.Update(sf);
			var match = reservedDb.Intersect(sf.Dialect.Keywords);
			Assert.That(match, Is.EquivalentTo(reservedDb));
		}
		/// <summary>
		/// Create an action that will evict collection and entity regions based on queryspaces (table names).  
		/// </summary>
		public BulkOperationCleanupAction(ISessionImplementor session, IESI.ISet<string> querySpaces)
		{
			//from H3.2 TODO: cache the autodetected information and pass it in instead.
			this.session = session;

			IESI.ISet<string> tmpSpaces = new IESI.HashedSet<string>(querySpaces);
			ISessionFactoryImplementor factory = session.Factory;
			IDictionary<string, IClassMetadata> acmd = factory.GetAllClassMetadata();
			foreach (KeyValuePair<string, IClassMetadata> entry in acmd)
			{
				string entityName = entry.Key;
				IEntityPersister persister = factory.GetEntityPersister(entityName);
				string[] entitySpaces = persister.QuerySpaces;

				if (AffectedEntity(querySpaces, entitySpaces))
				{
					if (persister.HasCache)
					{
						affectedEntityNames.Add(persister.EntityName);
					}
					IESI.ISet<string> roles = session.Factory.GetCollectionRolesByEntityParticipant(persister.EntityName);
					if (roles != null)
					{
						affectedCollectionRoles.AddAll(roles);
					}
					for (int y = 0; y < entitySpaces.Length; y++)
					{
						tmpSpaces.Add(entitySpaces[y]);
					}
				}
			}
			spaces = new List<string>(tmpSpaces);
		}
Пример #4
0
        public static void Synchronize(DirectoryInfo source, DirectoryInfo destination, bool smart)
        {
            if (!destination.Exists)
            {
                destination.Create();
            }

            FileInfo[] sources = source.GetFiles();
            IESI.ISet<string> srcNames = new IESI.HashedSet<string>();
            foreach (FileInfo fileInfo in sources)
            {
                srcNames.Add(fileInfo.Name);
            }

            FileInfo[] dests = destination.GetFiles();

            // Delete files not present in source
            foreach (FileInfo file in dests)
            {
                if (!srcNames.Contains(file.Name))
                {
                    try
                    {
                        /*
                         * Try to delete, could fail because windows don't permit a file to be
                         * deleted while it is in use. If it is the case, the file would be deleted 
                         * when the index is reopened or in the next synchronization. 
                         */
                        file.Delete();
                    }
                    catch (IOException e)
                    {
                        if (log.IsWarnEnabled)
                        {
                            log.Warn("Unable to delete file " + file.Name + ", maybe in use per another reader", e);
                        }
                    }
                }
            }

            // Copy each file from source
            foreach (FileInfo sourceFile in sources)
            {
                FileInfo destinationFile = new FileInfo(Path.Combine(destination.FullName, sourceFile.Name));
                long destinationChanged = destinationFile.LastWriteTime.Ticks/LastWriteTimePrecision;
                long sourceChanged = sourceFile.LastWriteTime.Ticks/LastWriteTimePrecision;
                if (!smart || destinationChanged != sourceChanged)
                {
                    sourceFile.CopyTo(destinationFile.FullName, true);
                }
            }

            foreach (DirectoryInfo directoryInfo in source.GetDirectories())
            {
                Synchronize(directoryInfo, new DirectoryInfo(Path.Combine(destination.FullName, directoryInfo.Name)), smart);
            }
        }
        public static IndexSearcher BuildSearcher(ISearchFactoryImplementor searchFactory,
                                             out IESI.ISet<System.Type> classesAndSubclasses,
                                             params System.Type[] classes)
        {
            IDictionary<System.Type, DocumentBuilder> builders = searchFactory.DocumentBuilders;
            IESI.ISet<IDirectoryProvider> directories = new IESI.HashedSet<IDirectoryProvider>();
            if (classes == null || classes.Length == 0)
            {
                // no class means all classes
                foreach (DocumentBuilder builder in builders.Values)
                {
                    foreach (IDirectoryProvider provider in builder.DirectoryProvidersSelectionStrategy.GetDirectoryProvidersForAllShards())
                    {
                        directories.Add(provider);
                    }
                }

                // Give them back an empty set
                classesAndSubclasses = null;
            }
            else
            {
                var involvedClasses = new IESI.HashedSet<System.Type>();
                involvedClasses.AddAll(classes);
                foreach (System.Type clazz in classes)
                {
                    DocumentBuilder builder;
                    builders.TryGetValue(clazz, out builder);
                    if (builder != null)
                    {
                        involvedClasses.AddAll(builder.MappedSubclasses);
                    }
                }

                foreach (System.Type clazz in involvedClasses)
                {
                    DocumentBuilder builder;
                    builders.TryGetValue(clazz, out builder);

                    // TODO should we rather choose a polymorphic path and allow non mapped entities
                    if (builder == null)
                    {
                        throw new HibernateException("Not a mapped entity: " + clazz);
                    }

                    foreach (IDirectoryProvider provider in builder.DirectoryProvidersSelectionStrategy.GetDirectoryProvidersForAllShards())
                    {
                        directories.Add(provider);
                    }
                }

                classesAndSubclasses = involvedClasses;
            }

            IDirectoryProvider[] directoryProviders = new List<IDirectoryProvider>(directories).ToArray();
            return new IndexSearcher(searchFactory.ReaderProvider.OpenReader(directoryProviders));
        }
Пример #6
0
		public virtual void AddOffspring(Animal offSpring)
		{
			if (Offspring == null)
			{
				Offspring = new IESI.HashedSet<Animal>();
			}

			Offspring.Add(offSpring);
		}
		public IESI.ISet<string> GetQuerySpaces()
		{
			IESI.ISet<string> result = new IESI.HashedSet<string>();

			foreach (ICriteriaInfoProvider info in criteriaInfoMap.Values)
			{
				result.AddAll(info.Spaces);
			}

			foreach (ICollectionPersister collectionPersister in criteriaCollectionPersisters)
			{
				result.AddAll(collectionPersister.CollectionSpaces);
			}
			return result;
		}
		public virtual void OnMerge(MergeEvent @event)
		{
			EventCache copyCache = new EventCache();
			
			OnMerge(@event, copyCache);
			
			// TODO: iteratively get transient entities and retry merge until one of the following conditions:
			//   1) transientCopyCache.size() == 0
			//   2) transientCopyCache.size() is not decreasing and copyCache.size() is not increasing
			
			// TODO: find out if retrying can add entities to copyCache (don't think it can...)
			// For now, just retry once; throw TransientObjectException if there are still any transient entities
			
			IDictionary transientCopyCache = this.GetTransientCopyCache(@event, copyCache);
			
			if (transientCopyCache.Count > 0)
			{
				RetryMergeTransientEntities(@event, transientCopyCache, copyCache);
				
				// find any entities that are still transient after retry
				transientCopyCache = this.GetTransientCopyCache(@event, copyCache);
				
				if (transientCopyCache.Count > 0)
				{
					IESI.ISet<string> transientEntityNames = new IESI.HashedSet<string>();
					
					foreach (object transientEntity in transientCopyCache.Keys)
					{
						string transientEntityName = @event.Session.GuessEntityName(transientEntity);
						
						transientEntityNames.Add(transientEntityName);
						
						log.InfoFormat(
							"transient instance could not be processed by merge: {0} [{1}]",
							transientEntityName,
							transientEntity.ToString());
					}
					
					throw new TransientObjectException("one or more objects is an unsaved transient instance - save transient instance(s) before merging: " + transientEntityNames);
				}
			}

			copyCache.Clear();
			copyCache = null;
		}
		private static IESI.ISet<string> GetReservedWords(Dialect.Dialect dialect, IConnectionHelper connectionHelper)
		{
			IESI.ISet<string> reservedDb = new IESI.HashedSet<string>();
			connectionHelper.Prepare();
			try
			{
				var metaData = dialect.GetDataBaseSchema(connectionHelper.Connection);
				foreach (var rw in metaData.GetReservedWords())
				{
					reservedDb.Add(rw.ToLowerInvariant());
				}
			}
			finally
			{
				connectionHelper.Release();
			}
			return reservedDb;
		}
		public IList TransformList(IList list)
		{
			IList result = (IList)Activator.CreateInstance(list.GetType());
			IESI.ISet<Identity> distinct = new IESI.HashedSet<Identity>();

			for (int i = 0; i < list.Count; i++)
			{
				object entity = list[i];
				if (distinct.Add(new Identity(entity)))
				{
					result.Add(entity);
				}
			}

			if (log.IsDebugEnabled)
			{
				log.Debug(string.Format("transformed: {0} rows to: {1} distinct results",
				                        list.Count, result.Count));
			}
			return result;
		}
		protected AbstractAuxiliaryDatabaseObject(IESI.HashedSet<string> dialectScopes)
		{
			this.dialectScopes = dialectScopes;
		}
		protected AbstractAuxiliaryDatabaseObject()
		{
            dialectScopes = new IESI.HashedSet<string>();
		}
Пример #13
0
 public FirstLevel() {
    SecondLevels = new IESI.HashedSet<SecondLevelComponent>();
 }
Пример #14
0
      public SpecificThirdLevel() {
				FourthLevels = new IESI.HashedSet<FourthLevel>();
      }
Пример #15
0
		public VersionedEntity()
		{
			Children = new IESI.HashedSet<VersionedEntity>();
		}
		public void AutoQuoteTableAndColumnsAtStratupIncludeKeyWordsImport()
		{
			var reservedDb = new IESI.HashedSet<string>();
			var configuration = TestConfigurationHelper.GetDefaultConfiguration();
			var dialect = Dialect.Dialect.GetDialect(configuration.Properties);
			var connectionHelper = new ManagedProviderConnectionHelper(configuration.Properties);
			connectionHelper.Prepare();
			try
			{
				var metaData = dialect.GetDataBaseSchema(connectionHelper.Connection);
				foreach (var rw in metaData.GetReservedWords())
				{
					reservedDb.Add(rw.ToLowerInvariant());
				}
			}
			finally
			{
				connectionHelper.Release();
			}

			configuration.SetProperty(Environment.Hbm2ddlKeyWords, "auto-quote");
			configuration.AddResource("NHibernate.Test.Tools.hbm2ddl.SchemaMetadataUpdaterTest.HeavyEntity.hbm.xml",
																GetType().Assembly);
			var sf = (ISessionFactoryImplementor)configuration.BuildSessionFactory();
			var match = reservedDb.Intersect(sf.Dialect.Keywords);
			Assert.That(match, Is.EquivalentTo(reservedDb));
		}
Пример #17
0
		public Post()
		{
			Comments = new IESI.HashedSet<Comment>();
		}
Пример #18
0
		protected internal virtual void CheckColumnDuplication()
		{
			IESI.HashedSet<string> cols = new IESI.HashedSet<string>();
			if (IdentifierMapper == null)
			{
				//an identifier mapper => Key will be included in the NonDuplicatedPropertyIterator
				//and checked later, so it needs to be excluded
				CheckColumnDuplication(cols, Key.ColumnIterator);
			}
			CheckColumnDuplication(cols, DiscriminatorColumnIterator);
			CheckPropertyColumnDuplication(cols, NonDuplicatedPropertyIterator);
			foreach (Join join in JoinIterator)
			{
				cols.Clear();
				CheckColumnDuplication(cols, join.Key.ColumnIterator);
				CheckPropertyColumnDuplication(cols, join.PropertyIterator);
			}
		}
		public UnionSubclassEntityPersister(PersistentClass persistentClass, ICacheConcurrencyStrategy cache, 
			ISessionFactoryImplementor factory, IMapping mapping):base(persistentClass, cache, factory)
		{
			if (IdentifierGenerator is IdentityGenerator)
			{
				throw new MappingException("Cannot use identity column key generation with <union-subclass> mapping for: " + EntityName);
			}

			// TABLE

			tableName =
				persistentClass.Table.GetQualifiedName(factory.Dialect, factory.Settings.DefaultCatalogName,
				                                       factory.Settings.DefaultSchemaName);

			#region Custom SQL

			SqlString sql;
			bool callable;
			ExecuteUpdateResultCheckStyle checkStyle;

			sql = persistentClass.CustomSQLInsert;
			callable = sql != null && persistentClass.IsCustomInsertCallable;
			checkStyle = sql == null
			             	? ExecuteUpdateResultCheckStyle.Count
			             	: (persistentClass.CustomSQLInsertCheckStyle
			             	   ?? ExecuteUpdateResultCheckStyle.DetermineDefault(sql, callable));
			customSQLInsert = new SqlString[] { sql };
			insertCallable = new bool[] { callable };
			insertResultCheckStyles = new ExecuteUpdateResultCheckStyle[] { checkStyle };

			sql = persistentClass.CustomSQLUpdate;
			callable = sql != null && persistentClass.IsCustomUpdateCallable;
			checkStyle = sql == null
			             	? ExecuteUpdateResultCheckStyle.Count
			             	: (persistentClass.CustomSQLUpdateCheckStyle
			             	   ?? ExecuteUpdateResultCheckStyle.DetermineDefault(sql, callable));
			customSQLUpdate = new SqlString[] { sql };
			updateCallable = new bool[] { callable };
			updateResultCheckStyles = new ExecuteUpdateResultCheckStyle[] { checkStyle };

			sql = persistentClass.CustomSQLDelete;
			callable = sql != null && persistentClass.IsCustomDeleteCallable;
			checkStyle = sql == null
			             	? ExecuteUpdateResultCheckStyle.Count
			             	: (persistentClass.CustomSQLDeleteCheckStyle
			             	   ?? ExecuteUpdateResultCheckStyle.DetermineDefault(sql, callable));
			customSQLDelete = new SqlString[] { sql };
			deleteCallable = new bool[] { callable };
			deleteResultCheckStyles = new ExecuteUpdateResultCheckStyle[] { checkStyle };

			#endregion

			discriminatorValue = persistentClass.SubclassId;
			discriminatorSQLValue = persistentClass.SubclassId.ToString();

			#region PROPERTIES

			int subclassSpan = persistentClass.SubclassSpan + 1;
			subclassClosure = new string[subclassSpan];
			subclassClosure[0] = EntityName;

			#endregion

			#region SUBCLASSES

			subclassByDiscriminatorValue[persistentClass.SubclassId] = persistentClass.EntityName;
			if (persistentClass.IsPolymorphic)
			{
				int k = 1;
				foreach (Subclass sc in persistentClass.SubclassIterator)
				{
					subclassClosure[k++] = sc.EntityName;
					subclassByDiscriminatorValue[sc.SubclassId] = sc.EntityName;
				}
			}

			#endregion

			#region SPACES
			//TODO: i'm not sure, but perhaps we should exclude abstract denormalized tables?

			int spacesSize = 1 + persistentClass.SynchronizedTables.Count;
			spaces = new string[spacesSize];
			spaces[0] = tableName;
			IEnumerator<string> iSyncTab = persistentClass.SynchronizedTables.GetEnumerator();
			for (int i = 1; i < spacesSize; i++)
			{
				iSyncTab.MoveNext();
				spaces[i] = iSyncTab.Current;
			}

			IESI.HashedSet<string> subclassTables = new IESI.HashedSet<string>();
			foreach (Table table in persistentClass.SubclassTableClosureIterator)
			{
				subclassTables.Add(
					table.GetQualifiedName(factory.Dialect, factory.Settings.DefaultCatalogName, factory.Settings.DefaultSchemaName));
			}
			subclassSpaces = new string[subclassTables.Count];
			subclassTables.CopyTo(subclassSpaces, 0);

			subquery = GenerateSubquery(persistentClass, mapping);

			if (IsMultiTable)
			{
				int idColumnSpan = IdentifierColumnSpan;
				List<string> tableNames = new List<string>();
				List<string[]> keyColumns = new List<string[]>();
				if (!IsAbstract)
				{
					tableNames.Add(tableName);
					keyColumns.Add(IdentifierColumnNames);
				}
				foreach (Table tab in persistentClass.SubclassTableClosureIterator)
				{
					if (!tab.IsAbstractUnionTable)
					{
						string _tableName =
							tab.GetQualifiedName(factory.Dialect, factory.Settings.DefaultCatalogName, factory.Settings.DefaultSchemaName);
						tableNames.Add(_tableName);

						List<string> key = new List<string>(idColumnSpan);
						foreach (Column column in tab.PrimaryKey.ColumnIterator)
							key.Add(column.GetQuotedName(factory.Dialect));

						keyColumns.Add(key.ToArray());
					}					
				}

				constraintOrderedTableNames = tableNames.ToArray();
				constraintOrderedKeyColumnNames = keyColumns.ToArray();
			}
			else
			{
				constraintOrderedTableNames = new string[] { tableName };
				constraintOrderedKeyColumnNames = new string[][] { IdentifierColumnNames };
			}
			#endregion

			InitLockers();

			InitSubclassPropertyAliasesMap(persistentClass);

			PostConstruct(mapping);
		}
		/// <summary> Constructs a PersistentContext, bound to the given session. </summary>
		/// <param name="session">The session "owning" this context. </param>
		public StatefulPersistenceContext(ISessionImplementor session)
		{
			loadCounter = 0;
			flushing = false;
			cascading = 0;
			this.session = session;

			entitiesByKey = new Dictionary<EntityKey, object>(InitCollectionSize);
			entitiesByUniqueKey = new Dictionary<EntityUniqueKey, object>(InitCollectionSize);
			proxiesByKey = new Dictionary<EntityKey, INHibernateProxy>(InitCollectionSize);
			entitySnapshotsByKey = new Dictionary<EntityKey, object>(InitCollectionSize);
			entityEntries = IdentityMap.InstantiateSequenced(InitCollectionSize);
			collectionEntries = IdentityMap.InstantiateSequenced(InitCollectionSize);
			collectionsByKey = new Dictionary<CollectionKey, IPersistentCollection>(InitCollectionSize);
			arrayHolders = IdentityMap.Instantiate(InitCollectionSize);
			parentsByChild = IdentityMap.Instantiate(InitCollectionSize);
			nullifiableEntityKeys = new IESI.HashedSet<EntityKey>();
			InitTransientState();
		}
Пример #21
0
        private static IESI.ISet<EntityKey>[] Transpose(IList<EntityKey[]> keys)
		{
            IESI.ISet<EntityKey>[] result = new IESI.ISet<EntityKey>[keys[0].Length];
			for (int j = 0; j < result.Length; j++)
			{
				result[j] = new IESI.HashedSet<EntityKey>();
				for (int i = 0; i < keys.Count; i++)
				{
					EntityKey key = keys[i][j];
					if (key != null)
					{
						result[j].Add(key);
					}
				}
			}
			return result;
		}
Пример #22
0
		private void CheckPropertyDuplication()
		{
			IESI.HashedSet<string> names = new IESI.HashedSet<string>();
			foreach (Property prop in PropertyIterator)
			{
				if (!names.Add(prop.Name))
					throw new MappingException("Duplicate property mapping of " + prop.Name + " found in " + EntityName);
			}
		}
Пример #23
0
		public Foo()
		{
			Bars = new IESI.HashedSet<Bar>();
		}
Пример #24
0
		public virtual void Resolve()
		{
			// Make sure that all from elements registered with this FROM clause are actually in the AST.
			var iter = (new ASTIterator(GetFirstChild())).GetEnumerator();
			var childrenInTree = new IESI.HashedSet<IASTNode>();
			while (iter.MoveNext())
			{
				childrenInTree.Add(iter.Current);
			}
			foreach (var fromElement in _fromElements)
			{
				if (!childrenInTree.Contains(fromElement))
				{
					throw new SemanticException("Element not in AST: " + fromElement);
				}
			}
		}
		protected string GenerateSubquery(PersistentClass model, IMapping mapping)
		{
			Dialect.Dialect dialect = Factory.Dialect;
			Settings settings = Factory.Settings;

			if (!model.HasSubclasses)
			{
				return model.Table.GetQualifiedName(dialect, settings.DefaultCatalogName, settings.DefaultSchemaName);
			}

			IESI.HashedSet<Column> columns = new IESI.HashedSet<Column>();
			foreach (Table table in model.SubclassTableClosureIterator)
			{
				if (!table.IsAbstractUnionTable)
				{
					foreach (Column column in table.ColumnIterator)
						columns.Add(column);
				}
			}

			StringBuilder buf = new StringBuilder().Append("( ");
			IEnumerable<PersistentClass> siter =
				new JoinedEnumerable<PersistentClass>(new SingletonEnumerable<PersistentClass>(model),
				                                      new SafetyEnumerable<PersistentClass>(model.SubclassIterator));

			foreach (PersistentClass clazz in siter)
			{
				Table table = clazz.Table;
				if (!table.IsAbstractUnionTable)
				{
					buf.Append("select ");
					foreach (Column col in columns)
					{
						if (!table.ContainsColumn(col))
						{
							SqlType sqlType = col.GetSqlTypeCode(mapping);
							buf.Append(dialect.GetSelectClauseNullString(sqlType)).Append(" as ");
						}
						buf.Append(col.Name);
						buf.Append(StringHelper.CommaSpace);
					}
					buf.Append(clazz.SubclassId).Append(" as clazz_");
					buf.Append(" from ").Append(table.GetQualifiedName(dialect, settings.DefaultCatalogName, settings.DefaultSchemaName));
					buf.Append(" union ");
					if (dialect.SupportsUnionAll)
						buf.Append("all ");
				}
			}

			if (buf.Length > 2)
			{
				//chop the last union (all)
				buf.Length -= (dialect.SupportsUnionAll ? 11 : 7); //" union " : "all "
			}

			return buf.Append(" )").ToString();
		}
Пример #26
0
		public Blog()
		{
			Posts = new IESI.HashedSet<Post>();
			Comments = new IESI.HashedSet<Comment>();
		}
		protected internal virtual SqlString GenerateLazySelectString()
		{
			if (!entityMetamodel.HasLazyProperties)
				return null;

			IESI.HashedSet<int> tableNumbers = new IESI.HashedSet<int>();
			List<int> columnNumbers = new List<int>();
			List<int> formulaNumbers = new List<int>();
			for (int i = 0; i < lazyPropertyNames.Length; i++)
			{
				// all this only really needs to consider properties
				// of this class, not its subclasses, but since we
				// are reusing code used for sequential selects, we
				// use the subclass closure
				int propertyNumber = GetSubclassPropertyIndex(lazyPropertyNames[i]);

				int tableNumber = GetSubclassPropertyTableNumber(propertyNumber);
				tableNumbers.Add(tableNumber);

				int[] colNumbers = subclassPropertyColumnNumberClosure[propertyNumber];
				for (int j = 0; j < colNumbers.Length; j++)
				{
					if (colNumbers[j] != -1)
					{
						columnNumbers.Add(colNumbers[j]);
					}
				}
				int[] formNumbers = subclassPropertyFormulaNumberClosure[propertyNumber];
				for (int j = 0; j < formNumbers.Length; j++)
				{
					if (formNumbers[j] != -1)
					{
						formulaNumbers.Add(formNumbers[j]);
					}
				}
			}

			if (columnNumbers.Count == 0 && formulaNumbers.Count == 0)
			{
				// only one-to-one is lazy fetched
				return null;
			}

			return RenderSelect(ArrayHelper.ToIntArray(tableNumbers), columnNumbers.ToArray(), formulaNumbers.ToArray());
		}
Пример #28
0
		private void CheckColumnDuplication()
		{
			IESI.HashedSet<string> cols = new IESI.HashedSet<string>();
			CheckColumnDuplication(cols, Key.ColumnIterator);
			if (IsIndexed)
			{
				CheckColumnDuplication(cols, ((IndexedCollection)this).Index.ColumnIterator);
			}
			if (IsIdentified)
			{
				CheckColumnDuplication(cols, ((IdentifierCollection)this).Identifier.ColumnIterator);
			}
			if (!IsOneToMany)
			{
				CheckColumnDuplication(cols, Element.ColumnIterator);
			}
		}
		internal StatefulPersistenceContext(SerializationInfo info, StreamingContext context)
		{
			loadCounter = 0;
			flushing = false;
			cascading = 0;
			entitiesByKey = (Dictionary<EntityKey, object>)info.GetValue("context.entitiesByKey", typeof(Dictionary<EntityKey, object>));
			entitiesByUniqueKey = (Dictionary<EntityUniqueKey, object>)info.GetValue("context.entitiesByUniqueKey", typeof(Dictionary<EntityUniqueKey, object>));
			entityEntries = (IdentityMap)info.GetValue("context.entityEntries", typeof(IdentityMap));
			proxiesByKey = (Dictionary<EntityKey, INHibernateProxy>)info.GetValue("context.proxiesByKey", typeof(Dictionary<EntityKey, INHibernateProxy>));
			entitySnapshotsByKey = (Dictionary<EntityKey, object>)info.GetValue("context.entitySnapshotsByKey", typeof(Dictionary<EntityKey, object>));
			arrayHolders = (IdentityMap)info.GetValue("context.arrayHolders", typeof(IdentityMap));
			collectionEntries = (IdentityMap)info.GetValue("context.collectionEntries", typeof(IdentityMap));
			collectionsByKey = (Dictionary<CollectionKey, IPersistentCollection>)info.GetValue("context.collectionsByKey", typeof(Dictionary<CollectionKey, IPersistentCollection>));
			nullifiableEntityKeys = (IESI.HashedSet<EntityKey>)info.GetValue("context.nullifiableEntityKeys", typeof(IESI.HashedSet<EntityKey>));
			unownedCollections = (Dictionary<CollectionKey, IPersistentCollection>)info.GetValue("context.unownedCollections", typeof(Dictionary<CollectionKey, IPersistentCollection>));
			hasNonReadOnlyEntities = info.GetBoolean("context.hasNonReadOnlyEntities");
			defaultReadOnly = info.GetBoolean("context.defaultReadOnly");
			InitTransientState();
		}
        public virtual IESI.ISet<string> GetReservedWords()
		{
			var result = new IESI.HashedSet<string>();
			DataTable dtReservedWords = connection.GetSchema(DbMetaDataCollectionNames.ReservedWords);
			foreach (DataRow row in dtReservedWords.Rows)
			{
				result.Add(row["ReservedWord"].ToString());
			}
			return result;
		}