/// <summary>Ctor. </summary>
/// <param name="descriptor">property descriptor</param>
/// <param name="getter">getter for values</param>
/// <param name="fragmentArray">true if array fragment</param>
/// <param name="optionalFragmentTypeName">null if not a fragment, else fragment type name</param>
public ExplicitPropertyDescriptor(EventPropertyDescriptor descriptor, EventPropertyGetter getter, bool fragmentArray, String optionalFragmentTypeName)
{
Descriptor = descriptor;
Getter = getter;
IsFragmentArray = fragmentArray;
OptionalFragmentTypeName = optionalFragmentTypeName;
}
/// <summary>
/// Sets explicit properties using a map of event property name and getter instance
/// for each property.
/// </summary>
/// <param name="explicitProperties">property descriptors for explicit properties</param>
protected void Initialize(ICollection <ExplicitPropertyDescriptor> explicitProperties)
{
PropertyGetters = new Dictionary <String, EventPropertyGetterSPI>();
_propertyDescriptors = new EventPropertyDescriptor[explicitProperties.Count];
_propertyNames = new String[explicitProperties.Count];
PropertyDescriptorMap = new Dictionary <String, EventPropertyDescriptor>();
_propertyFragmentTypes = new Dictionary <String, Pair <ExplicitPropertyDescriptor, FragmentEventType> >();
int count = 0;
foreach (ExplicitPropertyDescriptor propertyDescriptor in explicitProperties)
{
_propertyNames[count] = propertyDescriptor.Descriptor.PropertyName;
PropertyGetters.Put(propertyDescriptor.Descriptor.PropertyName, propertyDescriptor.Getter);
EventPropertyDescriptor desc = propertyDescriptor.Descriptor;
_propertyDescriptors[count] = desc;
PropertyDescriptorMap.Put(desc.PropertyName, desc);
if (propertyDescriptor.OptionalFragmentTypeName != null)
{
_propertyFragmentTypes.Put(propertyDescriptor.Descriptor.PropertyName,
new Pair <ExplicitPropertyDescriptor, FragmentEventType>(
propertyDescriptor, null));
}
if (!desc.IsFragment)
{
_propertyFragmentTypes.Put(propertyDescriptor.Descriptor.PropertyName, null);
}
count++;
}
}
private void RunAssertion(EPStatement stmt)
{
FragmentEventType fragmentType = stmt.EventType.GetFragmentType("subrow");
Assert.IsFalse(fragmentType.IsIndexed);
Assert.IsFalse(fragmentType.IsNative);
Object[][] rows = new Object[][] {
new Object[] { "v1", typeof(string) },
new Object[] { "v2", typeof(int) },
};
for (int i = 0; i < rows.Length; i++)
{
String message = "Failed assertion for " + rows[i][0];
EventPropertyDescriptor prop = fragmentType.FragmentType.PropertyDescriptors[i];
Assert.AreEqual(rows[i][0], prop.PropertyName, message);
Assert.AreEqual(rows[i][1], prop.PropertyType, message);
}
String[] fields = "subrow.v1,subrow.v2".Split(',');
_epService.EPRuntime.SendEvent(new SupportBean_S0(1));
EventBean theEvent = _listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(theEvent, fields, new Object[] { null, null });
_epService.EPRuntime.SendEvent(new SupportBean("E1", 10));
_epService.EPRuntime.SendEvent(new SupportBean_S0(2));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "E1", 10 });
_epService.EPRuntime.SendEvent(new SupportBean("E2", 20));
_epService.EPRuntime.SendEvent(new SupportBean_S0(3));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "E2", 20 });
}
private void InitializeWriters()
{
var writables = PropertyHelper.GetWritableProperties(Stem.Clazz);
var desc = new EventPropertyDescriptor[writables.Count];
IDictionary<string, Pair<EventPropertyDescriptor, BeanEventPropertyWriter>> writers =
new Dictionary<string, Pair<EventPropertyDescriptor, BeanEventPropertyWriter>>();
var count = 0;
foreach (var writable in writables) {
var propertyDesc = new EventPropertyDescriptor(
writable.PropertyName,
writable.PropertyType,
null,
false,
false,
false,
false,
false);
desc[count++] = propertyDesc;
writers.Put(
writable.PropertyName,
new Pair<EventPropertyDescriptor, BeanEventPropertyWriter>(
propertyDesc,
new BeanEventPropertyWriter(
Stem.Clazz,
writable.WriteMember)));
}
_writerMap = writers;
_writeablePropertyDescriptors = desc;
}
/// <summary>
/// Adds additional properties that do not yet exist on the given type. Ignores properties already present. Allows nesting.
/// </summary>
/// <param name="typeMap">properties to add</param>
/// <param name="eventAdapterService">for resolving further map event types that are property types</param>
public void AddAdditionalProperties(IDictionary <String, Object> typeMap, EventAdapterService eventAdapterService)
{
// merge type graphs
NestableTypes = GraphUtil.MergeNestableMap(NestableTypes, typeMap);
PostUpdateNestableTypes();
// construct getters and types for each property (new or old)
var propertySet = EventTypeUtility.GetNestableProperties(
typeMap, eventAdapterService, GetterFactory, _optionalSuperTypes);
// add each new descriptor
var newPropertyDescriptors = new List <EventPropertyDescriptor>();
foreach (var propertyDesc in propertySet.PropertyDescriptors)
{
if (_propertyItems.ContainsKey(propertyDesc.PropertyName)) // not a new property
{
continue;
}
newPropertyDescriptors.Add(propertyDesc);
}
// add each that is not already present
var newPropertyNames = new List <String>();
foreach (var propertyName in propertySet.PropertyNameList)
{
if (_propertyItems.ContainsKey(propertyName)) // not a new property
{
continue;
}
newPropertyNames.Add(propertyName);
_propertyItems.Put(propertyName, propertySet.PropertyItems.Get(propertyName));
}
// expand property name array
var allPropertyNames = new String[_propertyNames.Length + newPropertyNames.Count];
Array.Copy(_propertyNames, 0, allPropertyNames, 0, _propertyNames.Length);
var count = _propertyNames.Length;
foreach (var newProperty in newPropertyNames)
{
allPropertyNames[count++] = newProperty;
}
_propertyNames = allPropertyNames;
// expand descriptor array
var allPropertyDescriptors =
new EventPropertyDescriptor[_propertyDescriptors.Length + newPropertyNames.Count];
Array.Copy(_propertyDescriptors, 0, allPropertyDescriptors, 0, _propertyDescriptors.Length);
count = _propertyDescriptors.Length;
foreach (var desc in newPropertyDescriptors)
{
allPropertyDescriptors[count++] = desc;
}
_propertyDescriptors = allPropertyDescriptors;
}
/// Converts a set of events to a set of properties.
PropertyDescriptorCollection IEventBindingService.GetEventProperties(EventDescriptorCollection events)
{
if (events == null)
{
throw new ArgumentNullException("events");
}
PropertyDescriptor[] props = new PropertyDescriptor[events.Count];
// We cache the property descriptors here for speed. Create those for
// events that we don't have yet.
//
if (_eventProperties == null)
{
_eventProperties = new Hashtable();
}
for (int i = 0; i < events.Count; i++)
{
object eventHashCode = GetEventDescriptorHashCode(events[i]);
props[i] = (PropertyDescriptor)_eventProperties[eventHashCode];
if (props[i] == null)
{
props[i] = new EventPropertyDescriptor(events[i], this);
_eventProperties[eventHashCode] = props[i];
}
}
return(new PropertyDescriptorCollection(props));
}
/// <summary>
/// Sets explicit properties using a map of event property name and getter instance for each property.
/// </summary>
/// <param name="explicitProperties">property descriptors for explicit properties</param>
protected void Initialize(IList<ExplicitPropertyDescriptor> explicitProperties)
{
propertyGetters = new Dictionary<string, EventPropertyGetterSPI>();
PropertyDescriptors = new EventPropertyDescriptor[explicitProperties.Count];
PropertyNames = new string[explicitProperties.Count];
propertyDescriptorMap = new Dictionary<string, EventPropertyDescriptor>();
propertyFragmentTypes = new Dictionary<string, Pair<ExplicitPropertyDescriptor, FragmentEventType>>();
var count = 0;
foreach (var @explicit in explicitProperties) {
PropertyNames[count] = @explicit.Descriptor.PropertyName;
propertyGetters.Put(@explicit.Descriptor.PropertyName, @explicit.Getter);
var desc = @explicit.Descriptor;
PropertyDescriptors[count] = desc;
propertyDescriptorMap.Put(desc.PropertyName, desc);
if (@explicit.OptionalFragmentTypeName != null) {
propertyFragmentTypes.Put(
@explicit.Descriptor.PropertyName,
new Pair<ExplicitPropertyDescriptor, FragmentEventType>(@explicit, null));
}
if (!desc.IsFragment) {
propertyFragmentTypes.Put(@explicit.Descriptor.PropertyName, null);
}
count++;
}
}
/// <summary>
/// Converts the property descriptor to an xelement.
/// </summary>
/// <param name="propertyDescriptor">The property descriptor.</param>
/// <returns></returns>
public static XElement ToXElement(this EventPropertyDescriptor propertyDescriptor)
{
var propertyType = propertyDescriptor.PropertyType;
var propertyComponentType = propertyDescriptor.PropertyComponentType;
var element = new XElement(
"propertyDescriptor",
new XAttribute("name", propertyDescriptor.PropertyName),
new XAttribute("isFragment", propertyDescriptor.IsFragment),
new XAttribute("isIndexed", propertyDescriptor.IsIndexed),
new XAttribute("isMapped", propertyDescriptor.IsMapped),
new XAttribute("requiresIndex", propertyDescriptor.RequiresIndex),
new XAttribute("requiresMapKey", propertyDescriptor.RequiresMapKey)
);
if (propertyType != null)
{
element.Add(ToXElement(propertyType, "propertyType"));
}
if (propertyComponentType != null)
{
element.Add(ToXElement(propertyComponentType, "propertyComponentType"));
}
return(element);
}
/// <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 void RunAssertionTypeAndColNameAndEquivalency(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddImport(typeof(SupportStaticMethodLib).FullName);
string epl = "select " +
"first(sa.DoublePrimitive + sa.IntPrimitive), " +
"first(sa.IntPrimitive), " +
"window(sa.*), " +
"last(*) from SupportBean#length(2) as sa";
EPStatement stmt = epService.EPAdministrator.CreateEPL(epl);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
var rows = new[]
{
new object[] { "first(sa.DoublePrimitive+sa.IntPrimitive)", typeof(double?) },
new object[] { "first(sa.IntPrimitive)", typeof(int) },
new object[] { "window(sa.*)", typeof(SupportBean[]) },
new object[] { "last(*)", typeof(SupportBean) },
};
for (int i = 0; i < rows.Length; i++)
{
EventPropertyDescriptor prop = stmt.EventType.PropertyDescriptors[i];
Assert.AreEqual(rows[i][0], prop.PropertyName);
Assert.AreEqual(rows[i][1], prop.PropertyType);
}
stmt.Dispose();
epl = "select " +
"first(sa.DoublePrimitive + sa.IntPrimitive) as f1, " +
"first(sa.IntPrimitive) as f2, " +
"window(sa.*) as w1, " +
"last(*) as l1 " +
"from SupportBean#length(2) as sa";
stmt = epService.EPAdministrator.CreateEPL(epl);
stmt.Events += listener.Update;
TryAssertionType(epService, listener, false);
stmt.Dispose();
epl = "select " +
"first(sa.DoublePrimitive + sa.IntPrimitive) as f1, " +
"first(sa.IntPrimitive) as f2, " +
"window(sa.*) as w1, " +
"last(*) as l1 " +
"from SupportBean#length(2) as sa " +
"having SupportStaticMethodLib.AlwaysTrue({first(sa.DoublePrimitive + sa.IntPrimitive), " +
"first(sa.IntPrimitive), window(sa.*), last(*)})";
stmt = epService.EPAdministrator.CreateEPL(epl);
stmt.Events += listener.Update;
TryAssertionType(epService, listener, true);
stmt.Dispose();
}
public EventPropertyGetterIndexed GetGetterIndexed(string indexedPropertyName)
{
EventPropertyDescriptor desc = _propertyDescriptorMap.Get(indexedPropertyName);
if (desc == null || !desc.IsIndexed)
{
return null;
}
var indexedProperty = new IndexedProperty(indexedPropertyName);
return (EventPropertyGetterIndexed) indexedProperty.GetGetter(this, _eventAdapterService);
}
public EventPropertyGetterMapped GetGetterMapped(string mappedPropertyName)
{
EventPropertyDescriptor desc = _propertyDescriptorMap.Get(mappedPropertyName);
if (desc == null || !desc.IsMapped)
{
return null;
}
var mappedProperty = new MappedProperty(mappedPropertyName);
return (EventPropertyGetterMapped) mappedProperty.GetGetter(this, _eventAdapterService);
}
public static object ExtractFragmentTypeIsIndexed(EventPropertyDescriptor desc, EventType eventType)
{
FragmentEventType fragType = eventType.GetFragmentType(desc.PropertyName);
if (fragType == null)
{
return(null);
}
return(fragType.IsIndexed);
}
public Type GetPropertyType(String propertyExpression)
{
EventPropertyDescriptor desc = PropertyDescriptorMap.Get(propertyExpression);
if (desc != null)
{
return(desc.PropertyType);
}
return(DoResolvePropertyType(propertyExpression));
}
public PropertySetDescriptorItem(
EventPropertyDescriptor propertyDescriptor,
Type simplePropertyType,
EventPropertyGetter propertyGetter,
FragmentEventType fragmentEventType)
{
PropertyDescriptor = propertyDescriptor;
SimplePropertyType = simplePropertyType;
PropertyGetter = propertyGetter;
FragmentEventType = fragmentEventType;
}
private void AssertFragment(string prop, EventType eventType, string fragmentTypeName, bool indexed)
{
EventPropertyDescriptor desc = eventType.GetPropertyDescriptor(prop);
Assert.AreEqual(true, desc.IsFragment);
FragmentEventType fragment = eventType.GetFragmentType(prop);
Assert.AreEqual(fragmentTypeName, fragment.FragmentType.Name);
Assert.AreEqual(false, fragment.IsNative);
Assert.AreEqual(indexed, fragment.IsIndexed);
}
public void TestTypeAndColNameAndEquivalency()
{
_epService.EPAdministrator.Configuration.AddImport <SupportStaticMethodLib>();
string epl = "select " +
"first(sa.DoublePrimitive + sa.IntPrimitive), " +
"first(sa.IntPrimitive), " +
"window(sa.*), " +
"last(*) from SupportBean.win:length(2) as sa";
EPStatement stmt = _epService.EPAdministrator.CreateEPL(epl);
stmt.AddListener(_listener);
object[][] rows = new object[][] {
new object[] { "first(sa.DoublePrimitive+sa.IntPrimitive)", typeof(double?) },
new object[] { "first(sa.IntPrimitive)", typeof(int?) },
new object[] { "window(sa.*)", typeof(SupportBean[]) },
new object[] { "last(*)", typeof(SupportBean) },
};
for (int i = 0; i < rows.Length; i++)
{
EventPropertyDescriptor prop = stmt.EventType.PropertyDescriptors[i];
Assert.AreEqual(rows[i][0], prop.PropertyName);
Assert.AreEqual(rows[i][1], prop.PropertyType);
}
stmt.Dispose();
epl = "select " +
"first(sa.DoublePrimitive + sa.IntPrimitive) as f1, " +
"first(sa.IntPrimitive) as f2, " +
"window(sa.*) as w1, " +
"last(*) as l1 " +
"from SupportBean.win:length(2) as sa";
stmt = _epService.EPAdministrator.CreateEPL(epl);
stmt.AddListener(_listener);
RunAssertionType(false);
stmt.Dispose();
epl = "select " +
"first(sa.DoublePrimitive + sa.IntPrimitive) as f1, " +
"first(sa.IntPrimitive) as f2, " +
"window(sa.*) as w1, " +
"last(*) as l1 " +
"from SupportBean.win:length(2) as sa " +
"having SupportStaticMethodLib.AlwaysTrue({first(sa.DoublePrimitive + sa.IntPrimitive), " +
"first(sa.IntPrimitive), window(sa.*), last(*)})";
stmt = _epService.EPAdministrator.CreateEPL(epl);
stmt.AddListener(_listener);
RunAssertionType(true);
}
private void Init()
{
_propertyNames = new string[_avroSchema.GetFields().Count];
_propertyDescriptors = new EventPropertyDescriptor[_propertyNames.Length];
int fieldNum = 0;
foreach (Field field in _avroSchema.GetFields())
{
_propertyNames[fieldNum] = field.Name;
Type propertyType = AvroTypeUtil.PropertyType(field.Schema);
Type componentType = null;
bool indexed = false;
bool mapped = false;
FragmentEventType fragmentEventType = null;
if (field.Schema.Tag == global::Avro.Schema.Type.Array)
{
componentType = AvroTypeUtil.PropertyType(field.Schema.GetElementType());
indexed = true;
if (field.Schema.GetElementType().Tag == global::Avro.Schema.Type.Record)
{
fragmentEventType = AvroFragmentTypeUtil.GetFragmentEventTypeForField(field.Schema, _eventAdapterService);
}
}
else if (field.Schema.Tag == global::Avro.Schema.Type.Map)
{
mapped = true;
componentType = AvroTypeUtil.PropertyType(field.Schema.GetValueType());
}
else if (field.Schema.Tag == global::Avro.Schema.Type.String)
{
indexed = true;
componentType = typeof(char);
fragmentEventType = null;
}
else
{
fragmentEventType = AvroFragmentTypeUtil.GetFragmentEventTypeForField(field.Schema, _eventAdapterService);
}
var getter = new AvroEventBeanGetterSimple(
field, fragmentEventType == null ? null : fragmentEventType.FragmentType, _eventAdapterService);
var descriptor = new EventPropertyDescriptor(
field.Name, propertyType, componentType, false, false, indexed, mapped, fragmentEventType != null);
var item = new PropertySetDescriptorItem(descriptor, propertyType, getter, fragmentEventType);
_propertyItems.Put(field.Name, item);
_propertyDescriptors[fieldNum] = descriptor;
fieldNum++;
}
}
public void TestDuckTyping()
{
Configuration config = SupportConfigFactory.GetConfiguration();
config.EngineDefaults.ExpressionConfig.IsDuckTyping = true;
_epService = EPServiceProviderManager.GetDefaultProvider(config);
_epService.Initialize();
if (InstrumentationHelper.ENABLED)
{
InstrumentationHelper.StartTest(_epService, GetType(), GetType().FullName);
}
_listener = new SupportUpdateListener();
_epService.EPAdministrator.Configuration.AddEventType <SupportBeanDuckType>("SupportBeanDuckType");
const string epl = "select " +
"(dt).MakeString() as strval, " +
"(dt).MakeInteger() as intval, " +
"(dt).MakeCommon().MakeString() as commonstrval, " +
"(dt).MakeCommon().MakeInteger() as commonintval, " +
"(dt).ReturnDouble() as commondoubleval " +
"from SupportBeanDuckType dt ";
EPStatement stmt = _epService.EPAdministrator.CreateEPL(epl);
stmt.Events += _listener.Update;
var rows = new Object[][] {
new Object[] { "strval", typeof(Object) },
new Object[] { "intval", typeof(Object) },
new Object[] { "commonstrval", typeof(Object) },
new Object[] { "commonintval", typeof(Object) },
new Object[] { "commondoubleval", typeof(double) } // this one is strongly typed
};
for (int i = 0; i < rows.Length; i++)
{
EventPropertyDescriptor prop = stmt.EventType.PropertyDescriptors[i];
Assert.AreEqual(rows[i][0], prop.PropertyName);
Assert.AreEqual(rows[i][1], prop.PropertyType);
}
String[] fields = "strval,intval,commonstrval,commonintval,commondoubleval".Split(',');
_epService.EPRuntime.SendEvent(new SupportBeanDuckTypeOne("x"));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { "x", null, null, -1, 12.9876d });
_epService.EPRuntime.SendEvent(new SupportBeanDuckTypeTwo(-10));
EPAssertionUtil.AssertProps(_listener.AssertOneGetNewAndReset(), fields, new Object[] { null, -10, "mytext", null, 11.1234d });
}
private void RunAssertionMultirowSingleColumn(EPServiceProvider epService)
{
// test named window as well as stream
epService.EPAdministrator.CreateEPL("create window SupportWindow#length(3) as SupportBean");
epService.EPAdministrator.CreateEPL("insert into SupportWindow select * from SupportBean");
string stmtText = "select p00, (select window(IntPrimitive) from SupportBean#keepall sb) as val from S0 as s0";
EPStatement stmt = epService.EPAdministrator.CreateEPL(stmtText);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
string[] fields = "p00,val".Split(',');
var rows = new object[][] {
new object[] { "p00", typeof(string) },
new object[] { "val", typeof(int[]) }
};
for (int i = 0; i < rows.Length; i++)
{
string message = "Failed assertion for " + rows[i][0];
EventPropertyDescriptor prop = stmt.EventType.PropertyDescriptors[i];
Assert.AreEqual(rows[i][0], prop.PropertyName, message);
Assert.AreEqual(rows[i][1], prop.PropertyType, message);
}
epService.EPRuntime.SendEvent(new SupportBean("T1", 5));
epService.EPRuntime.SendEvent(new SupportBean("T2", 10));
epService.EPRuntime.SendEvent(new SupportBean("T3", 15));
epService.EPRuntime.SendEvent(new SupportBean("T1", 6));
epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { null, new int[] { 5, 10, 15, 6 } });
// test named window and late start
stmt.Dispose();
stmtText = "select p00, (select window(IntPrimitive) from SupportWindow) as val from S0 as s0";
stmt = epService.EPAdministrator.CreateEPL(stmtText);
stmt.Events += listener.Update;
epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { null, new int[] { 10, 15, 6 } }); // length window 3
epService.EPRuntime.SendEvent(new SupportBean("T1", 5));
epService.EPRuntime.SendEvent(new SupportBean_S0(0));
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { null, new int[] { 15, 6, 5 } }); // length window 3
stmt.Dispose();
}
private void RunAssertionMultirowUnderlyingCorrelated(EPServiceProvider epService)
{
string stmtText = "select p00, " +
"(select window(sb.*) from SupportBean#keepall sb where TheString = s0.p00) as val " +
"from S0 as s0";
EPStatement stmt = epService.EPAdministrator.CreateEPL(stmtText);
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
var rows = new object[][] {
new object[] { "p00", typeof(string) },
new object[] { "val", typeof(SupportBean[]) }
};
for (int i = 0; i < rows.Length; i++)
{
string message = "Failed assertion for " + rows[i][0];
EventPropertyDescriptor prop = stmt.EventType.PropertyDescriptors[i];
Assert.AreEqual(rows[i][0], prop.PropertyName, message);
Assert.AreEqual(rows[i][1], prop.PropertyType, message);
}
epService.EPRuntime.SendEvent(new SupportBean_S0(1, "T1"));
Assert.IsNull(listener.AssertOneGetNewAndReset().Get("val"));
var sb1 = new SupportBean("T1", 10);
epService.EPRuntime.SendEvent(sb1);
epService.EPRuntime.SendEvent(new SupportBean_S0(2, "T1"));
EventBean received = listener.AssertOneGetNewAndReset();
Assert.AreEqual(typeof(SupportBean[]), received.Get("val").GetType());
EPAssertionUtil.AssertEqualsAnyOrder((object[])received.Get("val"), new object[] { sb1 });
var sb2 = new SupportBean("T2", 20);
epService.EPRuntime.SendEvent(sb2);
var sb3 = new SupportBean("T2", 30);
epService.EPRuntime.SendEvent(sb3);
epService.EPRuntime.SendEvent(new SupportBean_S0(3, "T2"));
received = listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertEqualsAnyOrder((object[])received.Get("val"), new object[] { sb2, sb3 });
stmt.Dispose();
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="eventAdapterService">The event adapter service.</param>
/// <param name="metadata">event type metadata</param>
/// <param name="eventTypeId">The event type id.</param>
/// <param name="variantSpec">the variant specification</param>
/// <param name="propertyResStrategy">stragegy for resolving properties</param>
/// <param name="config">The config.</param>
public VariantEventType(
EventAdapterService eventAdapterService,
EventTypeMetadata metadata,
int eventTypeId,
VariantSpec variantSpec,
VariantPropResolutionStrategy propertyResStrategy,
ConfigurationVariantStream config)
{
_eventAdapterService = eventAdapterService;
_metadata = metadata;
_eventTypeId = eventTypeId;
_variants = variantSpec.EventTypes;
_propertyResStrategy = propertyResStrategy;
_config = config;
_propertyDesc = new Dictionary <String, VariantPropertyDesc>();
foreach (EventType type in _variants)
{
IList <string> properties = type.PropertyNames;
properties = PropertyUtility.CopyAndSort(properties);
foreach (String property in properties)
{
if (!_propertyDesc.ContainsKey(property))
{
FindProperty(property);
}
}
}
ICollection <String> propertyNameKeySet = _propertyDesc.Keys;
_propertyNames = propertyNameKeySet.ToArray();
// for each of the properties in each type, attempt to load the property to build a property list
_propertyDescriptors = new EventPropertyDescriptor[_propertyDesc.Count];
_propertyDescriptorMap = new Dictionary <String, EventPropertyDescriptor>();
int count = 0;
foreach (var desc in _propertyDesc)
{
var type = desc.Value.PropertyType;
var indexType = type.GetIndexType();
var isIndexed = indexType != null;
var descriptor = new EventPropertyDescriptor(desc.Key, type, indexType, false, false, isIndexed, false, desc.Value.PropertyType.IsFragmentableType());
_propertyDescriptors[count++] = descriptor;
_propertyDescriptorMap.Put(desc.Key, descriptor);
}
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="variantSpec">the variant specification</param>
/// <param name="metadata">event type metadata</param>
public VariantEventType(
EventTypeMetadata metadata,
VariantSpec variantSpec)
{
Metadata = metadata;
Variants = variantSpec.EventTypes;
IsVariantAny = variantSpec.TypeVariance == TypeVariance.ANY;
VariantPropertyGetterCache = new VariantPropertyGetterCache(variantSpec.EventTypes);
if (IsVariantAny) {
propertyResStrategy = new VariantPropResolutionStrategyAny(this);
}
else {
propertyResStrategy = new VariantPropResolutionStrategyDefault(this);
}
propertyDesc = new Dictionary<string, VariantPropertyDesc>();
foreach (var type in Variants) {
foreach (var property in CollectionUtil.CopyAndSort(type.PropertyNames)) {
if (!propertyDesc.ContainsKey(property)) {
FindProperty(property);
}
}
}
var propertyNameKeySet = propertyDesc.Keys;
PropertyNames = propertyNameKeySet.ToArray();
// for each of the properties in each type, attempt to load the property to build a property list
PropertyDescriptors = new EventPropertyDescriptor[propertyDesc.Count];
propertyDescriptorMap = new Dictionary<string, EventPropertyDescriptor>();
var count = 0;
foreach (var desc in propertyDesc) {
var type = desc.Value.PropertyType;
var descriptor = new EventPropertyDescriptor(
desc.Key,
type,
type.GetIndexType(),
false,
false,
type.IsIndexed(),
false,
desc.Value.PropertyType.IsFragmentableType());
PropertyDescriptors[count++] = descriptor;
propertyDescriptorMap.Put(desc.Key, descriptor);
}
}
public void TestMultirowUnderlyingCorrelated()
{
String stmtText = "select p00, " +
"(select Window(sb.*) from SupportBean.win:keepall() sb where TheString = s0.P00) as val " +
"from S0 as s0";
EPStatement stmt = _epService.EPAdministrator.CreateEPL(stmtText);
stmt.Events += _listener.Update;
Object[][] rows = new Object[][] {
new Object[] { "p00", typeof(string) },
new Object[] { "val", typeof(SupportBean[]) }
};
for (int i = 0; i < rows.Length; i++)
{
String message = "Failed assertion for " + rows[i][0];
EventPropertyDescriptor prop = stmt.EventType.PropertyDescriptors[i];
Assert.AreEqual(rows[i][0], prop.PropertyName, message);
Assert.AreEqual(rows[i][1], prop.PropertyType, message);
}
_epService.EPRuntime.SendEvent(new SupportBean_S0(1, "T1"));
Assert.IsNull(_listener.AssertOneGetNewAndReset().Get("val"));
SupportBean sb1 = new SupportBean("T1", 10);
_epService.EPRuntime.SendEvent(sb1);
_epService.EPRuntime.SendEvent(new SupportBean_S0(2, "T1"));
EventBean received = _listener.AssertOneGetNewAndReset();
Assert.AreEqual(typeof(SupportBean[]), received.Get("val").GetType());
EPAssertionUtil.AssertEqualsAnyOrder((Object[])received.Get("val"), new Object[] { sb1 });
SupportBean sb2 = new SupportBean("T2", 20);
_epService.EPRuntime.SendEvent(sb2);
SupportBean sb3 = new SupportBean("T2", 30);
_epService.EPRuntime.SendEvent(sb3);
_epService.EPRuntime.SendEvent(new SupportBean_S0(3, "T2"));
received = _listener.AssertOneGetNewAndReset();
EPAssertionUtil.AssertEqualsAnyOrder((Object[])received.Get("val"), new Object[] { sb2, sb3 });
}
private void TryAssertionChainedParam(EPServiceProvider epService, SupportUpdateListener listener, EPStatement stmt, string subexpr)
{
var rows = new object[][] {
new object[] { subexpr, typeof(SupportChainChildTwo) }
};
for (int i = 0; i < rows.Length; i++)
{
EventPropertyDescriptor prop = stmt.EventType.PropertyDescriptors[i];
Assert.AreEqual(rows[i][0], prop.PropertyName);
Assert.AreEqual(rows[i][1], prop.PropertyType);
}
epService.EPRuntime.SendEvent(new SupportChainTop());
Object result = listener.AssertOneGetNewAndReset().Get(subexpr);
Assert.AreEqual("abcappend", ((SupportChainChildTwo)result).GetText());
}
public static void AssertEventTypeProperties(
Object[][] expectedArr,
EventType eventType,
params SupportEventTypeAssertionEnum[] assertions)
{
for (int propNum = 0; propNum < expectedArr.Length; propNum++)
{
string message = "Failed assertion for property " + propNum;
EventPropertyDescriptor prop = eventType.PropertyDescriptors[propNum];
for (int i = 0; i < assertions.Length; i++)
{
SupportEventTypeAssertionEnum assertion = assertions[i];
object expected = expectedArr[propNum][i];
object value = assertion.GetExtractor().Invoke(prop, eventType);
ScopeTestHelper.AssertEquals(message + " at assertion " + assertion, expected, value);
}
}
}
private void InitializeWriters()
{
var writables = PropertyHelper.GetWritableProperties(FastClass.TargetType);
var desc = new EventPropertyDescriptor[writables.Count];
var writers = new Dictionary <String, Pair <EventPropertyDescriptor, BeanEventPropertyWriter> >();
int count = 0;
foreach (WriteablePropertyDescriptor writable in writables)
{
var propertyDesc = new EventPropertyDescriptor(writable.PropertyName, writable.PropertyType, null, false, false, false, false, false);
desc[count++] = propertyDesc;
FastMethod fastMethod = FastClass.GetMethod(writable.WriteMethod);
writers.Put(writable.PropertyName, new Pair <EventPropertyDescriptor, BeanEventPropertyWriter>(propertyDesc, new BeanEventPropertyWriter(UnderlyingType, fastMethod)));
}
_writerMap = writers;
_writeablePropertyDescriptors = desc;
}
PropertyDescriptor IEventBindingService.GetEventProperty(EventDescriptor e)
{
if (e == null)
{
throw new ArgumentNullException("e");
}
if (this._eventProperties == null)
{
this._eventProperties = new Hashtable();
}
object eventHashCode = this.GetEventDescriptorHashCode(e);
PropertyDescriptor prop = (PropertyDescriptor)this._eventProperties[eventHashCode];
if (prop == null)
{
prop = new EventPropertyDescriptor(e, this);
this._eventProperties[eventHashCode] = prop;
}
return(prop);
}
private Type DoResolvePropertyType(String propertyExpression, bool allowSimpleProperties)
{
// see if this is an indexed property
int index = ASTUtil.UnescapedIndexOfDot(propertyExpression);
if ((!allowSimpleProperties) && (index == -1))
{
// parse, can be an indexed property
Property property = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression);
if (!property.IsDynamic)
{
if (!(property is IndexedProperty))
{
return(null);
}
var indexedProp = (IndexedProperty)property;
EventPropertyDescriptor descriptor = PropertyDescriptorMap.Get(indexedProp.PropertyNameAtomic);
if (descriptor == null)
{
return(null);
}
return(descriptor.PropertyType);
}
}
Property prop = PropertyParser.ParseAndWalkLaxToSimple(propertyExpression);
if (prop.IsDynamic)
{
return(typeof(XmlNode));
}
SchemaItem item = prop.GetPropertyTypeSchema(_schemaModelRoot, EventAdapterService);
if (item == null)
{
return(null);
}
return(SchemaUtil.ToReturnType(item));
}
private ExprEvaluator GetPropertyPairEvaluator(ExprEvaluator parameterEval, Pair <PropertyResolutionDescriptor, string> propertyInfoPair, ExprValidationContext validationContext)
{
string propertyName = propertyInfoPair.First.PropertyName;
EventPropertyDescriptor propertyDesc = EventTypeUtility.GetNestablePropertyDescriptor(propertyInfoPair.First.StreamEventType, propertyName);
if (propertyDesc == null || (!propertyDesc.IsMapped && !propertyDesc.IsIndexed))
{
throw new ExprValidationException("Unknown single-row function, aggregation function or mapped or indexed property named '" + propertyName + "' could not be resolved");
}
int streamNum = propertyInfoPair.First.StreamNum;
if (propertyDesc.IsMapped)
{
if (parameterEval.ReturnType != typeof(string))
{
throw new ExprValidationException("Parameter expression to mapped property '" + propertyDesc.PropertyName + "' is expected to return a string-type value but returns " + parameterEval.ReturnType.GetTypeNameFullyQualPretty());
}
EventPropertyGetterMapped mappedGetter = propertyInfoPair.First.StreamEventType.GetGetterMapped(propertyInfoPair.First.PropertyName);
if (mappedGetter == null)
{
throw new ExprValidationException("Mapped property named '" + propertyName + "' failed to obtain getter-object");
}
return(new ExprDotEvalPropertyExprMapped(validationContext.StatementName, propertyDesc.PropertyName, streamNum, parameterEval, propertyDesc.PropertyComponentType, mappedGetter));
}
else
{
if (parameterEval.ReturnType.GetBoxedType() != typeof(int?))
{
throw new ExprValidationException("Parameter expression to indexed property '" + propertyDesc.PropertyName + "' is expected to return a Integer-type value but returns " + parameterEval.ReturnType.GetTypeNameFullyQualPretty());
}
EventPropertyGetterIndexed indexedGetter = propertyInfoPair.First.StreamEventType.GetGetterIndexed(propertyInfoPair.First.PropertyName);
if (indexedGetter == null)
{
throw new ExprValidationException("Indexed property named '" + propertyName + "' failed to obtain getter-object");
}
return(new ExprDotEvalPropertyExprIndexed(validationContext.StatementName, propertyDesc.PropertyName, streamNum, parameterEval, propertyDesc.PropertyComponentType, indexedGetter));
}
}
PropertyDescriptor IEventBindingService.GetEventProperty(EventDescriptor e)
{
PropertyDescriptor descriptor = (PropertyDescriptor) this.EventProperties[this.GetEventDescriptorHashCode(e)];
if (descriptor == null)
{
descriptor = new EventPropertyDescriptor(e);
this.EventProperties[this.GetEventDescriptorHashCode(e)] = descriptor;
}
return descriptor;
}