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; }