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)
{
}
