#pragma warning disable RCS1168
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext context)
#pragma warning restore RCS1168
{
if (!context.OutputPorts.IsEmpty())
{
throw new ArgumentException("EventBusSink operator does not provide an output stream");
}
var eventTypes = new EventType[context.InputPorts.Count];
for (int i = 0; i < eventTypes.Length; i++)
{
eventTypes[i] = context.InputPorts.Get(i).TypeDesc.EventType;
}
_runtimeEventSender = context.RuntimeEventSender;
_eventAdapterService = context.StatementContext.EventAdapterService;
if (collector != null)
{
_eventBusCollector = new EventBusCollectorImpl(
_eventAdapterService,
_runtimeEventSender);
}
else
{
_adapterFactories = new EventBeanAdapterFactory[eventTypes.Length];
for (int i = 0; i < eventTypes.Length; i++)
{
_adapterFactories[i] = context.ServicesContext.EventAdapterService.GetAdapterFactoryForType(eventTypes[i]);
}
}
return(null);
}
/// <summary>
/// Initializes the specified prepare context.
/// </summary>
/// <param name="prepareContext">The prepare context.</param>
/// <returns></returns>
/// <exception cref="ExprValidationException">
/// Filter requires single input port
/// or
/// Required parameter 'filter' providing the filter expression is not provided
/// </exception>
/// <exception cref="ArgumentException">Filter operator requires one or two output Stream(s) but produces " + prepareContext.OutputPorts.Count + " streams</exception>
#pragma warning disable RCS1168
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext prepareContext)
#pragma warning restore RCS1168
{
if (prepareContext.InputPorts.Count != 1)
{
throw new ExprValidationException("Filter requires single input port");
}
if (filter == null)
{
throw new ExprValidationException("Required parameter 'filter' providing the filter expression is not provided");
}
if (prepareContext.OutputPorts.IsEmpty() || prepareContext.OutputPorts.Count > 2)
{
throw new ArgumentException("Filter operator requires one or two output Stream(s) but produces " + prepareContext.OutputPorts.Count + " streams");
}
EventType eventType = prepareContext.InputPorts[0].TypeDesc.EventType;
_singleOutputPort = prepareContext.OutputPorts.Count == 1;
ExprNode validated = ExprNodeUtility.ValidateSimpleGetSubtree(ExprNodeOrigin.DATAFLOWFILTER, filter, prepareContext.StatementContext, eventType, false);
_evaluator = validated.ExprEvaluator;
_theEvent = prepareContext.ServicesContext.EventAdapterService.GetShellForType(eventType);
_eventsPerStream[0] = _theEvent;
var typesPerPort = new GraphTypeDesc[prepareContext.OutputPorts.Count];
for (int i = 0; i < typesPerPort.Length; i++)
{
typesPerPort[i] = new GraphTypeDesc(false, true, eventType);
}
return(new DataFlowOpInitializeResult(typesPerPort));
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext context)
{
if (context.OutputPorts.Count != 1)
{
throw new ArgumentException("EPStatementSource operator requires one output stream but produces " + context.OutputPorts.Count + " streams");
}
if (_statementName == null && _statementFilter == null)
{
throw new EPException("Failed to find required 'StatementName' or 'statementFilter' parameter");
}
if (_statementName != null && _statementFilter != null)
{
throw new EPException("Both 'StatementName' or 'statementFilter' parameters were provided, only either one is expected");
}
DataFlowOpOutputPort portZero = context.OutputPorts[0];
if (portZero != null && portZero.OptionalDeclaredType != null && portZero.OptionalDeclaredType.IsWildcard)
{
_submitEventBean = true;
}
_statementLifecycleSvc = context.ServicesContext.StatementLifecycleSvc;
return(null);
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext initContext)
{
var httpContext = initContext.ServicesContext.EventAdapterService.GetEventTypeByName("HttpContext");
if (initContext.OutputPorts.Count == 1)
{
Host = initContext.OutputPorts[0].StreamName;
}
return new DataFlowOpInitializeResult(new[] { new com.espertech.esper.dataflow.util.GraphTypeDesc(false, false, httpContext) });
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext initContext)
{
var httpContext = initContext.ServicesContext.EventAdapterService.GetEventTypeByName("HttpContext");
if (initContext.OutputPorts.Count == 1)
{
Host = initContext.OutputPorts[0].StreamName;
}
return(new DataFlowOpInitializeResult(new[] { new com.espertech.esper.dataflow.util.GraphTypeDesc(false, false, httpContext) }));
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext initContext)
{
if (initContext.InputPorts.Count == 1 && initContext.InputPorts[0].StreamNames.Count == 1)
{
Service = initContext.InputPorts[0].StreamNames.First();
}
var dataflowContext = initContext.DataflowInstanceUserObject as DataflowContext;
FinderFactory = dataflowContext.Resolve<Func<IServiceFinder>>();
return null;
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext initContext)
{
if (initContext.InputPorts.Count == 1 && initContext.InputPorts[0].StreamNames.Count == 1)
{
Service = initContext.InputPorts[0].StreamNames.First();
}
var dataflowContext = initContext.DataflowInstanceUserObject as DataflowContext;
FinderFactory = dataflowContext.Resolve <Func <IServiceFinder> >();
return(null);
}
private void RunAssertionFlowGraphSource(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
epService.EPAdministrator.Configuration.AddImport(typeof(SupportGraphSource));
SupportGraphSource.GetAndResetLifecycle();
epService.EPAdministrator.CreateEPL("create dataflow MyDataFlow @Name('Goodie') @Audit SupportGraphSource -> outstream<SupportBean> {propOne:'abc'}");
Assert.AreEqual(0, SupportGraphSource.GetAndResetLifecycle().Count);
// instantiate
var options = new EPDataFlowInstantiationOptions().DataFlowInstanceId("id1").DataFlowInstanceUserObject("myobject");
EPDataFlowInstance df = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlow", options);
List <object> events = SupportGraphSource.GetAndResetLifecycle();
Assert.AreEqual(3, events.Count);
Assert.AreEqual("instantiated", events[0]); // instantiated
Assert.AreEqual("setPropOne=abc", events[1]); // injected properties
Assert.IsTrue(events[2] is DataFlowOpInitializateContext); // called initialize
DataFlowOpInitializateContext initContext = (DataFlowOpInitializateContext)events[2];
Assert.IsNotNull(initContext.AgentInstanceContext);
Assert.IsNotNull(initContext.RuntimeEventSender);
Assert.IsNotNull(initContext.ServicesContext);
Assert.IsNotNull(initContext.StatementContext);
Assert.AreEqual("id1", initContext.DataflowInstanceId);
Assert.AreEqual("myobject", initContext.DataflowInstanceUserObject);
Assert.AreEqual(0, initContext.InputPorts.Count);
Assert.AreEqual(1, initContext.OutputPorts.Count);
Assert.AreEqual("outstream", initContext.OutputPorts[0].StreamName);
Assert.AreEqual("SupportBean", initContext.OutputPorts[0].OptionalDeclaredType.EventType.Name);
Assert.AreEqual(2, initContext.OperatorAnnotations.Length);
Assert.AreEqual("Goodie", ((NameAttribute)initContext.OperatorAnnotations[0]).Value);
Assert.IsNotNull((AuditAttribute)initContext.OperatorAnnotations[1]);
// run
df.Run();
events = SupportGraphSource.GetAndResetLifecycle();
Assert.AreEqual(5, events.Count);
Assert.IsTrue(events[0] is DataFlowOpOpenContext); // called open (GraphSource only)
Assert.AreEqual("Next(numrows=0)", events[1]);
Assert.AreEqual("Next(numrows=1)", events[2]);
Assert.AreEqual("Next(numrows=2)", events[3]);
Assert.IsTrue(events[4] is DataFlowOpCloseContext); // called close (GraphSource only)
epService.EPAdministrator.DestroyAllStatements();
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext initContext)
{
var dataflowContext = initContext.DataflowInstanceUserObject as DataflowContext;
var log = dataflowContext.Resolve <ILogger>();
var port = ChoosePort(Port, new[] { 80, 8080 });
if (port.HasValue == false)
{
log.Error("Unable to bind to port {Port}", Port);
}
var tcpListener = new TcpListener(IPAddress.Any, port.Value);
tcpListener.Start(100);
log.Information("Port open {Endpoint}", tcpListener.LocalEndpoint.ToString());
Task.Factory.StartNew(async() =>
{
while (true)
{
var tcpClient = await tcpListener.AcceptTcpClientAsync();
var stream = tcpClient.GetStream();
var context = new HttpContext()
{
Connection = tcpClient,
Request = new HttpRequest(stream),
Response = new HttpResponse(stream)
};
await context.Request.ReadHeadersAsync();
log = log.ForContext(new[] {
new CorrelationEnricher(context.Correlation.ToString())
});
context.Properties.Add("Log", log);
log.Information("Request Accepted {Correlation}", context.Correlation);
log.Verbose("{@Block} {@Request}", this, context.Request);
Emitter.Submit(context);
}
});
var httpContext = initContext.ServicesContext.EventAdapterService.GetEventTypeByName("HttpContext");
return(new DataFlowOpInitializeResult(new[] { new com.espertech.esper.dataflow.util.GraphTypeDesc(false, false, httpContext) }));
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext initContext)
{
var dataflowContext = initContext.DataflowInstanceUserObject as DataflowContext;
var log = dataflowContext.Resolve<ILogger>();
var port = ChoosePort(Port, new[] { 80, 8080 });
if(port.HasValue == false)
{
log.Error("Unable to bind to port {Port}", Port);
}
var tcpListener = new TcpListener(IPAddress.Any, port.Value);
tcpListener.Start(100);
log.Information("Port open {Endpoint}", tcpListener.LocalEndpoint.ToString());
Task.Factory.StartNew(async () =>
{
while (true)
{
var tcpClient = await tcpListener.AcceptTcpClientAsync();
var stream = tcpClient.GetStream();
var context = new HttpContext()
{
Connection = tcpClient,
Request = new HttpRequest(stream),
Response = new HttpResponse(stream)
};
await context.Request.ReadHeadersAsync();
log = log.ForContext(new[] {
new CorrelationEnricher(context.Correlation.ToString())
});
context.Properties.Add("Log", log);
log.Information("Request Accepted {Correlation}", context.Correlation);
log.Verbose("{@Block} {@Request}", this, context.Request);
Emitter.Submit(context);
}
});
var httpContext = initContext.ServicesContext.EventAdapterService.GetEventTypeByName("HttpContext");
return new DataFlowOpInitializeResult(new[] { new com.espertech.esper.dataflow.util.GraphTypeDesc(false, false, httpContext) });
}
private void RunAssertionFlowGraphOperator(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
epService.EPAdministrator.Configuration.AddImport(typeof(MyLineFeedSource));
epService.EPAdministrator.Configuration.AddImport(typeof(SupportOperator));
SupportGraphSource.GetAndResetLifecycle();
epService.EPAdministrator.CreateEPL("create dataflow MyDataFlow MyLineFeedSource -> outstream {} SupportOperator(outstream) {propOne:'abc'}");
Assert.AreEqual(0, SupportOperator.GetAndResetLifecycle().Count);
// instantiate
var src = new MyLineFeedSource(Collections.List("abc", "def").GetEnumerator());
var options = new EPDataFlowInstantiationOptions().OperatorProvider(new DefaultSupportGraphOpProvider(src));
EPDataFlowInstance df = epService.EPRuntime.DataFlowRuntime.Instantiate("MyDataFlow", options);
IList <object> events = SupportOperator.GetAndResetLifecycle();
Assert.AreEqual(3, events.Count);
Assert.AreEqual("instantiated", events[0]); // instantiated
Assert.AreEqual("setPropOne=abc", events[1]); // injected properties
Assert.IsTrue(events[2] is DataFlowOpInitializateContext); // called initialize
DataFlowOpInitializateContext initContext = (DataFlowOpInitializateContext)events[2];
Assert.IsNotNull(initContext.AgentInstanceContext);
Assert.IsNotNull(initContext.RuntimeEventSender);
Assert.IsNotNull(initContext.ServicesContext);
Assert.IsNotNull(initContext.StatementContext);
Assert.IsNull(initContext.DataflowInstanceId);
Assert.IsNull(initContext.DataflowInstanceUserObject);
Assert.AreEqual(1, initContext.InputPorts.Count);
Assert.AreEqual("[line]", CompatExtensions.Render(initContext.InputPorts[0].TypeDesc.EventType.PropertyNames));
Assert.AreEqual("[outstream]", CompatExtensions.Render(initContext.InputPorts[0].StreamNames.ToArray()));
Assert.AreEqual(0, initContext.OutputPorts.Count);
// run
df.Run();
events = SupportOperator.GetAndResetLifecycle();
Assert.AreEqual(4, events.Count);
Assert.IsTrue(events[0] is DataFlowOpOpenContext); // called open (GraphSource only)
Assert.AreEqual("abc", ((object[])events[1])[0]);
Assert.AreEqual("def", ((object[])events[2])[0]);
Assert.IsTrue(events[3] is DataFlowOpCloseContext); // called close (GraphSource only)
epService.EPAdministrator.DestroyAllStatements();
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext context)
{
if (!context.OutputPorts.IsEmpty())
{
throw new ArgumentException("LogSink operator does not provide an output stream");
}
_dataflowName = context.DataflowName;
_dataFlowInstanceId = context.DataflowInstanceId;
_shellPerStream = new EventBeanSPI[context.InputPorts.Count];
foreach (KeyValuePair <int, DataFlowOpInputPort> entry in context.InputPorts)
{
EventType eventType = entry.Value.TypeDesc.EventType;
if (eventType != null)
{
_shellPerStream[entry.Key] = context.StatementContext.EventAdapterService.GetShellForType(eventType);
}
}
if (format == null)
{
_renderer = new ConsoleOpRendererSummary();
}
else
{
try
{
var formatEnum = EnumHelper.Parse <LogSinkOutputFormat>(format.Trim());
if (formatEnum == LogSinkOutputFormat.summary)
{
_renderer = new ConsoleOpRendererSummary();
}
else
{
_renderer = new ConsoleOpRendererXmlJSon(formatEnum, context.Engine.EPRuntime);
}
}
catch (Exception ex)
{
throw new ExprValidationException("Format '" + format + "' is not supported, expecting any of " + EnumHelper.GetValues <LogSinkOutputFormat>().Render());
}
}
return(null);
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext context)
{
if (context.OutputPorts.Count != 1)
{
throw new ArgumentException("EventBusSource operator requires one output stream but produces " + context.OutputPorts.Count + " streams");
}
DataFlowOpOutputPort portZero = context.OutputPorts[0];
if (portZero.OptionalDeclaredType == null || portZero.OptionalDeclaredType.EventType == null)
{
throw new ArgumentException("EventBusSource operator requires an event type declated for the output stream");
}
if (!portZero.OptionalDeclaredType.IsUnderlying)
{
submitEventBean = true;
}
eventType = portZero.OptionalDeclaredType.EventType;
agentInstanceContext = context.AgentInstanceContext;
return(new DataFlowOpInitializeResult());
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext context)
{
return(null);
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext initContext)
{
var httpContext = initContext.ServicesContext.EventAdapterService.GetEventTypeByName("HttpContext");
return(new DataFlowOpInitializeResult(new[] { new com.espertech.esper.dataflow.util.GraphTypeDesc(false, false, httpContext) }));
}
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)
}));
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext context)
{
if (context.InputPorts.IsEmpty())
{
throw new ArgumentException("Select operator requires at least one input stream");
}
if (context.OutputPorts.Count != 1)
{
throw new ArgumentException("Select operator requires one output stream but produces " + context.OutputPorts.Count + " streams");
}
DataFlowOpOutputPort portZero = context.OutputPorts[0];
if (portZero.OptionalDeclaredType != null && !portZero.OptionalDeclaredType.IsUnderlying)
{
_submitEventBean = true;
}
// determine adapter factories for each type
int numStreams = context.InputPorts.Count;
_adapterFactories = new EventBeanAdapterFactory[numStreams];
for (int i = 0; i < numStreams; i++)
{
EventType eventType = context.InputPorts.Get(i).TypeDesc.EventType;
_adapterFactories[i] = context.StatementContext.EventAdapterService.GetAdapterFactoryForType(eventType);
}
// Compile and prepare execution
//
StatementContext statementContext = context.StatementContext;
EPServicesContext servicesContext = context.ServicesContext;
AgentInstanceContext agentInstanceContext = context.AgentInstanceContext;
// validate
if (select.InsertIntoDesc != null)
{
throw new ExprValidationException("Insert-into clause is not supported");
}
if (select.SelectStreamSelectorEnum != SelectClauseStreamSelectorEnum.ISTREAM_ONLY)
{
throw new ExprValidationException("Selecting remove-stream is not supported");
}
ExprNodeSubselectDeclaredDotVisitor visitor = StatementSpecRawAnalyzer.WalkSubselectAndDeclaredDotExpr(select);
GroupByClauseExpressions groupByExpressions = GroupByExpressionHelper.GetGroupByRollupExpressions(
servicesContext.Container,
select.GroupByExpressions,
select.SelectClauseSpec,
select.HavingExprRootNode,
select.OrderByList,
visitor);
if (!visitor.Subselects.IsEmpty())
{
throw new ExprValidationException("Subselects are not supported");
}
IDictionary <int, FilterStreamSpecRaw> streams = new Dictionary <int, FilterStreamSpecRaw>();
for (int streamNum = 0; streamNum < select.StreamSpecs.Count; streamNum++)
{
var rawStreamSpec = select.StreamSpecs[streamNum];
if (!(rawStreamSpec is FilterStreamSpecRaw))
{
throw new ExprValidationException("From-clause must contain only streams and cannot contain patterns or other constructs");
}
streams.Put(streamNum, (FilterStreamSpecRaw)rawStreamSpec);
}
// compile offered streams
IList <StreamSpecCompiled> streamSpecCompileds = new List <StreamSpecCompiled>();
for (int streamNum = 0; streamNum < select.StreamSpecs.Count; streamNum++)
{
var filter = streams.Get(streamNum);
var inputPort = FindInputPort(filter.RawFilterSpec.EventTypeName, context.InputPorts);
if (inputPort == null)
{
throw new ExprValidationException(
string.Format("Failed to find stream '{0}' among input ports, input ports are {1}", filter.RawFilterSpec.EventTypeName, GetInputPortNames(context.InputPorts).Render(", ", "[]")));
}
var eventType = inputPort.Value.Value.TypeDesc.EventType;
var streamAlias = filter.OptionalStreamName;
var filterSpecCompiled = new FilterSpecCompiled(eventType, streamAlias, new IList <FilterSpecParam>[] { Collections.GetEmptyList <FilterSpecParam>() }, null);
var filterStreamSpecCompiled = new FilterStreamSpecCompiled(filterSpecCompiled, select.StreamSpecs[0].ViewSpecs, streamAlias, StreamSpecOptions.DEFAULT);
streamSpecCompileds.Add(filterStreamSpecCompiled);
}
// create compiled statement spec
SelectClauseSpecCompiled selectClauseCompiled = StatementLifecycleSvcUtil.CompileSelectClause(select.SelectClauseSpec);
// determine if snapshot output is needed
OutputLimitSpec outputLimitSpec = select.OutputLimitSpec;
_isOutputLimited = outputLimitSpec != null;
if (iterate)
{
if (outputLimitSpec != null)
{
throw new ExprValidationException("Output rate limiting is not supported with 'iterate'");
}
outputLimitSpec = new OutputLimitSpec(OutputLimitLimitType.SNAPSHOT, OutputLimitRateType.TERM);
}
var mergedAnnotations = AnnotationUtil.MergeAnnotations(statementContext.Annotations, context.OperatorAnnotations);
var orderByArray = OrderByItem.ToArray(select.OrderByList);
var outerJoinArray = OuterJoinDesc.ToArray(select.OuterJoinDescList);
var streamSpecArray = streamSpecCompileds.ToArray();
var compiled = new StatementSpecCompiled(null, null, null, null, null, null, null, SelectClauseStreamSelectorEnum.ISTREAM_ONLY,
selectClauseCompiled, streamSpecArray, outerJoinArray, select.FilterExprRootNode, select.HavingExprRootNode, outputLimitSpec,
orderByArray, ExprSubselectNode.EMPTY_SUBSELECT_ARRAY, ExprNodeUtility.EMPTY_DECLARED_ARR, ExprNodeUtility.EMPTY_SCRIPTS, select.ReferencedVariables,
select.RowLimitSpec, CollectionUtil.EMPTY_STRING_ARRAY, mergedAnnotations, null, null, null, null, null, null, null, null, null, groupByExpressions, null, null);
// create viewable per port
var viewables = new EPLSelectViewable[context.InputPorts.Count];
_viewablesPerPort = viewables;
foreach (var entry in context.InputPorts)
{
EPLSelectViewable viewable = new EPLSelectViewable(entry.Value.TypeDesc.EventType);
viewables[entry.Key] = viewable;
}
var activatorFactory = new ProxyViewableActivatorFactory
{
ProcCreateActivatorSimple = filterStreamSpec =>
{
EPLSelectViewable found = null;
foreach (EPLSelectViewable sviewable in viewables)
{
if (sviewable.EventType == filterStreamSpec.FilterSpec.FilterForEventType)
{
found = sviewable;
}
}
if (found == null)
{
throw new IllegalStateException("Failed to find viewable for filter");
}
EPLSelectViewable viewable = found;
return(new ProxyViewableActivator(
(agentInstanceContext2, isSubselect, isRecoveringResilient) =>
new ViewableActivationResult(
viewable,
new ProxyStopCallback(() => { }),
null,
null,
null,
false,
false,
null)));
}
};
// for per-row deliver, register select expression result callback
OutputProcessViewCallback optionalOutputProcessViewCallback = null;
if (!iterate && !_isOutputLimited)
{
_deliveryCallback = new EPLSelectDeliveryCallback();
optionalOutputProcessViewCallback = this;
}
// prepare
EPStatementStartMethodSelectDesc selectDesc = EPStatementStartMethodSelectUtil.Prepare(compiled, servicesContext, statementContext, false, agentInstanceContext, false, activatorFactory, optionalOutputProcessViewCallback, _deliveryCallback);
// start
_selectResult = (StatementAgentInstanceFactorySelectResult)selectDesc.StatementAgentInstanceFactorySelect.NewContext(agentInstanceContext, false);
// for output-rate-limited, register a dispatch view
if (_isOutputLimited)
{
_selectResult.FinalView.AddView(new EPLSelectUpdateDispatchView(this));
}
// assign strategies to expression nodes
EPStatementStartMethodHelperAssignExpr.AssignExpressionStrategies(
selectDesc,
_selectResult.OptionalAggegationService,
_selectResult.SubselectStrategies,
_selectResult.PriorNodeStrategies,
_selectResult.PreviousNodeStrategies,
null,
null,
_selectResult.TableAccessEvalStrategies);
EventType outputEventType = selectDesc.ResultSetProcessorPrototypeDesc.ResultSetProcessorFactory.ResultEventType;
_agentInstanceContext = agentInstanceContext;
return(new DataFlowOpInitializeResult(new GraphTypeDesc[] { new GraphTypeDesc(false, true, outputEventType) }));
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext initContext)
{
return null;
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext context)
{
Port = context.OutputPorts[0];
return(null);
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext context)
{
_lifecycle.Add(context);
return(null);
}
public DataFlowOpInitializeResult Initialize(DataFlowOpInitializateContext initContext)
{
var httpContext = initContext.ServicesContext.EventAdapterService.GetEventTypeByName("HttpContext");
return new DataFlowOpInitializeResult(new[] { new com.espertech.esper.dataflow.util.GraphTypeDesc(false, false, httpContext) });
}
