public object[] GetPrimaryKeys(object data) { object[] rawkeys = new object[PrimaryKeyCount]; for (int i = 0; i < PrimaryKeyCount; i++) { DataFieldMapping field = PrimaryKeyFields[i]; rawkeys[i] = field.Handler.Get(data); } return(rawkeys); }
internal BasicFieldInfo(DataEntityMapping tableMapping, DataFieldMapping dataField) { if (tableMapping == null) { throw new ArgumentNullException(nameof(tableMapping)); } if (tableMapping != DataEntityMapping.Default && dataField == null) { throw new ArgumentNullException(nameof(dataField)); } TableMapping = tableMapping; DataField = dataField; }
void InitialFieldList() { List <DataFieldMapping> noIdentityTmpList = new List <DataFieldMapping>(); List <DataFieldMapping> primaryKeyTmpList = new List <DataFieldMapping>(); List <DataFieldMapping> noPrimaryKeyTmpList = new List <DataFieldMapping>(); List <DataFieldMapping> createTmpList = new List <DataFieldMapping>(); List <DataFieldMapping> updateTmpList = new List <DataFieldMapping>(); foreach (FieldMapping field in _fieldList) { if (field is PrimitiveFieldMapping pfmapping) { if (pfmapping.IsIdentity) { if (IdentityField == null) { _identityField = pfmapping; } else { throw new LightDataException(string.Format(SR.MultipleIdentityField, ObjectType)); } } else { noIdentityTmpList.Add(pfmapping); } if (pfmapping.IsPrimaryKey) { primaryKeyTmpList.Add(pfmapping); } else { noPrimaryKeyTmpList.Add(pfmapping); } } else { DataFieldMapping mapping = field as DataFieldMapping; noIdentityTmpList.Add(mapping); noPrimaryKeyTmpList.Add(mapping); } } _noIdentityFieldList = new ReadOnlyCollection <DataFieldMapping>(noIdentityTmpList); _primaryKeyFieldList = new ReadOnlyCollection <DataFieldMapping>(primaryKeyTmpList); _noPrimaryKeyFieldList = new ReadOnlyCollection <DataFieldMapping>(noPrimaryKeyTmpList); _createFieldList = new ReadOnlyCollection <DataFieldMapping>(noIdentityTmpList.FindAll(x => (x.FunctionControl & FunctionControl.Create) == FunctionControl.Create)); _updateFieldList = new ReadOnlyCollection <DataFieldMapping>(noPrimaryKeyTmpList.FindAll(x => (x.FunctionControl & FunctionControl.Update) == FunctionControl.Update)); _timeStampFieldList = new ReadOnlyCollection <DataFieldMapping>(noPrimaryKeyTmpList.FindAll(x => x.IsTimeStamp)); }
public virtual IDbCommand CreateAggregateCommand(DataFieldMapping fieldMapping, AggregateType aggregateType, QueryExpression query, bool distinct) { DataEntityMapping mapping = fieldMapping.EntityMapping; if (aggregateType != AggregateType.COUNT) { TypeCode code = Type.GetTypeCode(fieldMapping.ObjectType); if (aggregateType == AggregateType.MAX || aggregateType == AggregateType.MIN) { if (code == TypeCode.Char || code == TypeCode.DBNull || code == TypeCode.Object || code == TypeCode.String) { throw new LightDataException(RE.TheTypeOfAggregationFieldIsNotRight); } } else { if (code == TypeCode.Char || code == TypeCode.DBNull || code == TypeCode.Object || code == TypeCode.String || code == TypeCode.DateTime) { throw new LightDataException(RE.TheTypeOfAggregationFieldIsNotRight); } } } string function = null; switch (aggregateType) { case AggregateType.COUNT: function = CreateCountSql(fieldMapping.Name, distinct); break; case AggregateType.SUM: function = CreateSumSql(fieldMapping.Name, distinct); break; case AggregateType.AVG: function = CreateAvgSql(fieldMapping.Name, distinct); break; case AggregateType.MAX: function = CreateMaxSql(fieldMapping.Name); break; case AggregateType.MIN: function = CreateMinSql(fieldMapping.Name); break; } //string select = string.Format("{0}({2}{1})", aggregateType.ToString().ToLower(), CreateDataFieldSql(fieldMapping.Name), distinct ? "distinct " : string.Empty); return(CreateSelectBaseCommand(mapping, function, query, null, null)); //, false); }
/// <summary> /// 统计字段函数 /// </summary> /// <param name="fieldMapping">统计字段</param> /// <param name="aggregateType">统计方式</param> /// <param name="query">查询表达式</param> /// <param name="distinct">是否排除重复</param> /// <param name="level">安全级别</param> /// <returns>统计结果</returns> internal object Aggregate(DataFieldMapping fieldMapping, AggregateType aggregateType, QueryExpression query, bool distinct, SafeLevel level) { using (IDbCommand command = _dataBase.Factory.CreateAggregateCommand(fieldMapping, aggregateType, query, distinct)) { object obj = ExecuteScalar(command, level); if (Object.Equals(obj, DBNull.Value)) { return(null); } else { return(obj); } } }
private static DataDefine TransferDataDefine(DataFieldMapping fieldMapping) { DataDefine define = null; if (fieldMapping is PrimitiveFieldMapping) { if (fieldMapping.ObjectType == typeof(string)) { define = PrimitiveDataDefine.CreateString(fieldMapping.IsNullable, fieldMapping.Name); } else { if (fieldMapping.IsNullable) { Type itemstype = System.Type.GetType("System.Nullable`1"); Type type = itemstype.MakeGenericType(fieldMapping.ObjectType); define = PrimitiveDataDefine.Create(type, fieldMapping.Name); } else { define = PrimitiveDataDefine.Create(fieldMapping.ObjectType, fieldMapping.Name); } } } else if (fieldMapping is EnumFieldMapping) { EnumFieldMapping em = fieldMapping as EnumFieldMapping; if (fieldMapping.IsNullable) { Type itemstype = System.Type.GetType("System.Nullable`1"); Type type = itemstype.MakeGenericType(fieldMapping.ObjectType); define = EnumDataDefine.Create(type, em.EnumType, fieldMapping.Name); } else { define = EnumDataDefine.Create(fieldMapping.ObjectType, em.EnumType, fieldMapping.Name); } } else { throw new LightDataException(RE.OnlyPrimitiveFieldCanSelectSingle); } return(define); }
private void InitialDataFieldMapping() { var properties = ObjectTypeInfo.GetProperties(BindingFlags.Public | BindingFlags.Instance); var tempList = new List <DataFieldMapping> (); foreach (var pi in properties) { var mapping = DataFieldMapping.CreateCustomFieldMapping(pi, this); tempList.Add(mapping); // if (mapping != null) { // tempList.Add (mapping); // } } if (tempList.Count == 0) { throw new LightDataException(string.Format(SR.NoMappingField, ObjectType.FullName)); } _fieldList = new ReadOnlyCollection <DataFieldMapping> (tempList); }
protected virtual void InitialRelateMappingInc() { DataEntityMapping mapping = DataEntityMapping.GetEntityMapping(this.relateType); DataFieldInfo [] infos = new DataFieldInfo [keyPairs.Length]; DataFieldMapping [] fields = new DataFieldMapping [keyPairs.Length]; for (int i = 0; i < this.keyPairs.Length; i++) { DataFieldMapping field = mapping.FindDataEntityField(keyPairs [i].RelateKey); if (field == null) { throw new LightDataException(string.Format(SR.CanNotFindTheSpecifiedField, mapping.ObjectType, keyPairs[i].RelateKey)); } fields [i] = field; infos [i] = new DataFieldInfo(field); } this.relateInfos = infos; this.relateFieldMappings = fields; this.relateEntityMapping = mapping; }
private void InitialDataFieldMapping() { PropertyInfo [] propertys = ObjectTypeInfo.GetProperties(BindingFlags.Public | BindingFlags.Instance); List <DataFieldMapping> tmepList = new List <DataFieldMapping> (); foreach (PropertyInfo pi in propertys) { DataFieldMapping mapping = DataFieldMapping.CreateCustomFieldMapping(pi, this); if (mapping != null) { _fieldMappingDictionary.Add(mapping.IndexName, mapping); tmepList.Add(mapping); } } if (tmepList.Count == 0) { throw new LightDataException(string.Format(SR.NoMappingField, ObjectType.FullName)); } _fieldList = new ReadOnlyCollection <DataFieldMapping> (tmepList); }
protected BaseRelationFieldMapping(string fieldName, DataEntityMapping mapping, Type relateType, RelationKey [] keyPairs, PropertyHandler handler) { if (fieldName == null) { throw new ArgumentNullException(nameof(fieldName)); } if (mapping == null) { throw new ArgumentNullException(nameof(mapping)); } if (relateType == null) { throw new ArgumentNullException(nameof(relateType)); } if (keyPairs == null || keyPairs.Length == 0) { throw new ArgumentNullException(nameof(keyPairs)); } if (handler == null) { throw new ArgumentNullException(nameof(handler)); } this.fieldName = fieldName; this.masterEntityMapping = mapping; this.relateType = relateType; this.keyPairs = keyPairs; this.handler = handler; this.masterFieldMappings = new DataFieldMapping [keyPairs.Length]; this.masterInfos = new DataFieldInfo [keyPairs.Length]; for (int i = 0; i < keyPairs.Length; i++) { DataFieldMapping field = mapping.FindDataEntityField(keyPairs [i].MasterKey); if (field == null) { throw new LightDataException(string.Format(SR.CanNotFindTheSpecifiedField, mapping.ObjectType, keyPairs[i].MasterKey)); } this.masterFieldMappings [i] = field; this.masterInfos [i] = new DataFieldInfo(field); } }
public object ToProperty(DataContext context, object source, bool exceptOwner) { InitialRelateMapping(); QueryExpression expression = null; for (int i = 0; i < masterFieldMappings.Length; i++) { DataFieldInfo info = this.relateInfos[i]; DataFieldMapping field = this.masterFieldMappings[i]; QueryExpression keyExpression = new LightBinaryQueryExpression(relateEntityMapping, QueryPredicate.Eq, info, field.Handler.Get(source)); expression = QueryExpression.And(expression, keyExpression); } object target = null; if (defaultConstructorInfo != null) { object[] args = { context, source, expression, exceptOwner ? this.fieldPaths : null }; target = defaultConstructorInfo.Invoke(args); } return(target); }
public virtual IDbCommand CreateSelectSingleFieldCommand(DataFieldInfo fieldinfo, QueryExpression query, OrderExpression order, bool distinct, Region region) { if (region != null && !_canInnerPage) { throw new LightDataException(RE.DataBaseNotSupportInnerPage); } DataFieldMapping fieldMapping = fieldinfo.DataField; if (fieldMapping is PrimitiveFieldMapping || fieldMapping is EnumFieldMapping || fieldMapping is CustomFieldMapping) { DataEntityMapping mapping = fieldMapping.EntityMapping; string select = fieldinfo.CreateDataFieldSql(this); if (distinct) { select = "distinct " + select; } return(CreateSelectBaseCommand(mapping, select, query, order, region)); } else { throw new LightDataException(RE.OnlyPrimitiveFieldCanSelectSingle); } }
protected void InitialDataFieldMapping() { var properties = ObjectTypeInfo.GetProperties(BindingFlags.Public | BindingFlags.Instance); var index = 0; var list = new List <FieldInfo>(); foreach (var pi in properties) { var config = MapperConfigManager.LoadDataFieldConfig(ObjectType, pi); if (config != null) { index++; var info = new FieldInfo(pi, config, index); list.Add(info); } } if (list.Count == 0) { throw new LightDataException(string.Format(SR.NoMappingField, ObjectType)); } list.Sort((x, y) => { if (x.DataOrder.HasValue && y.DataOrder.HasValue) { if (x.DataOrder > y.DataOrder) { return(1); } if (x.DataOrder < y.DataOrder) { return(-1); } return(x.FieldOrder > y.FieldOrder ? 1 : -1); } if (x.DataOrder.HasValue && !y.DataOrder.HasValue) { return(-1); } if (!x.DataOrder.HasValue && y.DataOrder.HasValue) { return(1); } return(x.FieldOrder > y.FieldOrder ? 1 : -1); }); var tmpList = new List <DataFieldMapping>(); for (var i = 0; i < list.Count; i++) { var info = list[i]; var mapping = DataFieldMapping.CreateDataFieldMapping(info.Property, info.Config, i + 1, this); _fieldMappingDictionary.Add(mapping.IndexName, mapping); if (mapping.Name != mapping.IndexName) { _fieldMappingDictionary.Add(mapping.Name, mapping); } tmpList.Add(mapping); } _fieldList = new ReadOnlyCollection <DataFieldMapping>(tmpList); }
internal DataFieldInfo(DataFieldMapping fieldMapping, string aliasTableName) : base(fieldMapping.EntityMapping, fieldMapping) { _aliasTableName = aliasTableName; }
internal DataFieldInfo(DataFieldMapping fieldMapping) : base(fieldMapping.EntityMapping, fieldMapping) { }
internal DataFieldInfo(DataEntityMapping mapping, DataFieldMapping fieldMapping) : base(mapping, fieldMapping) { }