use of io.siddhi.core.exception.OperationNotSupportedException in project siddhi by wso2.
the class AvgAttributeAggregatorExecutor method init.
/**
* The initialization method for FunctionExecutor
*
* @param attributeExpressionExecutors are the executors of each attributes in the function
* @param processingMode query processing mode
* @param outputExpectsExpiredEvents is expired events sent as output
* @param configReader this hold the {@link AvgAttributeAggregatorExecutor} configuration reader.
* @param siddhiQueryContext Siddhi query runtime context
*/
@Override
protected StateFactory<AvgAttributeState> init(ExpressionExecutor[] attributeExpressionExecutors, ProcessingMode processingMode, boolean outputExpectsExpiredEvents, ConfigReader configReader, SiddhiQueryContext siddhiQueryContext) {
if (attributeExpressionExecutors.length != 1) {
throw new OperationNotSupportedException("Avg aggregator has to have exactly 1 parameter, currently " + attributeExpressionExecutors.length + " parameters provided");
}
returnType = Attribute.Type.DOUBLE;
Attribute.Type type = attributeExpressionExecutors[0].getReturnType();
return () -> {
switch(type) {
case FLOAT:
return new AvgAttributeAggregatorStateFloat();
case INT:
return new AvgAttributeAggregatorStateInt();
case LONG:
return new AvgAttributeAggregatorStateLong();
case DOUBLE:
return new AvgAttributeAggregatorStateDouble();
default:
throw new OperationNotSupportedException("Avg not supported for " + returnType);
}
};
}
use of io.siddhi.core.exception.OperationNotSupportedException in project siddhi by wso2.
the class StateInputStreamParser method parse.
private static InnerStateRuntime parse(StateElement stateElement, Map<String, AbstractDefinition> streamDefinitionMap, Map<String, AbstractDefinition> tableDefinitionMap, Map<String, AbstractDefinition> windowDefinitionMap, Map<String, AbstractDefinition> aggregationDefinitionMap, Map<String, Table> tableMap, MetaStateEvent metaStateEvent, List<VariableExpressionExecutor> variableExpressionExecutors, Map<String, ProcessStreamReceiver> processStreamReceiverMap, StreamPreStateProcessor streamPreStateProcessor, StreamPostStateProcessor streamPostStateProcessor, StateInputStream.Type stateType, boolean multiValue, List<PreStateProcessor> preStateProcessors, boolean isStartState, List<PreStateProcessor> startupPreStateProcessors, SiddhiQueryContext siddhiQueryContext) {
if (stateElement instanceof StreamStateElement) {
BasicSingleInputStream basicSingleInputStream = ((StreamStateElement) stateElement).getBasicSingleInputStream();
SingleStreamRuntime singleStreamRuntime = SingleInputStreamParser.parseInputStream(basicSingleInputStream, variableExpressionExecutors, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, processStreamReceiverMap.get(basicSingleInputStream.getUniqueStreamIds().get(0)), false, false, false, multiValue, siddhiQueryContext);
int stateIndex = metaStateEvent.getStreamEventCount() - 1;
if (streamPreStateProcessor == null) {
if (stateElement instanceof AbsentStreamStateElement) {
AbsentStreamPreStateProcessor absentProcessor = new AbsentStreamPreStateProcessor(stateType, ((AbsentStreamStateElement) stateElement).getWaitingTime().value());
// Set the scheduler
startupPreStateProcessors.add(absentProcessor);
EntryValveProcessor entryValveProcessor = new EntryValveProcessor(siddhiQueryContext.getSiddhiAppContext());
entryValveProcessor.setToLast(absentProcessor);
Scheduler scheduler = SchedulerParser.parse(entryValveProcessor, siddhiQueryContext);
absentProcessor.setScheduler(scheduler);
// Assign the AbsentStreamPreStateProcessor to streamPreStateProcessor
streamPreStateProcessor = absentProcessor;
} else {
streamPreStateProcessor = new StreamPreStateProcessor(stateType);
}
streamPreStateProcessor.init(siddhiQueryContext);
}
streamPreStateProcessor.setStateId(stateIndex);
streamPreStateProcessor.setStartState(isStartState);
streamPreStateProcessor.setNextProcessor(singleStreamRuntime.getProcessorChain());
singleStreamRuntime.setProcessorChain(streamPreStateProcessor);
if (streamPostStateProcessor == null) {
if (stateElement instanceof AbsentStreamStateElement) {
streamPostStateProcessor = new AbsentStreamPostStateProcessor();
} else {
streamPostStateProcessor = new StreamPostStateProcessor();
}
}
streamPostStateProcessor.setStateId(stateIndex);
singleStreamRuntime.getProcessorChain().setToLast(streamPostStateProcessor);
streamPostStateProcessor.setThisStatePreProcessor(streamPreStateProcessor);
streamPreStateProcessor.setThisStatePostProcessor(streamPostStateProcessor);
streamPreStateProcessor.setThisLastProcessor(streamPostStateProcessor);
StreamInnerStateRuntime innerStateRuntime = new StreamInnerStateRuntime(stateType);
innerStateRuntime.setFirstProcessor(streamPreStateProcessor);
innerStateRuntime.setLastProcessor(streamPostStateProcessor);
innerStateRuntime.addStreamRuntime(singleStreamRuntime);
preStateProcessors.add(streamPreStateProcessor);
return innerStateRuntime;
} else if (stateElement instanceof NextStateElement) {
StateElement currentElement = ((NextStateElement) stateElement).getStateElement();
InnerStateRuntime currentInnerStateRuntime = parse(currentElement, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, variableExpressionExecutors, processStreamReceiverMap, streamPreStateProcessor, streamPostStateProcessor, stateType, multiValue, preStateProcessors, isStartState, startupPreStateProcessors, siddhiQueryContext);
StateElement nextElement = ((NextStateElement) stateElement).getNextStateElement();
InnerStateRuntime nextInnerStateRuntime = parse(nextElement, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, variableExpressionExecutors, processStreamReceiverMap, streamPreStateProcessor, streamPostStateProcessor, stateType, multiValue, preStateProcessors, false, startupPreStateProcessors, siddhiQueryContext);
currentInnerStateRuntime.getLastProcessor().setNextStatePreProcessor(nextInnerStateRuntime.getFirstProcessor());
NextInnerStateRuntime nextStateRuntime = new NextInnerStateRuntime(currentInnerStateRuntime, nextInnerStateRuntime, stateType);
nextStateRuntime.setFirstProcessor(currentInnerStateRuntime.getFirstProcessor());
nextStateRuntime.setLastProcessor(nextInnerStateRuntime.getLastProcessor());
for (SingleStreamRuntime singleStreamRuntime : currentInnerStateRuntime.getSingleStreamRuntimeList()) {
nextStateRuntime.addStreamRuntime(singleStreamRuntime);
}
for (SingleStreamRuntime singleStreamRuntime : nextInnerStateRuntime.getSingleStreamRuntimeList()) {
nextStateRuntime.addStreamRuntime(singleStreamRuntime);
}
return nextStateRuntime;
} else if (stateElement instanceof EveryStateElement) {
StateElement currentElement = ((EveryStateElement) stateElement).getStateElement();
List<PreStateProcessor> withinEveryPreStateProcessors = new ArrayList<>();
InnerStateRuntime innerStateRuntime = parse(currentElement, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, variableExpressionExecutors, processStreamReceiverMap, streamPreStateProcessor, streamPostStateProcessor, stateType, multiValue, withinEveryPreStateProcessors, isStartState, startupPreStateProcessors, siddhiQueryContext);
EveryInnerStateRuntime everyInnerStateRuntime = new EveryInnerStateRuntime(innerStateRuntime, stateType);
everyInnerStateRuntime.setFirstProcessor(innerStateRuntime.getFirstProcessor());
everyInnerStateRuntime.setLastProcessor(innerStateRuntime.getLastProcessor());
for (SingleStreamRuntime singleStreamRuntime : innerStateRuntime.getSingleStreamRuntimeList()) {
everyInnerStateRuntime.addStreamRuntime(singleStreamRuntime);
}
everyInnerStateRuntime.getLastProcessor().setNextEveryStatePreProcessor(everyInnerStateRuntime.getFirstProcessor());
for (PreStateProcessor preStateProcessor : withinEveryPreStateProcessors) {
preStateProcessor.setWithinEveryPreStateProcessor(everyInnerStateRuntime.getFirstProcessor());
}
preStateProcessors.addAll(withinEveryPreStateProcessors);
return everyInnerStateRuntime;
} else if (stateElement instanceof LogicalStateElement) {
LogicalStateElement.Type type = ((LogicalStateElement) stateElement).getType();
LogicalPreStateProcessor logicalPreStateProcessor1;
if (((LogicalStateElement) stateElement).getStreamStateElement1() instanceof AbsentStreamStateElement) {
logicalPreStateProcessor1 = new AbsentLogicalPreStateProcessor(type, stateType, ((AbsentStreamStateElement) ((LogicalStateElement) stateElement).getStreamStateElement1()).getWaitingTime());
// Set the scheduler
startupPreStateProcessors.add(logicalPreStateProcessor1);
EntryValveProcessor entryValveProcessor = new EntryValveProcessor(siddhiQueryContext.getSiddhiAppContext());
entryValveProcessor.setToLast(logicalPreStateProcessor1);
Scheduler scheduler = SchedulerParser.parse(entryValveProcessor, siddhiQueryContext);
((SchedulingProcessor) logicalPreStateProcessor1).setScheduler(scheduler);
} else {
logicalPreStateProcessor1 = new LogicalPreStateProcessor(type, stateType);
}
logicalPreStateProcessor1.init(siddhiQueryContext);
LogicalPostStateProcessor logicalPostStateProcessor1;
if (((LogicalStateElement) stateElement).getStreamStateElement1() instanceof AbsentStreamStateElement) {
logicalPostStateProcessor1 = new AbsentLogicalPostStateProcessor(type);
} else {
logicalPostStateProcessor1 = new LogicalPostStateProcessor(type);
}
LogicalPreStateProcessor logicalPreStateProcessor2;
if (((LogicalStateElement) stateElement).getStreamStateElement2() instanceof AbsentStreamStateElement) {
logicalPreStateProcessor2 = new AbsentLogicalPreStateProcessor(type, stateType, ((AbsentStreamStateElement) ((LogicalStateElement) stateElement).getStreamStateElement2()).getWaitingTime());
startupPreStateProcessors.add(logicalPreStateProcessor2);
EntryValveProcessor entryValveProcessor = new EntryValveProcessor(siddhiQueryContext.getSiddhiAppContext());
entryValveProcessor.setToLast(logicalPreStateProcessor2);
Scheduler scheduler = SchedulerParser.parse(entryValveProcessor, siddhiQueryContext);
((SchedulingProcessor) logicalPreStateProcessor2).setScheduler(scheduler);
} else {
logicalPreStateProcessor2 = new LogicalPreStateProcessor(type, stateType);
}
logicalPreStateProcessor2.init(siddhiQueryContext);
LogicalPostStateProcessor logicalPostStateProcessor2;
if (((LogicalStateElement) stateElement).getStreamStateElement2() instanceof AbsentStreamStateElement) {
logicalPostStateProcessor2 = new AbsentLogicalPostStateProcessor(type);
} else {
logicalPostStateProcessor2 = new LogicalPostStateProcessor(type);
}
logicalPostStateProcessor1.setPartnerPreStateProcessor(logicalPreStateProcessor2);
logicalPostStateProcessor2.setPartnerPreStateProcessor(logicalPreStateProcessor1);
logicalPostStateProcessor1.setPartnerPostStateProcessor(logicalPostStateProcessor2);
logicalPostStateProcessor2.setPartnerPostStateProcessor(logicalPostStateProcessor1);
logicalPreStateProcessor1.setPartnerStatePreProcessor(logicalPreStateProcessor2);
logicalPreStateProcessor2.setPartnerStatePreProcessor(logicalPreStateProcessor1);
StateElement stateElement2 = ((LogicalStateElement) stateElement).getStreamStateElement2();
InnerStateRuntime innerStateRuntime2 = parse(stateElement2, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, variableExpressionExecutors, processStreamReceiverMap, logicalPreStateProcessor2, logicalPostStateProcessor2, stateType, multiValue, preStateProcessors, isStartState, startupPreStateProcessors, siddhiQueryContext);
StateElement stateElement1 = ((LogicalStateElement) stateElement).getStreamStateElement1();
InnerStateRuntime innerStateRuntime1 = parse(stateElement1, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, variableExpressionExecutors, processStreamReceiverMap, logicalPreStateProcessor1, logicalPostStateProcessor1, stateType, multiValue, preStateProcessors, isStartState, startupPreStateProcessors, siddhiQueryContext);
LogicalInnerStateRuntime logicalInnerStateRuntime = new LogicalInnerStateRuntime(innerStateRuntime1, innerStateRuntime2, stateType);
logicalInnerStateRuntime.setFirstProcessor(innerStateRuntime1.getFirstProcessor());
logicalInnerStateRuntime.setLastProcessor(innerStateRuntime2.getLastProcessor());
for (SingleStreamRuntime singleStreamRuntime : innerStateRuntime2.getSingleStreamRuntimeList()) {
logicalInnerStateRuntime.addStreamRuntime(singleStreamRuntime);
}
for (SingleStreamRuntime singleStreamRuntime : innerStateRuntime1.getSingleStreamRuntimeList()) {
logicalInnerStateRuntime.addStreamRuntime(singleStreamRuntime);
}
return logicalInnerStateRuntime;
} else if (stateElement instanceof CountStateElement) {
int minCount = ((CountStateElement) stateElement).getMinCount();
int maxCount = ((CountStateElement) stateElement).getMaxCount();
if (minCount == SiddhiConstants.ANY) {
minCount = 0;
}
if (maxCount == SiddhiConstants.ANY) {
maxCount = Integer.MAX_VALUE;
}
CountPreStateProcessor countPreStateProcessor = new CountPreStateProcessor(minCount, maxCount, stateType);
countPreStateProcessor.init(siddhiQueryContext);
CountPostStateProcessor countPostStateProcessor = new CountPostStateProcessor(minCount, maxCount);
countPreStateProcessor.setCountPostStateProcessor(countPostStateProcessor);
StateElement currentElement = ((CountStateElement) stateElement).getStreamStateElement();
InnerStateRuntime innerStateRuntime = parse(currentElement, streamDefinitionMap, tableDefinitionMap, windowDefinitionMap, aggregationDefinitionMap, tableMap, metaStateEvent, variableExpressionExecutors, processStreamReceiverMap, countPreStateProcessor, countPostStateProcessor, stateType, true, preStateProcessors, isStartState, startupPreStateProcessors, siddhiQueryContext);
return new CountInnerStateRuntime((StreamInnerStateRuntime) innerStateRuntime);
} else {
throw new OperationNotSupportedException();
}
}
use of io.siddhi.core.exception.OperationNotSupportedException in project siddhi by wso2.
the class ExpressionBuilder method buildVariableExecutors.
private void buildVariableExecutors(Expression expression, ExpressionVisitor expressionVisitor) {
try {
if (expression instanceof And) {
expressionVisitor.beginVisitAnd();
expressionVisitor.beginVisitAndLeftOperand();
buildVariableExecutors(((And) expression).getLeftExpression(), expressionVisitor);
expressionVisitor.endVisitAndLeftOperand();
expressionVisitor.beginVisitAndRightOperand();
buildVariableExecutors(((And) expression).getRightExpression(), expressionVisitor);
expressionVisitor.endVisitAndRightOperand();
expressionVisitor.endVisitAnd();
} else if (expression instanceof Or) {
expressionVisitor.beginVisitOr();
expressionVisitor.beginVisitOrLeftOperand();
buildVariableExecutors(((Or) expression).getLeftExpression(), expressionVisitor);
expressionVisitor.endVisitOrLeftOperand();
expressionVisitor.beginVisitOrRightOperand();
buildVariableExecutors(((Or) expression).getRightExpression(), expressionVisitor);
expressionVisitor.endVisitOrRightOperand();
expressionVisitor.endVisitOr();
} else if (expression instanceof Not) {
expressionVisitor.beginVisitNot();
buildVariableExecutors(((Not) expression).getExpression(), expressionVisitor);
expressionVisitor.endVisitNot();
} else if (expression instanceof Compare) {
expressionVisitor.beginVisitCompare(((Compare) expression).getOperator());
expressionVisitor.beginVisitCompareLeftOperand(((Compare) expression).getOperator());
buildVariableExecutors(((Compare) expression).getLeftExpression(), expressionVisitor);
expressionVisitor.endVisitCompareLeftOperand(((Compare) expression).getOperator());
expressionVisitor.beginVisitCompareRightOperand(((Compare) expression).getOperator());
buildVariableExecutors(((Compare) expression).getRightExpression(), expressionVisitor);
expressionVisitor.endVisitCompareRightOperand(((Compare) expression).getOperator());
expressionVisitor.endVisitCompare(((Compare) expression).getOperator());
} else if (expression instanceof Add) {
expressionVisitor.beginVisitMath(ExpressionVisitor.MathOperator.ADD);
expressionVisitor.beginVisitMathLeftOperand(ExpressionVisitor.MathOperator.ADD);
buildVariableExecutors(((Add) expression).getLeftValue(), expressionVisitor);
expressionVisitor.endVisitMathLeftOperand(ExpressionVisitor.MathOperator.ADD);
expressionVisitor.beginVisitMathRightOperand(ExpressionVisitor.MathOperator.ADD);
buildVariableExecutors(((Add) expression).getRightValue(), expressionVisitor);
expressionVisitor.endVisitMathRightOperand(ExpressionVisitor.MathOperator.ADD);
expressionVisitor.endVisitMath(ExpressionVisitor.MathOperator.ADD);
} else if (expression instanceof Subtract) {
expressionVisitor.beginVisitMath(ExpressionVisitor.MathOperator.SUBTRACT);
expressionVisitor.beginVisitMathLeftOperand(ExpressionVisitor.MathOperator.SUBTRACT);
buildVariableExecutors(((Subtract) expression).getLeftValue(), expressionVisitor);
expressionVisitor.endVisitMathLeftOperand(ExpressionVisitor.MathOperator.SUBTRACT);
expressionVisitor.beginVisitMathRightOperand(ExpressionVisitor.MathOperator.SUBTRACT);
buildVariableExecutors(((Subtract) expression).getRightValue(), expressionVisitor);
expressionVisitor.endVisitMathRightOperand(ExpressionVisitor.MathOperator.SUBTRACT);
expressionVisitor.endVisitMath(ExpressionVisitor.MathOperator.SUBTRACT);
} else if (expression instanceof Divide) {
expressionVisitor.beginVisitMath(ExpressionVisitor.MathOperator.DIVIDE);
expressionVisitor.beginVisitMathLeftOperand(ExpressionVisitor.MathOperator.DIVIDE);
buildVariableExecutors(((Divide) expression).getLeftValue(), expressionVisitor);
expressionVisitor.endVisitMathLeftOperand(ExpressionVisitor.MathOperator.DIVIDE);
expressionVisitor.beginVisitMathRightOperand(ExpressionVisitor.MathOperator.DIVIDE);
buildVariableExecutors(((Divide) expression).getRightValue(), expressionVisitor);
expressionVisitor.endVisitMathRightOperand(ExpressionVisitor.MathOperator.DIVIDE);
expressionVisitor.endVisitMath(ExpressionVisitor.MathOperator.DIVIDE);
} else if (expression instanceof Multiply) {
expressionVisitor.beginVisitMath(ExpressionVisitor.MathOperator.MULTIPLY);
expressionVisitor.beginVisitMathLeftOperand(ExpressionVisitor.MathOperator.MULTIPLY);
buildVariableExecutors(((Multiply) expression).getLeftValue(), expressionVisitor);
expressionVisitor.endVisitMathLeftOperand(ExpressionVisitor.MathOperator.MULTIPLY);
expressionVisitor.beginVisitMathRightOperand(ExpressionVisitor.MathOperator.MULTIPLY);
buildVariableExecutors(((Multiply) expression).getRightValue(), expressionVisitor);
expressionVisitor.endVisitMathRightOperand(ExpressionVisitor.MathOperator.MULTIPLY);
expressionVisitor.endVisitMath(ExpressionVisitor.MathOperator.MULTIPLY);
} else if (expression instanceof Mod) {
expressionVisitor.beginVisitMath(ExpressionVisitor.MathOperator.MOD);
expressionVisitor.beginVisitMathLeftOperand(ExpressionVisitor.MathOperator.MOD);
buildVariableExecutors(((Mod) expression).getLeftValue(), expressionVisitor);
expressionVisitor.endVisitMathLeftOperand(ExpressionVisitor.MathOperator.MOD);
expressionVisitor.beginVisitMathRightOperand(ExpressionVisitor.MathOperator.MOD);
buildVariableExecutors(((Mod) expression).getRightValue(), expressionVisitor);
expressionVisitor.endVisitMathRightOperand(ExpressionVisitor.MathOperator.MOD);
expressionVisitor.endVisitMath(ExpressionVisitor.MathOperator.MOD);
} else if (expression instanceof IsNull) {
IsNull isNull = (IsNull) expression;
if (isNull.getExpression() != null) {
expressionVisitor.beginVisitIsNull(null);
buildVariableExecutors(((IsNull) expression).getExpression(), expressionVisitor);
expressionVisitor.endVisitIsNull(null);
} else {
String streamId = isNull.getStreamId();
MetaStateEvent metaStateEvent = matchingMetaInfoHolder.getMetaStateEvent();
if (streamId == null) {
throw new SiddhiAppCreationException("IsNull does not support streamId being null");
} else {
AbstractDefinition definitionOutput = null;
MetaStreamEvent[] metaStreamEvents = metaStateEvent.getMetaStreamEvents();
for (int i = 0, metaStreamEventsLength = metaStreamEvents.length; i < metaStreamEventsLength; i++) {
MetaStreamEvent metaStreamEvent = metaStreamEvents[i];
AbstractDefinition definition = metaStreamEvent.getLastInputDefinition();
if (metaStreamEvent.getInputReferenceId() == null) {
if (definition.getId().equals(streamId)) {
definitionOutput = definition;
break;
}
} else {
if (metaStreamEvent.getInputReferenceId().equals(streamId)) {
definitionOutput = definition;
break;
}
}
}
if (definitionOutput != null) {
expressionVisitor.beginVisitIsNull(definitionOutput.getId());
expressionVisitor.endVisitIsNull(definitionOutput.getId());
} else {
expressionVisitor.beginVisitIsNull(null);
expressionVisitor.endVisitIsNull(null);
}
}
}
} else if (expression instanceof In) {
expressionVisitor.beginVisitIn(((In) expression).getSourceId());
buildVariableExecutors(((In) expression).getExpression(), expressionVisitor);
expressionVisitor.endVisitIn(((In) expression).getSourceId());
} else if (expression instanceof Constant) {
if (expression instanceof DoubleConstant) {
expressionVisitor.beginVisitConstant(((DoubleConstant) expression).getValue(), Attribute.Type.DOUBLE);
expressionVisitor.endVisitConstant(((DoubleConstant) expression).getValue(), Attribute.Type.DOUBLE);
} else if (expression instanceof StringConstant) {
expressionVisitor.beginVisitConstant(((StringConstant) expression).getValue(), Attribute.Type.STRING);
expressionVisitor.endVisitConstant(((StringConstant) expression).getValue(), Attribute.Type.STRING);
} else if (expression instanceof IntConstant) {
expressionVisitor.beginVisitConstant(((IntConstant) expression).getValue(), Attribute.Type.INT);
expressionVisitor.endVisitConstant(((IntConstant) expression).getValue(), Attribute.Type.INT);
} else if (expression instanceof BoolConstant) {
expressionVisitor.beginVisitConstant(((BoolConstant) expression).getValue(), Attribute.Type.BOOL);
expressionVisitor.endVisitConstant(((BoolConstant) expression).getValue(), Attribute.Type.BOOL);
} else if (expression instanceof FloatConstant) {
expressionVisitor.beginVisitConstant(((FloatConstant) expression).getValue(), Attribute.Type.FLOAT);
expressionVisitor.endVisitConstant(((FloatConstant) expression).getValue(), Attribute.Type.FLOAT);
} else if (expression instanceof LongConstant) {
expressionVisitor.beginVisitConstant(((LongConstant) expression).getValue(), Attribute.Type.LONG);
expressionVisitor.endVisitConstant(((LongConstant) expression).getValue(), Attribute.Type.LONG);
} else {
throw new OperationNotSupportedException("No constant exist with type " + expression.getClass().getName());
}
} else if (expression instanceof AttributeFunction) {
expressionVisitor.beginVisitAttributeFunction(((AttributeFunction) expression).getNamespace(), ((AttributeFunction) expression).getName());
Expression[] expressions = ((AttributeFunction) expression).getParameters();
if (expressions != null) {
for (int i = 0; i < expressions.length; i++) {
expressionVisitor.beginVisitParameterAttributeFunction(i);
buildVariableExecutors(expressions[i], expressionVisitor);
expressionVisitor.endVisitParameterAttributeFunction(i);
}
}
expressionVisitor.endVisitAttributeFunction(((AttributeFunction) expression).getNamespace(), ((AttributeFunction) expression).getName());
} else if (expression instanceof Variable) {
Variable variable = ((Variable) expression);
String attributeName = variable.getAttributeName();
AbstractDefinition definition;
Attribute.Type type = null;
int streamEventChainIndex = matchingMetaInfoHolder.getCurrentState();
if (variable.getStreamId() == null) {
MetaStreamEvent[] metaStreamEvents = matchingMetaInfoHolder.getMetaStateEvent().getMetaStreamEvents();
if (streamEventChainIndex == UNKNOWN_STATE) {
String firstInput = null;
for (int i = 0; i < metaStreamEvents.length; i++) {
MetaStreamEvent metaStreamEvent = metaStreamEvents[i];
definition = metaStreamEvent.getLastInputDefinition();
if (type == null) {
try {
type = definition.getAttributeType(attributeName);
firstInput = "Input Stream: " + definition.getId() + " with " + "reference: " + metaStreamEvent.getInputReferenceId();
streamEventChainIndex = i;
} catch (AttributeNotExistException e) {
// do nothing
}
} else {
try {
definition.getAttributeType(attributeName);
throw new SiddhiAppValidationException(firstInput + " and Input Stream: " + definition.getId() + " with " + "reference: " + metaStreamEvent.getInputReferenceId() + " contains attribute " + "with same" + " name '" + attributeName + "'");
} catch (AttributeNotExistException e) {
// do nothing as its expected
}
}
}
if (streamEventChainIndex != UNKNOWN_STATE) {
if (matchingMetaInfoHolder.getMatchingStreamEventIndex() == streamEventChainIndex) {
buildStreamVariableExecutor(variable, streamEventChainIndex, expressionVisitor, type);
} else {
buildStoreVariableExecutor(variable, expressionVisitor, type, matchingMetaInfoHolder.getStoreDefinition());
}
} else {
// Having state : i.e attribute is in the select clause
definition = matchingMetaInfoHolder.getMetaStateEvent().getOutputStreamDefinition();
try {
type = definition.getAttributeType(attributeName);
buildStoreVariableExecutor(variable, expressionVisitor, type, matchingMetaInfoHolder.getStoreDefinition());
} catch (AttributeNotExistException e) {
// do nothing as its not expected
}
}
} else {
MetaStreamEvent metaStreamEvent = matchingMetaInfoHolder.getMetaStateEvent().getMetaStreamEvent(matchingMetaInfoHolder.getCurrentState());
definition = metaStreamEvent.getLastInputDefinition();
try {
type = definition.getAttributeType(attributeName);
} catch (AttributeNotExistException e) {
// Having state : i.e attribute is in the select clause
definition = matchingMetaInfoHolder.getMetaStateEvent().getOutputStreamDefinition();
try {
type = definition.getAttributeType(attributeName);
buildStoreVariableExecutor(variable, expressionVisitor, type, matchingMetaInfoHolder.getStoreDefinition());
} catch (AttributeNotExistException e1) {
throw new SiddhiAppValidationException(e1.getMessageWithOutContext() + " Input Stream: " + definition.getId() + " with " + "reference: " + metaStreamEvent.getInputReferenceId(), e1.getQueryContextStartIndex(), e1.getQueryContextEndIndex(), siddhiQueryContext.getSiddhiAppContext().getName(), siddhiQueryContext.getSiddhiAppContext().getSiddhiAppString());
}
}
if (matchingMetaInfoHolder.getCurrentState() == matchingMetaInfoHolder.getMatchingStreamEventIndex()) {
buildStreamVariableExecutor(variable, streamEventChainIndex, expressionVisitor, type);
} else {
buildStoreVariableExecutor(variable, expressionVisitor, type, matchingMetaInfoHolder.getStoreDefinition());
}
}
} else {
MetaStreamEvent[] metaStreamEvents = matchingMetaInfoHolder.getMetaStateEvent().getMetaStreamEvents();
for (int i = 0, metaStreamEventsLength = metaStreamEvents.length; i < metaStreamEventsLength; i++) {
MetaStreamEvent metaStreamEvent = metaStreamEvents[i];
definition = metaStreamEvent.getLastInputDefinition();
if (metaStreamEvent.getInputReferenceId() == null) {
if (definition.getId().equals(variable.getStreamId())) {
type = definition.getAttributeType(attributeName);
streamEventChainIndex = i;
break;
}
} else {
if (metaStreamEvent.getInputReferenceId().equals(variable.getStreamId())) {
type = definition.getAttributeType(attributeName);
streamEventChainIndex = i;
break;
}
}
}
if (matchingMetaInfoHolder.getMatchingStreamEventIndex() == streamEventChainIndex) {
buildStreamVariableExecutor(variable, streamEventChainIndex, expressionVisitor, type);
} else {
buildStoreVariableExecutor(variable, expressionVisitor, type, matchingMetaInfoHolder.getStoreDefinition());
}
}
}
} catch (Throwable t) {
ExceptionUtil.populateQueryContext(t, expression, siddhiQueryContext.getSiddhiAppContext(), siddhiQueryContext);
throw t;
}
}
use of io.siddhi.core.exception.OperationNotSupportedException in project siddhi by wso2.
the class MaxAttributeAggregatorExecutor method init.
/**
* The initialization method for FunctionExecutor
*
* @param attributeExpressionExecutors are the executors of each attributes in the function
* @param processingMode query processing mode
* @param outputExpectsExpiredEvents is expired events sent as output
* @param configReader this hold the {@link MaxAttributeAggregatorExecutor} configuration reader.
* @param siddhiQueryContext Siddhi query runtime context
*/
@Override
protected StateFactory<MaxAggregatorState> init(ExpressionExecutor[] attributeExpressionExecutors, ProcessingMode processingMode, boolean outputExpectsExpiredEvents, ConfigReader configReader, SiddhiQueryContext siddhiQueryContext) {
if (attributeExpressionExecutors.length != 1) {
throw new OperationNotSupportedException("Max aggregator has to have exactly 1 parameter, currently " + attributeExpressionExecutors.length + " parameters provided");
}
boolean trackFutureStates = false;
if (processingMode == ProcessingMode.SLIDE || outputExpectsExpiredEvents) {
trackFutureStates = true;
}
attributeExpressionExecutor = attributeExpressionExecutors[0];
returnType = attributeExpressionExecutors[0].getReturnType();
boolean finalTrackFutureStates = trackFutureStates;
return () -> {
switch(returnType) {
case FLOAT:
return new MaxAttributeAggregatorStateFloat(finalTrackFutureStates);
case INT:
return new MaxAttributeAggregatorStateInt(finalTrackFutureStates);
case LONG:
return new MaxAttributeAggregatorStateLong(finalTrackFutureStates);
case DOUBLE:
return new MaxAttributeAggregatorStateDouble(finalTrackFutureStates);
default:
throw new OperationNotSupportedException("Max not supported for " + returnType);
}
};
}
use of io.siddhi.core.exception.OperationNotSupportedException in project siddhi by wso2.
the class IndexEventHolder method findEvents.
@Override
public Collection<StreamEvent> findEvents(String attribute, Compare.Operator operator, Object value) {
if (primaryKeyData != null && attribute.equals(primaryKeyAttributes)) {
StreamEvent resultEvent;
HashSet<StreamEvent> resultEventSet;
switch(operator) {
case LESS_THAN:
return ((TreeMap<Object, StreamEvent>) primaryKeyData).headMap(value, false).values();
case GREATER_THAN:
return ((TreeMap<Object, StreamEvent>) primaryKeyData).tailMap(value, false).values();
case LESS_THAN_EQUAL:
return ((TreeMap<Object, StreamEvent>) primaryKeyData).headMap(value, true).values();
case GREATER_THAN_EQUAL:
return ((TreeMap<Object, StreamEvent>) primaryKeyData).tailMap(value, true).values();
case EQUAL:
resultEventSet = new HashSet<StreamEvent>();
resultEvent = primaryKeyData.get(value);
if (resultEvent != null) {
resultEventSet.add(resultEvent);
}
return resultEventSet;
case NOT_EQUAL:
if (primaryKeyData.size() > 0) {
resultEventSet = new HashSet<StreamEvent>(primaryKeyData.values());
} else {
return new HashSet<StreamEvent>();
}
resultEvent = primaryKeyData.get(value);
if (resultEvent != null) {
resultEventSet.remove(resultEvent);
}
return resultEventSet;
}
} else {
HashSet<StreamEvent> resultEventSet = new HashSet<StreamEvent>();
TreeMap<Object, Set<StreamEvent>> currentIndexedData = indexData.get(attribute);
Set<StreamEvent> resultEvents;
switch(operator) {
case LESS_THAN:
for (Set<StreamEvent> eventSet : currentIndexedData.headMap(value, false).values()) {
resultEventSet.addAll(eventSet);
}
return resultEventSet;
case GREATER_THAN:
for (Set<StreamEvent> eventSet : currentIndexedData.tailMap(value, false).values()) {
resultEventSet.addAll(eventSet);
}
return resultEventSet;
case LESS_THAN_EQUAL:
for (Set<StreamEvent> eventSet : currentIndexedData.headMap(value, true).values()) {
resultEventSet.addAll(eventSet);
}
return resultEventSet;
case GREATER_THAN_EQUAL:
for (Set<StreamEvent> eventSet : currentIndexedData.tailMap(value, true).values()) {
resultEventSet.addAll(eventSet);
}
return resultEventSet;
case EQUAL:
resultEvents = currentIndexedData.get(value);
if (resultEvents != null) {
resultEventSet.addAll(resultEvents);
}
return resultEventSet;
case NOT_EQUAL:
if (currentIndexedData.size() > 0) {
resultEventSet = new HashSet<StreamEvent>();
for (Set<StreamEvent> eventSet : currentIndexedData.values()) {
resultEventSet.addAll(eventSet);
}
} else {
resultEventSet = new HashSet<StreamEvent>();
}
resultEvents = currentIndexedData.get(value);
if (resultEvents != null) {
resultEventSet.removeAll(resultEvents);
}
return resultEventSet;
}
}
throw new OperationNotSupportedException(operator + " not supported for '" + value + "' by " + getClass().getName());
}
Aggregations