private static void RunTest(PropTestDesc test, BeanEventType eventType, EventBean eventBean)
{
String propertyName = test.PropertyName;
Assert.AreEqual(test.IsProperty, eventType.IsProperty(propertyName), "isProperty mismatch on '" + propertyName + "',");
Assert.AreEqual(test.Clazz, eventType.GetPropertyType(propertyName), "getPropertyType mismatch on '" + propertyName + "',");
EventPropertyGetter getter = eventType.GetGetterSPI(propertyName);
if (getter == null)
{
Assert.IsFalse(test.HasGetter, "getGetter null on '" + propertyName + "',");
}
else
{
Assert.IsTrue(test.HasGetter, "getGetter not null on '" + propertyName + "',");
#pragma warning disable CS0252 // Possible unintended reference comparison; left hand side needs cast
if (test.GetterReturnValue == typeof(NullReferenceException))
{
#pragma warning restore CS0252 // Possible unintended reference comparison; left hand side needs cast
try {
getter.Get(eventBean);
Assert.Fail("getGetter not throwing null pointer on '" + propertyName);
} catch (NullReferenceException) {
// expected
}
}
else
{
var value = getter.Get(eventBean);
Assert.AreEqual(test.GetterReturnValue, value, "getter value mismatch on '" + propertyName + "',");
}
}
}
public WriteDesc(EventTypeSPI type, String variableName, EventPropertyWriter writer, EventPropertyGetter getter)
{
Type = type;
VariableName = variableName;
Writer = writer;
Getter = getter;
}
public void TestSubscriberandListener()
{
_epService.EPAdministrator.Configuration.AddEventType(
"SupportBean", typeof(SupportBean));
_epService.EPAdministrator.CreateEPL(
"insert into A1 select s.*, 1 as a from SupportBean as s");
EPStatement stmt = _epService.EPAdministrator.CreateEPL(
"select a1.* from A1 as a1");
var listener = new SupportUpdateListener();
var subscriber = new MySubscriberRowByRowObjectArr();
stmt.Events += listener.Update;
stmt.Subscriber = subscriber;
_epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EventBean theEvent = listener.AssertOneGetNewAndReset();
Assert.AreEqual("E1", theEvent.Get("TheString"));
Assert.AreEqual(1, theEvent.Get("IntPrimitive"));
Assert.IsTrue(theEvent.Underlying is Pair <object, IDictionary <string, object> >);
foreach (String property in stmt.EventType.PropertyNames)
{
EventPropertyGetter getter = stmt.EventType.GetGetter(property);
getter.Get(theEvent);
}
}
public virtual EventPropertyGetter GetGetter(string propertyName)
{
if (!_eventAdapterService.EngineImportService.IsCodegenEventPropertyGetters)
{
return(GetGetterSPI(propertyName));
}
if (_propertyGetterCodegeneratedCache == null)
{
_propertyGetterCodegeneratedCache = new Dictionary <string, EventPropertyGetter>();
}
EventPropertyGetter getter = _propertyGetterCodegeneratedCache.Get(propertyName);
if (getter != null)
{
return(getter);
}
EventPropertyGetterSPI getterSPI = GetGetterSPI(propertyName);
if (getterSPI == null)
{
return(null);
}
EventPropertyGetter getterCode = _eventAdapterService.EngineImportService.CodegenGetter(getterSPI, propertyName);
_propertyGetterCodegeneratedCache.Put(propertyName, getterCode);
return(getterCode);
}
public ExprIdentNodeEvaluatorImpl(int streamNum, EventPropertyGetter propertyGetter, Type propertyType, ExprIdentNode identNode)
{
_streamNum = streamNum;
_propertyGetter = propertyGetter;
_propertyType = propertyType; // .GetBoxedType();
_identNode = identNode;
}
internal DTLocalEvaluatorBeanReformat(
EventPropertyGetter getter,
DTLocalEvaluator inner)
{
_getter = getter;
_inner = inner;
}
public DTLocalBeanIntervalNoEndTSEval(
EventPropertyGetter getter,
DTLocalEvaluator inner)
{
this.getter = getter;
this.inner = inner;
}
private void RunAssertionSubscriberAndListener(EPServiceProvider epService)
{
epService.EPAdministrator.Configuration.AddEventType <SupportBean>();
epService.EPAdministrator.CreateEPL("insert into A1 select s.*, 1 as a from SupportBean as s");
EPStatement stmt = epService.EPAdministrator.CreateEPL("select a1.* from A1 as a1");
var listener = new SupportUpdateListener();
var subscriber = new SupportSubscriberRowByRowObjectArrayPlainNStmt();
stmt.Events += listener.Update;
stmt.Subscriber = subscriber;
epService.EPRuntime.SendEvent(new SupportBean("E1", 1));
EventBean theEvent = listener.AssertOneGetNewAndReset();
Assert.AreEqual("E1", theEvent.Get("TheString"));
Assert.AreEqual(1, theEvent.Get("IntPrimitive"));
Assert.That(theEvent.Underlying, Is.InstanceOf <Pair <object, Map> >());
foreach (string property in stmt.EventType.PropertyNames)
{
EventPropertyGetter getter = stmt.EventType.GetGetter(property);
getter.Get(theEvent);
}
}
public SubordIndexedTableLookupStrategySinglePropUnique(int keyStreamNum, EventPropertyGetter propertyGetter, PropertyIndexedEventTableSingleUnique index, LookupStrategyDesc strategyDesc)
{
_keyStreamNum = keyStreamNum;
_propertyGetter = propertyGetter;
_index = index;
_strategyDesc = strategyDesc;
}
private Object HandleGetterTrailingChain(Object result)
{
for (int i = 1; i < _getterChain.Length; i++)
{
if (result == null)
{
return(null);
}
EventPropertyGetter getter = _getterChain[i];
if (result is EventBean)
{
result = getter.Get((EventBean)result);
}
else if (getter is BeanEventPropertyGetter)
{
result = ((BeanEventPropertyGetter)getter).GetBeanProp(result);
}
else if (result is Map && getter is MapEventPropertyGetter)
{
result = ((MapEventPropertyGetter)getter).GetMap((Map)result);
}
else
{
return(null);
}
}
return(result);
}
private bool HandleIsExistsTrailingChain(object result)
{
for (var i = 1; i < _getterChain.Length; i++)
{
if (result == null) return false;
EventPropertyGetter getter = _getterChain[i];
if (i == _getterChain.Length - 1)
if (getter is BeanEventPropertyGetter)
return ((BeanEventPropertyGetter) getter).IsBeanExistsProperty(result);
else if (result is Map && getter is MapEventPropertyGetter)
return ((MapEventPropertyGetter) getter).IsMapExistsProperty((Map) result);
else if (result is EventBean)
return getter.IsExistsProperty((EventBean) result);
else
return false;
if (getter is BeanEventPropertyGetter)
result = ((BeanEventPropertyGetter) getter).GetBeanProp(result);
else if (result is Map && getter is MapEventPropertyGetter)
result = ((MapEventPropertyGetter) getter).GetMap((Map) result);
else if (result is EventBean)
result = getter.Get((EventBean) result);
else
return false;
}
return false;
}
/// <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>Ctor. </summary>
public PropertySortedEventTable(EventPropertyGetter propertyGetter, EventTableOrganization organization)
{
_organization = organization;
PropertyGetter = propertyGetter;
PropertyIndex = new OrderedDictionary <Object, ISet <EventBean> >();
NullKeyedValues = new LinkedHashSet <EventBean>();
}
private static void RunTest(PropTestDesc test, BeanEventType eventType, EventBean eventBean)
{
String propertyName = test.PropertyName;
Assert.AreEqual(test.IsProperty, eventType.IsProperty(propertyName), "isProperty mismatch on '" + propertyName + "',");
Assert.AreEqual(test.Clazz, eventType.GetPropertyType(propertyName), "getPropertyType mismatch on '" + propertyName + "',");
EventPropertyGetter getter = eventType.GetGetter(propertyName);
if (getter == null)
{
Assert.IsFalse(test.HasGetter, "getGetter null on '" + propertyName + "',");
}
else
{
Assert.IsTrue(test.HasGetter, "getGetter not null on '" + propertyName + "',");
if (test.GetterReturnValue == typeof(NullReferenceException))
{
try {
getter.Get(eventBean);
Assert.Fail("getGetter not throwing null pointer on '" + propertyName);
} catch (NullReferenceException) {
// expected
}
}
else
{
var value = getter.Get(eventBean);
Assert.AreEqual(test.GetterReturnValue, value, "getter value mismatch on '" + propertyName + "',");
}
}
}
internal DTLocalEvaluatorBeanCalOps(
EventPropertyGetter getter,
DTLocalEvaluator inner)
{
_getter = getter;
_inner = inner;
}
public EventPropertyGetter GetGetterIndexedEntryEventBeanArrayElement(
String propertyNameAtomic,
int index,
EventPropertyGetter nestedGetter)
{
return(new MapEventBeanArrayIndexedElementPropertyGetter(propertyNameAtomic, index, nestedGetter));
}
internal DTLocalEvaluatorBeanIntervalNoEndTS(
EventPropertyGetter getter,
DTLocalEvaluator inner)
{
_getter = getter;
_inner = inner;
}
public FilterSpecLookupable(String expression, EventPropertyGetter getter, Type returnType, bool isNonPropertyGetter)
{
Expression = expression;
Getter = getter;
ReturnType = returnType;
IsNonPropertyGetter = isNonPropertyGetter;
}
public override ExprNode Validate(ExprValidationContext validationContext)
{
if (validationContext.ContextDescriptor == null)
{
throw new ExprValidationException(
"Context property '" + _propertyName + "' cannot be used in the expression as provided");
}
EventType eventType = validationContext.ContextDescriptor.ContextPropertyRegistry.ContextEventType;
if (eventType == null)
{
throw new ExprValidationException(
"Context property '" + _propertyName + "' cannot be used in the expression as provided");
}
_getter = eventType.GetGetter(_propertyName);
if (_getter == null)
{
throw new ExprValidationException(
"Context property '" + _propertyName + "' is not a known property, known properties are " +
eventType.PropertyNames.Render());
}
_returnType = eventType.GetPropertyType(_propertyName);
return(null);
}
public DTLocalBeanReformatEval(
EventPropertyGetter getter,
DTLocalEvaluator inner)
{
this.getter = getter;
this.inner = inner;
}
public InSetOfValuesContextProp(String propertyName, EventPropertyGetter getter, Coercer coercer, Type returnType)
{
_propertyName = propertyName;
_getter = getter;
_numberCoercer = coercer;
_returnType = returnType;
}
public SubordIndexedTableLookupStrategySingleProp(int keyStreamNum, EventPropertyGetter propertyGetter, PropertyIndexedEventTableSingle index, LookupStrategyDesc strategyDesc)
{
this._keyStreamNum = keyStreamNum;
this._propertyGetter = propertyGetter;
this._index = index;
this._strategyDesc = strategyDesc;
}
/// <summary>Ctor. </summary>
/// <param name="propertyName">the property this gets</param>
/// <param name="propertyNumber">the property number</param>
/// <param name="fullGetter">the getter of the base event to use, if any</param>
/// <param name="authoritySets">is the group numbers that the getter may access to obtain a property value</param>
public RevisionGetterParameters(String propertyName, int propertyNumber, EventPropertyGetter fullGetter, int[] authoritySets)
{
this.propertyName = propertyName;
this.propertyNumber = propertyNumber;
this.baseGetter = fullGetter;
this.propertyGroups = authoritySets;
}
public FilterSpecParamContextProp(FilterSpecLookupable lookupable, FilterOperator filterOperator, String contextPropertyName, EventPropertyGetter getter, Coercer numberCoercer)
: base(lookupable, filterOperator)
{
_contextPropertyName = contextPropertyName;
_getter = getter;
_numberCoercer = numberCoercer;
}
public PropertyExprEvaluatorScalarCollection(string propertyName, int streamId, EventPropertyGetter getter, Type componentType)
{
_propertyName = propertyName;
_streamId = streamId;
_getter = getter;
_componentType = componentType;
}
/// <summary>Fast lookup of a getter for a property and type. </summary>
/// <param name="assignedPropertyNumber">number of property to use as index</param>
/// <param name="eventType">type of underlying event</param>
/// <returns>getter</returns>
public EventPropertyGetter GetGetter(int assignedPropertyNumber, EventType eventType)
{
VariantPropertyGetterRow lastGetters = _lastUsedGetters;
if ((lastGetters != null) && (lastGetters.EventType == eventType))
{
return(lastGetters.GetterPerProp[assignedPropertyNumber]);
}
VariantPropertyGetterRow row = _allGetters.Get(eventType);
// newly seen type (Using ANY type variance or as a subtype of an existing variance type)
// synchronized add, if added twice then that is ok too
if (row == null)
{
lock (this)
{
row = _allGetters.Get(eventType);
if (row == null)
{
row = AddType(eventType);
}
}
}
EventPropertyGetter getter = row.GetterPerProp[assignedPropertyNumber];
_lastUsedGetters = row;
return(getter);
}
public ExprIdentNodeEvaluatorLogging(int streamNum, EventPropertyGetter propertyGetter, Type propertyType, ExprIdentNode identNode, String propertyName, String statementName, String engineURI)
: base(streamNum, propertyGetter, propertyType, identNode)
{
_propertyName = propertyName;
_statementName = statementName;
_engineURI = engineURI;
}
private VariantPropertyGetterRow AddType(EventType eventType)
{
var newKnownTypes = (EventType[])ResizeArray(_knownTypes, _knownTypes.Length + 1);
newKnownTypes[newKnownTypes.Length - 1] = eventType;
// create getters
var getters = new EventPropertyGetter[_properties.Count];
for (int i = 0; i < _properties.Count; i++)
{
getters[i] = eventType.GetGetter(_properties[i]);
}
var row = new VariantPropertyGetterRow(eventType, getters);
var newAllGetters = new Dictionary <EventType, VariantPropertyGetterRow>();
newAllGetters.PutAll(_allGetters);
newAllGetters.Put(eventType, row);
// overlay volatiles
_knownTypes = newKnownTypes;
_allGetters = newAllGetters;
return(row);
}
public EventPropertyGetter GetGetter(String propertyName)
{
EventPropertyGetter cachedGetter = _propertyGetterCache.Get(propertyName);
if (cachedGetter != null)
{
return(cachedGetter);
}
SimplePropertyInfo simpleProp = GetSimplePropertyInfo(propertyName);
if ((simpleProp != null) && (simpleProp.Getter != null))
{
EventPropertyGetter propertyGetter = simpleProp.Getter;
_propertyGetterCache.Put(propertyName, propertyGetter);
return(propertyGetter);
}
Property prop = PropertyParser.ParseAndWalk(propertyName, false);
if (prop is SimpleProperty)
{
// there is no such property since it wasn't in simplePropertyGetters
return(null);
}
EventPropertyGetter getter = prop.GetGetter(this, _eventAdapterService);
_propertyGetterCache.Put(propertyName, getter);
return(getter);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="getter">for retrieving the value</param>
/// <param name="name">property name</param>
/// <param name="metadata">the nested properties metadata</param>
/// <param name="isArray">indicates whether this is an indexed property</param>
public NestedGetterPair(EventPropertyGetter getter, String name, RendererMeta metadata, bool isArray)
{
this.getter = getter;
this.name = name;
this.metadata = metadata;
this.isArray = isArray;
}