Upload to server

uploading

patientman/Datalib/DatabaseGeneric/FactoryClasses/EntityFactories.cs

@@ -0,0 +1,811 @@
+///////////////////////////////////////////////////////////////
+// This is generated code. 
+//////////////////////////////////////////////////////////////
+// Code is generated using LLBLGen Pro version: 4.2
+// Code is generated on: 
+// Code is generated using templates: SD.TemplateBindings.SharedTemplates
+// Templates vendor: Solutions Design.
+// Templates version: 
+//////////////////////////////////////////////////////////////
+using System;
+using System.Collections.Generic;
+using Datalib.EntityClasses;
+using Datalib.HelperClasses;
+using Datalib.RelationClasses;
+using SD.LLBLGen.Pro.ORMSupportClasses;
+
+namespace Datalib.FactoryClasses
+{
+	
+	// __LLBLGENPRO_USER_CODE_REGION_START AdditionalNamespaces
+	// __LLBLGENPRO_USER_CODE_REGION_END
+	
+	
+	/// <summary>general base class for the generated factories</summary>
+	[Serializable]
+	public partial class EntityFactoryBase2<TEntity> : EntityFactoryCore2
+		where TEntity : EntityBase2, IEntity2
+	{
+		private readonly Datalib.EntityType _typeOfEntity;
+		private readonly bool _isInHierarchy;
+		
+		/// <summary>CTor</summary>
+		/// <param name="entityName">Name of the entity.</param>
+		/// <param name="typeOfEntity">The type of entity.</param>
+		/// <param name="isInHierarchy">If true, the entity of this factory is in an inheritance hierarchy, false otherwise</param>
+		public EntityFactoryBase2(string entityName, Datalib.EntityType typeOfEntity, bool isInHierarchy) : base(entityName)
+		{
+			_typeOfEntity = typeOfEntity;
+			_isInHierarchy = isInHierarchy;
+		}
+		
+		/// <summary>Creates, using the generated EntityFieldsFactory, the IEntityFields2 object for the entity to create.</summary>
+		/// <returns>Empty IEntityFields2 object.</returns>
+		public override IEntityFields2 CreateFields()
+		{
+			return EntityFieldsFactory.CreateEntityFieldsObject(_typeOfEntity);
+		}
+		
+		/// <summary>Creates a new entity instance using the GeneralEntityFactory in the generated code, using the passed in entitytype value</summary>
+		/// <param name="entityTypeValue">The entity type value of the entity to create an instance for.</param>
+		/// <returns>new IEntity instance</returns>
+		public override IEntity2 CreateEntityFromEntityTypeValue(int entityTypeValue)
+		{
+			return GeneralEntityFactory.Create((Datalib.EntityType)entityTypeValue);
+		}
+
+		/// <summary>Creates the relations collection to the entity to join all targets so this entity can be fetched. </summary>
+		/// <param name="objectAlias">The object alias to use for the elements in the relations.</param>
+		/// <returns>null if the entity isn't in a hierarchy of type TargetPerEntity, otherwise the relations collection needed to join all targets together to fetch all subtypes of this entity and this entity itself</returns>
+		public override IRelationCollection CreateHierarchyRelations(string objectAlias) 
+		{
+			return InheritanceInfoProviderSingleton.GetInstance().GetHierarchyRelations(this.ForEntityName, objectAlias);
+		}
+
+		/// <summary>This method retrieves, using the InheritanceInfoprovider, the factory for the entity represented by the values passed in.</summary>
+		/// <param name="fieldValues">Field values read from the db, to determine which factory to return, based on the field values passed in.</param>
+		/// <param name="entityFieldStartIndexesPerEntity">indexes into values where per entity type their own fields start.</param>
+		/// <returns>the factory for the entity which is represented by the values passed in.</returns>
+		public override IEntityFactory2 GetEntityFactory(object[] fieldValues, Dictionary<string, int> entityFieldStartIndexesPerEntity) 
+		{
+			IEntityFactory2 toReturn = (IEntityFactory2)InheritanceInfoProviderSingleton.GetInstance().GetEntityFactory(this.ForEntityName, fieldValues, entityFieldStartIndexesPerEntity);
+			if(toReturn == null)
+			{
+				toReturn = this;
+			}
+			return toReturn;
+		}
+		
+		/// <summary>Gets a predicateexpression which filters on the entity with type belonging to this factory.</summary>
+		/// <param name="negate">Flag to produce a NOT filter, (true), or a normal filter (false). </param>
+		/// <param name="objectAlias">The object alias to use for the predicate(s).</param>
+		/// <returns>ready to use predicateexpression, or an empty predicate expression if the belonging entity isn't a hierarchical type.</returns>
+		public override IPredicateExpression GetEntityTypeFilter(bool negate, string objectAlias) 
+		{
+			return InheritanceInfoProviderSingleton.GetInstance().GetEntityTypeFilter(this.ForEntityName, objectAlias, negate);
+		}
+						
+		/// <summary>Creates a new generic EntityCollection(Of T) for the entity which this factory belongs to.</summary>
+		/// <returns>ready to use generic EntityCollection(Of T) with this factory set as the factory</returns>
+		public override IEntityCollection2 CreateEntityCollection()
+		{
+			return new EntityCollection<TEntity>(this);
+		}
+		
+		/// <summary>Creates the hierarchy fields for the entity to which this factory belongs.</summary>
+		/// <returns>IEntityFields2 object with the fields of all the entities in teh hierarchy of this entity or the fields of this entity if the entity isn't in a hierarchy.</returns>
+		public override IEntityFields2 CreateHierarchyFields() 
+		{
+			return _isInHierarchy ? new EntityFields2(InheritanceInfoProviderSingleton.GetInstance().GetHierarchyFields(this.ForEntityName), InheritanceInfoProviderSingleton.GetInstance(), null) : base.CreateHierarchyFields();
+		}
+	}
+
+	/// <summary>Factory to create new, empty TblAgeGroupEntity objects.</summary>
+	[Serializable]
+	public partial class TblAgeGroupEntityFactory : EntityFactoryBase2<TblAgeGroupEntity> {
+		/// <summary>CTor</summary>
+		public TblAgeGroupEntityFactory() : base("TblAgeGroupEntity", Datalib.EntityType.TblAgeGroupEntity, false) { }
+		
+		/// <summary>Creates a new TblAgeGroupEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblAgeGroupEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblAgeGroupUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblAgencyEntity objects.</summary>
+	[Serializable]
+	public partial class TblAgencyEntityFactory : EntityFactoryBase2<TblAgencyEntity> {
+		/// <summary>CTor</summary>
+		public TblAgencyEntityFactory() : base("TblAgencyEntity", Datalib.EntityType.TblAgencyEntity, false) { }
+		
+		/// <summary>Creates a new TblAgencyEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblAgencyEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblAgencyUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblChildEntity objects.</summary>
+	[Serializable]
+	public partial class TblChildEntityFactory : EntityFactoryBase2<TblChildEntity> {
+		/// <summary>CTor</summary>
+		public TblChildEntityFactory() : base("TblChildEntity", Datalib.EntityType.TblChildEntity, false) { }
+		
+		/// <summary>Creates a new TblChildEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblChildEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblChildUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblClinicInfoEntity objects.</summary>
+	[Serializable]
+	public partial class TblClinicInfoEntityFactory : EntityFactoryBase2<TblClinicInfoEntity> {
+		/// <summary>CTor</summary>
+		public TblClinicInfoEntityFactory() : base("TblClinicInfoEntity", Datalib.EntityType.TblClinicInfoEntity, false) { }
+		
+		/// <summary>Creates a new TblClinicInfoEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblClinicInfoEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblClinicInfoUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblCommuneEntity objects.</summary>
+	[Serializable]
+	public partial class TblCommuneEntityFactory : EntityFactoryBase2<TblCommuneEntity> {
+		/// <summary>CTor</summary>
+		public TblCommuneEntityFactory() : base("TblCommuneEntity", Datalib.EntityType.TblCommuneEntity, false) { }
+		
+		/// <summary>Creates a new TblCommuneEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblCommuneEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblCommuneUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblDiaryEntity objects.</summary>
+	[Serializable]
+	public partial class TblDiaryEntityFactory : EntityFactoryBase2<TblDiaryEntity> {
+		/// <summary>CTor</summary>
+		public TblDiaryEntityFactory() : base("TblDiaryEntity", Datalib.EntityType.TblDiaryEntity, false) { }
+		
+		/// <summary>Creates a new TblDiaryEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblDiaryEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblDiaryUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblDistrictEntity objects.</summary>
+	[Serializable]
+	public partial class TblDistrictEntityFactory : EntityFactoryBase2<TblDistrictEntity> {
+		/// <summary>CTor</summary>
+		public TblDistrictEntityFactory() : base("TblDistrictEntity", Datalib.EntityType.TblDistrictEntity, false) { }
+		
+		/// <summary>Creates a new TblDistrictEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblDistrictEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblDistrictUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblExaminationInfoEntity objects.</summary>
+	[Serializable]
+	public partial class TblExaminationInfoEntityFactory : EntityFactoryBase2<TblExaminationInfoEntity> {
+		/// <summary>CTor</summary>
+		public TblExaminationInfoEntityFactory() : base("TblExaminationInfoEntity", Datalib.EntityType.TblExaminationInfoEntity, false) { }
+		
+		/// <summary>Creates a new TblExaminationInfoEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblExaminationInfoEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblExaminationInfoUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblPatientEntity objects.</summary>
+	[Serializable]
+	public partial class TblPatientEntityFactory : EntityFactoryBase2<TblPatientEntity> {
+		/// <summary>CTor</summary>
+		public TblPatientEntityFactory() : base("TblPatientEntity", Datalib.EntityType.TblPatientEntity, false) { }
+		
+		/// <summary>Creates a new TblPatientEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblPatientEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblPatientUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblPreClinicsInfoEntity objects.</summary>
+	[Serializable]
+	public partial class TblPreClinicsInfoEntityFactory : EntityFactoryBase2<TblPreClinicsInfoEntity> {
+		/// <summary>CTor</summary>
+		public TblPreClinicsInfoEntityFactory() : base("TblPreClinicsInfoEntity", Datalib.EntityType.TblPreClinicsInfoEntity, false) { }
+		
+		/// <summary>Creates a new TblPreClinicsInfoEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblPreClinicsInfoEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblPreClinicsInfoUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblPregnanceInfoEntity objects.</summary>
+	[Serializable]
+	public partial class TblPregnanceInfoEntityFactory : EntityFactoryBase2<TblPregnanceInfoEntity> {
+		/// <summary>CTor</summary>
+		public TblPregnanceInfoEntityFactory() : base("TblPregnanceInfoEntity", Datalib.EntityType.TblPregnanceInfoEntity, false) { }
+		
+		/// <summary>Creates a new TblPregnanceInfoEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblPregnanceInfoEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblPregnanceInfoUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblProvinceEntity objects.</summary>
+	[Serializable]
+	public partial class TblProvinceEntityFactory : EntityFactoryBase2<TblProvinceEntity> {
+		/// <summary>CTor</summary>
+		public TblProvinceEntityFactory() : base("TblProvinceEntity", Datalib.EntityType.TblProvinceEntity, false) { }
+		
+		/// <summary>Creates a new TblProvinceEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblProvinceEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblProvinceUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblReferralFromPlaceEntity objects.</summary>
+	[Serializable]
+	public partial class TblReferralFromPlaceEntityFactory : EntityFactoryBase2<TblReferralFromPlaceEntity> {
+		/// <summary>CTor</summary>
+		public TblReferralFromPlaceEntityFactory() : base("TblReferralFromPlaceEntity", Datalib.EntityType.TblReferralFromPlaceEntity, false) { }
+		
+		/// <summary>Creates a new TblReferralFromPlaceEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblReferralFromPlaceEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblReferralFromPlaceUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblReferralsToEntity objects.</summary>
+	[Serializable]
+	public partial class TblReferralsToEntityFactory : EntityFactoryBase2<TblReferralsToEntity> {
+		/// <summary>CTor</summary>
+		public TblReferralsToEntityFactory() : base("TblReferralsToEntity", Datalib.EntityType.TblReferralsToEntity, false) { }
+		
+		/// <summary>Creates a new TblReferralsToEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblReferralsToEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblReferralsToUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblReferraltoServiceEntity objects.</summary>
+	[Serializable]
+	public partial class TblReferraltoServiceEntityFactory : EntityFactoryBase2<TblReferraltoServiceEntity> {
+		/// <summary>CTor</summary>
+		public TblReferraltoServiceEntityFactory() : base("TblReferraltoServiceEntity", Datalib.EntityType.TblReferraltoServiceEntity, false) { }
+		
+		/// <summary>Creates a new TblReferraltoServiceEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblReferraltoServiceEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblReferraltoServiceUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblRegimenEntity objects.</summary>
+	[Serializable]
+	public partial class TblRegimenEntityFactory : EntityFactoryBase2<TblRegimenEntity> {
+		/// <summary>CTor</summary>
+		public TblRegimenEntityFactory() : base("TblRegimenEntity", Datalib.EntityType.TblRegimenEntity, false) { }
+		
+		/// <summary>Creates a new TblRegimenEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblRegimenEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblRegimenUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblRegimenStopReasonEntity objects.</summary>
+	[Serializable]
+	public partial class TblRegimenStopReasonEntityFactory : EntityFactoryBase2<TblRegimenStopReasonEntity> {
+		/// <summary>CTor</summary>
+		public TblRegimenStopReasonEntityFactory() : base("TblRegimenStopReasonEntity", Datalib.EntityType.TblRegimenStopReasonEntity, false) { }
+		
+		/// <summary>Creates a new TblRegimenStopReasonEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblRegimenStopReasonEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblRegimenStopReasonUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblServiceEntity objects.</summary>
+	[Serializable]
+	public partial class TblServiceEntityFactory : EntityFactoryBase2<TblServiceEntity> {
+		/// <summary>CTor</summary>
+		public TblServiceEntityFactory() : base("TblServiceEntity", Datalib.EntityType.TblServiceEntity, false) { }
+		
+		/// <summary>Creates a new TblServiceEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblServiceEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblServiceUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblTestEntity objects.</summary>
+	[Serializable]
+	public partial class TblTestEntityFactory : EntityFactoryBase2<TblTestEntity> {
+		/// <summary>CTor</summary>
+		public TblTestEntityFactory() : base("TblTestEntity", Datalib.EntityType.TblTestEntity, false) { }
+		
+		/// <summary>Creates a new TblTestEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblTestEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblTestUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblTreatmentEntity objects.</summary>
+	[Serializable]
+	public partial class TblTreatmentEntityFactory : EntityFactoryBase2<TblTreatmentEntity> {
+		/// <summary>CTor</summary>
+		public TblTreatmentEntityFactory() : base("TblTreatmentEntity", Datalib.EntityType.TblTreatmentEntity, false) { }
+		
+		/// <summary>Creates a new TblTreatmentEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblTreatmentEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblTreatmentUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblTreatmentInfoEntity objects.</summary>
+	[Serializable]
+	public partial class TblTreatmentInfoEntityFactory : EntityFactoryBase2<TblTreatmentInfoEntity> {
+		/// <summary>CTor</summary>
+		public TblTreatmentInfoEntityFactory() : base("TblTreatmentInfoEntity", Datalib.EntityType.TblTreatmentInfoEntity, false) { }
+		
+		/// <summary>Creates a new TblTreatmentInfoEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblTreatmentInfoEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblTreatmentInfoUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty TblWaitingListEntity objects.</summary>
+	[Serializable]
+	public partial class TblWaitingListEntityFactory : EntityFactoryBase2<TblWaitingListEntity> {
+		/// <summary>CTor</summary>
+		public TblWaitingListEntityFactory() : base("TblWaitingListEntity", Datalib.EntityType.TblWaitingListEntity, false) { }
+		
+		/// <summary>Creates a new TblWaitingListEntity instance but uses a special constructor which will set the Fields object of the new IEntity2 instance to the passed in fields object.</summary>
+		/// <param name="fields">Populated IEntityFields2 object for the new IEntity2 to create</param>
+		/// <returns>Fully created and populated (due to the IEntityFields2 object) IEntity2 object</returns>
+		public override IEntity2 Create(IEntityFields2 fields) {
+			IEntity2 toReturn = new TblWaitingListEntity(fields);
+			// __LLBLGENPRO_USER_CODE_REGION_START CreateNewTblWaitingListUsingFields
+			// __LLBLGENPRO_USER_CODE_REGION_END
+			
+			return toReturn;
+		}
+		#region Included Code
+
+		#endregion
+	}
+
+	/// <summary>Factory to create new, empty Entity objects based on the entity type specified. Uses  entity specific factory objects</summary>
+	[Serializable]
+	public partial class GeneralEntityFactory
+	{
+		/// <summary>Creates a new, empty Entity object of the type specified</summary>
+		/// <param name="entityTypeToCreate">The entity type to create.</param>
+		/// <returns>A new, empty Entity object.</returns>
+		public static IEntity2 Create(Datalib.EntityType entityTypeToCreate)
+		{
+			IEntityFactory2 factoryToUse = null;
+			switch(entityTypeToCreate)
+			{
+				case Datalib.EntityType.TblAgeGroupEntity:
+					factoryToUse = new TblAgeGroupEntityFactory();
+					break;
+				case Datalib.EntityType.TblAgencyEntity:
+					factoryToUse = new TblAgencyEntityFactory();
+					break;
+				case Datalib.EntityType.TblChildEntity:
+					factoryToUse = new TblChildEntityFactory();
+					break;
+				case Datalib.EntityType.TblClinicInfoEntity:
+					factoryToUse = new TblClinicInfoEntityFactory();
+					break;
+				case Datalib.EntityType.TblCommuneEntity:
+					factoryToUse = new TblCommuneEntityFactory();
+					break;
+				case Datalib.EntityType.TblDiaryEntity:
+					factoryToUse = new TblDiaryEntityFactory();
+					break;
+				case Datalib.EntityType.TblDistrictEntity:
+					factoryToUse = new TblDistrictEntityFactory();
+					break;
+				case Datalib.EntityType.TblExaminationInfoEntity:
+					factoryToUse = new TblExaminationInfoEntityFactory();
+					break;
+				case Datalib.EntityType.TblPatientEntity:
+					factoryToUse = new TblPatientEntityFactory();
+					break;
+				case Datalib.EntityType.TblPreClinicsInfoEntity:
+					factoryToUse = new TblPreClinicsInfoEntityFactory();
+					break;
+				case Datalib.EntityType.TblPregnanceInfoEntity:
+					factoryToUse = new TblPregnanceInfoEntityFactory();
+					break;
+				case Datalib.EntityType.TblProvinceEntity:
+					factoryToUse = new TblProvinceEntityFactory();
+					break;
+				case Datalib.EntityType.TblReferralFromPlaceEntity:
+					factoryToUse = new TblReferralFromPlaceEntityFactory();
+					break;
+				case Datalib.EntityType.TblReferralsToEntity:
+					factoryToUse = new TblReferralsToEntityFactory();
+					break;
+				case Datalib.EntityType.TblReferraltoServiceEntity:
+					factoryToUse = new TblReferraltoServiceEntityFactory();
+					break;
+				case Datalib.EntityType.TblRegimenEntity:
+					factoryToUse = new TblRegimenEntityFactory();
+					break;
+				case Datalib.EntityType.TblRegimenStopReasonEntity:
+					factoryToUse = new TblRegimenStopReasonEntityFactory();
+					break;
+				case Datalib.EntityType.TblServiceEntity:
+					factoryToUse = new TblServiceEntityFactory();
+					break;
+				case Datalib.EntityType.TblTestEntity:
+					factoryToUse = new TblTestEntityFactory();
+					break;
+				case Datalib.EntityType.TblTreatmentEntity:
+					factoryToUse = new TblTreatmentEntityFactory();
+					break;
+				case Datalib.EntityType.TblTreatmentInfoEntity:
+					factoryToUse = new TblTreatmentInfoEntityFactory();
+					break;
+				case Datalib.EntityType.TblWaitingListEntity:
+					factoryToUse = new TblWaitingListEntityFactory();
+					break;
+			}
+			IEntity2 toReturn = null;
+			if(factoryToUse != null)
+			{
+				toReturn = factoryToUse.Create();
+			}
+			return toReturn;
+		}		
+	}
+		
+	/// <summary>Class which is used to obtain the entity factory based on the .NET type of the entity. </summary>
+	[Serializable]
+	public static class EntityFactoryFactory
+	{
+		private static Dictionary<Type, IEntityFactory2> _factoryPerType = new Dictionary<Type, IEntityFactory2>();
+
+		/// <summary>Initializes the <see cref="EntityFactoryFactory"/> class.</summary>
+		static EntityFactoryFactory()
+		{
+			Array entityTypeValues = Enum.GetValues(typeof(Datalib.EntityType));
+			foreach(int entityTypeValue in entityTypeValues)
+			{
+				IEntity2 dummy = GeneralEntityFactory.Create((Datalib.EntityType)entityTypeValue);
+				_factoryPerType.Add(dummy.GetType(), dummy.GetEntityFactory());
+			}
+		}
+
+		/// <summary>Gets the factory of the entity with the .NET type specified</summary>
+		/// <param name="typeOfEntity">The type of entity.</param>
+		/// <returns>factory to use or null if not found</returns>
+		public static IEntityFactory2 GetFactory(Type typeOfEntity)
+		{
+			IEntityFactory2 toReturn = null;
+			_factoryPerType.TryGetValue(typeOfEntity, out toReturn);
+			return toReturn;
+		}
+
+		/// <summary>Gets the factory of the entity with the Datalib.EntityType specified</summary>
+		/// <param name="typeOfEntity">The type of entity.</param>
+		/// <returns>factory to use or null if not found</returns>
+		public static IEntityFactory2 GetFactory(Datalib.EntityType typeOfEntity)
+		{
+			return GetFactory(GeneralEntityFactory.Create(typeOfEntity).GetType());
+		}
+	}
+		
+	/// <summary>Element creator for creating project elements from somewhere else, like inside Linq providers.</summary>
+	public class ElementCreator : ElementCreatorBase, IElementCreator2
+	{
+		/// <summary>Gets the factory of the Entity type with the Datalib.EntityType value passed in</summary>
+		/// <param name="entityTypeValue">The entity type value.</param>
+		/// <returns>the entity factory of the entity type or null if not found</returns>
+		public IEntityFactory2 GetFactory(int entityTypeValue)
+		{
+			return (IEntityFactory2)this.GetFactoryImpl(entityTypeValue);
+		}
+		
+		/// <summary>Gets the factory of the Entity type with the .NET type passed in</summary>
+		/// <param name="typeOfEntity">The type of entity.</param>
+		/// <returns>the entity factory of the entity type or null if not found</returns>
+		public IEntityFactory2 GetFactory(Type typeOfEntity)
+		{
+			return (IEntityFactory2)this.GetFactoryImpl(typeOfEntity);
+		}
+
+		/// <summary>Creates a new resultset fields object with the number of field slots reserved as specified</summary>
+		/// <param name="numberOfFields">The number of fields.</param>
+		/// <returns>ready to use resultsetfields object</returns>
+		public IEntityFields2 CreateResultsetFields(int numberOfFields)
+		{
+			return new ResultsetFields(numberOfFields);
+		}
+		
+		/// <summary>Obtains the inheritance info provider instance from the singleton </summary>
+		/// <returns>The singleton instance of the inheritance info provider</returns>
+		public override IInheritanceInfoProvider ObtainInheritanceInfoProviderInstance()
+		{
+			return InheritanceInfoProviderSingleton.GetInstance();
+		}
+
+
+		/// <summary>Creates a new dynamic relation instance</summary>
+		/// <param name="leftOperand">The left operand.</param>
+		/// <returns>ready to use dynamic relation</returns>
+		public override IDynamicRelation CreateDynamicRelation(DerivedTableDefinition leftOperand)
+		{
+			return new DynamicRelation(leftOperand);
+		}
+
+		/// <summary>Creates a new dynamic relation instance</summary>
+		/// <param name="leftOperand">The left operand.</param>
+		/// <param name="joinType">Type of the join. If None is specified, Inner is assumed.</param>
+		/// <param name="rightOperand">The right operand.</param>
+		/// <param name="onClause">The on clause for the join.</param>
+		/// <returns>ready to use dynamic relation</returns>
+		public override IDynamicRelation CreateDynamicRelation(DerivedTableDefinition leftOperand, JoinHint joinType, DerivedTableDefinition rightOperand, IPredicate onClause)
+		{
+			return new DynamicRelation(leftOperand, joinType, rightOperand, onClause);
+		}
+
+		/// <summary>Creates a new dynamic relation instance</summary>
+		/// <param name="leftOperand">The left operand.</param>
+		/// <param name="joinType">Type of the join. If None is specified, Inner is assumed.</param>
+		/// <param name="rightOperand">The right operand.</param>
+		/// <param name="aliasLeftOperand">The alias of the left operand. If you don't want to / need to alias the right operand (only alias if you have to), specify string.Empty.</param>
+		/// <param name="onClause">The on clause for the join.</param>
+		/// <returns>ready to use dynamic relation</returns>
+		public override IDynamicRelation CreateDynamicRelation(IEntityFieldCore leftOperand, JoinHint joinType, DerivedTableDefinition rightOperand, string aliasLeftOperand, IPredicate onClause)
+		{
+			return new DynamicRelation(leftOperand, joinType, rightOperand, aliasLeftOperand, onClause);
+		}
+
+
+		/// <summary>Creates a new dynamic relation instance</summary>
+		/// <param name="leftOperand">The left operand.</param>
+		/// <param name="joinType">Type of the join. If None is specified, Inner is assumed.</param>
+		/// <param name="rightOperandEntityName">Name of the entity, which is used as the right operand.</param>
+		/// <param name="aliasRightOperand">The alias of the right operand. If you don't want to / need to alias the right operand (only alias if you have to), specify string.Empty.</param>
+		/// <param name="onClause">The on clause for the join.</param>
+		/// <returns>ready to use dynamic relation</returns>
+		public override IDynamicRelation CreateDynamicRelation(DerivedTableDefinition leftOperand, JoinHint joinType, string rightOperandEntityName, string aliasRightOperand, IPredicate onClause)
+		{
+			return new DynamicRelation(leftOperand, joinType, (Datalib.EntityType)Enum.Parse(typeof(Datalib.EntityType), rightOperandEntityName, false), aliasRightOperand, onClause);
+		}
+
+		/// <summary>Creates a new dynamic relation instance</summary>
+		/// <param name="leftOperandEntityName">Name of the entity which is used as the left operand.</param>
+		/// <param name="joinType">Type of the join. If None is specified, Inner is assumed.</param>
+		/// <param name="rightOperandEntityName">Name of the entity, which is used as the right operand.</param>
+		/// <param name="aliasLeftOperand">The alias of the left operand. If you don't want to / need to alias the right operand (only alias if you have to), specify string.Empty.</param>
+		/// <param name="aliasRightOperand">The alias of the right operand. If you don't want to / need to alias the right operand (only alias if you have to), specify string.Empty.</param>
+		/// <param name="onClause">The on clause for the join.</param>
+		/// <returns>ready to use dynamic relation</returns>
+		public override IDynamicRelation CreateDynamicRelation(string leftOperandEntityName, JoinHint joinType, string rightOperandEntityName, string aliasLeftOperand, string aliasRightOperand, IPredicate onClause)
+		{
+			return new DynamicRelation((Datalib.EntityType)Enum.Parse(typeof(Datalib.EntityType), leftOperandEntityName, false), joinType, (Datalib.EntityType)Enum.Parse(typeof(Datalib.EntityType), rightOperandEntityName, false), aliasLeftOperand, aliasRightOperand, onClause);
+		}
+		
+		/// <summary>Creates a new dynamic relation instance</summary>
+		/// <param name="leftOperand">The left operand.</param>
+		/// <param name="joinType">Type of the join. If None is specified, Inner is assumed.</param>
+		/// <param name="rightOperandEntityName">Name of the entity, which is used as the right operand.</param>
+		/// <param name="aliasLeftOperand">The alias of the left operand. If you don't want to / need to alias the right operand (only alias if you have to), specify string.Empty.</param>
+		/// <param name="aliasRightOperand">The alias of the right operand. If you don't want to / need to alias the right operand (only alias if you have to), specify string.Empty.</param>
+		/// <param name="onClause">The on clause for the join.</param>
+		/// <returns>ready to use dynamic relation</returns>
+		public override IDynamicRelation CreateDynamicRelation(IEntityFieldCore leftOperand, JoinHint joinType, string rightOperandEntityName, string aliasLeftOperand, string aliasRightOperand, IPredicate onClause)
+		{
+			return new DynamicRelation(leftOperand, joinType, (Datalib.EntityType)Enum.Parse(typeof(Datalib.EntityType), rightOperandEntityName, false), aliasLeftOperand, aliasRightOperand, onClause);
+		}
+		
+		/// <summary>Implementation of the routine which gets the factory of the Entity type with the Datalib.EntityType value passed in</summary>
+		/// <param name="entityTypeValue">The entity type value.</param>
+		/// <returns>the entity factory of the entity type or null if not found</returns>
+		protected override IEntityFactoryCore GetFactoryImpl(int entityTypeValue)
+		{
+			return EntityFactoryFactory.GetFactory((Datalib.EntityType)entityTypeValue);
+		}
+
+		/// <summary>Implementation of the routine which gets the factory of the Entity type with the .NET type passed in</summary>
+		/// <param name="typeOfEntity">The type of entity.</param>
+		/// <returns>the entity factory of the entity type or null if not found</returns>
+		protected override IEntityFactoryCore GetFactoryImpl(Type typeOfEntity)
+		{
+			return EntityFactoryFactory.GetFactory(typeOfEntity);
+		}
+
+	}
+}

patientman/Datalib/DatabaseGeneric/FactoryClasses/EntityFieldFactory.cs

@@ -0,0 +1,42 @@
+///////////////////////////////////////////////////////////////
+// This is generated code. 
+//////////////////////////////////////////////////////////////
+// Code is generated using LLBLGen Pro version: 4.2
+// Code is generated on: 
+// Code is generated using templates: SD.TemplateBindings.SharedTemplates
+// Templates vendor: Solutions Design.
+// Templates version: 
+//////////////////////////////////////////////////////////////
+using System;
+
+using Datalib;
+using Datalib.HelperClasses;
+
+using SD.LLBLGen.Pro.ORMSupportClasses;
+
+namespace Datalib.FactoryClasses
+{
+	/// <summary>Factory class for IEntityField2 instances, used in IEntityFields2 instances.</summary>
+	public static partial class EntityFieldFactory
+	{
+		/// <summary>Creates a new IEntityField2 instance for usage in the EntityFields object for the entity related to the field index specified.</summary>
+		/// <param name="fieldIndex">The field which IEntityField2 instance should be created</param>
+		/// <returns>The IEntityField2 instance for the field specified in fieldIndex</returns>
+		public static IEntityField2 Create(Enum fieldIndex)
+		{
+			return new EntityField2(FieldInfoProviderSingleton.GetInstance().GetFieldInfo(fieldIndex));
+		}
+
+		/// <summary>Creates a new IEntityField2 instance, which represents the field objectName.fieldName</summary>
+		/// <param name="objectName">the name of the object the field belongs to, like CustomerEntity or OrdersTypedView</param>
+		/// <param name="fieldName">the name of the field to create</param>
+		public static IEntityField2 Create(string objectName, string fieldName)
+        {
+			return new EntityField2(FieldInfoProviderSingleton.GetInstance().GetFieldInfo(objectName, fieldName));
+        }
+
+		#region Included Code
+
+		#endregion
+	}
+}

patientman/Datalib/DatabaseGeneric/FactoryClasses/EntityFieldsFactory.cs

@@ -0,0 +1,53 @@
+///////////////////////////////////////////////////////////////
+// This is generated code. 
+//////////////////////////////////////////////////////////////
+// Code is generated using LLBLGen Pro version: 4.2
+// Code is generated on: 
+// Code is generated using templates: SD.TemplateBindings.SharedTemplates
+// Templates vendor: Solutions Design.
+// Templates version: 
+//////////////////////////////////////////////////////////////
+using System;
+using Datalib;
+using Datalib.HelperClasses;
+using System.Collections.Generic;
+using SD.LLBLGen.Pro.ORMSupportClasses;
+
+namespace Datalib.FactoryClasses
+{
+	/// <summary>Generates IEntityFields2 instances for different kind of Entities.</summary>
+	public static partial class EntityFieldsFactory
+	{
+		private static readonly Dictionary<Datalib.EntityType, string> _entityTypeNamesCache = new Dictionary<Datalib.EntityType, string>();
+
+		/// <summary>static ctor which initializes the static entity type cache.</summary>
+		static EntityFieldsFactory()
+		{
+			foreach(Datalib.EntityType value in Enum.GetValues(typeof(Datalib.EntityType)))
+			{
+				_entityTypeNamesCache.Add(value, Enum.GetName(typeof(Datalib.EntityType), value));
+			}
+		}	
+
+		/// <summary>General factory entrance method which will return an EntityFields2 object with the format generated by the factory specified</summary>
+		/// <param name="relatedEntityType">The type of entity the fields are for</param>
+		/// <returns>The IEntityFields instance requested</returns>
+		public static IEntityFields2 CreateEntityFieldsObject(Datalib.EntityType relatedEntityType)
+		{
+			return FieldInfoProviderSingleton.GetInstance().GetEntityFields(InheritanceInfoProviderSingleton.GetInstance(), _entityTypeNamesCache[relatedEntityType]);
+		}
+		
+		/// <summary>General method which will return an array of IEntityFieldCore objects, used by the InheritanceInfoProvider. Only the fields defined in the entity are returned, no inherited fields.</summary>
+		/// <param name="entityName">the name of the entity to get the fields for. Example: "CustomerEntity"</param>
+		/// <returns>array of IEntityFieldCore fields, defined in the entity with the name specified</returns>
+		internal static IEntityFieldCore[] CreateFields(string entityName)
+		{
+			return FieldInfoProviderSingleton.GetInstance().GetEntityFieldsArray(entityName);
+		}
+
+
+		#region Included Code
+
+		#endregion
+	}
+}

patientman/Datalib/DatabaseGeneric/FactoryClasses/QueryFactory.cs

@@ -0,0 +1,244 @@
+///////////////////////////////////////////////////////////////
+// This is generated code. 
+//////////////////////////////////////////////////////////////
+// Code is generated using LLBLGen Pro version: 4.2
+// Code is generated on: 
+// Code is generated using templates: SD.TemplateBindings.SharedTemplates
+// Templates vendor: Solutions Design.
+////////////////////////////////////////////////////////////// 
+using System;
+using System.Linq;
+using Datalib.EntityClasses;
+using Datalib.HelperClasses;
+using SD.LLBLGen.Pro.ORMSupportClasses;
+using SD.LLBLGen.Pro.QuerySpec;
+
+namespace Datalib.FactoryClasses
+{
+	/// <summary>Factory class to produce DynamicQuery instances and EntityQuery instances</summary>
+	public partial class QueryFactory
+	{
+		private int _aliasCounter = 0;
+
+		/// <summary>Creates a new DynamicQuery instance with no alias set.</summary>
+		/// <returns>Ready to use DynamicQuery instance</returns>
+		public DynamicQuery Create()
+		{
+			return Create(string.Empty);
+		}
+
+		/// <summary>Creates a new DynamicQuery instance with the alias specified as the alias set.</summary>
+		/// <param name="alias">The alias.</param>
+		/// <returns>Ready to use DynamicQuery instance</returns>
+		public DynamicQuery Create(string alias)
+		{
+			return new DynamicQuery(new ElementCreator(), alias, this.GetNextAliasCounterValue());
+		}
+
+		/// <summary>Creates a new DynamicQuery which wraps the specified TableValuedFunction call</summary>
+		/// <param name="toWrap">The table valued function call to wrap.</param>
+		/// <returns>toWrap wrapped in a DynamicQuery.</returns>
+		public DynamicQuery Create(TableValuedFunctionCall toWrap)
+		{
+			return this.Create().From(new TvfCallWrapper(toWrap)).Select(toWrap.GetFieldsAsArray().Select(f => this.Field(toWrap.Alias, f.Alias)).ToArray());
+		}
+
+		/// <summary>Creates a new EntityQuery for the entity of the type specified with no alias set.</summary>
+		/// <typeparam name="TEntity">The type of the entity to produce the query for.</typeparam>
+		/// <returns>ready to use EntityQuery instance</returns>
+		public EntityQuery<TEntity> Create<TEntity>()
+			where TEntity : IEntityCore
+		{
+			return Create<TEntity>(string.Empty);
+		}
+
+		/// <summary>Creates a new EntityQuery for the entity of the type specified with the alias specified as the alias set.</summary>
+		/// <typeparam name="TEntity">The type of the entity to produce the query for.</typeparam>
+		/// <param name="alias">The alias.</param>
+		/// <returns>ready to use EntityQuery instance</returns>
+		public EntityQuery<TEntity> Create<TEntity>(string alias)
+			where TEntity : IEntityCore
+		{
+			return new EntityQuery<TEntity>(new ElementCreator(), alias, this.GetNextAliasCounterValue());
+		}
+				
+		/// <summary>Creates a new field object with the name specified and of resulttype 'object'. Used for referring to aliased fields in another projection.</summary>
+		/// <param name="fieldName">Name of the field.</param>
+		/// <returns>Ready to use field object</returns>
+		public EntityField2 Field(string fieldName)
+		{
+			return Field<object>(string.Empty, fieldName);
+		}
+
+		/// <summary>Creates a new field object with the name specified and of resulttype 'object'. Used for referring to aliased fields in another projection.</summary>
+		/// <param name="targetAlias">The alias of the table/query to target.</param>
+		/// <param name="fieldName">Name of the field.</param>
+		/// <returns>Ready to use field object</returns>
+		public EntityField2 Field(string targetAlias, string fieldName)
+		{
+			return Field<object>(targetAlias, fieldName);
+		}
+
+		/// <summary>Creates a new field object with the name specified and of resulttype 'TValue'. Used for referring to aliased fields in another projection.</summary>
+		/// <typeparam name="TValue">The type of the value represented by the field.</typeparam>
+		/// <param name="fieldName">Name of the field.</param>
+		/// <returns>Ready to use field object</returns>
+		public EntityField2 Field<TValue>(string fieldName)
+		{
+			return Field<TValue>(string.Empty, fieldName);
+		}
+
+		/// <summary>Creates a new field object with the name specified and of resulttype 'TValue'. Used for referring to aliased fields in another projection.</summary>
+		/// <typeparam name="TValue">The type of the value.</typeparam>
+		/// <param name="targetAlias">The alias of the table/query to target.</param>
+		/// <param name="fieldName">Name of the field.</param>
+		/// <returns>Ready to use field object</returns>
+		public EntityField2 Field<TValue>(string targetAlias, string fieldName)
+		{
+			return new EntityField2(fieldName, targetAlias, typeof(TValue));
+		}
+		
+		/// <summary>Gets the next alias counter value to produce artifical aliases with</summary>
+		private int GetNextAliasCounterValue()
+		{
+			_aliasCounter++;
+			return _aliasCounter;
+		}
+		
+
+		/// <summary>Creates and returns a new EntityQuery for the TblAgeGroup entity</summary>
+		public EntityQuery<TblAgeGroupEntity> TblAgeGroup
+		{
+			get { return Create<TblAgeGroupEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblAgency entity</summary>
+		public EntityQuery<TblAgencyEntity> TblAgency
+		{
+			get { return Create<TblAgencyEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblChild entity</summary>
+		public EntityQuery<TblChildEntity> TblChild
+		{
+			get { return Create<TblChildEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblClinicInfo entity</summary>
+		public EntityQuery<TblClinicInfoEntity> TblClinicInfo
+		{
+			get { return Create<TblClinicInfoEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblCommune entity</summary>
+		public EntityQuery<TblCommuneEntity> TblCommune
+		{
+			get { return Create<TblCommuneEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblDiary entity</summary>
+		public EntityQuery<TblDiaryEntity> TblDiary
+		{
+			get { return Create<TblDiaryEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblDistrict entity</summary>
+		public EntityQuery<TblDistrictEntity> TblDistrict
+		{
+			get { return Create<TblDistrictEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblExaminationInfo entity</summary>
+		public EntityQuery<TblExaminationInfoEntity> TblExaminationInfo
+		{
+			get { return Create<TblExaminationInfoEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblPatient entity</summary>
+		public EntityQuery<TblPatientEntity> TblPatient
+		{
+			get { return Create<TblPatientEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblPreClinicsInfo entity</summary>
+		public EntityQuery<TblPreClinicsInfoEntity> TblPreClinicsInfo
+		{
+			get { return Create<TblPreClinicsInfoEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblPregnanceInfo entity</summary>
+		public EntityQuery<TblPregnanceInfoEntity> TblPregnanceInfo
+		{
+			get { return Create<TblPregnanceInfoEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblProvince entity</summary>
+		public EntityQuery<TblProvinceEntity> TblProvince
+		{
+			get { return Create<TblProvinceEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblReferralFromPlace entity</summary>
+		public EntityQuery<TblReferralFromPlaceEntity> TblReferralFromPlace
+		{
+			get { return Create<TblReferralFromPlaceEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblReferralsTo entity</summary>
+		public EntityQuery<TblReferralsToEntity> TblReferralsTo
+		{
+			get { return Create<TblReferralsToEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblReferraltoService entity</summary>
+		public EntityQuery<TblReferraltoServiceEntity> TblReferraltoService
+		{
+			get { return Create<TblReferraltoServiceEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblRegimen entity</summary>
+		public EntityQuery<TblRegimenEntity> TblRegimen
+		{
+			get { return Create<TblRegimenEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblRegimenStopReason entity</summary>
+		public EntityQuery<TblRegimenStopReasonEntity> TblRegimenStopReason
+		{
+			get { return Create<TblRegimenStopReasonEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblService entity</summary>
+		public EntityQuery<TblServiceEntity> TblService
+		{
+			get { return Create<TblServiceEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblTest entity</summary>
+		public EntityQuery<TblTestEntity> TblTest
+		{
+			get { return Create<TblTestEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblTreatment entity</summary>
+		public EntityQuery<TblTreatmentEntity> TblTreatment
+		{
+			get { return Create<TblTreatmentEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblTreatmentInfo entity</summary>
+		public EntityQuery<TblTreatmentInfoEntity> TblTreatmentInfo
+		{
+			get { return Create<TblTreatmentInfoEntity>(); }
+		}
+
+		/// <summary>Creates and returns a new EntityQuery for the TblWaitingList entity</summary>
+		public EntityQuery<TblWaitingListEntity> TblWaitingList
+		{
+			get { return Create<TblWaitingListEntity>(); }
+		}
+
+ 
+
+	}
+}