public PlugInAggregationMultiFunctionHandler ValidateGetHandler(
PlugInAggregationMultiFunctionValidationContext validationContext)
{
Assert.IsNotNull(validationContext.NamedParameters.Get("filter").First());
var valueEval = validationContext.ParameterExpressions[0].ExprEvaluator;
ExprEvaluator filterEval = validationContext.NamedParameters.Get("filter")[0].ExprEvaluator;
return new MyAccessAggHandler(valueEval, filterEval);
}
private void TryAssertion(EPServiceProvider epService, EPStatement stmt)
{
var listener = new SupportUpdateListener();
stmt.Events += listener.Update;
string[] fields = "c0,c1".Split(',');
foreach (string prop in fields)
{
Assert.AreEqual(typeof(SupportBean), stmt.EventType.GetPropertyDescriptor(prop).PropertyType);
Assert.AreEqual(true, stmt.EventType.GetPropertyDescriptor(prop).IsFragment);
Assert.AreEqual("SupportBean", stmt.EventType.GetFragmentType(prop).FragmentType.Name);
}
// there should be just 1 factory instance for all of the registered functions for this statement
Assert.AreEqual(1, SupportAggMFFactory.Factories.Count);
Assert.AreEqual(2, SupportAggMFFactory.FunctionDeclContexts.Count);
for (int i = 0; i < 2; i++)
{
PlugInAggregationMultiFunctionDeclarationContext contextDecl = SupportAggMFFactory.FunctionDeclContexts[i];
Assert.AreEqual(i == 0 ? "se1" : "se2", contextDecl.FunctionName);
Assert.AreEqual(EPServiceProviderConstants.DEFAULT_ENGINE_URI, contextDecl.EngineURI);
Assert.IsFalse(contextDecl.IsDistinct);
Assert.IsNotNull(contextDecl.Configuration);
PlugInAggregationMultiFunctionValidationContext contextValid = SupportAggMFFactory.FunctionHandlerValidationContexts[i];
Assert.AreEqual(i == 0 ? "se1" : "se2", contextValid.FunctionName);
Assert.AreEqual(EPServiceProviderConstants.DEFAULT_ENGINE_URI, contextValid.EngineURI);
Assert.IsNotNull(contextValid.ParameterExpressions);
Assert.IsNotNull(contextValid.AllParameterExpressions);
Assert.IsNotNull(contextValid.Config);
Assert.IsNotNull(contextValid.EventTypes);
Assert.IsNotNull(contextValid.ValidationContext);
Assert.IsNotNull(contextValid.StatementName);
}
Assert.AreEqual(2, SupportAggMFHandler.ProviderKeys.Count);
Assert.AreEqual(2, SupportAggMFHandler.Accessors.Count);
Assert.AreEqual(1, SupportAggMFHandler.ProviderFactories.Count);
Assert.AreEqual(0, SupportAggMFFactorySingleEvent.StateContexts.Count);
// group 1
var eventOne = new SupportBean("E1", 1);
epService.EPRuntime.SendEvent(eventOne);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { eventOne, eventOne });
Assert.AreEqual(1, SupportAggMFFactorySingleEvent.StateContexts.Count);
PlugInAggregationMultiFunctionStateContext context = SupportAggMFFactorySingleEvent.StateContexts[0];
Assert.AreEqual("E1", context.GroupKey);
// group 2
var eventTwo = new SupportBean("E2", 2);
epService.EPRuntime.SendEvent(eventTwo);
EPAssertionUtil.AssertProps(listener.AssertOneGetNewAndReset(), fields, new object[] { eventTwo, eventTwo });
Assert.AreEqual(2, SupportAggMFFactorySingleEvent.StateContexts.Count);
stmt.Dispose();
}
public PlugInAggregationMultiFunctionHandler ValidateGetHandler(PlugInAggregationMultiFunctionValidationContext validationContext)
{
if (validationContext.FunctionName.Equals("referenceCountedMap"))
{
return(new ReferenceCountedMapFunctionHandler(SharedStateKey));
}
if (validationContext.FunctionName.Equals("referenceCountLookup"))
{
var eval = validationContext.ParameterExpressions[0].ExprEvaluator;
return(new ReferenceCountLookupFunctionHandler(SharedStateKey, eval));
}
throw new ArgumentException("Unexpected function name '" + validationContext.FunctionName);
}
public PlugInAggregationMultiFunctionHandler ValidateGetHandler(PlugInAggregationMultiFunctionValidationContext validationContext)
{
switch (validationContext.FunctionName)
{
case "referenceCountedMap":
return(new ReferenceCountedMapFunctionHandler(SHARED_STATE_KEY));
case "referenceCountLookup":
ExprEvaluator eval = validationContext.ParameterExpressions[0].ExprEvaluator;
return(new ReferenceCountLookupFunctionHandler(SHARED_STATE_KEY, eval));
}
throw new ArgumentException("Unexpected function name '" + validationContext.FunctionName);
}
private AggregationMethodFactory ValidateAggregationInternal(ExprValidationContext validationContext, TableMetadataColumnAggregation optionalTableColumn)
{
var ctx = new PlugInAggregationMultiFunctionValidationContext(
_functionName,
validationContext.StreamTypeService.EventTypes, PositionalParams,
validationContext.StreamTypeService.EngineURIQualifier,
validationContext.StatementName,
validationContext, _config, optionalTableColumn, ChildNodes);
var handlerPlugin = _pluginAggregationMultiFunctionFactory.ValidateGetHandler(ctx);
_factory = new ExprPlugInAggMultiFunctionNodeFactory(this, handlerPlugin, validationContext.EngineImportService.AggregationFactoryFactory, validationContext.StatementExtensionSvcContext);
return(_factory);
}
public SupportAggMFHandler(PlugInAggregationMultiFunctionValidationContext validationContext)
{
_validationContext = validationContext;
}
public PlugInAggregationMultiFunctionHandler ValidateGetHandler(PlugInAggregationMultiFunctionValidationContext validationContext)
{
functionHandlerValidationContexts.Add(validationContext);
return(new SupportAggMFHandler(validationContext));
}
public static PlugInAggregationMultiFunctionStateFactory GetStateFactory(this SupportAggMFFunc value, PlugInAggregationMultiFunctionValidationContext validationContext)
{
if (value == SupportAggMFFunc.SCALAR)
{
if (validationContext.ParameterExpressions.Length != 1)
{
throw new ArgumentException("Function '" + validationContext.FunctionName + "' requires 1 parameter");
}
var evaluator = validationContext.ParameterExpressions[0].ExprEvaluator;
return(new SupportAggMFStatePlainScalarFactory(evaluator));
}
if (value == SupportAggMFFunc.ARR_SCALAR || value == SupportAggMFFunc.COLL_SCALAR)
{
if (validationContext.ParameterExpressions.Length != 1)
{
throw new ArgumentException("Function '" + validationContext.FunctionName + "' requires 1 parameter");
}
var evaluator = validationContext.ParameterExpressions[0].ExprEvaluator;
return(new SupportAggMFStateArrayCollScalarFactory(evaluator));
}
if (value == SupportAggMFFunc.ENUM_EVENT)
{
return(new ProxyPlugInAggregationMultiFunctionStateFactory
{
ProcMakeAggregationState = stateContext => new SupportAggMFStateEnumerableEvents()
});
}
throw new ArgumentException("Return type not supported for " + value);
}
