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));
}
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 EventBeanUpdateHelper Make(
string updatedWindowOrTableName,
EventTypeSPI eventTypeSPI,
IList <OnTriggerSetAssignment> assignments,
string updatedAlias,
EventType optionalTriggeringEventType,
bool isCopyOnWrite,
string statementName,
string engineURI,
EventAdapterService eventAdapterService)
{
var updateItems = new List <EventBeanUpdateItem>();
var properties = new List <string>();
var typeWidenerCustomizer = eventAdapterService.GetTypeWidenerCustomizer(eventTypeSPI);
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, false, typeWidenerCustomizer, statementName,
engineURI);
// 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);
}
else
{
// handle non-assignment, i.e. UDF or other expression
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
var 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));
}
