public override CodegenExpression Codegen(
InternalEventRouterWriterForge writer,
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
var method = parent
.MakeChild(typeof(InternalEventRouterWriterArrayElement), GetType(), classScope);
var indexExpr = ExprNodeUtilityCodegen.CodegenEvaluator(
_indexExpression.Forge,
method,
typeof(VariableTriggerWriteArrayElementForge),
classScope);
var rhsExpr = ExprNodeUtilityCodegen.CodegenEvaluator(
_rhsExpression.Forge,
method,
typeof(VariableTriggerWriteArrayElementForge),
classScope);
var typeWidenerExpr = _widener == null
? ConstantNull()
: TypeWidenerFactory.CodegenWidener(_widener, method, GetType(), classScope);
method.Block
.DeclareVar <InternalEventRouterWriterArrayElement>("desc", NewInstance(typeof(InternalEventRouterWriterArrayElement)))
.SetProperty(Ref("desc"), "IndexExpression", indexExpr)
.SetProperty(Ref("desc"), "RhsExpression", rhsExpr)
.SetProperty(Ref("desc"), "TypeWidener", typeWidenerExpr)
.SetProperty(Ref("desc"), "PropertyName", Constant(_propertyName))
.MethodReturn(Ref("desc"));
return(LocalMethod(method));
}
private static TypeWidener GetWidener(
int columnNum,
Type selectClauseType,
Type parameterType,
MethodInfo method,
string statementName,
string engineURI)
{
if (selectClauseType == null || parameterType == null)
{
return(null);
}
if (selectClauseType == parameterType)
{
return(null);
}
try
{
return(TypeWidenerFactory.GetCheckPropertyAssignType(
"Select-Clause Column " + columnNum, selectClauseType, parameterType,
"Method Parameter " + columnNum, false, null,
statementName, engineURI));
}
catch (ExprValidationException e)
{
throw new EPException(
"Unexpected exception assigning select clause columns to subscriber method " + method + ": " +
e.Message, e);
}
}
public TypeWidener WidenerFor(string columnName, Type columnType, Type writeablePropertyType, string writeablePropertyName, string statementName, string engineURI)
{
//if (columnType == typeof(byte[]) && writeablePropertyType == typeof(ByteBuffer))
//{
// return BYTE_ARRAY_TO_BYTE_BUFFER_COERCER;
//}
if (columnType != null && columnType.IsArray && writeablePropertyType.IsGenericCollection())
{
return(TypeWidenerFactory.GetArrayToCollectionCoercer(
columnType.GetElementType()));
}
return(null);
}
public TypeWidenerSPI WidenerFor(
string columnName,
Type columnType,
Type writeablePropertyType,
string writeablePropertyName,
string statementName)
{
if (columnType != null && columnType.IsArray && writeablePropertyType.IsGenericCollection()) {
return TypeWidenerFactory.GetArrayToCollectionCoercer(columnType.GetElementType());
}
return null;
}
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 CodegenExpression MakeWideners(
TypeWidenerSPI[] wideners,
CodegenMethod method,
CodegenClassScope classScope)
{
var init = new CodegenExpression[wideners.Length];
for (var i = 0; i < init.Length; i++) {
if (wideners[i] != null) {
init[i] = TypeWidenerFactory.CodegenWidener(wideners[i], method, GetType(), classScope);
}
else {
init[i] = ConstantNull();
}
}
return NewArrayWithInit(typeof(TypeWidener), init);
}
public override CodegenExpression Make(
CodegenMethodScope parent,
SAIFFInitializeSymbol symbols,
CodegenClassScope classScope)
{
CodegenMethod method = parent.MakeChild(typeof(VariableTriggerWriteArrayElement), this.GetType(), classScope);
method.Block
.DeclareVar <VariableTriggerWriteArrayElement>("desc", NewInstance(typeof(VariableTriggerWriteArrayElement)))
.SetProperty(Ref("desc"), "VariableName", Constant(variableName))
.SetProperty(
Ref("desc"),
"IndexExpression",
ExprNodeUtilityCodegen.CodegenEvaluator(indexExpression, method, typeof(VariableTriggerWriteArrayElementForge), classScope))
.SetProperty(
Ref("desc"),
"TypeWidener",
widener == null ? ConstantNull() : TypeWidenerFactory.CodegenWidener(widener, method, this.GetType(), classScope))
.MethodReturn(Ref("desc"));
return(LocalMethod(method));
}
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 DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext context)
{
_initialDelayMSec = (long)(initialDelay * 1000);
_periodDelayMSec = (long)(interval * 1000);
if (context.OutputPorts.Count != 1)
{
throw new ArgumentException(
"BeaconSource operator requires one output stream but produces " + context.OutputPorts.Count +
" streams");
}
// Check if a type is declared
var port = context.OutputPorts[0];
ICollection <string> props;
if (port.OptionalDeclaredType != null && port.OptionalDeclaredType.EventType != null)
{
var outputEventType = port.OptionalDeclaredType.EventType;
_produceEventBean = port.OptionalDeclaredType != null && !port.OptionalDeclaredType.IsUnderlying;
// compile properties to populate
props = _allProperties.Keys;
props.RemoveAll(PARAMETER_PROPERTIES);
var writables = SetupProperties(props.ToArray(), outputEventType, context.StatementContext);
_manufacturer = context.ServicesContext.EventAdapterService.GetManufacturer(
outputEventType, writables, context.ServicesContext.EngineImportService, false);
var index = 0;
_evaluators = new ExprEvaluator[writables.Length];
TypeWidenerCustomizer typeWidenerCustomizer =
context.ServicesContext.EventAdapterService.GetTypeWidenerCustomizer(outputEventType);
foreach (var writeable in writables)
{
var providedProperty = _allProperties.Get(writeable.PropertyName);
if (providedProperty is ExprNode)
{
var exprNode = (ExprNode)providedProperty;
var validated = ExprNodeUtility.ValidateSimpleGetSubtree(
ExprNodeOrigin.DATAFLOWBEACON, exprNode, context.StatementContext, null, false);
var exprEvaluator = validated.ExprEvaluator;
var widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(validated), exprEvaluator.ReturnType,
writeable.PropertyType, writeable.PropertyName, false, typeWidenerCustomizer,
context.StatementContext.StatementName, context.Engine.URI);
if (widener != null)
{
_evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams =>
{
var value = exprEvaluator.Evaluate(evaluateParams);
return(widener.Invoke(value));
},
ProcReturnType = () => null
};
}
else
{
_evaluators[index] = exprEvaluator;
}
}
else if (providedProperty == null)
{
_evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams => null,
ProcReturnType = () => null
};
}
else
{
_evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams => providedProperty,
ProcReturnType = () => providedProperty.GetType()
};
}
index++;
}
return(null); // no changing types
}
// No type has been declared, we can create one
var anonymousTypeName = context.DataflowName + "-beacon";
var types = new LinkedHashMap <string, Object>();
props = _allProperties.Keys;
props.RemoveAll(PARAMETER_PROPERTIES);
var count = 0;
_evaluators = new ExprEvaluator[props.Count];
foreach (var propertyName in props)
{
var exprNode = (ExprNode)_allProperties.Get(propertyName);
var validated = ExprNodeUtility.ValidateSimpleGetSubtree(ExprNodeOrigin.DATAFLOWBEACON, exprNode, context.StatementContext, null, false);
var evaluateParamsX = new EvaluateParams(null, true, context.AgentInstanceContext);
var value = validated.ExprEvaluator.Evaluate(evaluateParamsX);
if (value == null)
{
types.Put(propertyName, null);
}
else
{
types.Put(propertyName, value.GetType());
}
_evaluators[count] = new ProxyExprEvaluator()
{
ProcEvaluate = (evaluateParams) => value,
ProcReturnType = () => null
};
count++;
}
EventType type =
context.ServicesContext.EventAdapterService.CreateAnonymousObjectArrayType(anonymousTypeName, types);
return(new DataFlowOpInitializeResult(
new GraphTypeDesc[]
{
new GraphTypeDesc(false, true, type)
}));
}
public static SelectExprProcessorForge Make(
EventType[] eventTypes,
SelectExprForgeContext selectExprForgeContext,
int streamNumber,
AvroSchemaEventType targetType,
ExprNode[] exprNodes,
string statementName)
{
AvroEventType resultType = (AvroEventType) targetType;
AvroEventType streamType = (AvroEventType) eventTypes[streamNumber];
// (A) fully assignment-compatible: same number, name and type of fields, no additional expressions: Straight repackage
if (resultType.Schema.Equals(streamType.Schema) && selectExprForgeContext.ExprForges.Length == 0) {
return new AvroInsertProcessorSimpleRepackage(selectExprForgeContext, streamNumber, targetType);
}
// (B) not completely assignable: find matching properties
var writables = EventTypeUtility.GetWriteableProperties(resultType, true, false);
IList<Item> items = new List<Item>();
IList<WriteablePropertyDescriptor> written = new List<WriteablePropertyDescriptor>();
// find the properties coming from the providing source stream
foreach (var writeable in writables) {
var propertyName = writeable.PropertyName;
Field streamTypeField = streamType.SchemaAvro.GetField(propertyName);
Field resultTypeField = resultType.SchemaAvro.GetField(propertyName);
if (streamTypeField != null && resultTypeField != null) {
if (streamTypeField.Schema.Equals(resultTypeField.Schema)) {
items.Add(new Item(resultTypeField, streamTypeField, null, null));
}
else {
throw new ExprValidationException(
"Type by name '" +
resultType.Name +
"' " +
"in property '" +
propertyName +
"' expected schema '" +
resultTypeField.Schema +
"' but received schema '" +
streamTypeField.Schema +
"'");
}
}
}
// find the properties coming from the expressions of the select clause
var typeWidenerCustomizer =
selectExprForgeContext.EventTypeAvroHandler.GetTypeWidenerCustomizer(targetType);
for (var i = 0; i < selectExprForgeContext.ExprForges.Length; i++) {
var columnName = selectExprForgeContext.ColumnNames[i];
var exprNode = exprNodes[i];
var writable = FindWritable(columnName, writables);
if (writable == null) {
throw new ExprValidationException(
"Failed to find column '" + columnName + "' in target type '" + resultType.Name + "'");
}
Field resultTypeField = resultType.SchemaAvro.GetField(writable.PropertyName);
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(exprNode),
exprNode.Forge.EvaluationType,
writable.PropertyType,
columnName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
items.Add(new Item(resultTypeField, null, exprNode.Forge, widener));
written.Add(writable);
}
// make manufacturer
Item[] itemsArr = items.ToArray();
return new AvroInsertProcessorAllocate(
streamNumber,
itemsArr,
resultType,
resultType.SchemaAvro,
selectExprForgeContext.EventBeanTypedEventFactory);
}
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));
}
public static EventBeanUpdateHelper Make(
string updatedWindowOrTableName,
EventTypeSPI eventTypeSPI,
IList <OnTriggerSetAssignment> assignments,
string updatedAlias,
EventType optionalTriggeringEventType,
bool isCopyOnWrite)
{
IList <EventBeanUpdateItem> updateItems = new List <EventBeanUpdateItem>();
IList <string> properties = new List <string>();
for (var i = 0; i < assignments.Count; i++)
{
var assignment = assignments[i];
EventBeanUpdateItem updateItem;
// determine whether this is a "property=value" assignment, we use property setters in this case
var possibleAssignment = ExprNodeUtility.CheckGetAssignmentToProp(assignment.Expression);
// handle assignment "property = value"
if (possibleAssignment != null)
{
var propertyName = possibleAssignment.First;
var writableProperty = eventTypeSPI.GetWritableProperty(propertyName);
// check assignment to indexed or mapped property
if (writableProperty == null)
{
var nameWriteablePair = CheckIndexedOrMappedProp(possibleAssignment.First, updatedWindowOrTableName, updatedAlias, eventTypeSPI);
propertyName = nameWriteablePair.First;
writableProperty = nameWriteablePair.Second;
}
var evaluator = possibleAssignment.Second.ExprEvaluator;
var writers = eventTypeSPI.GetWriter(propertyName);
var notNullableField = writableProperty.PropertyType.IsPrimitive;
properties.Add(propertyName);
var widener = TypeWidenerFactory.GetCheckPropertyAssignType(ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(possibleAssignment.Second), possibleAssignment.Second.ExprEvaluator.ReturnType,
writableProperty.PropertyType, propertyName);
// check event type assignment
if (optionalTriggeringEventType != null && possibleAssignment.Second is ExprIdentNode)
{
var node = (ExprIdentNode)possibleAssignment.Second;
var fragmentRHS = optionalTriggeringEventType.GetFragmentType(node.ResolvedPropertyName);
var fragmentLHS = eventTypeSPI.GetFragmentType(possibleAssignment.First);
if (fragmentRHS != null && fragmentLHS != null && !EventTypeUtility.IsTypeOrSubTypeOf(fragmentRHS.FragmentType, fragmentLHS.FragmentType))
{
throw new ExprValidationException("Invalid assignment to property '" +
possibleAssignment.First + "' event type '" + fragmentLHS.FragmentType.Name +
"' from event type '" + fragmentRHS.FragmentType.Name + "'");
}
}
updateItem = new EventBeanUpdateItem(evaluator, propertyName, writers, notNullableField, widener);
}
// handle non-assignment, i.e. UDF or other expression
else
{
var evaluator = assignment.Expression.ExprEvaluator;
updateItem = new EventBeanUpdateItem(evaluator, null, null, false, null);
}
updateItems.Add(updateItem);
}
// copy-on-write is the default event semantics as events are immutable
EventBeanCopyMethod copyMethod;
if (isCopyOnWrite)
{
// obtain copy method
IList <string> propertiesUniqueList = new List <string>(new HashSet <string>(properties));
var propertiesArray = propertiesUniqueList.ToArray();
copyMethod = eventTypeSPI.GetCopyMethod(propertiesArray);
if (copyMethod == null)
{
throw new ExprValidationException("Event type does not support event bean copy");
}
}
else
{
// for in-place update, determine assignment expressions to use "initial" to access prior-change values
// the copy-method is optional
copyMethod = null;
var propertiesInitialValue = DeterminePropertiesInitialValue(assignments);
if (!propertiesInitialValue.IsEmpty())
{
var propertiesInitialValueArray = propertiesInitialValue.ToArray();
copyMethod = eventTypeSPI.GetCopyMethod(propertiesInitialValueArray);
}
}
var updateItemsArray = updateItems.ToArray();
return(new EventBeanUpdateHelper(copyMethod, updateItemsArray));
}
public static InternalEventRouterDescForge GetValidatePreprocessing(
EventType eventType,
UpdateDesc desc,
Attribute[] annotations)
{
if (!(eventType is EventTypeSPI)) {
throw new ExprValidationException(
"Update statements require the event type to implement the " + typeof(EventTypeSPI) + " interface");
}
var eventTypeSPI = (EventTypeSPI) eventType;
var size = desc.Assignments.Count;
var wideners = new TypeWidenerSPI[size];
var properties = new string[size];
var expressions = new ExprNode[size];
for (var i = 0; i < size; i++) {
var onSet = desc.Assignments[i];
var assignmentPair = ExprNodeUtilityValidate.CheckGetAssignmentToProp(onSet.Expression);
if (assignmentPair == null) {
throw new ExprValidationException(
"Missing property assignment expression in assignment number " + i);
}
properties[i] = assignmentPair.First;
expressions[i] = assignmentPair.Second;
var writableProperty = eventTypeSPI.GetWritableProperty(assignmentPair.First);
if (writableProperty == null) {
throw new ExprValidationException(
"Property '" + assignmentPair.First + "' is not available for write access");
}
try {
wideners[i] = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignmentPair.Second),
assignmentPair.Second.Forge.EvaluationType,
writableProperty.PropertyType,
assignmentPair.First,
false,
null,
null);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
}
// check copy-able
var copyMethod = eventTypeSPI.GetCopyMethodForge(properties);
if (copyMethod == null) {
throw new ExprValidationException(
"The update-clause requires the underlying event representation to support copy (via Serializable by default)");
}
return new InternalEventRouterDescForge(
copyMethod,
wideners,
eventType,
annotations,
desc.OptionalWhereClause,
properties,
expressions);
}
private static SelectExprProcessorForge InitializeJoinWildcardInternal(
EventType eventType,
ISet<WriteablePropertyDescriptor> writables,
string[] streamNames,
EventType[] streamTypes,
string statementName,
ImportServiceCompileTime importService,
EventTypeAvroHandler eventTypeAvroHandler)
{
var typeWidenerCustomizer = eventTypeAvroHandler.GetTypeWidenerCustomizer(eventType);
IList<WriteablePropertyDescriptor> writablePropertiesList = new List<WriteablePropertyDescriptor>();
IList<ExprForge> forgesList = new List<ExprForge>();
IList<TypeWidenerSPI> widenersList = new List<TypeWidenerSPI>();
// loop over all columns selected, if any
for (var i = 0; i < streamNames.Length; i++) {
WriteablePropertyDescriptor selectedWritable = null;
TypeWidenerSPI widener = null;
foreach (var desc in writables) {
if (!desc.PropertyName.Equals(streamNames[i])) {
continue;
}
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
streamNames[i],
streamTypes[i].UnderlyingType,
desc.PropertyType,
desc.PropertyName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
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);
}
ExprForge forge = new ExprForgeStreamUnderlying(i, streamTypes[i].UnderlyingType);
// add
writablePropertiesList.Add(selectedWritable);
forgesList.Add(forge);
widenersList.Add(widener);
}
// assign
var writableProperties = writablePropertiesList.ToArray();
var exprForges = forgesList.ToArray();
var wideners = widenersList.ToArray();
EventBeanManufacturerForge eventManufacturer;
try {
eventManufacturer = EventTypeUtility.GetManufacturer(
eventType,
writableProperties,
importService,
false,
eventTypeAvroHandler);
}
catch (EventBeanManufactureException e) {
throw new ExprValidationException(e.Message, e);
}
return new SelectExprInsertNativeWidening(eventType, eventManufacturer, exprForges, wideners);
}
private static SelectExprProcessorForge InitializeSetterManufactor(
EventType eventType,
ISet<WriteablePropertyDescriptor> writables,
bool isUsingWildcard,
StreamTypeService typeService,
ExprForge[] expressionForges,
string[] columnNames,
object[] expressionReturnTypes,
string statementName,
ImportServiceCompileTime importService,
EventTypeAvroHandler eventTypeAvroHandler)
{
var typeWidenerCustomizer = eventTypeAvroHandler.GetTypeWidenerCustomizer(eventType);
IList<WriteablePropertyDescriptor> writablePropertiesList = new List<WriteablePropertyDescriptor>();
IList<ExprForge> forgesList = new List<ExprForge>();
IList<TypeWidenerSPI> widenersList = new List<TypeWidenerSPI>();
// loop over all columns selected, if any
for (var i = 0; i < columnNames.Length; i++) {
WriteablePropertyDescriptor selectedWritable = null;
TypeWidenerSPI widener = null;
var forge = expressionForges[i];
foreach (var desc in writables) {
if (!desc.PropertyName.Equals(columnNames[i])) {
continue;
}
var columnType = expressionReturnTypes[i];
if (columnType == null) {
try {
TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i],
null,
desc.PropertyType,
desc.PropertyName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
}
else if (columnType is EventType) {
var columnEventType = (EventType) columnType;
var returnType = columnEventType.UnderlyingType;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i],
columnEventType.UnderlyingType,
desc.PropertyType,
desc.PropertyName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
// handle evaluator returning an event
if (TypeHelper.IsSubclassOrImplementsInterface(returnType, desc.PropertyType)) {
selectedWritable = desc;
widener = new ProxyTypeWidenerSPI {
ProcWidenResultType = () => desc.PropertyType,
ProcWiden = input => {
if (input is EventBean eventBean) {
return eventBean.Underlying;
}
return input;
},
ProcWidenCodegen = (
expression,
codegenMethodScope,
codegenClassScope) => {
var method = codegenMethodScope
.MakeChild(typeof(object), typeof(TypeWidenerSPI), codegenClassScope)
.AddParam(typeof(object), "input")
.Block
.IfCondition(InstanceOf(Ref("input"), typeof(EventBean)))
.BlockReturn(
ExprDotName(Cast(typeof(EventBean), Ref("input")), "Underlying"))
.MethodReturn(Ref("input"));
return LocalMethodBuild(method).Pass(expression).Call();
}
};
continue;
}
// find stream
var streamNum = 0;
for (var j = 0; j < typeService.EventTypes.Length; j++) {
if (typeService.EventTypes[j] == columnEventType) {
streamNum = j;
break;
}
}
forge = new ExprForgeStreamUnderlying(
streamNum,
typeService.EventTypes[streamNum].UnderlyingType);
}
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 = componentReturnType.MakeArrayType();
var allowObjectArrayToCollectionConversion = eventType is AvroSchemaEventType;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i],
arrayReturnType,
desc.PropertyType,
desc.PropertyName,
allowObjectArrayToCollectionConversion,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
var inner = forge;
forge = new ExprForgeStreamWithInner(inner, componentReturnType);
}
else if (!(columnType is Type columnAsType)) {
var message = "Invalid assignment of column '" +
columnNames[i] +
"' of type '" +
columnType +
"' to event property '" +
desc.PropertyName +
"' typed as '" +
desc.PropertyType.CleanName() +
"', column and parameter types mismatch";
throw new ExprValidationException(message);
}
else {
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
columnNames[i],
(Type) columnType,
desc.PropertyType,
desc.PropertyName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
}
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);
forgesList.Add(forge);
widenersList.Add(widener);
}
// handle wildcard
if (isUsingWildcard) {
var sourceType = typeService.EventTypes[0];
foreach (var eventPropDescriptor in sourceType.PropertyDescriptors) {
if (eventPropDescriptor.IsRequiresIndex || eventPropDescriptor.IsRequiresMapKey) {
continue;
}
WriteablePropertyDescriptor selectedWritable = null;
TypeWidenerSPI widener = null;
ExprForge forge = null;
foreach (var writableDesc in writables) {
if (!writableDesc.PropertyName.Equals(eventPropDescriptor.PropertyName)) {
continue;
}
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
eventPropDescriptor.PropertyName,
eventPropDescriptor.PropertyType,
writableDesc.PropertyType,
writableDesc.PropertyName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
selectedWritable = writableDesc;
var propertyName = eventPropDescriptor.PropertyName;
var getter = ((EventTypeSPI) sourceType).GetGetterSPI(propertyName);
forge = new ExprForgeStreamWithGetter(getter);
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);
forgesList.Add(forge);
widenersList.Add(widener);
}
}
// assign
var writableProperties = writablePropertiesList.ToArray();
var exprForges = forgesList.ToArray();
var wideners = widenersList.ToArray();
EventBeanManufacturerForge eventManufacturer;
try {
eventManufacturer = EventTypeUtility.GetManufacturer(
eventType,
writableProperties,
importService,
false,
eventTypeAvroHandler);
}
catch (EventBeanManufactureException e) {
throw new ExprValidationException(e.Message, e);
}
if (eventManufacturer == null) {
return null;
}
return new SelectExprInsertNativeWidening(eventType, eventManufacturer, exprForges, wideners);
}
private DataFlowOpForgeInitializeResult InitializeTypeDeclared(
DataFlowOpOutputPort port,
DataFlowOpForgeInitializeContext context)
{
produceEventBean = port.OptionalDeclaredType != null && !port.OptionalDeclaredType.IsUnderlying;
// compile properties to populate
outputEventType = port.OptionalDeclaredType.EventType;
var props = allProperties.Keys;
props.RemoveAll(PARAMETER_PROPERTIES);
var writables = SetupProperties(props.ToArray(), outputEventType);
try {
eventBeanManufacturer = EventTypeUtility.GetManufacturer(
outputEventType,
writables,
context.Services.ImportServiceCompileTime,
false,
context.Services.EventTypeAvroHandler);
}
catch (EventBeanManufactureException e) {
throw new ExprValidationException(
"Cannot manufacture event for the provided type '" + outputEventType.Name + "': " + e.Message,
e);
}
var index = 0;
evaluatorForges = new ExprForge[writables.Length];
var typeWidenerCustomizer =
context.Services.EventTypeAvroHandler.GetTypeWidenerCustomizer(outputEventType);
foreach (var writable in writables) {
object providedProperty = allProperties.Get(writable.PropertyName);
var exprNode = (ExprNode) providedProperty;
var validated = EPLValidationUtil.ValidateSimpleGetSubtree(
ExprNodeOrigin.DATAFLOWBEACON,
exprNode,
null,
false,
context.Base.StatementRawInfo,
context.Services);
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(validated),
validated.Forge.EvaluationType,
writable.PropertyType,
writable.PropertyName,
false,
typeWidenerCustomizer,
context.Base.StatementName);
}
catch (TypeWidenerException e) {
throw new ExprValidationException("Failed for property '" + writable.PropertyName + "'", e);
}
if (widener != null) {
evaluatorForges[index] = new ExprEvalWithTypeWidener(widener, validated, writable.PropertyType);
}
else {
evaluatorForges[index] = validated.Forge;
}
index++;
}
return null;
}
public EvalSelectNoWildcardAvro(
SelectExprForgeContext selectExprForgeContext,
ExprForge[] exprForges,
EventType resultEventTypeAvro,
string statementName)
{
_selectExprForgeContext = selectExprForgeContext;
_resultEventTypeAvro = (AvroEventType) resultEventTypeAvro;
_forges = new ExprForge[selectExprForgeContext.ExprForges.Length];
var typeWidenerCustomizer =
selectExprForgeContext.EventTypeAvroHandler.GetTypeWidenerCustomizer(resultEventTypeAvro);
for (var i = 0; i < _forges.Length; i++) {
_forges[i] = selectExprForgeContext.ExprForges[i];
var forge = exprForges[i];
var forgeEvaluationType = forge.EvaluationType;
if (forge is ExprEvalByGetterFragment) {
_forges[i] = HandleFragment((ExprEvalByGetterFragment) forge);
}
else if (forge is ExprEvalStreamInsertBean) {
var und = (ExprEvalStreamInsertBean) forge;
_forges[i] =
new SelectExprInsertEventBeanFactory.ExprForgeStreamUnderlying(und.StreamNum, typeof(object));
}
else if (forge is SelectExprProcessorTypableMapForge) {
var typableMap = (SelectExprProcessorTypableMapForge) forge;
_forges[i] = new SelectExprProcessorEvalAvroMapToAvro(
typableMap.InnerForge,
((AvroEventType) resultEventTypeAvro).SchemaAvro,
selectExprForgeContext.ColumnNames[i]);
}
else if (forge is ExprEvalStreamInsertNamedWindow) {
var nw = (ExprEvalStreamInsertNamedWindow) forge;
_forges[i] =
new SelectExprInsertEventBeanFactory.ExprForgeStreamUnderlying(nw.StreamNum, typeof(object));
}
else if (forgeEvaluationType != null && forgeEvaluationType.IsArray) {
var widener = TypeWidenerFactory.GetArrayToCollectionCoercer(forgeEvaluationType.GetElementType());
var resultType = typeof(ICollection<object>);
_forges[i] = new SelectExprProcessorEvalAvroArrayCoercer(forge, widener, resultType);
}
else {
var propertyName = selectExprForgeContext.ColumnNames[i];
var propertyType = resultEventTypeAvro.GetPropertyType(propertyName);
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
propertyName,
forgeEvaluationType,
propertyType,
propertyName,
true,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
if (widener != null) {
_forges[i] = new SelectExprProcessorEvalAvroArrayCoercer(forge, widener, propertyType);
}
}
}
}
public VariableReadWritePackageForge(
IList <OnTriggerSetAssignment> assignments,
string statementName,
StatementCompileTimeServices services)
{
_variables = new VariableMetaData[assignments.Count];
_mustCoerce = new bool[assignments.Count];
_writers = new VariableTriggerWriteForge[assignments.Count];
_variableTypes = new Dictionary <string, object>();
IDictionary <EventTypeSPI, CopyMethodDesc> eventTypeWrittenProps = new Dictionary <EventTypeSPI, CopyMethodDesc>();
var count = 0;
IList <ExprAssignment> assignmentList = new List <ExprAssignment>();
foreach (var spec in assignments)
{
var assignmentDesc = spec.Validated;
assignmentList.Add(assignmentDesc);
try {
if (assignmentDesc is ExprAssignmentStraight)
{
var assignment = (ExprAssignmentStraight)assignmentDesc;
var identAssignment = assignment.Lhs;
var variableName = identAssignment.Ident;
var variableMetadata = services.VariableCompileTimeResolver.Resolve(variableName);
if (variableMetadata == null)
{
throw new ExprValidationException("Variable by name '" + variableName + "' has not been created or configured");
}
_variables[count] = variableMetadata;
var expressionType = assignment.Rhs.Forge.EvaluationType;
if (assignment.Lhs is ExprAssignmentLHSIdent)
{
// determine types
if (variableMetadata.EventType != null)
{
if ((expressionType != null) &&
(!TypeHelper.IsSubclassOrImplementsInterface(expressionType, variableMetadata.EventType.UnderlyingType)))
{
throw new ExprValidationException(
"Variable '" +
variableName +
"' of declared event type '" +
variableMetadata.EventType.Name +
"' underlying type '" +
variableMetadata.EventType.UnderlyingType.Name +
"' cannot be assigned a value of type '" +
expressionType.Name +
"'");
}
_variableTypes.Put(variableName, variableMetadata.EventType.UnderlyingType);
}
else
{
var variableType = variableMetadata.Type;
_variableTypes.Put(variableName, variableType);
// determine if the expression type can be assigned
if (variableType != typeof(object))
{
if ((expressionType.GetBoxedType() != variableType.GetBoxedType()) &&
(expressionType != null))
{
if ((!TypeHelper.IsNumeric(variableType)) ||
(!TypeHelper.IsNumeric(expressionType)))
{
throw new ExprValidationException(VariableUtil.GetAssigmentExMessage(variableName, variableType, expressionType));
}
if (!(TypeHelper.CanCoerce(expressionType, variableType)))
{
throw new ExprValidationException(VariableUtil.GetAssigmentExMessage(variableName, variableType, expressionType));
}
_mustCoerce[count] = true;
}
}
}
}
else if (assignment.Lhs is ExprAssignmentLHSIdentWSubprop)
{
var subpropAssignment = (ExprAssignmentLHSIdentWSubprop)assignment.Lhs;
var subPropertyName = subpropAssignment.SubpropertyName;
if (variableMetadata.EventType == null)
{
throw new ExprValidationException(
"Variable by name '" + variableName + "' does not have a property named '" + subPropertyName + "'");
}
var type = variableMetadata.EventType;
if (!(type is EventTypeSPI))
{
throw new ExprValidationException("Variable by name '" + variableName + "' event type '" + type.Name + "' not writable");
}
var spi = (EventTypeSPI)type;
var writer = spi.GetWriter(subPropertyName);
var getter = spi.GetGetterSPI(subPropertyName);
var getterType = spi.GetPropertyType(subPropertyName);
if (writer == null)
{
throw new ExprValidationException(
"Variable by name '" + variableName + "' the property '" + subPropertyName + "' is not writable");
}
var fullVariableName = variableName + "." + subPropertyName;
_variableTypes.Put(fullVariableName, spi.GetPropertyType(subPropertyName));
var writtenProps = eventTypeWrittenProps.Get(spi);
if (writtenProps == null)
{
writtenProps = new CopyMethodDesc(variableName, new List <string>());
eventTypeWrittenProps.Put(spi, writtenProps);
}
writtenProps.PropertiesCopied.Add(subPropertyName);
_writers[count] = new VariableTriggerWriteDescForge(
spi,
variableName,
writer,
getter,
getterType,
assignment.Rhs.Forge.EvaluationType);
}
else if (assignment.Lhs is ExprAssignmentLHSArrayElement)
{
var arrayAssign = (ExprAssignmentLHSArrayElement)assignment.Lhs;
var variableType = variableMetadata.Type;
if (!variableType.IsArray)
{
throw new ExprValidationException("Variable '" + variableMetadata.VariableName + "' is not an array");
}
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignment.Rhs),
expressionType,
variableType.GetElementType(),
variableMetadata.VariableName,
false,
null,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
_writers[count] = new VariableTriggerWriteArrayElementForge(variableName, arrayAssign.IndexExpression.Forge, widener);
}
else
{
throw new IllegalStateException("Unrecognized left hand side assignment " + assignment.Lhs);
}
}
else if (assignmentDesc is ExprAssignmentCurly)
{
var curly = (ExprAssignmentCurly)assignmentDesc;
if (curly.Expression is ExprVariableNode)
{
throw new ExprValidationException("Missing variable assignment expression in assignment number " + count);
}
var variableVisitor = new ExprNodeVariableVisitor(services.VariableCompileTimeResolver);
curly.Expression.Accept(variableVisitor);
if (variableVisitor.VariableNames == null || variableVisitor.VariableNames.Count != 1)
{
throw new ExprValidationException("Assignment expression must receive a single variable value");
}
var variable = variableVisitor.VariableNames.First();
_variables[count] = variable.Value;
_writers[count] = new VariableTriggerWriteCurlyForge(variable.Key, curly.Expression.Forge);
}
else
{
throw new IllegalStateException("Unrecognized assignment expression " + assignmentDesc);
}
if (_variables[count].IsConstant)
{
throw new ExprValidationException("Variable by name '" + _variables[count].VariableName + "' is declared constant and may not be set");
}
count++;
}
catch (ExprValidationException ex) {
throw new ExprValidationException(
"Failed to validate assignment expression '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignmentDesc.OriginalExpression) +
"': " +
ex.Message,
ex);
}
}
_assignments = assignmentList.ToArray();
if (eventTypeWrittenProps.IsEmpty())
{
_copyMethods = EmptyDictionary <EventTypeSPI, EventBeanCopyMethodForge> .Instance;
return;
}
_copyMethods = new Dictionary <EventTypeSPI, EventBeanCopyMethodForge>();
foreach (var entry in eventTypeWrittenProps)
{
var propsWritten = entry.Value.PropertiesCopied;
var props = propsWritten.ToArray();
var copyMethod = entry.Key.GetCopyMethodForge(props);
if (copyMethod == null)
{
throw new ExprValidationException(
"Variable '" +
entry.Value.VariableName +
"' of declared type " +
entry.Key.UnderlyingType.CleanName() +
"' cannot be assigned to");
}
_copyMethods.Put(entry.Key, copyMethod);
}
}
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));
}
public static EventBeanUpdateHelperForge Make(
string updatedWindowOrTableName,
EventTypeSPI eventTypeSPI,
IList <OnTriggerSetAssignment> assignments,
string updatedAlias,
EventType optionalTriggeringEventType,
bool isCopyOnWrite,
string statementName,
EventTypeAvroHandler avroHandler)
{
IList <EventBeanUpdateItemForge> updateItems = new List <EventBeanUpdateItemForge>();
IList <string> properties = new List <string>();
TypeWidenerCustomizer typeWidenerCustomizer = avroHandler.GetTypeWidenerCustomizer(eventTypeSPI);
for (int i = 0; i < assignments.Count; i++)
{
OnTriggerSetAssignment desc = assignments[i];
ExprAssignment assignment = desc.Validated;
if (assignment == null)
{
throw new IllegalStateException("Assignment has not been validated");
}
try {
EventBeanUpdateItemForge updateItem;
if (assignment is ExprAssignmentStraight)
{
ExprAssignmentStraight straight = (ExprAssignmentStraight)assignment;
// handle assignment "property = value"
if (straight.Lhs is ExprAssignmentLHSIdent)
{
ExprAssignmentLHSIdent ident = (ExprAssignmentLHSIdent)straight.Lhs;
string propertyName = ident.Ident;
EventPropertyDescriptor writableProperty = eventTypeSPI.GetWritableProperty(propertyName);
// check assignment to indexed or mapped property
if (writableProperty == null)
{
Pair <string, EventPropertyDescriptor> nameWriteablePair = CheckIndexedOrMappedProp(
propertyName,
updatedWindowOrTableName,
updatedAlias,
eventTypeSPI);
propertyName = nameWriteablePair.First;
writableProperty = nameWriteablePair.Second;
}
ExprNode rhsExpr = straight.Rhs;
ExprForge rhsForge = rhsExpr.Forge;
EventPropertyWriterSPI writer = eventTypeSPI.GetWriter(propertyName);
bool notNullableField = writableProperty.PropertyType.IsPrimitive;
properties.Add(propertyName);
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(rhsExpr),
rhsForge.EvaluationType,
writableProperty.PropertyType,
propertyName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
// check event type assignment
bool useUntypedAssignment = false;
bool useTriggeringEvent = false;
if (optionalTriggeringEventType != null)
{
// handle RHS is ident node
if (rhsExpr is ExprIdentNode)
{
ExprIdentNode node = (ExprIdentNode)rhsExpr;
FragmentEventType fragmentRHS = optionalTriggeringEventType.GetFragmentType(node.ResolvedPropertyName);
FragmentEventType fragmentLHS = eventTypeSPI.GetFragmentType(propertyName);
if (fragmentRHS != null && fragmentLHS != null)
{
if (!EventTypeUtility.IsTypeOrSubTypeOf(fragmentRHS.FragmentType, fragmentLHS.FragmentType))
{
throw MakeEventTypeMismatch(propertyName, fragmentLHS.FragmentType, fragmentRHS.FragmentType);
}
}
// we don't need to cast if it is a self-assignment and LHS is an event and target needs no writer
if (node.StreamId == 0 && fragmentLHS != null && eventTypeSPI is BaseNestableEventType)
{
useUntypedAssignment = true;
}
}
// handle RHS is a stream of the triggering event itself
if (rhsExpr is ExprStreamUnderlyingNode)
{
ExprStreamUnderlyingNode und = (ExprStreamUnderlyingNode)rhsExpr;
if (und.StreamId == 1)
{
FragmentEventType fragmentLHS = eventTypeSPI.GetFragmentType(propertyName);
if (fragmentLHS != null &&
optionalTriggeringEventType is BaseNestableEventType &&
!EventTypeUtility.IsTypeOrSubTypeOf(optionalTriggeringEventType, fragmentLHS.FragmentType))
{
throw MakeEventTypeMismatch(propertyName, fragmentLHS.FragmentType, optionalTriggeringEventType);
}
// we use the event itself for assignment and target needs no writer
if (eventTypeSPI is BaseNestableEventType)
{
useUntypedAssignment = true;
useTriggeringEvent = true;
}
}
}
}
updateItem = new EventBeanUpdateItemForge(
rhsForge,
propertyName,
writer,
notNullableField,
widener,
useUntypedAssignment,
useTriggeringEvent,
null);
}
else if (straight.Lhs is ExprAssignmentLHSArrayElement)
{
// handle "property[expr] = value"
ExprAssignmentLHSArrayElement arrayElementLHS = (ExprAssignmentLHSArrayElement)straight.Lhs;
string arrayPropertyName = arrayElementLHS.Ident;
ExprNode rhs = straight.Rhs;
Type evaluationType = rhs.Forge.EvaluationType;
Type propertyType = eventTypeSPI.GetPropertyType(arrayPropertyName);
if (!eventTypeSPI.IsProperty(arrayPropertyName))
{
throw new ExprValidationException("Property '" + arrayPropertyName + "' could not be found");
}
if (propertyType == null || !propertyType.IsArray)
{
throw new ExprValidationException("Property '" + arrayPropertyName + "' is not an array");
}
EventPropertyGetterSPI getter = eventTypeSPI.GetGetterSPI(arrayPropertyName);
Type componentType = propertyType.GetElementType();
if (!TypeHelper.IsAssignmentCompatible(evaluationType, componentType))
{
throw new ExprValidationException(
"Invalid assignment to property '" +
arrayPropertyName +
"' component type '" +
componentType.CleanName() +
"' from expression returning '" +
evaluationType.CleanName() +
"'");
}
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(straight.Rhs),
evaluationType,
componentType,
arrayPropertyName,
false,
typeWidenerCustomizer,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
EventBeanUpdateItemArray arrayInfo = new EventBeanUpdateItemArray(
arrayPropertyName,
arrayElementLHS.IndexExpression,
propertyType,
getter);
updateItem = new EventBeanUpdateItemForge(
rhs.Forge,
arrayPropertyName,
null,
false,
widener,
false,
false,
arrayInfo);
}
else
{
throw new IllegalStateException("Unrecognized LHS assignment " + straight);
}
}
else if (assignment is ExprAssignmentCurly)
{
// handle non-assignment, i.e. UDF or other expression
ExprAssignmentCurly dot = (ExprAssignmentCurly)assignment;
updateItem = new EventBeanUpdateItemForge(
dot.Expression.Forge,
null,
null,
false,
null,
false,
false,
null);
}
else
{
throw new IllegalStateException("Unrecognized assignment " + assignment);
}
updateItems.Add(updateItem);
}
catch (ExprValidationException ex) {
throw new ExprValidationException(
"Failed to validate assignment expression '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignment.OriginalExpression) +
"': " +
ex.Message,
ex);
}
}
// copy-on-write is the default event semantics as events are immutable
EventBeanCopyMethodForge copyMethod;
if (isCopyOnWrite)
{
// obtain copy method
List <string> propertiesUniqueList = new List <string>(new HashSet <string>(properties));
string[] propertiesArray = propertiesUniqueList.ToArray();
copyMethod = eventTypeSPI.GetCopyMethodForge(propertiesArray);
if (copyMethod == null)
{
throw new ExprValidationException("Event type does not support event bean copy");
}
}
else
{
// for in-place update, determine assignment expressions to use "initial" to access prior-change values
// the copy-method is optional
copyMethod = null;
ISet <string> propertiesInitialValue = DeterminePropertiesInitialValue(assignments);
if (!propertiesInitialValue.IsEmpty())
{
string[] propertiesInitialValueArray = propertiesInitialValue.ToArray();
copyMethod = eventTypeSPI.GetCopyMethodForge(propertiesInitialValueArray);
}
}
EventBeanUpdateItemForge[] updateItemsArray = updateItems.ToArray();
return(new EventBeanUpdateHelperForge(eventTypeSPI, copyMethod, updateItemsArray));
}
public static SelectExprProcessorForge Make(
EventType[] eventTypes,
SelectExprForgeContext selectExprForgeContext,
int streamNumber,
EventType targetType,
ExprNode[] exprNodes,
ImportServiceCompileTime importService,
string statementName)
{
var oaResultType = (ObjectArrayEventType) targetType;
var oaStreamType = (ObjectArrayEventType) eventTypes[streamNumber];
// (A) fully assignment-compatible: same number, name and type of fields, no additional expressions: Straight repackage
if (oaResultType.IsDeepEqualsConsiderOrder(oaStreamType) && selectExprForgeContext.ExprForges.Length == 0) {
return new OAInsertProcessorSimpleRepackage(selectExprForgeContext, streamNumber, targetType);
}
// (B) not completely assignable: find matching properties
var writables = EventTypeUtility.GetWriteableProperties(oaResultType, true, false);
IList<Item> items = new List<Item>();
IList<WriteablePropertyDescriptor> written = new List<WriteablePropertyDescriptor>();
// find the properties coming from the providing source stream
foreach (var writeable in writables) {
var propertyName = writeable.PropertyName;
var hasIndexSource = oaStreamType.PropertiesIndexes.TryGetValue(propertyName, out var indexSource);
var hasIndexTarget = oaResultType.PropertiesIndexes.TryGetValue(propertyName, out var indexTarget);
if (hasIndexSource) {
var setOneType = oaStreamType.Types.Get(propertyName);
var setTwoType = oaResultType.Types.Get(propertyName);
var setTwoTypeFound = oaResultType.Types.ContainsKey(propertyName);
var message = BaseNestableEventUtil.ComparePropType(
propertyName,
setOneType,
setTwoType,
setTwoTypeFound,
oaResultType.Name);
if (message != null) {
throw new ExprValidationException(message.Message, message);
}
items.Add(new Item(indexTarget, indexSource, null, null));
written.Add(writeable);
}
}
// find the properties coming from the expressions of the select clause
var count = written.Count;
for (var i = 0; i < selectExprForgeContext.ExprForges.Length; i++) {
var columnName = selectExprForgeContext.ColumnNames[i];
var forge = selectExprForgeContext.ExprForges[i];
var exprNode = exprNodes[i];
var writable = FindWritable(columnName, writables);
if (writable == null) {
throw new ExprValidationException(
"Failed to find column '" + columnName + "' in target type '" + oaResultType.Name + "'");
}
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(exprNode),
exprNode.Forge.EvaluationType,
writable.PropertyType,
columnName,
false,
null,
statementName);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
items.Add(new Item(count, -1, forge, widener));
written.Add(writable);
count++;
}
// make manufacturer
var itemsArr = items.ToArray();
EventBeanManufacturerForge manufacturer;
try {
manufacturer = EventTypeUtility.GetManufacturer(
oaResultType,
written.ToArray(),
importService,
true,
selectExprForgeContext.EventTypeAvroHandler);
}
catch (EventBeanManufactureException e) {
throw new ExprValidationException("Failed to write to type: " + e.Message, e);
}
return new OAInsertProcessorAllocate(streamNumber, itemsArr, manufacturer, targetType);
}
public static InternalEventRouterDescForge GetValidatePreprocessing(
EventType eventType,
UpdateDesc desc,
Attribute[] annotations)
{
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 List<TypeWidenerSPI>();
var properties = new List<string>();
var propertiesTouched = new List<string>();
var expressions = new List<ExprNode>();
var specialWriters = new List<InternalEventRouterWriterForge>();
for (var i = 0; i < desc.Assignments.Count; i++) {
var onSet = desc.Assignments[i];
var assignmentDesc = onSet.Validated;
try {
if (assignmentDesc is ExprAssignmentStraight assignment) {
var lhs = assignment.Lhs;
if (lhs is ExprAssignmentLHSIdent ident) {
var propertyName = ident.Ident;
var writableProperty = eventTypeSPI.GetWritableProperty(propertyName);
if (writableProperty == null) {
throw new ExprValidationException("Property '" + propertyName + "' is not available for write access");
}
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignment.Rhs),
assignment.Rhs.Forge.EvaluationType,
writableProperty.PropertyType,
propertyName,
false,
null,
null);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
properties.Add(propertyName);
propertiesTouched.Add(propertyName);
expressions.Add(assignment.Rhs);
wideners.Add(widener);
}
else if (lhs is ExprAssignmentLHSIdentWSubprop subprop) {
throw new ExprValidationException("Property '" + subprop.SubpropertyName + "' is not available for write access");
}
else if (lhs is ExprAssignmentLHSArrayElement arrayElement) {
var propertyName = lhs.Ident;
var writableProperty = eventTypeSPI.GetWritableProperty(propertyName);
if (writableProperty == null) {
throw new ExprValidationException("Property '" + propertyName + "' is not available for write access");
}
if (!writableProperty.PropertyType.IsArray) {
throw new ExprValidationException("Property '" + propertyName + "' type is not array");
}
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignment.Rhs),
assignment.Rhs.Forge.EvaluationType,
writableProperty.PropertyType.GetElementType(),
propertyName,
false,
null,
null);
}
catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
var special = new InternalEventRouterWriterArrayElementForge(
arrayElement.IndexExpression,
assignment.Rhs,
widener,
propertyName);
specialWriters.Add(special);
}
else {
throw new IllegalStateException("Unrecognized left hande side assignment " + lhs);
}
}
else if (assignmentDesc is ExprAssignmentCurly curly) {
var special = new InternalEventRouterWriterCurlyForge(curly.Expression);
specialWriters.Add(special);
}
else {
throw new IllegalStateException("Unrecognized assignment " + assignmentDesc);
}
}
catch (ExprValidationException ex) {
throw new ExprValidationException(
"Failed to validate assignment expression '" +
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignmentDesc.OriginalExpression) +
"': " +
ex.Message,
ex);
}
}
// check copy-able
var copyMethod = eventTypeSPI.GetCopyMethodForge(propertiesTouched.ToArray());
if (copyMethod == null) {
throw new ExprValidationException(
"The update-clause requires the underlying event representation to support copy (via Serializable by default)");
}
return new InternalEventRouterDescForge(
copyMethod,
wideners.ToArray(),
eventType,
annotations,
desc.OptionalWhereClause,
properties.ToArray(),
expressions.ToArray(),
specialWriters.ToArray());
}
public EvalSelectNoWildcardAvro(
SelectExprContext selectExprContext,
EventType resultEventType,
string statementName,
string engineURI)
{
_selectExprContext = selectExprContext;
_resultEventType = (AvroEventType) resultEventType;
_evaluator = new ExprEvaluator[selectExprContext.ExpressionNodes.Length];
var typeWidenerCustomizer =
selectExprContext.EventAdapterService.GetTypeWidenerCustomizer(resultEventType);
for (var i = 0; i < _evaluator.Length; i++)
{
var eval = selectExprContext.ExpressionNodes[i];
_evaluator[i] = eval;
if (eval is SelectExprProcessorEvalByGetterFragment)
{
_evaluator[i] = HandleFragment((SelectExprProcessorEvalByGetterFragment) eval);
}
else if (eval is SelectExprProcessorEvalStreamInsertUnd)
{
var und = (SelectExprProcessorEvalStreamInsertUnd) eval;
_evaluator[i] = new ProxyExprEvaluator
{
ProcEvaluate = (evaluateParams) =>
{
var @event = evaluateParams.EventsPerStream[und.StreamNum];
if (@event == null)
{
return null;
}
return @event.Underlying;
},
ProcReturnType = () => { return typeof (GenericRecord); }
};
}
else if (eval is SelectExprProcessorEvalTypableMap)
{
var typableMap = (SelectExprProcessorEvalTypableMap) eval;
_evaluator[i] = new SelectExprProcessorEvalAvroMapToAvro(
typableMap.InnerEvaluator, ((AvroEventType) resultEventType).SchemaAvro,
selectExprContext.ColumnNames[i]);
}
else if (eval is SelectExprProcessorEvalStreamInsertNamedWindow)
{
var nw = (SelectExprProcessorEvalStreamInsertNamedWindow) eval;
_evaluator[i] = new ProxyExprEvaluator
{
ProcEvaluate = (evaluateParams) =>
{
var @event = evaluateParams.EventsPerStream[nw.StreamNum];
if (@event == null)
{
return null;
}
return @event.Underlying;
},
ProcReturnType = () => { return typeof (GenericRecord); }
};
}
else if (eval.ReturnType != null && eval.ReturnType.IsArray)
{
var widener = TypeWidenerFactory.GetArrayToCollectionCoercer(eval.ReturnType.GetElementType());
//if (eval.ReturnType == typeof (byte[]))
//{
// widener = TypeWidenerFactory.BYTE_ARRAY_TO_BYTE_BUFFER_COERCER;
//}
_evaluator[i] = new SelectExprProcessorEvalAvroArrayCoercer(eval, widener);
}
else
{
var propertyName = selectExprContext.ColumnNames[i];
var propertyType = resultEventType.GetPropertyType(propertyName);
var widener = TypeWidenerFactory.GetCheckPropertyAssignType(
propertyName, eval.ReturnType, propertyType, propertyName, true, typeWidenerCustomizer,
statementName, engineURI);
if (widener != null)
{
_evaluator[i] = new SelectExprProcessorEvalAvroArrayCoercer(eval, widener);
}
}
}
}
public static SelectExprProcessorForge Make(
EventType[] eventTypes,
SelectExprForgeContext selectExprForgeContext,
int streamNumber,
EventType targetType,
ExprNode[] exprNodes,
ImportServiceCompileTime classpathImportService,
string statementName)
{
var jsonResultType = (JsonEventType)targetType;
var jsonStreamType = (JsonEventType)eventTypes[streamNumber];
// (A) fully assignment-compatible: same number, name and type of fields, no additional expressions: Straight repackage
if (jsonResultType.IsDeepEqualsConsiderOrder(jsonStreamType) && selectExprForgeContext.ExprForges.Length == 0)
{
return(new JsonInsertProcessorStraightFieldAssign(streamNumber, jsonStreamType, jsonResultType));
}
// (B) not completely assignable: find matching properties
var writables = EventTypeUtility.GetWriteableProperties(jsonResultType, true, false);
var items = new List <Item>();
var written = new List <WriteablePropertyDescriptor>();
// find the properties coming from the providing source stream
foreach (var writeable in writables)
{
var propertyName = writeable.PropertyName;
var fieldSource = jsonStreamType.Detail.FieldDescriptors.Get(propertyName);
var fieldTarget = jsonResultType.Detail.FieldDescriptors.Get(propertyName);
if (fieldSource != null)
{
var setOneType = jsonStreamType.Types.Get(propertyName);
var setTwoType = jsonResultType.Types.Get(propertyName);
var setTwoTypeFound = jsonResultType.Types.ContainsKey(propertyName);
var message = BaseNestableEventUtil.ComparePropType(propertyName, setOneType, setTwoType, setTwoTypeFound, jsonResultType.Name);
if (message != null)
{
throw new ExprValidationException(message.Message, message);
}
items.Add(new Item(fieldTarget, fieldSource, null, null));
written.Add(writeable);
}
}
// find the properties coming from the expressions of the select clause
for (var i = 0; i < selectExprForgeContext.ExprForges.Length; i++)
{
var columnName = selectExprForgeContext.ColumnNames[i];
var forge = selectExprForgeContext.ExprForges[i];
var exprNode = exprNodes[i];
var writable = FindWritable(columnName, writables);
if (writable == null)
{
throw new ExprValidationException("Failed to find column '" + columnName + "' in target type '" + jsonResultType.Name + "'");
}
var fieldTarget = jsonResultType.Detail.FieldDescriptors.Get(writable.PropertyName);
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(exprNode),
exprNode.Forge.EvaluationType,
writable.PropertyType,
columnName,
false,
null,
statementName);
} catch (TypeWidenerException ex) {
throw new ExprValidationException(ex.Message, ex);
}
items.Add(new Item(fieldTarget, null, forge, widener));
written.Add(writable);
}
// make manufacturer
var itemsArr = items.ToArray();
return(new JsonInsertProcessorExpressions(streamNumber, itemsArr, jsonStreamType, jsonResultType));
}
