/// <summary>
/// Creates and starts a prepared statement.
/// <para/>
/// The statement name is optimally a unique name. If a statement of the same name
/// has already been created, the engine assigns a postfix to create a unique
/// statement name.
/// <para/>
/// Accepts an application defined user data object associated with the statement.
/// The <em>user object</em> is a single, unnamed field that is stored with every
/// statement. Applications may put arbitrary objects in this field or a null value.
/// </summary>
/// <param name="prepared">is the prepared statement for which all substitution values have been provided</param>
/// <param name="statementName">is the name to assign to the statement for use in managing the statement</param>
/// <param name="userObject">is the application-defined user object</param>
/// <returns>
/// EPStatement to poll data from or to add listeners to
/// </returns>
/// <throws>EPException when the prepared statement was not valid</throws>
public EPStatement Create(EPPreparedStatement prepared, string statementName, object userObject)
{
if (prepared == null)
{
throw new ArgumentNullException("prepared");
}
var cprepared = prepared as CatalystPreparedStatement;
if (cprepared == null)
{
throw new ArgumentException("prepared statement was of incorrect type", "prepared");
}
using (var wrapper = CreateControlManager())
{
return(WithExceptionHandling(
delegate
{
var controlManager = wrapper.Channel;
var statementArgs = new StatementCreationArgs();
statementArgs.PreparedStatementId = cprepared.Id;
statementArgs.StatementName = statementName;
statementArgs.StatementText = null;
var statement = controlManager.CreatePrepared(_instanceId, statementArgs);
var statementWrapper = new CatalystStatement(_adapter, statement, userObject);
BindStatement(statementWrapper);
return statementWrapper;
}));
}
}
/// <summary>
/// Compiles the specified statement text.
/// </summary>
/// <param name="creationArgs">The creation args.</param>
/// <returns></returns>
public EPStatementObjectModel Compile(StatementCreationArgs creationArgs)
{
var administrator = ServiceProvider.EPAdministrator;
var statementObjectModel = administrator.CompileEPL(creationArgs.StatementText);
return(statementObjectModel);
}
/// <summary>
/// Creates a statement based on the prepared statement.
/// </summary>
/// <param name="statementCreationArgs">The statement creation args.</param>
/// <returns></returns>
public StatementDescriptor CreatePrepared(StatementCreationArgs statementCreationArgs)
{
if (statementCreationArgs.PreparedStatementId == null)
{
throw new EPException("invalid statement arguments - missing prepared statement id");
}
var preparedStatement = GetPreparedStatement(statementCreationArgs.PreparedStatementId);
if (preparedStatement != null)
{
var administrator = ServiceProvider.EPAdministrator;
var statementDescriptor = new StatementDescriptor();
var statement = administrator.Create(
preparedStatement,
statementCreationArgs.StatementName,
statementDescriptor);
var publishers = _eventPublisherFactories
.Select(factory => factory.CreatePublisher(new EventPublisherArgs(ServiceProvider.EPRuntime, statement)));
if (StatementCreated != null)
{
StatementCreated(this, new StatementCreationEventArgs(this, statement));
}
statementDescriptor.Id = statement.Name;
statementDescriptor.URIs = publishers.Select(publisher => publisher.URI.ToString()).ToArray();
statementDescriptor.EventType = statement.EventType.ToXElement();
return(statementDescriptor);
}
throw new EPException("prepared statement does not exist");
}
/// <summary>
/// Creates a statement based off the pattern that is presented.
/// </summary>
/// <param name="instanceId">The instance id.</param>
/// <param name="statementCreationArgs">The statement creation args.</param>
/// <returns></returns>
public StatementDescriptor CreateEPL(string instanceId, StatementCreationArgs statementCreationArgs)
{
try {
var instance = GetInstanceOrFault(instanceId);
return(instance.CreateEPL(statementCreationArgs));
} catch (EPException e) {
Log.Warn("CreateEPL: BadRequest returned: {0}", e.Message);
throw new WebFaultException <string>(e.Message, HttpStatusCode.BadRequest);
}
}
/// <summary>
/// Compiles a statement.
/// </summary>
/// <param name="instanceId">The instance id.</param>
/// <param name="creationArgs">The creation args.</param>
/// <returns></returns>
public EPStatementObjectModel Compile(string instanceId, StatementCreationArgs creationArgs)
{
try {
var instance = GetInstanceOrFault(instanceId);
return(instance.Compile(creationArgs));
}
catch (EPException e) {
Log.Warn("Compile: BadRequest returned: {0}", e.Message);
throw new WebFaultException <string>(e.Message, HttpStatusCode.BadRequest);
}
}
/// <summary>
/// Creates a prepared statement based off the pattern that is presented. The value
/// that is returned is a unique identifier to the representation of the prepared
/// statement on the server. It is the prepared statement id.
/// </summary>
/// <param name="instanceId">The instance id.</param>
/// <param name="creationArgs">The creation args.</param>
/// <returns></returns>
public string PreparePattern(string instanceId, StatementCreationArgs creationArgs)
{
try
{
var instance = GetInstanceOrFault(instanceId);
return(instance.PreparePattern(creationArgs.StatementText));
}
catch (EPException e)
{
Log.Warn("PreparePattern: BadRequest returned: {0}", e.Message);
throw new WebFaultException <string>(e.Message, HttpStatusCode.BadRequest);
}
}
/// <summary>
/// Compiles a given EPL into an object model representation of the query.
/// </summary>
/// <param name="eplExpression">is the statement text to compile</param>
/// <returns>
/// object model of statement
/// </returns>
/// <throws>EPException indicates compilation errors.</throws>
public EPStatementObjectModel CompileEPL(string eplExpression)
{
using (var wrapper = CreateControlManager())
{
return(WithExceptionHandling(
delegate
{
var controlManager = wrapper.Channel;
var statementArgs = new StatementCreationArgs();
return controlManager.Compile(_instanceId, statementArgs);
}));
}
}
/// <summary>
/// Prepares a statement for the given pattern, which can include substitution
/// parameters marked via question mark '?'.
/// </summary>
/// <param name="patternExpression">is the statement text to prepare</param>
/// <returns>
/// prepared statement
/// </returns>
/// <throws>EPException indicates compilation errors.</throws>
public EPPreparedStatement PreparePattern(string patternExpression)
{
using (var wrapper = CreateControlManager())
{
return(WithExceptionHandling(
delegate
{
var controlManager = wrapper.Channel;
var statementArgs = new StatementCreationArgs();
statementArgs.StatementText = patternExpression;
var preparationId = controlManager.PreparePattern(_instanceId, statementArgs);
var statementWrapper = new CatalystPreparedStatement(_adapter, _instanceId, preparationId);
return statementWrapper;
}));
}
}
/// <summary>
/// Create and starts an EPL statement.
/// <para/>
/// Accepts an application defined user data object associated with the statement.
/// The <em>user object</em> is a single, unnamed field that is stored with every
/// statement. Applications may put arbitrary objects in this field or a null value.
/// </summary>
/// <param name="eplStatement">is the query language statement</param>
/// <param name="userObject">is the application-defined user object</param>
/// <returns>
/// EPStatement to poll data from or to add listeners to
/// </returns>
/// <throws>EPException when the expression was not valid</throws>
public EPStatement CreateEPL(string eplStatement, object userObject)
{
using (var wrapper = CreateControlManager())
{
return(WithExceptionHandling(
delegate
{
var controlManager = wrapper.Channel;
var statementArgs = new StatementCreationArgs();
statementArgs.StatementText = eplStatement;
var statement = controlManager.CreateEPL(_instanceId, statementArgs);
var statementWrapper = new CatalystStatement(_adapter, statement, userObject);
BindStatement(statementWrapper);
return statementWrapper;
}));
}
}
/// <summary>
/// Create and starts an event pattern statement for the expressing string passed.
/// <para/>
/// The engine assigns a unique name to the statement.
/// </summary>
/// <param name="onExpression">must follow the documented syntax for pattern statements</param>
/// <returns>
/// EPStatement to poll data from or to add listeners to
/// </returns>
/// <throws>EPException when the expression was not valid</throws>
public EPStatement CreatePattern(string onExpression)
{
using (var wrapper = CreateControlManager())
{
return(WithExceptionHandling(
delegate
{
var controlManager = wrapper.Channel;
var statementArgs = new StatementCreationArgs();
statementArgs.StatementText = onExpression;
var statement = controlManager.CreatePattern(_instanceId, statementArgs);
var statementWrapper = new CatalystStatement(_adapter, statement);
BindStatement(statementWrapper);
return statementWrapper;
}));
}
}
/// <summary>
/// Creates a statement based off the pattern that is presented.
/// </summary>
/// <param name="creationArgs">The on expression.</param>
/// <returns></returns>
public StatementDescriptor CreatePattern(StatementCreationArgs creationArgs)
{
var administrator = ServiceProvider.EPAdministrator;
var statementDescriptor = new StatementDescriptor();
var statement = administrator.CreatePattern(
creationArgs.StatementText,
creationArgs.StatementName,
statementDescriptor);
var publishers = _eventPublisherFactories
.Select(factory => factory.CreatePublisher(new EventPublisherArgs(ServiceProvider.EPRuntime, statement)));
if (StatementCreated != null)
{
StatementCreated(this, new StatementCreationEventArgs(this, statement));
}
statementDescriptor.Id = statement.Name;
statementDescriptor.URIs = publishers.Select(publisher => publisher.URI.ToString()).ToArray();
statementDescriptor.EventType = statement.EventType.ToXElement();
return(statementDescriptor);
}
/// <summary>
/// Creates a prepared statement based off the pattern that is presented. The value
/// that is returned is a unique identifier to the representation of the prepared
/// statement on the server. It is the prepared statement id.
/// </summary>
/// <param name="instanceId">The instance id.</param>
/// <param name="creationArgs">The creation args.</param>
/// <returns></returns>
public string PreparePattern(string instanceId, StatementCreationArgs creationArgs)
{
try
{
var instance = GetInstanceOrFault(instanceId);
return instance.PreparePattern(creationArgs.StatementText);
}
catch (EPException e)
{
Log.Warn("PreparePattern: BadRequest returned: {0}", e.Message);
throw new WebFaultException<string>(e.Message, HttpStatusCode.BadRequest);
}
}
/// <summary>
/// Creates a statement from a prepared statement.
/// </summary>
/// <param name="instanceId">The instance id.</param>
/// <param name="statementArgs">The statement args.</param>
/// <returns></returns>
public StatementDescriptor CreatePrepared(string instanceId, StatementCreationArgs statementArgs)
{
try
{
var instance = GetInstanceOrFault(instanceId);
return instance.CreatePrepared(statementArgs);
}
catch (EPException e)
{
Log.Warn("CreateEPL: BadRequest returned: {0}", e.Message);
throw new WebFaultException<string>(e.Message, HttpStatusCode.BadRequest);
}
}
/// <summary>
/// Compiles a statement.
/// </summary>
/// <param name="instanceId">The instance id.</param>
/// <param name="creationArgs">The creation args.</param>
/// <returns></returns>
public EPStatementObjectModel Compile(string instanceId, StatementCreationArgs creationArgs)
{
try {
var instance = GetInstanceOrFault(instanceId);
return instance.Compile(creationArgs);
}
catch (EPException e) {
Log.Warn("Compile: BadRequest returned: {0}", e.Message);
throw new WebFaultException<string>(e.Message, HttpStatusCode.BadRequest);
}
}
