private static ExpressionExecutor[] parseInnerExpression(Expression[] innerExpressions, MetaComplexEvent metaEvent,
                                                             int currentState, Map<String, Table> tableMap,
                                                             List<VariableExpressionExecutor> executorList,
                                                             boolean groupBy,
                                                             int defaultStreamEventIndex,
                                                             ProcessingMode processingMode,
                                                             boolean outputExpectsExpiredEvents,
                                                             SiddhiQueryContext siddhiQueryContext) {
        ExpressionExecutor[] innerExpressionExecutors;
        if (innerExpressions != null) {
            if (innerExpressions.length > 0) {
                innerExpressionExecutors = new ExpressionExecutor[innerExpressions.length];
                for (int i = 0, innerExpressionsLength = innerExpressions.length; i < innerExpressionsLength; i++) {
                    innerExpressionExecutors[i] = parseExpression(innerExpressions[i], metaEvent, currentState,
                            tableMap, executorList, groupBy, defaultStreamEventIndex,
                            processingMode, outputExpectsExpiredEvents, siddhiQueryContext);
                }
            } else {
                List<Expression> outputAttributes = new ArrayList<Expression>();
                if (metaEvent instanceof MetaStreamEvent) {

                    List<Attribute> attributeList = ((MetaStreamEvent) metaEvent).getLastInputDefinition()
                            .getAttributeList();
                    for (Attribute attribute : attributeList) {
                        outputAttributes.add(new Variable(attribute.getName()));
                    }
                } else {
                    for (MetaStreamEvent metaStreamEvent : ((MetaStateEvent) metaEvent).getMetaStreamEvents()) {
                        List<Attribute> attributeList = metaStreamEvent.getLastInputDefinition().getAttributeList();
                        for (Attribute attribute : attributeList) {
                            Expression outputAttribute = new Variable(attribute.getName());
                            if (!outputAttributes.contains(outputAttribute)) {
                                outputAttributes.add(outputAttribute);
                            } else {
                                List<AbstractDefinition> definitions = new ArrayList<AbstractDefinition>();
                                for (MetaStreamEvent aMetaStreamEvent : ((MetaStateEvent) metaEvent)
                                        .getMetaStreamEvents()) {
                                    definitions.add(aMetaStreamEvent.getLastInputDefinition());
                                }
                                throw new DuplicateAttributeException(
                                        "Duplicate attribute exist in streams " + definitions,
                                        attribute.getQueryContextStartIndex(), attribute.getQueryContextEndIndex());
                            }
                        }
                    }
                }
                innerExpressionExecutors = new ExpressionExecutor[outputAttributes.size()];
                for (int i = 0, innerExpressionsLength = outputAttributes.size(); i < innerExpressionsLength; i++) {
                    innerExpressionExecutors[i] = parseExpression(outputAttributes.get(i), metaEvent, currentState,
                            tableMap, executorList, groupBy, defaultStreamEventIndex,
                            processingMode, outputExpectsExpiredEvents, siddhiQueryContext);
                }
            }
        } else {
            innerExpressionExecutors = new ExpressionExecutor[0];
        }
        return innerExpressionExecutors;
    }
Parse the set of inner expression of AttributeFunctionExtensions and handling all (*) cases

@param innerExpressions           InnerExpressions to be parsed
@param metaEvent                  Meta Event
@param currentState               Current state number
@param tableMap                   Event Table Map
@param executorList               List to hold VariableExpressionExecutors to update after query parsing @return
@param groupBy                    is for groupBy expression
@param defaultStreamEventIndex    Default StreamEvent Index
@param processingMode             processing mode of the query
@param outputExpectsExpiredEvents is expired events sent as output
@param siddhiQueryContext         current siddhi query context
@return List of expressionExecutors
modules/siddhi-core/src/main/java/io/siddhi/core/util/parser/ExpressionParser.java