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));
}
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);
}
/// <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));
}
// 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);
}
