internal static FragmentEventType GetFragmentEventTypeForField( Schema fieldSchema, EventAdapterService eventAdapterService) { Schema recordSchema; bool indexed = false; if (fieldSchema.Tag == Schema.Type.Record) { recordSchema = fieldSchema; } else if (fieldSchema.Tag == Schema.Type.Array && fieldSchema.GetElementType().Tag == Schema.Type.Record) { recordSchema = fieldSchema.GetElementType(); indexed = true; } else { return(null); } // See if there is an existing type EventType existing = eventAdapterService.GetEventTypeByName(recordSchema.Name); if (existing != null && existing is AvroEventType) { return(new FragmentEventType(existing, indexed, false)); } EventType fragmentType = eventAdapterService.AddAvroType( recordSchema.Name, new ConfigurationEventTypeAvro().SetAvroSchema(recordSchema), false, false, false, false, false); return(new FragmentEventType(fragmentType, indexed, false)); }
public void AddEventTypeAvro(string eventTypeName, ConfigurationEventTypeAvro avro) { CheckTableExists(eventTypeName); try { _eventAdapterService.AddAvroType(eventTypeName, avro, false, true, true, false, false); } catch (EventAdapterException t) { throw new ConfigurationException(t.Message, t); } }
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> /// Initialize event adapter service for config snapshot. /// </summary> /// <param name="eventAdapterService">is events adapter</param> /// <param name="configSnapshot">is the config snapshot</param> /// <param name="engineImportService">engine import service</param> /// <param name="resourceManager">The resource manager.</param> /// <exception cref="ConfigurationException"> /// Error configuring engine: " + ex.Message /// or /// Error configuring engine: " + ex.Message /// or /// or /// Error configuring engine: " + ex.Message /// or /// Error configuring engine, dependency graph between map type names is circular: " + e.Message /// or /// Error configuring engine: " + ex.Message /// or /// Error configuring engine, dependency graph between object array type names is circular: " + /// e.Message /// or /// Error configuring engine: " + ex.Message /// or /// Failed to load plug-in event representation class '" + className + "' /// or /// Failed to instantiate plug-in event representation class '" + className + /// "' via default constructor /// or /// Failed to instantiate plug-in event representation class '" + className + /// "' via default constructor /// or /// Illegal access to instantiate plug-in event representation class '" + className + /// "' via default constructor /// or /// Illegal access to instantiate plug-in event representation class '" + className + /// "' via default constructor /// or /// Plug-in event representation class '" + className + /// "' does not implement the required interface " + typeof (PlugInEventRepresentation).Name /// or /// Plug-in event representation class '" + className + "' and URI '" + eventRepURI + /// "' did not initialize correctly : " + e.Message /// </exception> internal static void Init( EventAdapterService eventAdapterService, ConfigurationInformation configSnapshot, EngineImportService engineImportService, IResourceManager resourceManager) { // Extract legacy event type definitions for each event type name, if supplied. // // We supply this information as setup information to the event adapter service // to allow discovery of superclasses and interfaces during event type construction for bean events, // such that superclasses and interfaces can use the legacy type definitions. var classLegacyInfo = new Dictionary <string, ConfigurationEventTypeLegacy>(); foreach (var entry in configSnapshot.EventTypeNames) { var typeName = entry.Key; var className = entry.Value; var legacyDef = configSnapshot.EventTypesLegacy.Get(typeName); if (legacyDef != null) { classLegacyInfo.Put(className, legacyDef); } } eventAdapterService.TypeLegacyConfigs = classLegacyInfo; eventAdapterService.DefaultPropertyResolutionStyle = configSnapshot.EngineDefaults.EventMeta.ClassPropertyResolutionStyle; eventAdapterService.DefaultAccessorStyle = configSnapshot.EngineDefaults.EventMeta.DefaultAccessorStyle; foreach (var typeNamespace in configSnapshot.EventTypeAutoNamePackages) { eventAdapterService.AddAutoNamePackage(typeNamespace); } // Add from the configuration the event class names var typeNames = configSnapshot.EventTypeNames; foreach (var entry in typeNames) { // Add class try { var typeName = entry.Key; eventAdapterService.AddBeanType(typeName, entry.Value, false, true, true, true); } catch (EventAdapterException ex) { throw new ConfigurationException("Error configuring engine: " + ex.Message, ex); } } // Add from the configuration the Java event class names var avroNames = configSnapshot.EventTypesAvro; foreach (var entry in avroNames) { try { eventAdapterService.AddAvroType(entry.Key, entry.Value, true, true, true, false, false); } catch (EventAdapterException ex) { throw new ConfigurationException("Error configuring engine: " + ex.Message, ex); } } // Add from the configuration the XML DOM names and type def var xmlDOMNames = configSnapshot.EventTypesXMLDOM; foreach (var entry in xmlDOMNames) { SchemaModel schemaModel = null; if ((entry.Value.SchemaResource != null) || (entry.Value.SchemaText != null)) { try { schemaModel = XSDSchemaMapper.LoadAndMap( entry.Value.SchemaResource, entry.Value.SchemaText, engineImportService, resourceManager); } catch (Exception ex) { throw new ConfigurationException(ex.Message, ex); } } // Add XML DOM type try { eventAdapterService.AddXMLDOMType(entry.Key, entry.Value, schemaModel, true); } catch (EventAdapterException ex) { throw new ConfigurationException("Error configuring engine: " + ex.Message, ex); } } // Add maps in dependency order such that supertypes are added before subtypes ICollection <string> dependentMapOrder; try { var typesReferences = ToTypesReferences(configSnapshot.MapTypeConfigurations); dependentMapOrder = GraphUtil.GetTopDownOrder(typesReferences); } catch (GraphCircularDependencyException e) { throw new ConfigurationException( "Error configuring engine, dependency graph between map type names is circular: " + e.Message, e); } var mapNames = configSnapshot.EventTypesMapEvents; var nestableMapNames = configSnapshot.EventTypesNestableMapEvents; dependentMapOrder.AddAll(mapNames.Keys); dependentMapOrder.AddAll(nestableMapNames.Keys); try { foreach (var mapName in dependentMapOrder) { var mapConfig = configSnapshot.MapTypeConfigurations.Get(mapName); var propertiesUnnested = mapNames.Get(mapName); if (propertiesUnnested != null) { var propertyTypes = CreatePropertyTypes(propertiesUnnested, engineImportService); var propertyTypesCompiled = EventTypeUtility.CompileMapTypeProperties( propertyTypes, eventAdapterService); eventAdapterService.AddNestableMapType( mapName, propertyTypesCompiled, mapConfig, true, true, true, false, false); } var propertiesNestable = nestableMapNames.Get(mapName); if (propertiesNestable != null) { var propertiesNestableCompiled = EventTypeUtility.CompileMapTypeProperties( propertiesNestable, eventAdapterService); eventAdapterService.AddNestableMapType( mapName, propertiesNestableCompiled, mapConfig, true, true, true, false, false); } } } catch (EventAdapterException ex) { throw new ConfigurationException("Error configuring engine: " + ex.Message, ex); } // Add object-array in dependency order such that supertypes are added before subtypes ICollection <string> dependentObjectArrayOrder; try { var typesReferences = ToTypesReferences(configSnapshot.ObjectArrayTypeConfigurations); dependentObjectArrayOrder = GraphUtil.GetTopDownOrder(typesReferences); } catch (GraphCircularDependencyException e) { throw new ConfigurationException( "Error configuring engine, dependency graph between object array type names is circular: " + e.Message, e); } var nestableObjectArrayNames = configSnapshot.EventTypesNestableObjectArrayEvents; dependentObjectArrayOrder.AddAll(nestableObjectArrayNames.Keys); try { foreach (var objectArrayName in dependentObjectArrayOrder) { var objectArrayConfig = configSnapshot.ObjectArrayTypeConfigurations.Get(objectArrayName); var propertyTypes = nestableObjectArrayNames.Get(objectArrayName); propertyTypes = ResolveClassesForStringPropertyTypes(propertyTypes, engineImportService); var propertyTypesCompiled = EventTypeUtility.CompileMapTypeProperties( propertyTypes, eventAdapterService); eventAdapterService.AddNestableObjectArrayType( objectArrayName, propertyTypesCompiled, objectArrayConfig, true, true, true, false, false, false, null); } } catch (EventAdapterException ex) { throw new ConfigurationException("Error configuring engine: " + ex.Message, ex); } // Add plug-in event representations var plugInReps = configSnapshot.PlugInEventRepresentation; foreach (var entry in plugInReps) { String className = entry.Value.EventRepresentationTypeName; Type eventRepClass; try { eventRepClass = TypeHelper.ResolveType(className); } catch (TypeLoadException ex) { throw new ConfigurationException( "Failed to load plug-in event representation class '" + className + "'", ex); } Object pluginEventRepObj; try { pluginEventRepObj = Activator.CreateInstance(eventRepClass); } catch (TypeInstantiationException ex) { throw new ConfigurationException( "Failed to instantiate plug-in event representation class '" + className + "' via default constructor", ex); } catch (TargetInvocationException ex) { throw new ConfigurationException( "Failed to instantiate plug-in event representation class '" + className + "' via default constructor", ex); } catch (MethodAccessException ex) { throw new ConfigurationException( "Illegal access to instantiate plug-in event representation class '" + className + "' via default constructor", ex); } catch (MemberAccessException ex) { throw new ConfigurationException( "Illegal access to instantiate plug-in event representation class '" + className + "' via default constructor", ex); } if (!(pluginEventRepObj is PlugInEventRepresentation)) { throw new ConfigurationException( "Plug-in event representation class '" + className + "' does not implement the required interface " + typeof(PlugInEventRepresentation).Name); } var eventRepURI = entry.Key; var pluginEventRep = (PlugInEventRepresentation)pluginEventRepObj; var initializer = entry.Value.Initializer; var context = new PlugInEventRepresentationContext(eventAdapterService, eventRepURI, initializer); try { pluginEventRep.Init(context); eventAdapterService.AddEventRepresentation(eventRepURI, pluginEventRep); } catch (Exception e) { throw new ConfigurationException( "Plug-in event representation class '" + className + "' and URI '" + eventRepURI + "' did not initialize correctly : " + e.Message, e); } } // Add plug-in event type names var plugInNames = configSnapshot.PlugInEventTypes; foreach (var entry in plugInNames) { var name = entry.Key; var config = entry.Value; eventAdapterService.AddPlugInEventType( name, config.EventRepresentationResolutionURIs, config.Initializer); } }