internal static View ConvertCollection <T>(IEnumerable data) { var ctype = typeof(T); var type = Common.TryGetSerializationItemType(ctype, data, Text.Method.ToView); if (type == null) { throw new QueryTalkException("Common.TryGetSerializationItemType", QueryTalkExceptionType.EmptyDynamicResult, String.Format("type = {0}", ctype), Text.Method.ToView); } Type clrType = null; QueryTalkException exception; List <ViewColumnInfo> columns = new List <ViewColumnInfo>(); bool isScalar = (Mapping.CheckClrCompliance(type, out clrType, out exception) == Mapping.ClrTypeMatch.ClrMatch); bool isDataValue = type == typeof(Value); if (isDataValue) { isScalar = true; clrType = typeof(System.Object); } bool isEmpty = _CheckIfEmpty(data, isScalar); var properties = type.GetReadableProperties(); List <IPropertyAccessor> getters = null; int numberOfProperties = 0; var sqlOuter = Text.GenerateSql(500); var sqlEmpty = Text.GenerateSql(200) .NewLineIndent(Text.Select).S(); // outer select: if (isScalar) { _BuildScalarOuterSelect(type, clrType, columns, sqlOuter); } else { _BuildClassOuterSelect(type, ref clrType, ref exception, columns, isEmpty, properties, out getters, out numberOfProperties, sqlOuter, sqlEmpty); } // inner select: var sqlInner = Text.GenerateSql(500); int rowCount = 0; if (!isEmpty) { bool firstRow = true; foreach (var row in data) { if (!isScalar && row == null) { continue; } _BuildSelect(sqlInner, firstRow); if (!isScalar) { _BuildClassValues(columns, properties, getters, numberOfProperties, sqlInner, firstRow, row); } else { AppendColumn(sqlInner, Mapping.BuildUnchecked(row), Text.SingleColumnShortName); } firstRow = false; ++rowCount; } } else { if (isScalar) { AppendColumn(sqlEmpty, Text.Null, Text.SingleColumnShortName); } sqlInner.Append(sqlEmpty.ToString()); } return(Finalizer(type, sqlOuter, sqlInner, columns.ToArray(), rowCount, isEmpty)); }
private static void _BuildClassOuterSelect(Type type, ref Type clrType, ref QueryTalkException exception, List <ViewColumnInfo> columns, bool isEmpty, PropertyInfo[] properties, out List <IPropertyAccessor> getters, out int numberOfProperties, StringBuilder sqlOuter, StringBuilder sqlEmpty) { numberOfProperties = properties.Length; if (numberOfProperties == 0) { throw new QueryTalkException("ViewConverter.ToView<T>", QueryTalkExceptionType.InvalidDataClass, String.Format("data class = {0}", type)); } bool cached = Cache.PropertyAccessors.TryGetValue(type, out getters); if (!cached) { getters = new List <IPropertyAccessor>(); } NodeMap rowMap = null; bool isDbRow = type.IsDbRow(); if (isDbRow) { rowMap = DbMapping.GetNodeMap(type); if (rowMap.ID.Equals(DB3.Default)) { DbRow.ThrowInvalidDbRowException(type); } } // outer select: int i = 0; foreach (var property in properties) { string column; var clrTypeMatch = Mapping.CheckClrCompliance(property.PropertyType, out clrType, out exception); if (clrTypeMatch != Mapping.ClrTypeMatch.ClrMatch) { continue; } ViewColumnInfo columnInfo; if (isDbRow) { var rowColumn = rowMap.Columns.Where(a => a.ID.ColumnZ == i + 1).First(); column = rowColumn.Name.Part1; columnInfo = new ViewColumnInfo(column, rowColumn.DataType, rowColumn.IsNullable); columns.Add(columnInfo); } else { column = property.Name; columnInfo = new ViewColumnInfo(column, property.PropertyType, clrType); columns.Add(columnInfo); } if (i != 0) { sqlOuter.NewLineIndent(Text.Comma); sqlEmpty.Append(Text.Comma); } var dataType = Mapping.ProvideDataType(columnInfo.DataType, clrType); AppendOuterColumn(sqlOuter, dataType, i + 1, column); if (isEmpty) { AppendNullValueColumn(sqlEmpty, i + 1); } if (!cached) { getters.Add(PropertyAccessor.Create(type, property)); } ++i; } numberOfProperties = i; if (numberOfProperties == 0) { ThrowInvalidDataClassException(type); } if (!cached) { Cache.PropertyAccessors[type] = getters; } }
internal static T SetClass <T>(T target, object source) { if (target == null) { throw new QueryTalkException("ClassConverter.ToClass", QueryTalkExceptionType.ArgumentNull, "target= null", Text.Method.Pack); } if (source == null) { throw new QueryTalkException("ClassConverter.ToClass", QueryTalkExceptionType.ArgumentNull, "source = null", Text.Method.Pack); } if (target != null && object.ReferenceEquals(target, source)) { return(target); } Type targetType = target.GetType(); Type sourceType = source.GetType(); TryCheckClassType(targetType); TryCheckClassType(sourceType); var sourceProperties = sourceType.GetReadableProperties(); var targetProperties = targetType.GetWritableProperties(); if (targetProperties.Length == 0) { throw new QueryTalkException("ClassConverter.TryCheckClassType", QueryTalkExceptionType.InvalidPack, String.Format("type = {0}", targetType), Text.Method.Pack); } if (sourceProperties.Length == 0) { throw new QueryTalkException("ClassConverter.TryCheckClassType", QueryTalkExceptionType.InvalidPack, String.Format("type = {0}", sourceType), Text.Method.Pack); } bool match = false; Type clrType; QueryTalkException exception; foreach (var targetProperty in targetProperties) { var clrTypeMatch = Mapping.CheckClrCompliance(targetProperty.PropertyType, out clrType, out exception); if (clrTypeMatch != Mapping.ClrTypeMatch.ClrMatch) { continue; } var sourceProperty = sourceProperties.Where(p => p.Name == targetProperty.Name).FirstOrDefault(); if (sourceProperty != null) { if (Common.GetClrType(sourceProperty.PropertyType) != Common.GetClrType(targetProperty.PropertyType)) { throw new QueryTalkException("ClassConverter.ToClass", QueryTalkExceptionType.PackPropertyMismatch, String.Format("target property name = {0}{1} target property type = {2}{1} source property type = {3}", targetProperty.Name, Environment.NewLine, targetProperty.PropertyType, sourceProperty.PropertyType), Text.Method.Pack); } match = true; targetProperty.SetValue(target, sourceProperty.GetValue(source, null), null); } } if (!match) { throw new QueryTalkException("ClassConverter.TryCheckClassType", QueryTalkExceptionType.InvalidPack, String.Format("target type = {0}{1} source type = {2}", targetType, Environment.NewLine, sourceType), Text.Method.Pack); } return(target); }
// build the most outer SQL wrapper internal string BuildOutputWrapper(string execSql) { var root = Executable.Compilable.GetRoot(); var outputArguments = ParameterArgument.GetOutputArguments(Executable.Arguments); var sql = Text.GenerateSql(1000).Append(Text.Free.QueryTalkCode); // after: drop temp tables var sqlAfter = Text.GenerateSql(100); sqlAfter.Append(DropTempTables()); if (root.IsEmbeddedTryCatch) { sqlAfter .NewLine(Text.EndTry) .NewLine(Text.BeginCatch) .NewLine(Text.Free.RaiserrorS) .NewLine(Text.EndCatch).Terminate(); } sql.Append(Text.Declare).S().Append(Text.Reserved.ReturnValueOuterParam) .Append(Text._As_).Append(Text.Free.EnclosedInt).Terminate().S() .Append(Text.Set).S().Append(Text.Reserved.ReturnValueOuterParam).Append(Text._Equal_) .Append(Text.Zero).Terminate(); // TRY outer wrapper if (root.IsEmbeddedTryCatch) { sql.NewLine(Text.BeginTry); } // output arguments string outputValues = String.Empty; foreach (var argument in outputArguments) { // param in outer wrapper that holds the outer reference string paramOuterName = String.Format("{0}{1}{2}", argument.ParamName, Text.Underscore, Text.Output); // before sql.NewLine(Text.Declare).S() .Append(paramOuterName).Append(Text._As_) .Append(Executable.GetParamDeclaration(argument, false, true)) .Terminate().S() .Append(Text.Set).S().Append(paramOuterName).Append(Text._Equal_); if (argument.TestValue != null) { Testing.AppendTestValue(sql, argument); } else { sql.Append(Mapping.BuildUnchecked(argument.Value)); } sql.TerminateSingle(); // after: return output values outputValues = Text.GenerateSql(100) .NewLineIndent(Text.Comma) .Append(paramOuterName) .Append(Text._As_) .Append(Filter.Delimit(paramOuterName)) .ToString(); } // append last sql code: return value + output values sqlAfter .NewLine(Text.Select).S() .Append(Text.Free.ReturnValue) .Append(Text._As_) .Append(Text.Reserved.ReturnValueColumnName) .Append(outputValues); TryThrow(Text.Method.Pass); sql.NewLine(execSql) .Append(sqlAfter.ToString()) .TerminateSingle(); return(sql.ToString()); }
internal static IEnumerable <T> PackRows <T>(IEnumerable source) where T : new() { if (source == null) { return(null); } Type targetType = typeof(T); Type sourceType = null; foreach (var row in source) { if (row == null) { continue; } sourceType = row.GetType(); break; } if (sourceType == null) { return(null); } TryCheckClassType(targetType); TryCheckClassType(sourceType); var sourceProperties = sourceType.GetReadableProperties(); var targetProperties = targetType.GetWritableProperties(); if (targetProperties.Length == 0) { throw new QueryTalkException("ClassConverter.TryCheckClassType", QueryTalkExceptionType.InvalidPack, String.Format("type = {0}", targetType), Text.Method.Pack); } if (sourceProperties.Length == 0) { throw new QueryTalkException("ClassConverter.TryCheckClassType", QueryTalkExceptionType.InvalidPack, String.Format("type = {0}", sourceType), Text.Method.Pack); } var sourceGetters = new List <IPropertyAccessor>(); var targetGetters = new List <IPropertyAccessor>(); bool match = false; Type clrType; QueryTalkException exception; var numberOfPropertiesUsed = 0; foreach (var targetProperty in targetProperties) { var clrTypeMatch = Mapping.CheckClrCompliance(targetProperty.PropertyType, out clrType, out exception); if (clrTypeMatch != Mapping.ClrTypeMatch.ClrMatch) { continue; } var sourceProperty = sourceProperties.Where(p => p.Name == targetProperty.Name).FirstOrDefault(); if (sourceProperty != null) { if (Common.GetClrType(sourceProperty.PropertyType) != Common.GetClrType(targetProperty.PropertyType)) { throw new QueryTalkException("ClassConverter.ToClass", QueryTalkExceptionType.PackPropertyMismatch, String.Format("target property name = {0}{1} target property type = {2}{1} source property type = {3}", targetProperty.Name, Environment.NewLine, targetProperty.PropertyType, sourceProperty.PropertyType), Text.Method.Pack); } match = true; sourceGetters.Add(PropertyAccessor.Create(sourceType, sourceProperty)); targetGetters.Add(PropertyAccessor.Create(targetType, targetProperty)); ++numberOfPropertiesUsed; } } if (!match) { throw new QueryTalkException("ClassConverter.TryCheckClassType", QueryTalkExceptionType.InvalidPack, String.Format("target type = {0}{1} source type = {2}", targetType, Environment.NewLine, sourceType), Text.Method.Pack); } var rows = new HashSet <T>(); foreach (var sourceRow in source) { if (sourceRow == null) { continue; } var targetRow = new T(); for (int i = 0; i < numberOfPropertiesUsed; i++) { var value = sourceGetters[i].GetValue(sourceRow); targetGetters[i].SetValue(targetRow, value); } rows.Add(targetRow); } return(rows); }