/// <summary> /// Converts a LINQ expression to a select clause expression. /// </summary> /// <param name="expression">The expression.</param> /// <returns></returns> public static SelectClause LinqToSelectClause(System.Linq.Expressions.Expression expression) { if (expression == null) { return(null); } switch (expression.NodeType) { case ExpressionType.Lambda: do { var lambda = (System.Linq.Expressions.LambdaExpression)expression; using (ScopedInstance <System.Linq.Expressions.LambdaExpression> .Set(lambda)) { return(LinqToSelectClause(lambda.Body)); } } while (false); case ExpressionType.New: return(NewToSelectClause( (System.Linq.Expressions.NewExpression)expression)); } throw new ArgumentException( String.Format("Expression of type {0} is not supported", expression.NodeType), "expression"); }
/// <summary> /// Boilerplate for creating views on filter streams. Make your own if you'd like. /// </summary> /// <typeparam name="TIn">The type of the in.</typeparam> /// <typeparam name="TOut">The type of the out.</typeparam> /// <param name="esperQuery">The esper query.</param> /// <param name="viewFactory">The viewFactory.</param> /// <returns></returns> /// <exception cref="System.ArgumentException">no stream available to use for window /// or /// no stream available to use for window</exception> public static EsperQuery <TOut> FilterView <TIn, TOut>(this EsperQuery <TIn> esperQuery, Func <View> viewFactory) { var parentObjectModel = esperQuery.ObjectModel; var deriveObjectModel = parentObjectModel.ShallowCopy(); var deriveFromClause = deriveObjectModel.FromClause; using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel)) { var streams = deriveFromClause.Streams; if (streams == null) { throw new ArgumentException("no stream available to use for window"); } var filter = streams.OfType <FilterStream>().Last(); if (filter == null) { throw new ArgumentException("no stream available to use for window"); } filter.AddView(viewFactory.Invoke()); } return(new EsperQuery <TOut>(esperQuery.ServiceProvider, deriveObjectModel)); }
/// <summary> /// Handles the tasks in queue. /// </summary> private void HandleTasksInQueue() { bool isDebugEnabled = Log.IsDebugEnabled; Log.Debug( "HandleTasksInQueue: Instance {0} thread {1} starting with {2}", _id, Thread.CurrentThread.Name, _taskQueue.GetType().Name); using (ScopedInstance <IBlockingQueue <Runnable> > .Set(_taskQueue)) // introduces the queue into scope { while (_liveMode != LiveMode.STOPPED) { Runnable task; Interlocked.Increment(ref _tasksRunning); try { if (_taskQueue.Pop(500, out task)) { try { task.Invoke(); } catch (Exception e) { Log.Warn("HandleTasksInQueue: Instance {0} finished with abnormal termination", _id, e); TaskError?.Invoke(this, new ThreadExceptionEventArgs(e)); } finally { Interlocked.Increment(ref _numExecuted); } } else if (_liveMode == LiveMode.STOPPING) { if (isDebugEnabled) { Log.Debug( "HandleTasksInQueue: Instance {0} no items detected in queue, terminating", _id); } break; } else if (isDebugEnabled) { Log.Debug( "HandleTasksInQueue: Instance {0} no items detected in queue, start loop again", _id); } } finally { Interlocked.Decrement(ref _tasksRunning); } } } Log.Debug("HandleTasksInQueue: Instance {0} thread ending", _id); }
/// <summary> /// Converts a lambda expression to a soda expression. /// </summary> /// <param name="expression">The expression.</param> /// <returns></returns> private static Expression LambdaToSoda(System.Linq.Expressions.Expression expression) { var lambda = (System.Linq.Expressions.LambdaExpression)expression; using (ScopedInstance <System.Linq.Expressions.LambdaExpression> .Set(lambda)) { return(LinqToSodaExpression(lambda.Body)); } }
/// <summary> /// Imports a collection of schemas. /// </summary> /// <param name="schemaSet">The schema set.</param> public void ImportSchemas(XmlSchemaSet schemaSet) { using (ScopedInstance <XmlSchemaSet> .Set(schemaSet)) { foreach (XmlSchema schema in schemaSet.Schemas()) { ImportSchema(schema); } } }
/// <summary> /// Add a property / column to the query. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="esperQuery">The esper query.</param> /// <param name="property">The property.</param> /// <returns></returns> public static EsperQuery <T> AddProperty <T>(this EsperQuery <T> esperQuery, String property) { var parentObjectModel = esperQuery.ObjectModel; var deriveObjectModel = parentObjectModel.ShallowCopy(); using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel)) { deriveObjectModel.SelectClause.Add(property); return(new EsperQuery <T>(esperQuery.ServiceProvider, deriveObjectModel)); } }
/// <summary> /// Groups the results of the expression. /// </summary> /// <typeparam name="TSource">The type of the source.</typeparam> /// <typeparam name="TKey">The type of the key.</typeparam> /// <param name="esperQuery">The esper query.</param> /// <param name="keySelectionExpression">The key selection expression.</param> /// <returns></returns> public static EsperQuery <TSource> GroupBy <TSource, TKey>(this EsperQuery <TSource> esperQuery, Expression <Func <TSource, TKey> > keySelectionExpression) { var parentObjectModel = esperQuery.ObjectModel; var deriveObjectModel = parentObjectModel.ShallowCopy(); // Adapt or set the where clause according to the expression contents using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel)) { var sodaExpression = LinqToSoda.LinqToSodaExpression(keySelectionExpression); deriveObjectModel.GroupByClause = GroupByClause.Create(sodaExpression); return(new EsperQuery <TSource>(esperQuery.ServiceProvider, deriveObjectModel)); } }
/// <summary> /// Adds the property. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="esperQuery">The esper query.</param> /// <param name="propertyName">Name of the property.</param> /// <param name="expression">The expression.</param> /// <returns></returns> public static EsperQuery <T> AddProperty <T>(this EsperQuery <T> esperQuery, String propertyName, System.Linq.Expressions.Expression <Func <object> > expression) { var parentObjectModel = esperQuery.ObjectModel; var deriveObjectModel = parentObjectModel.ShallowCopy(); using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel)) { deriveObjectModel.SelectClause.Add( LinqToSoda.LinqToSodaExpression(expression), propertyName); return(new EsperQuery <T>(esperQuery.ServiceProvider, deriveObjectModel)); } }
/// <summary> /// Gets the native element representation of the named element. /// </summary> /// <param name="schemaSet">The schema set.</param> /// <param name="elementName">Name of the element.</param> /// <returns></returns> public Element GetNativeElement(XmlSchemaSet schemaSet, XmlQualifiedName elementName) { using (ScopedInstance <XmlSchemaSet> .Set(schemaSet)) { if ((elementName == null) || (elementName == XmlQualifiedName.Empty)) { throw new ArgumentException("invalid root element", "elementName"); } var rootElementNamespace = elementName.Namespace; var rootElementSchema = schemaSet.Schemas(rootElementNamespace).OfType <XmlSchema>().FirstOrDefault(); return(GetNativeElement(rootElementSchema, elementName)); } }
public void Run() { using (ScopedInstance <BoundBlockingQueueOverride> .Set(BoundBlockingQueueOverride.Default)) { try { _epRuntime.ProcessStatementFilterSingle(_handleCallback.AgentInstanceHandle, _handleCallback, _event, _filterVersion); _epRuntime.Dispatch(); _epRuntime.ProcessThreadWorkQueue(); } catch (Exception e) { Log.Error("Unexpected error processing route execution: " + e.Message, e); } } }
/// <summary> /// Constrains the specified esper query. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="esperQuery">The esper query.</param> /// <param name="expression">The expression.</param> /// <returns></returns> public static EsperQuery <T> Having <T>(this EsperQuery <T> esperQuery, System.Linq.Expressions.Expression <Func <T, bool> > expression) { var parentObjectModel = esperQuery.ObjectModel; var deriveObjectModel = parentObjectModel.ShallowCopy(); // Adapt or set the where clause according to the expression contents using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel)) { var sodaExpression = LinqToSoda.LinqToSodaExpression(expression); deriveObjectModel.HavingClause = deriveObjectModel.HavingClause == null ? sodaExpression : Expressions.And(deriveObjectModel.WhereClause, sodaExpression); deriveObjectModel.FromClause.Streams[0].StreamName = expression.Parameters[0].Name; return(new EsperQuery <T>(esperQuery.ServiceProvider, deriveObjectModel)); } }
/// <summary> /// Joins the specified outer. /// </summary> /// <typeparam name="TOuter">The type of the outer.</typeparam> /// <typeparam name="TInner">The type of the inner.</typeparam> /// <typeparam name="TKey">The type of the key.</typeparam> /// <typeparam name="TResult">The type of the result.</typeparam> /// <param name="outer">The outer.</param> /// <param name="inner">The inner.</param> /// <param name="outerKeySelector">The outer key selector.</param> /// <param name="innerKeySelector">The inner key selector.</param> /// <param name="resultSelector">The result selector.</param> /// <returns></returns> public static EsperQuery <TResult> Join <TOuter, TInner, TKey, TResult>( this EsperQuery <TOuter> outer, EsperQuery <TInner> inner, Expression <Func <TOuter, TKey> > outerKeySelector, Expression <Func <TInner, TKey> > innerKeySelector, Expression <Func <TOuter, TInner, TResult> > resultSelector) { var parentObjectModel = outer.ObjectModel; var deriveObjectModel = new EPStatementObjectModel(); using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel)) { deriveObjectModel.Annotations = parentObjectModel.Annotations; var innerKey = LinqToSoda.LinqToSodaExpression(innerKeySelector); var outerKey = LinqToSoda.LinqToSodaExpression(outerKeySelector); deriveObjectModel.FromClause = new FromClause( outer.ObjectModel.FromClause.Streams.Concat( inner.ObjectModel.FromClause.Streams) .ToArray()); var parametersArray = resultSelector.Parameters.ToArray(); for (var ii = 0; ii < parametersArray.Length; ii++) { deriveObjectModel.FromClause.Streams[ii].StreamName = parametersArray[ii].Name; } deriveObjectModel.FromClause.OuterJoinQualifiers = new List <OuterJoinQualifier>(); deriveObjectModel.FromClause.OuterJoinQualifiers.Add( new OuterJoinQualifier( OuterJoinType.LEFT, outerKey, innerKey, new PropertyValueExpressionPair[0])); deriveObjectModel.SelectClause = LinqToSoda.LinqToSelectClause(resultSelector); var toEPL = deriveObjectModel.ToEPL(); return(new EsperQuery <TResult>(outer.ServiceProvider, deriveObjectModel)); } }
/// <summary> /// Creates a window. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="serviceProvider">The service provider.</param> /// <param name="windowName">Name of the window.</param> /// <param name="view">The view.</param> /// <param name="esperQuery">The esper query.</param> /// <param name="insertWhereExpression">The insert where expression.</param> /// <returns></returns> public static EPStatementObjectModel CreateWindowAsObjectModel <T>( this EPServiceProvider serviceProvider, string windowName, View view, EsperQuery <T> esperQuery, System.Linq.Expressions.Expression <Func <T, bool> > insertWhereExpression) { var deriveObjectModel = DeriveObjectModel(esperQuery); using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel)) { deriveObjectModel.CreateWindow = CreateWindowClause.Create(windowName, view); deriveObjectModel.CreateWindow.IsInsert = false; if (insertWhereExpression != null) { deriveObjectModel.CreateWindow.InsertWhereClause = LinqToSoda.LinqToSodaExpression(insertWhereExpression); deriveObjectModel.CreateWindow.IsInsert = true; } return(deriveObjectModel); } }
/// <summary> /// Creates the delete trigger. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="serviceProvider">The service provider.</param> /// <param name="windowName">Name of the window.</param> /// <param name="asName">As name.</param> /// <param name="fromClause">From clause.</param> /// <param name="deferredWhereClause">The deferred where clause.</param> /// <returns></returns> public static EPStatement CreateDeleteTrigger <T>(EPServiceProvider serviceProvider, string windowName, string asName, EsperQuery <T> fromClause, Func <Expression> deferredWhereClause) { var deriveObjectModel = DeriveObjectModel(fromClause); using (ScopedInstance <EPStatementObjectModel> .Set(deriveObjectModel)) { deriveObjectModel.OnExpr = OnClause.CreateOnDelete(windowName, asName); if (deferredWhereClause != null) { var whereClause = deferredWhereClause.Invoke(); if (whereClause != null) { deriveObjectModel.WhereClause = whereClause; } } return(serviceProvider.EPAdministrator.Create(deriveObjectModel)); } }