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