public ResultSetSpec(
SelectClauseStreamSelectorEnum selectClauseStreamSelector,
IList<OrderByItem> orderByList,
SelectClauseSpecCompiled selectClauseSpec,
InsertIntoDesc insertIntoDesc,
GroupByClauseExpressions groupByClauseExpressions,
ExprNode whereClause,
ExprNode havingClause,
OutputLimitSpec optionalOutputLimitSpec,
RowLimitSpec rowLimitSpec,
string contextName,
ForClauseSpec forClauseSpec,
IntoTableSpec intoTableSpec,
StreamSpecCompiled[] streamSpecs,
Attribute[] annotations)
{
this.SelectClauseStreamSelector = selectClauseStreamSelector;
this.OrderByList = orderByList;
this.SelectClauseSpec = selectClauseSpec;
this.InsertIntoDesc = insertIntoDesc;
this.GroupByClauseExpressions = groupByClauseExpressions;
this.WhereClause = whereClause;
this.HavingClause = havingClause;
this.OptionalOutputLimitSpec = optionalOutputLimitSpec;
this.RowLimitSpec = rowLimitSpec;
this.ContextName = contextName;
this.ForClauseSpec = forClauseSpec;
this.IntoTableSpec = intoTableSpec;
this.StreamSpecs = streamSpecs;
this.Annotations = annotations;
}
public void SetUp()
{
_container = SupportContainer.Reset();
var selectList = SupportSelectExprFactory.MakeNoAggregateSelectList();
var eventAdapterService = _container.Resolve <EventAdapterService>();
var vaeService = new SupportValueAddEventService();
var selectExprEventTypeRegistry = new SelectExprEventTypeRegistry(
"abc", new StatementEventTypeRefImpl(_container.RWLockManager()));
var engineImportService = SupportEngineImportServiceFactory.Make(_container);
_methodOne = new SelectExprProcessorHelper(
Collections.GetEmptyList <int>(), selectList, Collections.GetEmptyList <SelectExprStreamDesc>(),
null, null, false, new SupportStreamTypeSvc1Stream(), eventAdapterService, vaeService,
selectExprEventTypeRegistry, engineImportService, 1, "stmtname", null,
new Configuration(_container), null,
new TableServiceImpl(_container), null);
var insertIntoDesc = new InsertIntoDesc(SelectClauseStreamSelectorEnum.ISTREAM_ONLY, "Hello");
insertIntoDesc.Add("a");
insertIntoDesc.Add("b");
_methodTwo = new SelectExprProcessorHelper(
Collections.GetEmptyList <int>(), selectList, Collections.GetEmptyList <SelectExprStreamDesc>(),
insertIntoDesc, null, false, new SupportStreamTypeSvc1Stream(), eventAdapterService, vaeService,
selectExprEventTypeRegistry, engineImportService, 1, "stmtname", null,
new Configuration(_container), null,
new TableServiceImpl(_container), null);
}
private NamedWindowOnMergeActionIns SetupInsert(string namedWindowName, InternalEventRouter internalEventRouter, EventTypeSPI eventTypeNamedWindow, int selectClauseNumber, OnTriggerMergeActionInsert desc, EventType triggeringEventType, string triggeringStreamName, StatementContext statementContext)
{
// Compile insert-into INFO
string streamName = desc.OptionalStreamName ?? eventTypeNamedWindow.Name;
var insertIntoDesc = InsertIntoDesc.FromColumns(streamName, desc.Columns);
// rewrite any wildcards to use "stream.wildcard"
if (triggeringStreamName == null)
{
triggeringStreamName = UuidGenerator.Generate();
}
var selectNoWildcard = CompileSelectNoWildcard(triggeringStreamName, desc.SelectClauseCompiled);
// Set up event types for select-clause evaluation: The first type does not contain anything as its the named window row which is not present for insert
var dummyTypeNoProperties = new MapEventType(EventTypeMetadata.CreateAnonymous("merge_named_window_insert", ApplicationType.MAP), "merge_named_window_insert", 0, null, Collections.EmptyDataMap, null, null, null);
var eventTypes = new EventType[] { dummyTypeNoProperties, triggeringEventType };
var streamNames = new string[] { UuidGenerator.Generate(), triggeringStreamName };
var streamTypeService = new StreamTypeServiceImpl(eventTypes, streamNames, new bool[1], statementContext.EngineURI, false);
// Get select expr processor
var selectExprEventTypeRegistry = new SelectExprEventTypeRegistry(statementContext.StatementName, statementContext.StatementEventTypeRef);
var exprEvaluatorContext = new ExprEvaluatorContextStatement(statementContext, false);
var insertHelper = SelectExprProcessorFactory.GetProcessor(
statementContext.Container,
Collections.SingletonList(selectClauseNumber),
selectNoWildcard.ToArray(), false,
insertIntoDesc, null, null, streamTypeService,
statementContext.EventAdapterService,
statementContext.StatementResultService,
statementContext.ValueAddEventService,
selectExprEventTypeRegistry,
statementContext.EngineImportService,
exprEvaluatorContext,
statementContext.VariableService,
statementContext.ScriptingService,
statementContext.TableService,
statementContext.TimeProvider,
statementContext.EngineURI,
statementContext.StatementId,
statementContext.StatementName,
statementContext.Annotations,
statementContext.ContextDescriptor,
statementContext.ConfigSnapshot, null,
statementContext.NamedWindowMgmtService, null, null,
statementContext.StatementExtensionServicesContext);
var filterEval = desc.OptionalWhereClause == null ? null : desc.OptionalWhereClause.ExprEvaluator;
var routerToUser = streamName.Equals(namedWindowName) ? null : internalEventRouter;
var audit = AuditEnum.INSERT.GetAudit(statementContext.Annotations) != null;
string insertIntoTableName = null;
if (statementContext.TableService.GetTableMetadata(insertIntoDesc.EventTypeName) != null)
{
insertIntoTableName = insertIntoDesc.EventTypeName;
}
return(new NamedWindowOnMergeActionIns(filterEval, insertHelper, routerToUser, insertIntoTableName, statementContext.TableService, statementContext.EpStatementHandle, statementContext.InternalEventEngineRouteDest, audit));
}
private static SelectExprProcessorWInsertTarget GetProcessorInternal(
SelectProcessorArgs args,
InsertIntoDesc insertIntoDesc)
{
// Wildcard not allowed when insert into specifies column order
if (args.IsUsingWildcard && insertIntoDesc != null && !insertIntoDesc.ColumnNames.IsEmpty()) {
throw new ExprValidationException("Wildcard not allowed when insert-into specifies column order");
}
var insertIntoTarget = insertIntoDesc == null
? null
: args.EventTypeCompileTimeResolver.GetTypeByName(insertIntoDesc.EventTypeName);
// Determine wildcard processor (select *)
if (IsWildcardsOnly(args.SelectionList)) {
// For joins
if (args.TypeService.StreamNames.Length > 1 && !(insertIntoTarget is VariantEventType)) {
Log.Debug(".getProcessor Using SelectExprJoinWildcardProcessor");
SelectExprProcessorForgeWForgables pair = SelectExprJoinWildcardProcessorFactory.Create(args, insertIntoDesc, eventTypeName => eventTypeName);
SelectExprProcessorForge forgeX = pair.Forge;
return new SelectExprProcessorWInsertTarget(forgeX, null, pair.AdditionalForgeables);
}
if (insertIntoDesc == null) {
// Single-table selects with no insert-into
// don't need extra processing
Log.Debug(".getProcessor Using wildcard processor");
if (args.TypeService.HasTableTypes) {
var table = args.TableCompileTimeResolver.ResolveTableFromEventType(
args.TypeService.EventTypes[0]);
if (table != null) {
SelectExprProcessorForge forgeX = new SelectEvalWildcardTable(table);
return new SelectExprProcessorWInsertTarget(forgeX, null, EmptyList<StmtClassForgeableFactory>.Instance);
}
}
SelectExprProcessorForge forgeOuter = new SelectEvalWildcardNonJoin(args.TypeService.EventTypes[0]);
return new SelectExprProcessorWInsertTarget(forgeOuter, null, EmptyList<StmtClassForgeableFactory>.Instance);
}
}
// Verify the assigned or name used is unique
if (insertIntoDesc == null) {
VerifyNameUniqueness(args.SelectionList);
}
// Construct processor
var buckets = GetSelectExpressionBuckets(args.SelectionList);
var factory = new SelectExprProcessorHelper(
buckets.Expressions,
buckets.SelectedStreams,
args,
insertIntoDesc);
return factory.Forge;
}
private StatementSpecCompiled MakeSpec(SelectClauseSpecCompiled selectClauseSpec,
InsertIntoDesc insertIntoDesc,
IList <ExprNode> groupByNodes,
ExprNode optionalHavingNode,
OutputLimitSpec outputLimitSpec,
IList <OrderByItem> orderByList)
{
return(new StatementSpecCompiled(null, // on trigger
null, // create win
null, // create index
null, // create var
null, // create agg var
null, // create schema
insertIntoDesc,
SelectClauseStreamSelectorEnum.ISTREAM_ONLY,
selectClauseSpec,
new StreamSpecCompiled[0], // stream specs
null, // outer join
null,
optionalHavingNode,
outputLimitSpec,
OrderByItem.ToArray(orderByList),
null,
null,
null,
null,
null,
CollectionUtil.EMPTY_STRING_ARRAY,
new Attribute[0],
null,
null,
null,
null,
null,
null,
null,
null,
null,
new GroupByClauseExpressions(ExprNodeUtility.ToArray(groupByNodes)),
null,
null
));
}
public static SelectExprProcessor GetInsertUnderlyingNonJoin(
EventAdapterService eventAdapterService,
EventType eventType,
bool isUsingWildcard,
StreamTypeService typeService,
ExprEvaluator[] expressionNodes,
string[] columnNames,
Object[] expressionReturnTypes,
EngineImportService engineImportService,
InsertIntoDesc insertIntoDesc,
string[] columnNamesAsProvided,
bool allowNestableTargetFragmentTypes,
string statementName)
{
// handle single-column coercion to underlying, i.e. "insert into MapDefinedEvent select DoSomethingReturnMap() from MyEvent"
if (expressionReturnTypes.Length == 1 &&
expressionReturnTypes[0] is Type &&
(eventType is BaseNestableEventType || eventType is AvroSchemaEventType) &&
TypeHelper.IsSubclassOrImplementsInterface((Type)expressionReturnTypes[0], eventType.UnderlyingType) &&
insertIntoDesc.ColumnNames.IsEmpty() &&
columnNamesAsProvided[0] == null)
{
if (eventType is MapEventType)
{
return(new SelectExprInsertNativeExpressionCoerceMap(
eventType, expressionNodes[0], eventAdapterService));
}
else if (eventType is ObjectArrayEventType)
{
return(new SelectExprInsertNativeExpressionCoerceObjectArray(
eventType, expressionNodes[0], eventAdapterService));
}
else if (eventType is AvroSchemaEventType)
{
return(new SelectExprInsertNativeExpressionCoerceAvro(
eventType, expressionNodes[0], eventAdapterService));
}
else
{
throw new IllegalStateException("Unrecognied event type " + eventType);
}
}
// handle special case where the target type has no properties and there is a single "null" value selected
if (eventType.PropertyDescriptors.Count == 0 &&
columnNames.Length == 1 &&
columnNames[0].Equals("null") &&
expressionReturnTypes[0] == null &&
!isUsingWildcard)
{
EventBeanManufacturer eventManufacturer;
try
{
eventManufacturer = eventAdapterService.GetManufacturer(
eventType, new WriteablePropertyDescriptor[0], engineImportService, true);
}
catch (EventBeanManufactureException e)
{
throw new ExprValidationException(e.Message, e);
}
return(new SelectExprInsertNativeNoEval(eventType, eventManufacturer));
}
// handle writing to defined columns
var writableProps = eventAdapterService.GetWriteableProperties(eventType, false);
var isEligible = CheckEligible(eventType, writableProps, allowNestableTargetFragmentTypes);
if (!isEligible)
{
return(null);
}
try
{
return(InitializeSetterManufactor(
eventType, writableProps, isUsingWildcard, typeService, expressionNodes, columnNames,
expressionReturnTypes, engineImportService, eventAdapterService, statementName));
}
catch (ExprValidationException)
{
if (!(eventType is BeanEventType))
{
throw;
}
// Try constructor injection
try
{
return(InitializeCtorInjection(
(BeanEventType)eventType, expressionNodes, expressionReturnTypes, engineImportService,
eventAdapterService));
}
catch (ExprValidationException)
{
if (writableProps.IsEmpty())
{
throw;
}
}
throw;
}
}
public static SelectExprProcessorDescriptor GetProcessor(
SelectProcessorArgs args,
InsertIntoDesc insertIntoDesc,
bool withSubscriber)
{
IList<StmtClassForgeableFactory> additionalForgeables = new List<StmtClassForgeableFactory>();
SelectExprProcessorWInsertTarget synthetic = GetProcessorInternal(args, insertIntoDesc);
additionalForgeables.AddAll(synthetic.AdditionalForgeables);
// plan serdes for variant event types
if (synthetic.InsertIntoTargetType is VariantEventType ||
synthetic.InsertIntoTargetType is WrapperEventType &&
(((WrapperEventType) synthetic.InsertIntoTargetType).UnderlyingEventType is VariantEventType)) {
var serdeForgeables = SerdeEventTypeUtility.Plan(
synthetic.Forge.ResultEventType,
args.StatementRawInfo,
args.CompileTimeServices.SerdeEventTypeRegistry,
args.CompileTimeServices.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
foreach (EventType eventType in args.TypeService.EventTypes) {
serdeForgeables = SerdeEventTypeUtility.Plan(
eventType,
args.StatementRawInfo,
args.CompileTimeServices.SerdeEventTypeRegistry,
args.CompileTimeServices.SerdeResolver);
additionalForgeables.AddAll(serdeForgeables);
}
}
if (args.IsFireAndForget || !withSubscriber) {
return new SelectExprProcessorDescriptor(new SelectSubscriberDescriptor(), synthetic.Forge, additionalForgeables);
}
// Handle for-clause delivery contract checking
ExprNode[] groupedDeliveryExpr = null;
MultiKeyClassRef groupedDeliveryMultiKey = null;
var forDelivery = false;
if (args.ForClauseSpec != null) {
foreach (var item in args.ForClauseSpec.Clauses) {
if (item.Keyword == null) {
throw new ExprValidationException(
"Expected any of the " +
EnumHelper.GetValues<ForClauseKeyword>().RenderAny().ToLowerInvariant() +
" for-clause keywords after reserved keyword 'for'");
}
try {
var keyword = EnumHelper.Parse<ForClauseKeyword>(item.Keyword);
if (keyword == ForClauseKeyword.GROUPED_DELIVERY && item.Expressions.IsEmpty()) {
throw new ExprValidationException(
"The for-clause with the " +
ForClauseKeyword.GROUPED_DELIVERY.GetName() +
" keyword requires one or more grouping expressions");
}
if (keyword == ForClauseKeyword.DISCRETE_DELIVERY && !item.Expressions.IsEmpty()) {
throw new ExprValidationException(
"The for-clause with the " +
ForClauseKeyword.DISCRETE_DELIVERY.GetName() +
" keyword does not allow grouping expressions");
}
if (forDelivery) {
throw new ExprValidationException(
"The for-clause with delivery keywords may only occur once in a statement");
}
}
catch (ExprValidationException) {
throw;
}
catch (EPException) {
throw;
}
catch (Exception) {
throw new ExprValidationException(
"Expected any of the " +
EnumHelper.GetValues<ForClauseKeyword>().RenderAny().ToLowerInvariant() +
" for-clause keywords after reserved keyword 'for'");
}
StreamTypeService type = new StreamTypeServiceImpl(synthetic.Forge.ResultEventType, null, false);
groupedDeliveryExpr = new ExprNode[item.Expressions.Count];
var validationContext = new ExprValidationContextBuilder(
type,
args.StatementRawInfo,
args.CompileTimeServices)
.WithAllowBindingConsumption(true)
.Build();
for (var i = 0; i < item.Expressions.Count; i++) {
groupedDeliveryExpr[i] = ExprNodeUtilityValidate.GetValidatedSubtree(
ExprNodeOrigin.FORCLAUSE,
item.Expressions[i],
validationContext);
}
forDelivery = true;
MultiKeyPlan multiKeyPlan = MultiKeyPlanner.PlanMultiKey(
groupedDeliveryExpr, false, args.StatementRawInfo, args.SerdeResolver);
groupedDeliveryMultiKey = multiKeyPlan.ClassRef;
additionalForgeables = multiKeyPlan.MultiKeyForgeables;
}
if (groupedDeliveryExpr != null && groupedDeliveryExpr.Length == 0) {
groupedDeliveryExpr = null;
}
}
var allowSubscriber = args.CompileTimeServices.Configuration.Compiler.ByteCode.IsAllowSubscriber;
SelectSubscriberDescriptor descriptor;
SelectExprProcessorForge forge;
if (allowSubscriber) {
BindProcessorForge bindProcessor = new BindProcessorForge(
synthetic.Forge,
args.SelectionList,
args.TypeService.EventTypes,
args.TypeService.StreamNames,
args.TableCompileTimeResolver);
descriptor = new SelectSubscriberDescriptor(
bindProcessor.ExpressionTypes,
bindProcessor.ColumnNamesAssigned,
forDelivery,
groupedDeliveryExpr,
groupedDeliveryMultiKey);
forge = new BindSelectExprProcessorForge(synthetic.Forge, bindProcessor);
} else {
descriptor = new SelectSubscriberDescriptor();
forge = new ListenerOnlySelectExprProcessorForge(synthetic.Forge);
}
return new SelectExprProcessorDescriptor(descriptor, forge, additionalForgeables);
}
public static SelectExprProcessor Create(
ICollection <int> assignedTypeNumberStack,
int statementId,
string statementName,
string[] streamNames,
EventType[] streamTypes,
EventAdapterService eventAdapterService,
InsertIntoDesc insertIntoDesc,
SelectExprEventTypeRegistry selectExprEventTypeRegistry,
EngineImportService engineImportService,
Attribute[] annotations,
ConfigurationInformation configuration,
TableService tableService,
string engineURI)
{
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];
bool hasTables = false;
for (int i = 0; i < streamTypes.Length; i++)
{
streamTypesWTables[i] = streamTypes[i];
string tableName = TableServiceUtil.GetTableNameFromEventType(streamTypesWTables[i]);
if (tableName != null)
{
hasTables = true;
streamTypesWTables[i] = tableService.GetTableMetadata(tableName).PublicEventType;
}
selectProperties.Put(streamNames[i], streamTypesWTables[i]);
}
// If we have a name for this type, add it
EventUnderlyingType representation = EventRepresentationUtil.GetRepresentation(
annotations, configuration, AssignedType.NONE);
EventType resultEventType;
SelectExprProcessor processor = null;
if (insertIntoDesc != null)
{
EventType existingType = eventAdapterService.GetEventTypeByName(insertIntoDesc.EventTypeName);
if (existingType != null)
{
processor = SelectExprInsertEventBeanFactory.GetInsertUnderlyingJoinWildcard(
eventAdapterService, existingType, streamNames, streamTypesWTables, engineImportService,
statementName, engineURI);
}
}
if (processor == null)
{
if (insertIntoDesc != null)
{
try
{
if (representation == EventUnderlyingType.MAP)
{
resultEventType = eventAdapterService.AddNestableMapType(
insertIntoDesc.EventTypeName, selectProperties, null, false, false, false, false, true);
}
else if (representation == EventUnderlyingType.OBJECTARRAY)
{
resultEventType = eventAdapterService.AddNestableObjectArrayType(
insertIntoDesc.EventTypeName, selectProperties, null, false, false, false, false, true,
false, null);
}
else if (representation == EventUnderlyingType.AVRO)
{
resultEventType = eventAdapterService.AddAvroType(
insertIntoDesc.EventTypeName, selectProperties, false, false, false, false, true,
annotations, null, statementName, engineURI);
}
else
{
throw new IllegalStateException("Unrecognized code " + representation);
}
selectExprEventTypeRegistry.Add(resultEventType);
}
catch (EventAdapterException ex)
{
throw new ExprValidationException(ex.Message, ex);
}
}
else
{
if (representation == EventUnderlyingType.MAP)
{
resultEventType =
eventAdapterService.CreateAnonymousMapType(
statementId + "_join_" + CollectionUtil.ToString(assignedTypeNumberStack, "_"),
selectProperties, true);
}
else if (representation == EventUnderlyingType.OBJECTARRAY)
{
resultEventType =
eventAdapterService.CreateAnonymousObjectArrayType(
statementId + "_join_" + CollectionUtil.ToString(assignedTypeNumberStack, "_"),
selectProperties);
}
else if (representation == EventUnderlyingType.AVRO)
{
resultEventType =
eventAdapterService.CreateAnonymousAvroType(
statementId + "_join_" + CollectionUtil.ToString(assignedTypeNumberStack, "_"),
selectProperties, annotations, statementName, engineURI);
}
else
{
throw new IllegalStateException("Unrecognized enum " + representation);
}
}
if (resultEventType is ObjectArrayEventType)
{
processor = new SelectExprJoinWildcardProcessorObjectArray(
streamNames, resultEventType, eventAdapterService);
}
else if (resultEventType is MapEventType)
{
processor = new SelectExprJoinWildcardProcessorMap(
streamNames, resultEventType, eventAdapterService);
}
else if (resultEventType is AvroSchemaEventType)
{
processor = eventAdapterService.EventAdapterAvroHandler.GetOutputFactory().MakeJoinWildcard(
streamNames, resultEventType, eventAdapterService);
}
}
if (!hasTables)
{
return(processor);
}
return(new SelectExprJoinWildcardProcessorTableRows(streamTypes, processor, tableService));
}
/// <summary>
/// Returns the processor to use for a given select-clause.
/// </summary>
/// <param name="assignedTypeNumberStack">The assigned type number stack.</param>
/// <param name="selectionList">the list of select clause elements/items, which are expected to have been validated</param>
/// <param name="isUsingWildcard">true if the wildcard (*) occurs in the select clause</param>
/// <param name="insertIntoDesc">contains column names for the optional insert-into clause (if supplied)</param>
/// <param name="optionalInsertIntoEventType">Type of the optional insert into event.</param>
/// <param name="forClauseSpec">For clause spec.</param>
/// <param name="typeService">serves stream type information</param>
/// <param name="eventAdapterService">for generating wrapper instances for events</param>
/// <param name="statementResultService">handles listeners/subscriptions awareness to reduce output result generation</param>
/// <param name="valueAddEventService">service that handles update events and variant events</param>
/// <param name="selectExprEventTypeRegistry">registry for event type to statements</param>
/// <param name="engineImportService"></param>
/// <param name="exprEvaluatorContext">context for expression evalauation</param>
/// <param name="variableService">The variable service.</param>
/// <param name="scriptingService">The scripting service.</param>
/// <param name="tableService">The table service.</param>
/// <param name="timeProvider">The time provider.</param>
/// <param name="engineURI">The engine URI.</param>
/// <param name="statementId">The statement identifier.</param>
/// <param name="statementName">Name of the statement.</param>
/// <param name="annotations">The annotations.</param>
/// <param name="contextDescriptor">The context descriptor.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="selectExprProcessorCallback">The select expr processor callback.</param>
/// <param name="namedWindowMgmtService">The named window service.</param>
/// <param name="intoTableClause">The into table clause.</param>
/// <param name="groupByRollupInfo"></param>
/// <param name="statementExtensionSvcContext"></param>
/// <returns>
/// select-clause expression processor
/// </returns>
/// <exception cref="ExprValidationException">Expected any of the + Arrays.ToString(ForClauseKeyword.Values()).ToLowerCase() + for-clause keywords after reserved keyword 'for'
/// or
/// The for-clause with the + ForClauseKeyword.GROUPED_DELIVERY.Name + keyword requires one or more grouping expressions
/// or
/// The for-clause with the + ForClauseKeyword.DISCRETE_DELIVERY.Name + keyword does not allow grouping expressions
/// or
/// The for-clause with delivery keywords may only occur once in a statement
/// or
/// Expected any of the + Arrays.ToString(ForClauseKeyword.Values()).ToLowerCase() + for-clause keywords after reserved keyword 'for'</exception>
/// <throws>ExprValidationException to indicate the select expression cannot be validated</throws>
public static SelectExprProcessor GetProcessor(
ICollection <int> assignedTypeNumberStack,
SelectClauseElementCompiled[] selectionList,
bool isUsingWildcard,
InsertIntoDesc insertIntoDesc,
EventType optionalInsertIntoEventType,
ForClauseSpec forClauseSpec,
StreamTypeService typeService,
EventAdapterService eventAdapterService,
StatementResultService statementResultService,
ValueAddEventService valueAddEventService,
SelectExprEventTypeRegistry selectExprEventTypeRegistry,
EngineImportService engineImportService,
ExprEvaluatorContext exprEvaluatorContext,
VariableService variableService,
ScriptingService scriptingService,
TableService tableService,
TimeProvider timeProvider,
string engineURI,
int statementId,
string statementName,
Attribute[] annotations,
ContextDescriptor contextDescriptor,
ConfigurationInformation configuration,
SelectExprProcessorDeliveryCallback selectExprProcessorCallback,
NamedWindowMgmtService namedWindowMgmtService,
IntoTableSpec intoTableClause,
GroupByRollupInfo groupByRollupInfo,
StatementExtensionSvcContext statementExtensionSvcContext)
{
if (selectExprProcessorCallback != null)
{
var bindProcessor = new BindProcessor(selectionList, typeService.EventTypes, typeService.StreamNames, tableService);
IDictionary <string, object> properties = new LinkedHashMap <string, object>();
for (var i = 0; i < bindProcessor.ColumnNamesAssigned.Length; i++)
{
properties.Put(bindProcessor.ColumnNamesAssigned[i], bindProcessor.ExpressionTypes[i]);
}
var eventType = eventAdapterService.CreateAnonymousObjectArrayType("Output_" + statementName, properties);
return(new SelectExprProcessorWDeliveryCallback(eventType, bindProcessor, selectExprProcessorCallback));
}
var synthetic = GetProcessorInternal(
assignedTypeNumberStack, selectionList, isUsingWildcard, insertIntoDesc, optionalInsertIntoEventType,
typeService, eventAdapterService, valueAddEventService, selectExprEventTypeRegistry,
engineImportService, statementId, statementName, annotations, configuration, namedWindowMgmtService, tableService,
groupByRollupInfo);
// Handle table as an optional service
if (statementResultService != null)
{
// Handle for-clause delivery contract checking
ExprNode[] groupedDeliveryExpr = null;
var forDelivery = false;
if (forClauseSpec != null)
{
foreach (var item in forClauseSpec.Clauses)
{
if (item.Keyword == null)
{
throw new ExprValidationException("Expected any of the " + EnumHelper.GetValues <ForClauseKeyword>().Render().ToLower() + " for-clause keywords after reserved keyword 'for'");
}
try
{
ForClauseKeyword keyword = EnumHelper.Parse <ForClauseKeyword>(item.Keyword);
if ((keyword == ForClauseKeyword.GROUPED_DELIVERY) && (item.Expressions.IsEmpty()))
{
throw new ExprValidationException(
"The for-clause with the " + ForClauseKeyword.GROUPED_DELIVERY.GetName() +
" keyword requires one or more grouping expressions");
}
if ((keyword == ForClauseKeyword.DISCRETE_DELIVERY) && (!item.Expressions.IsEmpty()))
{
throw new ExprValidationException(
"The for-clause with the " + ForClauseKeyword.DISCRETE_DELIVERY.GetName() +
" keyword does not allow grouping expressions");
}
if (forDelivery)
{
throw new ExprValidationException(
"The for-clause with delivery keywords may only occur once in a statement");
}
}
catch (ExprValidationException)
{
throw;
}
catch (EPException)
{
throw;
}
catch (Exception ex)
{
throw new ExprValidationException("Expected any of the " + EnumHelper.GetValues <ForClauseKeyword>().Render().ToLower() + " for-clause keywords after reserved keyword 'for'", ex);
}
StreamTypeService type = new StreamTypeServiceImpl(synthetic.ResultEventType, null, false, engineURI);
groupedDeliveryExpr = new ExprNode[item.Expressions.Count];
var validationContext = new ExprValidationContext(type, engineImportService, statementExtensionSvcContext, null, timeProvider, variableService, tableService, exprEvaluatorContext, eventAdapterService, statementName, statementId, annotations, null, scriptingService, false, false, true, false, intoTableClause == null ? null : intoTableClause.Name, false); // no context descriptor available
for (var i = 0; i < item.Expressions.Count; i++)
{
groupedDeliveryExpr[i] = ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.FORCLAUSE, item.Expressions[i], validationContext);
}
forDelivery = true;
}
}
var bindProcessor = new BindProcessor(selectionList, typeService.EventTypes, typeService.StreamNames, tableService);
statementResultService.SetSelectClause(bindProcessor.ExpressionTypes, bindProcessor.ColumnNamesAssigned, forDelivery, ExprNodeUtility.GetEvaluators(groupedDeliveryExpr), exprEvaluatorContext);
return(new SelectExprResultProcessor(statementResultService, synthetic, bindProcessor));
}
return(synthetic);
}
private static SelectExprProcessor GetProcessorInternal(
ICollection <int> assignedTypeNumberStack,
SelectClauseElementCompiled[] selectionList,
bool isUsingWildcard,
InsertIntoDesc insertIntoDesc,
EventType optionalInsertIntoEventType,
StreamTypeService typeService,
EventAdapterService eventAdapterService,
ValueAddEventService valueAddEventService,
SelectExprEventTypeRegistry selectExprEventTypeRegistry,
EngineImportService engineImportService,
int statementId,
string statementName,
Attribute[] annotations,
ConfigurationInformation configuration,
NamedWindowMgmtService namedWindowMgmtService,
TableService tableService,
GroupByRollupInfo groupByRollupInfo)
{
// Wildcard not allowed when insert into specifies column order
if (isUsingWildcard && insertIntoDesc != null && !insertIntoDesc.ColumnNames.IsEmpty())
{
throw new ExprValidationException("Wildcard not allowed when insert-into specifies column order");
}
// Determine wildcard processor (select *)
if (IsWildcardsOnly(selectionList))
{
// For joins
if (typeService.StreamNames.Length > 1)
{
Log.Debug(".getProcessor Using SelectExprJoinWildcardProcessor");
return(SelectExprJoinWildcardProcessorFactory.Create(
assignedTypeNumberStack, statementId, statementName,
typeService.StreamNames, typeService.EventTypes,
eventAdapterService, insertIntoDesc, selectExprEventTypeRegistry, engineImportService,
annotations, configuration, tableService, typeService.EngineURIQualifier));
}
// Single-table selects with no insert-into
// don't need extra processing
else if (insertIntoDesc == null)
{
Log.Debug(".getProcessor Using wildcard processor");
if (typeService.HasTableTypes)
{
var tableName = TableServiceUtil.GetTableNameFromEventType(typeService.EventTypes[0]);
return(new SelectExprWildcardTableProcessor(tableName, tableService));
}
return(new SelectExprWildcardProcessor(typeService.EventTypes[0]));
}
}
// Verify the assigned or name used is unique
if (insertIntoDesc == null)
{
VerifyNameUniqueness(selectionList);
}
// Construct processor
var buckets = GetSelectExpressionBuckets(selectionList);
var factory = new SelectExprProcessorHelper(
assignedTypeNumberStack, buckets.Expressions, buckets.SelectedStreams, insertIntoDesc,
optionalInsertIntoEventType, isUsingWildcard, typeService, eventAdapterService, valueAddEventService,
selectExprEventTypeRegistry, engineImportService, statementId, statementName, annotations, configuration,
namedWindowMgmtService, tableService, groupByRollupInfo);
SelectExprProcessor processor = factory.Evaluator;
// add reference to the type obtained
var type = (EventTypeSPI)processor.ResultEventType;
if (!typeService.IsOnDemandStreams && type.Metadata.TypeClass != TypeClass.ANONYMOUS)
{
selectExprEventTypeRegistry.Add(processor.ResultEventType);
}
return(processor);
}
public static OutputProcessViewFactoryForgeDesc Make(
EventType[] typesPerStream,
EventType resultEventType,
ResultSetProcessorType resultSetProcessorType,
StatementSpecCompiled statementSpec,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
InsertIntoDesc insertIntoDesc = statementSpec.Raw.InsertIntoDesc;
SelectClauseStreamSelectorEnum selectStreamSelector = statementSpec.Raw.SelectStreamSelectorEnum;
OutputLimitSpec outputLimitSpec = statementSpec.Raw.OutputLimitSpec;
int streamCount = statementSpec.StreamSpecs.Length;
bool isDistinct = statementSpec.Raw.SelectClauseSpec.IsDistinct;
bool isGrouped = statementSpec.GroupByExpressions != null &&
statementSpec.GroupByExpressions.GroupByNodes.Length > 0;
List<StmtClassForgeableFactory> additionalForgeables = new List<StmtClassForgeableFactory>();
// determine routing
bool isRouted = false;
bool routeToFront = false;
if (insertIntoDesc != null) {
isRouted = true;
routeToFront = services.NamedWindowCompileTimeResolver.Resolve(insertIntoDesc.EventTypeName) != null;
}
OutputStrategyPostProcessForge outputStrategyPostProcessForge = null;
if ((insertIntoDesc != null) || (selectStreamSelector == SelectClauseStreamSelectorEnum.RSTREAM_ONLY)) {
SelectClauseStreamSelectorEnum? insertIntoStreamSelector = null;
TableMetaData table = null;
if (insertIntoDesc != null) {
insertIntoStreamSelector = insertIntoDesc.StreamSelector;
table = services.TableCompileTimeResolver.Resolve(statementSpec.Raw.InsertIntoDesc.EventTypeName);
if (table != null) {
EPLValidationUtil.ValidateContextName(
true,
table.TableName,
table.OptionalContextName,
statementSpec.Raw.OptionalContextName,
true);
}
}
bool audit = AuditEnum.INSERT.GetAudit(statementSpec.Annotations) != null;
outputStrategyPostProcessForge = new OutputStrategyPostProcessForge(
isRouted,
insertIntoStreamSelector,
selectStreamSelector,
routeToFront,
table,
audit);
}
MultiKeyPlan multiKeyPlan = MultiKeyPlanner.PlanMultiKeyDistinct(
isDistinct,
resultEventType,
statementRawInfo,
SerdeCompileTimeResolverNonHA.INSTANCE);
MultiKeyClassRef distinctMultiKey = multiKeyPlan.ClassRef;
additionalForgeables.AddRange(multiKeyPlan.MultiKeyForgeables);
OutputProcessViewFactoryForge outputProcessViewFactoryForge;
if (outputLimitSpec == null) {
if (!isDistinct) {
if (outputStrategyPostProcessForge == null || !outputStrategyPostProcessForge.HasTable) {
// without table we have a shortcut implementation
outputProcessViewFactoryForge =
new OutputProcessViewDirectSimpleForge(outputStrategyPostProcessForge);
}
else {
outputProcessViewFactoryForge =
new OutputProcessViewDirectForge(outputStrategyPostProcessForge);
}
}
else {
outputProcessViewFactoryForge = new OutputProcessViewDirectDistinctOrAfterFactoryForge(
outputStrategyPostProcessForge,
isDistinct,
distinctMultiKey,
null,
null,
resultEventType);
}
}
else if (outputLimitSpec.RateType == OutputLimitRateType.AFTER) {
outputProcessViewFactoryForge = new OutputProcessViewDirectDistinctOrAfterFactoryForge(
outputStrategyPostProcessForge,
isDistinct,
distinctMultiKey,
outputLimitSpec.AfterTimePeriodExpr,
outputLimitSpec.AfterNumberOfEvents,
resultEventType);
}
else {
try {
bool isWithHavingClause = statementSpec.Raw.HavingClause != null;
bool isStartConditionOnCreation = HasOnlyTables(statementSpec.StreamSpecs);
OutputConditionFactoryForge outputConditionFactoryForge =
OutputConditionFactoryFactory.CreateCondition(
outputLimitSpec,
isGrouped,
isWithHavingClause,
isStartConditionOnCreation,
statementRawInfo,
services);
bool hasOrderBy = statementSpec.Raw.OrderByList != null && statementSpec.Raw.OrderByList.Count > 0;
bool hasAfter = outputLimitSpec.AfterNumberOfEvents != null ||
outputLimitSpec.AfterTimePeriodExpr != null;
// hint checking with order-by
bool hasOptHint = ResultSetProcessorOutputConditionTypeExtensions
.GetOutputLimitOpt(statementSpec.Annotations, services.Configuration, hasOrderBy);
ResultSetProcessorOutputConditionType conditionType =
ResultSetProcessorOutputConditionTypeExtensions
.GetConditionType(
outputLimitSpec.DisplayLimit,
resultSetProcessorType.IsAggregated(),
hasOrderBy,
hasOptHint,
resultSetProcessorType.IsGrouped());
// plan serdes
foreach (EventType eventType in typesPerStream) {
IList<StmtClassForgeableFactory> serdeForgeables = SerdeEventTypeUtility.Plan(
eventType,
statementRawInfo,
services.SerdeEventTypeRegistry,
services.SerdeResolver);
additionalForgeables.AddRange(serdeForgeables);
}
bool terminable = outputLimitSpec.RateType == OutputLimitRateType.TERM ||
outputLimitSpec.IsAndAfterTerminate;
outputProcessViewFactoryForge = new OutputProcessViewConditionForge(
outputStrategyPostProcessForge,
isDistinct,
distinctMultiKey,
outputLimitSpec.AfterTimePeriodExpr,
outputLimitSpec.AfterNumberOfEvents,
outputConditionFactoryForge,
streamCount,
conditionType,
terminable,
hasAfter,
resultSetProcessorType.IsUnaggregatedUngrouped(),
selectStreamSelector,
typesPerStream,
resultEventType);
}
catch (Exception ex) {
throw new ExprValidationException("Failed to validate the output rate limiting clause: " + ex.Message, ex);
}
}
return new OutputProcessViewFactoryForgeDesc(outputProcessViewFactoryForge, additionalForgeables);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="assignedTypeNumberStack">The assigned type number stack.</param>
/// <param name="statementId">The statement identifier.</param>
/// <param name="streamNames">name of each stream</param>
/// <param name="streamTypes">type of each stream</param>
/// <param name="eventAdapterService">service for generating events and handling event types</param>
/// <param name="insertIntoDesc">describes the insert-into clause</param>
/// <param name="selectExprEventTypeRegistry">registry for event type to statements</param>
/// <param name="methodResolutionService">for resolving writable properties</param>
/// <param name="annotations">The annotations.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="tableService">The table service.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentException">Stream names and types parameter length is invalid, expected use of this class is for join statements</exception>
/// <exception cref="ExprValidationException"></exception>
/// <throws>com.espertech.esper.epl.expression.core.ExprValidationException if the expression validation failed</throws>
public static SelectExprProcessor Create(
ICollection <int> assignedTypeNumberStack,
string statementId,
string[] streamNames,
EventType[] streamTypes,
EventAdapterService eventAdapterService,
InsertIntoDesc insertIntoDesc,
SelectExprEventTypeRegistry selectExprEventTypeRegistry,
MethodResolutionService methodResolutionService,
Attribute[] annotations,
ConfigurationInformation configuration,
TableService tableService)
{
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 eventTypeMap = 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 tableName = TableServiceUtil.GetTableNameFromEventType(streamTypesWTables[i]);
if (tableName != null)
{
hasTables = true;
streamTypesWTables[i] = tableService.GetTableMetadata(tableName).PublicEventType;
}
eventTypeMap.Put(streamNames[i], streamTypesWTables[i]);
}
// If we have a name for this type, add it
var useMap = EventRepresentationUtil.IsMap(annotations, configuration, AssignedType.NONE);
EventType resultEventType;
SelectExprProcessor processor = null;
if (insertIntoDesc != null)
{
EventType existingType = eventAdapterService.GetEventTypeByName(insertIntoDesc.EventTypeName);
if (existingType != null)
{
processor = SelectExprInsertEventBeanFactory.GetInsertUnderlyingJoinWildcard(
eventAdapterService, existingType, streamNames, streamTypesWTables,
methodResolutionService.EngineImportService);
}
}
if (processor == null)
{
if (insertIntoDesc != null)
{
try
{
if (useMap)
{
resultEventType = eventAdapterService.AddNestableMapType(
insertIntoDesc.EventTypeName, eventTypeMap, null, false, false, false, false, true);
}
else
{
resultEventType = eventAdapterService.AddNestableObjectArrayType(
insertIntoDesc.EventTypeName, eventTypeMap, null, false, false, false, false, true, false, null);
}
selectExprEventTypeRegistry.Add(resultEventType);
}
catch (EventAdapterException ex)
{
throw new ExprValidationException(ex.Message);
}
}
else
{
if (useMap)
{
resultEventType =
eventAdapterService.CreateAnonymousMapType(
statementId + "_join_" + CollectionUtil.ToString(assignedTypeNumberStack, "_"), eventTypeMap);
}
else
{
resultEventType =
eventAdapterService.CreateAnonymousObjectArrayType(
statementId + "_join_" + CollectionUtil.ToString(assignedTypeNumberStack, "_"), eventTypeMap);
}
}
if (resultEventType is ObjectArrayEventType)
{
processor = new SelectExprJoinWildcardProcessorObjectArray(
streamNames, resultEventType, eventAdapterService);
}
else
{
processor = new SelectExprJoinWildcardProcessorMap(streamNames, resultEventType, eventAdapterService);
}
}
if (!hasTables)
{
return(processor);
}
return(new SelectExprJoinWildcardProcessorTableRows(streamTypes, processor, tableService));
}
private InfraOnMergeActionInsForge SetupInsert(
string infraName,
EventType infraType,
OnTriggerMergeActionInsert desc,
EventType triggeringEventType,
string triggeringStreamName,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services,
bool isTable)
{
// Compile insert-into info
var streamName = desc.OptionalStreamName != null ? desc.OptionalStreamName : infraName;
InsertIntoDesc insertIntoDesc = InsertIntoDesc.FromColumns(streamName, desc.Columns);
// rewrite any wildcards to use "stream.wildcard"
if (triggeringStreamName == null) {
triggeringStreamName = UuidGenerator.Generate();
}
var selectNoWildcard = CompileSelectNoWildcard(triggeringStreamName, desc.SelectClauseCompiled);
// Set up event types for select-clause evaluation: The first type does not contain anything as its the named-window or table row which is not present for insert
var eventTypeMetadata = new EventTypeMetadata(
"merge_infra_insert",
statementRawInfo.ModuleName,
EventTypeTypeClass.STREAM,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
EventType dummyTypeNoProperties = BaseNestableEventUtil.MakeMapTypeCompileTime(
eventTypeMetadata,
Collections.GetEmptyMap<string, object>(),
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
var eventTypes = new EventType[] {dummyTypeNoProperties, triggeringEventType};
var streamNames = new string[] {UuidGenerator.Generate(), triggeringStreamName};
StreamTypeService streamTypeService = new StreamTypeServiceImpl(
eventTypes,
streamNames,
new bool[eventTypes.Length],
false,
false);
// Get select expr processor
var selectClause = selectNoWildcard.ToArray();
var args = new SelectProcessorArgs(
selectClause,
null,
false,
null,
null,
streamTypeService,
null,
false,
statementRawInfo.Annotations,
statementRawInfo,
services);
if (isTable && streamName.Equals(infraName)) {
args.OptionalInsertIntoEventType = infraType;
}
SelectExprProcessorForge insertHelperForge =
SelectExprProcessorFactory.GetProcessor(args, insertIntoDesc, false).Forge;
ExprNode filterEval = desc.OptionalWhereClause;
var route = !streamName.Equals(infraName);
bool audit = AuditEnum.INSERT.GetAudit(statementRawInfo.Annotations) != null;
TableMetaData insertIntoTable = services.TableCompileTimeResolver.Resolve(insertIntoDesc.EventTypeName);
return new InfraOnMergeActionInsForge(filterEval, insertHelperForge, insertIntoTable, audit, route);
}
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);
}