public ResultSetProcessorDesc(
ResultSetProcessorFactoryForge resultSetProcessorFactoryForge,
ResultSetProcessorType resultSetProcessorType,
SelectExprProcessorForge[] selectExprProcessorForges,
bool join,
bool hasOutputLimit,
ResultSetProcessorOutputConditionType? outputConditionType,
bool hasOutputLimitSnapshot,
EventType resultEventType,
bool rollup,
AggregationServiceForgeDesc aggregationServiceForgeDesc,
OrderByProcessorFactoryForge orderByProcessorFactoryForge,
SelectSubscriberDescriptor selectSubscriberDescriptor,
IList<StmtClassForgeableFactory> additionalForgeables)
{
ResultSetProcessorFactoryForge = resultSetProcessorFactoryForge;
ResultSetProcessorType = resultSetProcessorType;
SelectExprProcessorForges = selectExprProcessorForges;
IsJoin = join;
HasOutputLimit = hasOutputLimit;
OutputConditionType = outputConditionType;
HasOutputLimitSnapshot = hasOutputLimitSnapshot;
ResultEventType = resultEventType;
IsRollup = rollup;
AggregationServiceForgeDesc = aggregationServiceForgeDesc;
OrderByProcessorFactoryForge = orderByProcessorFactoryForge;
SelectSubscriberDescriptor = selectSubscriberDescriptor;
AdditionalForgeables = additionalForgeables;
}
public OnTriggerSetPlan(
StmtClassForgableAIFactoryProviderBase forgable,
IList<StmtClassForgable> forgables,
SelectSubscriberDescriptor selectSubscriberDescriptor)
{
Forgable = forgable;
Forgables = forgables;
SelectSubscriberDescriptor = selectSubscriberDescriptor;
}
public OnTriggerPlan(
StmtClassForgableAIFactoryProviderBase factory,
IList<StmtClassForgable> forgables,
SelectSubscriberDescriptor subscriberDescriptor)
{
Factory = factory;
Forgables = forgables;
SubscriberDescriptor = subscriberDescriptor;
}
public OnTriggerPlan(
StmtClassForgeableAIFactoryProviderBase factory,
IList<StmtClassForgeable> forgeables,
SelectSubscriberDescriptor subscriberDescriptor,
IList<StmtClassForgeableFactory> additionalForgeables)
{
Factory = factory;
Forgeables = forgeables;
SubscriberDescriptor = subscriberDescriptor;
AdditionalForgeables = additionalForgeables;
}
public OnTriggerSetPlan(
StmtClassForgeableAIFactoryProviderBase forgeable,
IList<StmtClassForgeable> forgeables,
SelectSubscriberDescriptor selectSubscriberDescriptor,
IList<StmtClassForgeableFactory> additionalForgeables)
{
Forgeable = forgeable;
Forgeables = forgeables;
SelectSubscriberDescriptor = selectSubscriberDescriptor;
AdditionalForgeables = additionalForgeables;
}
public StmtForgeMethodResult Make(
string @namespace,
string classPostfix,
StatementCompileTimeServices services)
{
var statementSpec = @base.StatementSpec;
var spec = statementSpec.Raw.CreateSchemaDesc;
if (services.EventTypeCompileTimeResolver.GetTypeByName(spec.SchemaName) != null) {
throw new ExprValidationException(
"Event type named '" + spec.SchemaName + "' has already been declared");
}
EPLValidationUtil.ValidateTableExists(services.TableCompileTimeResolver, spec.SchemaName);
var eventType = HandleCreateSchema(spec, services);
var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementFields), classPostfix);
var namespaceScope = new CodegenNamespaceScope(
@namespace, statementFieldsClassName, services.IsInstrumented);
var fieldsForgable = new StmtClassForgableStmtFields(statementFieldsClassName, namespaceScope, 0);
var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
var forge = new StatementAgentInstanceFactoryCreateSchemaForge(eventType);
var aiFactoryForgable = new StmtClassForgableAIFactoryProviderCreateSchema(
aiFactoryProviderClassName,
namespaceScope,
forge);
var selectSubscriberDescriptor = new SelectSubscriberDescriptor();
var informationals = StatementInformationalsUtil.GetInformationals(
@base,
new EmptyList<FilterSpecCompiled>(),
new EmptyList<ScheduleHandleCallbackProvider>(),
new EmptyList<NamedWindowConsumerStreamSpec>(),
false,
selectSubscriberDescriptor,
namespaceScope,
services);
var statementProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
var stmtProvider = new StmtClassForgableStmtProvider(
aiFactoryProviderClassName,
statementProviderClassName,
informationals,
namespaceScope);
IList<StmtClassForgable> forgables = new List<StmtClassForgable>();
forgables.Add(fieldsForgable);
forgables.Add(aiFactoryForgable);
forgables.Add(stmtProvider);
return new StmtForgeMethodResult(
forgables,
new EmptyList<FilterSpecCompiled>(),
new EmptyList<ScheduleHandleCallbackProvider>(),
new EmptyList<NamedWindowConsumerStreamSpec>(),
new EmptyList<FilterSpecParamExprNodeForge>());
}
public StmtForgeMethodResult Make(
string @namespace,
string classPostfix,
StatementCompileTimeServices services)
{
var statementSpec = @base.StatementSpec;
// determine context
var contextName = @base.StatementSpec.Raw.OptionalContextName;
if (contextName != null) {
throw new ExprValidationException("Update IStream is not supported in conjunction with a context");
}
var streamSpec = statementSpec.StreamSpecs[0];
var updateSpec = statementSpec.Raw.UpdateDesc;
string triggereventTypeName;
EventType streamEventType;
if (streamSpec is FilterStreamSpecCompiled) {
var filterStreamSpec = (FilterStreamSpecCompiled) streamSpec;
triggereventTypeName = filterStreamSpec.FilterSpecCompiled.FilterForEventTypeName;
streamEventType = filterStreamSpec.FilterSpecCompiled.FilterForEventType;
}
else if (streamSpec is NamedWindowConsumerStreamSpec) {
var namedSpec = (NamedWindowConsumerStreamSpec) streamSpec;
streamEventType = namedSpec.NamedWindow.EventType;
triggereventTypeName = streamEventType.Name;
}
else if (streamSpec is TableQueryStreamSpec) {
throw new ExprValidationException("Tables cannot be used in an update-istream statement");
}
else {
throw new ExprValidationException("Unknown stream specification streamEventType: " + streamSpec);
}
// determine a stream name
var streamName = triggereventTypeName;
if (updateSpec.OptionalStreamName != null) {
streamName = updateSpec.OptionalStreamName;
}
StreamTypeService typeService = new StreamTypeServiceImpl(
new[] {streamEventType},
new[] {streamName},
new[] {true},
false,
false);
// create subselect information
IList<FilterSpecCompiled> filterSpecCompileds = new List<FilterSpecCompiled>();
IList<NamedWindowConsumerStreamSpec> namedWindowConsumers = new List<NamedWindowConsumerStreamSpec>();
var subselectActivation = SubSelectHelperActivations.CreateSubSelectActivation(
filterSpecCompileds,
namedWindowConsumers,
@base,
services);
// handle subselects
var subselectForges = SubSelectHelperForgePlanner.PlanSubSelect(
@base,
subselectActivation,
typeService.StreamNames,
typeService.EventTypes,
new[] {triggereventTypeName},
services);
var validationContext =
new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services).Build();
foreach (var assignment in updateSpec.Assignments) {
var validated = ExprNodeUtilityValidate.GetValidatedAssignment(assignment, validationContext);
assignment.Expression = validated;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(
validated,
"Aggregation functions may not be used within an update-clause");
}
if (updateSpec.OptionalWhereClause != null) {
var validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.WHERE,
updateSpec.OptionalWhereClause,
validationContext);
updateSpec.OptionalWhereClause = validated;
EPStatementStartMethodHelperValidate.ValidateNoAggregations(
validated,
"Aggregation functions may not be used within an update-clause");
}
// build route information
var routerDesc = InternalEventRouterDescFactory.GetValidatePreprocessing(
streamEventType,
updateSpec,
@base.StatementRawInfo.Annotations);
var statementFieldsClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
var packageScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
var forge = new StatementAgentInstanceFactoryUpdateForge(routerDesc, subselectForges);
var aiFactoryForgable = new StmtClassForgableAIFactoryProviderUpdate(
aiFactoryProviderClassName,
packageScope,
forge);
var selectSubscriberDescriptor = new SelectSubscriberDescriptor(
new[] {streamEventType.UnderlyingType},
new[] {"*"},
false,
null);
var informationals = StatementInformationalsUtil.GetInformationals(
@base,
filterSpecCompileds,
Collections.GetEmptyList<ScheduleHandleCallbackProvider>(),
Collections.GetEmptyList<NamedWindowConsumerStreamSpec>(),
false,
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(aiFactoryForgable);
forgables.Add(stmtProvider);
forgables.Add(new StmtClassForgableStmtFields(statementFieldsClassName, packageScope, 0));
return new StmtForgeMethodResult(
forgables,
filterSpecCompileds,
Collections.GetEmptyList<ScheduleHandleCallbackProvider>(),
namedWindowConsumers,
Collections.GetEmptyList<FilterSpecParamExprNodeForge>());
}
public StmtForgeMethodResult Make(
string @namespace,
string classPostfix,
StatementCompileTimeServices services)
{
var statementSpec = @base.StatementSpec;
if (statementSpec.Raw.OptionalContextName != null) {
throw new ExprValidationException(
"A create-context statement cannot itself be associated to a context, please declare a nested context instead");
}
IList<FilterSpecCompiled> filterSpecCompileds = new List<FilterSpecCompiled>();
IList<ScheduleHandleCallbackProvider> scheduleHandleCallbackProviders =
new List<ScheduleHandleCallbackProvider>();
IList<FilterSpecParamExprNodeForge> filterBooleanExpressions = new List<FilterSpecParamExprNodeForge>();
var context = statementSpec.Raw.CreateContextDesc;
if (services.ContextCompileTimeResolver.GetContextInfo(context.ContextName) != null) {
throw new ExprValidationException("Context by name '" + context.ContextName + "' already exists");
}
// compile filter specs, if any
var validationEnv = new CreateContextValidationEnv(
context.ContextName,
@base.StatementRawInfo,
services,
filterSpecCompileds,
scheduleHandleCallbackProviders,
filterBooleanExpressions);
var additionalForgeables = ValidateContextDetail(
context.ContextDetail,
0,
validationEnv);
// get controller factory forges
var controllerFactoryForges = GetForges(
context.ContextName,
context.ContextDetail);
// build context properties type information
var contextProps = MakeContextProperties(
controllerFactoryForges,
@base.StatementRawInfo,
services);
// allocate type for context properties
var contextEventTypeName =
services.EventTypeNameGeneratorStatement.GetContextPropertyTypeName(context.ContextName);
var metadata = new EventTypeMetadata(
contextEventTypeName,
@base.ModuleName,
EventTypeTypeClass.CONTEXTPROPDERIVED,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var contextPropertiesType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata,
contextProps,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(contextPropertiesType);
// register context
var visibilityContext =
services.ModuleVisibilityRules.GetAccessModifierContext(@base, context.ContextName);
var validationInfo =
new ContextControllerPortableInfo[controllerFactoryForges.Length];
for (var i = 0; i < validationInfo.Length; i++) {
validationInfo[i] = controllerFactoryForges[i].ValidationInfo;
}
var detail = new ContextMetaData(
context.ContextName,
@base.ModuleName,
visibilityContext,
contextPropertiesType,
validationInfo);
services.ContextCompileTimeRegistry.NewContext(detail);
// define output event type
var statementEventTypeName =
services.EventTypeNameGeneratorStatement.GetContextStatementTypeName(context.ContextName);
var statementTypeMetadata = new EventTypeMetadata(
statementEventTypeName,
@base.ModuleName,
EventTypeTypeClass.STATEMENTOUT,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
EventType statementEventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
statementTypeMetadata,
EmptyDictionary<string, object>.Instance,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(statementEventType);
var statementFieldsClassName = CodeGenerationIDGenerator
.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
var namespaceScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
var forgeables = new List<StmtClassForgeable>();
foreach (var additional in additionalForgeables) {
forgeables.Add(additional.Make(namespaceScope, classPostfix));
}
var statementProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
var statementAIFactoryProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementAIFactoryProvider), classPostfix);
var forge =
new StatementAgentInstanceFactoryCreateContextForge(context.ContextName, statementEventType);
forgeables.Add(
new StmtClassForgeableAIFactoryProviderCreateContext(
statementAIFactoryProviderClassName,
namespaceScope,
context.ContextName,
controllerFactoryForges,
contextPropertiesType,
forge));
var selectSubscriberDescriptor = new SelectSubscriberDescriptor();
var informationals = StatementInformationalsUtil.GetInformationals(
@base,
filterSpecCompileds,
scheduleHandleCallbackProviders,
EmptyList<NamedWindowConsumerStreamSpec>.Instance,
false,
selectSubscriberDescriptor,
namespaceScope,
services);
informationals.Properties.Put(StatementProperty.CREATEOBJECTNAME, context.ContextName);
forgeables.Add(
new StmtClassForgeableStmtProvider(
statementAIFactoryProviderClassName,
statementProviderClassName,
informationals,
namespaceScope));
forgeables.Add(
new StmtClassForgeableStmtFields(
statementFieldsClassName,
namespaceScope,
0));
return new StmtForgeMethodResult(
forgeables,
filterSpecCompileds,
scheduleHandleCallbackProviders,
EmptyList<NamedWindowConsumerStreamSpec>.Instance,
FilterSpecCompiled.MakeExprNodeList(filterSpecCompileds, filterBooleanExpressions));
}
private StmtForgeMethodResult Build(
string @namespace,
string classPostfix,
StatementCompileTimeServices services)
{
var createDesc = @base.StatementSpec.Raw.CreateTableDesc;
var tableName = createDesc.TableName;
var additionalForgeables = new List<StmtClassForgeableFactory>();
// determine whether already declared as table or variable
EPLValidationUtil.ValidateAlreadyExistsTableOrVariable(
tableName,
services.VariableCompileTimeResolver,
services.TableCompileTimeResolver,
services.EventTypeCompileTimeResolver);
// determine key types
ValidateKeyTypes(createDesc.Columns, services.ImportServiceCompileTime);
// check column naming, interpret annotations
var columnsValidated = ValidateExpressions(createDesc.Columns, services);
var columnDescs = columnsValidated.First;
additionalForgeables.AddRange(columnsValidated.Second);
// analyze and plan the state holders
var plan = AnalyzePlanAggregations(createDesc.TableName, columnDescs, @base.StatementRawInfo, services);
additionalForgeables.AddAll(plan.AdditionalForgeables);
var visibility = plan.PublicEventType.Metadata.AccessModifier;
// determine context information
var contextName = @base.StatementRawInfo.ContextName;
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;
}
// add table
var tableMetaData = new TableMetaData(
tableName,
@base.ModuleName,
visibility,
contextName,
contextVisibility,
contextModuleName,
plan.InternalEventType,
plan.PublicEventType,
plan.PrimaryKeyColumns,
plan.PrimaryKeyTypes,
plan.PrimaryKeyColNums,
plan.TableColumns,
plan.ColsAggMethod.Length);
services.TableCompileTimeRegistry.NewTable(tableMetaData);
var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
var statementFieldsClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
var statementProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
var forge = new StatementAgentInstanceFactoryCreateTableForge(
aiFactoryProviderClassName,
tableMetaData.TableName,
plan);
// build forge list
var namespaceScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
var forgeables = additionalForgeables
.Select(additional => additional.Make(namespaceScope, classPostfix))
.ToList();
var aiFactoryForgeable = new StmtClassForgeableAIFactoryProviderCreateTable(
aiFactoryProviderClassName,
namespaceScope,
forge,
tableName);
forgeables.Add(aiFactoryForgeable);
var selectSubscriberDescriptor = new SelectSubscriberDescriptor();
var informationals = StatementInformationalsUtil.GetInformationals(
@base,
EmptyList<FilterSpecCompiled>.Instance,
EmptyList<ScheduleHandleCallbackProvider>.Instance,
EmptyList<NamedWindowConsumerStreamSpec>.Instance,
true,
selectSubscriberDescriptor,
namespaceScope,
services);
informationals.Properties.Put(StatementProperty.CREATEOBJECTNAME, createDesc.TableName);
forgeables.Add(
new StmtClassForgeableStmtProvider(
aiFactoryProviderClassName,
statementProviderClassName,
informationals,
namespaceScope));
forgeables.Add(
new StmtClassForgeableStmtFields(
statementFieldsClassName,
namespaceScope,
1));
return new StmtForgeMethodResult(
forgeables,
EmptyList<FilterSpecCompiled>.Instance,
EmptyList<ScheduleHandleCallbackProvider>.Instance,
EmptyList<NamedWindowConsumerStreamSpec>.Instance,
EmptyList<FilterSpecParamExprNodeForge>.Instance);
}
public static StatementInformationalsCompileTime GetInformationals(
StatementBaseInfo @base,
IList<FilterSpecCompiled> filterSpecCompileds,
IList<ScheduleHandleCallbackProvider> schedules,
IList<NamedWindowConsumerStreamSpec> namedWindowConsumers,
bool allowContext,
SelectSubscriberDescriptor selectSubscriberDescriptor,
CodegenNamespaceScope namespaceScope,
StatementCompileTimeServices services)
{
var specCompiled = @base.StatementSpec;
bool alwaysSynthesizeOutputEvents =
specCompiled.Raw.InsertIntoDesc != null ||
specCompiled.Raw.ForClauseSpec != null ||
specCompiled.SelectClauseCompiled.IsDistinct ||
specCompiled.Raw.CreateDataFlowDesc != null;
var needDedup = IsNeedDedup(filterSpecCompileds);
bool hasSubquery = [email protected]();
var canSelfJoin = StatementSpecWalkUtil.IsPotentialSelfJoin(specCompiled) || needDedup;
// Determine stateless statement
var stateless = DetermineStatelessSelect(
@base.StatementRawInfo.StatementType,
@base.StatementSpec.Raw,
[email protected]());
string contextName = null;
string contextModuleName = null;
NameAccessModifier? contextVisibility = null;
if (allowContext) {
ContextCompileTimeDescriptor descriptor = @base.StatementRawInfo.OptionalContextDescriptor;
if (descriptor != null) {
contextName = descriptor.ContextName;
contextModuleName = descriptor.ContextModuleName;
contextVisibility = descriptor.ContextVisibility;
}
}
var annotationData = AnnotationAnalysisResult.AnalyzeAnnotations(@base.StatementSpec.Annotations);
// Hint annotations are often driven by variables
var hasHint = false;
if (@base.StatementSpec.Raw.Annotations != null) {
foreach (Attribute annotation in @base.StatementRawInfo.Annotations) {
if (annotation is HintAttribute) {
hasHint = true;
}
}
}
var hasVariables = hasHint ||
[email protected]() ||
@base.StatementSpec.Raw.CreateContextDesc != null;
var writesToTables = StatementLifecycleSvcUtil.IsWritesToTables(
@base.StatementSpec.Raw,
services.TableCompileTimeResolver);
bool hasTableAccess = StatementLifecycleSvcUtil.DetermineHasTableAccess(
@base.StatementSpec.SubselectNodes,
@base.StatementSpec.Raw,
services.TableCompileTimeResolver);
IDictionary<StatementProperty, object> properties = new Dictionary<StatementProperty, object>();
if (services.Configuration.Compiler.ByteCode.IsAttachEPL) {
properties.Put(StatementProperty.EPL, @base.Compilable.ToEPL());
}
string insertIntoLatchName = null;
if (@base.StatementSpec.Raw.InsertIntoDesc != null ||
@base.StatementSpec.Raw.OnTriggerDesc is OnTriggerMergeDesc) {
if (@base.StatementSpec.Raw.InsertIntoDesc != null) {
insertIntoLatchName = @base.StatementSpec.Raw.InsertIntoDesc.EventTypeName;
}
else {
insertIntoLatchName = "merge";
}
}
bool allowSubscriber = services.Configuration.Compiler.ByteCode.IsAllowSubscriber;
return new StatementInformationalsCompileTime(
@base.StatementName,
alwaysSynthesizeOutputEvents,
contextName,
contextModuleName,
contextVisibility,
canSelfJoin,
hasSubquery,
needDedup,
specCompiled.Annotations,
stateless,
@base.UserObjectCompileTime,
filterSpecCompileds.Count,
schedules.Count,
namedWindowConsumers.Count,
@base.StatementRawInfo.StatementType,
annotationData.Priority,
annotationData.IsPremptive,
hasVariables,
writesToTables,
hasTableAccess,
selectSubscriberDescriptor.SelectClauseTypes,
selectSubscriberDescriptor.SelectClauseColumnNames,
selectSubscriberDescriptor.IsForClauseDelivery,
selectSubscriberDescriptor.GroupDelivery,
properties,
@base.StatementSpec.Raw.MatchRecognizeSpec != null,
services.IsInstrumented,
namespaceScope,
insertIntoLatchName,
allowSubscriber);
}
public StmtForgeMethodResult Make(
string @namespace,
string classPostfix,
StatementCompileTimeServices services)
{
var spec = @base.StatementSpec.Raw.CreateIndexDesc;
var infraName = spec.WindowName;
var namedWindow = services.NamedWindowCompileTimeResolver.Resolve(infraName);
var table = services.TableCompileTimeResolver.Resolve(infraName);
if (namedWindow == null && table == null) {
throw new ExprValidationException("A named window or table by name '" + infraName + "' does not exist");
}
if (namedWindow != null && table != null) {
throw new ExprValidationException("A named window or table by name '" + infraName + "' are both found");
}
string infraModuleName;
NameAccessModifier infraVisibility;
EventType indexedEventType;
string infraContextName;
if (namedWindow != null) {
infraModuleName = namedWindow.NamedWindowModuleName;
infraVisibility = namedWindow.EventType.Metadata.AccessModifier;
indexedEventType = namedWindow.EventType;
infraContextName = namedWindow.ContextName;
}
else {
infraModuleName = table.TableModuleName;
infraVisibility = table.TableVisibility;
indexedEventType = table.InternalEventType;
infraContextName = table.OptionalContextName;
if (!table.IsKeyed) {
throw new ExprValidationException(
"Tables without primary key column(s) do not allow creating an index");
}
}
EPLValidationUtil.ValidateContextName(
namedWindow == null,
infraName,
infraContextName,
@base.StatementSpec.Raw.OptionalContextName,
true);
// validate index
var explicitIndexDesc = EventTableIndexUtil.ValidateCompileExplicitIndex(
spec.IndexName,
spec.IsUnique,
spec.Columns,
indexedEventType,
@base.StatementRawInfo,
services);
var advancedIndexDesc = explicitIndexDesc.AdvancedIndexProvisionDesc == null
? null
: explicitIndexDesc.AdvancedIndexProvisionDesc.IndexDesc.AdvancedIndexDescRuntime;
var imk = new IndexMultiKey(
spec.IsUnique,
explicitIndexDesc.HashPropsAsList,
explicitIndexDesc.BtreePropsAsList,
advancedIndexDesc);
// add index as a new index to module-init
var indexKey = new IndexCompileTimeKey(
infraModuleName,
infraName,
infraVisibility,
namedWindow != null,
spec.IndexName,
@base.ModuleName);
services.IndexCompileTimeRegistry.NewIndex(indexKey, new IndexDetailForge(imk, explicitIndexDesc));
// add index current named window information
if (namedWindow != null) {
namedWindow.AddIndex(spec.IndexName, @base.ModuleName, imk, explicitIndexDesc.ToRuntime());
}
else {
table.AddIndex(spec.IndexName, @base.ModuleName, imk, explicitIndexDesc.ToRuntime());
}
var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementFields), classPostfix);
var namespaceScope = new CodegenNamespaceScope(
@namespace, statementFieldsClassName, services.IsInstrumented);
var fieldsForgable = new StmtClassForgableStmtFields(statementFieldsClassName, namespaceScope, 0);
var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
var forge = new StatementAgentInstanceFactoryCreateIndexForge(
indexedEventType,
spec.IndexName,
@base.ModuleName,
explicitIndexDesc,
imk,
namedWindow,
table);
var aiFactoryForgable = new StmtClassForgableAIFactoryProviderCreateIndex(
aiFactoryProviderClassName,
namespaceScope,
forge);
var selectSubscriberDescriptor = new SelectSubscriberDescriptor();
var informationals = StatementInformationalsUtil.GetInformationals(
@base,
new EmptyList<FilterSpecCompiled>(),
new EmptyList<ScheduleHandleCallbackProvider>(),
new EmptyList<NamedWindowConsumerStreamSpec>(),
true,
selectSubscriberDescriptor,
namespaceScope,
services);
var statementProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
var stmtProvider = new StmtClassForgableStmtProvider(
aiFactoryProviderClassName,
statementProviderClassName,
informationals,
namespaceScope);
IList<StmtClassForgable> forgables = new List<StmtClassForgable>();
forgables.Add(fieldsForgable);
forgables.Add(aiFactoryForgable);
forgables.Add(stmtProvider);
return new StmtForgeMethodResult(
forgables,
new EmptyList<FilterSpecCompiled>(),
new EmptyList<ScheduleHandleCallbackProvider>(),
new EmptyList<NamedWindowConsumerStreamSpec>(),
new EmptyList<FilterSpecParamExprNodeForge>());
}
public StmtForgeMethodResult Make(
string @namespace,
string classPostfix,
StatementCompileTimeServices services)
{
string objectName = Register(services);
// define output event type
string statementEventTypeName = services.EventTypeNameGeneratorStatement.AnonymousTypeName;
EventTypeMetadata statementTypeMetadata = new EventTypeMetadata(
statementEventTypeName,
_base.ModuleName,
EventTypeTypeClass.STATEMENTOUT,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
EventType statementEventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
statementTypeMetadata,
EmptyDictionary <string, object> .Instance,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(statementEventType);
string statementFieldsClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
CodegenNamespaceScope namespaceScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
string aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementAIFactoryProvider), classPostfix);
StmtClassForgeable aiFactoryForgeable = AiFactoryForgable(aiFactoryProviderClassName, namespaceScope, statementEventType, objectName);
SelectSubscriberDescriptor selectSubscriberDescriptor = new SelectSubscriberDescriptor();
StatementInformationalsCompileTime informationals = StatementInformationalsUtil.GetInformationals(
_base,
EmptyList <FilterSpecCompiled> .Instance,
EmptyList <ScheduleHandleCallbackProvider> .Instance,
EmptyList <NamedWindowConsumerStreamSpec> .Instance,
false,
selectSubscriberDescriptor,
namespaceScope,
services);
informationals.Properties.Put(StatementProperty.CREATEOBJECTNAME, objectName);
string statementProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
StmtClassForgeableStmtProvider stmtProvider = new StmtClassForgeableStmtProvider(
aiFactoryProviderClassName,
statementProviderClassName,
informationals,
namespaceScope);
var stmtClassForgeableStmtFields = new StmtClassForgeableStmtFields(
statementFieldsClassName,
namespaceScope,
1);
IList <StmtClassForgeable> forgeables = new List <StmtClassForgeable>();
forgeables.Add(aiFactoryForgeable);
forgeables.Add(stmtProvider);
forgeables.Add(stmtClassForgeableStmtFields);
return(new StmtForgeMethodResult(
forgeables,
EmptyList <FilterSpecCompiled> .Instance,
EmptyList <ScheduleHandleCallbackProvider> .Instance,
EmptyList <NamedWindowConsumerStreamSpec> .Instance,
EmptyList <FilterSpecParamExprNodeForge> .Instance));
}
