public static ObjectArrayEventType MakeTransientOAType(
string enumMethod,
IDictionary <string, object> boxedPropertyTypes,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
return(MakeTransientOATypeInternal(
enumMethod,
boxedPropertyTypes,
CodeGenerationIDGenerator.GenerateClassNameUUID(),
statementRawInfo,
services));
}
public static ClassProvidedPrecompileResult CompileClassProvided(
IList<string> classTexts,
StatementCompileTimeServices compileTimeServices,
ClassProvidedPrecompileResult optionalPrior)
{
if (classTexts == null || classTexts.IsEmpty()) {
return ClassProvidedPrecompileResult.EMPTY;
}
if (!compileTimeServices.Configuration.Compiler.ByteCode.IsAllowInlinedClass) {
throw new ExprValidationException("Inlined-class compilation has been disabled by configuration");
}
var index = -1;
var existingTypes = new List<Type>(optionalPrior?.Classes ?? EmptyList<Type>.Instance);
var existingTypesSet = new HashSet<string>(existingTypes.Select(_ => _.FullName));
// In .NET our classes must be part of an assembly. This is different from Java, where each class
// can be compiled into its own .class file. Technically, we can create netmodules, but even then
// its a container for classes.
var compilables = new List<CompilableClass>();
foreach (var classText in classTexts.Where(_ => !string.IsNullOrWhiteSpace(_))) {
index++;
var classNameId = CodeGenerationIDGenerator.GenerateClassNameUUID();
var className = $"provided_{index}_{classNameId}";
compilables.Add(new CompilableClass(classText, className));
}
CompileResponse response;
try {
response = compileTimeServices.CompilerServices.Compile(
new CompileRequest(compilables, compileTimeServices.Services));
}
catch(CompilerServicesCompileException ex) {
throw HandleException(ex, "Failed to compile class");
}
foreach (var exportedType in response.Assembly.ExportedTypes) {
if (existingTypesSet.Contains(exportedType.FullName)) {
throw new ExprValidationException("Duplicate class by name '" + exportedType.FullName + "'");
}
existingTypes.Add(exportedType);
}
return new ClassProvidedPrecompileResult(response.Assembly, existingTypes);
}
public static string CompileQuery(
FAFQueryMethodForge query,
string classPostfix,
ModuleCompileTimeServices compileTimeServices,
out Assembly assembly)
{
var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementFields),
classPostfix);
var packageScope = new CodegenNamespaceScope(
compileTimeServices.Namespace,
statementFieldsClassName,
compileTimeServices.IsInstrumented());
var queryMethodProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(FAFQueryMethodProvider),
classPostfix);
var forgeablesQueryMethod = query.MakeForgeables(queryMethodProviderClassName, classPostfix, packageScope);
IList<StmtClassForgeable> forgeables = new List<StmtClassForgeable>(forgeablesQueryMethod);
forgeables.Add(new StmtClassForgeableStmtFields(statementFieldsClassName, packageScope, 0));
// forge with statement-fields last
var classes = new List<CodegenClass>(forgeables.Count);
foreach (var forgeable in forgeables) {
var clazz = forgeable.Forge(true, true);
classes.Add(clazz);
}
// assign the assembly (required for completeness)
assembly = null;
// compile with statement-field first
classes = classes
.OrderBy(c => c.ClassType.GetSortCode())
.ToList();
var container = compileTimeServices.Container;
var compiler = container
.RoslynCompiler()
.WithCodeLogging(compileTimeServices.Configuration.Compiler.Logging.IsEnableCode)
.WithCodeAuditDirectory(compileTimeServices.Configuration.Compiler.Logging.AuditDirectory)
.WithCodegenClasses(classes);
assembly = compiler.Compile();
return queryMethodProviderClassName;
}
public static EventPropertyGetter Compile(
this ICodegenContext codegenContext,
string engineURI,
ClassLoaderProvider classLoaderProvider,
EventPropertyGetterSPI getterSPI,
string propertyExpression)
{
var get = getterSPI.CodegenEventBeanGet(Ref("bean"), codegenContext);
var exists = getterSPI.CodegenEventBeanExists(Ref("bean"), codegenContext);
var fragment = getterSPI.CodegenEventBeanFragment(Ref("bean"), codegenContext);
var singleBeanParam = CodegenNamedParam.From(typeof(EventBean), "bean");
// For: public object Get(EventBean eventBean) ;
// For: public bool IsExistsProperty(EventBean eventBean);
// For: public object GetFragment(EventBean eventBean) ;
var getMethod = new CodegenMethod(typeof(object), "Get", singleBeanParam, null);
getMethod.Statements.MethodReturn(get);
var isExistsPropertyMethod = new CodegenMethod(typeof(bool), "IsExistsProperty", singleBeanParam, null);
isExistsPropertyMethod.Statements.MethodReturn(exists);
var fragmentMethod = new CodegenMethod(typeof(object), "GetFragment", singleBeanParam, null);
fragmentMethod.Statements.MethodReturn(fragment);
var clazz = new CodegenClass(
"com.espertech.esper.codegen.uri_" + engineURI,
typeof(EventPropertyGetter).Name + "_" + CodeGenerationIDGenerator.GenerateClass(),
typeof(EventPropertyGetter),
codegenContext.Members,
new [] { getMethod, isExistsPropertyMethod, fragmentMethod },
codegenContext.Methods
);
string debugInfo = null;
if (codegenContext.IsDebugEnabled)
{
debugInfo = getterSPI.GetType().FullName + " for property '" + propertyExpression + "'";
}
return(codegenContext.Compiler.Compile(
clazz, classLoaderProvider, typeof(EventPropertyGetter), debugInfo));
}
/// <summary>
/// Determines a classname for the json event representation.
/// </summary>
/// <param name="metadata"></param>
/// <param name="raw"></param>
/// <param name="optionalUnderlyingProvided"></param>
/// <returns></returns>
private static string DetermineJsonClassName(
EventTypeMetadata metadata,
StatementRawInfo raw,
Type optionalUnderlyingProvided)
{
if (optionalUnderlyingProvided != null)
{
return(optionalUnderlyingProvided.Name);
}
var jsonClassNameSimple = metadata.Name;
if (metadata.AccessModifier.IsPrivateOrTransient())
{
var uuid = CodeGenerationIDGenerator.GenerateClassNameUUID();
jsonClassNameSimple = $"{jsonClassNameSimple}__{uuid}";
}
else if (raw.ModuleName != null)
{
jsonClassNameSimple = $"{jsonClassNameSimple}__module_{raw.ModuleName}";
}
return(jsonClassNameSimple);
}
public static OnTriggerSetPlan HandleSetVariable(
string className,
CodegenNamespaceScope namespaceScope,
string classPostfix,
OnTriggerActivatorDesc activatorResult,
string optionalStreamName,
IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation,
OnTriggerSetDesc desc,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
StreamTypeService typeService = new StreamTypeServiceImpl(
new[] {activatorResult.ActivatorResultEventType},
new[] {optionalStreamName},
new[] {true},
false,
false);
var validationContext = new ExprValidationContextBuilder(typeService, @base.StatementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
// handle subselects
var subselectForges = SubSelectHelperForgePlanner.PlanSubSelect(
@base,
subselectActivation,
new[] {optionalStreamName},
new[] {activatorResult.ActivatorResultEventType},
new[] {activatorResult.TriggerEventTypeName},
services);
// validate assignments
foreach (var assignment in desc.Assignments) {
var validated = ExprNodeUtilityValidate.GetValidatedAssignment(assignment, validationContext);
assignment.Expression = validated;
}
// create read-write logic
var variableReadWritePackageForge = new VariableReadWritePackageForge(desc.Assignments, services);
// plan table access
var tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(@base.StatementSpec.TableAccessNodes);
// create output event 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 eventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
eventTypeMetadata,
variableReadWritePackageForge.VariableTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(eventType);
// 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[] {eventType},
new[] {"trigger_stream"},
new[] {true},
false,
false);
var resultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
new ResultSetSpec(defaultSelectAllSpec),
streamTypeService,
null,
new bool[1],
false,
@base.ContextPropertyRegistry,
false,
false,
@base.StatementRawInfo,
services);
var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ResultSetProcessorFactoryProvider),
classPostfix);
var forge = new StatementAgentInstanceFactoryOnTriggerSetForge(
activatorResult.Activator,
eventType,
subselectForges,
tableAccessForges,
variableReadWritePackageForge,
classNameRSP);
IList<StmtClassForgable> forgables = new List<StmtClassForgable>();
forgables.Add(
new StmtClassForgableRSPFactoryProvider(
classNameRSP,
resultSetProcessor,
namespaceScope,
@base.StatementRawInfo));
var onTrigger = new StmtClassForgableAIFactoryProviderOnTrigger(className, namespaceScope, forge);
return new OnTriggerSetPlan(onTrigger, forgables, resultSetProcessor.SelectSubscriberDescriptor);
}
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 EPCompiled Compile(
Compilable compilable,
ModuleCompileTimeServices services,
CompilerArguments args)
{
var compileTimeServices = new StatementCompileTimeServices(0, services);
var walkResult = CompilerHelperSingleEPL.ParseCompileInlinedClassesWalk(compilable, compileTimeServices);
var raw = walkResult.StatementSpecRaw;
var statementType = StatementTypeUtil.GetStatementType(raw);
if (statementType != StatementType.SELECT) {
// the fire-and-forget spec is null for "select" and populated for I/U/D
throw new StatementSpecCompileException(
"Provided EPL expression is a continuous query expression (not an on-demand query)",
compilable.ToEPL());
}
var annotations = AnnotationUtil.CompileAnnotations(
raw.Annotations,
services.ImportServiceCompileTime,
compilable);
// walk subselects, alias expressions, declared expressions, dot-expressions
var visitor = StatementSpecRawWalkerSubselectAndDeclaredDot.WalkSubselectAndDeclaredDotExpr(raw);
// compile context descriptor
ContextCompileTimeDescriptor contextDescriptor = null;
var optionalContextName = raw.OptionalContextName;
if (optionalContextName != null) {
var detail = services.ContextCompileTimeResolver.GetContextInfo(optionalContextName);
if (detail == null) {
throw new StatementSpecCompileException(
"Context by name '" + optionalContextName + "' could not be found",
compilable.ToEPL());
}
contextDescriptor = new ContextCompileTimeDescriptor(
optionalContextName,
detail.ContextModuleName,
detail.ContextVisibility,
new ContextPropertyRegistry(detail),
detail.ValidationInfos);
}
var statementNameFromAnnotation = GetNameFromAnnotation(annotations);
var statementName = statementNameFromAnnotation == null ? GetDefaultStatementName() : statementNameFromAnnotation.Trim();
var statementRawInfo = new StatementRawInfo(
0,
statementName,
annotations,
statementType.Value,
contextDescriptor,
null,
compilable,
null);
StatementSpecCompiledDesc compiledDesc = StatementRawCompiler.Compile(
raw,
compilable,
false,
true,
annotations,
visitor.Subselects,
new List<ExprTableAccessNode>(raw.TableExpressions),
statementRawInfo,
compileTimeServices);
StatementSpecCompiled specCompiled = compiledDesc.Compiled;
var fafSpec = specCompiled.Raw.FireAndForgetSpec;
//var @namespace = "generated";
var classPostfix = IdentifierUtil.GetIdentifierMayStartNumeric(statementName);
EPCompiledManifest manifest;
Assembly assembly;
FAFQueryMethodForge query;
if (specCompiled.Raw.InsertIntoDesc != null) {
query = new FAFQueryMethodIUDInsertIntoForge(
specCompiled,
compilable,
statementRawInfo,
compileTimeServices);
}
else if (fafSpec == null) { // null indicates a select-statement, same as continuous query
var desc = new FAFQueryMethodSelectDesc(
specCompiled,
compilable,
statementRawInfo,
compileTimeServices);
var classNameResultSetProcessor =
CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ResultSetProcessorFactoryProvider),
classPostfix);
query = new FAFQueryMethodSelectForge(desc, classNameResultSetProcessor, statementRawInfo);
}
else if (fafSpec is FireAndForgetSpecDelete) {
query = new FAFQueryMethodIUDDeleteForge(
specCompiled,
compilable,
statementRawInfo,
compileTimeServices);
}
else if (fafSpec is FireAndForgetSpecUpdate) {
query = new FAFQueryMethodIUDUpdateForge(
specCompiled,
compilable,
statementRawInfo,
compileTimeServices);
}
else {
throw new IllegalStateException("Unrecognized FAF code " + fafSpec);
}
// verify substitution parameters
VerifySubstitutionParams(raw.SubstitutionParameters);
try {
manifest = CompileToAssembly(query, classPostfix, args.Options, services, out assembly);
}
catch (EPCompileException) {
throw;
}
catch (Exception ex) {
throw new EPCompileException(
"Unexpected exception compiling module: " + ex.Message,
ex,
new EmptyList<EPCompileExceptionItem>());
}
return new EPCompiled(new [] { assembly }, manifest);
}
private static string MakeFAFProvider(
string queryMethodProviderClassName,
string classPostfix,
ModuleCompileTimeServices compileTimeServices,
out Assembly assembly)
{
var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementFields), classPostfix);
var namespaceScope = new CodegenNamespaceScope(
compileTimeServices.Namespace, statementFieldsClassName, compileTimeServices.IsInstrumented());
var fafProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(FAFProvider), classPostfix);
var classScope = new CodegenClassScope(true, namespaceScope, fafProviderClassName);
var methods = new CodegenClassMethods();
var properties = new CodegenClassProperties();
// --------------------------------------------------------------------------------
// Add statementFields
// --------------------------------------------------------------------------------
var ctor = new CodegenCtor(
typeof(CompilerHelperFAFProvider),
classScope,
new List<CodegenTypedParam>());
ctor.Block.AssignRef(Ref("statementFields"), NewInstanceInner(statementFieldsClassName));
// initialize-event-types
var initializeEventTypesMethod = MakeInitEventTypes(classScope, compileTimeServices);
// initialize-query
var initializeQueryMethod = CodegenMethod
.MakeMethod(
typeof(void),
typeof(EPCompilerImpl),
CodegenSymbolProviderEmpty.INSTANCE,
classScope)
.AddParam(
typeof(EPStatementInitServices),
EPStatementInitServicesConstants.REF.Ref);
initializeQueryMethod.Block.AssignMember(
MEMBERNAME_QUERY_METHOD_PROVIDER,
NewInstanceInner(queryMethodProviderClassName, EPStatementInitServicesConstants.REF, Ref("statementFields")));
// get-execute
var queryMethodProviderProperty = CodegenProperty.MakePropertyNode(
typeof(FAFQueryMethodProvider),
typeof(EPCompilerImpl),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
queryMethodProviderProperty.GetterBlock.BlockReturn(Ref(MEMBERNAME_QUERY_METHOD_PROVIDER));
// provide module dependencies
var moduleDependenciesProperty = CodegenProperty.MakePropertyNode(
typeof(ModuleDependenciesRuntime),
typeof(EPCompilerImpl),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
moduleDependenciesProperty.GetterBlock
.BlockReturn(compileTimeServices.ModuleDependencies.Make(
initializeQueryMethod, classScope));
// build stack
CodegenStackGenerator.RecursiveBuildStack(moduleDependenciesProperty, "ModuleDependencies", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(initializeEventTypesMethod, "InitializeEventTypes", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(initializeQueryMethod, "InitializeQuery", methods, properties);
CodegenStackGenerator.RecursiveBuildStack(queryMethodProviderProperty, "QueryMethodProvider", methods, properties);
IList<CodegenTypedParam> members = new List<CodegenTypedParam>();
members.Add(new CodegenTypedParam(statementFieldsClassName, null, "statementFields"));
var typedParam = new CodegenTypedParam(typeof(FAFQueryMethodProvider), MEMBERNAME_QUERY_METHOD_PROVIDER);
typedParam.IsReadonly = false;
members.Add(typedParam);
var clazz = new CodegenClass(
CodegenClassType.FAFPROVIDER,
typeof(FAFProvider),
fafProviderClassName,
classScope,
members,
ctor,
methods,
properties,
new EmptyList<CodegenInnerClass>());
var container = compileTimeServices.Container;
var compiler = container
.RoslynCompiler()
.WithCodeLogging(compileTimeServices.Configuration.Compiler.Logging.IsEnableCode)
.WithCodeAuditDirectory(compileTimeServices.Configuration.Compiler.Logging.AuditDirectory)
.WithCodegenClasses(new List<CodegenClass>() { clazz });
assembly = compiler.Compile();
return CodeGenerationIDGenerator.GenerateClassNameWithNamespace(
compileTimeServices.Namespace,
typeof(FAFProvider),
classPostfix);
}
public string GetClassNameMKSerde(string classPostfix)
{
return CodeGenerationIDGenerator.GenerateClassNameWithUUID(
typeof(DataInputOutputSerde<>), classPostfix, uuid);
}
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));
}
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>());
}
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));
}
public static CompilableItem CompileItem(
Compilable compilable,
string optionalModuleName,
string moduleIdentPostfix,
int statementNumber,
ISet<string> statementNames,
ModuleCompileTimeServices moduleCompileTimeServices,
CompilerOptions compilerOptions,
out Assembly assembly)
{
var compileTimeServices = new StatementCompileTimeServices(statementNumber, moduleCompileTimeServices);
// Stage 0 - parse and compile-inline-classes and walk statement
var walked = ParseCompileInlinedClassesWalk(compilable, compileTimeServices);
var raw = walked.StatementSpecRaw;
string classNameCreateClass = null;
if (raw.CreateClassProvided != null) {
classNameCreateClass = DetermineClassNameCreateClass(walked.ClassesInlined);
}
try {
// Stage 2(a) - precompile: compile annotations
var annotations = AnnotationUtil.CompileAnnotations(
raw.Annotations,
compileTimeServices.ImportServiceCompileTime,
compilable);
// Stage 2(b) - walk subselects, alias expressions, declared expressions, dot-expressions
ExprNodeSubselectDeclaredDotVisitor visitor;
try {
visitor = StatementSpecRawWalkerSubselectAndDeclaredDot.WalkSubselectAndDeclaredDotExpr(raw);
}
catch (ExprValidationException ex) {
throw new StatementSpecCompileException(ex.Message, compilable.ToEPL());
}
var subselectNodes = visitor.Subselects;
// Determine a statement name
var statementNameProvided = GetNameFromAnnotation(annotations);
if (compilerOptions.StatementName != null) {
var assignedName = compilerOptions.StatementName.Invoke(
new StatementNameContext(
() => compilable.ToEPL(),
statementNameProvided,
optionalModuleName,
annotations,
statementNumber));
if (assignedName != null) {
statementNameProvided = assignedName;
}
}
var statementName = statementNameProvided ?? Convert.ToString(statementNumber);
if (statementNames.Contains(statementName)) {
var count = 1;
var newStatementName = statementName + "-" + count;
while (statementNames.Contains(newStatementName)) {
count++;
newStatementName = statementName + "-" + count;
}
statementName = newStatementName;
}
statementName = statementName.Trim();
statementNames.Add(statementName);
// Determine table access nodes
var tableAccessNodes = DetermineTableAccessNodes(raw.TableExpressions, visitor);
// compile scripts once in this central place, may also compile later in expression
ScriptValidationPrecompileUtil.ValidateScripts(
raw.ScriptExpressions,
raw.ExpressionDeclDesc,
compileTimeServices);
// Determine subselects for compilation, and lambda-expression shortcut syntax for named windows
if (!visitor.ChainedExpressionsDot.IsEmpty()) {
RewriteNamedWindowSubselect(
visitor.ChainedExpressionsDot,
subselectNodes,
compileTimeServices.NamedWindowCompileTimeResolver);
}
// Stage 2(c) compile context descriptor
ContextCompileTimeDescriptor contextDescriptor = null;
var optionalContextName = raw.OptionalContextName;
if (optionalContextName != null) {
var detail = compileTimeServices.ContextCompileTimeResolver.GetContextInfo(optionalContextName);
if (detail == null) {
throw new StatementSpecCompileException(
"Context by name '" + optionalContextName + "' could not be found",
compilable.ToEPL());
}
contextDescriptor = new ContextCompileTimeDescriptor(
optionalContextName,
detail.ContextModuleName,
detail.ContextVisibility,
new ContextPropertyRegistry(detail),
detail.ValidationInfos);
}
// Stage 2(d) compile raw statement spec
var statementType = StatementTypeUtil.GetStatementType(raw).Value;
var statementRawInfo = new StatementRawInfo(
statementNumber,
statementName,
annotations,
statementType,
contextDescriptor,
raw.IntoTableSpec?.Name,
compilable,
optionalModuleName);
var compiledDesc = StatementRawCompiler.Compile(
raw,
compilable,
false,
false,
annotations,
subselectNodes,
tableAccessNodes,
statementRawInfo,
compileTimeServices);
var specCompiled = compiledDesc.Compiled;
var statementIdentPostfix = IdentifierUtil.GetIdentifierMayStartNumeric(statementName);
// get compile-time user object
object userObjectCompileTime = null;
if (compilerOptions.StatementUserObject != null) {
userObjectCompileTime = compilerOptions.StatementUserObject.Invoke(
new StatementUserObjectContext(
() => compilable.ToEPL(),
statementName,
optionalModuleName,
annotations,
statementNumber));
}
// handle hooks
HandleStatementCompileHook(annotations, compileTimeServices, specCompiled);
// Stage 3(a) - statement-type-specific forge building
var @base = new StatementBaseInfo(
compilable,
specCompiled,
userObjectCompileTime,
statementRawInfo,
optionalModuleName);
StmtForgeMethod forgeMethod;
if (raw.UpdateDesc != null) {
forgeMethod = new StmtForgeMethodUpdate(@base);
}
else if (raw.OnTriggerDesc != null) {
forgeMethod = new StmtForgeMethodOnTrigger(@base);
}
else if (raw.CreateIndexDesc != null) {
forgeMethod = new StmtForgeMethodCreateIndex(@base);
}
else if (raw.CreateVariableDesc != null) {
forgeMethod = new StmtForgeMethodCreateVariable(@base);
}
else if (raw.CreateDataFlowDesc != null) {
forgeMethod = new StmtForgeMethodCreateDataflow(@base);
}
else if (raw.CreateTableDesc != null) {
forgeMethod = new StmtForgeMethodCreateTable(@base);
}
else if (raw.CreateExpressionDesc != null) {
forgeMethod = new StmtForgeMethodCreateExpression(@base);
}
else if (raw.CreateClassProvided != null) {
forgeMethod = new StmtForgeMethodCreateClass(@base, walked.ClassesInlined, classNameCreateClass);
}
else if (raw.CreateWindowDesc != null) {
forgeMethod = new StmtForgeMethodCreateWindow(@base);
}
else if (raw.CreateContextDesc != null) {
forgeMethod = new StmtForgeMethodCreateContext(@base);
}
else if (raw.CreateSchemaDesc != null) {
forgeMethod = new StmtForgeMethodCreateSchema(@base);
}
else {
forgeMethod = new StmtForgeMethodSelect(@base);
}
// check context-validity conditions for this statement
if (contextDescriptor != null) {
try {
foreach (var validator in contextDescriptor.ValidationInfos) {
validator.ValidateStatement(
contextDescriptor.ContextName,
specCompiled,
compileTimeServices);
}
}
catch (ExprValidationException ex) {
throw new StatementSpecCompileException(ex.Message, ex, compilable.ToEPL());
}
}
// Stage 3(b) - forge-factory-to-forge
var classPostfix = moduleIdentPostfix + "_" + statementIdentPostfix;
var forgeables = new List<StmtClassForgeable>();
// add forgeables from filter-related processing i.e. multikeys
foreach (var additional in compiledDesc.AdditionalForgeables) {
var namespaceScope = new CodegenNamespaceScope(compileTimeServices.Namespace, null, false);
forgeables.Add(additional.Make(namespaceScope, classPostfix));
}
var filterSpecCompileds = new List<FilterSpecCompiled>();
var scheduleHandleCallbackProviders = new List<ScheduleHandleCallbackProvider>();
var namedWindowConsumers = new List<NamedWindowConsumerStreamSpec>();
var filterBooleanExpressions = new List<FilterSpecParamExprNodeForge>();
var result = forgeMethod.Make(compileTimeServices.Namespace, classPostfix, compileTimeServices);
forgeables.AddAll(result.Forgeables);
VerifyForgeables(forgeables);
filterSpecCompileds.AddAll(result.Filtereds);
scheduleHandleCallbackProviders.AddAll(result.Scheduleds);
namedWindowConsumers.AddAll(result.NamedWindowConsumers);
filterBooleanExpressions.AddAll(result.FilterBooleanExpressions);
// Stage 3(c) - filter assignments: assign filter callback ids and filter-path-num for boolean expressions
var filterId = -1;
foreach (var provider in filterSpecCompileds) {
var assigned = ++filterId;
provider.FilterCallbackId = assigned;
}
// Stage 3(d) - schedule assignments: assign schedule callback ids
var scheduleId = 0;
foreach (var provider in scheduleHandleCallbackProviders) {
provider.ScheduleCallbackId = scheduleId++;
}
// Stage 3(e) - named window consumers: assign consumer id
var namedWindowConsumerId = 0;
foreach (var provider in namedWindowConsumers) {
provider.NamedWindowConsumerId = namedWindowConsumerId++;
}
// Stage 3(f) - filter boolean expression id assignment
var filterBooleanExprNum = 0;
foreach (var expr in filterBooleanExpressions) {
expr.FilterBoolExprId = filterBooleanExprNum++;
}
// Stage 3(f) - verify substitution parameters
VerifySubstitutionParams(raw.SubstitutionParameters);
// Stage 4 - forge-to-class (forge with statement-fields last)
var classes = forgeables
.Select(forgeable => forgeable.Forge(true, false))
.ToList();
// Stage 5 - refactor methods to make sure the constant pool does not grow too large for any given class
CompilerHelperRefactorToStaticMethods.RefactorMethods(
classes, compileTimeServices.Configuration.Compiler.ByteCode.MaxMethodsPerClass);
// Stage 6 - sort to make the "fields" class first and all the rest later
var sorted = classes
.OrderBy(c => c.ClassType.GetSortCode())
.ToList();
// We are making sure JsonEventType receives the underlying class itself
CompilableItemPostCompileLatch postCompile = CompilableItemPostCompileLatchDefault.INSTANCE;
foreach (var eventType in compileTimeServices.EventTypeCompileTimeRegistry.NewTypesAdded) {
if (eventType is JsonEventType) {
postCompile = new CompilableItemPostCompileLatchJson(
compileTimeServices.EventTypeCompileTimeRegistry.NewTypesAdded,
compileTimeServices.ParentClassLoader);
break;
}
}
var container = compileTimeServices.Container;
var compiler = container
.RoslynCompiler()
.WithCodeLogging(compileTimeServices.Configuration.Compiler.Logging.IsEnableCode)
.WithCodeAuditDirectory(compileTimeServices.Configuration.Compiler.Logging.AuditDirectory)
.WithCodegenClasses(sorted);
assembly = compiler.Compile();
string statementProviderClassName = CodeGenerationIDGenerator.GenerateClassNameWithNamespace(
compileTimeServices.Namespace,
typeof(StatementProvider),
classPostfix);
var additionalClasses = new HashSet<Type>();
additionalClasses.AddAll(walked.ClassesInlined.Classes);
compileTimeServices.ClassProvidedCompileTimeResolver.AddTo(additionalClasses);
compileTimeServices.ClassProvidedCompileTimeRegistry.AddTo(additionalClasses);
return new CompilableItem(
statementProviderClassName,
classes,
postCompile,
additionalClasses);
}
catch (StatementSpecCompileException) {
throw;
}
catch (ExprValidationException ex) {
throw new StatementSpecCompileException(ex.Message, ex, compilable.ToEPL());
}
catch (EPException ex) {
throw new StatementSpecCompileException(ex.Message, ex, compilable.ToEPL());
}
catch (Exception ex) {
var text = ex.Message ?? ex.GetType().FullName;
throw new StatementSpecCompileException(text, ex, compilable.ToEPL());
}
}
private StmtForgeMethodResult Build(
string @namespace,
string classPostfix,
StatementCompileTimeServices services)
{
var compileResult = CreateWindowUtil.HandleCreateWindow(@base, services);
var namedWindowType = compileResult.FilterSpecCompiled.FilterForEventType;
// view must be non-empty list
var createWindowDesc = @base.StatementSpec.Raw.CreateWindowDesc;
if (createWindowDesc.ViewSpecs.IsEmpty()) {
throw new ExprValidationException(NamedWindowManagementServiceConstants.ERROR_MSG_DATAWINDOWS);
}
if (services.NamedWindowCompileTimeResolver.Resolve(createWindowDesc.WindowName) != null) {
throw new ExprValidationException(
"Named window named '" + createWindowDesc.WindowName + "' has already been declared");
}
// build forge
var activator = new ViewableActivatorFilterForge(compileResult.FilterSpecCompiled, false, 0, false, -1);
var viewSpecs = createWindowDesc.ViewSpecs;
var viewArgs = new ViewFactoryForgeArgs(
0,
false,
-1,
createWindowDesc.StreamSpecOptions,
createWindowDesc.WindowName,
@base.StatementRawInfo,
services);
var viewForges = ViewFactoryForgeUtil.CreateForges(viewSpecs.ToArray(), viewArgs, namedWindowType);
IList<ScheduleHandleCallbackProvider> schedules = new List<ScheduleHandleCallbackProvider>();
ViewFactoryForgeUtil.DetermineViewSchedules(viewForges, schedules);
VerifyDataWindowViewFactoryChain(viewForges);
var optionalUniqueKeyProps =
StreamJoinAnalysisResultCompileTime.GetUniqueCandidateProperties(
viewForges,
@base.StatementSpec.Annotations);
var uniqueKeyProArray = optionalUniqueKeyProps == null ? null : optionalUniqueKeyProps.ToArray();
NamedWindowMetaData insertFromNamedWindow = null;
ExprNode insertFromFilter = null;
if (createWindowDesc.IsInsert || createWindowDesc.InsertFilter != null) {
var name = createWindowDesc.AsEventTypeName;
insertFromNamedWindow = services.NamedWindowCompileTimeResolver.Resolve(name);
if (insertFromNamedWindow == null) {
throw new ExprValidationException(
"A named window by name '" +
name +
"' could not be located, the insert-keyword requires an existing named window");
}
insertFromFilter = createWindowDesc.InsertFilter;
if (insertFromFilter != null) {
var checkMinimal = ExprNodeUtilityValidate.IsMinimalExpression(insertFromFilter);
if (checkMinimal != null) {
throw new ExprValidationException("Create window where-clause may not have " + checkMinimal);
}
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
insertFromNamedWindow.EventType,
name,
true);
var validationContext = new ExprValidationContextBuilder(
streamTypeService,
@base.StatementRawInfo,
services).Build();
insertFromFilter = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.CREATEWINDOWFILTER,
insertFromFilter,
validationContext);
}
}
// handle output format
var defaultSelectAllSpec = new StatementSpecCompiled();
defaultSelectAllSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard());
defaultSelectAllSpec.Raw.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH;
StreamTypeService typeService = new StreamTypeServiceImpl(
new[] {namedWindowType},
new[] {createWindowDesc.WindowName},
new[] {true},
false,
false);
var resultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
new ResultSetSpec(defaultSelectAllSpec),
typeService,
null,
new bool[1],
false,
@base.ContextPropertyRegistry,
false,
false,
@base.StatementRawInfo,
services);
var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ResultSetProcessorFactoryProvider),
classPostfix);
var selectSubscriberDescriptor = resultSetProcessor.SelectSubscriberDescriptor;
var forge = new StatementAgentInstanceFactoryCreateNWForge(
activator,
createWindowDesc.WindowName,
viewForges,
insertFromNamedWindow,
insertFromFilter,
compileResult.AsEventType,
classNameRSP);
// add named window
var isBatchingDataWindow = DetermineBatchingDataWindow(viewForges);
var virtualDataWindow = viewForges[0] is VirtualDWViewFactoryForge;
var isEnableIndexShare = virtualDataWindow ||
HintEnum.ENABLE_WINDOW_SUBQUERY_INDEXSHARE.GetHint(
@base.StatementSpec.Annotations) !=
null;
var metaData = new NamedWindowMetaData(
namedWindowType,
@base.ModuleName,
@base.ContextName,
uniqueKeyProArray,
isBatchingDataWindow,
isEnableIndexShare,
compileResult.AsEventType,
virtualDataWindow);
services.NamedWindowCompileTimeRegistry.NewNamedWindow(metaData);
// build forge list
IList<StmtClassForgable> forgables = new List<StmtClassForgable>(2);
var statementFieldsClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
var packageScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
forgables.Add(
new StmtClassForgableRSPFactoryProvider(
classNameRSP,
resultSetProcessor,
packageScope,
@base.StatementRawInfo));
var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
var aiFactoryForgable = new StmtClassForgableAIFactoryProviderCreateNW(
aiFactoryProviderClassName,
packageScope,
forge,
createWindowDesc.WindowName);
forgables.Add(aiFactoryForgable);
var statementProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
var informationals = StatementInformationalsUtil.GetInformationals(
@base,
Collections.SingletonList(compileResult.FilterSpecCompiled),
schedules,
new EmptyList<NamedWindowConsumerStreamSpec>(),
true,
selectSubscriberDescriptor,
packageScope,
services);
forgables.Add(
new StmtClassForgableStmtProvider(
aiFactoryProviderClassName,
statementProviderClassName,
informationals,
packageScope));
forgables.Add(new StmtClassForgableStmtFields(statementFieldsClassName, packageScope, 1));
return new StmtForgeMethodResult(
forgables,
Collections.SingletonList(compileResult.FilterSpecCompiled),
schedules,
new EmptyList<NamedWindowConsumerStreamSpec>(),
new EmptyList<FilterSpecParamExprNodeForge>());
}
public static StmtForgeMethodSelectResult Make(
IContainer container,
bool dataflowOperator,
string @namespace,
string classPostfix,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
var filterSpecCompileds = new List<FilterSpecCompiled>();
var scheduleHandleCallbackProviders = new List<ScheduleHandleCallbackProvider>();
var namedWindowConsumers = new List<NamedWindowConsumerStreamSpec>();
var statementSpec = @base.StatementSpec;
var additionalForgeables = new List<StmtClassForgeableFactory>();
var streamNames = StatementForgeMethodSelectUtil.DetermineStreamNames(statementSpec.StreamSpecs);
var numStreams = streamNames.Length;
if (numStreams == 0) {
throw new ExprValidationException("The from-clause is required but has not been specified");
}
// first we create streams for subselects, if there are any
SubSelectActivationDesc subSelectActivationDesc = SubSelectHelperActivations.CreateSubSelectActivation(
filterSpecCompileds, namedWindowConsumers, @base, services);
IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation = subSelectActivationDesc.Subselects;
additionalForgeables.AddAll(subSelectActivationDesc.AdditionalForgeables);
// verify for joins that required views are present
StreamJoinAnalysisResultCompileTime joinAnalysisResult = StatementForgeMethodSelectUtil.VerifyJoinViews(statementSpec);
var streamEventTypes = new EventType[statementSpec.StreamSpecs.Length];
var eventTypeNames = new string[numStreams];
var isNamedWindow = new bool[numStreams];
var viewableActivatorForges = new ViewableActivatorForge[numStreams];
var viewForges = new IList<ViewFactoryForge>[numStreams];
var historicalEventViewables = new HistoricalEventViewableForge[numStreams];
for (var stream = 0; stream < numStreams; stream++) {
var streamSpec = statementSpec.StreamSpecs[stream];
var isCanIterateUnbound = streamSpec.ViewSpecs.Length == 0 &&
(services.Configuration.Compiler.ViewResources.IsIterableUnbound ||
AnnotationUtil.HasAnnotation(statementSpec.Annotations, typeof(IterableUnboundAttribute)));
var args = new ViewFactoryForgeArgs(
stream,
false,
-1,
streamSpec.Options,
null,
@base.StatementRawInfo,
services);
if (dataflowOperator) {
var dfResult = HandleDataflowActivation(args, streamSpec);
streamEventTypes[stream] = dfResult.StreamEventType;
eventTypeNames[stream] = dfResult.EventTypeName;
viewableActivatorForges[stream] = dfResult.ViewableActivatorForge;
viewForges[stream] = dfResult.ViewForges;
additionalForgeables.AddAll(dfResult.AdditionalForgeables);
}
else if (streamSpec is FilterStreamSpecCompiled) {
var filterStreamSpec = (FilterStreamSpecCompiled) statementSpec.StreamSpecs[stream];
var filterSpecCompiled = filterStreamSpec.FilterSpecCompiled;
streamEventTypes[stream] = filterSpecCompiled.ResultEventType;
eventTypeNames[stream] = filterStreamSpec.FilterSpecCompiled.FilterForEventTypeName;
viewableActivatorForges[stream] = new ViewableActivatorFilterForge(
filterSpecCompiled,
isCanIterateUnbound,
stream,
false,
-1);
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, streamEventTypes[stream]);
viewForges[stream] = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
filterSpecCompileds.Add(filterSpecCompiled);
}
else if (streamSpec is PatternStreamSpecCompiled) {
var patternStreamSpec = (PatternStreamSpecCompiled) streamSpec;
var forges = patternStreamSpec.Root.CollectFactories();
foreach (var forgeNode in forges) {
forgeNode.CollectSelfFilterAndSchedule(filterSpecCompileds, scheduleHandleCallbackProviders);
}
var patternType = ViewableActivatorPatternForge.MakeRegisterPatternType(
@base,
stream,
patternStreamSpec,
services);
var patternContext = new PatternContext(0, patternStreamSpec.MatchedEventMapMeta, false, -1, false);
viewableActivatorForges[stream] = new ViewableActivatorPatternForge(
patternType,
patternStreamSpec,
patternContext,
isCanIterateUnbound);
streamEventTypes[stream] = patternType;
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, patternType);
viewForges[stream] = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
}
else if (streamSpec is NamedWindowConsumerStreamSpec) {
var namedSpec = (NamedWindowConsumerStreamSpec) streamSpec;
var namedWindow =
services.NamedWindowCompileTimeResolver.Resolve(namedSpec.NamedWindow.EventType.Name);
var namedWindowType = namedWindow.EventType;
if (namedSpec.OptPropertyEvaluator != null) {
namedWindowType = namedSpec.OptPropertyEvaluator.FragmentEventType;
}
var typesFilterValidation = new StreamTypeServiceImpl(
namedWindowType,
namedSpec.OptionalStreamName,
false);
var filterSingle =
ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(namedSpec.FilterExpressions);
var filterQueryGraph = EPLValidationUtil.ValidateFilterGetQueryGraphSafe(
filterSingle,
typesFilterValidation,
@base.StatementRawInfo,
services);
namedWindowConsumers.Add(namedSpec);
viewableActivatorForges[stream] = new ViewableActivatorNamedWindowForge(
namedSpec,
namedWindow,
filterSingle,
filterQueryGraph,
true,
namedSpec.OptPropertyEvaluator);
streamEventTypes[stream] = namedWindowType;
viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>();
joinAnalysisResult.SetNamedWindowsPerStream(stream, namedWindow);
eventTypeNames[stream] = namedSpec.NamedWindow.EventType.Name;
isNamedWindow[stream] = true;
// Consumers to named windows cannot declare a data window view onto the named window to avoid duplicate remove streams
ViewFactoryForgeDesc viewForgeDesc = ViewFactoryForgeUtil.CreateForges(streamSpec.ViewSpecs, args, namedWindowType);
viewForges[stream] = viewForgeDesc.Forges;
additionalForgeables.AddAll(viewForgeDesc.MultikeyForges);
EPStatementStartMethodHelperValidate.ValidateNoDataWindowOnNamedWindow(viewForges[stream]);
}
else if (streamSpec is TableQueryStreamSpec) {
ValidateNoViews(streamSpec, "Table data");
var tableStreamSpec = (TableQueryStreamSpec) streamSpec;
if (numStreams > 1 && tableStreamSpec.FilterExpressions.Count > 0) {
throw new ExprValidationException(
"Joins with tables do not allow table filter expressions, please add table filters to the where-clause instead");
}
var table = tableStreamSpec.Table;
EPLValidationUtil.ValidateContextName(
true,
table.TableName,
table.OptionalContextName,
statementSpec.Raw.OptionalContextName,
false);
var filter =
ExprNodeUtilityMake.ConnectExpressionsByLogicalAndWhenNeeded(tableStreamSpec.FilterExpressions);
viewableActivatorForges[stream] = new ViewableActivatorTableForge(table, filter);
viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>();
eventTypeNames[stream] = tableStreamSpec.Table.TableName;
streamEventTypes[stream] = tableStreamSpec.Table.InternalEventType;
joinAnalysisResult.SetTablesForStream(stream, table);
if (tableStreamSpec.Options.IsUnidirectional) {
throw new ExprValidationException("Tables cannot be marked as unidirectional");
}
if (tableStreamSpec.Options.IsRetainIntersection || tableStreamSpec.Options.IsRetainUnion) {
throw new ExprValidationException("Tables cannot be marked with retain");
}
}
else if (streamSpec is DBStatementStreamSpec) {
ValidateNoViews(streamSpec, "Historical data");
var sqlStreamSpec = (DBStatementStreamSpec) streamSpec;
var typeConversionHook = (SQLColumnTypeConversion) ImportUtil.GetAnnotationHook(
statementSpec.Annotations,
HookType.SQLCOL,
typeof(SQLColumnTypeConversion),
services.ImportServiceCompileTime);
var outputRowConversionHook = (SQLOutputRowConversion) ImportUtil.GetAnnotationHook(
statementSpec.Annotations,
HookType.SQLROW,
typeof(SQLOutputRowConversion),
services.ImportServiceCompileTime);
var viewable = HistoricalEventViewableDatabaseForgeFactory.CreateDBStatementView(
stream,
sqlStreamSpec,
typeConversionHook,
outputRowConversionHook,
@base,
services,
statementSpec.Annotations);
streamEventTypes[stream] = viewable.EventType;
viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>();
viewableActivatorForges[stream] = new ViewableActivatorHistoricalForge(viewable);
historicalEventViewables[stream] = viewable;
}
else if (streamSpec is MethodStreamSpec) {
ValidateNoViews(streamSpec, "Method data");
var methodStreamSpec = (MethodStreamSpec) streamSpec;
var viewable = HistoricalEventViewableMethodForgeFactory.CreateMethodStatementView(
stream,
methodStreamSpec,
@base,
services);
historicalEventViewables[stream] = viewable;
streamEventTypes[stream] = viewable.EventType;
viewForges[stream] = Collections.GetEmptyList<ViewFactoryForge>();
viewableActivatorForges[stream] = new ViewableActivatorHistoricalForge(viewable);
historicalEventViewables[stream] = viewable;
}
else {
throw new IllegalStateException("Unrecognized stream " + streamSpec);
}
// plan serde for iterate-unbound
if (isCanIterateUnbound) {
var serdeForgeables = SerdeEventTypeUtility.Plan(
streamEventTypes[stream], @base.StatementRawInfo, services.SerdeEventTypeRegistry, services.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
}
// handle match-recognize pattern
if (statementSpec.Raw.MatchRecognizeSpec != null) {
if (numStreams > 1) {
throw new ExprValidationException("Joins are not allowed when using match-recognize");
}
if (joinAnalysisResult.TablesPerStream[0] != null) {
throw new ExprValidationException("Tables cannot be used with match-recognize");
}
var isUnbound = viewForges[0].IsEmpty() &&
!(statementSpec.StreamSpecs[0] is NamedWindowConsumerStreamSpec);
var eventType = viewForges[0].IsEmpty()
? streamEventTypes[0]
: viewForges[0][(viewForges[0].Count - 1)].EventType;
var plan = RowRecogNFAViewPlanUtil.ValidateAndPlan(services.Container, eventType, isUnbound, @base, services);
var forge = new RowRecogNFAViewFactoryForge(plan.Forge);
additionalForgeables.AddAll(plan.AdditionalForgeables);
scheduleHandleCallbackProviders.Add(forge);
viewForges[0].Add(forge);
var serdeForgeables = SerdeEventTypeUtility.Plan(
eventType, @base.StatementRawInfo, services.SerdeEventTypeRegistry, services.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
// Obtain event types from view factory chains
for (var i = 0; i < viewForges.Length; i++) {
streamEventTypes[i] = viewForges[i].IsEmpty()
? streamEventTypes[i]
: viewForges[i][(viewForges[i].Count - 1)].EventType;
}
// add unique-information to join analysis
joinAnalysisResult.AddUniquenessInfo(viewForges, statementSpec.Annotations);
// plan sub-selects
SubSelectHelperForgePlan subselectForgePlan = SubSelectHelperForgePlanner.PlanSubSelect(
@base, subselectActivation, streamNames, streamEventTypes, eventTypeNames, services);
var subselectForges = subselectForgePlan.Subselects;
additionalForgeables.AddAll(subselectForgePlan.AdditionalForgeables);
DetermineViewSchedules(subselectForges, scheduleHandleCallbackProviders);
// determine view schedules
var viewResourceDelegateExpr = new ViewResourceDelegateExpr();
ViewFactoryForgeUtil.DetermineViewSchedules(viewForges, scheduleHandleCallbackProviders);
var hasIStreamOnly = StatementForgeMethodSelectUtil.GetHasIStreamOnly(isNamedWindow, viewForges);
var optionalStreamsIfAny = OuterJoinAnalyzer.OptionalStreamsIfAny(statementSpec.Raw.OuterJoinDescList);
StreamTypeService typeService = new StreamTypeServiceImpl(
streamEventTypes,
streamNames,
hasIStreamOnly,
false,
optionalStreamsIfAny);
// Validate views that require validation, specifically streams that don't have
// sub-views such as DB SQL joins
var historicalViewableDesc = new HistoricalViewableDesc(numStreams);
for (var stream = 0; stream < historicalEventViewables.Length; stream++) {
var historicalEventViewable = historicalEventViewables[stream];
if (historicalEventViewable == null) {
continue;
}
scheduleHandleCallbackProviders.Add(historicalEventViewable);
IList<StmtClassForgeableFactory> forgeables = historicalEventViewable.Validate(typeService, @base, services);
additionalForgeables.AddAll(forgeables);
historicalViewableDesc.SetHistorical(stream, historicalEventViewable.RequiredStreams);
if (historicalEventViewable.RequiredStreams.Contains(stream)) {
throw new ExprValidationException(
"Parameters for historical stream " +
stream +
" indicate that the stream is subordinate to itself as stream parameters originate in the same stream");
}
}
// Validate where-clause filter tree, outer join clause and output limit expression
var whereClauseValidated = EPStatementStartMethodHelperValidate.ValidateNodes(
statementSpec.Raw,
typeService,
viewResourceDelegateExpr,
@base.StatementRawInfo,
services);
var whereClauseForge = whereClauseValidated?.Forge;
// Obtain result set processor
var resultSetProcessorDesc = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
new ResultSetSpec(statementSpec),
typeService,
viewResourceDelegateExpr,
joinAnalysisResult.UnidirectionalInd,
true,
@base.ContextPropertyRegistry,
false,
false,
@base.StatementRawInfo,
services);
additionalForgeables.AddAll(resultSetProcessorDesc.AdditionalForgeables);
// Handle 'prior' function nodes in terms of view requirements
var viewResourceDelegateDesc =
ViewResourceVerifyHelper.VerifyPreviousAndPriorRequirements(viewForges, viewResourceDelegateExpr);
var hasPrior = ViewResourceDelegateDesc.HasPrior(viewResourceDelegateDesc);
if (hasPrior) {
for (var stream = 0; stream < numStreams; stream++) {
if (!viewResourceDelegateDesc[stream].PriorRequests.IsEmpty()) {
viewForges[stream].Add(new PriorEventViewForge(viewForges[stream].IsEmpty(), streamEventTypes[stream]));
var serdeForgeables = SerdeEventTypeUtility.Plan(
streamEventTypes[stream], @base.StatementRawInfo, services.SerdeEventTypeRegistry, services.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
}
}
var outputProcessDesc = OutputProcessViewForgeFactory.Make(
typeService.EventTypes,
resultSetProcessorDesc.ResultEventType,
resultSetProcessorDesc.ResultSetProcessorType,
statementSpec,
@base.StatementRawInfo,
services);
var outputProcessViewFactoryForge = outputProcessDesc.Forge;
additionalForgeables.AddAll(outputProcessDesc.AdditionalForgeables);
outputProcessViewFactoryForge.CollectSchedules(scheduleHandleCallbackProviders);
JoinSetComposerPrototypeForge joinForge = null;
if (numStreams > 1) {
var hasAggregations = !resultSetProcessorDesc.AggregationServiceForgeDesc.Expressions.IsEmpty();
var desc = JoinSetComposerPrototypeForgeFactory.MakeComposerPrototype(
statementSpec,
joinAnalysisResult,
typeService,
historicalViewableDesc,
false,
hasAggregations,
@base.StatementRawInfo,
services);
joinForge = desc.Forge;
additionalForgeables.AddAll(desc.AdditionalForgeables);
HandleIndexDependencies(joinForge.OptionalQueryPlan, services);
}
// plan table access
var tableAccessForges =
ExprTableEvalHelperPlan.PlanTableAccess(@base.StatementSpec.TableAccessNodes);
ValidateTableAccessUse(statementSpec.Raw.IntoTableSpec, statementSpec.Raw.TableExpressions);
if (joinAnalysisResult.IsUnidirectional && statementSpec.Raw.IntoTableSpec != null) {
throw new ExprValidationException("Into-table does not allow unidirectional joins");
}
var orderByWithoutOutputLimit = statementSpec.Raw.OrderByList != null &&
!statementSpec.Raw.OrderByList.IsEmpty() &&
statementSpec.Raw.OutputLimitSpec == null;
var statementAIFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
var resultSetProcessorProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ResultSetProcessorFactoryProvider),
classPostfix);
var outputProcessViewProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(OutputProcessViewFactoryProvider),
classPostfix);
var statementProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
var statementFieldsClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
//var statementFieldsClassName = namespaceScope.FieldsClassNameOptional;
var forgeX = new StatementAgentInstanceFactorySelectForge(
typeService.StreamNames,
viewableActivatorForges,
resultSetProcessorProviderClassName,
viewForges,
viewResourceDelegateDesc,
whereClauseForge,
joinForge,
outputProcessViewProviderClassName,
subselectForges,
tableAccessForges,
orderByWithoutOutputLimit,
joinAnalysisResult.IsUnidirectional);
var namespaceScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
var forgeablesX = additionalForgeables
.Select(additional => additional.Make(namespaceScope, classPostfix))
.ToList();
forgeablesX.Add(
new StmtClassForgeableRSPFactoryProvider(
resultSetProcessorProviderClassName,
resultSetProcessorDesc,
namespaceScope,
@base.StatementRawInfo));
forgeablesX.Add(
new StmtClassForgeableOPVFactoryProvider(
outputProcessViewProviderClassName,
outputProcessViewFactoryForge,
namespaceScope,
numStreams,
@base.StatementRawInfo));
forgeablesX.Add(
new StmtClassForgeableAIFactoryProviderSelect(statementAIFactoryProviderClassName, namespaceScope, forgeX));
forgeablesX.Add(
new StmtClassForgeableStmtFields(statementFieldsClassName, namespaceScope, numStreams));
if (!dataflowOperator) {
var informationals = StatementInformationalsUtil.GetInformationals(
@base,
filterSpecCompileds,
scheduleHandleCallbackProviders,
namedWindowConsumers,
true,
resultSetProcessorDesc.SelectSubscriberDescriptor,
namespaceScope,
services);
forgeablesX.Add(
new StmtClassForgeableStmtProvider(statementAIFactoryProviderClassName, statementProviderClassName, informationals, namespaceScope));
}
var forgeableResult = new StmtForgeMethodResult(
forgeablesX,
filterSpecCompileds,
scheduleHandleCallbackProviders,
namedWindowConsumers,
FilterSpecCompiled.MakeExprNodeList(filterSpecCompileds, EmptyList<FilterSpecParamExprNodeForge>.Instance));
return new StmtForgeMethodSelectResult(forgeableResult, resultSetProcessorDesc.ResultEventType, numStreams);
}
private static string CompileModule(
string optionalModuleName,
IDictionary<ModuleProperty, object> moduleProperties,
IList<string> statementClassNames,
string moduleIdentPostfix,
ModuleCompileTimeServices compileTimeServices,
out Assembly assembly)
{
// write code to create an implementation of StatementResource
var statementFieldsClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementFields),
moduleIdentPostfix);
var namespaceScope = new CodegenNamespaceScope(
compileTimeServices.Namespace,
statementFieldsClassName,
compileTimeServices.IsInstrumented());
var moduleClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ModuleProvider),
moduleIdentPostfix);
var classScope = new CodegenClassScope(true, namespaceScope, moduleClassName);
var methods = new CodegenClassMethods();
var properties = new CodegenClassProperties();
// provide module name
var moduleNameProp = CodegenProperty.MakePropertyNode(
typeof(string),
typeof(EPCompilerImpl),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
moduleNameProp.GetterBlock.BlockReturn(Constant(optionalModuleName));
// provide module properties
var modulePropertiesProp = CodegenProperty.MakePropertyNode(
typeof(IDictionary<ModuleProperty, object>),
typeof(EPCompilerImpl),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
MakeModuleProperties(moduleProperties, modulePropertiesProp);
// provide module dependencies
var moduleDependenciesProp = CodegenProperty.MakePropertyNode(
typeof(ModuleDependenciesRuntime),
typeof(EPCompilerImpl),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
compileTimeServices.ModuleDependencies.Inject(moduleDependenciesProp.GetterBlock);
// register types
var initializeEventTypesMethod = MakeInitEventTypes(classScope, compileTimeServices);
// register named windows
var symbolsNamedWindowInit = new ModuleNamedWindowInitializeSymbol();
var initializeNamedWindowsMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsNamedWindowInit, classScope)
.AddParam(
typeof(EPModuleNamedWindowInitServices),
ModuleNamedWindowInitializeSymbol.REF_INITSVC.Ref);
foreach (var namedWindow in compileTimeServices.NamedWindowCompileTimeRegistry.NamedWindows) {
var addNamedWindow = RegisterNamedWindowCodegen(
namedWindow,
initializeNamedWindowsMethod,
classScope,
symbolsNamedWindowInit);
initializeNamedWindowsMethod.Block.Expression(LocalMethod(addNamedWindow));
}
// register tables
var symbolsTableInit = new ModuleTableInitializeSymbol();
var initializeTablesMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsTableInit, classScope)
.AddParam(typeof(EPModuleTableInitServices), ModuleTableInitializeSymbol.REF_INITSVC.Ref);
foreach (var table in compileTimeServices.TableCompileTimeRegistry.Tables) {
var addTable = RegisterTableCodegen(table, initializeTablesMethod, classScope, symbolsTableInit);
initializeTablesMethod.Block.Expression(LocalMethod(addTable));
}
// register indexes
var symbolsIndexInit = new ModuleIndexesInitializeSymbol();
var initializeIndexesMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsIndexInit, classScope)
.AddParam(typeof(EPModuleIndexInitServices), EPModuleIndexInitServicesConstants.REF.Ref);
foreach (KeyValuePair<IndexCompileTimeKey, IndexDetailForge> index in compileTimeServices
.IndexCompileTimeRegistry.Indexes) {
var addIndex = RegisterIndexCodegen(index, initializeIndexesMethod, classScope, symbolsIndexInit);
initializeIndexesMethod.Block.Expression(LocalMethod(addIndex));
}
// register contexts
var symbolsContextInit = new ModuleContextInitializeSymbol();
var initializeContextsMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsContextInit, classScope)
.AddParam(
typeof(EPModuleContextInitServices),
ModuleContextInitializeSymbol.REF_INITSVC.Ref);
foreach (var context in compileTimeServices.ContextCompileTimeRegistry.Contexts) {
var addContext = RegisterContextCodegen(
context,
initializeContextsMethod,
classScope,
symbolsContextInit);
initializeContextsMethod.Block.Expression(LocalMethod(addContext));
}
// register variables
var symbolsVariablesInit = new ModuleVariableInitializeSymbol();
var initializeVariablesMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsVariablesInit, classScope)
.AddParam(
typeof(EPModuleVariableInitServices),
ModuleVariableInitializeSymbol.REF_INITSVC.Ref);
foreach (var variable in compileTimeServices.VariableCompileTimeRegistry.Variables) {
var addVariable = RegisterVariableCodegen(
variable,
initializeVariablesMethod,
classScope,
symbolsVariablesInit);
initializeVariablesMethod.Block.Expression(LocalMethod(addVariable));
}
// register expressions
var symbolsExprDeclaredInit = new ModuleExpressionDeclaredInitializeSymbol();
var initializeExprDeclaredMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsExprDeclaredInit, classScope)
.AddParam(
typeof(EPModuleExprDeclaredInitServices),
ModuleExpressionDeclaredInitializeSymbol.REF_INITSVC.Ref);
foreach (var expression in compileTimeServices.ExprDeclaredCompileTimeRegistry.Expressions) {
var addExpression = RegisterExprDeclaredCodegen(
expression,
initializeExprDeclaredMethod,
classScope,
symbolsExprDeclaredInit);
initializeExprDeclaredMethod.Block.Expression(LocalMethod(addExpression));
}
// register scripts
var symbolsScriptInit = new ModuleScriptInitializeSymbol();
var initializeScriptsMethod = CodegenMethod
.MakeMethod(typeof(void), typeof(EPCompilerImpl), symbolsScriptInit, classScope)
.AddParam(typeof(EPModuleScriptInitServices), ModuleScriptInitializeSymbol.REF_INITSVC.Ref);
foreach (var expression in compileTimeServices.ScriptCompileTimeRegistry.Scripts) {
var addScript = RegisterScriptCodegen(
expression,
initializeScriptsMethod,
classScope,
symbolsScriptInit);
initializeScriptsMethod.Block.Expression(LocalMethod(addScript));
}
// register provided classes
var symbolsClassProvidedInit = new ModuleClassProvidedInitializeSymbol();
var initializeClassProvidedMethod = CodegenMethod
.MakeParentNode(typeof(void), typeof(EPCompilerImpl), symbolsClassProvidedInit, classScope)
.AddParam(typeof(EPModuleClassProvidedInitServices), ModuleClassProvidedInitializeSymbol.REF_INITSVC.Ref);
foreach (var currClazz in compileTimeServices.ClassProvidedCompileTimeRegistry.Classes) {
var addClassProvided = RegisterClassProvidedCodegen(
currClazz,
initializeClassProvidedMethod,
classScope,
symbolsClassProvidedInit);
initializeClassProvidedMethod.Block.Expression(LocalMethod(addClassProvided));
}
// instantiate factories for statements
var statementsProp = CodegenProperty.MakePropertyNode(
typeof(IList<StatementProvider>),
typeof(EPCompilerImpl),
CodegenSymbolProviderEmpty.INSTANCE,
classScope);
statementsProp.GetterBlock.DeclareVar<IList<StatementProvider>>(
"statements",
NewInstance(typeof(List<StatementProvider>), Constant(statementClassNames.Count)));
foreach (var statementClassName in statementClassNames) {
statementsProp.GetterBlock.ExprDotMethod(
Ref("statements"),
"Add",
NewInstanceInner(statementClassName));
}
statementsProp.GetterBlock.BlockReturn(Ref("statements"));
// build stack
CodegenStackGenerator.RecursiveBuildStack(
moduleNameProp,
"ModuleName",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
modulePropertiesProp,
"ModuleProperties",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
moduleDependenciesProp,
"ModuleDependencies",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeEventTypesMethod,
"InitializeEventTypes",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeNamedWindowsMethod,
"InitializeNamedWindows",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeTablesMethod,
"InitializeTables",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeIndexesMethod,
"InitializeIndexes",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeContextsMethod,
"InitializeContexts",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeVariablesMethod,
"InitializeVariables",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeExprDeclaredMethod,
"InitializeExprDeclareds",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeScriptsMethod,
"InitializeScripts",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
initializeClassProvidedMethod,
"InitializeClassProvided",
methods,
properties);
CodegenStackGenerator.RecursiveBuildStack(
statementsProp,
"Statements",
methods,
properties);
var clazz = new CodegenClass(
CodegenClassType.MODULEPROVIDER,
typeof(ModuleProvider),
moduleClassName,
classScope,
new EmptyList<CodegenTypedParam>(),
null,
methods,
properties,
new EmptyList<CodegenInnerClass>());
var container = compileTimeServices.Container;
var compiler = container
.RoslynCompiler()
.WithCodeLogging(compileTimeServices.Configuration.Compiler.Logging.IsEnableCode)
.WithCodeAuditDirectory(compileTimeServices.Configuration.Compiler.Logging.AuditDirectory)
.WithCodegenClasses(new[] {clazz});
assembly = compiler.Compile();
return CodeGenerationIDGenerator.GenerateClassNameWithNamespace(
compileTimeServices.Namespace,
typeof(ModuleProvider),
moduleIdentPostfix);
}
public StmtForgeMethodResult Make(
string @namespace,
string classPostfix,
StatementCompileTimeServices services)
{
// determine context
var contextName = @base.StatementSpec.Raw.OptionalContextName;
IList<FilterSpecCompiled> filterSpecCompileds = new List<FilterSpecCompiled>();
IList<ScheduleHandleCallbackProvider> schedules = new List<ScheduleHandleCallbackProvider>();
IList<NamedWindowConsumerStreamSpec> namedWindowConsumers = new List<NamedWindowConsumerStreamSpec>();
IList<StmtClassForgeableFactory> additionalForgeables = new List<StmtClassForgeableFactory>();
// create subselect information
var subSelectActivationDesc = SubSelectHelperActivations.CreateSubSelectActivation(
filterSpecCompileds, namedWindowConsumers, @base, services);
IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation = subSelectActivationDesc.Subselects;
additionalForgeables.AddAll(subSelectActivationDesc.AdditionalForgeables);
// obtain activator
var streamSpec = @base.StatementSpec.StreamSpecs[0];
StreamSelector? optionalStreamSelector = null;
OnTriggerActivatorDesc activatorResult;
if (streamSpec is FilterStreamSpecCompiled) {
var filterStreamSpec = (FilterStreamSpecCompiled) streamSpec;
activatorResult = ActivatorFilter(filterStreamSpec, services);
filterSpecCompileds.Add(filterStreamSpec.FilterSpecCompiled);
}
else if (streamSpec is PatternStreamSpecCompiled) {
var patternStreamSpec = (PatternStreamSpecCompiled) streamSpec;
var forges = patternStreamSpec.Root.CollectFactories();
foreach (var forge in forges) {
forge.CollectSelfFilterAndSchedule(filterSpecCompileds, schedules);
}
activatorResult = ActivatorPattern(patternStreamSpec, services);
}
else if (streamSpec is NamedWindowConsumerStreamSpec) {
var namedSpec = (NamedWindowConsumerStreamSpec) streamSpec;
activatorResult = ActivatorNamedWindow(namedSpec, services);
namedWindowConsumers.Add(namedSpec);
}
else if (streamSpec is TableQueryStreamSpec) {
throw new ExprValidationException("Tables cannot be used in an on-action statement triggering stream");
}
else {
throw new ExprValidationException("Unknown stream specification type: " + streamSpec);
}
var statementFieldsClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementFields), classPostfix);
var namespaceScope = new CodegenNamespaceScope(
@namespace,
statementFieldsClassName,
services.IsInstrumented);
var aiFactoryProviderClassName = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(StatementAIFactoryProvider),
classPostfix);
// context-factory creation
//
// handle on-merge for table
var onTriggerDesc = @base.StatementSpec.Raw.OnTriggerDesc;
OnTriggerPlan onTriggerPlan;
if (onTriggerDesc is OnTriggerWindowDesc) {
var desc = (OnTriggerWindowDesc) onTriggerDesc;
var namedWindow = services.NamedWindowCompileTimeResolver.Resolve(desc.WindowName);
TableMetaData table = null;
if (namedWindow == null) {
table = services.TableCompileTimeResolver.Resolve(desc.WindowName);
if (table == null) {
throw new ExprValidationException(
"A named window or table '" + desc.WindowName + "' has not been declared");
}
}
var planDesc = new OnTriggerWindowPlan(
desc,
contextName,
activatorResult,
optionalStreamSelector,
subselectActivation,
streamSpec);
onTriggerPlan = OnTriggerWindowUtil.HandleContextFactoryOnTrigger(
aiFactoryProviderClassName,
namespaceScope,
classPostfix,
namedWindow,
table,
planDesc,
@base,
services);
}
else if (onTriggerDesc is OnTriggerSetDesc) {
// variable assignments
var desc = (OnTriggerSetDesc) onTriggerDesc;
var plan = OnTriggerSetUtil.HandleSetVariable(
aiFactoryProviderClassName,
namespaceScope,
classPostfix,
activatorResult,
streamSpec.OptionalStreamName,
subselectActivation,
desc,
@base,
services);
onTriggerPlan = new OnTriggerPlan(
plan.Forgeable,
plan.Forgeables,
plan.SelectSubscriberDescriptor,
plan.AdditionalForgeables);
}
else {
// split-stream use case
var desc = (OnTriggerSplitStreamDesc) onTriggerDesc;
onTriggerPlan = OnSplitStreamUtil.HandleSplitStream(
aiFactoryProviderClassName,
namespaceScope,
classPostfix,
desc,
streamSpec,
activatorResult,
subselectActivation,
@base,
services);
}
additionalForgeables.AddAll(onTriggerPlan.AdditionalForgeables);
// build forge list
IList<StmtClassForgeable> forgeables = new List<StmtClassForgeable>();
foreach (StmtClassForgeableFactory additional in additionalForgeables) {
forgeables.Add(additional.Make(namespaceScope, classPostfix));
}
forgeables.AddAll(onTriggerPlan.Forgeables);
forgeables.Add(onTriggerPlan.Factory);
var statementProviderClassName =
CodeGenerationIDGenerator.GenerateClassNameSimple(typeof(StatementProvider), classPostfix);
var informationals = StatementInformationalsUtil.GetInformationals(
@base,
filterSpecCompileds,
schedules,
namedWindowConsumers,
true,
onTriggerPlan.SubscriberDescriptor,
namespaceScope,
services);
forgeables.Add(
new StmtClassForgeableStmtProvider(
aiFactoryProviderClassName,
statementProviderClassName,
informationals,
namespaceScope));
forgeables.Add(
new StmtClassForgeableStmtFields(
statementFieldsClassName,
namespaceScope,
2));
return new StmtForgeMethodResult(
forgeables,
filterSpecCompileds,
schedules,
namedWindowConsumers,
FilterSpecCompiled.MakeExprNodeList(
filterSpecCompileds,
EmptyList<FilterSpecParamExprNodeForge>.Instance));
}
public static OnTriggerPlan HandleContextFactoryOnTrigger(
string className,
CodegenNamespaceScope namespaceScope,
string classPostfix,
NamedWindowMetaData namedWindow,
TableMetaData table,
OnTriggerWindowPlan planDesc,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
// validate context
var infraName = planDesc.OnTriggerDesc.WindowName;
var infraTitle = (namedWindow != null ? "Named window" : "Table") + " '" + infraName + "'";
var infraContextName = namedWindow != null ? namedWindow.ContextName : table.OptionalContextName;
var infraModuleName = namedWindow != null ? namedWindow.NamedWindowModuleName : table.TableModuleName;
var infraEventType = namedWindow != null ? namedWindow.EventType : table.InternalEventType;
var resultEventType = namedWindow != null ? namedWindow.EventType : table.PublicEventType;
var infraVisibility = namedWindow != null
? namedWindow.EventType.Metadata.AccessModifier
: table.TableVisibility;
ValidateOnExpressionContext(planDesc.ContextName, infraContextName, infraTitle);
List<StmtClassForgeableFactory> additionalForgeables = new List<StmtClassForgeableFactory>();
// validate expressions and plan subselects
var validationResult = OnTriggerPlanValidator.ValidateOnTriggerPlan(
infraEventType,
planDesc.OnTriggerDesc,
planDesc.StreamSpec,
planDesc.ActivatorResult,
planDesc.SubselectActivation,
@base,
services);
additionalForgeables.AddAll(validationResult.AdditionalForgeables);
var validatedJoin = validationResult.ValidatedJoin;
var activatorResultEventType = planDesc.ActivatorResult.ActivatorResultEventType;
var pair = IndexHintPair.GetIndexHintPair(
planDesc.OnTriggerDesc,
@base.StatementSpec.StreamSpecs[0].OptionalStreamName,
@base.StatementRawInfo,
services);
var indexHint = pair.IndexHint;
var excludePlanHint = pair.ExcludePlanHint;
var enabledSubqueryIndexShare = namedWindow != null && namedWindow.IsEnableIndexShare;
var isVirtualWindow = namedWindow != null && namedWindow.IsVirtualDataWindow;
var indexMetadata = namedWindow != null ? namedWindow.IndexMetadata : table.IndexMetadata;
var optionalUniqueKeySet = namedWindow != null ? namedWindow.UniquenessAsSet : table.UniquenessAsSet;
// query plan
var onlyUseExistingIndexes = table != null;
SubordinateWMatchExprQueryPlanResult planResult = SubordinateQueryPlanner.PlanOnExpression(
validatedJoin,
activatorResultEventType,
indexHint,
enabledSubqueryIndexShare,
-1,
excludePlanHint,
isVirtualWindow,
indexMetadata,
infraEventType,
optionalUniqueKeySet,
onlyUseExistingIndexes,
@base.StatementRawInfo,
services);
SubordinateWMatchExprQueryPlanForge queryPlan = planResult.Forge;
additionalForgeables.AddAll(planResult.AdditionalForgeables);
// indicate index dependencies
if (queryPlan.Indexes != null && infraVisibility == NameAccessModifier.PUBLIC) {
foreach (var index in queryPlan.Indexes) {
services.ModuleDependenciesCompileTime.AddPathIndex(
namedWindow != null,
infraName,
infraModuleName,
index.IndexName,
index.IndexModuleName,
services.NamedWindowCompileTimeRegistry,
services.TableCompileTimeRegistry);
}
}
var onTriggerType = planDesc.OnTriggerDesc.OnTriggerType;
var activator = planDesc.ActivatorResult.Activator;
var subselectForges = validationResult.SubselectForges;
var tableAccessForges = validationResult.TableAccessForges;
IList<StmtClassForgeable> forgeables = new List<StmtClassForgeable>(2);
StatementAgentInstanceFactoryOnTriggerInfraBaseForge forge;
var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ResultSetProcessorFactoryProvider),
classPostfix);
ResultSetProcessorDesc resultSetProcessor;
if (onTriggerType == OnTriggerType.ON_SELECT) {
resultSetProcessor = validationResult.ResultSetProcessorPrototype;
var outputEventType = resultSetProcessor.ResultEventType;
var insertInto = false;
TableMetaData optionalInsertIntoTable = null;
var insertIntoDesc = @base.StatementSpec.Raw.InsertIntoDesc;
var addToFront = false;
if (insertIntoDesc != null) {
insertInto = true;
optionalInsertIntoTable = services.TableCompileTimeResolver.Resolve(insertIntoDesc.EventTypeName);
var optionalInsertIntoNamedWindow =
services.NamedWindowCompileTimeResolver.Resolve(insertIntoDesc.EventTypeName);
addToFront = optionalInsertIntoNamedWindow != null || optionalInsertIntoTable != null;
}
var selectAndDelete = planDesc.OnTriggerDesc.IsDeleteAndSelect;
var distinct = @base.StatementSpec.SelectClauseCompiled.IsDistinct;
MultiKeyPlan distinctMultiKeyPlan = MultiKeyPlanner.PlanMultiKeyDistinct(
distinct,
outputEventType,
@base.StatementRawInfo,
services.SerdeResolver);
additionalForgeables.AddAll(distinctMultiKeyPlan.MultiKeyForgeables);
forge = new StatementAgentInstanceFactoryOnTriggerInfraSelectForge(
activator,
outputEventType,
subselectForges,
tableAccessForges,
namedWindow,
table,
queryPlan,
classNameRSP,
insertInto,
addToFront,
optionalInsertIntoTable,
selectAndDelete,
distinct,
distinctMultiKeyPlan.ClassRef);
}
else {
var defaultSelectAllSpec = new StatementSpecCompiled();
defaultSelectAllSpec.SelectClauseCompiled.WithSelectExprList(new SelectClauseElementWildcard());
defaultSelectAllSpec.Raw.SelectStreamDirEnum = SelectClauseStreamSelectorEnum.RSTREAM_ISTREAM_BOTH;
StreamTypeService typeService = new StreamTypeServiceImpl(
new[] {resultEventType},
new[] {infraName},
new[] {false},
false,
false);
resultSetProcessor = ResultSetProcessorFactoryFactory.GetProcessorPrototype(
new ResultSetSpec(defaultSelectAllSpec),
typeService,
null,
new bool[1],
false,
@base.ContextPropertyRegistry,
false,
false,
@base.StatementRawInfo,
services);
if (onTriggerType == OnTriggerType.ON_DELETE) {
forge = new StatementAgentInstanceFactoryOnTriggerInfraDeleteForge(
activator,
resultEventType,
subselectForges,
tableAccessForges,
classNameRSP,
namedWindow,
table,
queryPlan);
}
else if (onTriggerType == OnTriggerType.ON_UPDATE) {
var updateDesc = (OnTriggerWindowUpdateDesc) planDesc.OnTriggerDesc;
EventBeanUpdateHelperForge updateHelper = EventBeanUpdateHelperForgeFactory.Make(
infraName,
(EventTypeSPI) infraEventType,
updateDesc.Assignments,
validationResult.ZeroStreamAliasName,
activatorResultEventType,
namedWindow != null,
@base.StatementName,
services.EventTypeAvroHandler);
forge = new StatementAgentInstanceFactoryOnTriggerInfraUpdateForge(
activator,
resultEventType,
subselectForges,
tableAccessForges,
classNameRSP,
namedWindow,
table,
queryPlan,
updateHelper);
}
else if (onTriggerType == OnTriggerType.ON_MERGE) {
var onMergeTriggerDesc = (OnTriggerMergeDesc) planDesc.OnTriggerDesc;
var onMergeHelper = new InfraOnMergeHelperForge(
onMergeTriggerDesc,
activatorResultEventType,
planDesc.StreamSpec.OptionalStreamName,
infraName,
(EventTypeSPI) infraEventType,
@base.StatementRawInfo,
services,
table);
forge = new StatementAgentInstanceFactoryOnTriggerInfraMergeForge(
activator,
resultEventType,
subselectForges,
tableAccessForges,
classNameRSP,
namedWindow,
table,
queryPlan,
onMergeHelper);
}
else {
throw new IllegalStateException("Unrecognized trigger type " + onTriggerType);
}
}
forgeables.Add(
new StmtClassForgeableRSPFactoryProvider(
classNameRSP,
resultSetProcessor,
namespaceScope,
@base.StatementRawInfo));
var queryPlanLogging = services.Configuration.Common.Logging.IsEnableQueryPlan;
SubordinateQueryPlannerUtil.QueryPlanLogOnExpr(
queryPlanLogging,
QUERY_PLAN_LOG,
queryPlan,
@base.StatementSpec.Annotations,
services.ImportServiceCompileTime);
StmtClassForgeableAIFactoryProviderOnTrigger onTrigger = new StmtClassForgeableAIFactoryProviderOnTrigger(className, namespaceScope, forge);
return new OnTriggerPlan(onTrigger, forgeables, resultSetProcessor.SelectSubscriberDescriptor, additionalForgeables);
}
public static OnTriggerPlan HandleSplitStream(
string aiFactoryProviderClassName,
CodegenNamespaceScope namespaceScope,
string classPostfix,
OnTriggerSplitStreamDesc desc,
StreamSpecCompiled streamSpec,
OnTriggerActivatorDesc activatorResult,
IDictionary<ExprSubselectNode, SubSelectActivationPlan> subselectActivation,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
var raw = @base.StatementSpec.Raw;
if (raw.InsertIntoDesc == null) {
throw new ExprValidationException(
"Required insert-into clause is not provided, the clause is required for split-stream syntax");
}
if (raw.GroupByExpressions != null && raw.GroupByExpressions.Count > 0 ||
raw.HavingClause != null ||
raw.OrderByList.Count > 0) {
throw new ExprValidationException(
"A group-by clause, having-clause or order-by clause is not allowed for the split stream syntax");
}
var streamName = streamSpec.OptionalStreamName;
if (streamName == null) {
streamName = "stream_0";
}
StreamTypeService typeServiceTrigger = new StreamTypeServiceImpl(
new[] {activatorResult.ActivatorResultEventType},
new[] {streamName},
new[] {true},
false,
false);
// materialize sub-select views
var subselectForges = SubSelectHelperForgePlanner.PlanSubSelect(
@base,
subselectActivation,
new[] {streamSpec.OptionalStreamName},
new[] {activatorResult.ActivatorResultEventType},
new[] {activatorResult.TriggerEventTypeName},
services);
// compile top-level split
var items = new OnSplitItemForge[desc.SplitStreams.Count + 1];
items[0] = OnSplitValidate(
typeServiceTrigger,
@base.StatementSpec,
@base.ContextPropertyRegistry,
null,
@base.StatementRawInfo,
services);
// compile each additional split
var index = 1;
foreach (var splits in desc.SplitStreams) {
var splitSpec = new StatementSpecCompiled();
splitSpec.Raw.InsertIntoDesc = splits.InsertInto;
splitSpec.SelectClauseCompiled = CompileSelectAllowSubselect(splits.SelectClause);
splitSpec.Raw.WhereClause = splits.WhereClause;
PropertyEvaluatorForge optionalPropertyEvaluator = null;
StreamTypeService typeServiceProperty;
if (splits.FromClause != null) {
optionalPropertyEvaluator = PropertyEvaluatorForgeFactory.MakeEvaluator(
splits.FromClause.PropertyEvalSpec,
activatorResult.ActivatorResultEventType,
streamName,
@base.StatementRawInfo,
services);
typeServiceProperty = new StreamTypeServiceImpl(
new[] {optionalPropertyEvaluator.FragmentEventType},
new[] {splits.FromClause.OptionalStreamName},
new[] {true},
false,
false);
}
else {
typeServiceProperty = typeServiceTrigger;
}
items[index] = OnSplitValidate(
typeServiceProperty,
splitSpec,
@base.ContextPropertyRegistry,
optionalPropertyEvaluator,
@base.StatementRawInfo,
services);
index++;
}
// handle result set processor classes
IList<StmtClassForgable> forgables = new List<StmtClassForgable>();
for (var i = 0; i < items.Length; i++) {
var classNameRSP = CodeGenerationIDGenerator.GenerateClassNameSimple(
typeof(ResultSetProcessorFactoryProvider),
classPostfix + "_" + i);
forgables.Add(
new StmtClassForgableRSPFactoryProvider(
classNameRSP,
items[i].ResultSetProcessorDesc,
namespaceScope,
@base.StatementRawInfo));
items[i].ResultSetProcessorClassName = classNameRSP;
}
// plan table access
var tableAccessForges = ExprTableEvalHelperPlan.PlanTableAccess(@base.StatementSpec.TableAccessNodes);
// build forge
var splitStreamForge = new StatementAgentInstanceFactoryOnTriggerSplitStreamForge(
activatorResult.Activator,
activatorResult.ActivatorResultEventType,
subselectForges,
tableAccessForges,
items,
desc.IsFirst);
var triggerForge = new StmtClassForgableAIFactoryProviderOnTrigger(
aiFactoryProviderClassName,
namespaceScope,
splitStreamForge);
return new OnTriggerPlan(triggerForge, forgables, new SelectSubscriberDescriptor());
}
public MultiKeyClassRefUUIDBased(Type[] mkTypes)
{
uuid = CodeGenerationIDGenerator.GenerateClassNameUUID();
MKTypes = mkTypes;
}
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 string GetClassNameMK(string classPostfix)
{
AssignPostfix(classPostfix);
return CodeGenerationIDGenerator.GenerateClassNameWithUUID(
typeof(HashableMultiKey), classPostfix, uuid);
}
