// 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());
// handle evaluator returning an event
if (JavaClassHelper.isSubclassOrImplementsInterface(returnType, desc.getType())) {
selectedWritable = desc;
widener = new TypeWidener() {
public Object widen(Object input) {
if (input instanceof EventBean) {
return ((EventBean) input).getUnderlying();
}
return input;
}
};
continue;
}
// find stream
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 theEvent = eventsPerStream[streamNumEval];
if (theEvent != null)
{
return theEvent.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)
{
if (!writableDesc.getPropertyName().equals(eventPropDescriptor.getPropertyName()))
{
continue;
}
widener = TypeWidenerFactory.getCheckPropertyAssignType(eventPropDescriptor.getPropertyName(), eventPropDescriptor.getPropertyType(), writableDesc.getType(), writableDesc.getPropertyName());
selectedWritable = writableDesc;
final String propertyName = eventPropDescriptor.getPropertyName();
final Class propertyType = eventPropDescriptor.getPropertyType();
evaluator = new ExprEvaluator() {
public Object evaluate(EventBean[] eventsPerStream, boolean isNewData,ExprEvaluatorContext exprEvaluatorContext)
{
EventBean theEvent = eventsPerStream[0];
if (theEvent != null)