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 DataFlowOpForgeInitializeResult InitializeForge(DataFlowOpForgeInitializeContext 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 ExprValidationException(
"Both 'statementName' or 'statementFilter' parameters were provided, only either one is expected");
}
if ((statementDeploymentId == null && statementName != null) |
(statementDeploymentId != null && statementName == null)) {
throw new ExprValidationException(
"Both 'statementDeploymentId' and 'statementName' are required when either of these are specified");
}
DataFlowOpOutputPort portZero = context.OutputPorts[0];
if (portZero != null && portZero.OptionalDeclaredType != null && portZero.OptionalDeclaredType.IsWildcard) {
submitEventBean = true;
}
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)
{
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 context)
{
Port = context.OutputPorts[0];
return(null);
}
private DataFlowOpForgeInitializeResult InitializeTypeDeclared(
DataFlowOpOutputPort port,
DataFlowOpForgeInitializeContext context)
{
produceEventBean = port.OptionalDeclaredType != null && !port.OptionalDeclaredType.IsUnderlying;
// compile properties to populate
outputEventType = port.OptionalDeclaredType.EventType;
var props = allProperties.Keys;
props.RemoveAll(PARAMETER_PROPERTIES);
var writables = SetupProperties(props.ToArray(), outputEventType);
try {
eventBeanManufacturer = EventTypeUtility.GetManufacturer(
outputEventType,
writables,
context.Services.ImportServiceCompileTime,
false,
context.Services.EventTypeAvroHandler);
}
catch (EventBeanManufactureException e) {
throw new ExprValidationException(
"Cannot manufacture event for the provided type '" + outputEventType.Name + "': " + e.Message,
e);
}
var index = 0;
evaluatorForges = new ExprForge[writables.Length];
var typeWidenerCustomizer =
context.Services.EventTypeAvroHandler.GetTypeWidenerCustomizer(outputEventType);
foreach (var writable in writables) {
object providedProperty = allProperties.Get(writable.PropertyName);
var exprNode = (ExprNode) providedProperty;
var validated = EPLValidationUtil.ValidateSimpleGetSubtree(
ExprNodeOrigin.DATAFLOWBEACON,
exprNode,
null,
false,
context.Base.StatementRawInfo,
context.Services);
TypeWidenerSPI widener;
try {
widener = TypeWidenerFactory.GetCheckPropertyAssignType(
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(validated),
validated.Forge.EvaluationType,
writable.PropertyType,
writable.PropertyName,
false,
typeWidenerCustomizer,
context.Base.StatementName);
}
catch (TypeWidenerException e) {
throw new ExprValidationException("Failed for property '" + writable.PropertyName + "'", e);
}
if (widener != null) {
evaluatorForges[index] = new ExprEvalWithTypeWidener(widener, validated, writable.PropertyType);
}
else {
evaluatorForges[index] = validated.Forge;
}
index++;
}
return null;
}
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
DataFlowOpOutputPort port = context.OutputPorts[0];
if (port.OptionalDeclaredType != null && port.OptionalDeclaredType.EventType != null)
{
EventType outputEventType = port.OptionalDeclaredType.EventType;
_produceEventBean = port.OptionalDeclaredType != null && !port.OptionalDeclaredType.IsUnderlying;
// compile properties to populate
ISet <String> props = new HashSet <string>(_allProperties.Keys);
props.RemoveAll(PARAMETER_PROPERTIES);
WriteablePropertyDescriptor[] writables = SetupProperties(props.ToArray(), outputEventType, context.StatementContext);
_manufacturer = context.ServicesContext.EventAdapterService.GetManufacturer(outputEventType, writables, context.ServicesContext.EngineImportService, false);
int index = 0;
_evaluators = new ExprEvaluator[writables.Length];
foreach (WriteablePropertyDescriptor 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);
if (widener != null)
{
_evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams => widener.Invoke(exprEvaluator.Evaluate(evaluateParams)),
ReturnType = null
};
}
else
{
_evaluators[index] = exprEvaluator;
}
}
else if (providedProperty == null)
{
_evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams => null,
ReturnType = null
};
}
else
{
_evaluators[index] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams => providedProperty,
ReturnType = providedProperty.GetType()
};
}
index++;
}
return(null); // no changing types
}
// No type has been declared, we can create one
String anonymousTypeName = context.DataflowName + "-beacon";
var types = new LinkedHashMap <String, Object>();
ICollection <String> kprops = _allProperties.Keys;
kprops.RemoveAll(PARAMETER_PROPERTIES);
int count = 0;
_evaluators = new ExprEvaluator[kprops.Count];
foreach (String propertyName in kprops)
{
var exprNode = (ExprNode)_allProperties.Get(propertyName);
var validated = ExprNodeUtility.ValidateSimpleGetSubtree(ExprNodeOrigin.DATAFLOWBEACON, exprNode, context.StatementContext, null, false);
var value = validated.ExprEvaluator.Evaluate(new EvaluateParams(null, true, context.AgentInstanceContext));
if (value == null)
{
types.Put(propertyName, null);
}
else
{
types.Put(propertyName, value.GetType());
}
_evaluators[count] = new ProxyExprEvaluator
{
ProcEvaluate = evaluateParams => value,
ReturnType = null
};
count++;
}
EventType type = context.ServicesContext.EventAdapterService.CreateAnonymousObjectArrayType(anonymousTypeName, types);
return(new DataFlowOpInitializeResult(new GraphTypeDesc[] { new GraphTypeDesc(false, true, type) }));
}
