private static EventType GetDefineMultimatchEventType(
LinkedHashMap<string, Pair<int, bool>> variableStreams,
EventType parentEventType,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
IDictionary<string, object> multievent = new LinkedHashMap<string, object>();
foreach (var entry in variableStreams) {
if (entry.Value.Second) {
multievent.Put(entry.Key, new[] {parentEventType});
}
}
var multimatchAllTypeName = services.EventTypeNameGeneratorStatement.AnonymousRowrecogMultimatchAllName;
var multimatchAllTypeMetadata = new EventTypeMetadata(
multimatchAllTypeName,
@base.ModuleName,
EventTypeTypeClass.MATCHRECOGDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var multimatchAllEventType = BaseNestableEventUtil.MakeOATypeCompileTime(
multimatchAllTypeMetadata,
multievent,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(multimatchAllEventType);
return multimatchAllEventType;
}
public static ObjectArrayEventType MakeTransientOAType(
string enumMethod,
string propertyName,
Type type,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
IDictionary<string, object> propsResult = new Dictionary<string, object>();
propsResult.Put(propertyName, Boxing.GetBoxedType(type));
var eventTypeName =
services.EventTypeNameGeneratorStatement.GetAnonymousTypeNameEnumMethod(enumMethod, propertyName);
var metadata = new EventTypeMetadata(
eventTypeName,
statementRawInfo.ModuleName,
EventTypeTypeClass.ENUMDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var oatype = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata,
propsResult,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(oatype);
return oatype;
}
private static ObjectArrayEventType MakeTransientOATypeInternal(
string enumMethod,
IDictionary <string, object> boxedPropertyTypes,
string eventTypeNameUUid,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
var eventTypeName =
services.EventTypeNameGeneratorStatement.GetAnonymousTypeNameEnumMethod(enumMethod, eventTypeNameUUid);
var metadata = new EventTypeMetadata(
eventTypeName,
statementRawInfo.ModuleName,
EventTypeTypeClass.ENUMDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var oatype = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata,
boxedPropertyTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(oatype);
return(oatype);
}
static ExcludePlanHintExprUtil()
{
LinkedHashMap<string, object> properties = new LinkedHashMap<string, object>();
properties.Put("from_streamnum", typeof(int?));
properties.Put("to_streamnum", typeof(int?));
properties.Put("from_streamname", typeof(string));
properties.Put("to_streamname", typeof(string));
properties.Put("opname", typeof(string));
properties.Put("exprs", typeof(string[]));
string eventTypeName = EventTypeNameUtil.GetAnonymousTypeNameExcludePlanHint();
EventTypeMetadata eventTypeMetadata = new EventTypeMetadata(
eventTypeName,
null,
EventTypeTypeClass.EXCLUDEPLANHINTDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
OAEXPRESSIONTYPE = BaseNestableEventUtil.MakeOATypeCompileTime(
eventTypeMetadata,
properties,
null,
null,
null,
null,
new BeanEventTypeFactoryDisallow(EventBeanTypedEventFactoryCompileTime.INSTANCE),
null);
}
private DataFlowOpForgeInitializeResult InitializeTypeUndeclared(DataFlowOpForgeInitializeContext context)
{
// No type has been declared, we can create one
var types = new LinkedHashMap<string, object>();
var props = allProperties.Keys;
props.RemoveAll(PARAMETER_PROPERTIES);
var count = 0;
evaluatorForges = new ExprForge[props.Count];
foreach (var propertyName in props) {
var exprNode = allProperties.Get(propertyName);
var validated = EPLValidationUtil.ValidateSimpleGetSubtree(
ExprNodeOrigin.DATAFLOWBEACON,
exprNode,
null,
false,
context.StatementRawInfo,
context.Services);
types.Put(propertyName, validated.Forge.EvaluationType);
evaluatorForges[count] = validated.Forge;
count++;
}
var eventTypeName =
context.Services.EventTypeNameGeneratorStatement.GetDataflowOperatorTypeName(context.OperatorNumber);
var metadata = new EventTypeMetadata(
eventTypeName,
context.Base.ModuleName,
EventTypeTypeClass.DBDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
outputEventType = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata,
types,
null,
null,
null,
null,
context.Services.BeanEventTypeFactoryPrivate,
context.Services.EventTypeCompileTimeResolver);
context.Services.EventTypeCompileTimeRegistry.NewType(outputEventType);
return new DataFlowOpForgeInitializeResult(new[] {new GraphTypeDesc(false, true, outputEventType)});
}
public static EventType GetBuiltInEventType(
string moduleName,
BeanEventTypeFactory beanEventTypeFactory)
{
var metadata = new EventTypeMetadata(
"anonymous",
moduleName,
EventTypeTypeClass.STREAM,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
return(BaseNestableEventUtil.MakeOATypeCompileTime(
metadata,
TYPEINFO,
null,
null,
null,
null,
beanEventTypeFactory,
null));
}
public static HistoricalEventViewableMethodForge CreateMethodStatementView(
int stream,
MethodStreamSpec methodStreamSpec,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
var variableMetaData = services.VariableCompileTimeResolver.Resolve(methodStreamSpec.ClassName);
MethodPollingExecStrategyEnum strategy;
MethodInfo methodReflection = null;
string eventTypeNameProvidedUDFOrScript = null;
var contextName = @base.StatementSpec.Raw.OptionalContextName;
var classpathImportService = services.ImportServiceCompileTime;
// see if this is a script in the from-clause
ExprNodeScript scriptExpression = null;
if (methodStreamSpec.ClassName == null && methodStreamSpec.MethodName != null) {
var script = services.ScriptCompileTimeResolver.Resolve(
methodStreamSpec.MethodName,
methodStreamSpec.Expressions.Count);
if (script != null) {
scriptExpression = new ExprNodeScript(
services.Configuration.Compiler.Scripts.DefaultDialect,
script,
methodStreamSpec.Expressions);
}
}
try {
if (scriptExpression != null) {
eventTypeNameProvidedUDFOrScript = scriptExpression.EventTypeNameAnnotation;
strategy = MethodPollingExecStrategyEnum.TARGET_SCRIPT;
EPLValidationUtil.ValidateSimpleGetSubtree(
ExprNodeOrigin.METHODINVJOIN,
scriptExpression,
null,
false,
@base.StatementRawInfo,
services);
}
else if (variableMetaData != null) {
var variableName = variableMetaData.VariableName;
if (variableMetaData.OptionalContextName != null) {
if (contextName == null || !contextName.Equals(variableMetaData.OptionalContextName)) {
throw new ExprValidationException(
"Variable by name '" +
variableMetaData.VariableName +
"' has been declared for context '" +
variableMetaData.OptionalContextName +
"' and can only be used within the same context");
}
strategy = MethodPollingExecStrategyEnum.TARGET_VAR_CONTEXT;
}
else {
if (variableMetaData.IsConstant) {
strategy = MethodPollingExecStrategyEnum.TARGET_CONST;
}
else {
strategy = MethodPollingExecStrategyEnum.TARGET_VAR;
}
}
methodReflection = classpathImportService.ResolveNonStaticMethodOverloadChecked(
variableMetaData.Type,
methodStreamSpec.MethodName);
}
else if (methodStreamSpec.ClassName == null) { // must be either UDF or script
Pair<Type, ImportSingleRowDesc> udf;
try {
udf = classpathImportService.ResolveSingleRow(
methodStreamSpec.MethodName,
services.ClassProvidedExtension);
}
catch (ImportException ex) {
throw new ExprValidationException(
"Failed to find user-defined function '" + methodStreamSpec.MethodName + "': " + ex.Message,
ex);
}
methodReflection = classpathImportService.ResolveMethodOverloadChecked(
udf.First,
methodStreamSpec.MethodName);
eventTypeNameProvidedUDFOrScript = udf.Second.OptionalEventTypeName;
strategy = MethodPollingExecStrategyEnum.TARGET_CONST;
}
else {
methodReflection = classpathImportService.ResolveMethodOverloadChecked(
methodStreamSpec.ClassName,
methodStreamSpec.MethodName,
services.ClassProvidedExtension);
strategy = MethodPollingExecStrategyEnum.TARGET_CONST;
}
}
catch (ExprValidationException) {
throw;
}
catch (Exception e) {
throw new ExprValidationException(e.Message, e);
}
Type methodProviderClass = null;
Type beanClass;
IDictionary<string, object> oaType = null;
IDictionary<string, object> mapType = null;
var isCollection = false;
var isEnumerator = false;
EventType eventType;
EventType eventTypeWhenMethodReturnsEventBeans = null;
var isStaticMethod = false;
if (methodReflection != null) {
methodProviderClass = methodReflection.DeclaringType;
isStaticMethod = variableMetaData == null;
// Determine object type returned by method
beanClass = methodReflection.ReturnType;
if (beanClass == typeof(void) || beanClass == typeof(void) || beanClass.IsBuiltinDataType()) {
throw new ExprValidationException(
"Invalid return type for static method '" +
methodReflection.Name +
"' of class '" +
methodStreamSpec.ClassName +
"', expecting a type");
}
if (methodReflection.ReturnType.IsArray &&
methodReflection.ReturnType.GetElementType() != typeof(EventBean)) {
beanClass = methodReflection.ReturnType.GetElementType();
}
isCollection = beanClass.IsGenericCollection() && !beanClass.IsGenericDictionary();
Type collectionClass = null;
if (isCollection) {
collectionClass = TypeHelper.GetGenericReturnType(methodReflection, true);
beanClass = collectionClass;
}
isEnumerator = beanClass.IsGenericEnumerator();
Type enumerator = null;
if (isEnumerator) {
enumerator = TypeHelper.GetGenericReturnType(methodReflection, true);
beanClass = enumerator;
}
// If the method returns a Map, look up the map type
string mapTypeName = null;
if (methodReflection.ReturnType.IsGenericDictionary() ||
methodReflection.ReturnType.IsArray &&
methodReflection.ReturnType.GetElementType().IsGenericDictionary() ||
isCollection && collectionClass.IsGenericDictionary() ||
isEnumerator && enumerator.IsGenericDictionary()) {
MethodMetadataDesc metadata;
if (variableMetaData != null) {
metadata = GetCheckMetadataVariable(
methodStreamSpec.MethodName,
variableMetaData,
classpathImportService,
typeof(IDictionary<string, object>));
}
else {
metadata = GetCheckMetadataNonVariable(
methodStreamSpec.MethodName,
methodStreamSpec.ClassName,
classpathImportService,
typeof(IDictionary<string, object>));
}
mapTypeName = metadata.TypeName;
mapType = (IDictionary<string, object>) metadata.TypeMetadata;
}
// If the method returns an Object[] or Object[][], look up the type information
string oaTypeName = null;
if (methodReflection.ReturnType == typeof(object[]) ||
methodReflection.ReturnType == typeof(object[][]) ||
isCollection && collectionClass == typeof(object[]) ||
isEnumerator && enumerator == typeof(object[])) {
MethodMetadataDesc metadata;
if (variableMetaData != null) {
metadata = GetCheckMetadataVariable(
methodStreamSpec.MethodName,
variableMetaData,
classpathImportService,
typeof(IDictionary<string, object>));
}
else {
metadata = GetCheckMetadataNonVariable(
methodStreamSpec.MethodName,
methodStreamSpec.ClassName,
classpathImportService,
typeof(IDictionary<string, object>));
}
oaTypeName = metadata.TypeName;
oaType = (IDictionary<string, object>) metadata.TypeMetadata;
}
// Determine event type from class and method name
// If the method returns EventBean[], require the event type
Func<EventTypeApplicationType, EventTypeMetadata> metadataFunction = apptype => {
var eventTypeName = services.EventTypeNameGeneratorStatement.GetAnonymousMethodHistorical(stream);
return new EventTypeMetadata(
eventTypeName,
@base.ModuleName,
EventTypeTypeClass.METHODPOLLDERIVED,
apptype,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
};
if (methodReflection.ReturnType.IsArray &&
methodReflection.ReturnType.GetElementType() == typeof(EventBean) ||
isCollection && collectionClass == typeof(EventBean) ||
isEnumerator && enumerator == typeof(EventBean)) {
var typeName = methodStreamSpec.EventTypeName == null
? eventTypeNameProvidedUDFOrScript
: methodStreamSpec.EventTypeName;
eventType = EventTypeUtility.RequireEventType(
"Method",
methodReflection.Name,
typeName,
services.EventTypeCompileTimeResolver);
eventTypeWhenMethodReturnsEventBeans = eventType;
}
else if (mapType != null) {
eventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadataFunction.Invoke(EventTypeApplicationType.MAP),
mapType,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(eventType);
}
else if (oaType != null) {
eventType = BaseNestableEventUtil.MakeOATypeCompileTime(
metadataFunction.Invoke(EventTypeApplicationType.OBJECTARR),
oaType,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(eventType);
}
else {
var stem = services.BeanEventTypeStemService.GetCreateStem(beanClass, null);
eventType = new BeanEventType(
services.Container,
stem,
metadataFunction.Invoke(EventTypeApplicationType.CLASS),
services.BeanEventTypeFactoryPrivate,
null,
null,
null,
null);
services.EventTypeCompileTimeRegistry.NewType(eventType);
}
// the @type is only allowed in conjunction with EventBean return types
if (methodStreamSpec.EventTypeName != null && eventTypeWhenMethodReturnsEventBeans == null) {
throw new ExprValidationException(EventTypeUtility.DisallowedAtTypeMessage());
}
}
else {
var eventTypeName = methodStreamSpec.EventTypeName == null
? scriptExpression.EventTypeNameAnnotation
: methodStreamSpec.EventTypeName;
eventType = EventTypeUtility.RequireEventType(
"Script",
scriptExpression.Script.Name,
eventTypeName,
services.EventTypeCompileTimeResolver);
}
// metadata
var meta = new MethodPollingViewableMeta(
methodProviderClass,
isStaticMethod,
mapType,
oaType,
strategy,
isCollection,
isEnumerator,
variableMetaData,
eventTypeWhenMethodReturnsEventBeans,
scriptExpression);
return new HistoricalEventViewableMethodForge(stream, eventType, methodStreamSpec, meta);
}
private static StreamTypeService BuildDefineStreamTypeServiceDefine(
int defineNum,
LinkedHashMap<string, Pair<int, bool>> variableStreams,
MatchRecognizeDefineItem defineItem,
IDictionary<string, ISet<string>> visibilityByIdentifier,
EventType parentViewType,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
if (!variableStreams.ContainsKey(defineItem.Identifier)) {
throw new ExprValidationException("Variable '" + defineItem.Identifier + "' does not occur in pattern");
}
var streamNamesDefine = new string[variableStreams.Count + 1];
var typesDefine = new EventType[variableStreams.Count + 1];
var isIStreamOnly = new bool[variableStreams.Count + 1];
CompatExtensions.Fill(isIStreamOnly, true);
var streamNumDefine = variableStreams.Get(defineItem.Identifier).First;
streamNamesDefine[streamNumDefine] = defineItem.Identifier;
typesDefine[streamNumDefine] = parentViewType;
// add visible single-value
var visibles = visibilityByIdentifier.Get(defineItem.Identifier);
var hasVisibleMultimatch = false;
if (visibles != null) {
foreach (var visible in visibles) {
var def = variableStreams.Get(visible);
if (!def.Second) {
streamNamesDefine[def.First] = visible;
typesDefine[def.First] = parentViewType;
}
else {
hasVisibleMultimatch = true;
}
}
}
// compile multi-matching event type (in last position), if any are used
if (hasVisibleMultimatch) {
IDictionary<string, object> multievent = new LinkedHashMap<string, object>();
foreach (var entry in variableStreams) {
var identifier = entry.Key;
if (entry.Value.Second) {
if (visibles.Contains(identifier)) {
multievent.Put(identifier, new[] {parentViewType});
}
else {
multievent.Put("esper_matchrecog_internal", null);
}
}
}
var multimatchTypeName =
services.EventTypeNameGeneratorStatement.GetAnonymousRowrecogMultimatchDefineName(defineNum);
var multimatchTypeMetadata = new EventTypeMetadata(
multimatchTypeName,
statementRawInfo.ModuleName,
EventTypeTypeClass.MATCHRECOGDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var multimatchEventType = BaseNestableEventUtil.MakeOATypeCompileTime(
multimatchTypeMetadata,
multievent,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
typesDefine[typesDefine.Length - 1] = multimatchEventType;
streamNamesDefine[streamNamesDefine.Length - 1] = multimatchEventType.Name;
}
return new StreamTypeServiceImpl(typesDefine, streamNamesDefine, isIStreamOnly, false, true);
}
public static RowRecogPlan ValidateAndPlan(
IContainer container,
EventType parentEventType,
bool unbound,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
var statementRawInfo = @base.StatementRawInfo;
var matchRecognizeSpec = @base.StatementSpec.Raw.MatchRecognizeSpec;
var annotations = statementRawInfo.Annotations;
var iterateOnly = HintEnum.ITERATE_ONLY.GetHint(annotations) != null;
var additionalForgeables = new List<StmtClassForgeableFactory>();
// Expanded pattern already there
RowRecogExprNode expandedPatternNode = matchRecognizeSpec.Pattern;
// Determine single-row and multiple-row variables
var variablesSingle = new LinkedHashSet<string>();
var variablesMultiple = new LinkedHashSet<string>();
RowRecogHelper.RecursiveInspectVariables(expandedPatternNode, false, variablesSingle, variablesMultiple);
// each variable gets associated with a stream number (multiple-row variables as well to hold the current event for the expression).
var streamNum = 0;
var variableStreams = new LinkedHashMap<string, Pair<int, bool>>();
foreach (var variableSingle in variablesSingle) {
variableStreams.Put(variableSingle, new Pair<int, bool>(streamNum, false));
streamNum++;
}
foreach (var variableMultiple in variablesMultiple) {
variableStreams.Put(variableMultiple, new Pair<int, bool>(streamNum, true));
streamNum++;
}
// mapping of stream to variable
var streamVariables = new OrderedListDictionary<int, string>();
foreach (var entry in variableStreams) {
streamVariables.Put(entry.Value.First, entry.Key);
}
// determine visibility rules
var visibility = RowRecogHelper.DetermineVisibility(expandedPatternNode);
// assemble all single-row variables for expression validation
var allStreamNames = new string[variableStreams.Count];
var allTypes = new EventType[variableStreams.Count];
streamNum = 0;
foreach (var variableSingle in variablesSingle) {
allStreamNames[streamNum] = variableSingle;
allTypes[streamNum] = parentEventType;
streamNum++;
}
foreach (var variableMultiple in variablesMultiple) {
allStreamNames[streamNum] = variableMultiple;
allTypes[streamNum] = parentEventType;
streamNum++;
}
// determine type service for use with DEFINE
// validate each DEFINE clause expression
ISet<string> definedVariables = new HashSet<string>();
IList<ExprAggregateNode> aggregateNodes = new List<ExprAggregateNode>();
var isExprRequiresMultimatchState = new bool[variableStreams.Count];
var previousNodes = new OrderedListDictionary<int, IList<ExprPreviousMatchRecognizeNode>>();
for (var defineIndex = 0; defineIndex < matchRecognizeSpec.Defines.Count; defineIndex++) {
MatchRecognizeDefineItem defineItem = matchRecognizeSpec.Defines[defineIndex];
if (definedVariables.Contains(defineItem.Identifier)) {
throw new ExprValidationException(
"Variable '" + defineItem.Identifier + "' has already been defined");
}
definedVariables.Add(defineItem.Identifier);
// stream-type visibilities handled here
var typeServiceDefines = BuildDefineStreamTypeServiceDefine(
defineIndex,
variableStreams,
defineItem,
visibility,
parentEventType,
statementRawInfo,
services);
var exprNodeResult = HandlePreviousFunctions(defineItem.Expression, previousNodes);
var validationContext = new ExprValidationContextBuilder(typeServiceDefines, statementRawInfo, services)
.WithAllowBindingConsumption(true)
.WithDisablePropertyExpressionEventCollCache(true)
.Build();
ExprNode validated;
try {
// validate
validated = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.MATCHRECOGDEFINE,
exprNodeResult,
validationContext);
// check aggregates
defineItem.Expression = validated;
ExprAggregateNodeUtil.GetAggregatesBottomUp(validated, aggregateNodes);
if (!aggregateNodes.IsEmpty()) {
throw new ExprValidationException("An aggregate function may not appear in a DEFINE clause");
}
}
catch (ExprValidationException ex) {
throw new ExprValidationException(
"Failed to validate condition expression for variable '" +
defineItem.Identifier +
"': " +
ex.Message,
ex);
}
// determine access to event properties from multi-matches
var visitor = new ExprNodeStreamRequiredVisitor();
validated.Accept(visitor);
var streamsRequired = visitor.StreamsRequired;
foreach (var streamRequired in streamsRequired) {
if (streamRequired >= variableStreams.Count) {
var streamNumIdent = variableStreams.Get(defineItem.Identifier).First;
isExprRequiresMultimatchState[streamNumIdent] = true;
break;
}
}
}
var defineAsksMultimatches = CollectionUtil.IsAnySet(isExprRequiresMultimatchState);
// determine type service for use with MEASURE
IDictionary<string, object> measureTypeDef = new LinkedHashMap<string, object>();
foreach (var variableSingle in variablesSingle) {
measureTypeDef.Put(variableSingle, parentEventType);
}
foreach (var variableMultiple in variablesMultiple) {
measureTypeDef.Put(variableMultiple, new[] {parentEventType});
}
var compositeTypeName = services.EventTypeNameGeneratorStatement.AnonymousRowrecogCompositeName;
var compositeTypeMetadata = new EventTypeMetadata(
compositeTypeName,
@base.ModuleName,
EventTypeTypeClass.MATCHRECOGDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var compositeEventType = BaseNestableEventUtil.MakeOATypeCompileTime(
compositeTypeMetadata,
measureTypeDef,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(compositeEventType);
StreamTypeService compositeTypeServiceMeasure =
new StreamTypeServiceImpl(compositeEventType, "MATCH_RECOGNIZE", true);
// find MEASURE clause aggregations
var measureReferencesMultivar = false;
IList<ExprAggregateNode> measureAggregateExprNodes = new List<ExprAggregateNode>();
foreach (var measureItem in matchRecognizeSpec.Measures) {
ExprAggregateNodeUtil.GetAggregatesBottomUp(measureItem.Expr, measureAggregateExprNodes);
}
AggregationServiceForgeDesc[] aggregationServices = null;
if (!measureAggregateExprNodes.IsEmpty()) {
aggregationServices = PlanAggregations(
measureAggregateExprNodes,
compositeTypeServiceMeasure,
allStreamNames,
allTypes,
streamVariables,
variablesMultiple,
@base,
services);
foreach (AggregationServiceForgeDesc svc in aggregationServices) {
if (svc != null) {
additionalForgeables.AddAll(svc.AdditionalForgeables);
}
}
}
// validate each MEASURE clause expression
IDictionary<string, object> rowTypeDef = new LinkedHashMap<string, object>();
var streamRefVisitor = new ExprNodeStreamUseCollectVisitor();
foreach (var measureItem in matchRecognizeSpec.Measures) {
if (measureItem.Name == null) {
throw new ExprValidationException(
"The measures clause requires that each expression utilizes the AS keyword to assign a column name");
}
var validated = ValidateMeasureClause(
measureItem.Expr,
compositeTypeServiceMeasure,
variablesMultiple,
variablesSingle,
statementRawInfo,
services);
measureItem.Expr = validated;
rowTypeDef.Put(measureItem.Name, validated.Forge.EvaluationType);
validated.Accept(streamRefVisitor);
}
// Determine if any of the multi-var streams are referenced in the measures (non-aggregated only)
foreach (var @ref in streamRefVisitor.Referenced) {
var rootPropName = @ref.RootPropertyNameIfAny;
if (rootPropName != null) {
if (variablesMultiple.Contains(rootPropName)) {
measureReferencesMultivar = true;
break;
}
}
var streamRequired = @ref.StreamReferencedIfAny;
if (streamRequired != null) {
var streamVariable = streamVariables.Get(streamRequired.Value);
if (streamVariable != null) {
var def = variableStreams.Get(streamVariable);
if (def != null && def.Second) {
measureReferencesMultivar = true;
break;
}
}
}
}
var collectMultimatches = measureReferencesMultivar || defineAsksMultimatches;
// create rowevent type
var rowTypeName = services.EventTypeNameGeneratorStatement.AnonymousRowrecogRowName;
var rowTypeMetadata = new EventTypeMetadata(
rowTypeName,
@base.ModuleName,
EventTypeTypeClass.MATCHRECOGDERIVED,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var rowEventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
rowTypeMetadata,
rowTypeDef,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(rowEventType);
// validate partition-by expressions, if any
ExprNode[] partitionBy;
MultiKeyClassRef partitionMultiKey;
if (!matchRecognizeSpec.PartitionByExpressions.IsEmpty()) {
StreamTypeService typeServicePartition = new StreamTypeServiceImpl(
parentEventType,
"MATCH_RECOGNIZE_PARTITION",
true);
IList<ExprNode> validated = new List<ExprNode>();
var validationContext =
new ExprValidationContextBuilder(typeServicePartition, statementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
foreach (var partitionExpr in matchRecognizeSpec.PartitionByExpressions) {
validated.Add(
ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.MATCHRECOGPARTITION,
partitionExpr,
validationContext));
}
matchRecognizeSpec.PartitionByExpressions = validated;
partitionBy = ExprNodeUtilityQuery.ToArray(validated);
MultiKeyPlan multiKeyPlan = MultiKeyPlanner.PlanMultiKey(partitionBy, false, @base.StatementRawInfo, services.SerdeResolver);
partitionMultiKey = multiKeyPlan.ClassRef;
additionalForgeables.AddAll(multiKeyPlan.MultiKeyForgeables);
}
else {
partitionBy = null;
partitionMultiKey = null;
}
// validate interval if present
if (matchRecognizeSpec.Interval != null) {
var validationContext =
new ExprValidationContextBuilder(new StreamTypeServiceImpl(false), statementRawInfo, services)
.WithAllowBindingConsumption(true)
.Build();
var validated = (ExprTimePeriod) ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.MATCHRECOGINTERVAL,
matchRecognizeSpec.Interval.TimePeriodExpr,
validationContext);
matchRecognizeSpec.Interval.TimePeriodExpr = validated;
}
// compile variable definition expressions
IDictionary<string, ExprNode> variableDefinitions = new Dictionary<string, ExprNode>();
foreach (var defineItem in matchRecognizeSpec.Defines) {
variableDefinitions.Put(defineItem.Identifier, defineItem.Expression);
}
// create evaluators
var columnNames = new string[matchRecognizeSpec.Measures.Count];
var columnForges = new ExprNode[matchRecognizeSpec.Measures.Count];
var count = 0;
foreach (var measureItem in matchRecognizeSpec.Measures) {
columnNames[count] = measureItem.Name;
columnForges[count] = measureItem.Expr;
count++;
}
// build states
var strand = RowRecogHelper.BuildStartStates(
expandedPatternNode,
variableDefinitions,
variableStreams,
isExprRequiresMultimatchState);
var startStates = strand.StartStates.ToArray();
RowRecogNFAStateForge[] allStates = strand.AllStates.ToArray();
if (Log.IsInfoEnabled) {
Log.Info("NFA tree:\n" + RowRecogNFAViewUtil.Print(startStates));
}
// determine names of multimatching variables
string[] multimatchVariablesArray;
int[] multimatchStreamNumToVariable;
int[] multimatchVariableToStreamNum;
if (variablesSingle.Count == variableStreams.Count) {
multimatchVariablesArray = new string[0];
multimatchStreamNumToVariable = new int[0];
multimatchVariableToStreamNum = new int[0];
}
else {
multimatchVariablesArray = new string[variableStreams.Count - variablesSingle.Count];
multimatchVariableToStreamNum = new int[multimatchVariablesArray.Length];
multimatchStreamNumToVariable = new int[variableStreams.Count];
CompatExtensions.Fill(multimatchStreamNumToVariable, -1);
count = 0;
foreach (var entry in variableStreams) {
if (entry.Value.Second) {
var index = count;
multimatchVariablesArray[index] = entry.Key;
multimatchVariableToStreamNum[index] = entry.Value.First;
multimatchStreamNumToVariable[entry.Value.First] = index;
count++;
}
}
}
var numEventsEventsPerStreamDefine =
defineAsksMultimatches ? variableStreams.Count + 1 : variableStreams.Count;
// determine interval-or-terminated
var orTerminated = matchRecognizeSpec.Interval != null && matchRecognizeSpec.Interval.IsOrTerminated;
TimePeriodComputeForge intervalCompute = null;
if (matchRecognizeSpec.Interval != null) {
intervalCompute = matchRecognizeSpec.Interval.TimePeriodExpr.TimePeriodComputeForge;
}
EventType multimatchEventType = null;
if (defineAsksMultimatches) {
multimatchEventType = GetDefineMultimatchEventType(variableStreams, parentEventType, @base, services);
}
// determine previous-access indexes and assign "prev" node indexes
// Since an expression such as "prior(2, price), prior(8, price)" translates into {2, 8} the relative index is {0, 1}.
// Map the expression-supplied index to a relative index
int[] previousRandomAccessIndexes = null;
if (!previousNodes.IsEmpty()) {
previousRandomAccessIndexes = new int[previousNodes.Count];
var countPrev = 0;
foreach (var entry in previousNodes) {
previousRandomAccessIndexes[countPrev] = entry.Key;
foreach (var callback in entry.Value) {
callback.AssignedIndex = countPrev;
}
countPrev++;
}
}
RowRecogDescForge forge = new RowRecogDescForge(
parentEventType,
rowEventType,
compositeEventType,
multimatchEventType,
multimatchStreamNumToVariable,
multimatchVariableToStreamNum,
partitionBy,
partitionMultiKey,
variableStreams,
matchRecognizeSpec.Interval != null,
iterateOnly,
unbound,
orTerminated,
collectMultimatches,
defineAsksMultimatches,
numEventsEventsPerStreamDefine,
multimatchVariablesArray,
startStates,
allStates,
matchRecognizeSpec.IsAllMatches,
matchRecognizeSpec.Skip.Skip,
columnForges,
columnNames,
intervalCompute,
previousRandomAccessIndexes,
aggregationServices);
return new RowRecogPlan(forge, additionalForgeables);
}
private TableAccessAnalysisResult AnalyzePlanAggregations(
string tableName,
IList<TableColumnDesc> columns,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
// once upfront: obtains aggregation factories for each aggregation
// we do this once as a factory may be a heavier object
IDictionary<TableColumnDesc, AggregationForgeFactory> aggregationFactories =
new Dictionary<TableColumnDesc, AggregationForgeFactory>();
foreach (var column in columns) {
if (column is TableColumnDescAgg) {
var agg = (TableColumnDescAgg) column;
var factory = agg.Aggregation.Factory;
aggregationFactories.Put(column, factory);
}
}
// sort into these categories:
// plain / method-agg / access-agg
// compile all-column public types
IList<TableColumnDescTyped> plainColumns = new List<TableColumnDescTyped>();
IList<TableColumnDescAgg> methodAggColumns = new List<TableColumnDescAgg>();
IList<TableColumnDescAgg> accessAggColumns = new List<TableColumnDescAgg>();
var allColumnsPublicTypes = new LinkedHashMap<string, object>();
foreach (var column in columns) {
// handle plain types
if (column is TableColumnDescTyped) {
var typed = (TableColumnDescTyped) column;
plainColumns.Add(typed);
allColumnsPublicTypes.Put(column.ColumnName, typed.UnresolvedType);
continue;
}
// handle aggs
var agg = (TableColumnDescAgg) column;
var aggFactory = aggregationFactories.Get(agg);
if (aggFactory.IsAccessAggregation) {
accessAggColumns.Add(agg);
}
else {
methodAggColumns.Add(agg);
}
allColumnsPublicTypes.Put(column.ColumnName, agg.Aggregation.EvaluationType);
}
// determine column metadata
//
var columnMetadata = new LinkedHashMap<string, TableMetadataColumn>();
// handle typed columns
var allColumnsInternalTypes = new LinkedHashMap<string, object>();
allColumnsInternalTypes.Put(INTERNAL_RESERVED_PROPERTY, typeof(object));
var indexPlain = 1;
var assignPairsPlain = new TableMetadataColumnPairPlainCol[plainColumns.Count];
foreach (var typedColumn in plainColumns) {
allColumnsInternalTypes.Put(typedColumn.ColumnName, typedColumn.UnresolvedType);
columnMetadata.Put(
typedColumn.ColumnName,
new TableMetadataColumnPlain(typedColumn.ColumnName, typedColumn.IsKey, indexPlain));
assignPairsPlain[indexPlain - 1] = new TableMetadataColumnPairPlainCol(
typedColumn.PositionInDeclaration,
indexPlain);
indexPlain++;
}
// determine internally-used event type
var visibility = services.ModuleVisibilityRules.GetAccessModifierTable(@base, tableName);
var internalName = EventTypeNameUtil.GetTableInternalTypeName(tableName);
var internalMetadata = new EventTypeMetadata(
internalName,
@base.ModuleName,
EventTypeTypeClass.TABLE_INTERNAL,
EventTypeApplicationType.OBJECTARR,
visibility,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var internalEventType = BaseNestableEventUtil.MakeOATypeCompileTime(
internalMetadata,
allColumnsInternalTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(internalEventType);
// for use by indexes and lookups
var publicName = EventTypeNameUtil.GetTablePublicTypeName(tableName);
var publicMetadata = new EventTypeMetadata(
publicName,
@base.ModuleName,
EventTypeTypeClass.TABLE_PUBLIC,
EventTypeApplicationType.OBJECTARR,
visibility,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var publicEventType = BaseNestableEventUtil.MakeOATypeCompileTime(
publicMetadata,
allColumnsPublicTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(publicEventType);
// handle aggregation-methods single-func first.
var methodFactories = new AggregationForgeFactory[methodAggColumns.Count];
var index = 0;
var assignPairsMethod = new TableMetadataColumnPairAggMethod[methodAggColumns.Count];
foreach (var column in methodAggColumns) {
var factory = aggregationFactories.Get(column);
var optionalEnumerationType = EPTypeHelper.OptionalFromEnumerationExpr(
statementRawInfo,
services,
column.Aggregation);
methodFactories[index] = factory;
var bindingInfo = factory.AggregationPortableValidation;
var expression =
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(factory.AggregationExpression);
columnMetadata.Put(
column.ColumnName,
new TableMetadataColumnAggregation(
column.ColumnName,
false,
index,
bindingInfo,
expression,
true,
optionalEnumerationType));
assignPairsMethod[index] = new TableMetadataColumnPairAggMethod(column.PositionInDeclaration);
index++;
}
// handle access-aggregation (sharable, multi-value) aggregations
var stateFactories = new AggregationStateFactoryForge[accessAggColumns.Count];
var accessAccessorForges = new AggregationAccessorSlotPairForge[accessAggColumns.Count];
var assignPairsAccess = new TableMetadataColumnPairAggAccess[accessAggColumns.Count];
var accessNum = 0;
foreach (var column in accessAggColumns) {
var factory = aggregationFactories.Get(column);
var forge = factory.GetAggregationStateFactory(false);
stateFactories[accessNum] = forge;
var accessor = factory.AccessorForge;
var bindingInfo = factory.AggregationPortableValidation;
accessAccessorForges[accessNum] = new AggregationAccessorSlotPairForge(accessNum, accessor);
var expression =
ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(factory.AggregationExpression);
var optionalEnumerationType = EPTypeHelper.OptionalFromEnumerationExpr(
statementRawInfo,
services,
column.Aggregation);
columnMetadata.Put(
column.ColumnName,
new TableMetadataColumnAggregation(
column.ColumnName,
false,
index,
bindingInfo,
expression,
false,
optionalEnumerationType));
assignPairsAccess[accessNum] =
new TableMetadataColumnPairAggAccess(column.PositionInDeclaration, accessor);
index++;
accessNum++;
}
// determine primary key index information
var primaryKeyColumns = new List<string>();
var primaryKeyTypes = new List<Type>();
var primaryKeyGetters = new List<EventPropertyGetterSPI>();
var primaryKeyColNums = new List<int>();
var colNum = -1;
foreach (var typedColumn in plainColumns) {
colNum++;
if (typedColumn.IsKey) {
primaryKeyColumns.Add(typedColumn.ColumnName);
primaryKeyTypes.Add(internalEventType.GetPropertyType(typedColumn.ColumnName));
primaryKeyGetters.Add(internalEventType.GetGetterSPI(typedColumn.ColumnName));
primaryKeyColNums.Add(colNum + 1);
}
}
string[] primaryKeyColumnArray = null;
Type[] primaryKeyTypeArray = null;
EventPropertyGetterSPI[] primaryKeyGetterArray = null;
int[] primaryKeyColNumsArray = null;
if (!primaryKeyColumns.IsEmpty()) {
primaryKeyColumnArray = primaryKeyColumns.ToArray();
primaryKeyTypeArray = primaryKeyTypes.ToArray();
primaryKeyGetterArray = primaryKeyGetters.ToArray();
primaryKeyColNumsArray = primaryKeyColNums.ToArray();
}
var forgeDesc = new AggregationRowStateForgeDesc(
methodFactories,
null,
stateFactories,
accessAccessorForges,
new AggregationUseFlags(false, false, false));
var multiKeyPlan = MultiKeyPlanner.PlanMultiKey(
primaryKeyTypeArray, false, statementRawInfo, services.SerdeResolver);
var propertyForges = new DataInputOutputSerdeForge[internalEventType.PropertyNames.Length - 1];
var additionalForgeables = new List<StmtClassForgeableFactory>(multiKeyPlan.MultiKeyForgeables);
for (var i = 1; i < internalEventType.PropertyNames.Length; i++) {
var propertyName = internalEventType.PropertyNames[i];
var propertyType = internalEventType.Types.Get(propertyName);
var desc = SerdeEventPropertyUtility.ForgeForEventProperty(
publicEventType, propertyName, propertyType, statementRawInfo, services.SerdeResolver);
propertyForges[i - 1] = desc.Forge;
// plan serdes for nested types
foreach (var eventType in desc.NestedTypes) {
var serdeForgeables = SerdeEventTypeUtility.Plan(
eventType,
statementRawInfo,
services.SerdeEventTypeRegistry,
services.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
}
return new TableAccessAnalysisResult(
columnMetadata,
internalEventType,
propertyForges,
publicEventType,
assignPairsPlain,
assignPairsMethod,
assignPairsAccess,
forgeDesc,
primaryKeyColumnArray,
primaryKeyGetterArray,
primaryKeyTypeArray,
primaryKeyColNumsArray,
multiKeyPlan.ClassRef,
additionalForgeables);
}
public static SelectExprProcessorForgeWForgables Create(
SelectProcessorArgs args,
InsertIntoDesc insertIntoDesc,
Func<String, String> eventTypeNamePostfix)
{
var streamNames = args.TypeService.StreamNames;
var streamTypes = args.TypeService.EventTypes;
var moduleName = args.ModuleName;
var additionalForgeables = new List<StmtClassForgeableFactory>();
if (streamNames.Length < 2 || streamTypes.Length < 2 || streamNames.Length != streamTypes.Length) {
throw new ArgumentException(
"Stream names and types parameter length is invalid, expected use of this class is for join statements");
}
// Create EventType of result join events
var selectProperties = new LinkedHashMap<string, object>();
var streamTypesWTables = new EventType[streamTypes.Length];
var hasTables = false;
for (var i = 0; i < streamTypes.Length; i++) {
streamTypesWTables[i] = streamTypes[i];
var table = args.TableCompileTimeResolver.ResolveTableFromEventType(streamTypesWTables[i]);
if (table != null) {
hasTables = true;
streamTypesWTables[i] = table.PublicEventType;
}
selectProperties.Put(streamNames[i], streamTypesWTables[i]);
}
// If we have a name for this type, add it
var representation = EventRepresentationUtil.GetRepresentation(
args.Annotations,
args.Configuration,
AssignedType.NONE);
EventType resultEventType;
SelectExprProcessorForge processor = null;
if (insertIntoDesc != null) {
var existingType = args.EventTypeCompileTimeResolver.GetTypeByName(insertIntoDesc.EventTypeName);
if (existingType != null) {
processor = SelectExprInsertEventBeanFactory.GetInsertUnderlyingJoinWildcard(
existingType,
streamNames,
streamTypesWTables,
args.ImportService,
args.StatementName,
args.EventTypeAvroHandler);
}
}
if (processor == null) {
if (insertIntoDesc != null) {
var eventTypeName = eventTypeNamePostfix.Invoke(insertIntoDesc.EventTypeName);
var visibility =
args.CompileTimeServices.ModuleVisibilityRules.GetAccessModifierEventType(
args.StatementRawInfo,
eventTypeName);
var metadata = new Func<EventTypeApplicationType, EventTypeMetadata>(
apptype => new EventTypeMetadata(
eventTypeName,
moduleName,
EventTypeTypeClass.STREAM,
apptype,
visibility,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned()));
if (representation == EventUnderlyingType.MAP) {
IDictionary<string, object> propertyTypes =
EventTypeUtility.GetPropertyTypesNonPrimitive(selectProperties);
resultEventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata.Invoke(EventTypeApplicationType.MAP),
propertyTypes,
null,
null,
null,
null,
args.BeanEventTypeFactoryPrivate,
args.EventTypeCompileTimeResolver);
}
else if (representation == EventUnderlyingType.OBJECTARRAY) {
IDictionary<string, object> propertyTypes =
EventTypeUtility.GetPropertyTypesNonPrimitive(selectProperties);
resultEventType = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata.Invoke(EventTypeApplicationType.OBJECTARR),
propertyTypes,
null,
null,
null,
null,
args.BeanEventTypeFactoryPrivate,
args.EventTypeCompileTimeResolver);
}
else if (representation == EventUnderlyingType.AVRO) {
resultEventType = args.EventTypeAvroHandler.NewEventTypeFromNormalized(
metadata.Invoke(EventTypeApplicationType.AVRO),
args.EventTypeCompileTimeResolver,
EventBeanTypedEventFactoryCompileTime.INSTANCE,
selectProperties,
args.Annotations,
null,
null,
null,
args.StatementName);
} else if (representation == EventUnderlyingType.JSON) {
EventTypeForgeablesPair pair = JsonEventTypeUtility.MakeJsonTypeCompileTimeNewType(
metadata.Invoke(EventTypeApplicationType.JSON),
selectProperties,
null,
null,
args.StatementRawInfo,
args.CompileTimeServices);
resultEventType = pair.EventType;
additionalForgeables.AddAll(pair.AdditionalForgeables);
}
else {
throw new IllegalStateException("Unrecognized code " + representation);
}
args.EventTypeCompileTimeRegistry.NewType(resultEventType);
}
else {
var eventTypeName = eventTypeNamePostfix.Invoke(
args.CompileTimeServices.EventTypeNameGeneratorStatement.AnonymousTypeName);
IDictionary<string, object> propertyTypes =
EventTypeUtility.GetPropertyTypesNonPrimitive(selectProperties);
var metadata = new Func<EventTypeApplicationType, EventTypeMetadata>(
type => new EventTypeMetadata(
eventTypeName,
moduleName,
EventTypeTypeClass.STATEMENTOUT,
type,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned()));
if (representation == EventUnderlyingType.MAP) {
resultEventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata.Invoke(EventTypeApplicationType.MAP),
propertyTypes,
null,
null,
null,
null,
args.BeanEventTypeFactoryPrivate,
args.EventTypeCompileTimeResolver);
}
else if (representation == EventUnderlyingType.OBJECTARRAY) {
resultEventType = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata.Invoke(EventTypeApplicationType.OBJECTARR),
propertyTypes,
null,
null,
null,
null,
args.BeanEventTypeFactoryPrivate,
args.EventTypeCompileTimeResolver);
}
else if (representation == EventUnderlyingType.AVRO) {
resultEventType = args.EventTypeAvroHandler.NewEventTypeFromNormalized(
metadata.Invoke(EventTypeApplicationType.AVRO),
args.EventTypeCompileTimeResolver,
args.BeanEventTypeFactoryPrivate.EventBeanTypedEventFactory,
selectProperties,
args.Annotations,
null,
null,
null,
args.StatementName);
} else if (representation == EventUnderlyingType.JSON) {
EventTypeForgeablesPair pair = JsonEventTypeUtility.MakeJsonTypeCompileTimeNewType(
metadata.Invoke(EventTypeApplicationType.JSON),
propertyTypes,
null,
null,
args.StatementRawInfo,
args.CompileTimeServices);
resultEventType = pair.EventType;
additionalForgeables.AddAll(pair.AdditionalForgeables);
}
else {
throw new IllegalStateException("Unrecognized enum " + representation);
}
args.EventTypeCompileTimeRegistry.NewType(resultEventType);
}
// NOTE: Processors herein maintain their own result-event-type as they become inner types,
// for example "insert into VariantStream select * from A, B"
if (resultEventType is ObjectArrayEventType) {
processor = new SelectEvalJoinWildcardProcessorObjectArray(streamNames, resultEventType);
}
else if (resultEventType is MapEventType) {
processor = new SelectEvalJoinWildcardProcessorMap(streamNames, resultEventType);
}
else if (resultEventType is AvroSchemaEventType) {
processor = args.EventTypeAvroHandler.OutputFactory.MakeJoinWildcard(streamNames, resultEventType);
} else if (resultEventType is JsonEventType) {
processor = new SelectEvalJoinWildcardProcessorJson(streamNames, (JsonEventType) resultEventType);
}
}
if (!hasTables) {
return new SelectExprProcessorForgeWForgables(processor, additionalForgeables);
}
processor = new SelectEvalJoinWildcardProcessorTableRows(streamTypes, processor, args.TableCompileTimeResolver);
return new SelectExprProcessorForgeWForgables(processor, additionalForgeables);
}
// The create window command:
// create window windowName[.window_view_list] as [select properties from] type
//
// This section expected s single FilterStreamSpecCompiled representing the selected type.
// It creates a new event type representing the window type and a sets the type selected on the filter stream spec.
protected internal static CreateWindowCompileResult HandleCreateWindow(
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
var createWindowDesc = @base.StatementSpec.Raw.CreateWindowDesc;
var columns = createWindowDesc.Columns;
var typeName = createWindowDesc.WindowName;
EventType targetType;
// determine that the window name is not already in use as an event type name
var existingType = services.EventTypeCompileTimeResolver.GetTypeByName(typeName);
if (existingType != null && existingType.Metadata.TypeClass != EventTypeTypeClass.NAMED_WINDOW) {
throw new ExprValidationException(
"Error starting statement: An event type or schema by name '" + typeName + "' already exists");
}
// Determine select-from
var optionalSelectFrom = GetOptionalSelectFrom(createWindowDesc, services);
// Create Map or Wrapper event type from the select clause of the window.
// If no columns selected, simply create a wrapper type
// Build a list of properties
var newSelectClauseSpecRaw = new SelectClauseSpecRaw();
LinkedHashMap<string, object> properties;
var hasProperties = false;
if (columns != null && !columns.IsEmpty()) {
properties = EventTypeUtility.BuildType(
columns,
null,
services.ImportServiceCompileTime,
services.EventTypeCompileTimeResolver);
hasProperties = true;
}
else {
if (optionalSelectFrom == null) {
throw new IllegalStateException("Missing from-type information for create-window");
}
// Validate the select expressions which consists of properties only
var select = CompileLimitedSelect(optionalSelectFrom, @base, services);
properties = new LinkedHashMap<string, object>();
foreach (var selectElement in select) {
if (selectElement.FragmentType != null) {
properties.Put(selectElement.AssignedName, selectElement.FragmentType);
}
else {
properties.Put(selectElement.AssignedName, selectElement.SelectExpressionType);
}
// Add any properties to the new select clause for use by consumers to the statement itself
newSelectClauseSpecRaw.Add(
new SelectClauseExprRawSpec(new ExprIdentNodeImpl(selectElement.AssignedName), null, false));
hasProperties = true;
}
}
// Create Map or Wrapper event type from the select clause of the window.
// If no columns selected, simply create a wrapper type
var isOnlyWildcard = @base.StatementSpec.Raw.SelectClauseSpec.IsOnlyWildcard;
var isWildcard = @base.StatementSpec.Raw.SelectClauseSpec.IsUsingWildcard;
var namedWindowVisibility = services.ModuleVisibilityRules.GetAccessModifierNamedWindow(@base, typeName);
var additionalForgeables = new List<StmtClassForgeableFactory>();
try {
if (isWildcard && !isOnlyWildcard) {
var metadata = new EventTypeMetadata(
typeName,
@base.ModuleName,
EventTypeTypeClass.NAMED_WINDOW,
EventTypeApplicationType.WRAPPER,
namedWindowVisibility,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
targetType = WrapperEventTypeUtil.MakeWrapper(
metadata,
optionalSelectFrom.EventType,
properties,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
}
else {
// Some columns selected, use the types of the columns
Func<EventTypeApplicationType, EventTypeMetadata> metadata = type => new EventTypeMetadata(
typeName,
@base.ModuleName,
EventTypeTypeClass.NAMED_WINDOW,
type,
namedWindowVisibility,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
if (hasProperties && !isOnlyWildcard) {
var compiledProperties = EventTypeUtility.CompileMapTypeProperties(
properties,
services.EventTypeCompileTimeResolver);
var representation = EventRepresentationUtil.GetRepresentation(
@base.StatementSpec.Annotations,
services.Configuration,
AssignedType.NONE);
if (representation == EventUnderlyingType.MAP) {
targetType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata.Invoke(EventTypeApplicationType.MAP),
compiledProperties,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
}
else if (representation == EventUnderlyingType.OBJECTARRAY) {
targetType = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata.Invoke(EventTypeApplicationType.OBJECTARR),
compiledProperties,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
}
else if (representation == EventUnderlyingType.AVRO) {
targetType = services.EventTypeAvroHandler.NewEventTypeFromNormalized(
metadata.Invoke(EventTypeApplicationType.AVRO),
services.EventTypeCompileTimeResolver,
services.BeanEventTypeFactoryPrivate.EventBeanTypedEventFactory,
compiledProperties,
@base.StatementRawInfo.Annotations,
null,
null,
null,
@base.StatementName);
} else if (representation == EventUnderlyingType.JSON) {
EventTypeForgeablesPair pair = JsonEventTypeUtility.MakeJsonTypeCompileTimeNewType(
metadata.Invoke(EventTypeApplicationType.JSON),
compiledProperties,
null,
null,
@base.StatementRawInfo,
services);
targetType = pair.EventType;
additionalForgeables.AddRange(pair.AdditionalForgeables);
}
else {
throw new IllegalStateException("Unrecognized representation " + representation);
}
}
else {
if (optionalSelectFrom == null) {
throw new IllegalStateException("Missing from-type information for create-window");
}
var selectFromType = optionalSelectFrom.EventType;
// No columns selected, no wildcard, use the type as is or as a wrapped type
if (selectFromType is ObjectArrayEventType) {
var oaType = (ObjectArrayEventType) selectFromType;
targetType = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata.Invoke(EventTypeApplicationType.OBJECTARR),
oaType.Types,
null,
null,
oaType.StartTimestampPropertyName,
oaType.EndTimestampPropertyName,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
}
else if (selectFromType is AvroSchemaEventType) {
var avroSchemaEventType = (AvroSchemaEventType) selectFromType;
var avro = new ConfigurationCommonEventTypeAvro();
avro.AvroSchema = avroSchemaEventType.Schema;
targetType = services.EventTypeAvroHandler.NewEventTypeFromSchema(
metadata.Invoke(EventTypeApplicationType.AVRO),
services.BeanEventTypeFactoryPrivate.EventBeanTypedEventFactory,
avro,
null,
null);
} else if (selectFromType is JsonEventType) {
JsonEventType jsonType = (JsonEventType) selectFromType;
targetType = JsonEventTypeUtility.MakeJsonTypeCompileTimeExistingType(
metadata.Invoke(EventTypeApplicationType.JSON),
jsonType,
services);
}
else if (selectFromType is MapEventType) {
var mapType = (MapEventType) selectFromType;
targetType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata.Invoke(EventTypeApplicationType.MAP),
mapType.Types,
null,
null,
mapType.StartTimestampPropertyName,
mapType.EndTimestampPropertyName,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
}
else if (selectFromType is BeanEventType) {
var beanType = (BeanEventType) selectFromType;
targetType = new BeanEventType(
services.Container,
beanType.Stem,
metadata.Invoke(EventTypeApplicationType.CLASS),
services.BeanEventTypeFactoryPrivate,
null,
null,
beanType.StartTimestampPropertyName,
beanType.EndTimestampPropertyName);
}
else {
targetType = WrapperEventTypeUtil.MakeWrapper(
metadata.Invoke(EventTypeApplicationType.WRAPPER),
selectFromType,
new Dictionary<string, object>(),
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
}
}
}
services.EventTypeCompileTimeRegistry.NewType(targetType);
}
catch (EPException ex) {
throw new ExprValidationException(ex.Message, ex);
}
var filter = new FilterSpecCompiled(targetType, typeName, FilterSpecPlanForge.EMPTY, null);
return new CreateWindowCompileResult(
filter,
newSelectClauseSpecRaw,
optionalSelectFrom?.EventType,
additionalForgeables);
}