/// <summary>
        /// 根据对象拼Insert语句
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="graph">对象</param>
        /// <param name="mapping">映射关系</param>
        /// <param name="builder">生成Sql语句类型的Builder如TSqlBuilder或PlSqlBuilder</param>
        /// <param name="ignorProperties">忽略的字段</param>
        /// <returns>根据传入的对象和对象映射时需要忽略的字段以及类定义上的表名,生成完整的Insert语句</returns>
        public static string GetInsertSql <T>(T graph, ORMappingItemCollection mapping, ISqlBuilder builder, params string[] ignorProperties)
        {
            ExceptionHelper.FalseThrow <ArgumentNullException>(graph != null, "graph");
            ExceptionHelper.FalseThrow <ArgumentNullException>(mapping != null, "mapping");
            ExceptionHelper.FalseThrow <ArgumentNullException>(builder != null, "builder");

            InsertSqlClauseBuilder insertBuilder = GetInsertSqlClauseBuilder(graph, mapping, ignorProperties);

            return(string.Format("INSERT INTO {0} {1} \r\n SELECT SCOPE_IDENTITY()", mapping.TableName, insertBuilder.ToSqlString(builder)));
        }
        private static string GetDeleteSql <T>(T graph, ORMappingItemCollection mapping, ISqlBuilder builder, string[] ignorProperties)
        {
            ExceptionHelper.FalseThrow <ArgumentNullException>(graph != null, "graph");
            ExceptionHelper.FalseThrow <ArgumentNullException>(mapping != null, "mapping");
            ExceptionHelper.FalseThrow <ArgumentNullException>(builder != null, "builder");

            WhereSqlClauseBuilder whereBuilder = GetWhereSqlClauseBuilderByPrimaryKey(graph, mapping);

            return(string.Format("DELETE FROM {0} WHERE {1}", mapping.TableName, whereBuilder.ToSqlString(builder)));
        }
 private static void MergeMappingItems(ORMappingItemCollection dest, ORMappingItemCollection src)
 {
     foreach (ORMappingItem item in src)
     {
         if (dest.Contains(item.DataFieldName) == false)
         {
             dest.Add(item);
         }
     }
 }
        public static string GetColumnName(System.Type type, string propName)
        {
            ORMappingItemCollection mapping      = InnerGetMappingInfo(type);
            ORMappingItem           propertyItem = mapping[propName];

            if (propertyItem != null)
            {
                return(propertyItem.DataFieldName);
            }
            throw new ArgumentException("找不到属性" + propName + "所对应的表字段!");
        }
        /// <summary>
        /// 根据对象拼Where子句的方法
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="graph">对象</param>
        /// <param name="mapping">映射关系</param>
        /// <param name="ignorProperties">忽略的字段</param>
        /// <returns>WhereSqlClauseBuilder,供拼Where子句使用</returns>
        /// <remarks>
        /// 根据传入的对象和对象映射时需要忽略的字段,返回WhereSqlClauseBuilder对象,以供后续拼Where子句使用
        /// <code source="..\Framework\TestProjects\DeluxeWorks.Library.Data.SqlBuilder.Test\ORMappingTest.cs" region="GetWhereSqlClauseBuilder" lang="cs" title="根据传入的对象拼Where子句"/>
        /// <see cref="MCS.Library.Data.Builder.WhereSqlClauseBuilder"/>
        /// </remarks>
        public static WhereSqlClauseBuilder GetWhereSqlClauseBuilder <T>(T graph, ORMappingItemCollection mapping, params string[] ignorProperties)
        {
            ExceptionHelper.FalseThrow <ArgumentNullException>(graph != null, "graph");
            ExceptionHelper.FalseThrow <ArgumentNullException>(mapping != null, "mapping");

            WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();

            FillSqlClauseBuilder(builder, graph, mapping, ClauseBindingFlags.Where,
                                 new DoSqlClauseBuilder <T>(DoWhereSqlClauseBuilder <T>), ignorProperties);

            return(builder);
        }
        public static InsertSqlClauseBuilder GetInsertSqlClauseBuilder <T>(T graph, ORMappingItemCollection mapping, ref List <DbParameter> dbParams, params string[] ignorProperties)
        {
            ExceptionHelper.FalseThrow <ArgumentNullException>(graph != null, "graph");
            ExceptionHelper.FalseThrow <ArgumentNullException>(mapping != null, "mapping");

            InsertSqlClauseBuilder builder = new InsertSqlClauseBuilder();

            FillSqlClauseBuilder(builder, graph, mapping, ClauseBindingFlags.Insert,
                                 new DoSqlClauseBuilderWithParams <T>(DoInsertUpdateSqlWithParamBuilder <T>), ignorProperties);

            return(builder);
        }
        /// <summary>
        /// 复制Mapping的集合
        /// </summary>
        /// <returns></returns>
        public ORMappingItemCollection Clone()
        {
            ORMappingItemCollection items = new ORMappingItemCollection();

            items.tableName = this.tableName;

            foreach (ORMappingItem item in this)
            {
                items.Add(item.Clone());
            }

            return(items);
        }
        /// <summary>
        /// 根据对象拼Insert语句
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="graph">对象</param>
        /// <param name="mapping">映射关系</param>
        /// <param name="builder">生成Sql语句类型的Builder如TSqlBuilder或PlSqlBuilder</param>
        /// <param name="ignorProperties">忽略的字段</param>
        /// <returns>根据传入的对象和对象映射时需要忽略的字段以及类定义上的表名,生成完整的Insert语句</returns>
        public static string GetUpdateSql <T>(T graph, ORMappingItemCollection mapping, ISqlBuilder builder, params string[] ignorProperties)
        {
            ExceptionHelper.FalseThrow <ArgumentNullException>(graph != null, "graph");
            ExceptionHelper.FalseThrow <ArgumentNullException>(mapping != null, "mapping");
            ExceptionHelper.FalseThrow <ArgumentNullException>(builder != null, "builder");

            UpdateSqlClauseBuilder updateBuilder = GetUpdateSqlClauseBuilder(graph, mapping, ignorProperties);
            WhereSqlClauseBuilder  whereBuilder  = GetWhereSqlClauseBuilderByPrimaryKey(graph, mapping);

            return(string.Format("UPDATE {0} SET {1} WHERE {2}",
                                 mapping.TableName,
                                 updateBuilder.ToSqlString(builder),
                                 whereBuilder.ToSqlString(builder)));
        }
        /// <summary>
        /// 获取Mapping信息,作为扩展使用
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        private static ORMappingItemCollection InnerGetMappingInfo(System.Type type)
        {
            ExceptionHelper.FalseThrow <ArgumentNullException>(type != null, "type");

            ORMappingItemCollection result = null;

            if (ORMappingContextCache.Instance.TryGetValue(type, out result) == false)
            {
                result = ORMappingsCache.Instance.GetOrAddNewValue(type,
                                                                   (cache, key) => cache.Add(key, GetMappingItemCollection(type)));
            }

            return(result);
        }
        private static ORMappingItemCollection GetMappingItemsBySubClass(RelativeAttributes attrs, MemberInfo sourceMI)
        {
            ORMappingItemCollection items = new ORMappingItemCollection();

            System.Type subType = attrs.SubClassType != null ? attrs.SubClassType.Type : GetRealType(sourceMI);

            MemberInfo[] mis = GetTypeMembers(subType);

            foreach (SubClassORFieldMappingAttribute attr in attrs.SubClassFieldMappings)
            {
                MemberInfo mi = GetMemberInfoByName(attr.SubPropertyName, mis);

                if (mi != null)
                {
                    if (items.Contains(attr.DataFieldName) == false)
                    {
                        ORMappingItem item = new ORMappingItem();

                        item.PropertyName         = sourceMI.Name;
                        item.SubClassPropertyName = attr.SubPropertyName;
                        item.MemberInfo           = mi;

                        if (attrs.SubClassType != null)
                        {
                            item.SubClassTypeDescription = attrs.SubClassType.TypeDescription;
                        }

                        FillMappingItemByAttr(item, attr);

                        items.Add(item);
                    }
                }
            }

            foreach (SubClassSqlBehaviorAttribute attr in attrs.SubClassFieldSqlBehaviors)
            {
                ORMappingItem item = FindItemBySubClassPropertyName(attr.SubPropertyName, items);

                if (item != null)
                {
                    FillMappingItemByBehaviorAttr(item, attr);
                }
            }

            return(items);
        }
 private static void FillSqlClauseBuilder(SelectSqlClauseBuilder builder, ORMappingItemCollection mapping,
                                          ClauseBindingFlags bindingFlags, DoSelectClauseBuilder builderDelegate, params string[] ignorProperties)
 {
     foreach (ORMappingItem item in mapping)
     {
         if (Array.Exists <string>(ignorProperties,
                                   delegate(string target)
         {
             return(string.Compare(target, item.PropertyName, true) == 0);
         }) == false)
         {
             if ((item.BindingFlags & bindingFlags) != ClauseBindingFlags.None)
             {
                 builderDelegate(builder, item);
             }
         }
     }
 }
        private static ORMappingItemCollection CreateMappingItems(MemberInfo mi)
        {
            ORMappingItemCollection result = null;
            bool isDoMapping = false;

            RelativeAttributes attrs = null;

            if (mi.Name != "Item" &&
                (GetRealType(mi).GetInterface("ICollection") == null ||
                 GetRealType(mi).Name.ToLower() == "byte[]")) //byte[] 对应sql的image类型
            {
                attrs = GetRelativeAttributes(mi);

                if (attrs.NoMapping == null)
                {
                    isDoMapping = true;
                }
            }

            if (isDoMapping == true)
            {
                if (attrs != null)
                {
                    if (attrs.SubClassFieldMappings.Count > 0 || attrs.SubClassFieldSqlBehaviors.Count > 0)
                    {
                        result = GetMappingItemsBySubClass(attrs, mi);
                    }
                    else
                    {
                        result = GetMappingItems(attrs, mi);
                    }
                }
            }
            else
            {
                result = new ORMappingItemCollection();
            }

            return(result);
        }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="row">DataRow对象</param>
        /// <param name="items">映射关系</param>
        /// <param name="graph">对象</param>
        /// <param name="dod"></param>
        public static void DataRowToObject <T>(DataRow row, ORMappingItemCollection items, T graph, DataToObjectDeligations dod)
        {
            ExceptionHelper.FalseThrow <ArgumentNullException>(row != null, "row");
            ExceptionHelper.FalseThrow <ArgumentNullException>(items != null, "items");
            ExceptionHelper.FalseThrow <ArgumentNullException>(graph != null, "graph");
            ExceptionHelper.FalseThrow <ArgumentNullException>(row.Table != null, "row.Table");

            foreach (DataColumn column in row.Table.Columns)
            {
                if (items.Contains(column.ColumnName))
                {
                    ORMappingItem item = items[column.ColumnName];

                    System.Type realType = GetRealType(item.MemberInfo);

                    object data = row[column];
                    if (Convertible(realType, data))
                    {
                        SetValueToObject(item, graph, ConvertData(item, data), row, dod);
                    }
                }
            }
        }
        /// <summary>
        /// 将DataReader的值写入到对象中
        /// </summary>
        /// <typeparam name="T">对象类型</typeparam>
        /// <param name="dr">IDataReader对象</param>
        /// <param name="items">映射关系</param>
        /// <param name="graph">对象</param>
        /// <param name="dod"></param>
        public static void DataReaderToObject <T>(IDataReader dr, ORMappingItemCollection items, T graph, DataToObjectDeligations dod)
        {
            ExceptionHelper.FalseThrow <ArgumentNullException>(dr != null, "dr");
            ExceptionHelper.FalseThrow <ArgumentNullException>(items != null, "items");
            ExceptionHelper.FalseThrow <ArgumentNullException>(graph != null, "graph");

            DataTable schemaTable = dr.GetSchemaTable();

            foreach (DataRow row in schemaTable.Rows)
            {
                string columnName = row["ColumnName"].ToString();
                if (items.Contains(columnName))
                {
                    ORMappingItem item     = items[row["ColumnName"].ToString()];
                    System.Type   realType = GetRealType(item.MemberInfo);

                    object data = dr[columnName];
                    if (Convertible(realType, data))
                    {
                        SetValueToObject(item, graph, ConvertData(item, data), dr, dod);
                    }
                }
            }
        }
 /// <summary>
 /// 将DataReader的值写入到对象中
 /// </summary>
 /// <typeparam name="T">对象类型</typeparam>
 /// <param name="dr">IDataReader对象</param>
 /// <param name="items">映射关系</param>
 /// <param name="graph">对象</param>
 public static void DataReaderToObject <T>(IDataReader dr, ORMappingItemCollection items, T graph)
 {
     DataReaderToObject(dr, items, graph, null);
 }
 /// <summary>
 /// 将DataRow的值写入到对象中
 /// </summary>
 /// <typeparam name="T">对象类型</typeparam>
 /// <param name="row">DataRow对象</param>
 /// <param name="items">映射关系</param>
 /// <param name="graph">对象</param>
 public static void DataRowToObject <T>(DataRow row, ORMappingItemCollection items, T graph)
 {
     DataRowToObject(row, items, graph, null);
 }
        private static ORMappingItem FindItemBySubClassPropertyName(string subPropertyName, ORMappingItemCollection items)
        {
            ORMappingItem result = null;

            foreach (ORMappingItem item in items)
            {
                if (item.SubClassPropertyName == subPropertyName)
                {
                    result = item;
                    break;
                }
            }

            return(result);
        }
        public static string GetDeleteSql <T>(T graph, ISqlBuilder builder, params string[] ignorProperties)
        {
            ORMappingItemCollection mapping = InnerGetMappingInfoByObject(graph);

            return(GetDeleteSql <T>(graph, mapping, builder, ignorProperties));
        }
        public static string GetSelectSql <T>(ISqlBuilder builder, params string[] ignorProperties)
        {
            ORMappingItemCollection mapping = InnerGetMappingInfo(typeof(T));

            return(GetSelectSql(false, mapping, builder, ignorProperties));
        }
        private static SelectSqlClauseBuilder GetSelectSqlClauseBuilder(bool useTableName, ORMappingItemCollection mapping, params string[] ignorProperties)
        {
            ExceptionHelper.FalseThrow <ArgumentNullException>(mapping != null, "mapping");

            SelectSqlClauseBuilder builder = new SelectSqlClauseBuilder();

            if (useTableName)
            {
                builder.TableName = mapping.TableName;
            }
            FillSqlClauseBuilder(builder, mapping, ClauseBindingFlags.Select,
                                 new DoSelectClauseBuilder(DoSelectSqlClauseBuilder), ignorProperties);

            return(builder);
        }
        public static string GetInsertSql <T>(T graph, ISqlBuilder builder, ref List <DbParameter> dbParams, params string[] ignorProperties)
        {
            ORMappingItemCollection mapping = InnerGetMappingInfoByObject(graph);

            return(GetInsertSql <T>(graph, mapping, builder, ref dbParams, ignorProperties));
        }
        public static string GetTableName(System.Type type)
        {
            ORMappingItemCollection mapping = InnerGetMappingInfo(type);

            return(mapping.TableName);
        }
        public static string GetSelectSql(bool useTableName, System.Type type, ISqlBuilder builder, params string[] ignorProperties)
        {
            ORMappingItemCollection mapping = InnerGetMappingInfo(type);

            return(GetSelectSql(useTableName, mapping, builder, ignorProperties));
        }