private static String MakeProperty(EsperEPL2GrammarParser.EventPropertyAtomicContext ctx, String defaultNamespacePrefix)
{
String prefix = "";
if (defaultNamespacePrefix != null)
{
prefix = defaultNamespacePrefix + ":";
}
String unescapedIdent = ASTUtil.UnescapeDot(ctx.eventPropertyIdent().GetText());
if (ctx.lb != null)
{
int index = IntValue.ParseString(ctx.number().GetText());
int xPathPosition = index + 1;
return('/' + prefix + unescapedIdent + "[position() = " + xPathPosition + ']');
}
if (ctx.lp != null)
{
String key = StringValue.ParseString(ctx.s.Text);
return('/' + prefix + unescapedIdent + "[@id='" + key + "']");
}
return('/' + prefix + unescapedIdent);
}
internal static FragmentEventType GetFragmentType(
Schema schema,
string propertyName,
IDictionary <string, PropertySetDescriptorItem> propertyItems,
EventAdapterService eventAdapterService)
{
string unescapePropName = ASTUtil.UnescapeDot(propertyName);
PropertySetDescriptorItem item = propertyItems.Get(unescapePropName);
if (item != null)
{
return(item.FragmentEventType);
}
Property property = PropertyParser.ParseAndWalkLaxToSimple(propertyName);
AvroFieldDescriptor desc = AvroFieldUtil.FieldForProperty(schema, property);
if (desc == null)
{
return(null);
}
if (desc.IsDynamic)
{
return(null);
}
Schema fieldSchemaByAccess = desc.Field.Schema;
if (desc.IsAccessedByIndex)
{
fieldSchemaByAccess = fieldSchemaByAccess.GetElementType();
}
return(GetFragmentEventTypeForField(fieldSchemaByAccess, eventAdapterService));
}
public static void ToPrecedenceFreeEPL(TextWriter writer, string streamOrPropertyName, string unresolvedPropertyName)
{
if (streamOrPropertyName != null)
{
writer.Write(ASTUtil.UnescapeDot(streamOrPropertyName));
writer.Write('.');
}
writer.Write(ASTUtil.UnescapeDot(PropertyParser.UnescapeBacktick(unresolvedPropertyName)));
}
public Type GetPropertyType(string propertyName)
{
PropertySetDescriptorItem item = _propertyItems.Get(ASTUtil.UnescapeDot(propertyName));
if (item != null)
{
return item.SimplePropertyType;
}
Property property = PropertyParser.ParseAndWalkLaxToSimple(propertyName);
return AvroPropertyUtil.PropertyType(_avroSchema, property);
}
public Type GetPropertyType(String propertyName)
{
RevisionPropertyTypeDesc desc = _propertyDesc.Get(propertyName);
if (desc != null)
{
if (desc.PropertyType is Type)
{
return((Type)desc.PropertyType);
}
return(null);
}
// dynamic property names note allowed
if (propertyName.IndexOf('?') != -1)
{
return(null);
}
// see if this is a nested property
int index = ASTUtil.UnescapedIndexOfDot(propertyName);
if (index == -1)
{
return(null);
}
// Map event types allow 2 types of properties inside:
// - a property that is a Java object is interrogated via bean property getters and BeanEventType
// - a property that is a Map itself is interrogated via map property getters
// Take apart the nested property into a map key and a nested value class property name
String propertyMap = ASTUtil.UnescapeDot(propertyName.Substring(0, index));
String propertyNested = propertyName.Substring(index + 1);
desc = _propertyDesc.Get(propertyMap);
if (desc == null)
{
return(null); // prefix not a known property
}
else if (desc.PropertyType is Type)
{
Type simpleClass = (Type)desc.PropertyType;
EventType nestedEventType = _eventAdapterService.AddBeanType(simpleClass.FullName, simpleClass, false, false, false);
return(nestedEventType.GetPropertyType(propertyNested));
}
else
{
return(null);
}
}
public bool IsProperty(String propertyName)
{
var propertyType = GetPropertyType(propertyName);
if (propertyType == null)
{
// Could be a native null type, such as "insert into A select null as field..."
if (_propertyItems.ContainsKey(ASTUtil.UnescapeDot(propertyName)))
{
return(true);
}
}
return(propertyType != null);
}
private static Property MakeProperty(EsperEPL2GrammarParser.EventPropertyAtomicContext atomic, bool isRootedInDynamic)
{
var prop = ASTUtil.UnescapeDot(atomic.eventPropertyIdent().GetText());
if (prop.Length == 0)
{
throw new PropertyAccessException("Invalid zero-length string provided as an event property name");
}
if (atomic.lb != null)
{
var index = IntValue.ParseString(atomic.ni.GetText());
if (!isRootedInDynamic && atomic.q == null)
{
return(new IndexedProperty(prop, index));
}
else
{
return(new DynamicIndexedProperty(prop, index));
}
}
else if (atomic.lp != null)
{
var key = StringValue.ParseString(atomic.s.Text);
if (!isRootedInDynamic && atomic.q == null)
{
return(new MappedProperty(prop, key));
}
else
{
return(new DynamicMappedProperty(prop, key));
}
}
else
{
if (!isRootedInDynamic && atomic.q1 == null)
{
return(new SimpleProperty(prop));
}
else
{
return(new DynamicSimpleProperty(prop));
}
}
}
public EventPropertyGetterSPI GetGetterSPI(string propertyName)
{
var desc = _propertyDesc.Get(propertyName);
if (desc != null)
{
return(desc.RevisionGetter);
}
// dynamic property names note allowed
if (propertyName.IndexOf('?') != -1)
{
return(null);
}
// see if this is a nested property
var index = ASTUtil.UnescapedIndexOfDot(propertyName);
if (index == -1)
{
var prop = PropertyParser.ParseAndWalkLaxToSimple(propertyName);
if (prop is SimpleProperty)
{
// there is no such property since it wasn't found earlier
return(null);
}
string atomic = null;
if (prop is IndexedProperty)
{
var indexedprop = (IndexedProperty)prop;
atomic = indexedprop.PropertyNameAtomic;
}
if (prop is MappedProperty)
{
var indexedprop = (MappedProperty)prop;
atomic = indexedprop.PropertyNameAtomic;
}
desc = _propertyDesc.Get(atomic);
if (desc == null)
{
return(null);
}
if (!(desc.PropertyType is Type))
{
return(null);
}
var nestedClass = (Type)desc.PropertyType;
var complexProperty = (BeanEventType)_eventAdapterService.AddBeanType(nestedClass.GetDefaultTypeName(), nestedClass, false, false, false);
return(prop.GetGetter(complexProperty, _eventAdapterService));
}
// Map event types allow 2 types of properties inside:
// - a property that is a Java object is interrogated via bean property getters and BeanEventType
// - a property that is a Map itself is interrogated via map property getters
// Take apart the nested property into a map key and a nested value class property name
var propertyMap = ASTUtil.UnescapeDot(propertyName.Substring(0, index));
var propertyNested = propertyName.Substring(index + 1);
desc = _propertyDesc.Get(propertyMap);
if (desc == null)
{
return(null); // prefix not a known property
}
// only nested classes supported for revision event types since deep property information not currently exposed by EventType
if (desc.PropertyType is Type)
{
// ask the nested class to resolve the property
var simpleClass = (Type)desc.PropertyType;
var nestedEventType = (EventTypeSPI)_eventAdapterService.AddBeanType(
simpleClass.Name, simpleClass, false, false, false);
var nestedGetter = nestedEventType.GetGetterSPI(propertyNested);
if (nestedGetter == null)
{
return(null);
}
// construct getter for nested property
return(new RevisionNestedPropertyGetter(desc.RevisionGetter, nestedGetter, _eventAdapterService));
}
else
{
return(null);
}
}
public FragmentEventType GetFragmentType(String propertyName)
{
var item = _propertyItems.Get(propertyName);
if (item != null) // may contain null values
{
return(item.FragmentEventType);
}
// see if this is a nested property
var index = ASTUtil.UnescapedIndexOfDot(propertyName);
if (index == -1)
{
// dynamic simple property
if (propertyName.EndsWith("?"))
{
return(null);
}
// parse, can be an indexed property
var property = PropertyParser.ParseAndWalk(propertyName);
if (property is IndexedProperty)
{
var indexedProp = (IndexedProperty)property;
var type = NestableTypes.Get(indexedProp.PropertyNameAtomic);
if (type == null)
{
return(null);
}
else if (type is EventType[])
{
var eventType = ((EventType[])type)[0];
return(new FragmentEventType(eventType, false, false));
}
else if (type is String)
{
var propTypeName = type.ToString();
var isArray = EventTypeUtility.IsPropertyArray(propTypeName);
if (!isArray)
{
return(null);
}
propTypeName = EventTypeUtility.GetPropertyRemoveArray(propTypeName);
EventType innerType = EventAdapterService.GetEventTypeByName(propTypeName);
if (!(innerType is BaseNestableEventType))
{
return(null);
}
return(new FragmentEventType(innerType, false, false)); // false since an index is present
}
if (!(type is Type))
{
return(null);
}
if (!((Type)type).IsArray)
{
return(null);
}
// its an array
return(EventBeanUtility.CreateNativeFragmentType(((Type)type).GetElementType(), null, EventAdapterService));
}
else if (property is MappedProperty)
{
// No type information available for the inner event
return(null);
}
else
{
return(null);
}
}
// Map event types allow 2 types of properties inside:
// - a property that is a object is interrogated via bean property getters and BeanEventType
// - a property that is a Map itself is interrogated via map property getters
// The property getters therefore act on
// Take apart the nested property into a map key and a nested value class property name
var propertyMap = ASTUtil.UnescapeDot(propertyName.Substring(0, index));
var propertyNested = propertyName.Substring(index + 1);
// If the property is dynamic, it cannot be a fragment
if (propertyMap.EndsWith("?"))
{
return(null);
}
var nestedType = NestableTypes.Get(propertyMap);
if (nestedType == null)
{
// parse, can be an indexed property
var property = PropertyParser.ParseAndWalk(propertyMap);
if (property is IndexedProperty)
{
var indexedProp = (IndexedProperty)property;
var type = NestableTypes.Get(indexedProp.PropertyNameAtomic);
if (type == null)
{
return(null);
}
// handle map-in-map case
if (type is String)
{
var propTypeName = type.ToString();
var isArray = EventTypeUtility.IsPropertyArray(propTypeName);
if (isArray)
{
propTypeName = EventTypeUtility.GetPropertyRemoveArray(propTypeName);
}
EventType innerType = EventAdapterService.GetEventTypeByName(propTypeName);
if (!(innerType is BaseNestableEventType))
{
return(null);
}
return(innerType.GetFragmentType(propertyNested));
}
// handle eventtype[] in map
else if (type is EventType[])
{
var innerType = ((EventType[])type)[0];
return(innerType.GetFragmentType(propertyNested));
}
// handle array class in map case
else
{
if (!(type is Type))
{
return(null);
}
if (!((Type)type).IsArray)
{
return(null);
}
var fragmentParent = EventBeanUtility.CreateNativeFragmentType(
(Type)type, null, EventAdapterService);
if (fragmentParent == null)
{
return(null);
}
return(fragmentParent.FragmentType.GetFragmentType(propertyNested));
}
}
else if (property is MappedProperty)
{
// No type information available for the property's map value
return(null);
}
else
{
return(null);
}
}
// If there is a map value in the map, return the Object value if this is a dynamic property
if (ReferenceEquals(nestedType, typeof(IDictionary <string, object>)))
{
return(null);
}
else if (nestedType is IDictionary <string, object> )
{
return(null);
}
else if (nestedType is Type)
{
var simpleClass = (Type)nestedType;
if (!TypeHelper.IsFragmentableType(simpleClass))
{
return(null);
}
EventType nestedEventType =
EventAdapterService.BeanEventTypeFactory.CreateBeanTypeDefaultName(simpleClass);
return(nestedEventType.GetFragmentType(propertyNested));
}
else if (nestedType is EventType)
{
var innerType = (EventType)nestedType;
return(innerType.GetFragmentType(propertyNested));
}
else if (nestedType is EventType[])
{
var innerType = (EventType[])nestedType;
return(innerType[0].GetFragmentType(propertyNested));
}
else if (nestedType is String)
{
var nestedName = nestedType.ToString();
var isArray = EventTypeUtility.IsPropertyArray(nestedName);
if (isArray)
{
nestedName = EventTypeUtility.GetPropertyRemoveArray(nestedName);
}
var innerType = EventAdapterService.GetEventTypeByName(nestedName);
if (!(innerType is BaseNestableEventType))
{
return(null);
}
return(innerType.GetFragmentType(propertyNested));
}
else
{
var message = "Nestable map type configuration encountered an unexpected value type of '"
+ nestedType.GetType() + " for property '" + propertyName +
"', expected Class, typeof(Map) or IDictionary<String, Object> as value type";
throw new PropertyAccessException(message);
}
}
public static EventPropertyGetter GetGetter(
Schema avroSchema,
Dictionary <string, EventPropertyGetter> propertyGetterCache,
IDictionary <string, PropertySetDescriptorItem> propertyDescriptors,
string propertyName,
bool addToCache,
EventAdapterService eventAdapterService)
{
var getter = propertyGetterCache.Get(propertyName);
if (getter != null)
{
return(getter);
}
var unescapePropName = ASTUtil.UnescapeDot(propertyName);
var item = propertyDescriptors.Get(unescapePropName);
if (item != null)
{
getter = item.PropertyGetter;
MayAddToGetterCache(propertyName, propertyGetterCache, getter, true);
return(getter);
}
// see if this is a nested property
var index = ASTUtil.UnescapedIndexOfDot(propertyName);
if (index == -1)
{
var prop = PropertyParser.ParseAndWalkLaxToSimple(propertyName);
if (prop is IndexedProperty)
{
var indexedProp = (IndexedProperty)prop;
Field field = avroSchema.GetField(prop.PropertyNameAtomic);
if (field == null)
{
return(null);
}
switch (field.Schema.Tag)
{
case Schema.Type.Array:
var fragmentEventType = AvroFragmentTypeUtil.GetFragmentEventTypeForField(
field.Schema, eventAdapterService);
getter = new AvroEventBeanGetterIndexed(
field, indexedProp.Index,
fragmentEventType == null ? null : fragmentEventType.FragmentType, eventAdapterService);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
case Schema.Type.String:
getter = new AvroEventBeanGetterStringIndexed(field, indexedProp.Index);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
default:
return(null);
}
}
else if (prop is MappedProperty)
{
var mappedProp = (MappedProperty)prop;
Field field = avroSchema.GetField(prop.PropertyNameAtomic);
if (field == null || field.Schema.Tag != Schema.Type.Map)
{
return(null);
}
getter = new AvroEventBeanGetterMapped(field, mappedProp.Key);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
if (prop is DynamicIndexedProperty)
{
var dynamicIndexedProp = (DynamicIndexedProperty)prop;
getter = new AvroEventBeanGetterIndexedDynamic(prop.PropertyNameAtomic, dynamicIndexedProp.Index);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
if (prop is DynamicMappedProperty)
{
var dynamicMappedProp = (DynamicMappedProperty)prop;
getter = new AvroEventBeanGetterMappedDynamic(prop.PropertyNameAtomic, dynamicMappedProp.Key);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
else if (prop is DynamicSimpleProperty)
{
getter = new AvroEventBeanGetterSimpleDynamic(prop.PropertyNameAtomic);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
return(null); // simple property already cached
}
// Take apart the nested property into a map key and a nested value class property name
var propertyTop = ASTUtil.UnescapeDot(propertyName.Substring(0, index));
var propertyNested = propertyName.Substring(index + 1);
var isRootedDynamic = false;
// If the property is dynamic, remove the ? since the property type is defined without
if (propertyTop.EndsWith("?"))
{
propertyTop = propertyTop.Substring(0, propertyTop.Length - 1);
isRootedDynamic = true;
}
var propTop = PropertyParser.ParseAndWalkLaxToSimple(propertyTop);
Field fieldTop = avroSchema.GetField(propTop.PropertyNameAtomic);
// field is known and is a record
if (fieldTop != null && fieldTop.Schema.Tag == Schema.Type.Record && propTop is SimpleProperty)
{
var factory = new GetterNestedFactoryRootedSimple(eventAdapterService, fieldTop);
var property = PropertyParser.ParseAndWalk(propertyNested, isRootedDynamic);
getter = PropertyGetterNested(factory, fieldTop.Schema, property, eventAdapterService);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
// field is known and is a record
if (fieldTop != null && fieldTop.Schema.Tag == Schema.Type.Array && propTop is IndexedProperty)
{
var factory = new GetterNestedFactoryRootedIndexed(
eventAdapterService, fieldTop, ((IndexedProperty)propTop).Index);
var property = PropertyParser.ParseAndWalk(propertyNested, isRootedDynamic);
getter = PropertyGetterNested(factory, fieldTop.Schema.GetElementType(), property, eventAdapterService);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
// field is not known or is not a record
if (!isRootedDynamic)
{
return(null);
}
var propertyX = PropertyParser.ParseAndWalk(propertyNested, true);
var innerGetter = GetDynamicGetter(propertyX);
getter = new AvroEventBeanGetterNestedDynamicPoly(propertyTop, innerGetter);
MayAddToGetterCache(propertyName, propertyGetterCache, getter, addToCache);
return(getter);
}
