List<TypeWidener> widenersList = new ArrayList<TypeWidener>();
// loop over all columns selected, if any
for (int i = 0; i < columnNames.length; i++)
{
WriteablePropertyDescriptor selectedWritable = null;
TypeWidener widener = null;
ExprEvaluator evaluator = expressionNodes[i];
for (WriteablePropertyDescriptor desc : writables)
{
if (!desc.getPropertyName().equals(columnNames[i]))
{
continue;
}
Object columnType = expressionReturnTypes[i];
if (columnType == null)
{
TypeWidenerFactory.getCheckPropertyAssignType(columnNames[i], null, desc.getType(), desc.getPropertyName());
}
else if (columnType instanceof EventType)
{
EventType columnEventType = (EventType) columnType;
final Class returnType = columnEventType.getUnderlyingType();
widener = TypeWidenerFactory.getCheckPropertyAssignType(columnNames[i], columnEventType.getUnderlyingType(), desc.getType(), desc.getPropertyName());
int streamNum = 0;
for (int j = 0; j < typeService.getEventTypes().length; j++)
{
if (typeService.getEventTypes()[j] == columnEventType)
{
streamNum = j;
break;
}
}
final int streamNumEval = streamNum;
evaluator = new ExprEvaluator() {
public Object evaluate(EventBean[] eventsPerStream, boolean isNewData, ExprEvaluatorContext exprEvaluatorContext)
{
EventBean event = eventsPerStream[streamNumEval];
if (event != null)
{
return event.getUnderlying();
}
return null;
}
public Class getType()
{
return returnType;
}
public Map<String, Object> getEventType() {
return null;
}
};
}
// handle case where the select-clause contains an fragment array
else if (columnType instanceof EventType[])
{
EventType columnEventType = ((EventType[]) columnType)[0];
final Class componentReturnType = columnEventType.getUnderlyingType();
final Class arrayReturnType = Array.newInstance(componentReturnType, 0).getClass();
widener = TypeWidenerFactory.getCheckPropertyAssignType(columnNames[i], arrayReturnType, desc.getType(), desc.getPropertyName());
final ExprEvaluator inner = evaluator;
evaluator = new ExprEvaluator() {
public Object evaluate(EventBean[] eventsPerStream, boolean isNewData, ExprEvaluatorContext exprEvaluatorContext)
{
Object result = inner.evaluate(eventsPerStream, isNewData, exprEvaluatorContext);
if (!(result instanceof EventBean[])) {
return null;
}
EventBean[] events = (EventBean[]) result;
Object values = Array.newInstance(componentReturnType, events.length);
for (int i = 0; i < events.length; i++) {
Array.set(values, i, events[i].getUnderlying());
}
return values;
}
public Class getType()
{
return componentReturnType;
}
public Map<String, Object> getEventType() {
return null;
}
};
}
else if (!(columnType instanceof Class))
{
String message = "Invalid assignment of column '" + columnNames[i] +
"' of type '" + columnType +
"' to event property '" + desc.getPropertyName() +
"' typed as '" + desc.getType().getName() +
"', column and parameter types mismatch";
throw new ExprValidationException(message);
}
else
{
widener = TypeWidenerFactory.getCheckPropertyAssignType(columnNames[i], (Class) columnType, desc.getType(), desc.getPropertyName());
}
selectedWritable = desc;
break;
}
if (selectedWritable == null)
{
String 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)
{
EventType sourceType = typeService.getEventTypes()[0];
for (EventPropertyDescriptor eventPropDescriptor : sourceType.getPropertyDescriptors())
{
if (eventPropDescriptor.isRequiresIndex() || (eventPropDescriptor.isRequiresMapkey()))
{
continue;
}
WriteablePropertyDescriptor selectedWritable = null;
TypeWidener widener = null;
ExprEvaluator evaluator = null;
for (WriteablePropertyDescriptor writableDesc : writables)
{