private static DeliveryConvertor DetermineWideningDeliveryConvertor( bool firstParameterIsEPStatement, EPStatement statement, Type[] selectClauseTypes, Type[] parameterTypes, MethodInfo method, string engineURI) { var needWidener = false; for (var i = 0; i < selectClauseTypes.Length; i++) { var optionalWidener = GetWidener(i, selectClauseTypes[i], parameterTypes[i], method, statement.Name, engineURI); if (optionalWidener != null) { needWidener = true; break; } } if (!needWidener) { return(firstParameterIsEPStatement ? (DeliveryConvertor) new DeliveryConvertorNullWStatement(statement) : (DeliveryConvertor)DeliveryConvertorNull.INSTANCE); } var wideners = new TypeWidener[selectClauseTypes.Length]; for (var i = 0; i < selectClauseTypes.Length; i++) { wideners[i] = GetWidener(i, selectClauseTypes[i], parameterTypes[i], method, statement.Name, engineURI); } return(firstParameterIsEPStatement ? (DeliveryConvertor) new DeliveryConvertorWidenerWStatement(wideners, statement) : (DeliveryConvertor) new DeliveryConvertorWidener(wideners)); }
internal Item(int toIndex, int optionalFromIndex, ExprEvaluator evaluator, TypeWidener optionalWidener) { ToIndex = toIndex; OptionalFromIndex = optionalFromIndex; Evaluator = evaluator; OptionalWidener = optionalWidener; }
internal Item(int toIndex, String optionalPropertyName, ExprEvaluator evaluator, TypeWidener optionalWidener) { ToIndex = toIndex; OptionalPropertyName = optionalPropertyName; Evaluator = evaluator; OptionalWidener = optionalWidener; }
private static DeliveryConvertor DetermineWideningDeliveryConvertor(Type[] selectClauseTypes, Type[] parameterTypes, MethodInfo method) { bool needWidener = false; for (int i = 0; i < selectClauseTypes.Length; i++) { TypeWidener optionalWidener = GetWidener(i, selectClauseTypes[i], parameterTypes[i], method); if (optionalWidener != null) { needWidener = true; break; } } if (!needWidener) { return(DeliveryConvertorNull.INSTANCE); } var wideners = new TypeWidener[selectClauseTypes.Length]; for (int i = 0; i < selectClauseTypes.Length; i++) { wideners[i] = GetWidener(i, selectClauseTypes[i], parameterTypes[i], method); } return(new DeliveryConvertorWidener(wideners)); }
internal Item(Field toToField, Field optionalFromField, ExprEvaluator evaluator, TypeWidener optionalWidener) { ToField = toToField; OptionalFromField = optionalFromField; Evaluator = evaluator; OptionalWidener = optionalWidener; }
public EventBeanUpdateItem( ExprEvaluator expression, string optinalPropertyName, EventPropertyWriter optionalWriter, bool notNullableField, TypeWidener optionalWidener) { Expression = expression; OptionalPropertyName = optinalPropertyName; OptionalWriter = optionalWriter; IsNotNullableField = notNullableField; OptionalWidener = optionalWidener; }
public InternalEventRouterDesc GetValidatePreprocessing(EventType eventType, UpdateDesc desc, Attribute[] annotations) { if (Log.IsDebugEnabled) { Log.Debug("Validating route preprocessing for type '" + eventType.Name + "'"); } if (!(eventType is EventTypeSPI)) { throw new ExprValidationException("Update statements require the event type to implement the " + typeof(EventTypeSPI) + " interface"); } var eventTypeSPI = (EventTypeSPI)eventType; var wideners = new TypeWidener[desc.Assignments.Count]; var properties = new List <String>(); for (int i = 0; i < desc.Assignments.Count; i++) { var xxx = desc.Assignments[i]; var assignmentPair = ExprNodeUtility.CheckGetAssignmentToProp(xxx.Expression); if (assignmentPair == null) { throw new ExprValidationException("Missing property assignment expression in assignment number " + i); } var writableProperty = eventTypeSPI.GetWritableProperty(assignmentPair.First); if (writableProperty == null) { throw new ExprValidationException("Property '" + assignmentPair.First + "' is not available for write access"); } wideners[i] = TypeWidenerFactory.GetCheckPropertyAssignType( ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(assignmentPair.Second), assignmentPair.Second.ExprEvaluator.ReturnType, writableProperty.PropertyType, assignmentPair.First); properties.Add(assignmentPair.First); } // check copy-able var copyMethod = eventTypeSPI.GetCopyMethod(properties.ToArray()); if (copyMethod == null) { throw new ExprValidationException("The update-clause requires the underlying event representation to support copy (via Serializable by default)"); } return(new InternalEventRouterDesc(desc, copyMethod, wideners, eventType, annotations)); }
private static SelectExprProcessor InitializeJoinWildcardInternal( EventType eventType, ICollection <WriteablePropertyDescriptor> writables, string[] streamNames, EventType[] streamTypes, EngineImportService engineImportService, EventAdapterService eventAdapterService, string statementName, string engineURI) { var typeWidenerCustomizer = eventAdapterService.GetTypeWidenerCustomizer(eventType); var writablePropertiesList = new List <WriteablePropertyDescriptor>(); var evaluatorsList = new List <ExprEvaluator>(); var widenersList = new List <TypeWidener>(); // loop over all columns selected, if any for (var i = 0; i < streamNames.Length; i++) { WriteablePropertyDescriptor selectedWritable = null; TypeWidener widener = null; foreach (var desc in writables) { if (!desc.PropertyName.Equals(streamNames[i])) { continue; } widener = TypeWidenerFactory.GetCheckPropertyAssignType( streamNames[i], streamTypes[i].UnderlyingType, desc.PropertyType, desc.PropertyName, false, typeWidenerCustomizer, statementName, engineURI); selectedWritable = desc; break; } if (selectedWritable == null) { var message = "Stream underlying object for stream '" + streamNames[i] + "' could not be assigned to any of the properties of the underlying type (missing column names, event property or setter method?)"; throw new ExprValidationException(message); } var streamNum = i; var returnType = streamTypes[streamNum].UnderlyingType; var evaluator = new ProxyExprEvaluator { ProcEvaluate = evaluateParams => { EventBean theEvent = evaluateParams.EventsPerStream[streamNum]; if (theEvent != null) { return(theEvent.Underlying); } return(null); }, ProcReturnType = () => returnType }; // add writablePropertiesList.Add(selectedWritable); evaluatorsList.Add(evaluator); widenersList.Add(widener); } // assign var writableProperties = writablePropertiesList.ToArray(); var exprEvaluators = evaluatorsList.ToArray(); var wideners = widenersList.ToArray(); EventBeanManufacturer eventManufacturer; try { eventManufacturer = eventAdapterService.GetManufacturer( eventType, writableProperties, engineImportService, false); } catch (EventBeanManufactureException e) { throw new ExprValidationException(e.Message, e); } return(new SelectExprInsertNativeWidening(eventType, eventManufacturer, exprEvaluators, wideners)); }
private static SelectExprProcessor InitializeSetterManufactor( EventType eventType, ICollection <WriteablePropertyDescriptor> writables, bool isUsingWildcard, StreamTypeService typeService, ExprEvaluator[] expressionNodes, string[] columnNames, Object[] expressionReturnTypes, EngineImportService engineImportService, EventAdapterService eventAdapterService, string statementName) { var typeWidenerCustomizer = eventAdapterService.GetTypeWidenerCustomizer(eventType); var writablePropertiesList = new List <WriteablePropertyDescriptor>(); var evaluatorsList = new List <ExprEvaluator>(); var widenersList = new List <TypeWidener>(); // loop over all columns selected, if any for (var i = 0; i < columnNames.Length; i++) { WriteablePropertyDescriptor selectedWritable = null; TypeWidener widener = null; var evaluator = expressionNodes[i]; foreach (var desc in writables) { if (!desc.PropertyName.Equals(columnNames[i])) { continue; } var columnType = expressionReturnTypes[i]; if (columnType == null) { TypeWidenerFactory.GetCheckPropertyAssignType( columnNames[i], null, desc.PropertyType, desc.PropertyName, false, typeWidenerCustomizer, statementName, typeService.EngineURIQualifier); } else if (columnType is EventType) { var columnEventType = (EventType)columnType; var returnType = columnEventType.UnderlyingType; widener = TypeWidenerFactory.GetCheckPropertyAssignType( columnNames[i], columnEventType.UnderlyingType, desc.PropertyType, desc.PropertyName, false, typeWidenerCustomizer, statementName, typeService.EngineURIQualifier); // handle evaluator returning an event if (TypeHelper.IsSubclassOrImplementsInterface(returnType, desc.PropertyType)) { selectedWritable = desc; widener = input => { var eventBean = input as EventBean; if (eventBean != null) { return(eventBean.Underlying); } return(input); }; continue; } // find stream var streamNum = 0; for (var j = 0; j < typeService.EventTypes.Length; j++) { if (Equals(typeService.EventTypes[j], columnEventType)) { streamNum = j; break; } } var streamNumEval = streamNum; evaluator = new ProxyExprEvaluator { ProcEvaluate = evaluateParams => { EventBean theEvent = evaluateParams.EventsPerStream[streamNumEval]; if (theEvent != null) { return(theEvent.Underlying); } return(null); }, ProcReturnType = () => returnType }; } else if (columnType is EventType[]) { // handle case where the select-clause contains an fragment array var columnEventType = ((EventType[])columnType)[0]; var componentReturnType = columnEventType.UnderlyingType; var arrayReturnType = Array.CreateInstance(componentReturnType, 0).GetType(); var allowObjectArrayToCollectionConversion = eventType is AvroSchemaEventType; widener = TypeWidenerFactory.GetCheckPropertyAssignType( columnNames[i], arrayReturnType, desc.PropertyType, desc.PropertyName, allowObjectArrayToCollectionConversion, typeWidenerCustomizer, statementName, typeService.EngineURIQualifier); var inner = evaluator; evaluator = new ProxyExprEvaluator { ProcEvaluate = evaluateParams => { var result = inner.Evaluate(evaluateParams); if (!(result is EventBean[])) { return(null); } var events = (EventBean[])result; var values = Array.CreateInstance(componentReturnType, events.Length); for (var ii = 0; ii < events.Length; ii++) { values.SetValue(events[ii].Underlying, ii); } return(values); }, ProcReturnType = () => componentReturnType }; } else if (!(columnType is Type)) { var message = "Invalid assignment of column '" + columnNames[i] + "' of type '" + columnType + "' to event property '" + desc.PropertyName + "' typed as '" + desc.PropertyType.FullName + "', column and parameter types mismatch"; throw new ExprValidationException(message); } else { widener = TypeWidenerFactory.GetCheckPropertyAssignType( columnNames[i], (Type)columnType, desc.PropertyType, desc.PropertyName, false, typeWidenerCustomizer, statementName, typeService.EngineURIQualifier); } selectedWritable = desc; break; } if (selectedWritable == null) { var message = "Column '" + columnNames[i] + "' could not be assigned to any of the properties of the underlying type (missing column names, event property, setter method or constructor?)"; throw new ExprValidationException(message); } // add writablePropertiesList.Add(selectedWritable); evaluatorsList.Add(evaluator); widenersList.Add(widener); } // handle wildcard if (isUsingWildcard) { var sourceType = typeService.EventTypes[0]; foreach (var eventPropDescriptor in sourceType.PropertyDescriptors) { if (eventPropDescriptor.RequiresIndex || (eventPropDescriptor.RequiresMapKey)) { continue; } WriteablePropertyDescriptor selectedWritable = null; TypeWidener widener = null; ExprEvaluator evaluator = null; foreach (var writableDesc in writables) { if (!writableDesc.PropertyName.Equals(eventPropDescriptor.PropertyName)) { continue; } widener = TypeWidenerFactory.GetCheckPropertyAssignType( eventPropDescriptor.PropertyName, eventPropDescriptor.PropertyType, writableDesc.PropertyType, writableDesc.PropertyName, false, typeWidenerCustomizer, statementName, typeService.EngineURIQualifier); selectedWritable = writableDesc; var propertyName = eventPropDescriptor.PropertyName; var propertyType = eventPropDescriptor.PropertyType; evaluator = new ProxyExprEvaluator { ProcEvaluate = evaluateParams => { EventBean theEvent = evaluateParams.EventsPerStream[0]; if (theEvent != null) { return(theEvent.Get(propertyName)); } return(null); }, ProcReturnType = () => propertyType }; break; } if (selectedWritable == null) { var message = "Event property '" + eventPropDescriptor.PropertyName + "' could not be assigned to any of the properties of the underlying type (missing column names, event property, setter method or constructor?)"; throw new ExprValidationException(message); } writablePropertiesList.Add(selectedWritable); evaluatorsList.Add(evaluator); widenersList.Add(widener); } } // assign var writableProperties = writablePropertiesList.ToArray(); var exprEvaluators = evaluatorsList.ToArray(); var wideners = widenersList.ToArray(); EventBeanManufacturer eventManufacturer; try { eventManufacturer = eventAdapterService.GetManufacturer( eventType, writableProperties, engineImportService, false); } catch (EventBeanManufactureException e) { throw new ExprValidationException(e.Message, e); } return(new SelectExprInsertNativeWidening(eventType, eventManufacturer, exprEvaluators, wideners)); }
public static SelectExprProcessor Make(EventType[] eventTypes, SelectExprContext selectExprContext, int streamNumber, EventType targetType, ExprNode[] exprNodes, EngineImportService engineImportService) { var mapResultType = (MapEventType)targetType; var mapStreamType = (MapEventType)eventTypes[streamNumber]; // (A) fully assignment-compatible: same number, name and type of fields, no additional expressions: Straight repackage String typeSameMssage = BaseNestableEventType.IsDeepEqualsProperties(mapResultType.Name, mapResultType.Types, mapStreamType.Types); if (typeSameMssage == null && selectExprContext.ExpressionNodes.Length == 0) { return(new MapInsertProcessorSimpleRepackage(selectExprContext, streamNumber, targetType)); } // (B) not completely assignable: find matching properties ICollection <WriteablePropertyDescriptor> writables = selectExprContext.EventAdapterService.GetWriteableProperties(mapResultType, true); IList <Item> items = new List <Item>(); IList <WriteablePropertyDescriptor> written = new List <WriteablePropertyDescriptor>(); // find the properties coming from the providing source stream int count = 0; foreach (WriteablePropertyDescriptor writeable in writables) { String propertyName = writeable.PropertyName; if (mapStreamType.Types.ContainsKey(propertyName)) { Object setOneType = mapStreamType.Types.Get(propertyName); Object setTwoType = mapResultType.Types.Get(propertyName); bool setTwoTypeFound = mapResultType.Types.ContainsKey(propertyName); String message = BaseNestableEventUtil.ComparePropType(propertyName, setOneType, setTwoType, setTwoTypeFound, mapResultType.Name); if (message != null) { throw new ExprValidationException(message); } items.Add(new Item(count, propertyName, null, null)); written.Add(writeable); count++; } } // find the properties coming from the expressions of the select clause for (int i = 0; i < selectExprContext.ExpressionNodes.Length; i++) { String columnName = selectExprContext.ColumnNames[i]; ExprEvaluator evaluator = selectExprContext.ExpressionNodes[i]; ExprNode exprNode = exprNodes[i]; WriteablePropertyDescriptor writable = FindWritable(columnName, writables); if (writable == null) { throw new ExprValidationException("Failed to find column '" + columnName + "' in target type '" + mapResultType.Name + "'"); } TypeWidener widener = TypeWidenerFactory.GetCheckPropertyAssignType( ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(exprNode), exprNode.ExprEvaluator.ReturnType, writable.PropertyType, columnName); items.Add(new Item(count, null, evaluator, widener)); written.Add(writable); count++; } // make manufacturer Item[] itemsArr = items.ToArray(); EventBeanManufacturer manufacturer; try { manufacturer = selectExprContext.EventAdapterService.GetManufacturer(mapResultType, written.ToArray(), engineImportService, true); } catch (EventBeanManufactureException e) { throw new ExprValidationException("Failed to write to type: " + e.Message, e); } return(new MapInsertProcessorAllocate(streamNumber, itemsArr, manufacturer, targetType)); }
/// <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); }
public SelectExprProcessorEvalAvroArrayCoercer(ExprEvaluator eval, TypeWidener widener) { _eval = eval; _widener = widener; }