private Type[] GetKeyTypes(IList <CreateTableColumn> columns, EngineImportService engineImportService)
{
IList <Type> keys = new List <Type>();
foreach (var col in columns)
{
if (col.PrimaryKey == null || !col.PrimaryKey.Value)
{
continue;
}
var msg = "Column '" + col.ColumnName + "' may not be tagged as primary key";
if (col.OptExpression != null)
{
throw new ExprValidationException(msg + ", an expression cannot become a primary key column");
}
if (col.OptTypeIsArray != null && col.OptTypeIsArray.Value)
{
throw new ExprValidationException(msg + ", an array-typed column cannot become a primary key column");
}
var type = EventTypeUtility.BuildType(new ColumnDesc(col.ColumnName, col.OptTypeName, false, false), engineImportService);
if (!(type is Type))
{
throw new ExprValidationException(msg + ", received unexpected event type '" + type + "'");
}
keys.Add((Type)type);
}
return(keys.ToArray());
}
private void ValidateKeyTypes(
IList<CreateTableColumn> columns,
ImportServiceCompileTime importService)
{
foreach (var col in columns) {
if (col.PrimaryKey == null || !col.PrimaryKey.Value) {
continue;
}
var msg = "Column '" + col.ColumnName + "' may not be tagged as primary key";
if (col.OptExpression != null) {
throw new ExprValidationException(msg + ", an expression cannot become a primary key column");
}
var type = EventTypeUtility.BuildType(
new ColumnDesc(col.ColumnName, col.OptType.ToEPL()),
importService);
if (!(type is Type)) {
throw new ExprValidationException(msg + ", received unexpected event type '" + type + "'");
}
if (((Type) type).IsArray) {
throw new ExprValidationException(
msg + ", an array-typed column cannot become a primary key column");
}
}
}
private IList <TableColumnDesc> ValidateExpressions(
IList <CreateTableColumn> columns,
EPServicesContext services,
StatementContext statementContext)
{
ISet <string> columnNames = new HashSet <string>();
IList <TableColumnDesc> descriptors = new List <TableColumnDesc>();
var positionInDeclaration = 0;
foreach (var column in columns)
{
var msgprefix = "For column '" + column.ColumnName + "'";
// check duplicate name
if (columnNames.Contains(column.ColumnName))
{
throw new ExprValidationException("Column '" + column.ColumnName + "' is listed more than once");
}
columnNames.Add(column.ColumnName);
// determine presence of type annotation
var optionalEventType = ValidateExpressionGetEventType(msgprefix, column.Annotations, services.EventAdapterService);
// aggregation node
TableColumnDesc descriptor;
if (column.OptExpression != null)
{
var validated = ValidateAggregationExpr(column.OptExpression, optionalEventType, services, statementContext);
descriptor = new TableColumnDescAgg(positionInDeclaration, column.ColumnName, validated, optionalEventType);
}
else
{
var unresolvedType = EventTypeUtility.BuildType(
new ColumnDesc(
column.ColumnName,
column.OptTypeName,
column.OptTypeIsArray ?? false,
column.OptTypeIsPrimitiveArray ?? false),
services.EngineImportService);
descriptor = new TableColumnDescTyped(
positionInDeclaration, column.ColumnName, unresolvedType, column.PrimaryKey ?? false);
}
descriptors.Add(descriptor);
positionInDeclaration++;
}
return(descriptors);
}
private compat.collections.Pair<IList<TableColumnDesc>, IList<StmtClassForgeableFactory>> ValidateExpressions(
IList<CreateTableColumn> columns,
StatementCompileTimeServices services)
{
ISet<string> columnNames = new HashSet<string>();
IList<TableColumnDesc> descriptors = new List<TableColumnDesc>();
var positionInDeclaration = 0;
var additionalForgeables = new List<StmtClassForgeableFactory>();
foreach (var column in columns) {
var msgprefix = "For column '" + column.ColumnName + "'";
// check duplicate name
if (columnNames.Contains(column.ColumnName)) {
throw new ExprValidationException("Column '" + column.ColumnName + "' is listed more than once");
}
columnNames.Add(column.ColumnName);
// determine presence of type annotation
var optionalEventType = ValidateExpressionGetEventType(msgprefix, column.Annotations, services);
// aggregation node
TableColumnDesc descriptor;
if (column.OptExpression != null) {
var pair = ValidateAggregationExpr(column.OptExpression, optionalEventType, services);
descriptor = new TableColumnDescAgg(positionInDeclaration, column.ColumnName, pair.First, optionalEventType);
additionalForgeables.AddRange(pair.Second);
}
else {
var unresolvedType = EventTypeUtility.BuildType(
new ColumnDesc(column.ColumnName, column.OptType.ToEPL()),
services.ImportServiceCompileTime);
descriptor = new TableColumnDescTyped(
positionInDeclaration,
column.ColumnName,
unresolvedType,
column.PrimaryKey.GetValueOrDefault(false));
}
descriptors.Add(descriptor);
positionInDeclaration++;
}
return new compat.collections.Pair<IList<TableColumnDesc>, IList<StmtClassForgeableFactory>>(descriptors, 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);
}