private static void Configure(Configuration configuration)
{
foreach (var clazz in new[] {
typeof(SupportBean),
typeof(SupportBeanString),
typeof(SupportMarketDataBean),
typeof(SupportBeanNumeric),
typeof(SupportBean_S0),
typeof(SupportBean_S1),
typeof(SupportBean_A),
typeof(SupportBean_B),
typeof(SupportEventPropertyWithMethod),
typeof(SupportEventPropertyWithMethod),
typeof(SupportEventWithManyArray)
}) {
configuration.Common.AddEventType(clazz);
}
configuration.Common.AddImportType(typeof(SupportStaticMethodLib));
configuration.Common.AddImportType(typeof(HashableMultiKey));
configuration.Compiler.ByteCode.IncludeDebugSymbols = true;
configuration.Compiler.AddPlugInAggregationFunctionForge(
"concatMethodAgg",
typeof(SupportConcatWManagedAggregationFunctionForge));
var eventsAsList = new ConfigurationCompilerPlugInAggregationMultiFunction(
new[] {"eventsAsList"},
typeof(SupportAggMFEventsAsListForge));
configuration.Compiler.AddPlugInAggregationMultiFunction(eventsAsList);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="functionName">provides the aggregation multi-function name</param>
/// <param name="distinct">flag whether the "distinct" keyword was provided.</param>
/// <param name="configuration">the configuration provided when the aggregation multi-functions where registered</param>
public AggregationMultiFunctionDeclarationContext(
string functionName,
bool distinct,
ConfigurationCompilerPlugInAggregationMultiFunction configuration)
{
this._functionName = functionName;
this._distinct = distinct;
this._configuration = configuration;
}
private static void Configure(Configuration configuration)
{
foreach (var clazz in new[] {
typeof(SupportBean),
typeof(SupportBean_S0),
typeof(SupportBean_S1),
typeof(SupportIntrusionEvent),
typeof(SupportTrafficEvent),
typeof(SupportMySortValueEvent),
typeof(SupportBean_S2),
typeof(SupportBeanSimple),
typeof(SupportByteArrEventStringId),
typeof(SupportBeanRange),
typeof(SupportTwoKeyEvent),
typeof(SupportCtorSB2WithObjectArray),
typeof(Support10ColEvent),
typeof(SupportTopGroupSubGroupEvent),
typeof(SupportBeanNumeric),
typeof(SupportEventWithManyArray),
typeof(SupportEventWithManyArray),
typeof(SupportEventWithIntArray)
}) {
configuration.Common.AddEventType(clazz);
}
configuration.Compiler.AddPlugInSingleRowFunction(
"singlerow",
typeof(InfraTableInvalid),
"MySingleRowFunction");
configuration.Compiler.AddPlugInSingleRowFunction(
"pluginServiceEventBean",
typeof(InfraTableSelect),
"MyServiceEventBean");
configuration.Compiler.AddPlugInSingleRowFunction(
"toIntArray",
typeof(InfraTableOnUpdate),
"ToIntArray");
configuration.Compiler.AddPlugInAggregationFunctionForge(
"myaggsingle",
typeof(SupportCountBackAggregationFunctionForge));
configuration.Compiler.AddPlugInAggregationFunctionForge("csvWords", typeof(SupportSimpleWordCSVForge));
var config = new ConfigurationCompilerPlugInAggregationMultiFunction(
new[] {"referenceCountedMap"},
typeof(SupportReferenceCountedMapForge));
configuration.Compiler.AddPlugInAggregationMultiFunction(config);
var configMultiFuncAgg = new ConfigurationCompilerPlugInAggregationMultiFunction(
new[] {"se1"},
typeof(SupportAggMFMultiRTForge));
configuration.Compiler.AddPlugInAggregationMultiFunction(configMultiFuncAgg);
configuration.Common.Logging.IsEnableQueryPlan = true;
configuration.Common.AddImportType(typeof(SupportStaticMethodLib));
configuration.Compiler.ByteCode.AllowSubscriber = true;
}
public ExprPlugInMultiFunctionAggNode(
bool distinct,
ConfigurationCompilerPlugInAggregationMultiFunction config,
AggregationMultiFunctionForge aggregationMultiFunctionForge,
string functionName)
: base(distinct)
{
this.aggregationMultiFunctionForge = aggregationMultiFunctionForge;
this.functionName = functionName;
this.config = config;
}
public void AddAggregationMultiFunction(ConfigurationCompilerPlugInAggregationMultiFunction desc)
{
var orderedImmutableFunctionNames = new LinkedHashSet <string>();
foreach (var functionName in desc.FunctionNames)
{
orderedImmutableFunctionNames.Add(functionName.ToLowerInvariant());
ValidateFunctionName("aggregation multi-function", functionName.ToLowerInvariant());
}
if (!IsClassName(desc.MultiFunctionForgeClassName))
{
throw new ImportException("Invalid class name for aggregation multi-function factory '" + desc.MultiFunctionForgeClassName + "'");
}
_aggregationAccess.Add(new Pair <ISet <string>, ConfigurationCompilerPlugInAggregationMultiFunction>(orderedImmutableFunctionNames, desc));
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="functionName">function name</param>
/// <param name="eventTypes">event types</param>
/// <param name="parameterExpressions">expressions</param>
/// <param name="statementName">statement name</param>
/// <param name="validationContext">validation context</param>
/// <param name="config">configuration</param>
/// <param name="allParameterExpressions">all parameters</param>
/// <param name="optionalFilterExpression">optional filter parameter</param>
public AggregationMultiFunctionValidationContext(
string functionName,
EventType[] eventTypes,
ExprNode[] parameterExpressions,
string statementName,
ExprValidationContext validationContext,
ConfigurationCompilerPlugInAggregationMultiFunction config,
ExprNode[] allParameterExpressions,
ExprNode optionalFilterExpression)
{
FunctionName = functionName;
EventTypes = eventTypes;
ParameterExpressions = parameterExpressions;
StatementName = statementName;
ValidationContext = validationContext;
Config = config;
AllParameterExpressions = allParameterExpressions;
OptionalFilterExpression = optionalFilterExpression;
}
public void TestClientCompileInvalidConfigAggMultiFunc()
{
Consumer<Configuration> configurer;
configurer = config => {
config.Compiler.AddPlugInAggregationFunctionForge(
"abc",
typeof(SupportConcatWCodegenAggregationFunctionForge));
var func = new ConfigurationCompilerPlugInAggregationMultiFunction(
new [] { "abc" },
typeof(SupportAggMFMultiRTForge));
config.Compiler.AddPlugInAggregationMultiFunction(func);
};
TryInvalidConfigurationCompiler(
SupportConfigFactory.GetConfiguration(),
configurer,
"Failed compiler startup: Error configuring compiler: Aggregation function by name 'abc' is already defined");
configurer = config => {
var funcOne = new ConfigurationCompilerPlugInAggregationMultiFunction(
new [] { "abc","def" },
typeof(SupportAggMFMultiRTForge));
config.Compiler.AddPlugInAggregationMultiFunction(funcOne);
var funcTwo = new ConfigurationCompilerPlugInAggregationMultiFunction(
new [] { "def","xyz" },
typeof(SupportAggMFMultiRTForge));
config.Compiler.AddPlugInAggregationMultiFunction(funcTwo);
};
TryInvalidConfigurationCompiler(
SupportConfigFactory.GetConfiguration(),
configurer,
"Failed compiler startup: Error configuring compiler: Aggregation multi-function by name 'def' is already defined");
configurer = config => {
var configTwo =
new ConfigurationCompilerPlugInAggregationMultiFunction(new [] { "thefunction2" }, "x y z");
config.Compiler.AddPlugInAggregationMultiFunction(configTwo);
};
TryInvalidConfigurationCompiler(
SupportConfigFactory.GetConfiguration(),
configurer,
"Failed compiler startup: Error configuring compiler: Invalid class name for aggregation multi-function factory 'x y z'");
}
public Pair <ConfigurationCompilerPlugInAggregationMultiFunction, Type> ResolveAggregationMultiFunction(
string name,
ExtensionAggregationMultiFunction extension)
{
foreach (var config in _aggregationAccess)
{
if (config.First.Contains(name.ToLowerInvariant()))
{
return(new Pair <ConfigurationCompilerPlugInAggregationMultiFunction, Type>(config.Second, null));
}
}
var inlined = extension.ResolveAggregationMultiFunction(name);
if (inlined != null)
{
var config = new ConfigurationCompilerPlugInAggregationMultiFunction(inlined.Second, inlined.First.Name);
return(new Pair <ConfigurationCompilerPlugInAggregationMultiFunction, Type>(config, inlined.First));
}
return(null);
}
public static ExprNode TryResolveAsAggregation(
ImportServiceCompileTime importService,
bool distinct,
string functionName,
LazyAllocatedMap<ConfigurationCompilerPlugInAggregationMultiFunction, AggregationMultiFunctionForge>
plugInAggregations)
{
try {
AggregationFunctionForge aggregationFactory = importService.ResolveAggregationFunction(functionName);
return new ExprPlugInAggNode(distinct, aggregationFactory, functionName);
}
catch (ImportUndefinedException) {
// Not an aggregation function
}
catch (ImportException e) {
throw new ValidationException("Error resolving aggregation: " + e.Message, e);
}
// try plug-in aggregation multi-function
ConfigurationCompilerPlugInAggregationMultiFunction config =
importService.ResolveAggregationMultiFunction(functionName);
if (config != null) {
AggregationMultiFunctionForge factory = plugInAggregations.Map.Get(config);
if (factory == null) {
factory = (AggregationMultiFunctionForge) TypeHelper.Instantiate<AggregationMultiFunctionForge>(
config.MultiFunctionForgeClassName,
importService.ClassForNameProvider);
plugInAggregations.Map.Put(config, factory);
}
factory.AddAggregationFunction(
new AggregationMultiFunctionDeclarationContext(functionName.ToLowerInvariant(), distinct, config));
return new ExprPlugInMultiFunctionAggNode(distinct, config, factory, functionName);
}
// try built-in expanded set of aggregation functions
return importService.ResolveAggExtendedBuiltin(functionName, distinct);
}
private static void Configure(Configuration configuration)
{
foreach (var clazz in new[] {
typeof(SupportBean),
typeof(SupportBean_S0),
typeof(SupportBean_S1),
typeof(SupportMarketDataBean),
typeof(SupportCarEvent),
typeof(SupportCarInfoEvent),
typeof(SupportEventABCProp),
typeof(SupportBeanString),
typeof(SupportPriceEvent),
typeof(SupportMarketDataIDBean),
typeof(SupportBean_A),
typeof(SupportBean_B),
typeof(SupportEventWithIntArray),
typeof(SupportThreeArrayEvent)
}) {
configuration.Common.AddEventType(clazz);
}
configuration.Compiler.AddPlugInSingleRowFunction(
"myfunc",
typeof(ResultSetQueryTypeRollupGroupingFuncs.GroupingSupportFunc),
"Myfunc");
configuration.Compiler.AddPlugInAggregationFunctionForge(
"concatstring",
typeof(SupportConcatWManagedAggregationFunctionForge));
var mfAggConfig = new ConfigurationCompilerPlugInAggregationMultiFunction(
new[] {"sc"},
typeof(SupportAggMFMultiRTForge));
configuration.Compiler.AddPlugInAggregationMultiFunction(mfAggConfig);
configuration.Common.AddVariable("MyVar", typeof(string), "");
}
private static void Configure(Configuration configuration)
{
foreach (var clazz in new[] {
typeof(SupportBean),
typeof(SupportBean_A),
typeof(SupportBean_S0),
typeof(SupportMarketDataBean),
typeof(SupportSimpleBeanOne),
typeof(SupportBean_ST0),
typeof(SupportBeanRange),
typeof(SupportDateTime),
typeof(SupportCollection),
typeof(SupportBean_ST0_Container)
}) {
configuration.Common.AddEventType(clazz.Name, clazz);
}
IDictionary<string, object> mapType = new Dictionary<string, object>();
mapType.Put("col1", "string");
mapType.Put("col2", "string");
mapType.Put("col3", "int");
configuration.Common.AddEventType("MapType", mapType);
var configurationCompiler = configuration.Compiler;
configurationCompiler.AddPlugInSingleRowFunction(
"singlerow",
typeof(SupportSingleRowFunctionTwo),
"TestSingleRow");
configurationCompiler.AddPlugInSingleRowFunction(
"power3",
typeof(SupportSingleRowFunction),
"ComputePower3");
configurationCompiler.AddPlugInSingleRowFunction(
"chainTop",
typeof(SupportSingleRowFunction),
"GetChainTop");
configurationCompiler.AddPlugInSingleRowFunction(
"throwExceptionLogMe",
typeof(SupportSingleRowFunction),
"Throwexception",
ConfigurationCompilerPlugInSingleRowFunction.ValueCacheEnum.DISABLED,
ConfigurationCompilerPlugInSingleRowFunction.FilterOptimizableEnum.ENABLED,
false);
configurationCompiler.AddPlugInSingleRowFunction(
"throwExceptionRethrow",
typeof(SupportSingleRowFunction),
"Throwexception",
ConfigurationCompilerPlugInSingleRowFunction.ValueCacheEnum.DISABLED,
ConfigurationCompilerPlugInSingleRowFunction.FilterOptimizableEnum.ENABLED,
true);
configurationCompiler.AddPlugInSingleRowFunction(
"power3Rethrow",
typeof(SupportSingleRowFunction),
"ComputePower3",
ConfigurationCompilerPlugInSingleRowFunction.ValueCacheEnum.DISABLED,
ConfigurationCompilerPlugInSingleRowFunction.FilterOptimizableEnum.ENABLED,
true);
configurationCompiler.AddPlugInSingleRowFunction(
"power3Context",
typeof(SupportSingleRowFunction),
"ComputePower3WithContext",
ConfigurationCompilerPlugInSingleRowFunction.ValueCacheEnum.DISABLED,
ConfigurationCompilerPlugInSingleRowFunction.FilterOptimizableEnum.ENABLED,
true);
foreach (var method in Collections.List(
"Surroundx",
"IsNullValue",
"GetValueAsString",
"EventsCheckStrings",
"VarargsOnlyInt",
"VarargsOnlyString",
"VarargsOnlyObject",
"VarargsOnlyNumber",
"VarargsOnlyISupportBaseAB",
"VarargsW1Param",
"VarargsW2Param",
"VarargsOnlyWCtx",
"VarargsW1ParamWCtx",
"VarargsW2ParamWCtx",
"VarargsObjectsWCtx",
"VarargsW1ParamObjectsWCtx",
"VarargsOnlyBoxedFloat",
"VarargsOnlyBoxedShort",
"VarargsOnlyBoxedByte",
"VarargOverload")
) {
configurationCompiler.AddPlugInSingleRowFunction(method, typeof(SupportSingleRowFunction), method);
}
configurationCompiler.AddPlugInSingleRowFunction("extractNum", typeof(ClientExtendEnumMethod), "ExtractNum");
AddEventTypeUDF(
"MyItemProducerEventBeanArray",
"MyItem",
"MyItemProducerEventBeanArray",
configuration);
AddEventTypeUDF(
"MyItemProducerEventBeanCollection",
"MyItem",
"MyItemProducerEventBeanCollection",
configuration);
AddEventTypeUDF(
"MyItemProducerInvalidNoType",
null,
"MyItemProducerEventBeanArray",
configuration);
AddEventTypeUDF(
"MyItemProducerInvalidWrongType",
"dummy",
"MyItemProducerEventBeanArray",
configuration);
configurationCompiler.AddPlugInAggregationFunctionForge(
"concatstring",
typeof(SupportConcatWManagedAggregationFunctionForge));
configurationCompiler.AddPlugInAggregationFunctionForge(
"myagg",
typeof(SupportSupportBeanAggregationFunctionForge));
configurationCompiler.AddPlugInAggregationFunctionForge(
"countback",
typeof(SupportCountBackAggregationFunctionForge));
configurationCompiler.AddPlugInAggregationFunctionForge(
"countboundary",
typeof(SupportLowerUpperCompareAggregationFunctionForge));
configurationCompiler.AddPlugInAggregationFunctionForge(
"concatWCodegen",
typeof(SupportConcatWCodegenAggregationFunctionForge));
configurationCompiler.AddPlugInAggregationFunctionForge("invalidAggFuncForge", typeof(TimeSpan));
configurationCompiler.AddPlugInAggregationFunctionForge("nonExistAggFuncForge", "com.NoSuchClass");
var configGeneral = new ConfigurationCompilerPlugInAggregationMultiFunction(
new[] {"ss", "sa", "sc", "se1", "se2", "ee"},
typeof(SupportAggMFMultiRTForge));
configGeneral.AdditionalConfiguredProperties = Collections.SingletonDataMap("someinfokey", "someinfovalue");
configurationCompiler.AddPlugInAggregationMultiFunction(configGeneral);
var codegenTestAccum = new ConfigurationCompilerPlugInAggregationMultiFunction(
new[] {"collectEvents"},
typeof(SupportAggMFEventsAsListForge));
configurationCompiler.AddPlugInAggregationMultiFunction(codegenTestAccum);
// For use with the inlined-class example when disabled, comment-in when needed:
// ConfigurationCompilerPlugInAggregationMultiFunction codegenTestTrie = new ConfigurationCompilerPlugInAggregationMultiFunction("".Split(","), ClientExtendAggregationMultiFunctionInlinedClass.TrieAggForge.class.getName());
// configurationCompiler.addPlugInAggregationMultiFunction(codegenTestTrie);
configuration.Compiler.AddPlugInView("mynamespace", "flushedsimple", typeof(MyFlushedSimpleViewForge));
configuration.Compiler.AddPlugInView("mynamespace", "invalid", typeof(string));
configuration.Compiler.AddPlugInView("mynamespace", "trendspotter", typeof(MyTrendSpotterViewForge));
configurationCompiler.AddPlugInVirtualDataWindow("test", "vdwnoparam", typeof(SupportVirtualDWForge));
configurationCompiler.AddPlugInVirtualDataWindow(
"test",
"vdwwithparam",
typeof(SupportVirtualDWForge),
SupportVirtualDW.ITERATE); // configure with iteration
configurationCompiler.AddPlugInVirtualDataWindow("test", "vdw", typeof(SupportVirtualDWForge));
configurationCompiler.AddPlugInVirtualDataWindow("invalid", "invalid", typeof(SupportBean));
configurationCompiler.AddPlugInVirtualDataWindow(
"test",
"testnoindex",
typeof(SupportVirtualDWInvalidForge));
configurationCompiler.AddPlugInVirtualDataWindow(
"test",
"exceptionvdw",
typeof(SupportVirtualDWExceptionForge));
configurationCompiler.AddPlugInPatternGuard(
"myplugin",
"count_to",
typeof(MyCountToPatternGuardForge));
configurationCompiler.AddPlugInPatternGuard("namespace", "name", typeof(string));
configurationCompiler.AddPlugInDateTimeMethod("roll", typeof(ClientExtendDateTimeMethod.MyLocalDTMForgeFactoryRoll));
configurationCompiler.AddPlugInDateTimeMethod("asArrayOfString", typeof(ClientExtendDateTimeMethod.MyLocalDTMForgeFactoryArrayOfString));
configurationCompiler.AddPlugInDateTimeMethod(
"dtmInvalidMethodNotExists",
typeof(ClientExtendDateTimeMethod.MyLocalDTMForgeFactoryInvalidMethodNotExists));
configurationCompiler.AddPlugInDateTimeMethod("dtmInvalidNotProvided", typeof(ClientExtendDateTimeMethod.MyLocalDTMForgeFactoryInvalidNotProvided));
configurationCompiler.AddPlugInDateTimeMethod("someDTMInvalidReformat", typeof(ClientExtendDateTimeMethod.MyLocalDTMForgeFactoryInvalidReformat));
configurationCompiler.AddPlugInDateTimeMethod("someDTMInvalidNoOp", typeof(ClientExtendDateTimeMethod.MyLocalDTMForgeFactoryInvalidNoOp));
configurationCompiler.AddPlugInEnumMethod("enumPlugInMedian", typeof(ClientExtendEnumMethod.MyLocalEnumMethodForgeMedian));
configurationCompiler.AddPlugInEnumMethod("enumPlugInOne", typeof(ClientExtendEnumMethod.MyLocalEnumMethodForgeOne));
configurationCompiler.AddPlugInEnumMethod("enumPlugInEarlyExit", typeof(ClientExtendEnumMethod.MyLocalEnumMethodForgeEarlyExit));
configurationCompiler.AddPlugInEnumMethod("enumPlugInReturnEvents", typeof(ClientExtendEnumMethod.MyLocalEnumMethodForgePredicateReturnEvents));
configurationCompiler.AddPlugInEnumMethod(
"enumPlugInReturnSingleEvent",
typeof(ClientExtendEnumMethod.MyLocalEnumMethodForgePredicateReturnSingleEvent));
configurationCompiler.AddPlugInEnumMethod("enumPlugInTwoLambda", typeof(ClientExtendEnumMethod.MyLocalEnumMethodForgeTwoLambda));
configurationCompiler.AddPlugInEnumMethod("enumPlugInLambdaEventWPredicateAndIndex", typeof(ClientExtendEnumMethod.MyLocalEnumMethodForgeThree));
configurationCompiler.AddPlugInEnumMethod("enumPlugInLambdaScalarWPredicateAndIndex", typeof(ClientExtendEnumMethod.MyLocalEnumMethodForgeThree));
configurationCompiler.AddPlugInEnumMethod("enumPlugInLambdaScalarWStateAndValue", typeof(ClientExtendEnumMethod.MyLocalEnumMethodForgeStateWValue));
configuration.Common.AddImportType(typeof(ClientExtendSingleRowFunction));
configuration.Common.AddImportType(typeof(BigInteger));
configuration.Runtime.Threading.IsRuntimeFairlock = true;
configuration.Common.Logging.IsEnableQueryPlan = true;
}
