Ejemplo n.º 1
0
        private static FilterSpecParamForge MakeBooleanExprParam(
            ExprNode exprNode,
            FilterSpecCompilerArgs args)
        {
            bool hasSubselectFilterStream = DetermineSubselectFilterStream(exprNode);
            bool hasTableAccess = DetermineTableAccessFilterStream(exprNode);

            ExprNodeVariableVisitor visitor =
                new ExprNodeVariableVisitor(args.compileTimeServices.VariableCompileTimeResolver);
            exprNode.Accept(visitor);
            bool hasVariable = visitor.IsVariables;

            ExprFilterSpecLookupableForge lookupable = new ExprFilterSpecLookupableForge(
                PROPERTY_NAME_BOOLEAN_EXPRESSION,
                null,
                exprNode.Forge.EvaluationType,
                false);

            return new FilterSpecParamExprNodeForge(
                lookupable,
                FilterOperator.BOOLEAN_EXPRESSION,
                exprNode,
                args.taggedEventTypes,
                args.arrayEventTypes,
                args.streamTypeService,
                hasSubselectFilterStream,
                hasTableAccess,
                hasVariable,
                args.compileTimeServices);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Ctor.
        /// </summary>
        /// <param name="lookupable">is the lookup-able</param>
        /// <param name="filterOperator">is expected to be the BOOLEAN_EXPR operator</param>
        /// <param name="exprNode">represents the boolean expression</param>
        /// <param name="taggedEventTypes">is null if the expression doesn't need other streams, or is filled with a ordered list of stream names and types</param>
        /// <param name="arrayEventTypes">is a map of name tags and event type per tag for repeat-expressions that generate an array of events</param>
        /// <param name="variableService">provides access to variables</param>
        /// <param name="tableService">The table service.</param>
        /// <param name="eventAdapterService">for creating event types and event beans</param>
        /// <param name="configurationInformation">The configuration information.</param>
        /// <param name="statementName">Name of the statement.</param>
        /// <param name="hasSubquery">if set to <c>true</c> [has subquery].</param>
        /// <param name="hasTableAccess">if set to <c>true</c> [has table access].</param>
        /// <exception cref="System.ArgumentException">Invalid filter operator for filter expression node</exception>
        /// <throws>IllegalArgumentException for illegal args</throws>
        public FilterSpecParamExprNode(
            FilterSpecLookupable lookupable,
            FilterOperator filterOperator,
            ExprNode exprNode,
            IDictionary <string, Pair <EventType, string> > taggedEventTypes,
            IDictionary <string, Pair <EventType, string> > arrayEventTypes,
            VariableService variableService,
            TableService tableService,
            EventAdapterService eventAdapterService,
            ConfigurationInformation configurationInformation,
            string statementName,
            bool hasSubquery,
            bool hasTableAccess)
            : base(lookupable, filterOperator)
        {
            if (filterOperator != FilterOperator.BOOLEAN_EXPRESSION)
            {
                throw new ArgumentException("Invalid filter operator for filter expression node");
            }
            _exprNode                 = exprNode;
            _taggedEventTypes         = taggedEventTypes;
            _arrayEventTypes          = arrayEventTypes;
            _variableService          = variableService;
            _tableService             = tableService;
            _eventAdapterService      = eventAdapterService;
            _useLargeThreadingProfile = configurationInformation.EngineDefaults.ExecutionConfig.ThreadingProfile == ConfigurationEngineDefaults.ThreadingProfile.LARGE;
            _hasFilterStreamSubquery  = hasSubquery;
            _hasTableAccess           = hasTableAccess;

            var visitor = new ExprNodeVariableVisitor();

            exprNode.Accept(visitor);
            _hasVariable = visitor.HasVariables;
        }
Ejemplo n.º 3
0
        public OutputConditionExpressionFactory(
            ExprNode whenExpressionNode,
            IList<OnTriggerSetAssignment> assignments,
            StatementContext statementContext,
            ExprNode andWhenTerminatedExpr,
            IList<OnTriggerSetAssignment> afterTerminateAssignments,
            bool isStartConditionOnCreation)
        {
            _whenExpressionNodeEval = whenExpressionNode.ExprEvaluator;
            _andWhenTerminatedExpressionNodeEval = andWhenTerminatedExpr != null ? andWhenTerminatedExpr.ExprEvaluator : null;
            _isStartConditionOnCreation = isStartConditionOnCreation;

            // determine if using variables
            var variableVisitor = new ExprNodeVariableVisitor(statementContext.VariableService);
            whenExpressionNode.Accept(variableVisitor);
            _variableNames = variableVisitor.VariableNames;

            // determine if using properties
            bool containsBuiltinProperties = ContainsBuiltinProperties(whenExpressionNode);
            if (!containsBuiltinProperties && assignments != null)
            {
                foreach (OnTriggerSetAssignment assignment in assignments)
                {
                    if (ContainsBuiltinProperties(assignment.Expression))
                    {
                        containsBuiltinProperties = true;
                    }
                }
            }
            if (!containsBuiltinProperties && _andWhenTerminatedExpressionNodeEval != null)
            {
                containsBuiltinProperties = ContainsBuiltinProperties(andWhenTerminatedExpr);
            }
            if (!containsBuiltinProperties && afterTerminateAssignments != null)
            {
                foreach (OnTriggerSetAssignment assignment in afterTerminateAssignments)
                {
                    if (ContainsBuiltinProperties(assignment.Expression))
                    {
                        containsBuiltinProperties = true;
                    }
                }
            }

            if (containsBuiltinProperties)
            {
                _builtinPropertiesEventType = GetBuiltInEventType(statementContext.EventAdapterService);
            }

            if (assignments != null)
            {
                _variableReadWritePackage = new VariableReadWritePackage(
                    assignments, statementContext.VariableService, statementContext.EventAdapterService);
            }
            else
            {
                _variableReadWritePackage = null;
            }

            if (afterTerminateAssignments != null)
            {
                _variableReadWritePackageAfterTerminated = new VariableReadWritePackage(
                    afterTerminateAssignments, statementContext.VariableService, statementContext.EventAdapterService);
            }
            else
            {
                _variableReadWritePackageAfterTerminated = null;
            }
        }
Ejemplo n.º 4
0
        public OutputConditionExpressionForge(
            ExprNode whenExpressionNode,
            IList<OnTriggerSetAssignment> assignments,
            ExprNode andWhenTerminatedExpr,
            IList<OnTriggerSetAssignment> afterTerminateAssignments,
            bool isStartConditionOnCreation,
            StatementRawInfo statementRawInfo,
            StatementCompileTimeServices services)
        {
            whenExpressionNodeEval = whenExpressionNode;
            andWhenTerminatedExpressionNodeEval = andWhenTerminatedExpr;
            this.isStartConditionOnCreation = isStartConditionOnCreation;

            // determine if using variables
            var variableVisitor = new ExprNodeVariableVisitor(services.VariableCompileTimeResolver);
            whenExpressionNode.Accept(variableVisitor);
            variableNames = variableVisitor.VariableNames;

            // determine if using properties
            var containsBuiltinProperties = ContainsBuiltinProperties(whenExpressionNode);
            if (!containsBuiltinProperties && assignments != null) {
                foreach (var assignment in assignments) {
                    if (ContainsBuiltinProperties(assignment.Expression)) {
                        containsBuiltinProperties = true;
                    }
                }
            }

            if (!containsBuiltinProperties && andWhenTerminatedExpressionNodeEval != null) {
                containsBuiltinProperties = ContainsBuiltinProperties(andWhenTerminatedExpr);
            }

            if (!containsBuiltinProperties && afterTerminateAssignments != null) {
                foreach (var assignment in afterTerminateAssignments) {
                    if (ContainsBuiltinProperties(assignment.Expression)) {
                        containsBuiltinProperties = true;
                    }
                }
            }

            isUsingBuiltinProperties = containsBuiltinProperties;

            if (assignments != null && !assignments.IsEmpty()) {
                variableReadWritePackage = new VariableReadWritePackageForge(
                    assignments,
                    statementRawInfo.StatementName,
                    services);
            }
            else {
                variableReadWritePackage = null;
            }

            if (afterTerminateAssignments != null) {
                variableReadWritePackageAfterTerminated = new VariableReadWritePackageForge(
                    afterTerminateAssignments,
                    statementRawInfo.StatementName,
                    services);
            }
            else {
                variableReadWritePackageAfterTerminated = null;
            }
        }
Ejemplo n.º 5
0
        public void Attach(EventType parentEventType, StatementContext statementContext, ViewFactory optionalParentFactory, IList <ViewFactory> parentViewFactories)
        {
            _eventType = parentEventType;

            // define built-in fields
            var builtinTypeDef = ExpressionViewOAFieldEnumExtensions.AsMapOfTypes(_eventType);

            _builtinMapType = statementContext.EventAdapterService.CreateAnonymousObjectArrayType(
                statementContext.StatementId + "_exprview", builtinTypeDef);

            StreamTypeService streamTypeService = new StreamTypeServiceImpl(new EventType[] { _eventType, _builtinMapType }, new String[2], new bool[2], statementContext.EngineURI, false);

            // validate expression
            ExpiryExpression = ViewFactorySupport.ValidateExpr(ViewName, statementContext, ExpiryExpression, streamTypeService, 0);

            var summaryVisitor = new ExprNodeSummaryVisitor();

            ExpiryExpression.Accept(summaryVisitor);
            if (summaryVisitor.HasSubselect || summaryVisitor.HasStreamSelect || summaryVisitor.HasPreviousPrior)
            {
                throw new ViewParameterException("Invalid expiry expression: Sub-select, previous or prior functions are not supported in this context");
            }

            var returnType = ExpiryExpression.ExprEvaluator.ReturnType;

            if (returnType.GetBoxedType() != typeof(bool?))
            {
                throw new ViewParameterException("Invalid return value for expiry expression, expected a bool return value but received " + returnType.GetParameterAsString());
            }

            // determine variables used, if any
            var visitor = new ExprNodeVariableVisitor();

            ExpiryExpression.Accept(visitor);
            VariableNames = visitor.VariableNames;

            // determine aggregation nodes, if any
            var aggregateNodes = new List <ExprAggregateNode>();

            ExprAggregateNodeUtil.GetAggregatesBottomUp(ExpiryExpression, aggregateNodes);
            if (aggregateNodes.IsNotEmpty())
            {
                try {
                    AggregationServiceFactoryDesc = AggregationServiceFactoryFactory.GetService(
                        Collections.GetEmptyList <ExprAggregateNode>(),
                        Collections.GetEmptyMap <ExprNode, String>(),
                        Collections.GetEmptyList <ExprDeclaredNode>(),
                        null, aggregateNodes,
                        Collections.GetEmptyList <ExprAggregateNode>(),
                        Collections.GetEmptyList <ExprAggregateNodeGroupKey>(), false,
                        statementContext.Annotations,
                        statementContext.VariableService, false, false, null, null,
                        AggregationServiceFactoryServiceImpl.DEFAULT_FACTORY,
                        streamTypeService.EventTypes,
                        statementContext.MethodResolutionService, null,
                        statementContext.ContextName,
                        null, null);
                }
                catch (ExprValidationException ex) {
                    throw new ViewParameterException(ex.Message, ex);
                }
            }
        }
        public VariableReadWritePackageForge(
            IList <OnTriggerSetAssignment> assignments,
            string statementName,
            StatementCompileTimeServices services)
        {
            _variables     = new VariableMetaData[assignments.Count];
            _mustCoerce    = new bool[assignments.Count];
            _writers       = new VariableTriggerWriteForge[assignments.Count];
            _variableTypes = new Dictionary <string, object>();

            IDictionary <EventTypeSPI, CopyMethodDesc> eventTypeWrittenProps = new Dictionary <EventTypeSPI, CopyMethodDesc>();
            var count = 0;
            IList <ExprAssignment> assignmentList = new List <ExprAssignment>();

            foreach (var spec in assignments)
            {
                var assignmentDesc = spec.Validated;
                assignmentList.Add(assignmentDesc);

                try {
                    if (assignmentDesc is ExprAssignmentStraight)
                    {
                        var assignment      = (ExprAssignmentStraight)assignmentDesc;
                        var identAssignment = assignment.Lhs;

                        var variableName     = identAssignment.Ident;
                        var variableMetadata = services.VariableCompileTimeResolver.Resolve(variableName);
                        if (variableMetadata == null)
                        {
                            throw new ExprValidationException("Variable by name '" + variableName + "' has not been created or configured");
                        }

                        _variables[count] = variableMetadata;
                        var expressionType = assignment.Rhs.Forge.EvaluationType;

                        if (assignment.Lhs is ExprAssignmentLHSIdent)
                        {
                            // determine types
                            if (variableMetadata.EventType != null)
                            {
                                if ((expressionType != null) &&
                                    (!TypeHelper.IsSubclassOrImplementsInterface(expressionType, variableMetadata.EventType.UnderlyingType)))
                                {
                                    throw new ExprValidationException(
                                              "Variable '" +
                                              variableName +
                                              "' of declared event type '" +
                                              variableMetadata.EventType.Name +
                                              "' underlying type '" +
                                              variableMetadata.EventType.UnderlyingType.Name +
                                              "' cannot be assigned a value of type '" +
                                              expressionType.Name +
                                              "'");
                                }

                                _variableTypes.Put(variableName, variableMetadata.EventType.UnderlyingType);
                            }
                            else
                            {
                                var variableType = variableMetadata.Type;
                                _variableTypes.Put(variableName, variableType);

                                // determine if the expression type can be assigned
                                if (variableType != typeof(object))
                                {
                                    if ((expressionType.GetBoxedType() != variableType.GetBoxedType()) &&
                                        (expressionType != null))
                                    {
                                        if ((!TypeHelper.IsNumeric(variableType)) ||
                                            (!TypeHelper.IsNumeric(expressionType)))
                                        {
                                            throw new ExprValidationException(VariableUtil.GetAssigmentExMessage(variableName, variableType, expressionType));
                                        }

                                        if (!(TypeHelper.CanCoerce(expressionType, variableType)))
                                        {
                                            throw new ExprValidationException(VariableUtil.GetAssigmentExMessage(variableName, variableType, expressionType));
                                        }

                                        _mustCoerce[count] = true;
                                    }
                                }
                            }
                        }
                        else if (assignment.Lhs is ExprAssignmentLHSIdentWSubprop)
                        {
                            var subpropAssignment = (ExprAssignmentLHSIdentWSubprop)assignment.Lhs;
                            var subPropertyName   = subpropAssignment.SubpropertyName;
                            if (variableMetadata.EventType == null)
                            {
                                throw new ExprValidationException(
                                          "Variable by name '" + variableName + "' does not have a property named '" + subPropertyName + "'");
                            }

                            var type = variableMetadata.EventType;
                            if (!(type is EventTypeSPI))
                            {
                                throw new ExprValidationException("Variable by name '" + variableName + "' event type '" + type.Name + "' not writable");
                            }

                            var spi        = (EventTypeSPI)type;
                            var writer     = spi.GetWriter(subPropertyName);
                            var getter     = spi.GetGetterSPI(subPropertyName);
                            var getterType = spi.GetPropertyType(subPropertyName);
                            if (writer == null)
                            {
                                throw new ExprValidationException(
                                          "Variable by name '" + variableName + "' the property '" + subPropertyName + "' is not writable");
                            }

                            var fullVariableName = variableName + "." + subPropertyName;
                            _variableTypes.Put(fullVariableName, spi.GetPropertyType(subPropertyName));
                            var writtenProps = eventTypeWrittenProps.Get(spi);
                            if (writtenProps == null)
                            {
                                writtenProps = new CopyMethodDesc(variableName, new List <string>());
                                eventTypeWrittenProps.Put(spi, writtenProps);
                            }

                            writtenProps.PropertiesCopied.Add(subPropertyName);

                            _writers[count] = new VariableTriggerWriteDescForge(
                                spi,
                                variableName,
                                writer,
                                getter,
                                getterType,
                                assignment.Rhs.Forge.EvaluationType);
                        }
                        else if (assignment.Lhs is ExprAssignmentLHSArrayElement)
                        {
                            var arrayAssign  = (ExprAssignmentLHSArrayElement)assignment.Lhs;
                            var variableType = variableMetadata.Type;
                            if (!variableType.IsArray)
                            {
                                throw new ExprValidationException("Variable '" + variableMetadata.VariableName + "' is not an array");
                            }

                            TypeWidenerSPI widener;
                            try {
                                widener = TypeWidenerFactory.GetCheckPropertyAssignType(
                                    ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignment.Rhs),
                                    expressionType,
                                    variableType.GetElementType(),
                                    variableMetadata.VariableName,
                                    false,
                                    null,
                                    statementName);
                            }
                            catch (TypeWidenerException ex) {
                                throw new ExprValidationException(ex.Message, ex);
                            }

                            _writers[count] = new VariableTriggerWriteArrayElementForge(variableName, arrayAssign.IndexExpression.Forge, widener);
                        }
                        else
                        {
                            throw new IllegalStateException("Unrecognized left hand side assignment " + assignment.Lhs);
                        }
                    }
                    else if (assignmentDesc is ExprAssignmentCurly)
                    {
                        var curly = (ExprAssignmentCurly)assignmentDesc;
                        if (curly.Expression is ExprVariableNode)
                        {
                            throw new ExprValidationException("Missing variable assignment expression in assignment number " + count);
                        }

                        var variableVisitor = new ExprNodeVariableVisitor(services.VariableCompileTimeResolver);
                        curly.Expression.Accept(variableVisitor);
                        if (variableVisitor.VariableNames == null || variableVisitor.VariableNames.Count != 1)
                        {
                            throw new ExprValidationException("Assignment expression must receive a single variable value");
                        }

                        var variable = variableVisitor.VariableNames.First();
                        _variables[count] = variable.Value;
                        _writers[count]   = new VariableTriggerWriteCurlyForge(variable.Key, curly.Expression.Forge);
                    }
                    else
                    {
                        throw new IllegalStateException("Unrecognized assignment expression " + assignmentDesc);
                    }

                    if (_variables[count].IsConstant)
                    {
                        throw new ExprValidationException("Variable by name '" + _variables[count].VariableName + "' is declared constant and may not be set");
                    }

                    count++;
                }
                catch (ExprValidationException ex) {
                    throw new ExprValidationException(
                              "Failed to validate assignment expression '" +
                              ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(assignmentDesc.OriginalExpression) +
                              "': " +
                              ex.Message,
                              ex);
                }
            }

            _assignments = assignmentList.ToArray();

            if (eventTypeWrittenProps.IsEmpty())
            {
                _copyMethods = EmptyDictionary <EventTypeSPI, EventBeanCopyMethodForge> .Instance;
                return;
            }

            _copyMethods = new Dictionary <EventTypeSPI, EventBeanCopyMethodForge>();
            foreach (var entry in eventTypeWrittenProps)
            {
                var propsWritten = entry.Value.PropertiesCopied;
                var props        = propsWritten.ToArray();
                var copyMethod   = entry.Key.GetCopyMethodForge(props);
                if (copyMethod == null)
                {
                    throw new ExprValidationException(
                              "Variable '" +
                              entry.Value.VariableName +
                              "' of declared type " +
                              entry.Key.UnderlyingType.CleanName() +
                              "' cannot be assigned to");
                }

                _copyMethods.Put(entry.Key, copyMethod);
            }
        }