Example #1
0
 public static void Ctor_Default()
 {
     ColumnAttribute attribute = new ColumnAttribute();
     Assert.Null(attribute.Name);
     Assert.Equal(-1, attribute.Order);
     Assert.Null(attribute.TypeName);
 }
Example #2
0
 public static void Ctor_String(string name)
 {
     ColumnAttribute attribute = new ColumnAttribute(name);
     Assert.Equal(name, attribute.Name);
     Assert.Equal(-1, attribute.Order);
     Assert.Null(attribute.TypeName);
 }
Example #3
0
 protected override void CreateColumnMap(Type entityType, MemberInfo member, ColumnAttribute columnAtt, ColumnMapCollection columnMaps)
 {
     if (ColumnPredicate(member))
     {
         // Map public property to DB column
         columnMaps.Add(new ColumnMap(member));
     }
 }
 /// <summary>
 /// Registers any member with a ColumnAttribute as a ColumnMap.
 /// <param name="entityType">The entity that is being mapped.</param>
 /// <param name="member">The current member that is being inspected.</param>
 /// <param name="columnAtt">A ColumnAttribute (is null of one does not exist).</param>
 /// <param name="columnMaps">A list of ColumnMaps.</param>
 /// </summary>
 protected override void CreateColumnMap(Type entityType, MemberInfo member, ColumnAttribute columnAtt, ColumnMapCollection columnMaps)
 {
     if (columnAtt != null)
     {
         ColumnMap columnMap = new ColumnMap(member, columnAtt);
         columnMaps.Add(columnMap);
     }
 }
 /// <summary>
 /// Maps properties to DB columns if a ColumnAttribute is not present.
 /// <param name="entityType">The entity that is being mapped.</param>
 /// <param name="member">The current member that is being inspected.</param>
 /// <param name="columnAtt">A ColumnAttribute (is null of one does not exist).</param>
 /// <param name="columnMaps">A list of ColumnMaps.</param>
 /// </summary>
 protected override void CreateColumnMap(Type entityType, MemberInfo member, ColumnAttribute columnAtt, ColumnMapCollection columnMaps)
 {
     if (columnAtt != null)
     {
         // Add columns with ColumnAttribute
         base.CreateColumnMap(entityType, member, columnAtt, columnMaps);
     }
     else
     {
         if (member.MemberType == MemberTypes.Property)
         {
             // Map public property to DB column
             columnMaps.Add(new ColumnMap(member));
         }
     }
 }
        public static void Order_Set_NegativeValue_ThrowsArgumentOutOfRangeException()
        {
            ColumnAttribute attribute = new ColumnAttribute();

            AssertExtensions.Throws <ArgumentOutOfRangeException>("value", () => attribute.Order = -1);
        }
Example #7
0
        internal static SqlType Get(Type memberType, ColumnAttribute col)
        {
            SqlType result = null;
            DBType  dbType = col.DbType;

            string key = null;

            if (col.DbType == DBType.Unkonw)
            {
                var typeKey = memberType.TypeHandle.Value.GetHashCode();

                if (col.Length == 0 &&
                    col.IsNullable &&
                    col.Precision == 0 &&
                    col.Scale == 0)
                {
                    if (defaultTypes.TryGetValue(typeKey, out result))
                    {
                        return(result);
                    }
                }

                var underlyingType = memberType;
                if (underlyingType.IsNullable())
                {
                    underlyingType = Nullable.GetUnderlyingType(underlyingType);
                }
                if (underlyingType.IsEnum)
                {
                    underlyingType = Enum.GetUnderlyingType(underlyingType);
                }
                //if (!TypeMap.TryGetValue(underlyingType.TypeHandle.Value.GetHashCode(), out dbType))
                //    throw new NotSupportedException("Not support '" + underlyingType.FullName + "' for field or property type.");
                typeKey = underlyingType.TypeHandle.Value.GetHashCode();
                if (TypeMap.TryGetValue(typeKey, out dbType))
                {
                    key = string.Concat(typeKey, col.Length, col.IsNullable, col.Precision, col.Scale);
                    if (SqlTypes.TryGetValue(key, out result))
                    {
                        return(result);
                    }

                    defaultTypes.TryGetValue(typeKey, out result);
                }
            }
            else
            {
                key = string.Concat(col.DbType, col.Length, col.IsNullable, col.Precision, col.Scale);
                if (SqlTypes.TryGetValue(key, out result))
                {
                    return(result);
                }
                result = new SqlType(col.DbType);
            }
            if (result != null)
            {
                dbType = result.DbType;
            }

            result = new SqlType(dbType, col.Precision, col.Scale)
            {
                Length = col.Length, Required = !col.IsNullable
            };

            lock (SqlTypes)
                SqlTypes.Add(key, result);
            return(result);
        }
        private void DiscoverRecordFields(Type recordType, string declaringMember, bool optIn = false)
        {
            if (recordType == null)
            {
                return;
            }
            if (!recordType.IsDynamicType())
            {
                Type pt = null;
                if (optIn) //ChoTypeDescriptor.GetProperties(recordType).Where(pd => pd.Attributes.OfType<ChoKVPRecordFieldAttribute>().Any()).Any())
                {
                    foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
                    {
                        pt = pd.PropertyType.GetUnderlyingType();
                        if (!pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt))
                        {
                            DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn);
                        }
                        else if (pd.Attributes.OfType <ChoKVPRecordFieldAttribute>().Any())
                        {
                            var obj = new ChoKVPRecordFieldConfiguration(pd.Name, pd.Attributes.OfType <ChoKVPRecordFieldAttribute>().First(), pd.Attributes.OfType <Attribute>().ToArray());
                            obj.FieldType          = pt;
                            obj.PropertyDescriptor = pd;
                            obj.DeclaringMember    = declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name);
                            if (!KVPRecordFieldConfigurations.Any(c => c.Name == pd.Name))
                            {
                                KVPRecordFieldConfigurations.Add(obj);
                            }
                        }
                    }
                }
                else
                {
                    foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
                    {
                        pt = pd.PropertyType.GetUnderlyingType();
                        if (pt != typeof(object) && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt))
                        {
                            DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn);
                        }
                        else
                        {
                            var obj = new ChoKVPRecordFieldConfiguration(pd.Name);
                            obj.FieldType          = pt;
                            obj.PropertyDescriptor = pd;
                            obj.DeclaringMember    = declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name);
                            StringLengthAttribute slAttr = pd.Attributes.OfType <StringLengthAttribute>().FirstOrDefault();
                            if (slAttr != null && slAttr.MaximumLength > 0)
                            {
                                obj.Size = slAttr.MaximumLength;
                            }
                            DisplayNameAttribute dnAttr = pd.Attributes.OfType <DisplayNameAttribute>().FirstOrDefault();
                            if (dnAttr != null && !dnAttr.DisplayName.IsNullOrWhiteSpace())
                            {
                                obj.FieldName = dnAttr.DisplayName.Trim();
                            }
                            else
                            {
                                DisplayAttribute dpAttr = pd.Attributes.OfType <DisplayAttribute>().FirstOrDefault();
                                if (dpAttr != null)
                                {
                                    if (!dpAttr.ShortName.IsNullOrWhiteSpace())
                                    {
                                        obj.FieldName = dpAttr.ShortName;
                                    }
                                    else if (!dpAttr.Name.IsNullOrWhiteSpace())
                                    {
                                        obj.FieldName = dpAttr.Name;
                                    }

                                    obj.Order = dpAttr.Order;
                                }
                                else
                                {
                                    ColumnAttribute clAttr = pd.Attributes.OfType <ColumnAttribute>().FirstOrDefault();
                                    if (clAttr != null)
                                    {
                                        obj.Order = clAttr.Order;
                                        if (!clAttr.Name.IsNullOrWhiteSpace())
                                        {
                                            obj.FieldName = clAttr.Name;
                                        }
                                    }
                                }
                            }
                            DisplayFormatAttribute dfAttr = pd.Attributes.OfType <DisplayFormatAttribute>().FirstOrDefault();
                            if (dfAttr != null && !dfAttr.DataFormatString.IsNullOrWhiteSpace())
                            {
                                obj.FormatText = dfAttr.DataFormatString;
                            }
                            if (dfAttr != null && !dfAttr.NullDisplayText.IsNullOrWhiteSpace())
                            {
                                obj.NullValue = dfAttr.NullDisplayText;
                            }
                            if (!KVPRecordFieldConfigurations.Any(c => c.Name == pd.Name))
                            {
                                KVPRecordFieldConfigurations.Add(obj);
                            }
                        }
                    }
                }
            }
        }
        private void DiscoverRecordFields(Type recordType, string declaringMember, bool optIn = false)
        {
            if (recordType == null)
            {
                return;
            }
            if (!recordType.IsDynamicType())
            {
                IsComplexXPathUsed = false;
                Type pt = null;
                if (optIn) //ChoTypeDescriptor.GetProperties(recordType).Where(pd => pd.Attributes.OfType<ChoXmlNodeRecordFieldAttribute>().Any()).Any())
                {
                    foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
                    {
                        pt = pd.PropertyType.GetUnderlyingType();
                        var  fa     = pd.Attributes.OfType <ChoXmlNodeRecordFieldAttribute>().FirstOrDefault();
                        bool optIn1 = fa == null || fa.UseXmlSerialization ? optIn : ChoTypeDescriptor.GetProperties(pt).Where(pd1 => pd1.Attributes.OfType <ChoXmlNodeRecordFieldAttribute>().Any()).Any();
                        if (false) //optIn1 && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt))
                        {
                            DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn1);
                        }
                        else if (pd.Attributes.OfType <ChoXmlNodeRecordFieldAttribute>().Any())
                        {
                            bool   useCache = true;
                            string xpath    = null;
                            ChoXmlNodeRecordFieldAttribute attr = ChoTypeDescriptor.GetPropetyAttribute <ChoXmlNodeRecordFieldAttribute>(pd);
                            if (attr.XPath.IsNullOrEmpty())
                            {
                                if (!attr.FieldName.IsNullOrWhiteSpace())
                                {
                                    attr.XPath = $"/{attr.FieldName}|/@{attr.FieldName}";
                                }
                                else
                                {
                                    attr.XPath = xpath = $"/{pd.Name}|/@{pd.Name}";
                                }
                                IsComplexXPathUsed = true;
                            }
                            else
                            {
                                useCache = false;
                            }

                            var obj = new ChoXmlRecordFieldConfiguration(pd.Name, attr, pd.Attributes.OfType <Attribute>().ToArray());
                            obj.FieldType          = pt;
                            obj.PropertyDescriptor = pd;
                            obj.DeclaringMember    = declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name);
                            obj.UseCache           = useCache;
                            if (obj.XPath.IsNullOrWhiteSpace())
                            {
                                if (!obj.FieldName.IsNullOrWhiteSpace())
                                {
                                    obj.XPath = $"/{obj.FieldName}|/@{obj.FieldName}";
                                }
                                else
                                {
                                    obj.XPath = $"/{obj.Name}|/@{obj.Name}";
                                }
                            }

                            obj.FieldType = pd.PropertyType.GetUnderlyingType();
                            if (!XmlRecordFieldConfigurations.Any(c => c.Name == pd.Name))
                            {
                                XmlRecordFieldConfigurations.Add(obj);
                            }
                        }
                    }
                }
                else
                {
                    foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
                    {
                        XmlIgnoreAttribute xiAttr = pd.Attributes.OfType <XmlIgnoreAttribute>().FirstOrDefault();
                        if (xiAttr != null)
                        {
                            continue;
                        }

                        pt = pd.PropertyType.GetUnderlyingType();
                        if (false) //pt != typeof(object) && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt))
                        {
                            DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn);
                        }
                        else
                        {
                            var obj = new ChoXmlRecordFieldConfiguration(pd.Name, $"/{pd.Name}|/@{pd.Name}");
                            obj.FieldType          = pt;
                            obj.PropertyDescriptor = pd;
                            obj.DeclaringMember    = declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name);
                            StringLengthAttribute slAttr = pd.Attributes.OfType <StringLengthAttribute>().FirstOrDefault();
                            if (slAttr != null && slAttr.MaximumLength > 0)
                            {
                                obj.Size = slAttr.MaximumLength;
                            }

                            XmlElementAttribute xAttr = pd.Attributes.OfType <XmlElementAttribute>().FirstOrDefault();
                            if (xAttr != null && !xAttr.ElementName.IsNullOrWhiteSpace())
                            {
                                obj.FieldName = xAttr.ElementName;
                            }
                            else
                            {
                                XmlAttributeAttribute xaAttr = pd.Attributes.OfType <XmlAttributeAttribute>().FirstOrDefault();
                                if (xAttr != null && !xaAttr.AttributeName.IsNullOrWhiteSpace())
                                {
                                    obj.FieldName = xaAttr.AttributeName;
                                }
                                else
                                {
                                    DisplayNameAttribute dnAttr = pd.Attributes.OfType <DisplayNameAttribute>().FirstOrDefault();
                                    if (dnAttr != null && !dnAttr.DisplayName.IsNullOrWhiteSpace())
                                    {
                                        obj.FieldName = dnAttr.DisplayName.Trim();
                                    }
                                    else
                                    {
                                        DisplayAttribute dpAttr = pd.Attributes.OfType <DisplayAttribute>().FirstOrDefault();
                                        if (dpAttr != null)
                                        {
                                            if (!dpAttr.ShortName.IsNullOrWhiteSpace())
                                            {
                                                obj.FieldName = dpAttr.ShortName;
                                            }
                                            else if (!dpAttr.Name.IsNullOrWhiteSpace())
                                            {
                                                obj.FieldName = dpAttr.Name;
                                            }

                                            obj.Order = dpAttr.Order;
                                        }
                                        else
                                        {
                                            ColumnAttribute clAttr = pd.Attributes.OfType <ColumnAttribute>().FirstOrDefault();
                                            if (clAttr != null)
                                            {
                                                obj.Order = clAttr.Order;
                                                if (!clAttr.Name.IsNullOrWhiteSpace())
                                                {
                                                    obj.FieldName = clAttr.Name;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                            DisplayFormatAttribute dfAttr = pd.Attributes.OfType <DisplayFormatAttribute>().FirstOrDefault();
                            if (dfAttr != null && !dfAttr.DataFormatString.IsNullOrWhiteSpace())
                            {
                                obj.FormatText = dfAttr.DataFormatString;
                            }
                            if (dfAttr != null && !dfAttr.NullDisplayText.IsNullOrWhiteSpace())
                            {
                                obj.NullValue = dfAttr.NullDisplayText;
                            }
                            if (!XmlRecordFieldConfigurations.Any(c => c.Name == pd.Name))
                            {
                                XmlRecordFieldConfigurations.Add(obj);
                            }
                        }
                    }
                }
            }
        }
        /// <summary>
        /// 创建 INSRT 命令
        /// </summary>
        /// <param name="tree">查询语义</param>
        /// <param name="context">解析SQL命令上下文</param>
        /// <returns></returns>
        protected override DbRawCommand TranslateInsertCommand <T>(DbQueryInsertTree tree, ITranslateContext context)
        {
            ISqlBuilder builder     = this.CreateSqlBuilder(context);;
            var         typeRuntime = TypeRuntimeInfoCache.GetRuntimeInfo <T>();

            if (tree.Entity != null)
            {
                // 如果没有Sequence列,使用 INSERT ALL INTO 语法,否则就一条一条逐行写入~~
                // 批量 INSERT,自增列不会自动赋值

                object      entity         = tree.Entity;
                ISqlBuilder columnsBuilder = this.CreateSqlBuilder(context);
                ISqlBuilder valuesBuilder  = this.CreateSqlBuilder(context);

                // 指定插入列
                var members = typeRuntime.Members;
                if (tree.EntityColumns != null && tree.EntityColumns.Count > 0)
                {
                    members = new MemberAccessorCollection();
                    for (int i = 0; i < tree.EntityColumns.Count; i++)
                    {
                        Expression curExpr = tree.EntityColumns[i];
                        if (curExpr.NodeType == ExpressionType.Lambda)
                        {
                            curExpr = (curExpr as LambdaExpression).Body.ReduceUnary();
                        }
                        if (curExpr.NodeType != ExpressionType.MemberAccess)
                        {
                            throw new XFrameworkException("Can't read field name from expression {0}", tree.EntityColumns[i]);
                        }

                        MemberExpression member = curExpr as MemberExpression;
                        string           name   = member.Member.Name;
                        members[name] = typeRuntime.Members[name];
                    }
                }

                // 自增列参数
                IDbDataParameter seqParameter = null;
                // 自增列标记
                ColumnAttribute seqColumn = null;
                foreach (var item in members)
                {
                    var m = item as FieldAccessorBase;
                    if (m == null || !m.IsDbField)
                    {
                        continue;
                    }

                    columnsBuilder.AppendMember(null, m.Member, typeRuntime.Type);
                    columnsBuilder.Append(',');

                    if (m == typeRuntime.Identity)
                    {
                        seqColumn = m.Column;
                        if (tree.Bulk == null)
                        {
                            // 非批量INSERT,产生一个 OUTPUT 类型的参数
                            string parameterName = string.Format("{0}{1}{2}", this.ParameterPrefix, AppConst.PARAMETER_NAME_PRIFIX, context.Parameters.Count);
                            seqParameter = this.DbProvider.CreateParameter(parameterName, -1, direction: ParameterDirection.Output);
                            context.Parameters.Add(seqParameter);
                            valuesBuilder.Append(seqParameter.ParameterName);
                            valuesBuilder.Append(',');
                        }
                        else
                        {
                            valuesBuilder.AppendMember(((OracleColumnAttribute)m.Column).SEQName);
                            valuesBuilder.Append(".NEXTVAL");
                            valuesBuilder.Append(',');
                        }
                    }
                    else
                    {
                        var    value         = m.Invoke(entity);
                        string sqlExpression = this.Constor.GetSqlValueWidthDefault(value, context, m.Column);
                        valuesBuilder.Append(sqlExpression);
                        valuesBuilder.Append(',');
                    }
                }
                columnsBuilder.Length -= 1;
                valuesBuilder.Length  -= 1;

                if (tree.Bulk == null)
                {
                    // 非批量INSERT,产生一个 OUTPUT 类型的参数
                    if (seqParameter != null)
                    {
                        seqParameter.Direction = ParameterDirection.Output;
                        seqParameter.DbType    = DbType.Int64;
                        builder.Append("SELECT ");
                        builder.AppendMember(((OracleColumnAttribute)seqColumn).SEQName);
                        builder.Append(".NEXTVAL INTO ");
                        builder.Append(seqParameter.ParameterName);
                        builder.Append(" FROM DUAL;");
                        builder.AppendNewLine();
                        //useSEQ = true;
                    }
                    builder.Append("INSERT ");
                }
                else
                {
                    // 批量 INSERT
                    if (!tree.Bulk.OnlyValue || seqColumn != null)
                    {
                        builder.Append("INSERT ");
                    }
                    // 如果有自增列则不使用 INSERT ALL INTO 语法
                    if (!tree.Bulk.OnlyValue && seqColumn == null)
                    {
                        builder.Append("ALL ");
                    }
                }

                builder.Append("INTO ");
                builder.AppendTable(typeRuntime.TableSchema, typeRuntime.TableName, typeRuntime.IsTemporary);
                builder.Append('(');
                builder.Append(columnsBuilder);
                builder.Append(')');
                builder.AppendNewLine();
                builder.AppendTab();
                builder.Append("VALUES");
                builder.Append('(');
                builder.Append(valuesBuilder);
                builder.Append(')');

                if (tree.Bulk == null)
                {
                    builder.Append(';');
                }
                else
                {
                    if (seqColumn != null)
                    {
                        if (tree.Bulk.IsEndPos)
                        {
                            builder.Append(";");
                        }
                        else
                        {
                            builder.AppendNewLine(";");
                        }
                    }
                    else
                    {
                        builder.AppendNewLine();
                        if (tree.Bulk.IsEndPos)
                        {
                            builder.Append("SELECT 1 FROM DUAL;");
                        }
                    }
                }
            }
            else if (tree.Select != null)
            {
                builder.Append("INSERT INTO ");
                builder.AppendTable(typeRuntime.TableSchema, typeRuntime.TableName, typeRuntime.IsTemporary);
                builder.Append('(');

                var srcExpressionType = context.CurrentExpressionType;
                var srcIsOutermost    = context.CurrentIsOutermost;
                context.CurrentExpressionType = DbExpressionType.Insert;
                context.CurrentIsOutermost    = false;

                var cmd = this.TranslateSelectCommand(tree.Select, 0, false, context) as DbSelectCommand;

                context.CurrentExpressionType = srcExpressionType;
                context.CurrentIsOutermost    = srcIsOutermost;

                int index = 0;
                foreach (var column in cmd.SelectedColumns)
                {
                    builder.AppendMember(column.Name);
                    if (index < cmd.SelectedColumns.Count - 1)
                    {
                        builder.Append(',');
                    }
                    index++;
                }

                builder.Append(')');
                builder.AppendNewLine();
                builder.Append(cmd.CommandText);
                builder.Append(';');
            }

            var result = new DbRawCommand(builder.ToString(), builder.TranslateContext != null ? builder.TranslateContext.Parameters : null, System.Data.CommandType.Text);

            return(result);
        }
Example #11
0
        /// <summary>
        /// Initializes a new instance of the <see cref="SqlTypeInfo"/> class.
        /// </summary>
        /// <param name="type">The table type.</param>
        /// <param name="adapter">The adapter used to generate SQL commands.</param>
        public SqlTypeInfo(Type type, ISqlAdapter adapter)
        {
            Type    = type;
            Adapter = adapter ?? SqlAdapter.GetAdapter(ExtraCrud.Dialect);
            TableAttribute tableAttr = type.GetCustomAttribute <TableAttribute>(false);
            BindingFlags   flags     = BindingFlags.Instance | BindingFlags.Public | BindingFlags.SetProperty | BindingFlags.NonPublic;

            // Determine the TableName, Adapter, and BindingFlags
            bool inherit = false;

            if (tableAttr == null)
            {
                var tableAttr2 = type.GetCustomAttribute <System.ComponentModel.DataAnnotations.Schema.TableAttribute>(false);
                if (tableAttr2 != null && !string.IsNullOrWhiteSpace(tableAttr2.Schema))
                {
                    TableName = tableAttr2.Name;
                    if (!string.IsNullOrWhiteSpace(tableAttr2.Schema))
                    {
                        Schema = tableAttr2.Schema.Trim();
                    }
                }
                else
                {
                    TableName = type.Name;
                }
            }
            else
            {
                TableName = string.IsNullOrWhiteSpace(tableAttr.Name) ? type.Name : tableAttr.Name;
                if (tableAttr.DeclaredOnly)
                {
                    flags      |= BindingFlags.DeclaredOnly;
                    Attributes |= SqlTableAttributes.DeclaredOnly;
                }
                if (tableAttr.InheritAttributes)
                {
                    inherit     = true;
                    Attributes |= SqlTableAttributes.InheritAttributes;
                }
                if (!string.IsNullOrWhiteSpace(tableAttr.Schema))
                {
                    Schema = tableAttr.Schema.Trim();
                }
            }
            FullyQualifiedTableName = TableName;
            if (Schema != null)
            {
                FullyQualifiedTableName = Schema + "." + TableName;
            }

            // Filter properties and iterate them for primary keys
            PropertyInfo[] properties      = type.GetProperties(flags);
            PropertyInfo[] validProperties = properties.Where(ExtraCrud.IsValidProperty).Where(prop => {
                return(prop.GetCustomAttribute <NotMappedAttribute>(inherit) == null &&
                       prop.GetCustomAttribute <System.ComponentModel.DataAnnotations.Schema.NotMappedAttribute>(inherit) == null);
            }).ToArray();
            if (!validProperties.Any())
            {
                throw new InvalidOperationException(type.FullName + " does not have any valid properties.");
            }
            ReadOnlyAttribute readOnlyAttr = type.GetCustomAttribute <ReadOnlyAttribute>(false);

            if (readOnlyAttr != null)
            {
                Attributes |= SqlTableAttributes.IgnoreInsert | SqlTableAttributes.IgnoreUpdate | SqlTableAttributes.IgnoreDelete;
            }
            else
            {
                var editableAttr = type.GetCustomAttribute <System.ComponentModel.DataAnnotations.EditableAttribute>(false);
                AutoSyncAttribute autoSyncAttr = type.GetCustomAttribute <AutoSyncAttribute>(false);
                if (autoSyncAttr != null)
                {
                    if (autoSyncAttr.SyncUpdate)
                    {
                        Attributes |= SqlTableAttributes.UpdateAutoSync;
                    }
                    if (autoSyncAttr.SyncInsert)
                    {
                        Attributes |= SqlTableAttributes.InsertAutoSync;
                    }
                }
                if (editableAttr != null)
                {
                    if (!editableAttr.AllowEdit)
                    {
                        Attributes |= SqlTableAttributes.IgnoreUpdate;
                    }
                    if (editableAttr.AllowInitialValue)
                    {
                        Attributes |= SqlTableAttributes.IgnoreInsert;
                    }
                }
                else
                {
                    IgnoreInsertAttribute noInserts = type.GetCustomAttribute <IgnoreInsertAttribute>(false);
                    if (noInserts != null)
                    {
                        Attributes |= SqlTableAttributes.IgnoreInsert;
                    }
                    IgnoreUpdateAttribute noUpdates = type.GetCustomAttribute <IgnoreUpdateAttribute>(false);
                    if (noUpdates != null)
                    {
                        Attributes |= SqlTableAttributes.IgnoreUpdate;
                    }
                }
                IgnoreDeleteAttribute noDeletes = type.GetCustomAttribute <IgnoreDeleteAttribute>(false);
                if (noDeletes != null)
                {
                    Attributes |= SqlTableAttributes.IgnoreDelete;
                }
            }

            // Determine primary key
            List <SqlColumn> keys    = new List <SqlColumn>();
            List <SqlColumn> columns = new List <SqlColumn>();
            int autoKeyCount         = 0;

            for (int i = 0; i < validProperties.Length; i++)
            {
                PropertyInfo    prop       = validProperties[i];
                string          columnName = null;
                ColumnAttribute columnAttr = prop.GetCustomAttribute <ColumnAttribute>(inherit);
                if (columnAttr != null)
                {
                    columnName = columnAttr.Name;
                }
                else
                {
                    var columnAttr2 = prop.GetCustomAttribute <System.ComponentModel.DataAnnotations.Schema.ColumnAttribute>(inherit);
                    if (columnAttr2 != null)
                    {
                        columnName = columnAttr2.Name;
                    }
                }
                string       propName = Adapter.QuoteIdentifier(prop.Name);
                SqlColumn    column   = new SqlColumn(prop, string.IsNullOrWhiteSpace(columnName) ? propName : Adapter.QuoteIdentifier(columnName), propName, i);
                KeyAttribute keyAttr  = prop.GetCustomAttribute <KeyAttribute>(inherit);
                if (keyAttr != null)
                {
                    if (keyAttr.AutoIncrement)
                    {
                        autoKeyCount++;
                    }
                    column.Attributes = keyAttr.AutoIncrement ? SqlColumnAttributes.AutoKey : SqlColumnAttributes.Key;
                }
                else
                {
                    var keyAttrCm = prop.GetCustomAttribute <System.ComponentModel.DataAnnotations.KeyAttribute>(inherit);
                    if (keyAttrCm != null)
                    {
                        var requiredAttr = prop.GetCustomAttribute <System.ComponentModel.DataAnnotations.RequiredAttribute>(inherit);
                        if (requiredAttr != null && ExtraCrud.IsValidAutoIncrementType(prop.PropertyType))
                        {
                            column.Attributes |= SqlColumnAttributes.Key;
                        }
                        else
                        {
                            column.Attributes |= SqlColumnAttributes.AutoKey;
                            autoKeyCount++;
                        }
                    }
                }
                if (column.IsKey)
                {
                    keys.Add(column);
                    if (!prop.CanRead || !prop.GetMethod.IsPublic || prop.GetMethod.IsStatic)
                    {
                        Attributes |= SqlTableAttributes.IgnoreInsert | SqlTableAttributes.IgnoreUpdate | SqlTableAttributes.IgnoreDelete;
                    }
                }
                columns.Add(column);
            }
            if (keys.Count == 0)
            {
                string    quotedId = Adapter.QuoteIdentifier("ID");
                SqlColumn key      = columns.FirstOrDefault(c => string.Equals(c.ColumnName, quotedId, StringComparison.OrdinalIgnoreCase));
                if (key == null)
                {
                    quotedId = Adapter.QuoteIdentifier(type.Name + "ID");
                    key      = columns.Where(c => c.ColumnName.Equals(quotedId, StringComparison.OrdinalIgnoreCase)).OrderByDescending(c => c.ColumnName.Contains(type.Name)).FirstOrDefault();
                }
                if (key != null)
                {
                    var requiredAttr = key.Property.GetCustomAttribute <System.ComponentModel.DataAnnotations.RequiredAttribute>(inherit);
                    if (requiredAttr == null)
                    {
                        key.Attributes |= SqlColumnAttributes.AutoKey;
                    }
                    else
                    {
                        key.Attributes |= SqlColumnAttributes.Key;
                    }
                    keys.Add(key);
                }
                else
                {
                    KeyColumns = Constants.SqlColumnsEmpty;
                }
            }
            if (keys.Count != 0)
            {
                KeyColumns = keys.ToArray();
                if (KeyColumns.Count == 1 && KeyColumns[0].IsAutoKey && ExtraCrud.IsValidAutoIncrementType(KeyColumns[0].Type))
                {
                    AutoKeyColumn = KeyColumns[0];
                }
                else if (autoKeyCount != 0 && KeyColumns.Count != autoKeyCount)
                {
                    throw new InvalidOperationException(Type.FullName + " cannot have a both a composite key and an autoincrement key.");
                }
                else
                {
                    // remove SqlColumnAttributes.AutoKey from all key columns
                    SqlColumnAttributes invertedAutoKey = ~(SqlColumnAttributes.AutoKey ^ SqlColumnAttributes.Key);
                    foreach (SqlColumn key in KeyColumns)
                    {
                        key.Attributes &= invertedAutoKey;
                    }
                }
            }

            foreach (SqlColumn column in columns.Where(c => !c.IsKey))
            {
                PropertyInfo prop = column.Property;

                bool selectOnly = !prop.CanRead || !prop.GetMethod.IsPublic || prop.GetMethod.IsStatic;
                if (selectOnly)
                {
                    column.Attributes |= SqlColumnAttributes.IgnoreInsert | SqlColumnAttributes.IgnoreUpdate | SqlColumnAttributes.IgnoreDelete;
                }

                // Selects
                IgnoreSelectAttribute selectAttr = prop.GetCustomAttribute <IgnoreSelectAttribute>(inherit);
                if (selectAttr != null)
                {
                    column.Attributes |= SqlColumnAttributes.IgnoreSelect;
                    if (selectOnly)
                    {
                        continue;
                    }
                }
                else if (selectOnly)
                {
                    continue;
                }
                else
                {
                    AutoSyncAttribute autoSyncAttr = prop.GetCustomAttribute <AutoSyncAttribute>(inherit);
                    if (autoSyncAttr != null)
                    {
                        if (autoSyncAttr.SyncInsert)
                        {
                            column.Attributes |= SqlColumnAttributes.InsertAutoSync;
                        }
                        if (autoSyncAttr.SyncUpdate)
                        {
                            column.Attributes |= SqlColumnAttributes.UpdateAutoSync;
                        }
                    }
                    if (InsertAutoSync)
                    {
                        column.Attributes |= SqlColumnAttributes.InsertAutoSync;
                    }
                    if (UpdateAutoSync)
                    {
                        column.Attributes |= SqlColumnAttributes.UpdateAutoSync;
                    }
                }

                // Deletes
                MatchDeleteAttribute deleteAttr = prop.GetCustomAttribute <MatchDeleteAttribute>(inherit);
                if (deleteAttr != null || IgnoreDelete)
                {
                    column.Attributes |= SqlColumnAttributes.IgnoreDelete;
                }

                readOnlyAttr = prop.GetCustomAttribute <ReadOnlyAttribute>(inherit);
                if (readOnlyAttr != null)
                {
                    column.Attributes |= SqlColumnAttributes.IgnoreInsert | SqlColumnAttributes.IgnoreUpdate;
                    continue;
                }
                var editableAttr = prop.GetCustomAttribute <System.ComponentModel.DataAnnotations.EditableAttribute>(inherit);
                if (editableAttr != null)
                {
                    if (!editableAttr.AllowInitialValue)
                    {
                        column.Attributes |= SqlColumnAttributes.IgnoreUpdate;
                    }
                    if (!editableAttr.AllowEdit)
                    {
                        column.Attributes |= SqlColumnAttributes.IgnoreUpdate;
                    }
                }

                // Inserts
                IgnoreInsertAttribute insertAttr = prop.GetCustomAttribute <IgnoreInsertAttribute>(inherit);
                if (insertAttr != null)
                {
                    column.Attributes |= SqlColumnAttributes.IgnoreInsert;
                    column.InsertValue = insertAttr.Value;
                    if (insertAttr.AutoSync)
                    {
                        column.Attributes |= SqlColumnAttributes.InsertAutoSync;
                    }
                }
                else if (IgnoreInsert)
                {
                    column.Attributes |= SqlColumnAttributes.IgnoreInsert;
                }

                // Updates
                IgnoreUpdateAttribute ignoreUpdateAttr = prop.GetCustomAttribute <IgnoreUpdateAttribute>(inherit);
                if (ignoreUpdateAttr != null)
                {
                    column.Attributes |= SqlColumnAttributes.IgnoreUpdate;
                    column.UpdateValue = ignoreUpdateAttr.Value;
                    if (ignoreUpdateAttr.AutoSync)
                    {
                        column.Attributes |= SqlColumnAttributes.UpdateAutoSync;
                    }
                }
                else if (IgnoreUpdate)
                {
                    column.Attributes = SqlColumnAttributes.IgnoreUpdate;
                }
                else
                {
                    MatchUpdateAttribute matchUpdateAttr = prop.GetCustomAttribute <MatchUpdateAttribute>(inherit);                    //NOTE: MatchUpdate != IgnoreUpdate
                    if (matchUpdateAttr != null)
                    {
                        column.Attributes |= SqlColumnAttributes.MatchUpdate;
                        column.UpdateValue = matchUpdateAttr.Value;
                        if (matchUpdateAttr.AutoSync)
                        {
                            column.Attributes |= SqlColumnAttributes.UpdateAutoSync;
                        }
                    }
                }
            }
            if (columns.Count == 0)
            {
                throw new InvalidOperationException(type.FullName + " does not have any valid properties.");                 // double check
            }
            Columns          = columns.ToArray();
            EqualityColumns  = KeyColumns.Count == 0 || KeyColumns.Count == Columns.Count ? Columns : KeyColumns;
            UpdateKeyColumns = Columns == EqualityColumns ? Constants.SqlColumnsEmpty : Columns.Where(c => c.IsKey || c.MatchUpdate).ToArray();
            DeleteKeyColumns = Columns == EqualityColumns ? Columns : Columns.Where(c => c.IsKey || c.MatchDelete).ToArray();
        }
Example #12
0
 public static void TypeName_Set_ReturnsExpected(string value)
 {
     ColumnAttribute attribute = new ColumnAttribute() { TypeName = value };
     Assert.Equal(value, attribute.TypeName);
 }
Example #13
0
        public void parse(object entity)
        {
            this._entity = entity;
            this._type   = entity.GetType();

            SetDBType();

            //获得实体的属性集合
            PropertyInfo[] props = _type.GetProperties();

            this.ParameterNames  = new List <String>(props.Length);
            this.ParameterValues = new List <Object>(props.Length);

            this.OutputNames  = new List <String>(props.Length);
            this.OutputValues = new List <Object>(props.Length);

            this.KeyNames  = new List <String>(1);
            this.KeyValues = new List <Object>(1);

            this.IsSqlServerIdentityTable = false;

            foreach (PropertyInfo prop in props)
            {
                string colName  = prop.Name;
                object colValue = prop.GetValue(entity, null);
                bool   isPK     = false;

                //if is keyattribute return key
                object[]        columnAttrs = prop.GetCustomAttributes(typeof(ColumnAttribute), true);
                ColumnAttribute colAttr     = null;
                if (columnAttrs.Length > 0)
                {
                    colAttr = columnAttrs[0] as ColumnAttribute;
                    if (colAttr.Name != null)
                    {
                        colName = colAttr.Name;
                    }
                    isPK = colAttr.IsPrimaryKey;

                    if (Object2SQL.TODO_INSERT == Todo)
                    {
                        if (ADOTemplate.DB_TYPE_SQLSERVER == this.dbType &&
                            colAttr.IsDbGenerated &&
                            !IsSqlServerIdentityTable)
                        {
                            IsSqlServerIdentityTable = true;
                            OutputNames.Add(colName);
                        }

                        // 如果是oracle时,如果有seq定义,则取seq
                        else if (ADOTemplate.DB_TYPE_ORACLE == this.dbType &&
                                 colAttr.Expression != null &&
                                 (colValue == null || colValue == (object)0))
                        {
                            String seqSql = String.Format("select {0}.nextval from dual", colAttr.Expression);

                            colValue = adoTemplate.GetLong(seqSql);
                            OutputNames.Add(colName);
                            OutputValues.Add(colValue);
                            // 设置获取的Seq值到属性中
                            // prop.SetValue(entity, colValue, null);
                        }
                    }

                    if (isPK)
                    {
                        this.KeyNames.Add(colName);
                        this.KeyValues.Add(colValue);
                    }
                    else
                    {
                        if (colValue != null || Object2SQL.TODO_UPDATE == Todo)
                        {
                            this.ParameterNames.Add(colName);
                            this.ParameterValues.Add(colValue);
                        }
                    }
                }
            }
        }
Example #14
0
 public SqlColumnBuilder(ColumnAttribute attribute)
 {
     Column = attribute;
 }
        /// <summary>
        /// 访问 ToString 方法
        /// </summary>
        /// <param name="node">即将访问的表达式</param>
        protected override Expression VisitToStringImpl(Expression node)
        {
            // => a.ID.ToString()
            // 字符串不进行转换
            if (node == null || node.Type == typeof(string))
            {
                return(_visitor.Visit(node));
            }

            // 其它类型转字符串
            bool isDate =
                node.Type == typeof(TimeSpan) ||
                node.Type == typeof(TimeSpan?) ||
                node.Type == typeof(DateTime) ||
                node.Type == typeof(DateTime?) ||
                node.Type == typeof(DateTimeOffset) ||
                node.Type == typeof(DateTimeOffset?);

            if (isDate)
            {
                _builder.Append("TO_CHAR(");
                _visitor.Visit(node);

                string          format = string.Empty;
                ColumnAttribute c      = _visitedMark.Current != null?TypeUtils.GetColumnAttribute(_visitedMark.Current.Member, _visitedMark.Current.ReflectedType) : null;

                if (c != null && NpgUtils.IsTime(c.DbType))
                {
                    format = "hh24:mi:ss.us";
                }
                else if (c != null && NpgUtils.IsDate(c.DbType))
                {
                    format = "yyyy-mm-dd";
                }
                else if (c != null && (NpgUtils.IsDateTime(c.DbType) || NpgUtils.IsDateTime2(c.DbType)))
                {
                    format = "yyyy-mm-dd hh24:mi:ss.us";
                }
                else if (c != null && NpgUtils.IsDateTimeOffset(c.DbType))
                {
                    format = "yyyy-mm-dd hh24:mi:ss.us TZH:TZM";
                }

                // 没有显式指定数据类型,则根据表达式的类型来判断
                if (string.IsNullOrEmpty(format))
                {
                    if (node.Type == typeof(TimeSpan) || node.Type == typeof(TimeSpan?))
                    {
                        format = "hh24:mi:ss.us";
                    }
                    else if (node.Type == typeof(DateTime) || node.Type == typeof(DateTime?))
                    {
                        format = "yyyy-mm-dd hh24:mi:ss.us";
                    }
                    else if (node.Type == typeof(DateTimeOffset) || node.Type == typeof(DateTimeOffset?))
                    {
                        format = "yyyy-mm-dd hh24:mi:ss.us TZH:TZM";
                    }
                }

                if (!string.IsNullOrEmpty(format))
                {
                    _builder.Append(",'");
                    _builder.Append(format);
                    _builder.Append("'");
                }
                _builder.Append(')');
            }
            else if (node.Type == typeof(byte[]))
            {
                _builder.Append("ENCODE(");
                _visitor.Visit(node);
                _builder.Append(",'hex')");
            }
            else
            {
                _builder.Append("CAST(");
                _visitor.Visit(node);
                _builder.Append(" AS VARCHAR)");
            }

            return(node);
        }
        public static string Convert(ColumnAttribute attr)
        {
            Types type;

            if (System.Enum.TryParse(attr.Type, out type))
            {
                switch (type)
                {
                case Types.Bool:
                    return("bool");

                case Types.Byte:
                    return("byte");

                case Types.Char:
                    return("char");

                case Types.DateTime:
                    return("DateTime");

                case Types.Double:
                    return("double");

                case Types.Float:
                    return("float");

                case Types.Int:
                    return("int");

                case Types.Long:
                    return("long");

                case Types.GID:
                    return("long");

                case Types.LID:
                    return("long");

                case Types.String:
                    return("string");

                case Types.Short:
                    return("short");

                case Types.UShort:
                    return("ushort");

                case Types.UInt:
                    return("uint");

                case Types.ULong:
                    return("ulong");

                default:
                    return("unknown type");
                }
            }
            else
            {
                List <string> enums = new List <string>();
                foreach (ModelType modelType in attr.DataGrid.ModelRoot.Types)
                {
                    if (!(modelType is ExternalType))
                    {
                        continue;
                    }
                    ExternalType typeEnum = modelType as ExternalType;
                    enums.Add(typeEnum.Name);
                }
                if (enums.Contains(attr.Type))
                {
                    return(attr.Type);
                }
            }
            return("unknown type");
        }
Example #17
0
        private void IntiailizeColumnAttribute(ColumnAttribute column)
        {
            alias = column.Alias;
            columnName = column.Name.HasValue() ? column.Name : member.Name;
            isComputed = column is ComputedColumnAttribute;
            sqlType = SqlType.Get(memberType, column);

            var id = column as IdAttribute;
            isPrimaryKey = id != null;
            if (id != null)
            {
                isGenerated = isPrimaryKey && id.IsDbGenerated;
                sequenceName = id.SequenceName;
            }

            isUpdatable = !isPrimaryKey && !isComputed;
            var version = column as VersionAttribute;
            if (version != null)
            {
                switch (sqlType.DbType)
                {
                    case DBType.Int16:
                    case DBType.Int32:
                    case DBType.Int64:
                        isVersion = true;
                        break;
                    default:
                        throw new MappingException(string.Format(Res.VersionMemberTypeInvalid, sqlType.DbType.ToString(), this.entity.entityType.Name + "." + member.Name));
                }
            }
        }
        private Globals.ResultType LoadDataMemberInformation(MemberInfo memberInfo, Type dataType, BindingFlags bindingFlags = BindingFlags.NonPublic | BindingFlags.Instance)
        {
            try
            {
                // Get Custom Attributes
                this.m_Attributes = memberInfo.GetCustomAttributes(false)
                                    .Select(attribute => (Attribute)attribute).ToList();

                // Get First Column Attribute
                ColumnAttribute columnAttribute = (ColumnAttribute)this.Attributes
                                                  .Where(attribute => attribute.GetType() == typeof(ColumnAttribute)).FirstOrDefault();

                // Validation
                if (columnAttribute == null)
                {
                    return(Globals.ResultType.Failure);
                }

                // Member Full Name
                this.m_FullName = memberInfo.Name;

                // Column Name
                this.m_ColumnName = columnAttribute.Name;

                // DataType
                this.m_DataType = dataType;

                // Sql DataType
                this.m_SqlDataType = DatabaseInformation.GetSqlTypeFromString(columnAttribute.DbType);

                // Nullable
                this.m_Nullable = columnAttribute.CanBeNull;

                // Is Primary Key
                this.m_IsPrimaryKey = columnAttribute.IsPrimaryKey;

                // Get First String Length Attribute
                StringLengthAttribute stringLengthAttribute = (StringLengthAttribute)this.Attributes
                                                              .Where(attribute => attribute.GetType() == typeof(StringLengthAttribute)).FirstOrDefault();

                // Validation
                if (stringLengthAttribute == null)
                {
                    return(Globals.ResultType.Success);
                }

                // Max Length
                this.m_FieldLength = stringLengthAttribute.MaximumLength;

                // Max Length Error Message
                this.m_FieldLengthErrorMessage = stringLengthAttribute.ErrorMessage;

                return(Globals.ResultType.Success);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());

                return(Globals.ResultType.Failure);
            }
        }
Example #19
0
 public static void TypeName_Set_NullOrWhitespaceValue_ThrowsArgumentException(string value)
 {
     ColumnAttribute attribute = new ColumnAttribute();
     Assert.Throws<ArgumentException>(null, () => attribute.TypeName = value);
 }
Example #20
0
        public void Initialize()
        {
            if (isInitialized)
            {
                return;
            }

            lock (this.initializeLock)
            {
                Dictionary <string, FieldInfo>    rowFields;
                Dictionary <string, PropertyInfo> rowProperties;
                GetRowFieldsAndProperties(out rowFields, out rowProperties);

                foreach (var fieldInfo in this.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public))
                {
                    if (fieldInfo.FieldType.IsSubclassOf(typeof(Field)))
                    {
                        var field = (Field)fieldInfo.GetValue(this);

                        PropertyInfo property;
                        if (!rowProperties.TryGetValue(fieldInfo.Name, out property))
                        {
                            property = null;
                        }

                        ColumnAttribute         column       = null;
                        DisplayNameAttribute    display      = null;
                        SizeAttribute           size         = null;
                        ExpressionAttribute     expression   = null;
                        ScaleAttribute          scale        = null;
                        MinSelectLevelAttribute selectLevel  = null;
                        ForeignKeyAttribute     foreignKey   = null;
                        LeftJoinAttribute       leftJoin     = null;
                        InnerJoinAttribute      innerJoin    = null;
                        DefaultValueAttribute   defaultValue = null;
                        TextualFieldAttribute   textualField = null;
                        DateTimeKindAttribute   dateTimeKind = null;

                        FieldFlags addFlags    = (FieldFlags)0;
                        FieldFlags removeFlags = (FieldFlags)0;

                        if (property != null)
                        {
                            column       = property.GetCustomAttribute <ColumnAttribute>(false);
                            display      = property.GetCustomAttribute <DisplayNameAttribute>(false);
                            size         = property.GetCustomAttribute <SizeAttribute>(false);
                            expression   = property.GetCustomAttribute <ExpressionAttribute>(false);
                            scale        = property.GetCustomAttribute <ScaleAttribute>(false);
                            selectLevel  = property.GetCustomAttribute <MinSelectLevelAttribute>(false);
                            foreignKey   = property.GetCustomAttribute <ForeignKeyAttribute>(false);
                            leftJoin     = property.GetCustomAttributes <LeftJoinAttribute>(false).FirstOrDefault(x => x.ToTable == null && x.OnCriteria == null);
                            innerJoin    = property.GetCustomAttributes <InnerJoinAttribute>(false).FirstOrDefault(x => x.ToTable == null && x.OnCriteria == null);
                            defaultValue = property.GetCustomAttribute <DefaultValueAttribute>(false);
                            textualField = property.GetCustomAttribute <TextualFieldAttribute>(false);
                            dateTimeKind = property.GetCustomAttribute <DateTimeKindAttribute>(false);

                            var insertable = property.GetCustomAttribute <InsertableAttribute>(false);
                            var updatable  = property.GetCustomAttribute <UpdatableAttribute>(false);

                            if (insertable != null && !insertable.Value)
                            {
                                removeFlags |= FieldFlags.Insertable;
                            }

                            if (updatable != null && !updatable.Value)
                            {
                                removeFlags |= FieldFlags.Updatable;
                            }

                            foreach (var attr in property.GetCustomAttributes <SetFieldFlagsAttribute>(false))
                            {
                                addFlags    |= attr.Add;
                                removeFlags |= attr.Remove;
                            }
                        }

                        if (ReferenceEquals(null, field))
                        {
                            if (property == null)
                            {
                                throw new InvalidProgramException(String.Format(
                                                                      "Field {0} in type {1} is null and has no corresponding property in entity!",
                                                                      fieldInfo.Name, rowType.Name));
                            }

                            object[] prm = new object[7];
                            prm[0] = this; // owner
                            prm[1] = column == null ? property.Name : (column.Name.TrimToNull() ?? property.Name);
                            prm[2] = display != null ? new LocalText(display.DisplayName) : null;
                            prm[3] = size != null ? size.Value : 0;
                            prm[4] = (FieldFlags.Default ^ removeFlags) | addFlags;
                            prm[5] = null;
                            prm[6] = null;

                            FieldInfo storage;
                            if (rowFields.TryGetValue("_" + property.Name, out storage) ||
                                rowFields.TryGetValue("m_" + property.Name, out storage) ||
                                rowFields.TryGetValue(property.Name, out storage))
                            {
                                prm[5] = CreateFieldGetMethod(storage);
                                prm[6] = CreateFieldSetMethod(storage);
                            }

                            field = (Field)Activator.CreateInstance(fieldInfo.FieldType, prm);
                            fieldInfo.SetValue(this, field);
                        }
                        else
                        {
                            if (size != null)
                            {
                                throw new InvalidProgramException(String.Format(
                                                                      "Field size '{0}' in type {1} can't be overridden by Size attribute!",
                                                                      fieldInfo.Name, rowType.Name));
                            }

                            if (display != null)
                            {
                                field.Caption = new LocalText(display.DisplayName);
                            }

                            if ((int)addFlags != 0 || (int)removeFlags != 0)
                            {
                                field.Flags = (field.Flags ^ removeFlags) | addFlags;
                            }

                            if (column != null && String.Compare(column.Name, field.Name, StringComparison.OrdinalIgnoreCase) != 0)
                            {
                                throw new InvalidProgramException(String.Format(
                                                                      "Field name '{0}' in type {1} can't be overridden by Column name attribute!",
                                                                      fieldInfo.Name, rowType.Name));
                            }
                        }

                        if (scale != null)
                        {
                            field.Scale = scale.Value;
                        }

                        if (defaultValue != null)
                        {
                            field.DefaultValue = defaultValue.Value;
                        }

                        if (selectLevel != null)
                        {
                            field.MinSelectLevel = selectLevel.Value;
                        }

                        if (expression != null)
                        {
                            field.Expression = expression.Value;
                        }

                        if (foreignKey != null)
                        {
                            field.ForeignTable = foreignKey.Table;
                            field.ForeignField = foreignKey.Field;
                        }

                        if (leftJoin != null)
                        {
                            field.ForeignJoinAlias = new LeftJoin(this.joins, field.ForeignTable, leftJoin.Alias,
                                                                  new Criteria(leftJoin.Alias, field.ForeignField) == new Criteria(field));
                        }

                        if (innerJoin != null)
                        {
                            field.ForeignJoinAlias = new InnerJoin(this.joins, field.ForeignTable, innerJoin.Alias,
                                                                   new Criteria(innerJoin.Alias, field.ForeignField) == new Criteria(field));
                        }

                        if (textualField != null)
                        {
                            field.textualField = textualField.Value;
                        }

                        if (dateTimeKind != null && field is DateTimeField)
                        {
                            ((DateTimeField)field).DateTimeKind = dateTimeKind.Value;
                        }

                        if (property != null)
                        {
                            if (property.PropertyType != null &&
                                field is IEnumTypeField)
                            {
                                if (property.PropertyType.IsEnum)
                                {
                                    (field as IEnumTypeField).EnumType = property.PropertyType;
                                }
                                else
                                {
                                    var nullableType = Nullable.GetUnderlyingType(property.PropertyType);
                                    if (nullableType != null && nullableType.IsEnum)
                                    {
                                        (field as IEnumTypeField).EnumType = nullableType;
                                    }
                                }
                            }

                            foreach (var attr in property.GetCustomAttributes <LeftJoinAttribute>())
                            {
                                if (attr.ToTable != null && attr.OnCriteria != null)
                                {
                                    new LeftJoin(this.joins, attr.ToTable, attr.Alias,
                                                 new Criteria(attr.Alias, attr.OnCriteria) == new Criteria(field));
                                }
                            }

                            foreach (var attr in property.GetCustomAttributes <InnerJoinAttribute>())
                            {
                                if (attr.ToTable != null && attr.OnCriteria != null)
                                {
                                    new InnerJoin(this.joins, attr.ToTable, attr.Alias,
                                                  new Criteria(attr.Alias, attr.OnCriteria) == new Criteria(field));
                                }
                            }

                            field.PropertyName = property.Name;
                            this.byPropertyName[field.PropertyName] = field;

                            field.CustomAttributes = property.GetCustomAttributes(false);
                        }
                    }
                }

                foreach (var attr in this.rowType.GetCustomAttributes <LeftJoinAttribute>())
                {
                    new LeftJoin(this.joins, attr.ToTable, attr.Alias, new Criteria(attr.OnCriteria));
                }

                foreach (var attr in this.rowType.GetCustomAttributes <InnerJoinAttribute>())
                {
                    new InnerJoin(this.joins, attr.ToTable, attr.Alias, new Criteria(attr.OnCriteria));
                }

                foreach (var attr in this.rowType.GetCustomAttributes <OuterApplyAttribute>())
                {
                    new OuterApply(this.joins, attr.InnerQuery, attr.Alias);
                }

                var propertyDescriptorArray = new PropertyDescriptor[this.Count];
                for (int i = 0; i < this.Count; i++)
                {
                    var field = this[i];
                    propertyDescriptorArray[i] = new FieldDescriptor(field);
                }

                this.propertyDescriptors = new PropertyDescriptorCollection(propertyDescriptorArray);

                InferTextualFields();
                AfterInitialize();
            }

            isInitialized = true;
        }
        private Type DiscoverRecordFields(Type recordType, string declaringMember, bool optIn = false,
                                          List <ChoJSONRecordFieldConfiguration> recordFieldConfigurations = null, bool isTop = false)
        {
            if (recordType == null)
            {
                return(recordType);
            }
            if (!recordType.IsDynamicType())
            {
                Type pt = null;
                if (ChoTypeDescriptor.GetProperties(recordType).Where(pd => pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any()).Any())
                {
                    foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
                    {
                        pt = pd.PropertyType.GetUnderlyingType();
                        bool optIn1 = ChoTypeDescriptor.GetProperties(pt).Where(pd1 => pd1.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any()).Any();
                        if (optIn1 && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt) && FlatToNestedObjectSupport)
                        {
                            DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn1, recordFieldConfigurations, false);
                        }
                        else if (pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().Any())
                        {
                            var obj = new ChoJSONRecordFieldConfiguration(pd.Name, pd.Attributes.OfType <ChoJSONRecordFieldAttribute>().First(), pd.Attributes.OfType <Attribute>().ToArray());
                            obj.FieldType          = pt;
                            obj.PropertyDescriptor = pd;
                            obj.DeclaringMember    = declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name);
                            if (recordFieldConfigurations != null)
                            {
                                if (!recordFieldConfigurations.Any(c => c.Name == pd.Name))
                                {
                                    recordFieldConfigurations.Add(obj);
                                }
                            }
                        }
                    }
                }
                else
                {
                    if (isTop)
                    {
                        if (typeof(IList).IsAssignableFrom(recordType) || (recordType.IsGenericType && recordType.GetGenericTypeDefinition() == typeof(IList <>)))
                        {
                            throw new ChoParserException("Record type not supported.");
                        }
                        else if (typeof(IDictionary <string, object>).IsAssignableFrom(recordType))
                        {
                            recordType = typeof(ExpandoObject);
                            return(recordType);
                        }
                        else if (typeof(IDictionary).IsAssignableFrom(recordType))
                        {
                            recordType = typeof(ExpandoObject);
                            return(recordType);
                        }
                    }

                    if (recordType.IsSimple())
                    {
                        var obj = new ChoJSONRecordFieldConfiguration("Value", "$.Value");
                        obj.FieldType = recordType;

                        recordFieldConfigurations.Add(obj);
                        return(recordType);
                    }

                    foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(recordType))
                    {
                        JsonIgnoreAttribute jiAttr = pd.Attributes.OfType <JsonIgnoreAttribute>().FirstOrDefault();
                        if (jiAttr != null)
                        {
                            continue;
                        }

                        pt = pd.PropertyType.GetUnderlyingType();
                        if (pt != typeof(object) && !pt.IsSimple() && !typeof(IEnumerable).IsAssignableFrom(pt) && FlatToNestedObjectSupport)
                        {
                            DiscoverRecordFields(pt, declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name), optIn, recordFieldConfigurations, false);
                        }
                        else
                        {
                            var obj = new ChoJSONRecordFieldConfiguration(pd.Name, ChoTypeDescriptor.GetPropetyAttribute <ChoJSONRecordFieldAttribute>(pd),
                                                                          pd.Attributes.OfType <Attribute>().ToArray());

                            obj.FieldType          = pt;
                            obj.PropertyDescriptor = pd;
                            obj.DeclaringMember    = declaringMember == null ? pd.Name : "{0}.{1}".FormatString(declaringMember, pd.Name);
                            StringLengthAttribute slAttr = pd.Attributes.OfType <StringLengthAttribute>().FirstOrDefault();
                            if (slAttr != null && slAttr.MaximumLength > 0)
                            {
                                obj.Size = slAttr.MaximumLength;
                            }
                            ChoUseJSONSerializationAttribute sAttr = pd.Attributes.OfType <ChoUseJSONSerializationAttribute>().FirstOrDefault();
                            if (sAttr != null)
                            {
                                obj.UseJSONSerialization = sAttr.Flag;
                            }
                            ChoJSONPathAttribute jpAttr = pd.Attributes.OfType <ChoJSONPathAttribute>().FirstOrDefault();
                            if (jpAttr != null)
                            {
                                obj.JSONPath = jpAttr.JSONPath;
                            }

                            JsonPropertyAttribute jAttr = pd.Attributes.OfType <JsonPropertyAttribute>().FirstOrDefault();
                            if (jAttr != null && !jAttr.PropertyName.IsNullOrWhiteSpace())
                            {
                                obj.FieldName = jAttr.PropertyName;
                                obj.JSONPath  = jAttr.PropertyName;
                                obj.Order     = jAttr.Order;
                            }
                            else
                            {
                                DisplayNameAttribute dnAttr = pd.Attributes.OfType <DisplayNameAttribute>().FirstOrDefault();
                                if (dnAttr != null && !dnAttr.DisplayName.IsNullOrWhiteSpace())
                                {
                                    obj.FieldName = dnAttr.DisplayName.Trim();
                                }
                                else
                                {
                                    DisplayAttribute dpAttr = pd.Attributes.OfType <DisplayAttribute>().FirstOrDefault();
                                    if (dpAttr != null)
                                    {
                                        if (!dpAttr.ShortName.IsNullOrWhiteSpace())
                                        {
                                            obj.FieldName = dpAttr.ShortName;
                                        }
                                        else if (!dpAttr.Name.IsNullOrWhiteSpace())
                                        {
                                            obj.FieldName = dpAttr.Name;
                                        }

                                        obj.Order = dpAttr.Order;
                                    }
                                    else
                                    {
                                        ColumnAttribute clAttr = pd.Attributes.OfType <ColumnAttribute>().FirstOrDefault();
                                        if (clAttr != null)
                                        {
                                            obj.Order = clAttr.Order;
                                            if (!clAttr.Name.IsNullOrWhiteSpace())
                                            {
                                                obj.FieldName = clAttr.Name;
                                            }
                                        }
                                    }
                                }
                            }
                            DisplayFormatAttribute dfAttr = pd.Attributes.OfType <DisplayFormatAttribute>().FirstOrDefault();
                            if (dfAttr != null && !dfAttr.DataFormatString.IsNullOrWhiteSpace())
                            {
                                obj.FormatText = dfAttr.DataFormatString;
                            }
                            if (dfAttr != null && !dfAttr.NullDisplayText.IsNullOrWhiteSpace())
                            {
                                obj.NullValue = dfAttr.NullDisplayText;
                            }

                            if (recordFieldConfigurations != null)
                            {
                                if (!recordFieldConfigurations.Any(c => c.Name == pd.Name))
                                {
                                    recordFieldConfigurations.Add(obj);
                                }
                            }
                        }
                    }
                }
            }
            return(recordType);
        }
Example #22
0
        /// <summary>
        /// Δημιουργεί ένα νέο αντικείμενο μεταδεδομένων στήλης / πεδίου οντότητας
        /// </summary>
        /// <param name="FieldInfo"></param>
        public ColumnMetadata(FieldInfo FieldInfo)
        {
            this.FieldInfo = FieldInfo ?? throw new ArgumentNullException(nameof(FieldInfo));

            this.FieldInfo = FieldInfo;
            this.FieldName = FieldInfo.Name;
            this.FieldType = FieldInfo.FieldType;

            //Get Attributes
            ColumnAttribute       column       = this.FieldInfo.GetCustomAttribute <ColumnAttribute>();
            CustomColumnAttribute customColumn = this.FieldInfo.GetCustomAttribute <CustomColumnAttribute>();

            ManyToOneAttribute manyToOne = this.FieldInfo.GetCustomAttribute <ManyToOneAttribute>();
            OneToManyAttribute oneToMany = this.FieldInfo.GetCustomAttribute <OneToManyAttribute>();

            if (column == null && customColumn == null && oneToMany == null)
            {
                throw new MetadataException("This field does not contain any Column information");
            }

            this.IsIdentifier = (this.FieldInfo.GetCustomAttribute <IdentityAttribute>() != null);

            if (column != null)
            {
                this.ColumnName = column.ColumnName;
                this.ColumnType = GetType(column.ColumnType);
                this.IsNullable = column.Nullable;
                this.IsUnique   = column.Unique;
            }
            if (customColumn != null)
            {
                this.IsCustomColumn = true;
                //This is hardcoded since our database names the column that stores the value "CustomFieldValue"
                this.ColumnName = "CustomFieldValue";
                this.ColumnType = GetType(customColumn.ColumnType);
                //Default values
                this.IsNullable = true;
                this.IsUnique   = false;

                this.CustomFieldTable     = customColumn.CustomTableName;
                this.CustomFieldId        = customColumn.CustomFieldId;
                this.CustomFieldReference = customColumn.IdentifierColumn;
            }
            if (manyToOne != null)
            {
                this.IsRelationship = true;
                this.TargetEntity   = manyToOne.TargetEntity;
                this.RelationshipReferenceColumn = manyToOne.IdentifierColumn;
                this.RelationshipType            = RelationshipType.ManyToOne;
            }
            if (oneToMany != null)
            {
                this.IsRelationship = true;
                this.TargetEntity   = oneToMany.TargetEntity;
                this.RelationshipReferenceColumn = oneToMany.IdentifierColumn;
                this.RelationshipType            = RelationshipType.OneToMany;
            }
            //ADDED Row Guid
            this.IsRowGuid = (this.FieldInfo.GetCustomAttribute <GuidAttribute>() != null);

            var version = this.FieldInfo.GetCustomAttribute <VersionAttribute>();

            IsVersion = (version != null);
        }
Example #23
0
        public override string CreateColumnQuery(PropertyInfo property, ColumnAttribute column)
        {
            var type   = column.Type ?? property.PropertyType;
            var name   = property.Name;
            var result = new StringBuilder(string.Format(" {0} ", name));

            // Тип данных

            if (type == typeof(XmlDocument))
            {
                result.Append("xml");
            }
            else if (type == typeof(object))
            {
                result.Append("sql_variant");
            }
            else if (type == typeof(Guid))
            {
                result.Append("uniqueidentifier");
            }
            else if (type == typeof(DateTime))
            {
                result.Append("datetime2");
            }
            else if (type == typeof(DateTime?))
            {
                result.Append("datetime2");
            }
            else if (type == typeof(int))
            {
                result.Append("int");
            }
            else if (type == typeof(int?))
            {
                result.Append("int");
            }
            else if (type == typeof(long))
            {
                result.Append("bigint");
            }
            else if (type == typeof(long?))
            {
                result.Append("bigint");
            }
            else if (type == typeof(float))
            {
                result.Append("float");
            }
            else if (type == typeof(float?))
            {
                result.Append("float");
            }
            else if (type == typeof(decimal))
            {
                result.Append("real");
            }
            else if (type == typeof(decimal?))
            {
                result.Append("real");
            }
            else if (type == typeof(string))
            {
                result.AppendFormat("nvarchar({0})", column.Size);
            }
            else if (type == typeof(bool))
            {
                result.Append("bit");
            }
            else if (type == typeof(bool?))
            {
                result.Append("bit");
            }
            else if (type.IsEnum)
            {
                result.Append("int");
            }
            else
            {
                throw new Exception("Неизвестный тип данных");
            }

            // Ограничения

            if (column.Primary)
            {
                result.Append(" PRIMARY KEY");
            }
            if (column.AutoIncrement)
            {
                result.Append(" IDENTITY");
            }
            if (column.Unique)
            {
                result.Append(" UNIQUE");
            }
            if (column.NotNull)
            {
                result.Append(" NOT NULL");
            }
            if (!string.IsNullOrEmpty(column.Default))
            {
                result.AppendFormat(" DEFAULT {0}", column.Default);
            }

            // Результат

            return(result.ToString());
        }
Example #24
0
    public static ILogins Parse(DataRow row, Type type)
    {
        object res = Activator.CreateInstance(type);

        if (type.IsClass)
        {
            PropertyInfo[] pis = type.GetProperties();
            foreach (PropertyInfo pi in pis)
            {
                ColumnAttribute attr = pi.GetCustomAttribute <ColumnAttribute>();
                if (attr == null)
                {
                    continue;
                }

                string columnName = attr.Name;
                if (!row.Table.Columns.Contains(columnName))
                {
                    Console.WriteLine(string.Format("Parse: missed column name {0}", columnName));
                    continue;
                }

                object value = row[columnName];
                if (value is DBNull)
                {
                    pi.SetValue(res, null);
                }
                else
                {
                    pi.SetValue(res, value);
                }
            }
        }
        else
        {
            TypedReference reference = __makeref(res);

            FieldInfo[] fis = type.GetFields();
            foreach (FieldInfo fi in fis)
            {
                ColumnAttribute attr = fi.GetCustomAttribute <ColumnAttribute>();
                if (attr == null)
                {
                    continue;
                }

                string columnName = attr.Name;
                if (!row.Table.Columns.Contains(columnName))
                {
                    Console.WriteLine(string.Format("Parse: missed column name {0}", columnName));
                    continue;
                }

                object value = row[columnName];
                if (value is DBNull)
                {
                    fi.SetValueDirect(reference, null);
                }
                else
                {
                    fi.SetValueDirect(reference, value);
                }
            }
        }

        return(res as ILogins);
    }
Example #25
0
        public TypeSchema(Type type)
        {
            this.type       = type;
            propertySchemas = new Hashtable();
            parentSchemas   = new Hashtable();
            childSchemas    = new Hashtable();

            Trace.WriteLineIf(DebugOutput.Enabled, "Creating TypeSchema for " + type.FullName);

            if (!type.IsSubclassOf(typeof(ServerObject)))
            {
                throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "{0} is not a subclass of ServerObject.", type.FullName));
            }

            if (type.GetCustomAttributes(typeof(TableAttribute), false).Length != 1)
            {
                throw new ObjectServerException("Could not locate TableAttribute on type " + type.FullName);
            }

            if (!type.IsAbstract)
            {
                throw new ObjectServerException(type.FullName + " is not an abstract class");
            }

            tableData = (TableAttribute)type.GetCustomAttributes(typeof(TableAttribute), false)[0];

            Debug.Indent();
            Trace.WriteLineIf(DebugOutput.Enabled, "TableName = " + tableData.TableName);
            Trace.WriteLineIf(DebugOutput.Enabled, "PrimaryKey = " + tableData.PrimaryKey);
            Trace.WriteLineIf(DebugOutput.Enabled, "PrimaryKeyType = " + tableData.KeyType);
            Trace.WriteLineIf(DebugOutput.Enabled, "DefaultOrder = " + tableData.DefaultOrder);
            Debug.Unindent();

            PropertyInfo keyProperty = type.GetProperty(tableData.PrimaryKey, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

            if (keyProperty == null)
            {
                throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "Could not locate the property {0} which is defined as the property for {1}", tableData.PrimaryKey, type.FullName));
            }

            if (tableData.KeyType == PrimaryKeyType.Identity && keyProperty.PropertyType != typeof(int))
            {
                throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "KeyType equals PrimaryKeyType.Identity and the property {0}.{1} is not System.Int32", type.FullName, keyProperty.Name));
            }

            if (tableData.KeyType == PrimaryKeyType.Guid && keyProperty.PropertyType != typeof(Guid))
            {
                throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "KeyType equals PrimaryKeyType.Guid and the property {0}.{1} is not System.Guid", type.FullName, keyProperty.Name));
            }

            foreach (PropertyInfo propInfo in type.GetProperties(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance))
            {
                Trace.WriteLineIf(DebugOutput.Enabled, "Checking property " + propInfo.Name);

                if (propInfo.GetCustomAttributes(typeof(ColumnAttribute), false).Length == 1)
                {
                    if (propInfo.GetIndexParameters().Length != 0)
                    {
                        throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "Index properties ({0}.{1}) cannot be attributed with ColumnAttribute", type.FullName, propInfo.Name));
                    }

                    if (!propInfo.CanRead)
                    {
                        throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "{0}.{1} must have an accessor", type.FullName, propInfo.Name));
                    }

                    if (!propInfo.GetGetMethod(true).IsAbstract)
                    {
                        throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "{0}.{1} must be abstract", type.FullName, propInfo.Name));
                    }

                    ColumnAttribute columnData = (ColumnAttribute)propInfo.GetCustomAttributes(typeof(ColumnAttribute), false)[0];

                    Debug.Indent();
                    Trace.WriteLineIf(DebugOutput.Enabled, "ColumnName = " + columnData.ColumnName);;
                    Trace.WriteLineIf(DebugOutput.Enabled, "NullValue = " + columnData.NullValue);
                    Debug.Unindent();

                    if (propInfo.Name == tableData.PrimaryKey && columnData.NullValue != null)
                    {
                        throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "{0}.{1} is marked as the Primary Key and cannot have a NullValue", type.FullName, propInfo.Name));
                    }

                    propertySchemas.Add(propInfo.Name, new PropertySchema(this, propInfo, columnData));
                }
                else if (propInfo.GetCustomAttributes(typeof(ParentAttribute), false).Length == 1)
                {
                    if (propInfo.GetIndexParameters().Length != 0)
                    {
                        throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "Index properties ({0}.{1}) cannot be attributed with ParentAttribute", type.FullName, propInfo.Name));
                    }

                    if (!propInfo.CanRead)
                    {
                        throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "{0}.{1} must have an accessor", type.FullName, propInfo.Name));
                    }

                    if (!propInfo.GetGetMethod(true).IsAbstract)
                    {
                        throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "{0}.{1} must be abstract", type.FullName, propInfo.Name));
                    }

                    ParentAttribute parentData = (ParentAttribute)propInfo.GetCustomAttributes(typeof(ParentAttribute), false)[0];

                    if (parentData.DeleteAction == DeleteAction.Null && !parentData.CanBeNull)
                    {
                        throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "{0}.{1} has DeleteAction.Null and CanBeNull is false", type.FullName, propInfo.Name));
                    }

                    Debug.Indent();
                    Trace.WriteLineIf(DebugOutput.Enabled, "ColumnName = " + parentData.ColumnName);
                    Trace.WriteLineIf(DebugOutput.Enabled, "ActionOnDelete = " + parentData.DeleteAction);
                    Debug.Unindent();

                    parentSchemas.Add(propInfo.Name, new ParentSchema(this, propInfo, parentData));
                }
                else if (propInfo.GetCustomAttributes(typeof(ChildrenAttribute), false).Length == 1)
                {
                    if (propInfo.GetIndexParameters().Length != 0)
                    {
                        throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "Index properties ({0}.{1}) cannot be attributed with ChildrenAttribute", type.FullName, propInfo.Name));
                    }

                    if (!propInfo.CanRead)
                    {
                        throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "{0}.{1} must have an accessor", type.FullName, propInfo.Name));
                    }

                    if (propInfo.CanWrite)
                    {
                        throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "{0}.{1} must be read only", type.FullName, propInfo.Name));
                    }

                    if (!propInfo.GetGetMethod(true).IsAbstract)
                    {
                        throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "{0}.{1} must be abstract", type.FullName, propInfo.Name));
                    }

                    if (propInfo.PropertyType != typeof(ServerObjectCollection))
                    {
                        throw new ObjectServerException(String.Format(CultureInfo.CurrentCulture, "{0}.{1} must be of type ServerObjectCollection", type.FullName, propInfo.Name));
                    }

                    ChildrenAttribute childData = (ChildrenAttribute)propInfo.GetCustomAttributes(typeof(ChildrenAttribute), false)[0];

                    Debug.Indent();
                    Trace.WriteLineIf(DebugOutput.Enabled, "ChildType = " + childData.ChildType.FullName);
                    Trace.WriteLineIf(DebugOutput.Enabled, "PropertyName = " + childData.PropertyName);
                    Debug.Unindent();

                    childSchemas.Add(propInfo.Name, new ChildrenSchema(this, propInfo, childData));
                }
            }

            proxyType = ProxyBuilder.BuildProxy(type);
        }
 private static void AppendColumnEqParameter(StringBuilder sqlBuilder, DbProvider dbProvider, ColumnAttribute column)
 {
     sqlBuilder.AppendFormat("{0}{1}{2}={3}{4}", dbProvider.ParameterNamePrefix, column.Name, dbProvider.ParameterNameSuffix, dbProvider.ParameterPrefix, column.Property.Name);
 }
Example #27
0
        public ColumnAttribute GetEntityColumnAttribute(Type type, PropertyInfo proto)
        {
            ColumnAttribute attr = null;

            if (_orm.Aop.ConfigEntityPropertyHandler != null)
            {
                var aope = new Aop.ConfigEntityPropertyEventArgs(type, proto);
                _orm.Aop.ConfigEntityPropertyHandler(_orm, aope);
                attr = aope.ModifyResult;
            }
            if (attr == null)
            {
                attr = new ColumnAttribute();
            }
            if (dicConfigEntity.TryGetValue(type, out var trytb) && trytb._columns.TryGetValue(proto.Name, out var trycol))
            {
                if (!string.IsNullOrEmpty(trycol.Name))
                {
                    attr.Name = trycol.Name;
                }
                if (!string.IsNullOrEmpty(trycol.OldName))
                {
                    attr.OldName = trycol.OldName;
                }
                if (!string.IsNullOrEmpty(trycol.DbType))
                {
                    attr.DbType = trycol.DbType;
                }
                if (trycol._IsPrimary != null)
                {
                    attr._IsPrimary = trycol.IsPrimary;
                }
                if (trycol._IsIdentity != null)
                {
                    attr._IsIdentity = trycol.IsIdentity;
                }
                if (trycol._IsNullable != null)
                {
                    attr._IsNullable = trycol.IsNullable;
                }
                if (trycol._IsIgnore != null)
                {
                    attr._IsIgnore = trycol.IsIgnore;
                }
                if (trycol._IsVersion != null)
                {
                    attr._IsVersion = trycol.IsVersion;
                }
                if (trycol.MapType != null)
                {
                    attr.MapType = trycol.MapType;
                }
                if (trycol._Position != null)
                {
                    attr._Position = trycol.Position;
                }
                if (trycol._CanInsert != null)
                {
                    attr._CanInsert = trycol.CanInsert;
                }
                if (trycol._CanUpdate != null)
                {
                    attr._CanUpdate = trycol.CanUpdate;
                }
                if (trycol.ServerTime != DateTimeKind.Unspecified)
                {
                    attr.ServerTime = trycol.ServerTime;
                }
                if (trycol._StringLength != null)
                {
                    attr.StringLength = trycol.StringLength;
                }
                if (!string.IsNullOrEmpty(trycol.InsertValueSql))
                {
                    attr.InsertValueSql = trycol.InsertValueSql;
                }
                if (trycol._Precision != null)
                {
                    attr.Precision = trycol.Precision;
                }
                if (trycol._Scale != null)
                {
                    attr.Scale = trycol.Scale;
                }
            }
            var attrs = proto.GetCustomAttributes(typeof(ColumnAttribute), false);

            foreach (var tryattrobj in attrs)
            {
                var tryattr = tryattrobj as ColumnAttribute;
                if (tryattr == null)
                {
                    continue;
                }
                if (!string.IsNullOrEmpty(tryattr.Name))
                {
                    attr.Name = tryattr.Name;
                }
                if (!string.IsNullOrEmpty(tryattr.OldName))
                {
                    attr.OldName = tryattr.OldName;
                }
                if (!string.IsNullOrEmpty(tryattr.DbType))
                {
                    attr.DbType = tryattr.DbType;
                }
                if (tryattr._IsPrimary != null)
                {
                    attr._IsPrimary = tryattr.IsPrimary;
                }
                if (tryattr._IsIdentity != null)
                {
                    attr._IsIdentity = tryattr.IsIdentity;
                }
                if (tryattr._IsNullable != null)
                {
                    attr._IsNullable = tryattr.IsNullable;
                }
                if (tryattr._IsIgnore != null)
                {
                    attr._IsIgnore = tryattr.IsIgnore;
                }
                if (tryattr._IsVersion != null)
                {
                    attr._IsVersion = tryattr.IsVersion;
                }
                if (tryattr.MapType != null)
                {
                    attr.MapType = tryattr.MapType;
                }
                if (tryattr._Position != null)
                {
                    attr._Position = tryattr.Position;
                }
                if (tryattr._CanInsert != null)
                {
                    attr._CanInsert = tryattr.CanInsert;
                }
                if (tryattr._CanUpdate != null)
                {
                    attr._CanUpdate = tryattr.CanUpdate;
                }
                if (tryattr.ServerTime != DateTimeKind.Unspecified)
                {
                    attr.ServerTime = tryattr.ServerTime;
                }
                if (tryattr._StringLength != null)
                {
                    attr.StringLength = tryattr.StringLength;
                }
                if (!string.IsNullOrEmpty(tryattr.InsertValueSql))
                {
                    attr.InsertValueSql = tryattr.InsertValueSql;
                }
                if (tryattr._Precision != null)
                {
                    attr.Precision = tryattr.Precision;
                }
                if (tryattr._Scale != null)
                {
                    attr.Scale = tryattr.Scale;
                }
            }
            ColumnAttribute ret = null;

            if (!string.IsNullOrEmpty(attr.Name))
            {
                ret = attr;
            }
            if (!string.IsNullOrEmpty(attr.OldName))
            {
                ret = attr;
            }
            if (!string.IsNullOrEmpty(attr.DbType))
            {
                ret = attr;
            }
            if (attr._IsPrimary != null)
            {
                ret = attr;
            }
            if (attr._IsIdentity != null)
            {
                ret = attr;
            }
            if (attr._IsNullable != null)
            {
                ret = attr;
            }
            if (attr._IsIgnore != null)
            {
                ret = attr;
            }
            if (attr._IsVersion != null)
            {
                ret = attr;
            }
            if (attr.MapType != null)
            {
                ret = attr;
            }
            if (attr._Position != null)
            {
                ret = attr;
            }
            if (attr._CanInsert != null)
            {
                ret = attr;
            }
            if (attr._CanUpdate != null)
            {
                ret = attr;
            }
            if (attr.ServerTime != DateTimeKind.Unspecified)
            {
                ret = attr;
            }
            if (attr._StringLength != null)
            {
                ret = attr;
            }
            if (!string.IsNullOrEmpty(attr.InsertValueSql))
            {
                ret = attr;
            }
            if (attr._Precision != null)
            {
                ret = attr;
            }
            if (attr._Scale != null)
            {
                ret = attr;
            }
            if (ret != null && ret.MapType == null)
            {
                ret.MapType = proto.PropertyType;
            }
            return(ret);
        }
Example #28
0
        // 创建 INSRT 命令
        protected override Command ResolveInsertCommand <T>(DbQueryableInfo_Insert <T> dbQuery, ResolveToken token)
        {
            ISqlBuilder     builder     = this.CreateSqlBuilder(token);
            TypeRuntimeInfo typeRuntime = TypeRuntimeInfoCache.GetRuntimeInfo <T>();
            TableAliasCache aliases     = new TableAliasCache();

            if (dbQuery.Entity != null)
            {
                // 如果没有Sequence列,使用 INSERT ALL INTO 语法,否则就一条一条逐行写入~~
                // 批量 INSERT,自增列不会自动赋值

                object      entity         = dbQuery.Entity;
                ISqlBuilder columnsBuilder = this.CreateSqlBuilder(token);
                ISqlBuilder valuesBuilder  = this.CreateSqlBuilder(token);

                // 指定插入列
                MemberInvokerCollection invokers = typeRuntime.Invokers;
                if (dbQuery.EntityColumns != null && dbQuery.EntityColumns.Count > 0)
                {
                    invokers = new MemberInvokerCollection();
                    for (int i = 0; i < dbQuery.EntityColumns.Count; i++)
                    {
                        Expression curExpr = dbQuery.EntityColumns[i];
                        if (curExpr.NodeType == ExpressionType.Lambda)
                        {
                            curExpr = (curExpr as LambdaExpression).Body.ReduceUnary();
                        }
                        if (curExpr.NodeType != ExpressionType.MemberAccess)
                        {
                            throw new XFrameworkException("Can't read field name from expression {0}", dbQuery.EntityColumns[i]);
                        }

                        MemberExpression member = curExpr as MemberExpression;
                        string           name   = member.Member.Name;
                        invokers[name] = typeRuntime.Invokers[name];
                    }
                }

                // 自增列参数
                IDbDataParameter seqParameter = null;
                // 自增列标记
                ColumnAttribute seqColumn = null;
                foreach (var invoker in invokers)
                {
                    var column = invoker.Column;
                    if (column != null && column.NoMapped)
                    {
                        continue;
                    }
                    if (invoker.ForeignKey != null)
                    {
                        continue;
                    }
                    if (invoker.Member.MemberType == System.Reflection.MemberTypes.Method)
                    {
                        continue;
                    }

                    columnsBuilder.AppendMember(invoker.Member.Name);
                    columnsBuilder.Append(',');

                    if (invoker == dbQuery.AutoIncrement)
                    {
                        seqColumn = column;
                        if (dbQuery.Bulk == null)
                        {
                            // 非批量INSERT,产生一个 OUTPUT 类型的参数
                            string pName    = string.Format("{0}p{1}", this.ParameterPrefix, token.Parameters.Count);
                            var    database = dbQuery.SourceQuery.DbContext.Database;
                            seqParameter = database.CreateParameter(pName, -1, direction: ParameterDirection.Output);
                            token.Parameters.Add(seqParameter);
                            valuesBuilder.Append(seqParameter.ParameterName);
                            valuesBuilder.Append(',');
                        }
                        else
                        {
                            valuesBuilder.Append(((OracleColumnAttribute)column).SEQName);
                            valuesBuilder.Append(".NEXTVAL");
                            valuesBuilder.Append(',');
                        }
                    }
                    else
                    {
                        var    value = invoker.Invoke(entity);
                        string seg   = this.DbValue.GetSqlValueWidthDefault(value, token, column);
                        valuesBuilder.Append(seg);
                        valuesBuilder.Append(',');
                    }
                }
                columnsBuilder.Length -= 1;
                valuesBuilder.Length  -= 1;

                if (dbQuery.Bulk == null)
                {
                    // 非批量INSERT,产生一个 OUTPUT 类型的参数
                    if (seqParameter != null)
                    {
                        seqParameter.Direction = ParameterDirection.Output;
                        seqParameter.DbType    = DbType.Int64;
                        builder.Append("SELECT ");
                        builder.Append(((OracleColumnAttribute)seqColumn).SEQName);
                        builder.Append(".NEXTVAL INTO ");
                        builder.Append(seqParameter.ParameterName);
                        builder.Append(" FROM DUAL;");
                        builder.AppendNewLine();
                        //useSEQ = true;
                    }
                    builder.Append("INSERT ");
                }
                else
                {
                    // 批量 INSERT
                    if (!dbQuery.Bulk.OnlyValue || seqColumn != null)
                    {
                        builder.Append("INSERT ");
                    }
                    // 如果有自增列则不使用 INSERT ALL INTO 语法
                    if (!dbQuery.Bulk.OnlyValue && seqColumn == null)
                    {
                        builder.Append("ALL ");
                    }
                }

                builder.Append("INTO ");
                builder.AppendMember(typeRuntime.TableName, !typeRuntime.IsTemporary);
                builder.Append('(');
                builder.Append(columnsBuilder);
                builder.Append(')');
                builder.AppendNewLine();
                builder.AppendNewTab();
                builder.Append("VALUES");
                builder.Append('(');
                builder.Append(valuesBuilder);
                builder.Append(')');

                if (dbQuery.Bulk == null)
                {
                    builder.Append(';');
                }
                else
                {
                    if (seqColumn != null)
                    {
                        if (dbQuery.Bulk.IsEndPos)
                        {
                            builder.Append(";");
                        }
                        else
                        {
                            builder.AppendNewLine(";");
                        }
                    }
                    else
                    {
                        builder.AppendNewLine();
                        if (dbQuery.Bulk.IsEndPos)
                        {
                            builder.Append("SELECT 1 FROM DUAL;");
                        }
                    }
                }
            }
            else if (dbQuery.SelectInfo != null)
            {
                builder.Append("INSERT INTO ");
                builder.AppendMember(typeRuntime.TableName, !typeRuntime.IsTemporary);
                builder.Append('(');

                int           i    = 0;
                MapperCommand cmd2 = this.ResolveSelectCommand(dbQuery.SelectInfo, 0, false, token) as MapperCommand;
                foreach (var column in cmd2.PickColumns)
                {
                    builder.AppendMember(column.Name);
                    if (i < cmd2.PickColumns.Count - 1)
                    {
                        builder.Append(',');
                    }
                    i++;
                }

                builder.Append(')');
                builder.AppendNewLine();
                builder.Append(cmd2.CommandText);
                builder.Append(';');
            }

            var cmd = new Command(builder.ToString(), builder.Token != null ? builder.Token.Parameters : null, System.Data.CommandType.Text);

            return(cmd);
        }
Example #29
0
        internal static TableInfo GetTableByEntity(Type entity, CommonUtils common)
        {
            if (entity.FullName.StartsWith("<>f__AnonymousType"))
            {
                return(null);
            }
            if (_cacheGetTableByEntity.TryGetValue($"{common.QuoteSqlName("db")}{entity.FullName}", out var trytb))
            {
                return(trytb);                                                                                                                //区分数据库类型缓存
            }
            if (common.CodeFirst.GetDbInfo(entity) != null)
            {
                return(null);
            }

            var tbattr = entity.GetCustomAttributes(typeof(TableAttribute), false).LastOrDefault() as TableAttribute;

            trytb            = new TableInfo();
            trytb.Type       = entity;
            trytb.Properties = entity.GetProperties().ToDictionary(a => a.Name, a => a, StringComparer.CurrentCultureIgnoreCase);
            trytb.CsName     = entity.Name;
            trytb.DbName     = (tbattr?.Name ?? entity.Name);
            trytb.DbOldName  = tbattr?.OldName;
            if (common.CodeFirst.IsSyncStructureToLower)
            {
                trytb.DbName    = trytb.DbName.ToLower();
                trytb.DbOldName = trytb.DbOldName?.ToLower();
            }
            trytb.SelectFilter = tbattr?.SelectFilter;
            foreach (var p in trytb.Properties.Values)
            {
                var tp = common.CodeFirst.GetDbInfo(p.PropertyType);
                //if (tp == null) continue;
                var colattr = p.GetCustomAttributes(typeof(ColumnAttribute), false).LastOrDefault() as ColumnAttribute;
                if (tp == null && colattr == null)
                {
                    continue;
                }
                if (colattr == null)
                {
                    colattr = new ColumnAttribute {
                        Name       = p.Name,
                        DbType     = tp.Value.dbtypeFull,
                        IsIdentity = false,
                        IsNullable = tp.Value.isnullable ?? true,
                        IsPrimary  = false,
                    }
                }
                ;
                if (string.IsNullOrEmpty(colattr.DbType))
                {
                    colattr.DbType = tp?.dbtypeFull ?? "varchar(255)";
                }
                colattr.DbType = colattr.DbType.ToUpper();

                if (tp != null && tp.Value.isnullable == null)
                {
                    colattr.IsNullable = tp.Value.dbtypeFull.Contains("NOT NULL") == false;
                }
                if (colattr.DbType?.Contains("NOT NULL") == true)
                {
                    colattr.IsNullable = false;
                }
                if (string.IsNullOrEmpty(colattr.Name))
                {
                    colattr.Name = p.Name;
                }
                if (common.CodeFirst.IsSyncStructureToLower)
                {
                    colattr.Name = colattr.Name.ToLower();
                }

                if ((colattr.IsNullable == false || colattr.IsIdentity || colattr.IsPrimary) && colattr.DbType.Contains("NOT NULL") == false)
                {
                    colattr.DbType += " NOT NULL";
                }
                if (colattr.IsNullable == true && colattr.DbType.Contains("NOT NULL"))
                {
                    colattr.DbType = colattr.DbType.Replace("NOT NULL", "");
                }
                colattr.DbType        = Regex.Replace(colattr.DbType, @"\([^\)]+\)", m => Regex.Replace(m.Groups[0].Value, @"\s", ""));
                colattr.DbDefautValue = trytb.Properties[p.Name].GetValue(Activator.CreateInstance(trytb.Type));
                if (colattr.DbDefautValue == null)
                {
                    colattr.DbDefautValue = tp?.defaultValue;
                }
                if (colattr.IsNullable == false && colattr.DbDefautValue == null)
                {
                    var consturctorType = p.PropertyType.GenericTypeArguments.FirstOrDefault() ?? p.PropertyType;
                    colattr.DbDefautValue = Activator.CreateInstance(consturctorType);
                }

                var col = new ColumnInfo {
                    Table     = trytb,
                    CsName    = p.Name,
                    CsType    = p.PropertyType,
                    Attribute = colattr
                };
                trytb.Columns.Add(colattr.Name, col);
                trytb.ColumnsByCs.Add(p.Name, col);
            }
            trytb.Primarys = trytb.Columns.Values.Where(a => a.Attribute.IsPrimary).ToArray();
            if (trytb.Primarys.Any() == false)
            {
                trytb.Primarys = trytb.Columns.Values.Where(a => a.Attribute.IsIdentity).ToArray();
            }
            _cacheGetTableByEntity.TryAdd(entity.FullName, trytb);
            return(trytb);
        }
Example #30
0
 /// <summary>
 /// 动态函数
 /// </summary>
 /// <param name="type"></param>
 /// <param name="attribute"></param>
 public ToArray(Type type, ColumnAttribute attribute)
 {
     this.attribute = attribute;
     dynamicMethod  = new DynamicMethod("SqlColumnToArray", null, new Type[] { type, typeof(object[]), Field.RefIntType }, type, true);
     generator      = dynamicMethod.GetILGenerator();
 }
Example #31
0
        /// <summary>
        /// 访问 ToString 方法
        /// </summary>
        protected override Expression VisitToStringImpl(Expression node)
        {
            // => a.ID.ToString()
            // 字符串不进行转换
            if (node == null || node.Type == typeof(string))
            {
                return(_visitor.Visit(node));
            }

            ColumnAttribute column    = null;
            bool            isUnicode = _provider.DbValue.IsUnicode(_visitedMark.Current, out column);
            bool            isBytes   = node.Type == typeof(byte[]);
            bool            isDate    = node.Type == typeof(DateTime) ||
                                        node.Type == typeof(DateTime?) ||
                                        node.Type == typeof(TimeSpan) ||
                                        node.Type == typeof(TimeSpan?) ||
                                        node.Type == typeof(DateTimeOffset) ||
                                        node.Type == typeof(DateTimeOffset?);

            if (!isBytes)
            {
                if (isUnicode)
                {
                    _builder.Append("TO_NCHAR(");
                }
                else
                {
                    _builder.Append("TO_CHAR(");
                }
            }

            // 其它类型转字符串
            if (isDate)
            {
                _visitor.Visit(node);

                string          format = string.Empty;
                ColumnAttribute c      = _provider.DbValue.GetColumnAttribute(_visitedMark.Current);
                if (c != null && DbTypeUtils.IsDate(c.DbType))
                {
                    format = "yyyy-mm-dd";
                }
                else if (c != null && (DbTypeUtils.IsDateTime(c.DbType) || DbTypeUtils.IsDateTime2(c.DbType)))
                {
                    format = "yyyy-mm-dd hh24:mi:ss.ff";
                }
                else if (c != null && DbTypeUtils.IsDateTimeOffset(c.DbType))
                {
                    format = "yyyy-mm-dd hh24:mi:ss.ff tzh:tzm";
                }

                // 没有显式指定数据类型,则根据表达式的类型来判断
                if (string.IsNullOrEmpty(format))
                {
                    if (node.Type == typeof(DateTime) || node.Type == typeof(DateTime?))
                    {
                        format = "yyyy-mm-dd hh24:mi:ss.ff";
                    }
                    else if (node.Type == typeof(DateTimeOffset) || node.Type == typeof(DateTimeOffset?))
                    {
                        format = "yyyy-mm-dd hh24:mi:ss.ff tzh:tzm";
                    }
                }

                if (!string.IsNullOrEmpty(format))
                {
                    _builder.Append(",'");
                    _builder.Append(format);
                    _builder.Append("'");
                }
            }
            else if (isBytes)
            {
                _builder.Append("RTRIM(DBMS_LOB.SUBSTR(");
                _visitor.Visit(node);
                _builder.Append(')');
            }
            else if (node.Type == typeof(Guid))
            {
                _builder.Append("REGEXP_REPLACE(REGEXP_REPLACE(");
                _visitor.Visit(node);
                _builder.Append(@",'(.{8})(.{4})(.{4})(.{4})(.{12})', '\1-\2-\3-\4-\5'),'(.{2})(.{2})(.{2})(.{2}).(.{2})(.{2}).(.{2})(.{2})(.{18})','\4\3\2\1-\6\5-\8\7\9')");
            }
            else
            {
                _visitor.Visit(node);
            }

            _builder.Append(')');
            return(node);
        }
Example #32
0
        internal ColumnAttribute GetEntityColumnAttribute(Type type, PropertyInfo proto)
        {
            ColumnAttribute attr = null;

            if (_orm.Aop.ConfigEntityProperty != null)
            {
                var aope = new AopConfigEntityPropertyEventArgs(type, proto);
                _orm.Aop.ConfigEntityProperty(_orm, aope);
                attr = aope.ModifyResult;
            }
            if (attr == null)
            {
                attr = new ColumnAttribute();
            }
            if (dicConfigEntity.TryGetValue(type, out var trytb) && trytb._columns.TryGetValue(proto.Name, out var trycol))
            {
                if (!string.IsNullOrEmpty(trycol.Name))
                {
                    attr.Name = trycol.Name;
                }
                if (!string.IsNullOrEmpty(trycol.OldName))
                {
                    attr.OldName = trycol.OldName;
                }
                if (!string.IsNullOrEmpty(trycol.DbType))
                {
                    attr.DbType = trycol.DbType;
                }
                if (trycol._IsPrimary != null)
                {
                    attr._IsPrimary = trycol.IsPrimary;
                }
                if (trycol._IsIdentity != null)
                {
                    attr._IsIdentity = trycol.IsIdentity;
                }
                if (trycol._IsNullable != null)
                {
                    attr._IsNullable = trycol.IsNullable;
                }
                if (trycol._IsIgnore != null)
                {
                    attr._IsIgnore = trycol.IsIgnore;
                }
                if (trycol._IsVersion != null)
                {
                    attr._IsVersion = trycol.IsVersion;
                }
                if (trycol.DbDefautValue != null)
                {
                    attr.DbDefautValue = trycol.DbDefautValue;
                }
            }
            var attrs = proto.GetCustomAttributes(typeof(ColumnAttribute), false);

            foreach (var tryattrobj in attrs)
            {
                var tryattr = tryattrobj as ColumnAttribute;
                if (tryattr == null)
                {
                    continue;
                }
                if (!string.IsNullOrEmpty(tryattr.Name))
                {
                    attr.Name = tryattr.Name;
                }
                if (!string.IsNullOrEmpty(tryattr.OldName))
                {
                    attr.OldName = tryattr.OldName;
                }
                if (!string.IsNullOrEmpty(tryattr.DbType))
                {
                    attr.DbType = tryattr.DbType;
                }
                if (tryattr._IsPrimary != null)
                {
                    attr._IsPrimary = tryattr.IsPrimary;
                }
                if (tryattr._IsIdentity != null)
                {
                    attr._IsIdentity = tryattr.IsIdentity;
                }
                if (tryattr._IsNullable != null)
                {
                    attr._IsNullable = tryattr.IsNullable;
                }
                if (tryattr._IsIgnore != null)
                {
                    attr._IsIgnore = tryattr.IsIgnore;
                }
                if (tryattr._IsVersion != null)
                {
                    attr._IsVersion = tryattr.IsVersion;
                }
                if (tryattr.DbDefautValue != null)
                {
                    attr.DbDefautValue = tryattr.DbDefautValue;
                }
            }
            if (!string.IsNullOrEmpty(attr.Name))
            {
                return(attr);
            }
            if (!string.IsNullOrEmpty(attr.OldName))
            {
                return(attr);
            }
            if (!string.IsNullOrEmpty(attr.DbType))
            {
                return(attr);
            }
            if (attr._IsPrimary != null)
            {
                return(attr);
            }
            if (attr._IsIdentity != null)
            {
                return(attr);
            }
            if (attr._IsNullable != null)
            {
                return(attr);
            }
            if (attr._IsIgnore != null)
            {
                return(attr);
            }
            if (attr._IsVersion != null)
            {
                return(attr);
            }
            if (attr.DbDefautValue != null)
            {
                return(attr);
            }
            return(null);
        }
Example #33
0
        internal static void PopulateFromProperty(object objValue, PropertyInfo pi, ref ColumnInfo ci, out ColumnAttribute columnAttr)
        {
            //验证Table修饰符
            var isExplicit = pi.DeclaringType.GetCustomAttributes(typeof(TableAttribute), true).Any();
            var tableAttr  = pi.DeclaringType.GetCustomAttributes(typeof(TableAttribute), true).FirstOrDefault() as TableAttribute;

            columnAttr = pi.GetCustomAttributes(typeof(ColumnAttribute), true).FirstOrDefault() as ColumnAttribute;
            var isIgnore = pi.GetCustomAttributes(typeof(IgnoreAttribute), true).Any();

            if (isIgnore || (isExplicit && columnAttr == null))
            {
                ci = null;
            }
            else if (objValue == null)
            {
                ci = null;
            }
            else
            {
                ci             = ci ?? new ColumnInfo();
                ci.ColumnName  = columnAttr.NameAs;
                ci.ColumnType  = columnAttr.ColumnTypeAs ?? pi.PropertyType;
                ci.IsClass     = RefletUtil.IsClass(pi.PropertyType);
                ci.IsGenric    = RefletUtil.IsListGeneric(pi.PropertyType);
                ci.IsBaseType  = RefletUtil.IsBaseType(pi.PropertyType);
                ci.IsTableAs   = string.IsNullOrEmpty(columnAttr.TableNameAs);
                ci.TableNameAs = string.IsNullOrEmpty(columnAttr.TableNameAs) ? tableAttr.TableName : columnAttr.TableNameAs;
                ci.DBType      = columnAttr.DbTypeAs == TargetDbType.Oracle ? "ORACLE" : "SQLSERVER";
                object colValue = new BuildColumn()
                {
                    PropertyInfo = pi
                }.GetValue(objValue);
                if (colValue != null)
                {
                    if (!columnAttr.HasExtendies)
                    {
                        ci.Value = Convert.ChangeType(colValue, ci.ColumnType);
                    }
                    else
                    {
                        MethodInfo       method     = pi.DeclaringType.GetMethod(columnAttr.FormatFuncName);
                        ExtensionsResult extensions = (ExtensionsResult)method.Invoke(objValue, new object[] { colValue });
                        ci.Value      = extensions.Value;
                        ci.ColumnType = extensions.ValueType;
                    }
                    ci.IsNull = false;
                }
                else
                {
                    ci.IsNull = true;
                }
            }
        }
Example #34
0
        internal static SqlType Get(Type memberType, ColumnAttribute col)
        {
            SqlType result = null;
            DBType dbType = col.DbType;

            string key = null;
            if (col.DbType == DBType.Unkonw)
            {
                var typeKey = memberType.TypeHandle.Value.GetHashCode();

                if (col.Length == 0
                && col.IsNullable
                && col.Precision == 0
                && col.Scale == 0)
                {
                    if (defaultTypes.TryGetValue(typeKey, out result))
                        return result;
                }

                var underlyingType = memberType;
                if (underlyingType.IsNullable())
                    underlyingType = Nullable.GetUnderlyingType(underlyingType);
                if (underlyingType.IsEnum)
                    underlyingType = Enum.GetUnderlyingType(underlyingType);
                //if (!TypeMap.TryGetValue(underlyingType.TypeHandle.Value.GetHashCode(), out dbType))
                //    throw new NotSupportedException("Not support '" + underlyingType.FullName + "' for field or property type.");
                typeKey = underlyingType.TypeHandle.Value.GetHashCode();
                if (TypeMap.TryGetValue(typeKey, out dbType))
                {
                    key = string.Concat(typeKey, col.Length, col.IsNullable, col.Precision, col.Scale);
                    if (SqlTypes.TryGetValue(key, out result))
                        return result;

                    defaultTypes.TryGetValue(typeKey, out result);
                }
            }
            else
            {
                key = string.Concat(col.DbType, col.Length, col.IsNullable, col.Precision, col.Scale);
                if (SqlTypes.TryGetValue(key, out result))
                    return result;
                result = new SqlType(col.DbType);
            }
            if (result != null)
                dbType = result.DbType;

            result = new SqlType(dbType, col.Precision, col.Scale) { Length = col.Length, Required = !col.IsNullable };

            lock (SqlTypes)
                SqlTypes.Add(key, result);
            return result;
        }
        public static void TypeName_Set_NullOrWhitespaceValue_ThrowsArgumentException(string value)
        {
            ColumnAttribute attribute = new ColumnAttribute();

            AssertExtensions.Throws <ArgumentException>("value", null, () => attribute.TypeName = value);
        }
Example #36
0
        /// <summary> Write a Column XML Element from attributes in a member. </summary>
        public virtual void WriteColumn(System.Xml.XmlWriter writer, System.Reflection.MemberInfo member, ColumnAttribute attribute, BaseAttribute parentAttribute, System.Type mappedClass)
        {
            writer.WriteStartElement( "column" );
            // Attribute: <name>
            writer.WriteAttributeString("name", attribute.Name==null ? DefaultHelper.Get_Column_Name_DefaultValue(member) : GetAttributeValue(attribute.Name, mappedClass));
            // Attribute: <length>
            if(attribute.Length != -1)
            writer.WriteAttributeString("length", attribute.Length.ToString());
            // Attribute: <precision>
            if(attribute.Precision != -1)
            writer.WriteAttributeString("precision", attribute.Precision.ToString());
            // Attribute: <scale>
            if(attribute.Scale != -1)
            writer.WriteAttributeString("scale", attribute.Scale.ToString());
            // Attribute: <not-null>
            if( attribute.NotNullSpecified )
            writer.WriteAttributeString("not-null", attribute.NotNull ? "true" : "false");
            // Attribute: <unique>
            if( attribute.UniqueSpecified )
            writer.WriteAttributeString("unique", attribute.Unique ? "true" : "false");
            // Attribute: <unique-key>
            if(attribute.UniqueKey != null)
            writer.WriteAttributeString("unique-key", GetAttributeValue(attribute.UniqueKey, mappedClass));
            // Attribute: <sql-type>
            if(attribute.SqlType != null)
            writer.WriteAttributeString("sql-type", GetAttributeValue(attribute.SqlType, mappedClass));
            // Attribute: <index>
            if(attribute.Index != null)
            writer.WriteAttributeString("index", GetAttributeValue(attribute.Index, mappedClass));
            // Attribute: <check>
            if(attribute.Check != null)
            writer.WriteAttributeString("check", GetAttributeValue(attribute.Check, mappedClass));
            // Attribute: <default>
            if(attribute.Default != null)
            writer.WriteAttributeString("default", GetAttributeValue(attribute.Default, mappedClass));

            WriteUserDefinedContent(writer, member, null, attribute);

            System.Collections.ArrayList memberAttribs = GetSortedAttributes(member);
            int attribPos; // Find the position of the ColumnAttribute (its <sub-element>s must be after it)
            for(attribPos=0; attribPos<memberAttribs.Count; attribPos++)
                if( memberAttribs[attribPos] is ColumnAttribute
                    && ((BaseAttribute)memberAttribs[attribPos]).Position == attribute.Position )
                    break; // found
            int i = attribPos + 1;

            // Element: <comment>
            for(; i<memberAttribs.Count; i++)
            {
                BaseAttribute memberAttrib = memberAttribs[i] as BaseAttribute;
                if( IsNextElement(memberAttrib, parentAttribute, attribute.GetType())
                    || IsNextElement(memberAttrib, attribute, typeof(CommentAttribute)) )
                    break; // next attributes are 'elements' of the same level OR for 'sub-elements'
                else
                {
                    if( memberAttrib is ColumnAttribute )
                        break; // Following attributes are for this Column
                    if( memberAttrib is CommentAttribute )
                        WriteComment(writer, member, memberAttrib as CommentAttribute, attribute, mappedClass);
                }
            }
            WriteUserDefinedContent(writer, member, typeof(CommentAttribute), attribute);

            writer.WriteEndElement();
        }
Example #37
0
 private static string WrapColumnEqParameter(DbProvider dbProvider, ColumnAttribute col)
 {
     return
         ($"{dbProvider.ParameterNamePrefix}{col.Name}{dbProvider.ParameterNameSuffix}={dbProvider.ParameterPrefix}{col.Property.Name}");
 }
Example #38
0
 public static void Order_Set_ReturnsExpected(int value)
 {
     ColumnAttribute attribute = new ColumnAttribute() { Order = value };
     Assert.Equal(value, attribute.Order);
 }
Example #39
0
        public static IEnumerable <string> GetModeledDataProperties(Type t)
        {
            foreach (PropertyInfo prop in t.GetProperties())
            {
                string tableName = t.ToString();
                if (tableName.Contains('.'))
                {
                    int lastIndex = tableName.LastIndexOf('.');
                    tableName = tableName.Substring(lastIndex + 1, tableName.Length - lastIndex - 1);
                }

                MemberInfo                   info            = prop;
                ModeledDataAttribute         attrib          = null;
                ModeledDataTypeAttribute     typeAttrib      = null;
                ModeledDataNullableAttribute nullableAttrib  = null;
                ColumnAttribute              columnAttribute = null;

                foreach (object attribObject in info.GetCustomAttributes(true))
                {
                    if (attribObject is ModeledDataAttribute)
                    {
                        attrib = attribObject as ModeledDataAttribute;
                    }
                    else if (attribObject is ModeledDataTypeAttribute)
                    {
                        typeAttrib = attribObject as ModeledDataTypeAttribute;
                    }
                    else if (attribObject is ModeledDataNullableAttribute)
                    {
                        nullableAttrib = attribObject as ModeledDataNullableAttribute;
                    }
                    else if (attribObject is ColumnAttribute)
                    {
                        columnAttribute = attribObject as ColumnAttribute;
                    }
                }

                // Check for nullable types
                bool isNullable = false;
                Type propType   = prop.PropertyType;
                if (propType.Name.StartsWith("Nullable"))
                {
                    propType   = Nullable.GetUnderlyingType(propType);
                    isNullable = true;
                }

                // Has a ColumnAttribute
                if (columnAttribute != null)
                {
                    if (propType == typeof(String))
                    {
                        isNullable = true;
                    }
                    if (isNullable && !columnAttribute.CanBeNull)
                    {
                        isNullable = false;
                    }
                    yield return(tableName + "." +
                                 (!string.IsNullOrEmpty(columnAttribute.Name) ?
                                  columnAttribute.Name : prop.Name) + " " +
                                 GetSqlTypeString(!string.IsNullOrEmpty(columnAttribute.DbType) ?
                                                  columnAttribute.DbType : propType.Name, isNullable));
                }

                // Has a ModeledDataAttribute
                else if (attrib != null)
                {
                    if (attrib.Alias1Name == null)
                    {
                        yield return(tableName + "." + prop.Name + " " +
                                     GetSqlTypeString(
                                         (((typeAttrib != null) && (typeAttrib.Alias1Type != null)) ?
                                          typeAttrib.Alias1Type : propType.Name), ((nullableAttrib != null) || isNullable)));
                    }
                    else
                    {
                        yield return(tableName + "." + attrib.Alias1Name + " " +
                                     GetSqlTypeString(
                                         (((typeAttrib != null) && (typeAttrib.Alias1Type != null)) ?
                                          typeAttrib.Alias1Type : propType.Name), ((nullableAttrib != null) || isNullable)));
                    }
                    if (typeAttrib != null)
                    {
                        if (attrib.Alias2Name != null)
                        {
                            yield return(tableName + "." + attrib.Alias2Name + " " +
                                         GetSqlTypeString(typeAttrib.Alias2Type, (nullableAttrib != null)));
                        }
                        if (attrib.Alias3Name != null)
                        {
                            yield return(tableName + "." + attrib.Alias3Name + " " +
                                         GetSqlTypeString(typeAttrib.Alias3Type, (nullableAttrib != null)));
                        }
                        if (attrib.Alias4Name != null)
                        {
                            yield return(tableName + "." + attrib.Alias4Name + " " +
                                         GetSqlTypeString(typeAttrib.Alias4Type, (nullableAttrib != null)));
                        }
                    }
                }
            }
        }
Example #40
0
 public static void Order_Set_NegativeValue_ThrowsArgumentOutOfRangeException()
 {
     ColumnAttribute attribute = new ColumnAttribute();
     Assert.Throws<ArgumentOutOfRangeException>("value", () => attribute.Order = -1);
 }
 /// <summary>
 /// Inspect a member and optionally add a ColumnMap.
 /// </summary>
 /// <param name="entityType">The entity type that is being mapped.</param>
 /// <param name="member">The member that is being mapped.</param>
 /// <param name="columnMaps">The ColumnMapCollection that is being created.</param>
 protected abstract void CreateColumnMap(Type entityType, MemberInfo member, ColumnAttribute columnAtt, ColumnMapCollection columnMaps);
Example #42
0
        /// <summary>
        /// Generate Dictonary type based on models property
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="modeltoConvert"></param>
        /// <param name="properties"></param>
        /// <returns></returns>
        private static IDictionary <string, object> GenerateDBEntityFromProperty <T>(T modeltoConvert, IList <PropertyInfo> properties, bool iterateSubModel)
        {
            var expando = new ExpandoObject() as IDictionary <string, object>;

            try {
                foreach (var property in properties)
                {
                    if ((property.PropertyType.FullName.Contains("System.Collections.Generic.List") || property.PropertyType.FullName.Contains("System.Collections.Generic.IList")) &&
                        iterateSubModel)
                    {
                        var submodel = property.GetValue(modeltoConvert);
                        if (submodel != null)
                        {
                            Type type = submodel.GetType().GetGenericArguments()[0];
                            //Type submodeltype = submodel.GetType();

                            var list       = CreateListObject(submodel, type);
                            var listResult = new List <IDictionary <string, object> >();

                            foreach (var itm in list)
                            {
                                var subproperties = DataTableExtensions.GetPropertiesForType <T>(type);
                                listResult.Add(GenerateDBEntityFromProperty(itm, subproperties, iterateSubModel));
                            }
                            var objname = GetAttributeName(property);

                            expando.Add((objname == string.Empty ? property.Name.ToUpper() : objname), listResult);
                        }
                    }
                    else if (property.PropertyType.FullName.Contains("GTS.BusinessEntity"))
                    {
                        var submodel = property.GetValue(modeltoConvert);
                        if (submodel != null)
                        {
                            submodel = SetDefaultValuestoModels(submodel);
                            Type   submodeltype  = submodel.GetType();
                            var    subproperties = DataTableExtensions.GetPropertiesForType <T>(submodeltype);
                            string attname       = GetAttributeName(submodel);
                            if (!string.IsNullOrEmpty(attname))
                            {
                                expando.Add(attname.ToUpper(), GenerateDBEntityFromProperty(submodel, subproperties, iterateSubModel));
                            }
                            else
                            {
                                //Recursive call for the sub models
                                if (iterateSubModel)
                                {
                                    expando.Add(property.Name.ToUpper(), GenerateDBEntityFromProperty(submodel, subproperties, iterateSubModel));
                                }
                            }
                        }
                    }


                    var             att = property.GetCustomAttributes(true);
                    ColumnAttribute p   = null;

                    if (att.Length > 0)
                    {
                        foreach (var itm in att)
                        {
                            if (typeof(ColumnAttribute).IsEquivalentTo(itm.GetType()))
                            {
                                p = itm as ColumnAttribute;
                                if (p != null && !string.IsNullOrEmpty(p.FieldName))
                                {
                                    var val = property.GetValue(modeltoConvert);

                                    if (val != null && val.GetType() == typeof(bool) && p.IsNotBoolean)
                                    {
                                        expando.Add(p.FieldName.ToUpper(), (bool)val ? "Y" : "N");
                                    }
                                    else if (val != null && val.GetType() == typeof(DateTime))
                                    {
                                        expando.Add(p.FieldName.ToUpper(), ((DateTime)val).ToString("yyyy-MM-dd HH:mm:ss"));
                                    }
                                    else
                                    {
                                        expando.Add(p.FieldName.ToUpper(), val);
                                    }
                                }
                            }
                        }
                    }
                }

                return(expando);
            } catch (Exception ex) {
                return(expando);
            }
        }
        // called when created from existing DBF file
        public void Initialize(DbfVersion version, FieldInfo fieldinfo, ColumnAttribute columnAttribute)
        {
            this.mFieldInfo = fieldinfo;
            this.mVersion = version;
            if (columnAttribute == null) columnAttribute = new ColumnAttribute();

            Type fieldType = mFieldInfo.FieldType;

            if (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(Nullable<>))
            {
                IsNullable=true;
                NativeTypeCode= Type.GetTypeCode(fieldType.GetGenericArguments()[0]);
            }
            else this.NativeTypeCode = Type.GetTypeCode(fieldType);

            mColumnName = (columnAttribute.ColumnName == null || columnAttribute.ColumnName.Length == 0 ?
                fieldinfo.Name : columnAttribute.ColumnName);

            mColumnType = columnAttribute.Type;
            mWidth = columnAttribute.Width;
            mDecimals = columnAttribute.Decimals;
            int defaultWidth, defaultDecimals;

            if (mColumnType == ColumnType.UNKNOWN)
            {
                if (NativeTypeCode == TypeCode.Object)
                {
                    GetDefaultColumnType(fieldType, mVersion, out mColumnType, out defaultWidth, out defaultDecimals);
                }
                else
                {
                    GetDefaultColumnType(NativeTypeCode, IsNullable, mVersion, out mColumnType, out defaultWidth, out defaultDecimals);
                }
                if (mWidth == -1) mWidth = defaultWidth;
                if (mDecimals == -1) mDecimals = defaultDecimals;
            }
            CheckWidthAndDecimals();
        }
Example #44
0
 public static bool TryGetColumnByPropertyName(String propertyName, out ColumnAttribute columnAttribute)
 {
     return(MetaData.Columns.TryGetValue(propertyName, out columnAttribute));
 }