/// <summary>Retrieves in the calling MembershipCollection object all MembershipEntity objects which have data in common with the specified related Entities. If one is omitted, that entity is not used as a filter. </summary>
 /// <param name="containingTransaction">A containing transaction, if caller is added to a transaction, or null if not.</param>
 /// <param name="collectionToFill">Collection to fill with the entity objects retrieved</param>
 /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query. When set to 0, no limitations are specified.</param>
 /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param>
 /// <param name="entityFactoryToUse">The EntityFactory to use when creating entity objects during a GetMulti() call.</param>
 /// <param name="filter">Extra filter to limit the resultset. Predicate expression can be null, in which case it will be ignored.</param>
 /// <param name="roleInstance">RoleEntity instance to use as a filter for the MembershipEntity objects to return</param>
 /// <param name="storeInformationInstance">StoreInformationEntity instance to use as a filter for the MembershipEntity objects to return</param>
 /// <param name="pageNumber">The page number to retrieve.</param>
 /// <param name="pageSize">The page size of the page to retrieve.</param>
 public bool GetMulti(ITransaction containingTransaction, IEntityCollection collectionToFill, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IEntityFactory entityFactoryToUse, IPredicateExpression filter, IEntity roleInstance, IEntity storeInformationInstance, int pageNumber, int pageSize)
 {
     this.EntityFactoryToUse = entityFactoryToUse;
     IEntityFields fieldsToReturn = EntityFieldsFactory.CreateEntityFieldsObject(ProductSearchEngine.EntityType.MembershipEntity);
     IPredicateExpression selectFilter = CreateFilterUsingForeignKeys(roleInstance, storeInformationInstance, fieldsToReturn);
     if(filter!=null)
     {
         selectFilter.AddWithAnd(filter);
     }
     return this.PerformGetMultiAction(containingTransaction, collectionToFill, maxNumberOfItemsToReturn, sortClauses, selectFilter, null, null, null, pageNumber, pageSize);
 }

 /// <summary>Retrieves in the calling ForumCollection object all ForumEntity objects which have data in common with the specified related Entities. If one is omitted, that entity is not used as a filter. </summary>
 /// <param name="containingTransaction">A containing transaction, if caller is added to a transaction, or null if not.</param>
 /// <param name="collectionToFill">Collection to fill with the entity objects retrieved</param>
 /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query. When set to 0, no limitations are specified.</param>
 /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param>
 /// <param name="entityFactoryToUse">The EntityFactory to use when creating entity objects during a GetMulti() call.</param>
 /// <param name="filter">Extra filter to limit the resultset. Predicate expression can be null, in which case it will be ignored.</param>
 /// <param name="sectionInstance">SectionEntity instance to use as a filter for the ForumEntity objects to return</param>
 /// <param name="defaultSupportQueueInstance">SupportQueueEntity instance to use as a filter for the ForumEntity objects to return</param>
 /// <param name="pageNumber">The page number to retrieve.</param>
 /// <param name="pageSize">The page size of the page to retrieve.</param>
 public bool GetMulti(ITransaction containingTransaction, IEntityCollection collectionToFill, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IEntityFactory entityFactoryToUse, IPredicateExpression filter, IEntity sectionInstance, IEntity defaultSupportQueueInstance, int pageNumber, int pageSize)
 {
     this.EntityFactoryToUse = entityFactoryToUse;
     IEntityFields fieldsToReturn = EntityFieldsFactory.CreateEntityFieldsObject(SD.HnD.DAL.EntityType.ForumEntity);
     IPredicateExpression selectFilter = CreateFilterUsingForeignKeys(sectionInstance, defaultSupportQueueInstance, fieldsToReturn);
     if(filter!=null)
     {
         selectFilter.AddWithAnd(filter);
     }
     return this.PerformGetMultiAction(containingTransaction, collectionToFill, maxNumberOfItemsToReturn, sortClauses, selectFilter, null, null, null, pageNumber, pageSize);
 }

 internal ColumnConstraint(string constraintTableName, string constraintColumnName, IPredicateExpression predicateExpression, PredicateExpressionOperator operatorToUse)
 {
     this.predicateExpression = predicateExpression;
     if (string.IsNullOrEmpty(constraintTableName))
         throw new QueryGenerationException("Cannot create a constraint without a table");
     if (string.IsNullOrEmpty(constraintColumnName))
         throw new QueryGenerationException("Cannot create a constraint without a column");
     this.ColumnName = constraintColumnName;
     this.TableName = constraintTableName;
     this.Parameters = new List<IDataParameter>();
     if (operatorToUse == PredicateExpressionOperator.And)
         predicateExpression.And(this);
     else
         predicateExpression.Or(this);
 }

        /// <summary>
        /// Returns predicate which returns single (on none) entity for given moment in time.
        /// Vraća predikat koji filtrira jedan entitet koji je validan za dani momentInTime.
        /// </summary>
        /// <param name="setFilter">Additional filter which applies before datetime predicate.</param>
        public static PredicateExpression FilterValidEntities(DateTime momentInTime,
            EntityField2 validDateTimeField,
            IPredicateExpression setFilter)
        {
            PredicateExpression newSetFilter;

            if (null != setFilter)
            {
                newSetFilter = new PredicateExpression(setFilter);
                newSetFilter.AddWithAnd(validDateTimeField <= momentInTime);
            }
            else
            {
                newSetFilter = new PredicateExpression(validDateTimeField <= momentInTime);
            }

            PredicateExpression toReturn = new PredicateExpression();
            toReturn.Add(validDateTimeField <= momentInTime);
            toReturn.Add(new FieldCompareSetPredicate(validDateTimeField, null, validDateTimeField, null, SetOperator.GreaterEqualAll, newSetFilter));

            return toReturn;
        }

 /// <summary> Retrieves all related entities of type 'AuctionEventDonorEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="entityFactoryToUse">The entity factory to use for the GetMultiManyToOne() routine.</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of the type constructed by the passed in entity factory</returns>
 public virtual Auction.Entities.CollectionClasses.AuctionEventDonorCollection GetMultiAuctionEventDonor(bool forceFetch, IEntityFactory entityFactoryToUse, IPredicateExpression filter)
 {
     if( ( !_alreadyFetchedAuctionEventDonor || forceFetch || _alwaysFetchAuctionEventDonor) && !base.IsSerializing && !base.IsDeserializing && !base.InDesignMode)
     {
         if(base.ParticipatesInTransaction)
         {
             if(!_auctionEventDonor.ParticipatesInTransaction)
             {
                 base.Transaction.Add(_auctionEventDonor);
             }
         }
         _auctionEventDonor.SuppressClearInGetMulti=!forceFetch;
         if(entityFactoryToUse!=null)
         {
             _auctionEventDonor.EntityFactoryToUse = entityFactoryToUse;
         }
         _auctionEventDonor.GetMultiManyToOne(null, this, filter);
         _auctionEventDonor.SuppressClearInGetMulti=false;
         _alreadyFetchedAuctionEventDonor = true;
     }
     return _auctionEventDonor;
 }

 /// <summary> Retrieves all related entities of type 'THistoryAlatEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="entityFactoryToUse">The entity factory to use for the GetMultiManyToOne() routine.</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of the type constructed by the passed in entity factory</returns>
 public virtual Kalibrasi.Data.CollectionClasses.THistoryAlatCollection GetMultiThistoryAlat(bool forceFetch, IEntityFactory entityFactoryToUse, IPredicateExpression filter)
 {
     if( ( !_alreadyFetchedThistoryAlat || forceFetch || _alwaysFetchThistoryAlat) && !base.IsSerializing && !base.IsDeserializing && !base.InDesignMode)
     {
         if(base.ParticipatesInTransaction)
         {
             if(!_thistoryAlat.ParticipatesInTransaction)
             {
                 base.Transaction.Add(_thistoryAlat);
             }
         }
         _thistoryAlat.SuppressClearInGetMulti=!forceFetch;
         if(entityFactoryToUse!=null)
         {
             _thistoryAlat.EntityFactoryToUse = entityFactoryToUse;
         }
         _thistoryAlat.GetMultiManyToOne(this, filter);
         _thistoryAlat.SuppressClearInGetMulti=false;
         _alreadyFetchedThistoryAlat = true;
     }
     return _thistoryAlat;
 }

 /// <summary> Retrieves all related entities of type 'ForumEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of type 'ForumEntity'</returns>
 public SD.HnD.DAL.CollectionClasses.ForumCollection GetMultiForums(bool forceFetch, IPredicateExpression filter)
 {
     return GetMultiForums(forceFetch, _forums.EntityFactoryToUse, filter);
 }

 /// <summary>
 /// Retrieves in the calling MUserCollection object all MUserEntity objects which have data in common
 /// with the specified related Entities. If one is omitted, that entity is not used as a filter. 
 /// </summary>
 /// <param name="containingTransaction">A containing transaction, if caller is added to a transaction, or null if not.</param>
 /// <param name="collectionToFill">Collection to fill with the entity objects retrieved</param>
 /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query. 
 /// If the used Dynamic Query Engine supports it, 'TOP' is used to limit the amount of rows to return. 
 /// When set to 0, no limitations are specified.</param>
 /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param>
 /// <param name="entityFactoryToUse">The EntityFactory to use when creating entity objects during a GetMulti() call.</param>
 /// <param name="filter">Extra filter to limit the resultset. Predicate expression can be null, in which case it will be ignored.</param>
 /// <param name="mhakAksesInstance">MHakAksesEntity instance to use as a filter for the MUserEntity objects to return</param>
 /// <param name="pageNumber">The page number to retrieve.</param>
 /// <param name="pageSize">The page size of the page to retrieve.</param>
 public bool GetMulti(ITransaction containingTransaction, IEntityCollection collectionToFill, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IEntityFactory entityFactoryToUse, IPredicateExpression filter, IEntity mhakAksesInstance, int pageNumber, int pageSize)
 {
     base.EntityFactoryToUse = entityFactoryToUse;
     IEntityFields fieldsToReturn = EntityFieldsFactory.CreateEntityFieldsObject(Kalibrasi.Data.EntityType.MUserEntity);
     IPredicateExpression selectFilter = CreateFilterUsingForeignKeys(mhakAksesInstance, fieldsToReturn);
     if(filter!=null)
     {
         selectFilter.AddWithAnd(filter);
     }
     return base.PerformGetMultiAction(containingTransaction, collectionToFill, maxNumberOfItemsToReturn, sortClauses, selectFilter, null, null, null, pageNumber, pageSize);
 }

 /// <summary> Retrieves all related entities of type 'MUserEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of type 'MUserEntity'</returns>
 public Kalibrasi.Data.CollectionClasses.MUserCollection GetMultiMuser(bool forceFetch, IPredicateExpression filter)
 {
     return GetMultiMuser(forceFetch, _muser.EntityFactoryToUse, filter);
 }

 /// <summary> Retrieves all related entities of type 'RuleEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of type 'RuleEntity'</returns>
 public policyDB.CollectionClasses.RuleCollection GetMultiRule(bool forceFetch, IPredicateExpression filter)
 {
     return GetMultiRule(forceFetch, _rule.EntityFactoryToUse, filter);
 }

 /// <summary> Retrieves all related entities of type 'CommentEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of type 'CommentEntity'</returns>
 public ProductSearchEngine.CollectionClasses.CommentCollection GetMultiComments(bool forceFetch, IPredicateExpression filter)
 {
     return GetMultiComments(forceFetch, _comments.EntityFactoryToUse, filter);
 }

 /// <summary> Retrieves all related entities of type 'PolicyEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of type 'PolicyEntity'</returns>
 public policyDB.CollectionClasses.PolicyCollection GetMultiPolicy(bool forceFetch, IPredicateExpression filter)
 {
     return GetMultiPolicy(forceFetch, _policy.EntityFactoryToUse, filter);
 }

 /// <summary> Retrieves all related entities of type 'PackageEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of type 'PackageEntity'</returns>
 public Auction.Entities.CollectionClasses.PackageCollection GetMultiPackage(bool forceFetch, IPredicateExpression filter)
 {
     return GetMultiPackage(forceFetch, _package.EntityFactoryToUse, filter);
 }

 /// <summary> Retrieves all related entities of type 'ProductPhotoEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of type 'ProductPhotoEntity'</returns>
 public ProductSearchEngine.CollectionClasses.ProductPhotoCollection GetMultiProductPhotos(bool forceFetch, IPredicateExpression filter)
 {
     return GetMultiProductPhotos(forceFetch, _productPhotos.EntityFactoryToUse, filter);
 }

 /// <summary>
 /// Retrieves in the calling PackageCollection object all PackageEntity objects which have data in common
 /// with the specified related Entities. If one is omitted, that entity is not used as a filter. 
 /// </summary>
 /// <param name="containingTransaction">A containing transaction, if caller is added to a transaction, or null if not.</param>
 /// <param name="collectionToFill">Collection to fill with the entity objects retrieved</param>
 /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query. 
 /// If the used Dynamic Query Engine supports it, 'TOP' is used to limit the amount of rows to return. 
 /// When set to 0, no limitations are specified.</param>
 /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param>
 /// <param name="entityFactoryToUse">The EntityFactory to use when creating entity objects during a GetMulti() call.</param>
 /// <param name="filter">Extra filter to limit the resultset. Predicate expression can be null, in which case it will be ignored.</param>
 /// <param name="auctionEventInstance">AuctionEventEntity instance to use as a filter for the PackageEntity objects to return</param>
 /// <param name="bidderInstance">BidderEntity instance to use as a filter for the PackageEntity objects to return</param>
 /// <param name="categoryInstance">CategoryEntity instance to use as a filter for the PackageEntity objects to return</param>
 /// <param name="user__Instance">UserEntity instance to use as a filter for the PackageEntity objects to return</param>
 /// <param name="user_Instance">UserEntity instance to use as a filter for the PackageEntity objects to return</param>
 /// <param name="userInstance">UserEntity instance to use as a filter for the PackageEntity objects to return</param>
 /// <param name="pageNumber">The page number to retrieve.</param>
 /// <param name="pageSize">The page size of the page to retrieve.</param>
 public bool GetMulti(ITransaction containingTransaction, IEntityCollection collectionToFill, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IEntityFactory entityFactoryToUse, IPredicateExpression filter, IEntity auctionEventInstance, IEntity bidderInstance, IEntity categoryInstance, IEntity user__Instance, IEntity user_Instance, IEntity userInstance, int pageNumber, int pageSize)
 {
     base.EntityFactoryToUse = entityFactoryToUse;
     IEntityFields fieldsToReturn = EntityFieldsFactory.CreateEntityFieldsObject(Auction.Entities.EntityType.PackageEntity);
     IPredicateExpression selectFilter = CreateFilterUsingForeignKeys(auctionEventInstance, bidderInstance, categoryInstance, user__Instance, user_Instance, userInstance, fieldsToReturn);
     if(filter!=null)
     {
         selectFilter.AddWithAnd(filter);
     }
     return base.PerformGetMultiAction(containingTransaction, collectionToFill, maxNumberOfItemsToReturn, sortClauses, selectFilter, null, null, null, pageNumber, pageSize);
 }

 /// <summary> Retrieves all related entities of type 'MLokasiEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of type 'MLokasiEntity'</returns>
 public Kalibrasi.Data.CollectionClasses.MLokasiCollection GetMultiMlokasi(bool forceFetch, IPredicateExpression filter)
 {
     return GetMultiMlokasi(forceFetch, _mlokasi.EntityFactoryToUse, filter);
 }

 /// <summary> Retrieves all related entities of type 'MDepartementEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of type 'MDepartementEntity'</returns>
 public Kalibrasi.Data.CollectionClasses.MDepartementCollection GetMultiMdepartement(bool forceFetch, IPredicateExpression filter)
 {
     return GetMultiMdepartement(forceFetch, _mdepartement.EntityFactoryToUse, filter);
 }

 /// <summary> Retrieves all related entities of type 'DonationEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of type 'DonationEntity'</returns>
 public Auction.Entities.CollectionClasses.DonationCollection GetMultiDonation(bool forceFetch, IPredicateExpression filter)
 {
     return GetMultiDonation(forceFetch, _donation.EntityFactoryToUse, filter);
 }

 /// <summary> Retrieves all related entities of type 'UserEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="entityFactoryToUse">The entity factory to use for the GetMultiManyToOne() routine.</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of the type constructed by the passed in entity factory</returns>
 public virtual Auction.Entities.CollectionClasses.UserCollection GetMultiUser___(bool forceFetch, IEntityFactory entityFactoryToUse, IPredicateExpression filter)
 {
     if( ( !_alreadyFetchedUser___ || forceFetch || _alwaysFetchUser___) && !base.IsSerializing && !base.IsDeserializing && !base.InDesignMode)
     {
         if(base.ParticipatesInTransaction)
         {
             if(!_user___.ParticipatesInTransaction)
             {
                 base.Transaction.Add(_user___);
             }
         }
         _user___.SuppressClearInGetMulti=!forceFetch;
         if(entityFactoryToUse!=null)
         {
             _user___.EntityFactoryToUse = entityFactoryToUse;
         }
         _user___.GetMultiManyToOne(null, null, null, this, filter);
         _user___.SuppressClearInGetMulti=false;
         _alreadyFetchedUser___ = true;
     }
     return _user___;
 }

 /// <summary> Retrieves all related entities of type 'RoleSystemActionRightEntity' using a relation of type '1:n'.</summary>
 /// <param name="forceFetch">if true, it will discard any changes currently in the collection and will rerun the complete query instead</param>
 /// <param name="filter">Extra filter to limit the resultset.</param>
 /// <returns>Filled collection with all related entities of type 'RoleSystemActionRightEntity'</returns>
 public SD.HnD.DAL.CollectionClasses.RoleSystemActionRightCollection GetMultiRoleSystemActionRights(bool forceFetch, IPredicateExpression filter)
 {
     return GetMultiRoleSystemActionRights(forceFetch, _roleSystemActionRights.EntityFactoryToUse, filter);
 }