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