public ContainedEventEvalArrayToEvent( ExprEvaluator evaluator, EventBeanManufacturer manufacturer) { this.evaluator = evaluator; this.manufacturer = manufacturer; }
internal SelectExprInsertNativeNoWiden( EventType eventType, EventBeanManufacturer eventManufacturer, ExprEvaluator[] exprEvaluators) : base(eventType, eventManufacturer, exprEvaluators) { }
internal MapInsertProcessorAllocate(int underlyingStreamNumber, Item[] items, EventBeanManufacturer manufacturer, EventType resultType) { _underlyingStreamNumber = underlyingStreamNumber; _items = items; _manufacturer = manufacturer; _resultType = resultType; }
internal ParseMakePropertiesDesc(int[] indexes, SimpleTypeParser[] parsers, EventBeanManufacturer eventBeanManufacturer) { _indexes = indexes; _parsers = parsers; _eventBeanManufacturer = eventBeanManufacturer; }
internal SelectExprInsertNativeWidening( EventType eventType, EventBeanManufacturer eventManufacturer, ExprEvaluator[] exprEvaluators, TypeWidener[] wideners) : base(eventType, eventManufacturer, exprEvaluators) { _wideners = wideners; }
internal SelectExprInsertNativeBase( EventType eventType, EventBeanManufacturer eventManufacturer, ExprEvaluator[] exprEvaluators) { _eventType = eventType; EventManufacturer = eventManufacturer; ExprEvaluators = exprEvaluators; }
internal SelectExprInsertNativeNoEval(EventType eventType, EventBeanManufacturer eventManufacturer) { _eventType = eventType; _eventManufacturer = eventManufacturer; }
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext context) { _initialDelayMSec = (long)(initialDelay * 1000); _periodDelayMSec = (long)(interval * 1000); if (context.OutputPorts.Count != 1) { throw new ArgumentException( "BeaconSource operator requires one output stream but produces " + context.OutputPorts.Count + " streams"); } // Check if a type is declared var port = context.OutputPorts[0]; ICollection <string> props; if (port.OptionalDeclaredType != null && port.OptionalDeclaredType.EventType != null) { var outputEventType = port.OptionalDeclaredType.EventType; _produceEventBean = port.OptionalDeclaredType != null && !port.OptionalDeclaredType.IsUnderlying; // compile properties to populate props = _allProperties.Keys; props.RemoveAll(PARAMETER_PROPERTIES); var writables = SetupProperties(props.ToArray(), outputEventType, context.StatementContext); _manufacturer = context.ServicesContext.EventAdapterService.GetManufacturer( outputEventType, writables, context.ServicesContext.EngineImportService, false); var index = 0; _evaluators = new ExprEvaluator[writables.Length]; TypeWidenerCustomizer typeWidenerCustomizer = context.ServicesContext.EventAdapterService.GetTypeWidenerCustomizer(outputEventType); foreach (var writeable in writables) { var providedProperty = _allProperties.Get(writeable.PropertyName); if (providedProperty is ExprNode) { var exprNode = (ExprNode)providedProperty; var validated = ExprNodeUtility.ValidateSimpleGetSubtree( ExprNodeOrigin.DATAFLOWBEACON, exprNode, context.StatementContext, null, false); var exprEvaluator = validated.ExprEvaluator; var widener = TypeWidenerFactory.GetCheckPropertyAssignType( ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(validated), exprEvaluator.ReturnType, writeable.PropertyType, writeable.PropertyName, false, typeWidenerCustomizer, context.StatementContext.StatementName, context.Engine.URI); if (widener != null) { _evaluators[index] = new ProxyExprEvaluator { ProcEvaluate = evaluateParams => { var value = exprEvaluator.Evaluate(evaluateParams); return(widener.Invoke(value)); }, ProcReturnType = () => null }; } else { _evaluators[index] = exprEvaluator; } } else if (providedProperty == null) { _evaluators[index] = new ProxyExprEvaluator { ProcEvaluate = evaluateParams => null, ProcReturnType = () => null }; } else { _evaluators[index] = new ProxyExprEvaluator { ProcEvaluate = evaluateParams => providedProperty, ProcReturnType = () => providedProperty.GetType() }; } index++; } return(null); // no changing types } // No type has been declared, we can create one var anonymousTypeName = context.DataflowName + "-beacon"; var types = new LinkedHashMap <string, Object>(); props = _allProperties.Keys; props.RemoveAll(PARAMETER_PROPERTIES); var count = 0; _evaluators = new ExprEvaluator[props.Count]; foreach (var propertyName in props) { var exprNode = (ExprNode)_allProperties.Get(propertyName); var validated = ExprNodeUtility.ValidateSimpleGetSubtree(ExprNodeOrigin.DATAFLOWBEACON, exprNode, context.StatementContext, null, false); var evaluateParamsX = new EvaluateParams(null, true, context.AgentInstanceContext); var value = validated.ExprEvaluator.Evaluate(evaluateParamsX); if (value == null) { types.Put(propertyName, null); } else { types.Put(propertyName, value.GetType()); } _evaluators[count] = new ProxyExprEvaluator() { ProcEvaluate = (evaluateParams) => value, ProcReturnType = () => null }; count++; } EventType type = context.ServicesContext.EventAdapterService.CreateAnonymousObjectArrayType(anonymousTypeName, types); return(new DataFlowOpInitializeResult( new GraphTypeDesc[] { new GraphTypeDesc(false, true, type) })); }
/// <summary> /// Makes the property evaluator. /// </summary> /// <param name="spec">is the property specification</param> /// <param name="sourceEventType">the event type</param> /// <param name="optionalSourceStreamName">the source stream name</param> /// <param name="eventAdapterService">for event instances</param> /// <param name="engineImportService">The engine import service.</param> /// <param name="timeProvider">provides time</param> /// <param name="variableService">for resolving variables</param> /// <param name="scriptingService">The scripting service.</param> /// <param name="tableService">The table service.</param> /// <param name="engineURI">engine URI</param> /// <param name="statementId">The statement identifier.</param> /// <param name="statementName">Name of the statement.</param> /// <param name="annotations">The annotations.</param> /// <param name="assignedTypeNumberStack">The assigned type number stack.</param> /// <param name="configuration">The configuration.</param> /// <param name="namedWindowMgmtService">The named window service.</param> /// <param name="statementExtensionSvcContext">The statement extension SVC context.</param> /// <returns> /// propert evaluator /// </returns> /// <exception cref="ExprValidationException">Missing @type(name) declaration providing the event type name of the return type for expression ' + /// ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) + ' /// or /// Event type by name ' + atom.OptionalResultEventType + ' could not be found /// or /// Event type ' + streamEventType.Name + ' underlying type + streamEventType.UnderlyingType.Name + /// cannot be assigned a value of type + returnType.GetTypeNameFullyQualPretty() /// or /// Return type of expression ' + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) + ' is ' + returnType.Name + ', expected an Iterable or array result /// or /// Property rename ' + rawStreamSpec.MaskTypeName + ' not found in path /// or /// Expression in a property-selection may not utilize + isMinimal</exception> /// <exception cref="IllegalStateException">Unknown select clause item: + raw</exception> /// <throws>ExprValidationException if any expressions could not be verified</throws> public static PropertyEvaluator MakeEvaluator( PropertyEvalSpec spec, EventType sourceEventType, string optionalSourceStreamName, EventAdapterService eventAdapterService, EngineImportService engineImportService, TimeProvider timeProvider, VariableService variableService, ScriptingService scriptingService, TableService tableService, string engineURI, int statementId, string statementName, Attribute[] annotations, ICollection <int> assignedTypeNumberStack, ConfigurationInformation configuration, NamedWindowMgmtService namedWindowMgmtService, StatementExtensionSvcContext statementExtensionSvcContext) { var length = spec.Atoms.Count; var containedEventEvals = new ContainedEventEval[length]; var fragmentEventTypes = new FragmentEventType[length]; var currentEventType = sourceEventType; var whereClauses = new ExprEvaluator[length]; var streamEventTypes = new List <EventType>(); var streamNames = new List <string>(); var streamNameAndNumber = new Dictionary <string, int>().WithNullSupport(); var expressionTexts = new List <string>(); var validateContext = new ExprEvaluatorContextTimeOnly(timeProvider); streamEventTypes.Add(sourceEventType); streamNames.Add(optionalSourceStreamName); streamNameAndNumber.Put(optionalSourceStreamName, 0); expressionTexts.Add(sourceEventType.Name); IList <SelectClauseElementCompiled> cumulativeSelectClause = new List <SelectClauseElementCompiled>(); for (var i = 0; i < length; i++) { var atom = spec.Atoms[i]; ContainedEventEval containedEventEval = null; string expressionText = null; EventType streamEventType = null; FragmentEventType fragmentEventType = null; // Resolve directly as fragment event type if possible if (atom.SplitterExpression is ExprIdentNode) { var propertyName = ((ExprIdentNode)atom.SplitterExpression).FullUnresolvedName; fragmentEventType = currentEventType.GetFragmentType(propertyName); if (fragmentEventType != null) { var getter = currentEventType.GetGetter(propertyName); if (getter != null) { containedEventEval = new ContainedEventEvalGetter(getter); expressionText = propertyName; streamEventType = fragmentEventType.FragmentType; } } } // evaluate splitter expression if (containedEventEval == null) { ExprNodeUtility.ValidatePlainExpression( ExprNodeOrigin.CONTAINEDEVENT, ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression), atom.SplitterExpression); var availableTypes = streamEventTypes.ToArray(); var availableStreamNames = streamNames.ToArray(); var isIStreamOnly = new bool[streamNames.Count]; isIStreamOnly.Fill(true); StreamTypeService streamTypeService = new StreamTypeServiceImpl( availableTypes, availableStreamNames, isIStreamOnly, engineURI, false); var validationContext = new ExprValidationContext( streamTypeService, engineImportService, statementExtensionSvcContext, null, timeProvider, variableService, tableService, validateContext, eventAdapterService, statementName, statementId, annotations, null, scriptingService, false, false, true, false, null, false); var validatedExprNode = ExprNodeUtility.GetValidatedSubtree( ExprNodeOrigin.CONTAINEDEVENT, atom.SplitterExpression, validationContext); var evaluator = validatedExprNode.ExprEvaluator; // determine result type if (atom.OptionalResultEventType == null) { throw new ExprValidationException( "Missing @type(name) declaration providing the event type name of the return type for expression '" + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) + "'"); } streamEventType = eventAdapterService.GetEventTypeByName(atom.OptionalResultEventType); if (streamEventType == null) { throw new ExprValidationException( "Event type by name '" + atom.OptionalResultEventType + "' could not be found"); } var returnType = evaluator.ReturnType; // when the expression returns an array, allow array values to become the column of the single-column event type if (returnType.IsArray && streamEventType.PropertyNames.Length == 1 && TypeHelper.IsSubclassOrImplementsInterface( TypeHelper.GetBoxedType(returnType.GetElementType()), TypeHelper.GetBoxedType(streamEventType.GetPropertyType(streamEventType.PropertyNames[0])))) { var writables = eventAdapterService.GetWriteableProperties(streamEventType, false); if (!writables.IsEmpty()) { try { EventBeanManufacturer manufacturer = EventAdapterServiceHelper.GetManufacturer( eventAdapterService, streamEventType, new WriteablePropertyDescriptor[] { writables.First() }, engineImportService, false, eventAdapterService.EventAdapterAvroHandler); containedEventEval = new ContainedEventEvalArrayToEvent(evaluator, manufacturer); } catch (EventBeanManufactureException e) { throw new ExprValidationException( "Event type '" + streamEventType.Name + "' cannot be populated: " + e.Message, e); } } else { throw new ExprValidationException("Event type '" + streamEventType.Name + "' cannot be written to"); } } else if (returnType.IsArray() && returnType.GetElementType() == typeof(EventBean)) { containedEventEval = new ContainedEventEvalEventBeanArray(evaluator); } else { EventBeanFactory eventBeanFactory = EventAdapterServiceHelper.GetFactoryForType( streamEventType, eventAdapterService); // check expression result type against eventtype expected underlying type if (returnType.IsArray()) { if (!TypeHelper.IsSubclassOrImplementsInterface(returnType.GetElementType(), streamEventType.UnderlyingType)) { throw new ExprValidationException( "Event type '" + streamEventType.Name + "' underlying type " + streamEventType.UnderlyingType.FullName + " cannot be assigned a value of type " + TypeHelper.GetTypeNameFullyQualPretty(returnType)); } } else if (GenericExtensions.IsGenericEnumerable(returnType) || returnType.IsImplementsInterface <IEnumerable>()) { // fine, assumed to return the right type } else { throw new ExprValidationException( "Return type of expression '" + ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(atom.SplitterExpression) + "' is '" + returnType.FullName + "', expected an Iterable or array result"); } containedEventEval = new ContainedEventEvalExprNode(evaluator, eventBeanFactory); } expressionText = ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(validatedExprNode); fragmentEventType = new FragmentEventType(streamEventType, true, false); } // validate where clause, if any streamEventTypes.Add(streamEventType); streamNames.Add(atom.OptionalAsName); streamNameAndNumber.Put(atom.OptionalAsName, i + 1); expressionTexts.Add(expressionText); if (atom.OptionalWhereClause != null) { var whereTypes = streamEventTypes.ToArray(); var whereStreamNames = streamNames.ToArray(); var isIStreamOnly = new bool[streamNames.Count]; isIStreamOnly.Fill(true); StreamTypeService streamTypeService = new StreamTypeServiceImpl( whereTypes, whereStreamNames, isIStreamOnly, engineURI, false); var validationContext = new ExprValidationContext( streamTypeService, engineImportService, statementExtensionSvcContext, null, timeProvider, variableService, tableService, validateContext, eventAdapterService, statementName, statementId, annotations, null, scriptingService, false, false, true, false, null, false); whereClauses[i] = ExprNodeUtility.GetValidatedSubtree( ExprNodeOrigin.CONTAINEDEVENT, atom.OptionalWhereClause, validationContext).ExprEvaluator; } // validate select clause if (atom.OptionalSelectClause != null) { var whereTypes = streamEventTypes.ToArray(); var whereStreamNames = streamNames.ToArray(); var isIStreamOnly = new bool[streamNames.Count]; isIStreamOnly.Fill(true); StreamTypeService streamTypeService = new StreamTypeServiceImpl( whereTypes, whereStreamNames, isIStreamOnly, engineURI, false); var validationContext = new ExprValidationContext( streamTypeService, engineImportService, statementExtensionSvcContext, null, timeProvider, variableService, tableService, validateContext, eventAdapterService, statementName, statementId, annotations, null, scriptingService, false, false, true, false, null, false); foreach (var raw in atom.OptionalSelectClause.SelectExprList) { if (raw is SelectClauseStreamRawSpec) { var rawStreamSpec = (SelectClauseStreamRawSpec)raw; if (!streamNames.Contains(rawStreamSpec.StreamName)) { throw new ExprValidationException( "Property rename '" + rawStreamSpec.StreamName + "' not found in path"); } var streamSpec = new SelectClauseStreamCompiledSpec( rawStreamSpec.StreamName, rawStreamSpec.OptionalAsName); int streamNumber = streamNameAndNumber.Get(rawStreamSpec.StreamName); streamSpec.StreamNumber = streamNumber; cumulativeSelectClause.Add(streamSpec); } else if (raw is SelectClauseExprRawSpec) { var exprSpec = (SelectClauseExprRawSpec)raw; var exprCompiled = ExprNodeUtility.GetValidatedSubtree( ExprNodeOrigin.CONTAINEDEVENT, exprSpec.SelectExpression, validationContext); var resultName = exprSpec.OptionalAsName; if (resultName == null) { resultName = ExprNodeUtility.ToExpressionStringMinPrecedenceSafe(exprCompiled); } cumulativeSelectClause.Add( new SelectClauseExprCompiledSpec( exprCompiled, resultName, exprSpec.OptionalAsName, exprSpec.IsEvents)); var isMinimal = ExprNodeUtility.IsMinimalExpression(exprCompiled); if (isMinimal != null) { throw new ExprValidationException( "Expression in a property-selection may not utilize " + isMinimal); } } else if (raw is SelectClauseElementWildcard) { // wildcards are stream selects: we assign a stream name (any) and add a stream wildcard select var streamNameAtom = atom.OptionalAsName; if (streamNameAtom == null) { streamNameAtom = UuidGenerator.Generate(); } var streamSpec = new SelectClauseStreamCompiledSpec(streamNameAtom, atom.OptionalAsName); var streamNumber = i + 1; streamSpec.StreamNumber = streamNumber; cumulativeSelectClause.Add(streamSpec); } else { throw new IllegalStateException("Unknown select clause item:" + raw); } } } currentEventType = fragmentEventType.FragmentType; fragmentEventTypes[i] = fragmentEventType; containedEventEvals[i] = containedEventEval; } if (cumulativeSelectClause.IsEmpty()) { if (length == 1) { return(new PropertyEvaluatorSimple( containedEventEvals[0], fragmentEventTypes[0], whereClauses[0], expressionTexts[0])); } else { return(new PropertyEvaluatorNested(containedEventEvals, fragmentEventTypes, whereClauses, expressionTexts)); } } else { var accumulative = new PropertyEvaluatorAccumulative( containedEventEvals, fragmentEventTypes, whereClauses, expressionTexts); var whereTypes = streamEventTypes.ToArray(); var whereStreamNames = streamNames.ToArray(); var isIStreamOnly = new bool[streamNames.Count]; isIStreamOnly.Fill(true); StreamTypeService streamTypeService = new StreamTypeServiceImpl( whereTypes, whereStreamNames, isIStreamOnly, engineURI, false); var cumulativeSelectArr = cumulativeSelectClause.ToArray(); var selectExpr = SelectExprProcessorFactory.GetProcessor( assignedTypeNumberStack, cumulativeSelectArr, false, null, null, null, streamTypeService, eventAdapterService, null, null, null, engineImportService, validateContext, variableService, scriptingService, tableService, timeProvider, engineURI, statementId, statementName, annotations, null, configuration, null, namedWindowMgmtService, null, null, statementExtensionSvcContext); return(new PropertyEvaluatorSelect(selectExpr, accumulative)); } }
public FileBeginEndProcessorGeneralPurpose(EventBeanManufacturer manufacturer) { _manufacturer = manufacturer; }
public LineProcessorGeneralPurpose(EventBeanManufacturer manufacturer) { _manufacturer = manufacturer; }
public void Next() { if (iterationNumber == 0 && initialDelayMSec > 0) { try { Thread.Sleep((int) initialDelayMSec); } catch (ThreadInterruptedException) { graphContext.SubmitSignal(new EPDataFlowSignalFinalMarkerImpl()); } } if (iterationNumber > 0 && periodDelayMSec > 0) { var nsecDelta = lastSendTime - PerformanceObserver.NanoTime; var sleepTime = periodDelayMSec - nsecDelta / 1000000; if (sleepTime > 0) { try { Thread.Sleep((int) sleepTime); } catch (ThreadInterruptedException) { graphContext.SubmitSignal(new EPDataFlowSignalFinalMarkerImpl()); } } } if (iterations > 0 && iterationNumber >= iterations) { graphContext.SubmitSignal(new EPDataFlowSignalFinalMarkerImpl()); } else { iterationNumber++; ExprEvaluator[] evaluators = factory.PropertyEvaluators; if (evaluators != null) { var row = new object[evaluators.Length]; for (var i = 0; i < row.Length; i++) { if (evaluators[i] != null) { row[i] = evaluators[i].Evaluate(null, true, null); } } if (log.IsDebugEnabled) { log.Debug("BeaconSource submitting row " + row.RenderAny()); } EventBeanManufacturer manufacturer = factory.Manufacturer; if (manufacturer == null) { SubmitAndDone(row); return; } if (!factory.IsProduceEventBean && additionalProperties == null) { var outputEvent = manufacturer.MakeUnderlying(row); SubmitAndDone(outputEvent); return; } var @event = manufacturer.Make(row); if (additionalProperties != null) { foreach (var pair in additionalProperties) { pair.First.Write(pair.Second, @event); } } if (!factory.IsProduceEventBean) { SubmitAndDone(@event.Underlying); return; } SubmitAndDone(@event); } else { if (log.IsDebugEnabled) { log.Debug("BeaconSource submitting empty row"); } SubmitAndDone(new object[0]); } } }