/// <summary> /// Returns the widener. /// </summary> /// <param name="columnName">name of column</param> /// <param name="columnType">type of column</param> /// <param name="writeablePropertyType">property type</param> /// <param name="writeablePropertyName">propery name</param> /// <param name="allowObjectArrayToCollectionConversion">whether we widen object-array to collection</param> /// <param name="customizer">customization if any</param> /// <param name="statementName">statement name</param> /// <returns>type widener</returns> /// <throws>TypeWidenerException if type validation fails</throws> public static TypeWidenerSPI GetCheckPropertyAssignType( string columnName, Type columnType, Type writeablePropertyType, string writeablePropertyName, bool allowObjectArrayToCollectionConversion, TypeWidenerCustomizer customizer, string statementName) { var columnTypeBoxed = columnType.GetBoxedType(); var targetTypeBoxed = writeablePropertyType.GetBoxedType(); var custom = customizer?.WidenerFor( columnName, columnType, writeablePropertyType, writeablePropertyName, statementName); if (custom != null) { return custom; } if (columnType == null) { if (writeablePropertyType.CanNotBeNull()) { var message = "Invalid assignment of column '" + columnName + "' of null type to event property '" + writeablePropertyName + "' typed as '" + writeablePropertyType.CleanName() + "', nullable type mismatch"; throw new TypeWidenerException(message); } } else if (columnTypeBoxed != targetTypeBoxed) { if (columnTypeBoxed == typeof(string) && targetTypeBoxed == typeof(char?)) { return STRING_TO_CHAR_COERCER; } if (allowObjectArrayToCollectionConversion && columnTypeBoxed.IsArray && !columnTypeBoxed.GetElementType().IsValueType && targetTypeBoxed.IsImplementsInterface(typeof(ICollection<object>))) { return OBJECT_ARRAY_TO_COLLECTION_COERCER; } // Boxed types tend to be incompatible from an assignment perspective. We have both // the boxed and unboxed values. The problem is that the boxed values will always // be unboxed prior to assignment, so looking for assignment of boxed types is not // a winning approach. var columnTypeUnboxed = columnType.GetUnboxedType(); var targetTypeUnboxed = targetTypeBoxed.GetUnboxedType(); if (!columnType.IsAssignmentCompatible(writeablePropertyType) && !columnTypeUnboxed.IsAssignmentCompatible(targetTypeUnboxed)) { // Arrays can be assigned to each other if the underlying target types // can be assigned from one another. if (columnType.IsArray && targetTypeBoxed.IsArray && columnType.GetArrayRank() == targetTypeBoxed.GetArrayRank()) { var columnElementType = columnType.GetElementType(); var targetElementType = targetTypeBoxed.GetElementType(); if (columnElementType.IsAssignmentCompatible(targetElementType)) { return new TypeWidenerCompatibleArrayCoercer( columnElementType, targetElementType); } } var writablePropName = writeablePropertyType.CleanName(); if (writeablePropertyType.IsArray) { writablePropName = writeablePropertyType.GetElementType().CleanName() + "[]"; } var columnTypeName = columnType.CleanName(); if (columnType.IsArray) { columnTypeName = columnType.GetElementType().CleanName() + "[]"; } var message = "Invalid assignment of column '" + columnName + "' of type '" + columnTypeName + "' to event property '" + writeablePropertyName + "' typed as '" + writablePropName + "', column and parameter types mismatch"; throw new TypeWidenerException(message); } if (writeablePropertyType.IsNumeric()) { return new TypeWidenerBoxedNumeric( SimpleNumberCoercerFactory.GetCoercer(columnTypeBoxed, targetTypeBoxed)); } } return null; }
/// <summary>Returns the widener. </summary> /// <param name="columnName">name of column</param> /// <param name="columnType">type of column</param> /// <param name="writeablePropertyType">property type</param> /// <param name="writeablePropertyName">propery name</param> /// <param name="allowObjectArrayToCollectionConversion">whether we widen object-array to collection</param> /// <param name="customizer">customization if any</param> /// <param name="engineURI">engine URI</param> /// <param name="statementName">statement name</param> /// <exception cref="ExprValidationException">if type validation fails</exception> /// <returns>type widender</returns> /// <throws>ExprValidationException if type validation fails</throws> public static TypeWidener GetCheckPropertyAssignType( String columnName, Type columnType, Type writeablePropertyType, String writeablePropertyName, bool allowObjectArrayToCollectionConversion, TypeWidenerCustomizer customizer, string statementName, string engineURI) { Type columnClassBoxed = TypeHelper.GetBoxedType(columnType); Type targetClassBoxed = TypeHelper.GetBoxedType(writeablePropertyType); if (customizer != null) { TypeWidener custom = customizer.WidenerFor(columnName, columnType, writeablePropertyType, writeablePropertyName, statementName, engineURI); if (custom != null) { return(custom); } } if (columnType == null) { if (writeablePropertyType.IsPrimitive) { String message = "Invalid assignment of column '" + columnName + "' of null type to event property '" + writeablePropertyName + "' typed as '" + writeablePropertyType.FullName + "', nullable type mismatch"; throw new ExprValidationException(message); } } else if (columnClassBoxed != targetClassBoxed) { if (columnClassBoxed == typeof(string) && targetClassBoxed == typeof(char?)) { return(TypeWidenerStringToCharCoercer.Widen); } if (allowObjectArrayToCollectionConversion && columnClassBoxed.IsArray && !columnClassBoxed.GetElementType().IsPrimitive && targetClassBoxed.IsGenericCollection()) { return(OBJECT_ARRAY_TO_COLLECTION_COERCER); } if (columnClassBoxed.IsGenericDictionary() && targetClassBoxed.IsGenericDictionary()) { var columnClassGenerics = columnClassBoxed.GetGenericArguments(); var targetClassGenerics = targetClassBoxed.GetGenericArguments(); var transformMethod = typeof(TransformDictionaryFactory) .GetMethod("Create", new[] { typeof(object) }) .MakeGenericMethod(targetClassGenerics[0], targetClassGenerics[1], columnClassGenerics[0], columnClassGenerics[1]); return(source => { var parameters = new object[] { source }; return transformMethod.Invoke(null, BindingFlags.Static | BindingFlags.Public, null, parameters, null); }); } if ((columnClassBoxed == typeof(string)) && (targetClassBoxed == typeof(char[]))) { return(source => { var sourceAsString = (string)source; return sourceAsString != null?sourceAsString.ToCharArray() : null; }); } if ((columnClassBoxed == typeof(char[])) && (targetClassBoxed == typeof(string))) { return(source => { var sourceAsCharArray = (char[])source; return sourceAsCharArray != null ? new string(sourceAsCharArray) : null; }); } if (columnClassBoxed.IsArray && targetClassBoxed.IsArray) { var columnClassElement = columnClassBoxed.GetElementType(); var targetClassElement = targetClassBoxed.GetElementType(); if (columnClassElement.IsAssignmentCompatible(targetClassElement)) { // By definition, columnClassElement and targetClassElement should be // incompatible. Question is, can we find a coercer between them? var coercer = CoercerFactory.GetCoercer(columnClassElement, targetClassElement); return(source => WidenArray(source, targetClassElement, coercer)); } } if (!columnClassBoxed.IsAssignmentCompatible(targetClassBoxed)) { var writablePropName = writeablePropertyType.FullName; if (writeablePropertyType.IsArray) { writablePropName = writeablePropertyType.GetElementType().FullName + "[]"; } var columnTypeName = columnType.FullName; if (columnType.IsArray) { columnTypeName = columnType.GetElementType().FullName + "[]"; } String message = "Invalid assignment of column '" + columnName + "' of type '" + columnTypeName + "' to event property '" + writeablePropertyName + "' typed as '" + writablePropName + "', column and parameter types mismatch"; throw new ExprValidationException(message); } if (writeablePropertyType.IsNumeric()) { var instance = new TypeWidenerBoxedNumeric( CoercerFactory.GetCoercer(columnClassBoxed, targetClassBoxed)); return(instance.Widen); } } return(null); }