protected override string GetParameterName(IPropertyMap propertyMap, string prefix)
 {
     string name = prefix;
     name = name + propertyMap.Name;
     name = ":" + name + GetNextParamNr().ToString() ;
     return name;
 }

        public virtual void NotifyPropertyLoad(object obj, IPropertyMap propertyMap, object value)
        {
            if (propertyMap.NoInverseManagement)
                return;
            if (propertyMap.ReferenceType == ReferenceType.None)
                return;
            if (!(propertyMap.Inverse.Length > 0))
                return;
            IPropertyMap invPropertyMap = propertyMap.MustGetInversePropertyMap();
            if (invPropertyMap == null)
                return;

            if (propertyMap.ReferenceType == ReferenceType.ManyToMany)
            {
                HandleManyManyPropertyLoad(obj, propertyMap, invPropertyMap, (IList) value);
            }
            if (propertyMap.ReferenceType == ReferenceType.ManyToOne)
            {
                HandleManyOnePropertyLoad(obj, propertyMap, invPropertyMap, (IList) value);
            }
            if (propertyMap.ReferenceType == ReferenceType.OneToMany)
            {
                HandleOneManyPropertyLoad(obj, propertyMap, invPropertyMap, value);
            }
            if (propertyMap.ReferenceType == ReferenceType.OneToOne)
            {
                HandleOneOnePropertyLoad(obj, propertyMap, invPropertyMap, value);
            }
        }

        public virtual IList CloneList(object obj, IPropertyMap propertyMap, IList orgList)
        {
            Type t = obj.GetType() ;
            Type listType = t.GetProperty(propertyMap.Name).PropertyType;

            IList newList = Context.ProxyFactory.CreateListProxy(listType,Context.ObjectFactory,new object[0] ) ;

            IInterceptableList mList;
            bool stackMute = false;

            mList = newList as IInterceptableList;
            if (mList != null)
            {
                stackMute = mList.MuteNotify;
                mList.MuteNotify = true;
                mList.Interceptable = (IInterceptable) obj;
                mList.PropertyName = propertyMap.Name;
            }
            foreach (object item in orgList)
            {
                newList.Add(item);
            }
            if (mList != null)
            {
                mList.MuteNotify = stackMute;
            }
            return newList;
        }

		public virtual SqlColumnAlias GetPropertyColumn(IPropertyMap propertyMap, object hash) 
		{	
			if (hash == null) { hash = propertyMap; }
			SqlTableAlias tbl = sqlEmitter.GetTableAlias(propertyMap.MustGetTableMap(), hash)  ;

            IColumnMap columnMap = propertyMap.GetColumnMap();

            return tbl.GetSqlColumnAlias(columnMap);
		}

 public void ChangeOperator(Func<IDbConnection, IDbTransaction,object, object> action, IDbContext context, dynamic entity,IPropertyMap map=null)
 {
     OperatorInfo item = new OperatorInfo {
         func = action,
         Context = context,
         entity = entity,
         Map = map
     };
     this.list.Add(item);
 }

		public SqlEmitter(INPathEngine npathEngine, NPathSelectQuery query,NPathQueryType queryType, IClassMap rootClassMap,SqlSelectStatement parentQuery,IPropertyMap backReference,int subQueryLevel)
		{
			this.npathEngine = npathEngine;
			this.query = query;
			this.rootClassMap = rootClassMap;
			propertyPathTraverser = new PropertyPathTraverser(this);
			this.propertyColumnMap = new Hashtable() ;
			this.npathQueryType = queryType;
			this.parentQuery = parentQuery;
			this.backReference = backReference;
			this.subQueryLevel = subQueryLevel;
		}

 public static void GenerateDLinqField(IClassMap classMap, IPropertyMap propertyMap, CodeTypeDeclaration classDecl)
 {
     switch (propertyMap.ReferenceType)
     {
         case ReferenceType.None :
             classDecl.Members.Add(GenerateDLinqPrimitiveField(classMap, propertyMap));
         break;
         case ReferenceType.OneToMany :
             GenerateDLinqOneToManyFields(classMap, propertyMap, classDecl);
         break;
     }
 }

 public ObjectTreeNode(IContext context, object obj, object referencedByObj, IPropertyMap referencedByPropertyMap)
 {
     this.context = context;
     this.obj = obj;
     this.ClassMap = context.DomainMap.MustGetClassMap(obj.GetType() );
     this.referencedByObj = referencedByObj;
     this.referencedByClassMap = context.DomainMap.MustGetClassMap(ReferencedByObj.GetType() );
     this.referencedByPropertyMap = referencedByPropertyMap;
     this.Nodes.Add(new TreeNode() );
     SetText();
     this.ImageIndex = 0;
     this.SelectedImageIndex = 0;
 }

		/// <summary>
		/// Generates the property.
		/// </summary>
		/// <param name="file">The file.</param>
		/// <param name="property">The property.</param>
		/// <param name="isReadOnly">if set to <c>true</c> the readonly property is generated.</param>
		public static void GenerateProperty(StreamWriter file, IPropertyMap property, bool isReadOnly)
		{
			string fieldType = ConvertColumnTypeToCsType(property.GetColumnMap().DataType);
			string fieldName = GetFieldName(property);

			file.WriteLine("\t\tpublic " + fieldType + " " + property.Name);
			file.WriteLine("\t\t{");
			file.WriteLine("\t\t\tget { return " + fieldName + "; }");
			if (!isReadOnly)
			{
				file.WriteLine("\t\t\tset { " + fieldName + " = value; }");
			}
			file.WriteLine("\t\t}");
		}

        private string BuildObjectIdentity(object obj, IPropertyMap newPropertyMap, object newValue)
        {
            string id = "";
            IClassMap classMap = m_ObjectManager.Context.DomainMap.MustGetClassMap(obj.GetType());
            string sep = classMap.IdentitySeparator;
            //			bool gotObjectStatus = false;
            //			ObjectStatus objStatus = ObjectStatus.Clean;
            if (sep == "")
            {
                sep = "|";
            }
            object value;
            foreach (IPropertyMap propertyMap in classMap.GetIdentityPropertyMaps())
            {
                if (propertyMap == newPropertyMap)
                {
                    value = newValue;
                    if (propertyMap.ReferenceType != ReferenceType.None)
                    {
                        value = m_ObjectManager.GetObjectIdentity(value);
                    }
                }
                else
                {
                    value = m_ObjectManager.GetPropertyValue(obj, propertyMap.Name);
                    if (value == null || m_ObjectManager.GetNullValueStatus(obj, propertyMap.Name) == true)
                    {
                        if (!(m_hashTempIds.ContainsKey(obj)))
                        {
                            m_hashTempIds[obj] = Guid.NewGuid().ToString();
                        }
                        return (string)m_hashTempIds[obj];
                    }
                    else if (propertyMap.ReferenceType != ReferenceType.None)
                    {
                        //this ensures that a complete id can be created ahead in case of auto-in
                        //m_ObjectManager.GetPropertyValue(obj, propertyMap.Name);
                        value = m_ObjectManager.GetObjectIdentity(value);
                    }
                }

                id += Convert.ToString(value) + sep;
            }
            if (id.Length > sep.Length)
            {
                id = id.Substring(0, id.Length - sep.Length);
            }
            return id;
        }

        /*

        private System.Nullable<int> _ReportsTo;

        private EntityRef<Employee> _ReportsToEmployee;

         * */
        public static void GenerateDLinqOneToManyFields(IClassMap classMap, IPropertyMap propertyMap, CodeTypeDeclaration classDecl)
        {
            foreach (IColumnMap columnMap in propertyMap.GetAllColumnMaps())
            {
                string fieldName = propertyMap.GenerateMemberName(columnMap.Name);

                CodeMemberField fieldMember = new CodeMemberField() ;
                fieldMember.Name = fieldName;

                //Add code for adding Nullable generics when OM is ported to .NET 2.0

                CodeTypeReference typeReference = new CodeTypeReference(columnMap.GetSystemType());
                fieldMember.Type = typeReference;

                classDecl.Members.Add(fieldMember);
            }
        }

		public void SetupJoin(IPropertyMap propertyMap, IPropertyMap parentMap, string propertyPath, JoinType joinType)
		{
			TableJoin tableJoin = GetTableJoinForPropertyPath(propertyPath);
			if (tableJoin == null)
			{
				tableJoin = new TableJoin();
				tableJoin.PropertyMap = propertyMap;
				tableJoin.JoinType = joinType;
				if (parentMap == null)
				{
					tableJoin.JoinTree = this;
					this.propertyPathTraverser.SqlEmitter.GetTableAlias(propertyMap.MustGetTableMap(), propertyMap);
				}
				else
				{
					//make sure the table has an alias
					tableJoin.Parent = GetTableJoinForPropertyPath(propertyPath.Substring(0, propertyPath.Length - propertyMap.Name.Length - 1));
					this.propertyPathTraverser.SqlEmitter.GetTableAlias(propertyMap.MustGetTableMap(), tableJoin.Parent);
				}
			}
		}

 public virtual ValidationMode GetValidationMode(IClassMap classMap, IPropertyMap propertyMap)
 {
     ValidationMode validationMode = propertyMap.ValidationMode;
     if (validationMode == ValidationMode.Default)
     {
         validationMode = classMap.ValidationMode;
         if (validationMode == ValidationMode.Default)
         {
             validationMode = classMap.DomainMap.ValidationMode;
             if (validationMode == ValidationMode.Default)
             {
                 validationMode = this.Context.ValidationMode;
                 if (validationMode == ValidationMode.Default)
                 {
                     validationMode = ValidationMode.ValidateLoaded;
                 }
             }
         }
     }
     return validationMode;
 }

        public ObjectPropertyDescriptor(MemberDescriptor descr, IContext context, IPropertyMap propertyMap, object obj, Attribute[] attrs)
            : base(descr, attrs)
        {
            this.realPropertyDescriptor = (PropertyDescriptor) descr;
            this.name = propertyMap.Name;
            this.displayName = propertyMap.Name;

            Attribute[] attribs = new Attribute[descr.Attributes.Count + 4];

            int i = 0;
            foreach (Attribute attrib in descr.Attributes)
            {
                attribs[i] = attrib;
                i++;
            }
            attribs[i] = new DescriptionAttribute(propertyMap.Name + " is a property.");
            attribs[i + 1] = new CategoryAttribute("");
            attribs[i + 2] = new DefaultValueAttribute(context.ObjectManager.GetOriginalPropertyValue(obj, propertyMap.Name));
            attribs[i + 3] = new ReadOnlyAttribute(propertyMap.IsReadOnly);

            attributes = new AttributeCollection(attribs);
        }

		/// <summary>
		/// Fetches a FieldInfo for a specific property in a given type
		/// </summary>
		/// <param name="propertyMap"></param>
		/// <param name="type"></param>
		/// <param name="propertyName"></param>
		/// <returns></returns>
		//[DebuggerStepThrough()]
		public static FieldInfo GetFieldInfo(IPropertyMap propertyMap, Type type, string propertyName)
		{
			Hashtable fieldLookup = FieldLookup(type);
			if (fieldLookup != null)
			{
				if (!fieldLookup.ContainsKey(propertyName))
				{
					FieldInfo fieldInfo = type.GetField(propertyMap.GetFieldName(), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
				
					if (fieldInfo == null) //field was not found in this type
						fieldInfo = GetFieldInfo(propertyMap, type.BaseType, propertyName); //fetch the field from the base class

					lock(syncRoot)
					{
						if (!fieldLookup.ContainsKey(propertyName))
						{
							fieldLookup.Add(propertyName, fieldInfo); //cache the field info with this type , even if the field was found in a super class
						}
					}
				}				
				return fieldLookup[propertyName] as FieldInfo;
			}
			return null;
		}

		private bool KeepExistingValue(object value, object extValue, MergeBehaviorType mergeBehavior, IClassMap classMap, IPropertyMap propertyMap, object existing, object obj, PropertyStatus propStatus, PropertyStatus extPropStatus, bool forOrgValue)
		{
			bool keepExisting = false;
			MergeBehaviorType useMergeBehavior = GetMergeBehavior(mergeBehavior, classMap, propertyMap);
			if (useMergeBehavior == MergeBehaviorType.ThrowConcurrencyException) 
				throw new MergeException("Merge Conflict!", extValue, value, existing, obj, propertyMap.Name, forOrgValue);

			//First try: Dirty wins..
			if (propStatus == PropertyStatus.Dirty && extPropStatus == PropertyStatus.Dirty)
			{
				if (useMergeBehavior == MergeBehaviorType.DefaultBehavior)
					throw new BothDirtyMergeException("Unresovable Merge Conflict! Both values are dirty!", extValue, value, existing, obj, propertyMap.Name, forOrgValue);
				else if (useMergeBehavior == MergeBehaviorType.IgnoreConflictsUsingMergeValue)
					keepExisting = false;
				else if (useMergeBehavior == MergeBehaviorType.IgnoreConflictsUsingCashedValue)
					keepExisting = true;
				else
					throw new NPersistException("This should be unreachable code...if it is not, that means I made a mistake!" );					
			}
			else if (propStatus == PropertyStatus.Dirty)
				keepExisting = false;
			else if (extPropStatus == PropertyStatus.Dirty)
				keepExisting = true;
			else
			{
				//Second try: Clean wins
				if (propStatus == PropertyStatus.Clean && extPropStatus == PropertyStatus.Clean)
				{
					if (useMergeBehavior == MergeBehaviorType.DefaultBehavior)
						throw new BothCleanMergeException("Unresovable Merge Conflict! Both values are clean!", extValue, value, existing, obj, propertyMap.Name, forOrgValue);
					else if (useMergeBehavior == MergeBehaviorType.IgnoreConflictsUsingMergeValue)
						keepExisting = false;
					else if (useMergeBehavior == MergeBehaviorType.IgnoreConflictsUsingCashedValue)
						keepExisting = true;
					else
						throw new NPersistException("This should be unreachable code...if it is not, that means I made a mistake!" );						
				}
				else if (propStatus == PropertyStatus.Clean)
					keepExisting = false;
				else if (extPropStatus == PropertyStatus.Clean)
					keepExisting = true;
				else
				{
					if (extPropStatus == PropertyStatus.NotLoaded)
						keepExisting = false;
					if (extPropStatus == PropertyStatus.Deleted)
						keepExisting = true;
					else
						throw new NPersistException("This should be unreachable code...if it is not, that means I made a mistake!" );					
				}
			}
			return keepExisting;
		}

		private void MergePrimitivePropertyValues(object value, object extValue, PropertyStatus propStatus, PropertyStatus extPropStatus, IObjectManager om, object existing, IClassMap classMap, IPropertyMap propertyMap, object obj, bool forOrgValue, MergeBehaviorType mergeBehavior)
		{
			if (!value.Equals(extValue)) // May be to naive - possibly should use some advanced method like ComparePropertyValues..
			{
				bool keepExisting = KeepExistingValue(value, extValue, mergeBehavior, classMap, propertyMap, existing, obj, propStatus, extPropStatus, forOrgValue);
				if (!keepExisting)
				{
					if (forOrgValue)
					{
						om.SetPropertyValue(existing, propertyMap.Name, value);				
						om.SetNullValueStatus(existing, propertyMap.Name, om.GetNullValueStatus(obj, propertyMap.Name));
						if (propStatus == PropertyStatus.Dirty)
						{
							this.Context.UnitOfWork.RegisterDirty(existing);					
							om.SetUpdatedStatus(existing, propertyMap.Name, true);						
						}
					}
					else
					{
						om.SetOriginalPropertyValue(existing, propertyMap.Name, value);									
					}
				}
			}
		}

		private void MergePrimitiveProperty(IObjectManager om, object obj, IClassMap classMap, IPropertyMap propertyMap, object existing, bool forOrgValue, PropertyStatus propStatus, PropertyStatus extPropStatus, MergeBehaviorType mergeBehavior)
		{
			if (forOrgValue)
			{
				object value = om.GetPropertyValue(obj, propertyMap.Name);
				object extValue = om.GetPropertyValue(existing, propertyMap.Name);
				MergePrimitivePropertyValues(value, extValue, propStatus, extPropStatus, om, existing, classMap, propertyMap, obj, forOrgValue, mergeBehavior);
			}
			else
			{
				object orgValue = om.GetOriginalPropertyValue(obj, propertyMap.Name);
				object extOrgValue = om.GetOriginalPropertyValue(existing, propertyMap.Name);
				MergePrimitivePropertyValues(orgValue, extOrgValue, propStatus, extPropStatus, om, existing, classMap, propertyMap, obj, forOrgValue, mergeBehavior);
			}
		}

		public virtual OptimisticConcurrencyBehaviorType GetDeleteOptimisticConcurrencyBehavior(OptimisticConcurrencyBehaviorType optimisticConcurrencyBehavior, IPropertyMap propertyMap)
		{
			IColumnMap columnMap = null;
			if (optimisticConcurrencyBehavior == OptimisticConcurrencyBehaviorType.DefaultBehavior)
			{
				if (this.Context.OptimisticConcurrencyMode == OptimisticConcurrencyMode.Disabled)
				{
					optimisticConcurrencyBehavior = OptimisticConcurrencyBehaviorType.Disabled;
				}
				else
				{
					optimisticConcurrencyBehavior = propertyMap.DeleteOptimisticConcurrencyBehavior;
					if (optimisticConcurrencyBehavior == OptimisticConcurrencyBehaviorType.DefaultBehavior)
					{
						optimisticConcurrencyBehavior = propertyMap.ClassMap.DeleteOptimisticConcurrencyBehavior;
						if (optimisticConcurrencyBehavior == OptimisticConcurrencyBehaviorType.DefaultBehavior)
						{
							optimisticConcurrencyBehavior = propertyMap.ClassMap.DomainMap.DeleteOptimisticConcurrencyBehavior;
							if (optimisticConcurrencyBehavior == OptimisticConcurrencyBehaviorType.DefaultBehavior)
							{
								optimisticConcurrencyBehavior = m_DeleteOptimisticConcurrencyBehavior;
							}
						}
					}					
				}
			}
			if (optimisticConcurrencyBehavior == OptimisticConcurrencyBehaviorType.DefaultBehavior)
			{
				columnMap = propertyMap.GetColumnMap();
				if (columnMap != null)
				{
					if (columnMap.DataType == DbType.AnsiString || columnMap.DataType == DbType.AnsiStringFixedLength || columnMap.DataType == DbType.String || columnMap.DataType == DbType.StringFixedLength)
					{
						if (columnMap.Precision == 0 || columnMap.Precision >= 4000)
						{
							optimisticConcurrencyBehavior = OptimisticConcurrencyBehaviorType.Disabled;
						}
						else
						{
							optimisticConcurrencyBehavior = OptimisticConcurrencyBehaviorType.IncludeWhenLoaded;
						}
					}
					else if (columnMap.DataType == DbType.Binary || columnMap.DataType == DbType.Object)
					{
						optimisticConcurrencyBehavior = OptimisticConcurrencyBehaviorType.Disabled;
					}
					else
					{
						optimisticConcurrencyBehavior = OptimisticConcurrencyBehaviorType.IncludeWhenLoaded;
					}
				}
			}
			else
			{
				if (!(optimisticConcurrencyBehavior == OptimisticConcurrencyBehaviorType.Disabled))
				{
					if (propertyMap.DeleteOptimisticConcurrencyBehavior == OptimisticConcurrencyBehaviorType.DefaultBehavior)
					{
						columnMap = propertyMap.GetColumnMap();
						if (columnMap != null)
						{
							if (columnMap.DataType == DbType.AnsiString || columnMap.DataType == DbType.AnsiStringFixedLength || columnMap.DataType == DbType.String || columnMap.DataType == DbType.StringFixedLength)
							{
								if (columnMap.Precision == 0 || columnMap.Precision >= 4000)
								{
									optimisticConcurrencyBehavior = OptimisticConcurrencyBehaviorType.Disabled;
								}
							}
							else if (columnMap.DataType == DbType.Binary || columnMap.DataType == DbType.Object)
							{
								optimisticConcurrencyBehavior = OptimisticConcurrencyBehaviorType.Disabled;
							}
						}
					}
				}
			}
			if (columnMap == null)
			{
				columnMap = propertyMap.GetColumnMap();
			}
			if (columnMap != null)
			{
				if (columnMap.DataType == DbType.Binary || columnMap.DataType == DbType.Object)
				{
					optimisticConcurrencyBehavior = OptimisticConcurrencyBehaviorType.Disabled;
				}
			}
			return optimisticConcurrencyBehavior;
		}

		public virtual RefreshBehaviorType GetRefreshBehavior(RefreshBehaviorType refreshBehavior, IClassMap classMap, IPropertyMap propertyMap)
		{
			if (refreshBehavior == RefreshBehaviorType.DefaultBehavior)
			{
				if (this.Context.OptimisticConcurrencyMode == OptimisticConcurrencyMode.Early)
				{
					refreshBehavior = RefreshBehaviorType.ThrowConcurrencyException ;					
				}
				else
				{
					refreshBehavior = propertyMap.RefreshBehavior;
					if (refreshBehavior == RefreshBehaviorType.DefaultBehavior)
					{
						refreshBehavior = classMap.RefreshBehavior;
						if (refreshBehavior == RefreshBehaviorType.DefaultBehavior)
						{
							refreshBehavior = classMap.DomainMap.RefreshBehavior;
							if (refreshBehavior == RefreshBehaviorType.DefaultBehavior)
							{
								refreshBehavior = m_RefreshBehavior;
								if (refreshBehavior == RefreshBehaviorType.DefaultBehavior)
								{
									refreshBehavior = RefreshBehaviorType.OverwriteNotLoaded;
								}
							}
						}
					}					
				}
			}
			return refreshBehavior;
		}