public void RegisterSerde(
EventTypeMetadata metadata,
DataInputOutputSerde underlyingSerde,
Type underlyingClass)
{
_serdes.Add(new EventTypeCollectedSerde(metadata, underlyingSerde, underlyingClass));
}
public static ObjectArrayEventType MakeTransientOAType(
string enumMethod,
string propertyName,
Type type,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
IDictionary<string, object> propsResult = new Dictionary<string, object>();
propsResult.Put(propertyName, Boxing.GetBoxedType(type));
var eventTypeName =
services.EventTypeNameGeneratorStatement.GetAnonymousTypeNameEnumMethod(enumMethod, propertyName);
var metadata = new EventTypeMetadata(
eventTypeName,
statementRawInfo.ModuleName,
EventTypeTypeClass.ENUMDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var oatype = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata,
propsResult,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(oatype);
return oatype;
}
public void RegisterXML(
EventTypeMetadata metadata,
string representsFragmentOfProperty,
string representsOriginalTypeName)
{
var existing = _xmlFragmentEventTypeFactory.GetTypeByName(metadata.Name);
if (existing != null) {
HandleRegister(existing);
return;
}
var schemaType = _xmlFragmentEventTypeFactory.GetRootTypeByName(representsOriginalTypeName);
if (schemaType == null) {
throw new EPException("Failed to find XML schema type '" + representsOriginalTypeName + "'");
}
var prop = PropertyParser.ParseAndWalkLaxToSimple(representsFragmentOfProperty);
var schemaModelRoot = SchemaUtil.FindRootElement(
schemaType.SchemaModel,
schemaType.ConfigurationEventTypeXMLDOM.RootElementNamespace,
schemaType.RootElementName);
var item = prop.GetPropertyTypeSchema(schemaModelRoot);
var complex = (SchemaElementComplex) item;
var eventType = _xmlFragmentEventTypeFactory.GetCreateXMLDOMType(
representsOriginalTypeName,
metadata.Name,
metadata.ModuleName,
complex,
representsFragmentOfProperty);
HandleRegister(eventType);
}
public void RegisterXMLNewType(
EventTypeMetadata metadata,
ConfigurationCommonEventTypeXMLDOM config)
{
SchemaModel schemaModel = null;
if ((config.SchemaResource != null) || (config.SchemaText != null)) {
try {
schemaModel = XSDSchemaMapper.LoadAndMap(
config.SchemaResource,
config.SchemaText,
_container.ResourceManager());
}
catch (Exception ex) {
throw new EPException(ex.Message, ex);
}
}
EventType eventType = _eventTypeFactory.CreateXMLType(
metadata,
config,
schemaModel,
null,
metadata.Name,
_beanEventTypeFactory,
_xmlFragmentEventTypeFactory,
_eventTypeNameResolver);
HandleRegister(eventType);
if (eventType is SchemaXMLEventType) {
_xmlFragmentEventTypeFactory.AddRootType((SchemaXMLEventType) eventType);
}
}
private static ObjectArrayEventType MakeTransientOATypeInternal(
string enumMethod,
IDictionary <string, object> boxedPropertyTypes,
string eventTypeNameUUid,
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
var eventTypeName =
services.EventTypeNameGeneratorStatement.GetAnonymousTypeNameEnumMethod(enumMethod, eventTypeNameUUid);
var metadata = new EventTypeMetadata(
eventTypeName,
statementRawInfo.ModuleName,
EventTypeTypeClass.ENUMDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var oatype = BaseNestableEventUtil.MakeOATypeCompileTime(
metadata,
boxedPropertyTypes,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(oatype);
return(oatype);
}
public JsonEventType CreateJson(
EventTypeMetadata metadata,
IDictionary<String, Object> properties,
string[] superTypes,
string startTimestampPropertyName,
string endTimestampPropertyName,
BeanEventTypeFactory beanEventTypeFactory,
EventTypeNameResolver eventTypeNameResolver,
JsonEventTypeDetail detail)
{
var st = EventTypeUtility.GetSuperTypesDepthFirst(superTypes, EventUnderlyingType.JSON, eventTypeNameResolver);
properties = BaseNestableEventUtil.ResolvePropertyTypes(properties, eventTypeNameResolver);
var getterFactoryJson = new EventTypeNestableGetterFactoryJson(detail);
// We use a null-stand-in class as the actual underlying class is provided later
return new JsonEventType(
metadata,
properties,
st.First,
st.Second,
startTimestampPropertyName,
endTimestampPropertyName,
getterFactoryJson,
beanEventTypeFactory,
detail,
null,
false);
}
public EventType CreateXMLType(
EventTypeMetadata metadata,
ConfigurationCommonEventTypeXMLDOM detail,
SchemaModel schemaModel,
string representsFragmentOfProperty,
string representsOriginalTypeName,
BeanEventTypeFactory beanEventTypeFactory,
XMLFragmentEventTypeFactory xmlFragmentEventTypeFactory,
EventTypeNameResolver eventTypeNameResolver)
{
if (metadata.IsPropertyAgnostic) {
return new SimpleXMLEventType(
metadata,
detail,
beanEventTypeFactory.EventBeanTypedEventFactory,
eventTypeNameResolver,
xmlFragmentEventTypeFactory);
}
return new SchemaXMLEventType(
metadata,
detail,
schemaModel,
representsFragmentOfProperty,
representsOriginalTypeName,
beanEventTypeFactory.EventBeanTypedEventFactory,
eventTypeNameResolver,
xmlFragmentEventTypeFactory);
}
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 BeanEventType(
IContainer container,
BeanEventTypeStem stem,
EventTypeMetadata metadata,
BeanEventTypeFactory beanEventTypeFactory,
EventType[] superTypes,
ICollection<EventType> deepSuperTypes,
string startTimestampPropertyName,
string endTimestampPropertyName)
{
_container = container;
Stem = stem;
Metadata = metadata;
_beanEventTypeFactory = beanEventTypeFactory;
SuperTypes = superTypes;
DeepSuperTypesCollection = deepSuperTypes;
var desc = EventTypeUtility.ValidatedDetermineTimestampProps(
this,
startTimestampPropertyName,
endTimestampPropertyName,
superTypes);
StartTimestampPropertyName = desc.Start;
EndTimestampPropertyName = desc.End;
}
/// <summary>
/// Constructor takes a class as an argument.
/// </summary>
/// <param name="metadata">event type metadata</param>
/// <param name="eventTypeId">The event type id.</param>
/// <param name="clazz">is the class of an object</param>
/// <param name="eventAdapterService">factory for event beans and event types</param>
/// <param name="optionalLegacyDef">optional configuration supplying legacy event type information</param>
public BeanEventType(EventTypeMetadata metadata,
int eventTypeId,
Type clazz,
EventAdapterService eventAdapterService,
ConfigurationEventTypeLegacy optionalLegacyDef)
{
Metadata = metadata;
UnderlyingType = clazz;
_eventAdapterService = eventAdapterService;
OptionalLegacyDef = optionalLegacyDef;
EventTypeId = eventTypeId;
if (optionalLegacyDef != null)
{
FactoryMethodName = optionalLegacyDef.FactoryMethod;
_copyMethodName = optionalLegacyDef.CopyMethod;
PropertyResolutionStyle = optionalLegacyDef.PropertyResolutionStyle;
}
else
{
PropertyResolutionStyle = eventAdapterService.BeanEventTypeFactory.DefaultPropertyResolutionStyle;
}
_propertyGetterCache = new Dictionary <String, EventPropertyGetter>();
Initialize(false);
EventTypeUtility.TimestampPropertyDesc desc = EventTypeUtility.ValidatedDetermineTimestampProps(
this,
optionalLegacyDef == null ? null : optionalLegacyDef.StartTimestampPropertyName,
optionalLegacyDef == null ? null : optionalLegacyDef.EndTimestampPropertyName,
SuperTypes);
StartTimestampPropertyName = desc.Start;
EndTimestampPropertyName = desc.End;
}
public static MapEventType MakeMapTypeCompileTime(
EventTypeMetadata metadata,
IDictionary<string, object> propertyTypes,
EventType[] optionalSuperTypes,
ISet<EventType> optionalDeepSupertypes,
string startTimestampPropertyName,
string endTimestampPropertyName,
BeanEventTypeFactory beanEventTypeFactory,
EventTypeCompileTimeResolver eventTypeCompileTimeResolver)
{
if (metadata.ApplicationType != EventTypeApplicationType.MAP) {
throw new ArgumentException("Invalid application type " + metadata.ApplicationType);
}
IDictionary<string, object> verified = ResolvePropertyTypes(
propertyTypes, eventTypeCompileTimeResolver);
return new MapEventType(
metadata,
verified,
optionalSuperTypes,
optionalDeepSupertypes,
startTimestampPropertyName,
endTimestampPropertyName,
beanEventTypeFactory);
}
/// <summary>
/// Creates a new EventType object for a object of the specified class if this is the first time the class has been seen. Else uses a cached EventType instance, i.e. client classes do not need to cache.
/// </summary>
/// <param name="name">is the name</param>
/// <param name="clazz">is the class of the object.</param>
/// <param name="isPreconfiguredStatic">if from static engine config</param>
/// <param name="isPreconfigured">if configured before use</param>
/// <param name="isConfigured">if the class is a configuration value, false if discovered</param>
/// <returns>EventType implementation for bean class</returns>
public BeanEventType CreateBeanType(String name, Type clazz, bool isPreconfiguredStatic, bool isPreconfigured, bool isConfigured)
{
if (clazz == null)
{
throw new ArgumentException("Null value passed as class");
}
BeanEventType eventType;
// not created yet, thread-safe create
using (_typesPerObjectLock.Acquire())
{
eventType = _typesPerObject.Get(clazz);
if (eventType != null)
{
_eventTypeIdGenerator.AssignedType(name, eventType);
return(eventType);
}
// Check if we have a legacy type definition for this class
ConfigurationEventTypeLegacy legacyDef = _typeToLegacyConfigs.Get(clazz.FullName);
if ((legacyDef == null) && (_defaultAccessorStyle != AccessorStyleEnum.NATIVE))
{
legacyDef = new ConfigurationEventTypeLegacy();
legacyDef.AccessorStyle = _defaultAccessorStyle;
}
int typeId = _eventTypeIdGenerator.GetTypeId(name);
EventTypeMetadata metadata = EventTypeMetadata.CreateBeanType(name, clazz, isPreconfiguredStatic, isPreconfigured, isConfigured, TypeClass.APPLICATION);
eventType = new BeanEventType(metadata, typeId, clazz, _eventAdapterService, legacyDef);
_typesPerObject.Put(clazz, eventType);
}
return(eventType);
}
public AvroEventType(
EventTypeMetadata metadata,
Schema avroSchema,
string startTimestampPropertyName,
string endTimestampPropertyName,
EventType[] optionalSuperTypes,
ISet<EventType> deepSupertypes,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
EventTypeAvroHandler eventTypeAvroHandler)
{
Metadata = metadata;
_avroSchema = avroSchema;
_optionalSuperTypes = optionalSuperTypes;
_deepSupertypes = deepSupertypes ?? new EmptySet<EventType>();
_propertyItems = new LinkedHashMap<string, PropertySetDescriptorItem>();
_eventBeanTypedEventFactory = eventBeanTypedEventFactory;
_eventTypeAvroHandler = eventTypeAvroHandler;
Init();
var desc = EventTypeUtility.ValidatedDetermineTimestampProps(
this,
startTimestampPropertyName,
endTimestampPropertyName,
optionalSuperTypes);
StartTimestampPropertyName = desc.Start;
EndTimestampPropertyName = desc.End;
}
public AvroEventType(
EventTypeMetadata metadata,
string eventTypeName,
int typeId,
EventAdapterService eventAdapterService,
RecordSchema avroSchema,
string startTimestampPropertyName,
string endTimestampPropertyName,
EventType[] optionalSuperTypes,
ICollection<EventType> deepSupertypes)
{
_metadata = metadata;
_typeId = typeId;
_eventAdapterService = eventAdapterService;
_avroSchema = avroSchema;
_optionalSuperTypes = optionalSuperTypes;
_deepSupertypes = deepSupertypes ?? Collections.GetEmptySet<EventType>();
_propertyItems = new LinkedHashMap<string, PropertySetDescriptorItem>();
Init();
EventTypeUtility.TimestampPropertyDesc desc = EventTypeUtility.ValidatedDetermineTimestampProps(
this, startTimestampPropertyName, endTimestampPropertyName, optionalSuperTypes);
_startTimestampPropertyName = desc.Start;
_endTimestampPropertyName = desc.End;
}
/// <summary>
/// Make a wrapper type.
/// A wrapper event type may indeed wrap another wrapper event type. This is so that a wrapper event bean can wrap
/// another wrapper event bean.
/// If there were unwrapped the nesting information such as what is the nested wrapper type and how they are nested
/// would be lost.
/// </summary>
/// <param name="metadata">metadata</param>
/// <param name="underlyingEventType">underlying event type</param>
/// <param name="propertyTypesMayPrimitive">property types</param>
/// <param name="eventBeanTypedEventFactory">factory for instances</param>
/// <param name="beanEventTypeFactory">bean event type factory</param>
/// <param name="eventTypeNameResolver">type name resolver</param>
/// <returns>wrapper type</returns>
public static WrapperEventType MakeWrapper(
EventTypeMetadata metadata,
EventType underlyingEventType,
IDictionary<string, object> propertyTypesMayPrimitive,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
BeanEventTypeFactory beanEventTypeFactory,
EventTypeNameResolver eventTypeNameResolver)
{
// If we are wrapping an underlying type that is itself a wrapper, then this is a special case
if (underlyingEventType is WrapperEventType underlyingWrapperType) {
// the underlying type becomes the type already wrapped
// properties are a superset of the wrapped properties and the additional properties
underlyingEventType = underlyingWrapperType.UnderlyingEventType;
var propertiesSuperset = new Dictionary<string, object>();
propertiesSuperset.PutAll(underlyingWrapperType.UnderlyingMapType.Types);
propertiesSuperset.PutAll(propertyTypesMayPrimitive);
propertyTypesMayPrimitive = propertiesSuperset;
}
IDictionary<string, object> verified = BaseNestableEventUtil.ResolvePropertyTypes(
propertyTypesMayPrimitive,
eventTypeNameResolver);
return new WrapperEventType(
metadata,
underlyingEventType,
verified,
eventBeanTypedEventFactory,
beanEventTypeFactory);
}
public JsonEventType(
EventTypeMetadata metadata,
IDictionary <string, object> propertyTypes,
EventType[] optionalSuperTypes,
ISet <EventType> optionalDeepSupertypes,
string startTimestampPropertyName,
string endTimestampPropertyName,
EventTypeNestableGetterFactory getterFactory,
BeanEventTypeFactory beanEventTypeFactory,
JsonEventTypeDetail detail,
Type underlyingStandInClass,
bool underlyingTypeIsTransient)
: base(
metadata,
propertyTypes,
optionalSuperTypes,
optionalDeepSupertypes,
startTimestampPropertyName,
endTimestampPropertyName,
getterFactory,
beanEventTypeFactory,
true)
{
_detail = detail;
_underlyingType = underlyingStandInClass;
_underlyingTypeIsTransient = underlyingTypeIsTransient;
}
public static EventType NewType(
string name,
LinkedHashMap<string, object> schemaMap,
ViewForgeEnv env,
int streamNum)
{
string outputEventTypeName =
env.StatementCompileTimeServices.EventTypeNameGeneratorStatement.GetViewDerived(name, streamNum);
EventTypeMetadata metadata = new EventTypeMetadata(
outputEventTypeName,
env.ModuleName,
EventTypeTypeClass.VIEWDERIVED,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
IDictionary<string, object> propertyTypes = EventTypeUtility.GetPropertyTypesNonPrimitive(schemaMap);
EventType resultEventType = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata,
propertyTypes,
null,
null,
null,
null,
env.BeanEventTypeFactoryProtected,
env.EventTypeCompileTimeResolver);
env.EventTypeModuleCompileTimeRegistry.NewType(resultEventType);
return resultEventType;
}
protected abstract AvroSchemaEventType MakeType(
EventTypeMetadata metadata,
EventBeanTypedEventFactory eventAdapterService,
Schema schema,
ConfigurationCommonEventTypeAvro optionalConfig,
EventType[] supertypes,
ISet<EventType> deepSupertypes);
private static BeanEventType MakeBeanType(
string methodName,
Type clazz,
ExprValidationContext validationContext)
{
var eventTypeName =
validationContext.StatementCompileTimeService.EventTypeNameGeneratorStatement
.GetAnonymousTypeNameUDFMethod(methodName, clazz.Name);
var metadata = new EventTypeMetadata(
eventTypeName,
validationContext.ModuleName,
EventTypeTypeClass.UDFDERIVED,
EventTypeApplicationType.CLASS,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var stem = validationContext.StatementCompileTimeService.BeanEventTypeStemService
.GetCreateStem(clazz, null);
var beantype = new BeanEventType(
validationContext.Container,
stem,
metadata,
validationContext.StatementCompileTimeService.BeanEventTypeFactoryPrivate,
null,
null,
null,
null);
validationContext.StatementCompileTimeService.EventTypeCompileTimeRegistry.NewType(beantype);
return beantype;
}
static ExcludePlanHintExprUtil()
{
LinkedHashMap<string, object> properties = new LinkedHashMap<string, object>();
properties.Put("from_streamnum", typeof(int?));
properties.Put("to_streamnum", typeof(int?));
properties.Put("from_streamname", typeof(string));
properties.Put("to_streamname", typeof(string));
properties.Put("opname", typeof(string));
properties.Put("exprs", typeof(string[]));
string eventTypeName = EventTypeNameUtil.GetAnonymousTypeNameExcludePlanHint();
EventTypeMetadata eventTypeMetadata = new EventTypeMetadata(
eventTypeName,
null,
EventTypeTypeClass.EXCLUDEPLANHINTDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
OAEXPRESSIONTYPE = BaseNestableEventUtil.MakeOATypeCompileTime(
eventTypeMetadata,
properties,
null,
null,
null,
null,
new BeanEventTypeFactoryDisallow(EventBeanTypedEventFactoryCompileTime.INSTANCE),
null);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="revisionEventTypeName">name</param>
/// <param name="spec">specification</param>
/// <param name="statementStopService">for stop handling</param>
/// <param name="eventAdapterService">for nested property handling</param>
/// <param name="eventTypeIdGenerator">The event type id generator.</param>
public VAERevisionProcessorDeclared(
string revisionEventTypeName,
RevisionSpec spec,
StatementStopService statementStopService,
EventAdapterService eventAdapterService,
EventTypeIdGenerator eventTypeIdGenerator)
: base(spec, revisionEventTypeName, eventAdapterService)
{
// on statement stop, remove versions
statementStopService.StatementStopped += () => _statePerKey.Clear();
_statePerKey = new Dictionary <object, RevisionStateDeclared>().WithNullSupport();
_baseEventType = spec.BaseEventType;
_fullKeyGetters = PropertyUtility.GetGetters(_baseEventType, spec.KeyPropertyNames);
// sort non-key properties, removing keys
_groups = PropertyUtility.AnalyzeGroups(spec.ChangesetPropertyNames, spec.DeltaTypes, spec.DeltaNames);
var propertyDesc = CreatePropertyDescriptors(spec, _groups);
TypeDescriptors = PropertyUtility.GetPerType(_groups, spec.ChangesetPropertyNames, spec.KeyPropertyNames);
var metadata = EventTypeMetadata.CreateValueAdd(revisionEventTypeName, TypeClass.REVISION);
RevisionEventType = new RevisionEventType(metadata, eventTypeIdGenerator.GetTypeId(revisionEventTypeName),
propertyDesc, eventAdapterService);
}
public EventType CreateMapType(IDictionary<string, object> map)
{
var metadata = new EventTypeMetadata(UuidGenerator.Generate(), null, EventTypeTypeClass.STREAM, EventTypeApplicationType.MAP, NameAccessModifier.INTERNAL, EventTypeBusModifier.NONBUS, false, EventTypeIdPair.Unassigned());
return new MapEventType(
metadata, map, null, null, null, null,
BEAN_EVENT_TYPE_FACTORY);
}
private EventType GetAssignAnonymousType(
StatementRawInfo statementRawInfo,
StatementCompileTimeServices services)
{
IDictionary<string, object> rowType = RowType;
var eventTypeName =
services.EventTypeNameGeneratorStatement.GetAnonymousTypeSubselectMultirow(SubselectNumber);
var metadata = new EventTypeMetadata(
eventTypeName,
statementRawInfo.ModuleName,
EventTypeTypeClass.SUBQDERIVED,
EventTypeApplicationType.MAP,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var maptype = BaseNestableEventUtil.MakeMapTypeCompileTime(
metadata,
rowType,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(maptype);
subselectMultirowType = maptype;
return maptype;
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="propertyDesc">describes each properties type</param>
/// <param name="eventAdapterService">for nested property handling</param>
/// <param name="metadata">- event type metadata</param>
/// <param name="eventTypeId">type id</param>
public RevisionEventType(
EventTypeMetadata metadata,
int eventTypeId,
IDictionary <string, RevisionPropertyTypeDesc> propertyDesc,
EventAdapterService eventAdapterService)
{
_metadata = metadata;
_eventTypeId = eventTypeId;
_propertyDesc = propertyDesc;
_propertyNames = propertyDesc.Keys.ToArray();
_eventAdapterService = eventAdapterService;
_propertyDescriptors = new EventPropertyDescriptor[propertyDesc.Count];
_propertyDescriptorMap = new Dictionary <string, EventPropertyDescriptor>();
var count = 0;
foreach (var desc in propertyDesc)
{
var type = (Type)desc.Value.PropertyType;
var descriptor = new EventPropertyDescriptor(
desc.Key, type, null, false, false, false, false, type.IsFragmentableType());
_propertyDescriptors[count] = descriptor;
_propertyDescriptorMap.Put(desc.Key, descriptor);
count++;
}
}
private static EventType GetDefineMultimatchEventType(
LinkedHashMap<string, Pair<int, bool>> variableStreams,
EventType parentEventType,
StatementBaseInfo @base,
StatementCompileTimeServices services)
{
IDictionary<string, object> multievent = new LinkedHashMap<string, object>();
foreach (var entry in variableStreams) {
if (entry.Value.Second) {
multievent.Put(entry.Key, new[] {parentEventType});
}
}
var multimatchAllTypeName = services.EventTypeNameGeneratorStatement.AnonymousRowrecogMultimatchAllName;
var multimatchAllTypeMetadata = new EventTypeMetadata(
multimatchAllTypeName,
@base.ModuleName,
EventTypeTypeClass.MATCHRECOGDERIVED,
EventTypeApplicationType.OBJECTARR,
NameAccessModifier.TRANSIENT,
EventTypeBusModifier.NONBUS,
false,
EventTypeIdPair.Unassigned());
var multimatchAllEventType = BaseNestableEventUtil.MakeOATypeCompileTime(
multimatchAllTypeMetadata,
multievent,
null,
null,
null,
null,
services.BeanEventTypeFactoryPrivate,
services.EventTypeCompileTimeResolver);
services.EventTypeCompileTimeRegistry.NewType(multimatchAllEventType);
return multimatchAllEventType;
}
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));
}
public void TestEquals()
{
EventTypeMetadata metadata = EventTypeMetadata.CreateNonPonoApplicationType(
ApplicationType.MAP, "", true, true, true,
false, false);
IDictionary <String, Object> mapTwo = new LinkedHashMap <String, Object>();
mapTwo["MyInt"] = typeof(int);
mapTwo["mySupportBean"] = typeof(SupportBean);
mapTwo["myNullableSupportBean"] = typeof(SupportBean);
mapTwo["myComplexBean"] = typeof(SupportBeanComplexProps);
Assert.IsFalse(
(new MapEventType(metadata, "", 1, _eventAdapterService, mapTwo, null, null, null)).Equals(_eventType));
mapTwo["MyString"] = typeof(string);
mapTwo["myNullableString"] = typeof(string);
mapTwo["myNullType"] = null;
// compare, should equal
Assert.IsTrue(
new MapEventType(metadata, "", 1, _eventAdapterService, mapTwo, null, null, null).EqualsCompareType(
_eventType));
Assert.IsFalse(
(new MapEventType(metadata, "google", 1, _eventAdapterService, mapTwo, null, null, null)).
EqualsCompareType(_eventType));
mapTwo["xx"] = typeof(int);
Assert.IsFalse(
_eventType.EqualsCompareType(new MapEventType(metadata, "", 1, _eventAdapterService, mapTwo, null, null,
null)));
mapTwo.Remove("xx");
Assert.IsTrue(
_eventType.EqualsCompareType(new MapEventType(metadata, "", 1, _eventAdapterService, mapTwo, null, null,
null)));
mapTwo["MyInt"] = typeof(int?);
Assert.IsTrue(
_eventType.EqualsCompareType(new MapEventType(metadata, "", 1, _eventAdapterService, mapTwo, null, null,
null)));
mapTwo.Remove("MyInt");
Assert.IsFalse(
_eventType.EqualsCompareType(new MapEventType(metadata, "", 1, _eventAdapterService, mapTwo, null, null,
null)));
mapTwo["MyInt"] = typeof(int);
Assert.IsTrue(
_eventType.EqualsCompareType(new MapEventType(metadata, "", 1, _eventAdapterService, mapTwo, null, null,
null)));
// Test boxed and primitive compatible
IDictionary <String, Object> mapOne = new LinkedHashMap <String, Object>();
mapOne["MyInt"] = typeof(int);
mapTwo = new LinkedHashMap <String, Object>();
mapTwo["MyInt"] = typeof(int);
Assert.IsTrue(
new MapEventType(metadata, "T1", 1, _eventAdapterService, mapOne, null, null, null).EqualsCompareType(
new MapEventType(metadata, "T1", 1, _eventAdapterService, mapTwo, null, null, null)));
}
public static AvroEventType MakeAvroSupportEventType(Schema schema)
{
var metadata = EventTypeMetadata.CreateNonPonoApplicationType(
ApplicationType.AVRO, "typename", true, true, true, false, false);
return(new AvroEventType(
metadata, "typename", 1, SupportEventAdapterService.Service, schema.AsRecordSchema(), null, null, null, null));
}
public AvroSchemaEventType NewEventTypeFromJson(
EventTypeMetadata metadata,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
string schemaJson,
IList<EventType> superTypes,
ISet<EventType> deepSuperTypes)
{
throw new UnsupportedOperationException();
}
public AvroSchemaEventType NewEventTypeFromSchema(
EventTypeMetadata metadata,
EventBeanTypedEventFactory eventBeanTypedEventFactory,
ConfigurationCommonEventTypeAvro requiredConfig,
EventType[] supertypes,
ISet<EventType> deepSupertypes)
{
throw new UnsupportedOperationException();
}
