protected abstract AvroSchemaEventType MakeType( EventTypeMetadata metadata, EventBeanTypedEventFactory eventAdapterService, Schema schema, ConfigurationCommonEventTypeAvro optionalConfig, EventType[] supertypes, ISet<EventType> deepSupertypes);
private static void BuildAvroType( EventTypeRepositoryImpl eventTypeRepositoryPreconfigured, string eventTypeName, ConfigurationCommonEventTypeAvro config, EventTypeAvroHandler eventTypeAvroHandler, EventBeanTypedEventFactory eventBeanTypedEventFactory) { var metadata = new EventTypeMetadata( eventTypeName, null, EventTypeTypeClass.APPLICATION, EventTypeApplicationType.AVRO, NameAccessModifier.PRECONFIGURED, EventTypeBusModifier.NONBUS, false, new EventTypeIdPair(CRC32Util.ComputeCRC32(eventTypeName), -1)); var avroSuperTypes = EventTypeUtility.GetSuperTypesDepthFirst( config.SuperTypes, EventUnderlyingType.AVRO, eventTypeRepositoryPreconfigured); var newEventType = eventTypeAvroHandler.NewEventTypeFromSchema( metadata, eventBeanTypedEventFactory, config, avroSuperTypes.First, avroSuperTypes.Second); eventTypeRepositoryPreconfigured.AddType(newEventType); }
public AvroSchemaEventType NewEventTypeFromSchema( EventTypeMetadata metadata, EventBeanTypedEventFactory eventBeanTypedEventFactory, ConfigurationCommonEventTypeAvro requiredConfig, EventType[] supertypes, ISet<EventType> deepSupertypes) { throw new UnsupportedOperationException(); }
public AvroSchemaEventType NewEventTypeFromNormalized( EventTypeMetadata metadata, EventTypeNameResolver eventTypeNameResolver, EventBeanTypedEventFactory eventBeanTypedEventFactory, IDictionary<string, object> properties, Attribute[] annotations, ConfigurationCommonEventTypeAvro optionalConfig, EventType[] superTypes, ISet<EventType> deepSuperTypes, string statementName) { throw new UnsupportedOperationException(); }
public AvroSchemaEventType NewEventTypeFromNormalized( EventTypeMetadata metadata, EventTypeNameResolver eventTypeNameResolver, EventBeanTypedEventFactory eventAdapterService, IDictionary<string, object> properties, Attribute[] annotations, ConfigurationCommonEventTypeAvro optionalConfig, EventType[] superTypes, ISet<EventType> deepSuperTypes, string statementName) { var assembler = new JArray(); var eventTypeName = metadata.Name; // add supertypes first so the positions are comparable var added = new HashSet<string>(); if (superTypes != null) { for (var i = 0; i < superTypes.Length; i++) { var superType = (AvroEventType) superTypes[i]; foreach (var field in superType.SchemaAvro.AsRecordSchema().Fields) { if (properties.ContainsKey(field.Name) || added.Contains(field.Name)) { continue; } added.Add(field.Name); assembler.Add(TypeBuilder.Field(field.Name, field.Schema)); //assembler.Name(field.Name).Type(field.Schema).NoDefault(); } } } foreach (var prop in properties) { if (!added.Contains(prop.Key)) { AvroSchemaUtil.AssembleField( prop.Key, prop.Value, assembler, annotations, _avroSettings, eventTypeNameResolver, statementName, _optionalTypeMapper); added.Add(prop.Key); } } var schema = SchemaBuilder.Record(eventTypeName, assembler); //Schema schema = assembler.EndRecord(); return MakeType(metadata, eventAdapterService, schema, optionalConfig, superTypes, deepSuperTypes); }
internal static FragmentEventType GetFragmentEventTypeForField( Schema fieldSchema, string moduleName, EventBeanTypedEventFactory eventBeanTypedEventFactory, EventTypeAvroHandler eventTypeAvroHandler, AvroEventTypeFragmentTypeCache fragmentTypeCache) { Schema recordSchema; var indexed = false; if (fieldSchema.Tag == Schema.Type.Record) { recordSchema = fieldSchema; } else if (fieldSchema.Tag == Schema.Type.Array && fieldSchema.AsArraySchema().ItemSchema.Tag == Schema.Type.Record) { recordSchema = fieldSchema.AsArraySchema().ItemSchema; indexed = true; } else { return null; } var cached = fragmentTypeCache.Get(recordSchema.Name); if (cached != null) { return new FragmentEventType(cached, indexed, false); } var metadata = new EventTypeMetadata( recordSchema.Name, moduleName, EventTypeTypeClass.STREAM, EventTypeApplicationType.AVRO, NameAccessModifier.TRANSIENT, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned()); var config = new ConfigurationCommonEventTypeAvro(); config.AvroSchema = recordSchema; var fragmentType = eventTypeAvroHandler.NewEventTypeFromSchema( metadata, eventBeanTypedEventFactory, config, null, null); fragmentTypeCache.Add(recordSchema.Name, fragmentType); return new FragmentEventType(fragmentType, indexed, false); }
protected override AvroSchemaEventType MakeType( EventTypeMetadata metadata, EventBeanTypedEventFactory eventBeanTypedEventFactory, Schema schema, ConfigurationCommonEventTypeAvro optionalConfig, EventType[] supertypes, ISet<EventType> deepSupertypes) { return new AvroEventType( metadata, schema, optionalConfig?.StartTimestampPropertyName, optionalConfig?.EndTimestampPropertyName, supertypes, deepSupertypes, eventBeanTypedEventFactory, this); }
public AvroSchemaEventType NewEventTypeFromSchema( EventTypeMetadata metadata, EventBeanTypedEventFactory eventAdapterService, ConfigurationCommonEventTypeAvro requiredConfig, EventType[] superTypes, ISet<EventType> deepSuperTypes) { var avroSchemaObj = requiredConfig.AvroSchema; var avroSchemaText = requiredConfig.AvroSchemaText; if (avroSchemaObj == null && avroSchemaText == null) { throw new ArgumentException("Null value for schema and schema text"); } if (avroSchemaObj != null && avroSchemaText != null) { throw new ArgumentException( "Both avro schema and avro schema text are supplied and one can be provided"); } if (avroSchemaObj != null && !(avroSchemaObj is Schema)) { throw new ArgumentException( "Schema expected of type " + typeof(Schema).Name + " but received " + avroSchemaObj.GetType().Name); } Schema schema; if (avroSchemaObj != null) { schema = (Schema) avroSchemaObj; } else { try { schema = Schema.Parse(avroSchemaText); } catch (Exception ex) { throw new EPException("Failed for parse avro schema: " + ex.Message, ex); } } return MakeType(metadata, eventAdapterService, schema, requiredConfig, superTypes, deepSuperTypes); }
private static void Configure(Configuration configuration) { foreach (var clazz in new[] {typeof(SupportBean)}) { configuration.Common.AddEventType(clazz); } var schemaUser = "******"namespace\": \"example.avro\",\n" + " \"type\": \"record\",\n" + " \"name\": \"User\",\n" + " \"fields\": [\n" + " {\"name\": \"name\", \"type\": {\n" + " \"type\": \"string\",\n" + " \"avro.string\": \"String\"\n" + " }},\n" + " {\"name\": \"favorite_number\", \"type\": \"int\"},\n" + " {\"name\": \"favorite_color\", \"type\": {\n" + " \"type\": \"string\",\n" + " \"avro.string\": \"String\"\n" + " }}\n" + " ]\n" + "}"; var schema = Schema.Parse(schemaUser); configuration.Common.AddEventTypeAvro("User", new ConfigurationCommonEventTypeAvro(schema)); var schemaCarLocUpdateEvent = SchemaBuilder.Record( "CarLocUpdateEvent", TypeBuilder.Field( "carId", TypeBuilder.StringType( TypeBuilder.Property(PROP_STRING_KEY, PROP_STRING_VALUE))), TypeBuilder.RequiredInt("direction")); var avroEvent = new ConfigurationCommonEventTypeAvro(schemaCarLocUpdateEvent); configuration.Common.AddEventTypeAvro("CarLocUpdateEvent", avroEvent); var avro = new ConfigurationCommonEventTypeAvro(EventAvroEventBean.RECORD_SCHEMA); configuration.Common.AddEventTypeAvro("MyNestedMap", avro); }
// 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); }