private static AggSvcGroupByReclaimAgedEvalFuncFactoryForge GetEvaluationFunction(
VariableCompileTimeResolver variableCompileTimeResolver,
string hintValue,
string optionalContextName)
{
var variableMetaData = variableCompileTimeResolver.Resolve(hintValue);
if (variableMetaData != null) {
if (!variableMetaData.Type.IsNumeric()) {
throw new ExprValidationException(
"Variable type of variable '" + variableMetaData.VariableName + "' is not numeric");
}
var message = VariableUtil.CheckVariableContextName(optionalContextName, variableMetaData);
if (message != null) {
throw new ExprValidationException(message);
}
return new AggSvcGroupByReclaimAgedEvalFuncFactoryVariableForge(variableMetaData);
}
double valueDouble;
try {
valueDouble = Double.Parse(hintValue);
}
catch (EPException) {
throw;
}
catch (Exception) {
throw new ExprValidationException(
"Failed to parse hint parameter value '" +
hintValue +
"' as a double-typed seconds value or variable name");
}
if (valueDouble <= 0) {
throw new ExprValidationException(
"Hint parameter value '" +
hintValue +
"' is an invalid value, expecting a double-typed seconds value or variable name");
}
return new AggSvcGroupByReclaimAgedEvalFuncFactoryConstForge(valueDouble);
}
public static ExprNode ResolvePropertyOrVariableIdentifier(
string identifier,
VariableCompileTimeResolver variableCompileTimeResolver,
StatementSpecRaw spec)
{
VariableMetaData metaData = variableCompileTimeResolver.Resolve(identifier);
if (metaData != null)
{
ExprVariableNodeImpl exprNode = new ExprVariableNodeImpl(metaData, null);
spec.ReferencedVariables.Add(metaData.VariableName);
string message = VariableUtil.CheckVariableContextName(spec.OptionalContextName, metaData);
if (message != null)
{
throw ASTWalkException.From(message);
}
return exprNode;
}
return new ExprIdentNodeImpl(identifier);
}
public static OutputConditionFactoryForge CreateCondition(
OutputLimitSpec outputLimitSpec,
bool isGrouped,
bool isWithHavingClause,
bool isStartConditionOnCreation,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
if (outputLimitSpec == null) {
return OutputConditionNullFactoryForge.INSTANCE;
}
// Check if a variable is present
VariableMetaData variableMetaData = null;
if (outputLimitSpec.VariableName != null) {
variableMetaData = services.VariableCompileTimeResolver.Resolve(outputLimitSpec.VariableName);
if (variableMetaData == null) {
throw new ExprValidationException(
"Variable named '" + outputLimitSpec.VariableName + "' has not been declared");
}
var message = VariableUtil.CheckVariableContextName(statementRawInfo.ContextName, variableMetaData);
if (message != null) {
throw new ExprValidationException(message);
}
}
if (outputLimitSpec.DisplayLimit == OutputLimitLimitType.FIRST && isGrouped) {
return OutputConditionNullFactoryForge.INSTANCE;
}
if (outputLimitSpec.RateType == OutputLimitRateType.CRONTAB) {
return new OutputConditionCrontabForge(
outputLimitSpec.CrontabAtSchedule,
isStartConditionOnCreation,
statementRawInfo,
services);
}
if (outputLimitSpec.RateType == OutputLimitRateType.WHEN_EXPRESSION) {
return new OutputConditionExpressionForge(
outputLimitSpec.WhenExpressionNode,
outputLimitSpec.ThenExpressions,
outputLimitSpec.AndAfterTerminateExpr,
outputLimitSpec.AndAfterTerminateThenExpressions,
isStartConditionOnCreation,
statementRawInfo,
services);
}
if (outputLimitSpec.RateType == OutputLimitRateType.EVENTS) {
if (variableMetaData != null && !variableMetaData.Type.IsNumericNonFP()) {
throw new ArgumentException(
"Variable named '" + outputLimitSpec.VariableName + "' must be type integer, long or short");
}
var rate = -1;
if (outputLimitSpec.Rate != null) {
rate = outputLimitSpec.Rate.AsInt32();
}
return new OutputConditionCountForge(rate, variableMetaData);
}
if (outputLimitSpec.RateType == OutputLimitRateType.TERM) {
if (outputLimitSpec.AndAfterTerminateExpr == null &&
(outputLimitSpec.AndAfterTerminateThenExpressions == null ||
outputLimitSpec.AndAfterTerminateThenExpressions.IsEmpty())) {
return new OutputConditionTermFactoryForge();
}
return new OutputConditionExpressionForge(
new ExprConstantNodeImpl(false),
Collections.GetEmptyList<OnTriggerSetAssignment>(),
outputLimitSpec.AndAfterTerminateExpr,
outputLimitSpec.AndAfterTerminateThenExpressions,
isStartConditionOnCreation,
statementRawInfo,
services);
}
if (Log.IsDebugEnabled) {
Log.Debug(".createCondition creating OutputConditionTime with interval length " + outputLimitSpec.Rate);
}
if (variableMetaData != null && !variableMetaData.Type.IsNumeric()) {
throw new ArgumentException(
"Variable named '" + outputLimitSpec.VariableName + "' must be of numeric type");
}
return new OutputConditionTimeForge(outputLimitSpec.TimePeriodExpr, isStartConditionOnCreation);
}
public EPServicesContext CreateServicesContext(
EPRuntimeSPI epRuntime,
Configuration configs)
{
var container = epRuntime.Container;
var runtimeEnvContext = new RuntimeEnvContext();
var eventProcessingRWLock = epRuntime.Container.RWLockManager().CreateLock("EventProcLock");
var deploymentLifecycleService = new DeploymentLifecycleServiceImpl(-1);
var runtimeSettingsService = MakeRuntimeSettingsService(configs);
var scriptCompiler = new ScriptCompilerImpl(container, configs.Common);
var timeAbacus = TimeAbacusFactory.Make(configs.Common.TimeSource.TimeUnit);
var timeZone = configs.Runtime.Expression.TimeZone ?? TimeZoneInfo.Utc;
var importServiceRuntime = new ImportServiceRuntime(
container,
configs.Common.TransientConfiguration, timeAbacus,
configs.Common.EventTypeAutoNameNamespaces, timeZone,
configs.Common.MethodInvocationReferences,
configs.Common.Imports,
configs.Common.AnnotationImports);
var epServicesHA = InitHA(epRuntime.URI, configs, runtimeEnvContext, eventProcessingRWLock, runtimeSettingsService);
var eventTypeAvroHandler = MakeEventTypeAvroHandler(
importServiceRuntime, configs.Common.EventMeta.AvroSettings, epServicesHA.RuntimeExtensionServices);
var resolvedBeanEventTypes = BeanEventTypeRepoUtil.ResolveBeanEventTypes(configs.Common.EventTypeNames, importServiceRuntime);
var eventBeanTypedEventFactory = MakeEventBeanTypedEventFactory(eventTypeAvroHandler);
var beanEventTypeStemService =
BeanEventTypeRepoUtil.MakeBeanEventTypeStemService(configs, resolvedBeanEventTypes, eventBeanTypedEventFactory);
var eventTypeRepositoryPreconfigured = new EventTypeRepositoryImpl(false);
var eventTypeFactory = MakeEventTypeFactory(
epServicesHA.RuntimeExtensionServices, eventTypeRepositoryPreconfigured, deploymentLifecycleService, eventBeanTypedEventFactory);
var beanEventTypeFactoryPrivate = new BeanEventTypeFactoryPrivate(eventBeanTypedEventFactory, eventTypeFactory, beanEventTypeStemService);
EventTypeRepositoryBeanTypeUtil.BuildBeanTypes(
beanEventTypeStemService,
eventTypeRepositoryPreconfigured,
resolvedBeanEventTypes,
beanEventTypeFactoryPrivate,
configs.Common.EventTypesBean);
EventTypeRepositoryMapTypeUtil.BuildMapTypes(
eventTypeRepositoryPreconfigured,
configs.Common.MapTypeConfigurations,
configs.Common.EventTypesMapEvents,
configs.Common.EventTypesNestableMapEvents,
beanEventTypeFactoryPrivate,
importServiceRuntime);
EventTypeRepositoryOATypeUtil.BuildOATypes(
eventTypeRepositoryPreconfigured,
configs.Common.ObjectArrayTypeConfigurations,
configs.Common.EventTypesNestableObjectArrayEvents,
beanEventTypeFactoryPrivate,
importServiceRuntime);
var xmlFragmentEventTypeFactory = new XMLFragmentEventTypeFactory(beanEventTypeFactoryPrivate, null, eventTypeRepositoryPreconfigured);
EventTypeRepositoryXMLTypeUtil.BuildXMLTypes(
eventTypeRepositoryPreconfigured,
configs.Common.EventTypesXMLDOM,
beanEventTypeFactoryPrivate,
xmlFragmentEventTypeFactory,
container.ResourceManager());
//importServiceRuntime
EventTypeRepositoryAvroTypeUtil.BuildAvroTypes(
eventTypeRepositoryPreconfigured, configs.Common.EventTypesAvro, eventTypeAvroHandler,
beanEventTypeFactoryPrivate.EventBeanTypedEventFactory);
EventTypeRepositoryVariantStreamUtil.BuildVariantStreams(
eventTypeRepositoryPreconfigured, configs.Common.VariantStreams, eventTypeFactory);
var eventTypeResolvingBeanFactory = MakeEventTypeResolvingBeanFactory(eventTypeRepositoryPreconfigured, eventTypeAvroHandler);
var viewableActivatorFactory = InitViewableActivatorFactory();
var statementLifecycleService = new StatementLifecycleServiceImpl();
EventTypeIdResolver eventTypeIdResolver = new ProxyEventTypeIdResolver {
ProcGetTypeById = (
eventTypeIdPublic,
eventTypeIdProtected) => {
if (eventTypeIdProtected == -1) {
return eventTypeRepositoryPreconfigured.GetTypeById(eventTypeIdPublic);
}
var deployerResult = deploymentLifecycleService.GetDeploymentByCRC(eventTypeIdPublic);
return deployerResult.DeploymentTypes.Get(eventTypeIdProtected);
}
};
var filterSharedBoolExprRepository = MakeFilterSharedBoolExprRepository();
var filterSharedLookupableRepository = MakeFilterSharedLookupableRepository();
var filterServiceSPI = MakeFilterService(
epServicesHA.RuntimeExtensionServices, eventTypeRepositoryPreconfigured, statementLifecycleService, runtimeSettingsService,
eventTypeIdResolver, filterSharedLookupableRepository);
var filterBooleanExpressionFactory = MakeFilterBooleanExpressionFactory(statementLifecycleService);
var statementResourceHolderBuilder = MakeStatementResourceHolderBuilder();
var aggregationServiceFactoryService = MakeAggregationServiceFactoryService(epServicesHA.RuntimeExtensionServices);
var viewFactoryService = MakeViewFactoryService();
var patternFactoryService = MakePatternFactoryService();
var exceptionHandlingService = InitExceptionHandling(
epRuntime.URI, configs.Runtime.ExceptionHandling, configs.Runtime.ConditionHandling, ClassForNameProviderDefault.INSTANCE);
var timeSourceService = MakeTimeSource(configs);
var schedulingService = MakeSchedulingService(
epServicesHA,
timeSourceService,
epServicesHA.RuntimeExtensionServices,
runtimeSettingsService,
statementLifecycleService,
importServiceRuntime.TimeZone.Id);
var internalEventRouter = new InternalEventRouterImpl(eventBeanTypedEventFactory);
var multiMatchHandlerFactory = MakeMultiMatchHandlerFactory(configs);
var dispatchService = new DispatchService();
var contextServiceFactory = MakeContextServiceFactory(epServicesHA.RuntimeExtensionServices);
ContextManagementService contextManagementService = new ContextManagementServiceImpl();
var viewServicePreviousFactory = MakeViewServicePreviousFactory(epServicesHA.RuntimeExtensionServices);
var epStatementFactory = MakeEPStatementFactory();
var msecTimerResolution = configs.Runtime.Threading.InternalTimerMsecResolution;
if (msecTimerResolution <= 0) {
throw new ConfigurationException("Timer resolution configuration not set to a valid value, expecting a non-zero value");
}
TimerService timerService = new TimerServiceImpl(epRuntime.URI, msecTimerResolution);
StatementAgentInstanceLockFactory statementAgentInstanceLockFactory = new StatementAgentInstanceLockFactoryImpl(
configs.Runtime.Execution.IsFairlock, configs.Runtime.Execution.IsDisableLocking);
var eventTableIndexService = MakeEventTableIndexService(epServicesHA.RuntimeExtensionServices);
var expressionResultCacheSharable = new ExpressionResultCacheService(
configs.Runtime.Execution.DeclaredExprValueCacheSize,
epRuntime.Container.ThreadLocalManager());
var resultSetProcessorHelperFactory = MakeResultSetProcessorHelperFactory(epServicesHA.RuntimeExtensionServices);
var variableRepositoryPreconfigured = new VariableRepositoryPreconfigured();
VariableUtil.ConfigureVariables(
variableRepositoryPreconfigured, configs.Common.Variables, importServiceRuntime, eventBeanTypedEventFactory,
eventTypeRepositoryPreconfigured, beanEventTypeFactoryPrivate);
var variableManagementService = MakeVariableManagementService(
configs, schedulingService, eventBeanTypedEventFactory, runtimeSettingsService, epServicesHA);
foreach (var publicVariable in variableRepositoryPreconfigured.Metadata) {
variableManagementService.AddVariable(null, publicVariable.Value, null, null);
variableManagementService.AllocateVariableState(
null, publicVariable.Key, DEFAULT_AGENT_INSTANCE_ID, false, null, eventBeanTypedEventFactory);
}
var variablePathRegistry = new PathRegistry<string, VariableMetaData>(PathRegistryObjectType.VARIABLE);
var tableExprEvaluatorContext = new TableExprEvaluatorContext(
epRuntime.Container.ThreadLocalManager());
var tableManagementService = MakeTableManagementService(epServicesHA.RuntimeExtensionServices, tableExprEvaluatorContext);
var tablePathRegistry = new PathRegistry<string, TableMetaData>(PathRegistryObjectType.TABLE);
var metricsReporting = new MetricReportingServiceImpl(
configs.Runtime.MetricsReporting, epRuntime.URI, container.RWLockManager());
var namedWindowFactoryService = MakeNamedWindowFactoryService();
var namedWindowDispatchService = MakeNamedWindowDispatchService(
schedulingService, configs, eventProcessingRWLock, exceptionHandlingService, variableManagementService, tableManagementService,
metricsReporting);
NamedWindowManagementService namedWindowManagementService = new NamedWindowManagementServiceImpl();
var namedWindowConsumerManagementService = MakeNamedWindowConsumerManagementService(namedWindowManagementService);
var pathNamedWindowRegistry = new PathRegistry<string, NamedWindowMetaData>(PathRegistryObjectType.NAMEDWINDOW);
var eventTypePathRegistry = new PathRegistry<string, EventType>(PathRegistryObjectType.EVENTTYPE);
var pathContextRegistry = new PathRegistry<string, ContextMetaData>(PathRegistryObjectType.CONTEXT);
EventBeanService eventBeanService = new EventBeanServiceImpl(
eventTypeRepositoryPreconfigured, eventTypePathRegistry, eventBeanTypedEventFactory);
PatternSubexpressionPoolRuntimeSvc patternSubexpressionPoolSvc;
if (configs.Runtime.Patterns.MaxSubexpressions != null) {
patternSubexpressionPoolSvc = new PatternSubexpressionPoolRuntimeSvcImpl(
configs.Runtime.Patterns.MaxSubexpressions.Value,
configs.Runtime.Patterns.IsMaxSubexpressionPreventStart);
}
else {
patternSubexpressionPoolSvc = PatternSubexpressionPoolRuntimeSvcNoOp.INSTANCE;
}
var exprDeclaredPathRegistry = new PathRegistry<string, ExpressionDeclItem>(PathRegistryObjectType.EXPRDECL);
var scriptPathRegistry = new PathRegistry<NameAndParamNum, ExpressionScriptProvided>(PathRegistryObjectType.SCRIPT);
RowRecogStatePoolRuntimeSvc rowRecogStatePoolEngineSvc = null;
if (configs.Runtime.MatchRecognize.MaxStates != null) {
rowRecogStatePoolEngineSvc = new RowRecogStatePoolRuntimeSvc(
configs.Runtime.MatchRecognize.MaxStates.Value,
configs.Runtime.MatchRecognize.IsMaxStatesPreventStart);
}
var rowRecogStateRepoFactory = MakeRowRecogStateRepoFactory();
DatabaseConfigServiceRuntime databaseConfigServiceRuntime =
new DatabaseConfigServiceImpl(
container,
configs.Common.DatabaseReferences,
importServiceRuntime);
var historicalDataCacheFactory = MakeHistoricalDataCacheFactory(epServicesHA.RuntimeExtensionServices);
var dataflowService = new EPDataFlowServiceImpl(container);
var dataFlowFilterServiceAdapter = MakeDataFlowFilterServiceAdapter();
var threadingService = MakeThreadingService(configs);
var eventRenderer = new EPRenderEventServiceImpl();
var eventSerdeFactory = MakeEventSerdeFactory(epServicesHA.RuntimeExtensionServices);
var eventTypeSerdeRepository = MakeEventTypeSerdeRepository(eventTypeRepositoryPreconfigured, eventTypePathRegistry);
var classLoaderParent = new ParentClassLoader(importServiceRuntime.ClassLoader);
var stageRecoveryService = MakeStageRecoveryService(epServicesHA);
var classProvidedPathRegistry = new PathRegistry<string, ClassProvided>(PathRegistryObjectType.CLASSPROVIDED);
return new EPServicesContext(
container,
aggregationServiceFactoryService,
beanEventTypeFactoryPrivate,
beanEventTypeStemService,
ClassForNameProviderDefault.INSTANCE,
classLoaderParent,
classProvidedPathRegistry,
configs,
contextManagementService,
pathContextRegistry,
contextServiceFactory,
dataflowService,
dataFlowFilterServiceAdapter,
databaseConfigServiceRuntime,
deploymentLifecycleService,
dispatchService,
runtimeEnvContext,
runtimeSettingsService,
epRuntime.URI,
importServiceRuntime,
epStatementFactory,
exprDeclaredPathRegistry,
eventProcessingRWLock,
epServicesHA,
epRuntime,
eventBeanService,
eventBeanTypedEventFactory,
eventRenderer,
eventSerdeFactory,
eventTableIndexService,
eventTypeAvroHandler,
eventTypeFactory,
eventTypeIdResolver,
eventTypePathRegistry,
eventTypeRepositoryPreconfigured,
eventTypeResolvingBeanFactory,
eventTypeSerdeRepository,
exceptionHandlingService,
expressionResultCacheSharable,
filterBooleanExpressionFactory,
filterServiceSPI,
filterSharedBoolExprRepository,
filterSharedLookupableRepository,
historicalDataCacheFactory,
internalEventRouter,
metricsReporting,
multiMatchHandlerFactory,
namedWindowConsumerManagementService,
namedWindowDispatchService,
namedWindowFactoryService,
namedWindowManagementService,
pathNamedWindowRegistry,
patternFactoryService,
patternSubexpressionPoolSvc,
resultSetProcessorHelperFactory,
rowRecogStateRepoFactory,
rowRecogStatePoolEngineSvc,
schedulingService,
scriptPathRegistry,
scriptCompiler,
stageRecoveryService,
statementLifecycleService,
statementAgentInstanceLockFactory,
statementResourceHolderBuilder,
tableExprEvaluatorContext,
tableManagementService,
tablePathRegistry,
threadingService,
timeAbacus,
timeSourceService,
timerService,
variableManagementService,
variablePathRegistry,
viewableActivatorFactory,
viewFactoryService,
viewServicePreviousFactory,
xmlFragmentEventTypeFactory);
}
public StmtForgeMethodResult Make(
string @namespace,
string classPostfix,
StatementCompileTimeServices services)
{
var statementSpec = _base.StatementSpec;
var createDesc = statementSpec.Raw.CreateVariableDesc;
// Check if the variable is already declared
EPLValidationUtil.ValidateAlreadyExistsTableOrVariable(
createDesc.VariableName,
services.VariableCompileTimeResolver,
services.TableCompileTimeResolver,
services.EventTypeCompileTimeResolver);
// Get assignment value when compile-time-constant
object initialValue = null;
ExprForge initialValueExpr = null;
if (createDesc.Assignment != null) {
// Evaluate assignment expression
StreamTypeService typeService = new StreamTypeServiceImpl(
new EventType[0],
new string[0],
new bool[0],
false,
false);
var validationContext =
new ExprValidationContextBuilder(typeService, _base.StatementRawInfo, services).Build();
var validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.VARIABLEASSIGN,
createDesc.Assignment,
validationContext);
if (validated.Forge.ForgeConstantType == ExprForgeConstantType.COMPILETIMECONST) {
initialValue = validated.Forge.ExprEvaluator.Evaluate(null, true, null);
}
createDesc.Assignment = validated;
initialValueExpr = validated.Forge;
}
var contextName = statementSpec.Raw.OptionalContextName;
NameAccessModifier? contextVisibility = null;
string contextModuleName = null;
if (contextName != null) {
var contextDetail = services.ContextCompileTimeResolver.GetContextInfo(contextName);
if (contextDetail == null) {
throw new ExprValidationException("Failed to find context '" + contextName + "'");
}
contextVisibility = contextDetail.ContextVisibility;
contextModuleName = contextDetail.ContextModuleName;
}
// get visibility
var visibility = services.ModuleVisibilityRules.GetAccessModifierVariable(_base, createDesc.VariableName);
// Compile metadata
var compileTimeConstant = createDesc.IsConstant &&
initialValueExpr != null &&
initialValueExpr.ForgeConstantType.IsCompileTimeConstant;
var metaData = VariableUtil.CompileVariable(
createDesc.VariableName,
_base.ModuleName,
visibility,
contextName,
contextVisibility,
contextModuleName,
createDesc.VariableType,
createDesc.IsConstant,
compileTimeConstant,
initialValue,
services.ImportServiceCompileTime,
EventBeanTypedEventFactoryCompileTime.INSTANCE,
services.EventTypeRepositoryPreconfigured,
services.BeanEventTypeFactoryPrivate);
// Register variable
services.VariableCompileTimeRegistry.NewVariable(metaData);
// Statement event type
var eventTypePropertyTypes = Collections.SingletonDataMap(
metaData.VariableName,
metaData.Type);
var eventTypeName = services.EventTypeNameGeneratorStatement.AnonymousTypeName;
var eventTypeMetadata = new EventTypeMetadata(
eventTypeName,
_base.ModuleName,
EventTypeTypeClass.STATEMENTOUT,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var outputEventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
eventTypeMetadata,
eventTypePropertyTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(outputEventType);
// Handle output format
var defaultSelectAllSpec = new StatementSpecCompiled();
defaultSelectAllSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard());
defaultSelectAllSpec.Raw.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH;
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
new EventType[] {outputEventType},
new string[] {"trigger_stream"},
new bool[] {true},
false,
false);
var resultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
new ResultSetSpec(defaultSelectAllSpec),
streamTypeService,
null,
new bool[1],
false,
_base.ContextPropertyRegistry,
false,
false,
_base.StatementRawInfo,
services);
// Code generation
var statementFieldsClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ResultSetProcessorFactoryProvider),
classPostfix);
var packageScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
var forge =
new StatementAgentInstanceFactoryCreateVariableForge(
createDesc.VariableName,
initialValueExpr,
classNameRSP);
var aiFactoryForgable = new StmtClassForgableAIFactoryProviderCreateVariable(
aiFactoryProviderClassName,
packageScope,
forge,
createDesc.VariableName);
var informationals = StatementInformationalsUtil.GetInformationals(
_base,
Collections.GetEmptyList<FilterSpecCompiled>(),
Collections.GetEmptyList<ScheduleHandleCallbackProvider>(),
Collections.GetEmptyList<NamedWindowConsumerStreamSpec>(),
true,
resultSetProcessor.SelectSubscriberDescriptor,
packageScope,
services);
var statementProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
var stmtProvider = new StmtClassForgableStmtProvider(
aiFactoryProviderClassName,
statementProviderClassName,
informationals,
packageScope);
IList<StmtClassForgable> forgables = new List<StmtClassForgable>();
forgables.Add(
new StmtClassForgableRSPFactoryProvider(
classNameRSP,
resultSetProcessor,
packageScope,
_base.StatementRawInfo));
forgables.Add(aiFactoryForgable);
forgables.Add(stmtProvider);
forgables.Add(new StmtClassForgableStmtFields(statementFieldsClassName, packageScope, 0));
return new StmtForgeMethodResult(
forgables,
Collections.GetEmptyList<FilterSpecCompiled>(),
Collections.GetEmptyList<ScheduleHandleCallbackProvider>(),
Collections.GetEmptyList<NamedWindowConsumerStreamSpec>(),
Collections.GetEmptyList<FilterSpecParamExprNodeForge>());
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="rowLimitSpec">specification for row limit, or null if no row limit is defined</param>
/// <param name="variableCompileTimeResolver">for retrieving variable state for use with row limiting</param>
/// <param name="optionalContextName">context name</param>
/// <throws>ExprValidationException exception</throws>
public RowLimitProcessorFactoryForge(
RowLimitSpec rowLimitSpec,
VariableCompileTimeResolver variableCompileTimeResolver,
string optionalContextName)
{
if (rowLimitSpec.NumRowsVariable != null) {
numRowsVariableMetaData = variableCompileTimeResolver.Resolve(rowLimitSpec.NumRowsVariable);
if (numRowsVariableMetaData == null) {
throw new ExprValidationException(
"Limit clause variable by name '" + rowLimitSpec.NumRowsVariable + "' has not been declared");
}
string message = VariableUtil.CheckVariableContextName(optionalContextName, numRowsVariableMetaData);
if (message != null) {
throw new ExprValidationException(message);
}
if (!TypeHelper.IsNumeric(numRowsVariableMetaData.Type)) {
throw new ExprValidationException("Limit clause requires a variable of numeric type");
}
}
else {
numRowsVariableMetaData = null;
currentRowLimit = rowLimitSpec.NumRows.GetValueOrDefault(Int32.MaxValue);
if (currentRowLimit < 0) {
currentRowLimit = Int32.MaxValue;
}
}
if (rowLimitSpec.OptionalOffsetVariable != null) {
offsetVariableMetaData = variableCompileTimeResolver.Resolve(rowLimitSpec.OptionalOffsetVariable);
if (offsetVariableMetaData == null) {
throw new ExprValidationException(
"Limit clause variable by name '" +
rowLimitSpec.OptionalOffsetVariable +
"' has not been declared");
}
string message = VariableUtil.CheckVariableContextName(optionalContextName, offsetVariableMetaData);
if (message != null) {
throw new ExprValidationException(message);
}
if (!TypeHelper.IsNumeric(offsetVariableMetaData.Type)) {
throw new ExprValidationException("Limit clause requires a variable of numeric type");
}
}
else {
offsetVariableMetaData = null;
if (rowLimitSpec.OptionalOffset != null) {
if (rowLimitSpec.OptionalOffset.Value <= 0) {
throw new ExprValidationException("Limit clause requires a positive offset");
}
currentOffset = rowLimitSpec.OptionalOffset.Value;
}
else {
currentOffset = 0;
}
}
}
public override void DrawCommandGUI()
{
serializedObject.Update();
SetVariable t = target as SetVariable;
var flowchart = (Flowchart)t.GetFlowchart();
if (flowchart == null)
{
return;
}
// Select Variable
EditorGUILayout.PropertyField(anyVarProp, true);
//fetching every draw to ensure we don't have stale data based on types that have changed by user selection,
// without us noticing.
// Get selected variable
Variable selectedVariable = anyVarProp.FindPropertyRelative("variable").objectReferenceValue as Variable;
List <GUIContent> operatorsList = new List <GUIContent>();
if (selectedVariable != null)
{
if (selectedVariable.IsArithmeticSupported(SetOperator.Assign))
{
operatorsList.Add(new GUIContent(VariableUtil.GetSetOperatorDescription(SetOperator.Assign)));
}
if (selectedVariable.IsArithmeticSupported(SetOperator.Negate))
{
operatorsList.Add(new GUIContent(VariableUtil.GetSetOperatorDescription(SetOperator.Negate)));
}
if (selectedVariable.IsArithmeticSupported(SetOperator.Add))
{
operatorsList.Add(new GUIContent(VariableUtil.GetSetOperatorDescription(SetOperator.Add)));
}
if (selectedVariable.IsArithmeticSupported(SetOperator.Subtract))
{
operatorsList.Add(new GUIContent(VariableUtil.GetSetOperatorDescription(SetOperator.Subtract)));
}
if (selectedVariable.IsArithmeticSupported(SetOperator.Multiply))
{
operatorsList.Add(new GUIContent(VariableUtil.GetSetOperatorDescription(SetOperator.Multiply)));
}
if (selectedVariable.IsArithmeticSupported(SetOperator.Divide))
{
operatorsList.Add(new GUIContent(VariableUtil.GetSetOperatorDescription(SetOperator.Divide)));
}
}
else
{
operatorsList.Add(VariableConditionEditor.None);
}
// Get previously selected operator
int selectedIndex = (int)t._SetOperator;
if (selectedIndex < 0)
{
// Default to first index if the operator is not found in the available operators list
// This can occur when changing between variable types
selectedIndex = 0;
}
// Get next selected operator
selectedIndex = EditorGUILayout.Popup(new GUIContent("Operation", "Arithmetic operator to use"), selectedIndex, operatorsList.ToArray());
if (selectedVariable != null)
{
setOperatorProp.enumValueIndex = selectedIndex;
}
serializedObject.ApplyModifiedProperties();
}
private static ModuleCompileTimeServices GetServices(
CompilerArguments arguments,
string moduleName,
ICollection<string> moduleUses,
bool isFireAndForget)
{
var configuration = arguments.Configuration;
var path = arguments.Path;
var options = arguments.Options;
// script
var scriptCompiler = MakeScriptCompiler(configuration);
// imports
var importServiceCompileTime = MakeImportService(configuration);
var classLoaderParent = new ParentClassLoader(importServiceCompileTime.ClassLoader);
var container = importServiceCompileTime.Container;
// resolve pre-configured bean event types, make bean-stem service
var resolvedBeanEventTypes = BeanEventTypeRepoUtil.ResolveBeanEventTypes(
configuration.Common.EventTypeNames,
importServiceCompileTime);
var beanEventTypeStemService = BeanEventTypeRepoUtil.MakeBeanEventTypeStemService(
configuration,
resolvedBeanEventTypes,
EventBeanTypedEventFactoryCompileTime.INSTANCE);
// allocate repositories
var eventTypeRepositoryPreconfigured = new EventTypeRepositoryImpl(true);
var eventTypeCompileRegistry = new EventTypeCompileTimeRegistry(eventTypeRepositoryPreconfigured);
var beanEventTypeFactoryPrivate = new BeanEventTypeFactoryPrivate(
EventBeanTypedEventFactoryCompileTime.INSTANCE, EventTypeFactoryImpl.GetInstance(container), beanEventTypeStemService);
var variableRepositoryPreconfigured = new VariableRepositoryPreconfigured();
// allocate path registries
var pathEventTypes = new PathRegistry<string, EventType>(PathRegistryObjectType.EVENTTYPE);
var pathNamedWindows = new PathRegistry<string, NamedWindowMetaData>(PathRegistryObjectType.NAMEDWINDOW);
var pathTables = new PathRegistry<string, TableMetaData>(PathRegistryObjectType.TABLE);
var pathContexts = new PathRegistry<string, ContextMetaData>(PathRegistryObjectType.CONTEXT);
var pathVariables = new PathRegistry<string, VariableMetaData>(PathRegistryObjectType.VARIABLE);
var pathExprDeclared = new PathRegistry<string, ExpressionDeclItem>(PathRegistryObjectType.EXPRDECL);
var pathScript = new PathRegistry<NameAndParamNum, ExpressionScriptProvided>(PathRegistryObjectType.SCRIPT);
var pathClassProvided = new PathRegistry<string, ClassProvided>(PathRegistryObjectType.CLASSPROVIDED);
// add runtime-path which is the information an existing runtime may have
if (path.CompilerPathables != null) {
foreach (EPCompilerPathable pathable in path.CompilerPathables) {
EPCompilerPathableImpl impl = (EPCompilerPathableImpl) pathable;
pathVariables.MergeFrom(impl.VariablePathRegistry);
pathEventTypes.MergeFrom(impl.EventTypePathRegistry);
pathExprDeclared.MergeFrom(impl.ExprDeclaredPathRegistry);
pathNamedWindows.MergeFrom(impl.NamedWindowPathRegistry);
pathTables.MergeFrom(impl.TablePathRegistry);
pathContexts.MergeFrom(impl.ContextPathRegistry);
pathScript.MergeFrom(impl.ScriptPathRegistry);
pathClassProvided.MergeFrom(impl.ClassProvidedPathRegistry);
eventTypeRepositoryPreconfigured.MergeFrom(impl.EventTypePreconfigured);
variableRepositoryPreconfigured.MergeFrom(impl.VariablePreconfigured);
JsonEventTypeUtility.AddJsonUnderlyingClass(pathEventTypes, classLoaderParent);
}
}
// build preconfigured type system
EventTypeRepositoryBeanTypeUtil.BuildBeanTypes(
beanEventTypeStemService,
eventTypeRepositoryPreconfigured,
resolvedBeanEventTypes,
beanEventTypeFactoryPrivate,
configuration.Common.EventTypesBean);
EventTypeRepositoryMapTypeUtil.BuildMapTypes(
eventTypeRepositoryPreconfigured,
configuration.Common.MapTypeConfigurations,
configuration.Common.EventTypesMapEvents,
configuration.Common.EventTypesNestableMapEvents,
beanEventTypeFactoryPrivate,
importServiceCompileTime);
EventTypeRepositoryOATypeUtil.BuildOATypes(
eventTypeRepositoryPreconfigured,
configuration.Common.ObjectArrayTypeConfigurations,
configuration.Common.EventTypesNestableObjectArrayEvents,
beanEventTypeFactoryPrivate,
importServiceCompileTime);
XMLFragmentEventTypeFactory xmlFragmentEventTypeFactory = new XMLFragmentEventTypeFactory(
beanEventTypeFactoryPrivate,
eventTypeCompileRegistry,
eventTypeRepositoryPreconfigured);
EventTypeRepositoryXMLTypeUtil.BuildXMLTypes(
eventTypeRepositoryPreconfigured,
configuration.Common.EventTypesXMLDOM,
beanEventTypeFactoryPrivate,
xmlFragmentEventTypeFactory,
container.ResourceManager());
EventTypeAvroHandler eventTypeAvroHandler = EventTypeAvroHandlerFactory.Resolve(
importServiceCompileTime,
configuration.Common.EventMeta.AvroSettings,
EventTypeAvroHandlerConstants.COMPILE_TIME_HANDLER_IMPL);
EventTypeRepositoryAvroTypeUtil.BuildAvroTypes(
eventTypeRepositoryPreconfigured,
configuration.Common.EventTypesAvro,
eventTypeAvroHandler,
beanEventTypeFactoryPrivate.EventBeanTypedEventFactory);
EventTypeRepositoryVariantStreamUtil.BuildVariantStreams(
eventTypeRepositoryPreconfigured,
configuration.Common.VariantStreams,
EventTypeFactoryImpl.GetInstance(container));
// build preconfigured variables
VariableUtil.ConfigureVariables(
variableRepositoryPreconfigured,
configuration.Common.Variables,
importServiceCompileTime,
EventBeanTypedEventFactoryCompileTime.INSTANCE,
eventTypeRepositoryPreconfigured,
beanEventTypeFactoryPrivate);
var deploymentNumber = -1;
foreach (var unit in path.Compileds) {
deploymentNumber++;
var provider = ModuleProviderUtil.Analyze(unit, classLoaderParent, pathClassProvided);
var unitModuleName = provider.ModuleProvider.ModuleName;
// initialize event types
var moduleTypes = new Dictionary<string, EventType>();
var eventTypeResolver = new EventTypeResolverImpl(
moduleTypes,
pathEventTypes,
eventTypeRepositoryPreconfigured,
beanEventTypeFactoryPrivate,
EventSerdeFactoryDefault.INSTANCE);
var eventTypeCollector = new EventTypeCollectorImpl(
container,
moduleTypes,
beanEventTypeFactoryPrivate,
provider.ClassLoader,
EventTypeFactoryImpl.GetInstance(container),
beanEventTypeStemService,
eventTypeResolver,
xmlFragmentEventTypeFactory,
eventTypeAvroHandler,
EventBeanTypedEventFactoryCompileTime.INSTANCE,
importServiceCompileTime);
try {
provider.ModuleProvider.InitializeEventTypes(
new EPModuleEventTypeInitServicesImpl(eventTypeCollector, eventTypeResolver));
}
catch (Exception e) {
throw new EPException(e);
}
JsonEventTypeUtility.AddJsonUnderlyingClass(moduleTypes, classLoaderParent, null);
// initialize named windows
var moduleNamedWindows = new Dictionary<string, NamedWindowMetaData>();
var namedWindowCollector = new NamedWindowCollectorImpl(moduleNamedWindows);
try {
provider.ModuleProvider.InitializeNamedWindows(
new EPModuleNamedWindowInitServicesImpl(namedWindowCollector, eventTypeResolver));
}
catch (Exception e) {
throw new EPException(e);
}
// initialize tables
var moduleTables = new Dictionary<string, TableMetaData>();
var tableCollector = new TableCollectorImpl(moduleTables);
try {
provider.ModuleProvider.InitializeTables(
new EPModuleTableInitServicesImpl(tableCollector, eventTypeResolver));
}
catch (Exception e) {
throw new EPException(e);
}
// initialize create-index indexes
var indexCollector = new IndexCollectorCompileTime(
moduleNamedWindows,
moduleTables,
pathNamedWindows,
pathTables);
try {
provider.ModuleProvider.InitializeIndexes(new EPModuleIndexInitServicesImpl(indexCollector));
}
catch (Exception e) {
throw new EPException(e);
}
// initialize create-contexts
var moduleContexts = new Dictionary<string, ContextMetaData>();
var contextCollector = new ContextCollectorImpl(moduleContexts);
try {
provider.ModuleProvider.InitializeContexts(
new EPModuleContextInitServicesImpl(contextCollector, eventTypeResolver));
}
catch (Exception e) {
throw new EPException(e);
}
// initialize variables
var moduleVariables = new Dictionary<string, VariableMetaData>();
var variableCollector = new VariableCollectorImpl(moduleVariables);
try {
provider.ModuleProvider.InitializeVariables(
new EPModuleVariableInitServicesImpl(variableCollector, eventTypeResolver));
}
catch (Exception e) {
throw new EPException(e);
}
// initialize module expressions
var moduleExprDeclareds = new Dictionary<string, ExpressionDeclItem>();
var exprDeclaredCollector = new ExprDeclaredCollectorCompileTime(moduleExprDeclareds);
try {
provider.ModuleProvider.InitializeExprDeclareds(
new EPModuleExprDeclaredInitServicesImpl(exprDeclaredCollector));
}
catch (Exception e) {
throw new EPException(e);
}
// initialize module scripts
var moduleScripts = new Dictionary<NameAndParamNum, ExpressionScriptProvided>();
var scriptCollector = new ScriptCollectorCompileTime(moduleScripts);
try {
provider.ModuleProvider.InitializeScripts(new EPModuleScriptInitServicesImpl(scriptCollector));
}
catch (Exception e) {
throw new EPException(e);
}
// initialize inlined classes
var moduleClassProvideds = new Dictionary<string, ClassProvided>();
var classProvidedCollector = new ClassProvidedCollectorCompileTime(moduleClassProvideds, classLoaderParent);
try {
provider.ModuleProvider.InitializeClassProvided(new EPModuleClassProvidedInitServicesImpl(classProvidedCollector));
} catch (Exception e) {
throw new EPException(e);
}
// save path-visibility event types and named windows to the path
var deploymentId = "D" + deploymentNumber;
try {
foreach (var type in moduleTypes) {
if (type.Value.Metadata.AccessModifier.IsNonPrivateNonTransient()) {
pathEventTypes.Add(type.Key, unitModuleName, type.Value, deploymentId);
}
}
foreach (var entry in moduleNamedWindows) {
if (entry.Value.EventType.Metadata.AccessModifier.IsNonPrivateNonTransient()) {
pathNamedWindows.Add(entry.Key, unitModuleName, entry.Value, deploymentId);
}
}
foreach (var entry in moduleTables) {
if (entry.Value.TableVisibility.IsNonPrivateNonTransient()) {
pathTables.Add(entry.Key, unitModuleName, entry.Value, deploymentId);
}
}
foreach (var entry in moduleContexts) {
if (entry.Value.ContextVisibility.IsNonPrivateNonTransient()) {
pathContexts.Add(entry.Key, unitModuleName, entry.Value, deploymentId);
}
}
foreach (var entry in moduleVariables) {
if (entry.Value.VariableVisibility.IsNonPrivateNonTransient()) {
pathVariables.Add(entry.Key, unitModuleName, entry.Value, deploymentId);
}
}
foreach (var entry in moduleExprDeclareds) {
if (entry.Value.Visibility.IsNonPrivateNonTransient()) {
pathExprDeclared.Add(entry.Key, unitModuleName, entry.Value, deploymentId);
}
}
foreach (var entry in moduleScripts) {
if (entry.Value.Visibility.IsNonPrivateNonTransient()) {
pathScript.Add(entry.Key, unitModuleName, entry.Value, deploymentId);
}
}
foreach (var entry in moduleClassProvideds) {
if (entry.Value.Visibility.IsNonPrivateNonTransient()) {
pathClassProvided.Add(entry.Key, unitModuleName, entry.Value, deploymentId);
}
}
}
catch (PathException ex) {
throw new EPCompileException(
"Invalid path: " + ex.Message,
ex,
new EmptyList<EPCompileExceptionItem>());
}
}
var moduleDependencies = new ModuleDependenciesCompileTime();
// build bean space of public and protected
var eventTypeCompileTimeResolver = new EventTypeCompileTimeResolver(
moduleName,
moduleUses,
eventTypeCompileRegistry,
eventTypeRepositoryPreconfigured,
pathEventTypes,
moduleDependencies,
isFireAndForget);
// build named window registry
var namedWindowCompileTimeRegistry = new NamedWindowCompileTimeRegistry();
var namedWindowCompileTimeResolver = new NamedWindowCompileTimeResolverImpl(
moduleName,
moduleUses,
namedWindowCompileTimeRegistry,
pathNamedWindows,
moduleDependencies,
isFireAndForget);
// build context registry
var contextCompileTimeRegistry = new ContextCompileTimeRegistry();
var contextCompileTimeResolver = new ContextCompileTimeResolverImpl(
moduleName,
moduleUses,
contextCompileTimeRegistry,
pathContexts,
moduleDependencies,
isFireAndForget);
// build variable registry
var variableCompileTimeRegistry = new VariableCompileTimeRegistry();
var variableCompileTimeResolver = new VariableCompileTimeResolverImpl(
moduleName,
moduleUses,
variableRepositoryPreconfigured,
variableCompileTimeRegistry,
pathVariables,
moduleDependencies,
isFireAndForget);
// build declared-expression registry
var exprDeclaredCompileTimeRegistry = new ExprDeclaredCompileTimeRegistry();
var exprDeclaredCompileTimeResolver = new ExprDeclaredCompileTimeResolverImpl(
moduleName,
moduleUses,
exprDeclaredCompileTimeRegistry,
pathExprDeclared,
moduleDependencies,
isFireAndForget);
// build table-registry
var localTables = new Dictionary<string, TableMetaData>();
var tableCompileTimeRegistry = new TableCompileTimeRegistry(localTables);
var tableCompileTimeResolver = new TableCompileTimeResolverImpl(
moduleName,
moduleUses,
tableCompileTimeRegistry,
pathTables,
moduleDependencies,
isFireAndForget);
// build script registry
var scriptCompileTimeRegistry = new ScriptCompileTimeRegistry();
var scriptCompileTimeResolver = new ScriptCompileTimeResolverImpl(
moduleName,
moduleUses,
scriptCompileTimeRegistry,
pathScript,
moduleDependencies,
isFireAndForget);
// build classes registry
var classProvidedCompileTimeRegistry = new ClassProvidedCompileTimeRegistry();
var classProvidedCompileTimeResolver = new ClassProvidedCompileTimeResolverImpl(
moduleName,
moduleUses,
classProvidedCompileTimeRegistry,
pathClassProvided,
moduleDependencies,
isFireAndForget);
// view resolution
var plugInViews = new PluggableObjectCollection();
plugInViews.AddViews(
configuration.Compiler.PlugInViews,
configuration.Compiler.PlugInVirtualDataWindows,
importServiceCompileTime);
var viewRegistry = new PluggableObjectRegistryImpl(new[] {ViewEnumHelper.BuiltinViews, plugInViews});
ViewResolutionService viewResolutionService = new ViewResolutionServiceImpl(viewRegistry);
var plugInPatternObj = new PluggableObjectCollection();
plugInPatternObj.AddPatternObjects(configuration.Compiler.PlugInPatternObjects, importServiceCompileTime);
plugInPatternObj.AddObjects(PatternObjectHelper.BuiltinPatternObjects);
PatternObjectResolutionService patternResolutionService =
new PatternObjectResolutionServiceImpl(plugInPatternObj);
var indexCompileTimeRegistry = new IndexCompileTimeRegistry(new Dictionary<IndexCompileTimeKey, IndexDetailForge>());
var moduleVisibilityRules = new ModuleAccessModifierServiceImpl(options, configuration.Compiler.ByteCode);
var databaseConfigServiceCompileTime =
new DatabaseConfigServiceImpl(
container,
configuration.Common.DatabaseReferences,
importServiceCompileTime);
var compilerServices = new CompilerServicesImpl();
var targetHA = configuration.GetType().Name.EndsWith("ConfigurationHA");
var serdeEventTypeRegistry = new SerdeEventTypeCompileTimeRegistryImpl(targetHA);
SerdeCompileTimeResolver serdeResolver = targetHA
? MakeSerdeResolver(configuration.Compiler.Serde, configuration.Common.TransientConfiguration)
: SerdeCompileTimeResolverNonHA.INSTANCE;
return new ModuleCompileTimeServices(
container,
compilerServices,
configuration,
contextCompileTimeRegistry,
contextCompileTimeResolver,
beanEventTypeStemService,
beanEventTypeFactoryPrivate,
classProvidedCompileTimeRegistry,
classProvidedCompileTimeResolver,
databaseConfigServiceCompileTime,
importServiceCompileTime,
exprDeclaredCompileTimeRegistry,
exprDeclaredCompileTimeResolver,
eventTypeAvroHandler,
eventTypeCompileRegistry,
eventTypeCompileTimeResolver,
eventTypeRepositoryPreconfigured,
isFireAndForget,
indexCompileTimeRegistry,
moduleDependencies,
moduleVisibilityRules,
namedWindowCompileTimeResolver,
namedWindowCompileTimeRegistry,
classLoaderParent,
patternResolutionService,
scriptCompileTimeRegistry,
scriptCompileTimeResolver,
scriptCompiler,
serdeEventTypeRegistry,
serdeResolver,
tableCompileTimeRegistry,
tableCompileTimeResolver,
variableCompileTimeRegistry,
variableCompileTimeResolver,
viewResolutionService,
xmlFragmentEventTypeFactory);
}
