All Classes and Interfaces
Class
Description
An abstract implementation of a hash-based map which provides numerous points for
subclasses to override.
EntrySet implementation.
EntrySet iterator.
HashEntry used to store the data.
Base Iterator
MapIterator implementation.
KeySet implementation.
KeySet iterator.
Values implementation.
Values iterator.
Abstract pair class to assist with creating
KeyValue
and Map.Entry implementations.Abstract Pair class to assist with creating correct
Map.Entry implementations.An abstract implementation of a hash-based map that allows the entries to
be removed by the garbage collector.
A MapEntry implementation for the map.
Accessor style defines the methods of a class that are automatically exposed via event property.
Represents the base expression for "first", "last" and "window" aggregation functions.
This view simply adds a property to the events posted to it.
Context-partition local script context.
Executes a sequence of translators one after the other.
Represents the aggregation accessor that provides the result for the "first" and "last" aggregation function with index.
Represents the aggregation accessor that provides the result for the "first" and "last" aggregation function with index.
Represents the aggregation accessor that provides the result for the "first" aggregation function without index.
Represents the aggregation accessor that provides the result for the "first" aggregation function without index.
Represents the aggregation accessor that provides the result for the "last" aggregation function without index.
Represents the aggregation accessor that provides the result for the "last" aggregation function without index.
Enum for aggregation multi-function state type.
Represents the aggregation accessor that provides the result for the "maxBy" aggregation function.
Represents the aggregation accessor that provides the result for the "maxBy" aggregation function.
Represents the aggregation accessor that provides the result for the "maxBy" aggregation function.
For handling access aggregation functions "first, last, window" a pair of slow and accessorForge.
Represents the aggregation accessor that provides the result for the "maxBy" aggregation function.
Represents the aggregation accessor that provides the result for the "maxBy" aggregation function.
Represents the aggregation accessor that provides the result for the "window" aggregation function.
Represents the aggregation accessor that provides the result for the "window" aggregation function.
Represents the aggregation accessor that provides the result for the "window" aggregation function.
Represents the aggregation accessor that provides the result for the "window" aggregation function.
Factory for aggregation methods.
Maintains aggregation state applying values as entering and leaving the state.
Interface to implement for factories of aggregation functions.
Context for use with plug-in custom aggregation functions that implement
AggregationFunctionFactory.Compile-time representation of a plug-in aggregation function.
Describes to the compiler how it should manage code for the aggregation function.
Use this class to provide a fully code-generated aggregation function by implementing the internal
AggregatorMethodFactory interface.Use this class to provide an aggregation function wherein there is no need to write code that generates code,
wherein the aggregation function takes a single parameter and
wherein the compiler handles filtering and distinct.
Use this class to provide an aggregation function wherein there is no need to write code that generates code,
wherein the aggregation function takes a multiple parameters and
wherein the compiler does not handle filtering and distinct.
Context for use with plug-in custom aggregation functions that implement
AggregationFunctionForge.- Each local-group-by gets its own access state factory, shared between same-local-group-by for compatible states
Accessor for access aggregation functions.
Factory for aggregation multi-function accessors.
Context for use with plug-in aggregation multi-functions that implement
AggregationMultiFunctionAccessorFactory.Describes to the compiler how it should manage code for aggregation multi-function accessors.
Use this class to provide an accessor wherein there is no need to write code that generates code,
Agents change mult-function aggregation state.
Factory for aggregation multi-function agents
Context for use with plug-in aggregation multi-functions that implement
AggregationMultiFunctionAgentFactory.Describes to the compiler how it should manage code for aggregation multi-function agents.
Use this class to provide an agent wherein there is no need to write code that generates code,
Aggregation method that operates on aggregation multi-function state such as provided by a multi-function aggregation (standalone or table column).
Context for use with plug-in aggregation multi-functions aggregation methods.
Factory for aggregation multi-function aggregation method
Context for use with plug-in aggregation multi-function that implement
AggregationMultiFunctionAggregationMethodFactory.Describes to the compiler how it should manage code for aggregation multi-function aggregation method.
Use this class to provide a aggregation method wherein there is no need to write code that generates code,
Context for use with
AggregationMultiFunctionForge provides
information about an aggregation function at the time of declaration.Entry point for the extension API for aggregation multi-functions.
Part of the aggregation multi-function extension API, this class represents
one of more aggregation function expression instances.
Aggregation multi-function return-type descriptor
Base interface for providing access-aggregations, i.e.
Factory for aggregation multi-function state
Context for use with plug-in aggregation multi-function that implement
AggregationMultiFunctionStateFactory.Marker interface for use with multi-function aggregation to indicate whether aggregation functions share state
Describes to the compiler how it should manage code for aggregation multi-function state factory.
Use this class to provide an state factory wherein there is no need to write code that generates code,
Context for use with
AggregationFunctionForge provides
information about an aggregation function at the time of validation.Interface for use by aggregate expression nodes representing aggregate functions such as 'sum' or 'avg' to use
to obtain the current value for the function at time of expression evaluation.
Service for maintaining aggregation state.
Factory for aggregation service instances.
Factory for aggregation service instances.
Aggregation service for use when only first/last/window aggregation functions are used an none other.
Implementation for handling aggregation with grouping by group-keys.
Aggregation result future for use with match recognize.
A null object implementation of the AggregationService
interface.
A null object implementation of the AggregationService
interface.
Implementation of access function for single-stream (not joins).
Implementation of access function for joins.
Implementation of access function for single-stream (not joins).
Implementation of access function for single-stream (not joins).
Average that generates double-typed numbers.
Average that generates double-typed numbers.
Aggregator for the very first value.
Aggregator for the very last value.
Min/max aggregator for all values.
Min/max aggregator for all values, not considering events leaving the aggregation (i.e.
Aggregation computing an event arrival rate for data windowed-events.
Aggregation computing an event arrival rate for with and without data window.
Standard deviation always generates double-typed numbers.
Sum for BigInteger values.
Implementation for handling aggregation without any grouping (no group-by).
Implementation for handling aggregation with grouping by group-keys.
Implementation for handling aggregation with grouping by group-keys.
Implementation for handling aggregation with grouping by group-keys.
Implementation for handling aggregation with grouping by group-keys.
Implementation for handling aggregation with grouping by group-keys.
Implementation for handling aggregation with grouping by group-keys.
Implementation for handling aggregation with grouping by group-keys.
Implementation for handling aggregation with grouping by group-keys.
Implementation for handling aggregation with grouping by group-keys.
Represents a single annotation attribute, the value of which may itself be a single value, array or further annotations.
Represents a attribute of an annotation.
Describes an annotation.
Thrown to indicate a problem processing an EPL statement annotation.
Represents a single annotation.
Utility to handle EPL statement annotations.
Annotation to target certain constructs.
Arithmatic expression for addition, subtraction, multiplication, division and modulo.
A fast collection backed by an array with severe limitations.
Iterator for an array of events.
Array expression forms array results, similar to the syntax of "{element 1, element 2, ...
Getter for an array property backed by a field, identified by a given index, using vanilla reflection.
Iterator for iterating over an array of events up to a given max number of events.
Iterator for iterating over an array of events up to a given max number of events.
Getter for an array property identified by a given index, using vanilla reflection.
Builds a tree of assembly nodes given a strategy for how to join streams.
An assignment is an expression specifically for the purpose of usage in updates.
Marker interface for use with view factories that create data window views
that are asymetric in posting insert and remove stream data:
Data windows that post only a partial insert and remove stream as output when compared to
the insert and remove stream received.
Annotation for use in EPL statements to add a debug.
Enumeration of audit values.
Global boolean for enabling and disable audit path reporting.
Mean deviation of the (distinct) values returned by an expression.
Average of the (distinct) values returned by an expression.
Annotation for use with Avro to provide a schema for a given event property.
Represents a node in a tree responsible for assembling outer join query results.
Represents the factory of a node in a tree responsible for assembling outer join query results.
View for computing statistics that require 2 input variable arrays containing X and Y datapoints.
Marker interface for conditions reported.
EventType than can be supplied with a preconfigured list of properties getters (aka.
Base getter for native fragments.
Implementation of the
EventType interface for handling name value pairs.Bean for performing statistical calculations.
Base class for XML event types.
Wrapper for Java bean (POJO or regular) Java objects the represent events.
Copies an event for modification.
Copies an event for modification.
Copy method for bean events utilizing serializable.
Copy method for bean events utilizing serializable.
Writer for a set of event properties to a bean event.
Shortcut-evaluator for use with POJO-backed events only.
Writer for a property to an event.
Implementation of the EventType interface for handling JavaBean-type classes.
Interface for a factory for obtaining
BeanEventType instances.Between checks that a given value is in a range between a low endpoint and a high endpoint.
Works in conjunction with
SelectExprProcessor to present
a result as an object array for 'natural' delivery.Enum representing relational types of operation.
Bit Wise And.
Bit Wise And.
Bit Wise And.
Bit Wise And.
Bit Wise And.
Bit Wise Or.
Bit Wise Or.
Bit Wise Or.
Bit Wise Or.
Bit Wise Or.
Bit Wise Xor.
Bit Wise Xor.
Bit Wise Xor.
Bit Wise Xor.
Bit Wise Xor.
Computer for relational op.
Bitwise (binary) operator for binary AND, binary OR and binary XOR.
Assembly node for an event stream that is a branch with a single optional child node below it.
Assembly factory node for an event stream that is a branch with a single optional child node below it.
Assembly node for an event stream that is a branch with a single required child node below it.
Assembly node factory for an event stream that is a branch with a single required child node below it.
Observer interface to a stream publishing new and old events.
A view that acts as an adapter between views and update listeners.
List of built-in annotations.
Annotation that is the modifier for event-bus-visible event types
Enum indicating what kind of references are used to store the cache map's keys and values.
Assembly node for an event stream that is a branch with a two or more child nodes (required and optional) below it.
Structure to represent a list of event result rows per stream.
Assembly node for an event stream that is a branch with a two or more child nodes (required and optional) below it.
Helper class to compute the cartesian product of the events from two streams.
Case-expression that acts as a switch testing a value against other values.
Case expression that act as a when-then-else.
Cast expression casts the return value of an expression to a specified type.
An API for translating text.
Parser similar in structure to:
http://cogitolearning.co.uk/docs/cogpar/files.html
Provider of lookup of a class name resolving into a class.
Default provider for classname lookups.
Exception to represent an error instantiating a class from a class name.
Provider of a classloader.
Default class loader provider returns the current thread context classloader.
Indicates a problem importing classes, aggregation functions and the like.
Provides information about a single-row function.
Indicates a problem importing classes, aggregation functions and the like.
Script-expression is external scripting language expression such as JavaScript, Groovy or MVEL, for example.
Coalesce-function which returns the first non-null value in a list of values.
if (!(valueMap instanceof TYPE)) {
if (value instanceof EventBean) {
return getter.XXX((EventBean) value);
}
return XXXX;
}
return getter.getXXXX(value);
Helper subclass to CharSequenceTranslator to allow for translations that
will replace up to one character at a time.
Exception to represent a mismatch in Java types in an expression.
Utility for handling collection or array tasks.
Describes a column name and type.
A utility class for replacing select-clause column names with their
definitions in expression node trees.
Column-level configuration settings are held in this immutable descriptor.
Provided a 2-dimensional array of values, provide all possible combinations:
A comparator on multikeys.
A comparator on multikeys.
A comparator on multikeys with string values and using the Collator for comparing.
A comparator on multikeys.
A comparator on multikeys.
A comparator on multikeys with string values and using the Collator for comparing.
Represents a list-compare of the format "expression operator all/any (expressions)".
Marker interface for compile-time resolvers
Plan to perform an indexed table lookup.
Plan to perform an indexed table lookup.
Lookup on an nested map structure that represents an index for use with at least one range and possibly multiple ranges
and optionally keyed by one or more unique keys.
Concatenation expression that concatenates the result of child expressions to the expression.
Interface for a handler registered with a runtime instance to receive reported runtime conditions.
Context provided to
ConditionHandler implementations providing
runtime-condition-contextual information.Factory for runtime condition handler instance(s).
Context provided to
ConditionHandlerFactory implementations providing
runtime contextual information.Indicates that on the runtimelevel the match-recognize has reached the configured runtime-wide limit at runtime.
Indicates that on the runtimelevel the followed-by pattern operator, regardless whether parameterized with a max number of sub-expressions or not,
has reached the configured runtime-wide limit at runtime.
Indicates that the followed-by pattern operator, when parameterized with a max number of sub-expressions,
has reached that limit at runtime.
An instance of
Configuration allows the application
to specify properties to be used when compiling and when getting a runtime.Contains settings that apply to both the compile-time and the runtime.
Marker interface for different cache settings.
Expiring cache settings.
LRU cache settings.
Container for database configuration information, such as
options around getting a database connection and options to control the lifecycle
of connections and set connection parameters.
Controls how output column names get reflected in the event type.
Marker for different connection factory settings.
Enum controlling connection lifecycle.
Supplies connection-level settings for a given database name.
Connection factory settings for using a DataSource.
Connection factory settings for using a Apache DBCP or other provider DataSource factory.
Connection factory settings for using a DriverManager.
Indicates how the runtime retrieves metadata about a statement's output columns.
Configuration for Avro event types.
Configuration information for legacy (non-JavaBean) event types.
Encapsulates information about an accessor field backing a named event property.
Encapsulates information about an accessor method backing a named event property.
Configuration information for JSON event types.
Configuration object for Map-based event types.
Event representation metadata.
Avro settings.
Configuration object for Object array-based event types.
Configuration object for event types with super-types and timestamp.
Configuration object for enabling the runtimeto process events represented as XML DOM document nodes.
Descriptor class for event properties that are resolved via XPath-expression.
Holds common execution-related settings.
Holds view logging settings other then the Apache commons or Log4J settings.
Holds configuration information for data caches for use in method invocations in the from-clause.
Parser for the common section of configuration.
Time source configuration, the default in MILLI (millisecond resolution from System.currentTimeMillis).
Provides variable configuration.
Configures a variant stream.
Enumeration specifying whether only the predefine types or any type of event is accepted by the variant stream.
Contains settings that apply to the compiler only (and that do not apply at runtime).
Code generation settings.
Holds execution-related settings.
Controls the level of planning of filter indexes from filter expressions.
Expression evaluation settings in the runtime are for results of expressions.
Language settings in the runtime are for string comparisons.
Holds view logging settings other then the Apache commons or Log4J settings.
Parser for the compiler section of configuration.
Configuration information for plugging in a custom aggregation function.
Configuration information for plugging in a custom aggregation multi-function.
Configuration information for plugging in a custom date-time-method.
Configuration information for plugging in a custom enum-method.
Configuration information for plugging in a custom view.
Configuration information for plugging in a custom single-row function.
Controls whether a single-row function is eligible for optimization if it occurs in a filter expression.
Enum for single-row function value cache setting.
Configuration information for plugging in a custom view.
Configuration information for plugging in a custom view.
Holder for script settings.
Serialization and Deserialization options.
Holds default settings for stream selection in the select-clause.
Holds view resources settings.
Thrown to indicate a configuration problem.
Parser for configuration XML.
Contains settings that apply to the runtime only (and that do not apply to the compiler).
Configuration object for defining condition handling behavior.
Configuration object for defining exception handling behavior.
Holds runtime execution-related settings.
Expression evaluation settings in the runtime are for results of expressions.
Holds view logging settings other then the Apache commons or Log4J settings.
Holds match-recognize settings.
Configuration for metrics reporting.
Class to configure statement metrics reporting for a group of one or more statements.
Parser for the runtime section of configuration.
Holds pattern settings.
Holds configuration for a plugin such as an input/output adapter loader.
Holds threading settings.
Time source configuration, the default in MILLI (millisecond resolution from System.currentTimeMillis).
Holds variables settings.
Helper to migrate schema version 7 XML configuration to schema version 8 XML configuration.
Conjunction represents a logical AND allowing multiple sub-expressions to be connected by AND.
Base class for a Connection and PreparedStatement cache.
Caches the Connection and PreparedStatement instance for reuse.
Implementation of a connection cache that simply doesn't cache but gets
a new connection and statement every request, and closes these every time
a client indicates done.
Constant value returns a fixed value for use in expressions.
Helper class to find and invoke a class constructors that matches the types of arguments supplied.
Represents a contained-event selection.
Keyed-context partition key for the case when there are init-conditions and we must keep the initiating event
Interface for context dimension descriptors.
Category-segmented context.
Context descriptor for categories.
For use with overlapping or non-overlapping contexts, implementations represents a condition for starting/initiating
or ending/terminating a context.
Context condition that start/initiated or ends/terminates context partitions based on a crontab expression.
Context condition that start/initiated or ends/terminates context partitions based on a filter expression.
Context condition that starts/initiates immediately.
Context condition that starts/initiates immediately.
Context condition that start/initiated or ends/terminates context partitions based on a pattern.
Context condition that start/initiated or ends/terminates context partitions based on a time period.
Hash-segmented context.
Context detail for a library-func and filter pair for the hash segmented context.
Context dimension descriptor for a start-and-end temporal (single instance) or initiated-terminated (overlapping) context
Context dimension information for keyed segmented context.
Context detail for a key-filter pair for the keyed segmented context.
Nested context.
A collection of context partitions each uniquely identified by a context partition id (agent instance id).
Context partition identifiers are provided by the API when interrogating context partitions for a given statement.
Context partition identifier for category context.
Context partition identifier for hash context.
Context partition identifier for overlapping and non-overlapping contexts.
Context partition identifier for nested contexts.
Context partition identifier for segmented contexts.
Interface for classes representing a selector for navigating, querying or selecting among context partitions.
Selects all context paritions.
Selects a context partition by providing the context partition id(s).
Selects context partitions for use with a category context by providing a set of labels.
Selects context partitions by receiving a context partition identifier for interrogation.
Selects context partitions based on hash codes, for use with hashed context.
Selects context partitions of a nested context by providing selector according to the nested contexts.
Selector of context partitions for use with segmented contexts, provides a set of partition keys to select.
Listener for context-specific partition-related events.
The variable state for a context partitioned variable.
Context state event.
Context state event indicating a context activated.
Context state event indicating a new context created.
Context state event indicating a context deactivated.
Context state event indicating a context destroyed.
Context partition state event.
Context partition state event indicating a context partition allocated.
Context partition state event indicating a context partition de-allocated.
Context partition state event indicating a statement added.
Context partition state event indicating a statement removed.
Listener for event in respect to context management.
A view that calculates correlation on two fields.
Factory for
CorrelationView instances.Factory for
CorrelationView instances.Represents the "countever" aggregation function.
For use with Count-min sketch aggregation functions:
The agent implementation encapsulates transformation of value objects to byte-array and back (when needed),
and may override or provide custom behavior.
Count-min sketch base context object.
Count-min sketch context object for add-operations.
Count-min sketch context object for estimate-operations.
Count-min sketch context object for topk-operations.
For use with Count-min sketch aggregation functions:
The agent implementation encapsulates transformation of value objects to byte-array and back (when needed),
and may override or provide custom behavior.
Count-min sketch agent that handles String-type values and uses UTF-16 encoding
to transform strings to byte-array and back.
Count-min sketch agent that handles String-type values and uses UTF-16 encoding
to transform strings to byte-array and back.
Count-min sketch (or CM sketch) is a probabilistic sub-linear space streaming algorithm
(source: Wikipedia, see http://en.wikipedia.org/wiki/Count%E2%80%93min_sketch)
Value object for count-min-sketch top-k.
Count of the (distinct) values returned by an expression, equivalent to "count(distinct property)"
Count of (distinct) rows, equivalent to "count(*)"
Clause for creating an application-provided class for use across one or more statements.
Create a context.
Represents a create-variable syntax for creating a new variable.
Clause for creating an expression for use across one or more statements.
Create an index on a named window.
Create an index on a named window.
Enumeration to represents the index type.
Specification for creating a named window.
Specification for creating a named window index column.
Specification for creating a named window index column type.
Represents a create-schema syntax for creating a new event type.
Represents a type definition for use with the create-schema syntax for creating a new event type.
Specification for creating an event type/schema.
Represents a create-variable syntax for creating a new variable.
Table column in a create-table statement.
Descriptor for create-table statements.
Represents a create-variable syntax for creating a new variable.
Descriptor for create-variable statements.
Create a named window, defining the parameter of the named window such as window name and data window view name(s).
Specification for creating a named window.
Enumeration for special keywords in crontab timer.
Hold parameters for timer:at.
Frequency expression for use in crontab expressions.
Parameter expression such as last/lastweek/weekday/wildcard for use in crontab expressions.
An expression for use in crontab provides all child expression as part of a parameter list.
Parameter expression for use in crontab expressions and representing a range.
Current execution context supplies the current expression execution context.
Current timestamp supplies the current runtime time in an expression.
A holder for versioned values that holds a current version-value and a prior version-value pair.
This class supplies position information for
LookupInstructionExec
to use for iterating over events for lookup.Exception to indicate that a stream name could not be resolved.
Service providing database connection factory and configuration information
for use with historical data polling.
Service providing database connection factory and configuration information
for use with historical data polling.
Implementation provides database instance services such as connection factory and
connection settings.
Service providing database connection factory and configuration information
for use with historical data polling.
Factory for new database connections.
Database connection factory using
DriverManager to obtain connections.Database connection factory using
InitialContext and DataSource to obtain connections.Database connection factory using
InitialContext and DataSource to obtain connections.Binding from database output column type to Java object.
Enumeration of the different Java built-in types that are used to represent database output column values.
Data flow field-level annotation for the field that receives the dataflow context
Service for isolating non-HA and HA filter operation.
Object model of a data flow operator declaration.
Represents an input port of an operator.
Represents an output port of an operator.
Represents type information for data flow operators.
Object model of a data flow operator parameter.
Annotation for use with data flow fields on operator forges to receive parameters
Annotation for use with data flow fields on operator forges to receive additional properties
Annotation for use with data flow forges to indicate signal handling
Utility for data flow parameter resolution that considers parameter providers that are passed in.
Utility for validation data flow forge parameters
Implementations read and write objects from/to the stream.
Encapsulates information on what serde should be used, for byte code production.
Collects an object from
DataInput and emits the object to an emitter.Context for use with
DataInputToObjectCollector carries data input and emitter.Reads a
Serializable from DataInput and emits the resulting object.Tag interface for data window view factories that express a batch expiry policy.
Tag interface for data window views.
Marker interface for use with view factories that create data window views only.
Marker interface for use with view factories that create data window views only.
Utility class for date-time functions.
Provides footprint information for date-time method extension.
Date-time method extension API for adding date-time methods.
Context for use with the date-time method extension API
Describes to the compiler how it should manage code for the date-time method.
Provides information about the public static method that implements the logic for the date-time method.
Interface for use with date-time method operations.
For adding a date-time method that modifies the date-time value and that return a result of the same type
as the date-time value.
For adding a date-time method that reformats the date-time value returning a result of a different type
as the date-time value.
Context for use with the date-time method extension API
Descriptor for SQL output columns.
Specification object for historical data poll via database SQL statement.
Interface for event types that provide decorating event properties as a name-value map.
A restricted implementation of
Map.Entry that prevents
the Map.Entry contract from being broken.Model of dependency of lookup, in which one stream supplies values for lookup in another stream.
Tag interface for derived-value views.
Annotation for use in EPL statements to add a description.
General pupose callback to destroy a resource and free it's underlying resources.
Binding for nullable boolean values.
Binding for non-null boolean values.
Binding for non-null byte values.
Binding for non-null character values.
Binding for (nullable) String-typed values.
Binding for non-null double values.
Binding for non-null float values.
Binding for non-null integer values.
Binding for non-null long values.
Binding for nullable boolean values.
Binding for nullable byte values.
Binding for nullable character values.
Binding for nullable double values.
Binding for nullable float values.
Binding for nullable integer values.
Binding for nullable long values.
Binding for nullable short-typed values.
Binding for (nullable) String-typed values.
Serde that serializes and de-serializes using
ObjectInputStream and ObjectOutputStream.Binding for non-null short values.
Disjunction represents a logical OR allowing multiple sub-expressions to be connected by OR.
Implementations are executed when the DispatchService receives a dispatch invocation.
Implements dispatch service using a thread-local linked list of Dispatchable instances.
Getter for both attribute and element values, attributes are checked first.
Getter for a DOM complex element.
Getter for converting a Node child nodes into an array.
Getter for parsing node content to a desired type.
Iterator over DOM nodes that positions between elements.
Getter for retrieving a value at a certain index.
DOM getter for Map-property.
Getter for nested properties in a DOM tree.
Shortcut-getter for DOM underlying objects.
Getter for simple attributes in a DOM node.
Dot-expresson is for use in "(inner_expression).dot_expression".
Dot-expresson item is for use in "root_expression.dot_expression".
Dot-expresson item representing an array operation.
Dot-expresson item representing a call that has an name and parameters.
Dot-expresson item representing an identifier without parameters.
Holds a range of double values with a minimum (start) value and a maximum (end) value.
An execution directive for use in an EPL statement, that causes processing of an event to stop after the EPL statement
marked with @Drop has processed the event, applicable only if multiple statements must process the same event.
Interval methods.
Indicates a property exists in multiple streams.
Represents a dynamic indexed property of a given name.
Getter for a dynamic indexed property (syntax field.indexed[0]?), using vanilla reflection.
Getter for a dynamic indexed property (syntax field.indexed[0]?), using vanilla reflection.
Represents a dynamic mapped property of a given name.
Getter for a dynamic mapped property (syntax field.mapped('key')?), using vanilla reflection.
Getter for a dynamic mapped property (syntax field.mapped('key')?), using vanilla reflection.
Marker interface for dynamic properties.
Provides method information for dynamic (unchecked) properties of each class for use in obtaining property values.
Provides method information for dynamic (unchecked) properties of each class for use in obtaining property values.
Base class for getters for a dynamic property (syntax field.inner?), caches methods to use for classes.
Base class for getters for a dynamic property (syntax field.inner?), caches methods to use for classes.
Represents a dynamic simple property of a given name.
Getter for a dynamic property (syntax field.inner?), using vanilla reflection.
Getter for a dynamic property (syntax field.inner?), using vanilla reflection.
A simple node for the creation of a tree, intended in this case to mirror an XML model.
Provides an implementation of an empty iterator.
Provides an implementation of an empty map iterator.
Class holding various entity data for HTML and XML - generally for use with
the LookupTranslator.
Provides footprint information for enumeration method extension.
Enumeration method extension API for adding enum-methods.
Context for use with the date-time method extension API
For use with lambda parameters, the descriptor identifies a specific lambda parameter.
Lambda parameter type defines what value "v" assumes in an expression such as
mymethod(v => ...),
or what value "a" or "b" assume in an expression such as mymethod( (a,b) => ...).A lambda parameter that assumes an index value.
A lambda parameter that assumes the size value.
A lambda parameter that assumes a value of the given type and that originates from the state object
by calling the provided getter-method.
A lambda parameter that assumes the value itself.
Describes to the compiler how it should manage code for the enumeration method.
Provides information about the public static method that implements the logic for the enumeration method.
Interface for state-providing classes for use with enumeration method extension
Context for use with the enumeration method extension API
Assertion methods for event processing applications.
Callback for extracting individual collection items for assertion.
Base class for named runtime objects such as views, patterns guards and observers.
Any Java primitive type as well as any class and other non-array or non-collection type
Clazz can be either
- Collection
- Array i.e.
Carries return type information related to the return values returned by expressions.
The byte code and manifest of a compile EPL module or EPL fire-and-forget query.
Manifest is part of the
EPCompiled and provides information for the runtime that
allows it to use the byte code.Marker interface for an object containing information that can be added to the compiler path
Service interface for administration of contexts and context partitions.
Thrown to indicate a data flow saved configuration already exists.
Indicates cancellation of a data flow instance.
Data flow descriptor.
Emitter for use with data flow operators
Filter for use with the EPStatementSource operator.
Context object for filter for use with the EPStatementSource operator.
Collector for use with the EventBusSource operator.
For use with
EPDataFlowEventBeanCollector provides collection context.Collector for use with the EventBusSink operator.
For use with
EPDataFlowEventCollector provides collection context.Context for use with
EPDataFlowExceptionHandler.Handler for exceptions thrown by data flow operators.
Thrown to indicate a data flow execution exception.
Data flow instanve.
Holder for captive data flow execution.
Statistics holder for data flow instances.
Interface for statictics of data flow instance.
Indicates an exception instantiating a data flow.
Options for use when instantiating a data flow in
EPDataFlowService.Collector for use with the EPStatementSource operator.
Context for use with
EPDataFlowIRStreamCollector.Thrown to indicate a data flow is not found.
Handles setting or overriding properties for operators in a data flow.
Context for use with
EPDataFlowOperatorParameterProvider describes the operator and parameters to provide.For use in data flow instantiation, may provide operator instances.
Context for use with
EPDataFlowOperatorProvider.A data flow configuration is just a configuration name, a data flow name
and an instantiation options object.
Data flow runtime for instantiating data flows.
Base marker interface for data flow signals.
Final marker for data flows.
Window marker for data flows.
Data flow instance states.
Provider for rendering services of
EventBean events.This exception is thrown to indicate a problem in administration and runtime.
Interface for a prepared on-demand query that can be executed multiple times.
Parameter holder for parameterized on-demand queries that are prepared with substitution parameters and that
can be executed efficiently multiple times with different actual values for parameters.
Result for fire-and-forget queries.
Invocation handler for EPL and application-specified annotations.
Provides expression evaluation context information in an expression.
Invocation context for method invocations that invoke static methods or plug-in single-row functions.
Available when using JSR-223 scripts or MVEL, for access of script attributes.
Service for metrics reporting.
Represents a statement in the query API for statement metrics
Represents a statement group in the query API for statement metrics
The result of executing a prepared query.
Provider for a re-compiler that acts on existing deployment to either re-compile or re-load from an external source
Context for use with
EPRecompileProviderException for use with
EPRecompileProviderProvider for rendering services of
EventBean events.Provider for rendering services of
EventBean events.For use by event sender for direct feed of wrapped events for processing.
Interface for statement-level dispatch.
Class exists once per statement and hold statement resource lock(s).
Statement resource handle and callback for use with filter services.
Object model of an EPL statement.
EPType is the common superinterface for all types in EPL.EPTypeClass represents the value class and does not have type parameters.Provides type parameters.
EPTypeNull represents a null-type.Provides
EPType instances for common types.Service for variable management.
This class represents an 'and' operator in the evaluation tree representing an event expressions.
This class represents an 'and' operator in the evaluation tree representing an event expressions.
This class represents an 'and' operator in the evaluation tree representing an event expressions.
This class represents the state of an "and" operator in the evaluation state tree.
This class represents an 'every-distinct' operator in the evaluation tree representing an event expression.
This class represents an 'every-distinct' operator in the evaluation tree representing an event expression.
This class represents an 'every-distinct' operator in the evaluation tree representing an event expression.
Contains the state collected by an "every" operator.
Contains the state collected by an "every" operator.
This class represents an 'every' operator in the evaluation tree representing an event expression.
This class represents an 'every' operator in the evaluation tree representing an event expression.
This class represents an 'every' operator in the evaluation tree representing an event expression.
Contains the state collected by an "every" operator.
This class contains the state of an 'every' operator in the evaluation state tree.
This class represents a filter of events in the evaluation tree representing any event expressions.
This class represents a filter of events in the evaluation tree representing any event expressions.
This class represents a filter of events in the evaluation tree representing any event expressions.
This class contains the state of a single filter expression in the evaluation state tree.
This class contains the state of a single filter expression in the evaluation state tree.
This class represents a followed-by operator in the evaluation tree representing any event expressions.
This class represents a followed-by operator in the evaluation tree representing any event expressions.
This class represents a followed-by operator in the evaluation tree representing any event expressions.
Followed-by operator types in the evaluation tree representing any event expressions.
This class represents the state of a followed-by operator in the evaluation state tree.
This class represents the state of a followed-by operator in the evaluation state tree, with a maximum number of instances provided, and
with the additional capability to runtime-wide report on pattern instances.
Superclass of all nodes in an evaluation tree representing an event pattern expression.
This class represents a guard in the evaluation tree representing an event expressions.
This class represents a guard in the evaluation tree representing an event expressions.
This class represents a guard in the evaluation tree representing an event expressions.
This class represents the state of a "within" operator in the evaluation state tree.
This class represents a match-until observer in the evaluation tree representing any event expressions.
This class represents a match-until observer in the evaluation tree representing any event expressions.
This class represents a match-until observer in the evaluation tree representing any event expressions.
This class represents the state of a match-until node in the evaluation state tree.
Result of analysis of pattern expression node tree.
This class represents an 'not' operator in the evaluation tree representing any event expressions.
This class represents an 'not' operator in the evaluation tree representing any event expressions.
This class represents an 'not' operator in the evaluation tree representing any event expressions.
This class contains the state of an 'not' operator in the evaluation state tree.
This class represents an observer expression in the evaluation tree representing an pattern expression.
This class represents an observer expression in the evaluation tree representing an pattern expression.
This class represents the state of an eventObserver sub-expression in the evaluation state tree.
This class represents an 'or' operator in the evaluation tree representing any event expressions.
This class represents an 'or' operator in the evaluation tree representing any event expressions.
This class represents an 'or' operator in the evaluation tree representing any event expressions.
This class represents the state of a "or" operator in the evaluation state tree.
This class is always the root node in the evaluation tree representing an event expression.
This class represents an observer expression in the evaluation tree representing an pattern expression.
Interface for a root pattern node for removing matches.
This class is always the root node in the evaluation tree representing an event expression.
Interface for a root state node accepting a callback to use to indicate pattern results.
This class is always the root node in the evaluation state tree representing any activated event expression.
Superclass of all state nodes in an evaluation node tree representing an event expressions.
Interface for visiting each element in the evaluation node tree for an event expression (see Visitor pattern).
Interface for nodes in an expression evaluation state tree that are being informed by a child that the
event expression fragments (subtrees) which the child represents has turned true (evaluateTrue method)
or false (evaluateFalse).
This exception is thrown to indicate a problem resolving an event type by name.
Interface for event representation.
Collated writer for events, intented for passing along as a parameter and not intended to be implemented by an application
Implementations copy the event object for controlled modification (shallow copy).
Implementations copy the event object for controlled modification (shallow copy).
Factory for
EventBean instances given an underlying event object.Thrown to indicate a problem creating or populating an underlying event objects.
Factory for creating an event bean instance by writing property values to an underlying object.
Factory for event beans created and populate anew from a set of values.
Factory for event beans created and populate anew from a set of values.
Factory for creating an event bean instance by writing property values to an underlying object.
Factory for Json-underlying events.
Factory for Map-underlying events.
Factory for event beans created and populate anew from a set of values.
Factory for event beans created and populate anew from a set of values.
Factory for Map-underlying events.
Factory for Map-underlying events.
Factory for ObjectArray-underlying events.
Factory for ObjectArray-underlying events.
Method to getSelectListEvents events in collections to other collections or other event types.
Interface for writing a set of event properties to an event.
Iterator for obtaining distinct events.
Observers observe and indicate other external events such as timing events.
Descriptor for event property names, property types and access metadata.
Get property values from an event instance for a given event property.
Get property values from an event instance for a given indexed event property by passing the array index.
Get property values from an event instance for a given mapped event property by passing the map string key.
Interface for use with the JSON or XML event renderes to handle custom event property rendering.
Context for use with the
EventPropertyRenderer interface for use with the JSON or XML event renderes to handle custom event property rendering.Enumeration of property types.
Get property values from an event instance for a given event property.
Writer for a single property value to an event.
Writer for a single property value to an event.
Annotation that can be attached to specify which underlying event representation to use for events.
Returns a facility to process event objects that are of a known type.
Event sender for avro-backed events.
Event sender for POJO Java object events.
Event sender for JSON documents and pre-parsed event objects.
Event sender for json-backed events.
Event sender for map-backed events.
Event sender for map-backed events.
Event sender for XML DOM-backed events.
A streams is a conduct for incoming events.
Table of events allowing add and remove.
Table of events allowing add and remove.
Table of events allowing add and remove.
A repository of index tables for use with anything that
may use the indexes to correlate triggering events with indexed events.
This interface provides metadata on events.
Application type.
Modifier that dictates whether an event type allows or does not allow sending events in using one of the send-event
methods.
Indicates that a problem occurred looking up, assigning or creating and event type.
Pair of public and protected event type id.
Provides metadata for an event type.
Pair of event type and property.
Service provider interface for internal use for event types.
Metatype.
Iterator for an iterator of events returning the underlying itself.
Iterator for an iterator of events returning the underlying itself.
Enumeration of event representation.
Interface for an exception handler.
Context provided to
ExceptionHandler implementations providing
exception-contextual information as well as the exception itself.Context provided to
ExceptionHandler implementations providing
exception-contextual information as well as the exception itself,
for use with inbound pools and for exceptions unassociated to statements when using inbound pools.Indicates the phase during which and exception was encountered.
Factory for exception handler instance(s).
Context provided to
ExceptionHandlerFactory implementations providing
runtime contextual information.Extends the
ExceptionHandler with a method to, for the inbound-pool threading configuration,
handle exceptions that are not associated to a specific statement i.e.Exception for line item.
Interface for exceptions that have a line items
Interface for an execution node that looks up events and builds a result set contributing to an overall
join result set.
Query strategy for building a join tuple set by using an execution node tree.
Utility class that control debug-level logging in the execution path
beyond which is controlled by Log4j.
Descriptor for explicit properties for use with
BaseConfigurableEventType.Represents the Count-min sketch aggregate function.
Base expression node that represents an aggregation function such as 'sum' or 'count'.
Base expression node that represents an aggregation function such as 'sum' or 'count'.
Represents an And-condition.
Represents an And-condition.
Represents an array in a filter expressiun tree.
Represents the avedev(...) aggregate function is an expression tree.
Represents the avg(...) aggregate function is an expression tree.
Represents the between-clause function in an expression tree.
Represents the between-clause function in an expression tree.
Represents the bit-wise operators in an expression tree.
Represents the case-when-then-else control flow function is an expression tree.
Represents the CAST(expression, type) function is an expression tree.
Casting and parsing computer.
Casting and parsing computer.
Casting and parsing computer.
Casting and parsing computer.
Casting and parsing computer.
Casting and parsing computer.
Represents the CAST(expression, type) function is an expression tree.
Represents the COALESCE(a,b,...) function is an expression tree.
Represents a string concatenation.
Represents a constant in an expressiun tree.
Represents a constant in an expressiun tree.
Represents an stream property identifier in a filter expressiun tree.
Represents the "countever" aggregate function is an expression tree.
Represents the count(...) and count(*) and count(distinct ...) aggregate function is an expression tree.
Represents the "current_evaluation_context" function in an expression tree.
Expression instance as declared elsewhere.
Expression instance as declared elsewhere.
Represents an Dot-operator expression, for use when "(expression).method(...).method(...)"
Represents an Dot-operator expression, for use when "(expression).method(...).method(...)"
Interface for evaluating of an event tuple.
Interface for evaluating of an event tuple.
Interface for evaluating of an event re.
Interface for evaluating of an event re.
Represents an equals-for-group (= ANY/ALL/SOME (expression list)) comparator in a expression tree.
Represents an equals (=, !=, <>, is, is not) comparator in a filter expressiun tree.
Represents an equals (=) comparator in a filter expressiun tree.
Interface representing an expression for use in select-clauses, where-clauses, having-clauses, order-by clauses and
streams based on filters and pattern filter expressions.
Base expression.
This view is a moving window extending the into the past until the expression passed to it returns false.
Factory for
ExpressionBatchView.Factory for
ExpressionBatchView.Represents a single expression declaration that applies to a given statement.
Guard implementation that keeps a timer instance and quits when the timer expired,
and also keeps a count of the number of matches so far, checking both count and timer,
letting all
MatchedEventMap instances pass until then.For use in expression as a placeholder to represent its child nodes.
Precendence levels for expressions.
Cache entry bean-to-collection-of-bean.
Cache entry bean-to-collection-of-bean.
Cache entry bean-to-collection-of-bean.
Cache entry bean-to-collection-of-bean.
On the level of expression declaration:
a) for non-enum evaluation and for enum-evaluation a separate cache
b) The cache is keyed by the prototype-node and verified by a events-per-stream (EventBean[]) that is maintained or rewritten.
On the level of expression declaration:
a) for non-enum evaluation and for enum-evaluation a separate cache
b) The cache is keyed by the prototype-node and verified by a events-per-stream (EventBean[]) that is maintained or rewritten.
On the level of indexed event properties: Properties that are contained in EventBean instances, such as for Enumeration Methods, get wrapped only once for the same event.
Convenience factory for creating
Expression instances.This view is a moving window extending the into the past until the expression passed to it returns false.
Base factory for expression-based window and batch view.
Base factory for expression-based window and batch view.
This view is a moving window extending the into the past until the expression passed to it returns false.
Interface for evaluating of an event tuple.
Returns the context for expression evaluation.
Represents the "firstever" and "lastever: aggregate function is an expression tree.
Represents an stream property identifier in a filter expressiun tree.
Represents an stream property identifier in a filter expressiun tree.
Represents the in-clause (set check) function in an expression tree.
Represents the in-clause (set check) function in an expression tree.
Represents the in-clause (set check) function in an expression tree.
Represents the in-clause (set check) function in an expression tree.
Represents the in-clause (set check) function in an expression tree.
Represents the INSTANCEOF(a,b,...) function is an expression tree.
Represents the RSTREAM() function in an expression tree.
Represents the case-when-then-else control flow function is an expression tree.
Represents the leaving() aggregate function is an expression tree.
Represents the like-clause in an expression tree.
Like-Node Form-1: constant pattern
Like-Node Form-1: non-constant pattern
Represents a simple Math (+/-/divide/*) in a filter expression tree.
Represents the median(...) aggregate function is an expression tree.
Represents the min/max(distinct? ...) aggregate function is an expression tree.
Represents the MAX(a,b) and MIN(a,b) functions is an expression tree.
Represents the MAX(a,b) and MIN(a,b) functions is an expression tree.
Represents the "new Class(...)" operator in an expression tree.
Represents the "new Class[dim][dim]" operator in an expression tree.
Represents the "new Class(...)" operator in an expression tree.
Represents the "new {...}" operator in an expression tree.
Adapter to evaluate boolean expressions, providing
events per stream to expression nodes.
Adapter to evaluate boolean expressions, providing
events per stream to expression nodes.
Superclass for filter nodes in a filter expression tree.
Visitor that early-exists when it finds a context partition property.
Visitor that collects declared-expression instances.
Visitor that collects event property identifier information under expression nodes.
Visitor that collects event property identifier information under expression nodes.
Visitor that collects event property identifier information under expression nodes.
Visitor for getting a list of identifier nodes with their parent node, which can be null if there is no parent node.
Visitor for getting a list of "prev" functions.
Visitor that collects event property identifier information under expression nodes.
Visitor that collects subqueries, declared-expression and chained-dot.
Visitor that collects subselect instances only
directly under alias expressions, and declared expressions, stopping at nested declared expressions.
Visitor for compiling usage informaton of special expressions within an expression tree.
A placeholder for another expression node that has been validated already.
Visitor for expression node trees that determines if the expressions within contain a variable.
Visitor that collects expression nodes that require view resources.
Visitor interface for use with expression node trees.
Visitor interface for use with expression node trees, receives both the child node and the parent node (or null to indicate no parent node).
Represents a NOT expression in an expression tree.
Represents the nth(...) and aggregate function is an expression tree.
Expression for a parameter within a crontab.
Expression for use within crontab to specify a frequency.
Expression for use within crontab to specify a list of values.
Expression for use within crontab to specify a range.
A placeholder expression for view/pattern object parameters that allow
sorting expression values ascending or descending.
Represents an OR expression in a filter expression tree.
Represents a custom aggregation function in an expresson tree.
Represents a custom aggregation function in an expresson tree.
Represents an invocation of a plug-in single-row function in the expression tree.
Precendence levels for expressions.
Represents the 'prev' previous event function in match-recognize "define" item.
Represents the 'prev' previous event function in an expression node tree.
Represents the 'prior' prior event function in an expression node tree.
Represents the 'prior' prior event function in an expression node tree.
Represents the 'prior' prior event function in an expression node tree.
Represents the EXISTS(property) function in an expression tree.
Represents the rate(...) and aggregate function is an expression tree.
Represents the regexp-clause in an expression tree.
Regex-Node Form-1: constant pattern
Like-Node Form-1: string input, constant pattern and no or constant escape character
Like-Node Form-1: string input, constant pattern and no or constant escape character
Represents a lesser or greater then (</<=/>/>=) expression in a filter expression tree.
Represents a lesser or greater then (</<=/>/>=) expression in a filter expression tree.
Represents a lesser or greater then (</<=/>/>=) expression in a filter expression tree.
Represents a lesser or greater then (</<=/>/>=) expression in a filter expression tree.
Represents the stddev(...) aggregate function is an expression tree.
Represents a stream-reference.
Represents an stream selector that returns the streams underlying event, or null if undefined.
Represents an stream selector that returns the streams underlying event, or null if undefined.
Represents a subselect in an expression tree.
Represents an exists-subselect in an expression tree.
Represents a subselect in an expression tree.
Represents a subselect in an expression tree.
Represents a subselect in an expression tree.
Represents a substitution value to be substituted in an expression tree, not valid for any purpose of use
as an expression, however can take a place in an expression tree.
Represents the sum(...) aggregate function is an expression tree.
Expression representing a time period.
Expression representing a time period.
Expression representing a time period.
Represents the CURRENT_TIMESTAMP() function or reserved keyword in an expression tree.
Interface for evaluators that select possible multi-valued results in a single select column,
such as subqueries and "new" and case+new combined.
Interface for evaluators that select possible multi-valued results in a single select column,
such as subqueries and "new" and case+new combined.
Represents an expression node that returns the predefined type and
that cannot be evaluated.
Represents the TYPEOF(a) function is an expression tree.
Represents the TYPEOF(a) function is an expression tree.
Thrown to indicate a validation error in a filter expression.
Thrown to indicate a validation error in an expression originating from a property resolution error.
Validation interface for expression nodes.
Represents a variable in an expression tree.
Represents a variable in an expression tree.
Expression for use as wildcard (*).
Expression for use within crontab to specify a wildcard.
Annotation for use in EPL statements to add a debug.
Annotation for use in EPL statements to add a debug.
Annotation for use in EPL statements with inline classes for providing a plug-in single-row function.
Batch window based on timestamp of arriving events.
View for a moving window extending the specified amount of time into the past, driven entirely by external timing
supplied within long-type timestamp values in a field of the event beans that the view receives.
Factory for
ExternallyTimedWindowView.Factory for
ExternallyTimedWindowView.FAF query execute.
FAF query execute.
Starts and provides the stop method for EPL statements.
Starts and provides the stop method for EPL statements.
Starts and provides the stop method for EPL statements.
Starts and provides the stop method for EPL statements.
Starts and provides the stop method for EPL statements.
Starts and provides the stop method for EPL statements.
Starts and provides the stop method for EPL statements.
Starts and provides the stop method for EPL statements.
FAF query execute.
Starts and provides the stop method for EPL statements.
Starts and provides the stop method for EPL statements.
Starts and provides the stop method for EPL statements.
Starts and provides the stop method for EPL statements.
Starts and provides the stop method for EPL statements.
Fast byte array input stream, does not synchronize or check buffer overflow.
Output on fast byte array output stream.
Filter defines the event type to be filtered for, and an optional expression that returns true if
the filter should consider the event, or false to reject the event.
An iterator that filters events suppied by another iterator,
using a list of one or more filter expressions as filter.
Analyzes a filter expression and builds a query graph model.
Simple filter view filtering events using a filter expression tree.
Iterator for reading and filtering a source event iterator.
Constant value in a list of values following an in-keyword.
A Double-typed value as a filter parameter representing a range.
A String-typed value as a filter parameter representing a range.
A Double-typed value as a filter parameter representing a range.
Event property value in a list of values following an in-keyword.
Event property value in a list of values following an in-keyword.
An event property as a filter parameter representing a range.
Event property value in a list of values following an in-keyword.
An event property as a filter parameter representing a range.
Event property value in a list of values following an in-keyword.
Marker interface for use with
FilterService.Interface for a callback method to be called when an event matches a filter specification.
Defines the different operator types available for event filters.
Interface for filtering events by event type and event property values.
Filter service profile.
Contains the filter criteria to sift through events.
Contains the filter criteria to sift through events.
Helper to compile (validate and optimize) filter expressions as used in pattern and filter-based streams.
Helper to compile (validate and optimize) filter expressions as used in pattern and filter-based streams.
Helper to compile (validate and optimize) filter expressions as used in pattern and filter-based streams.
Helper to compile (validate and optimize) filter expressions as used in pattern and filter-based streams.
A two-sided map for filter parameters mapping filter expression nodes to filter parameters and
back.
This class represents one filter parameter in an
FilterSpecActivatable filter specification.Sort comparator for filter parameters that sorts filter parameters according to filter operator type.
This class represents a single, constant value filter parameter in an
FilterSpecActivatable filter specification.This class represents a filter parameter containing a reference to another event's property
in the event pattern result, for use to describe a filter parameter in a
FilterSpecActivatable filter specification.This class represents a filter parameter containing a reference to another event's property
in the event pattern result, for use to describe a filter parameter in a filter specification.
This class represents an arbitrary expression node returning a boolean value as a filter parameter in an
FilterSpecActivatable filter specification.This class represents an arbitrary expression node returning a boolean value as a filter parameter in an
FilterSpecActivatable filter specification.This class represents a 'in' filter parameter in an
FilterSpecActivatable filter specification.This class represents a range filter parameter in an
FilterSpecActivatable filter specification.Filter definition in an un-validated and un-resolved form.
A stream upon which projections (views) can be added that selects events by name and filter expression.
Specification for building an event stream out of a filter for events (supplying type and basic filter criteria)
and views onto these events which are staggered onto each other to supply a final stream of events.
Unvalided filter-based stream specification.
This interface represents one filter parameter in an filter specification.
Filter parameter value defining the event property to filter, the filter operator, and the filter value.
Marker interface used for fire-and-forget (on-demand) queries such as "update...set" and "delete from..."
that can be executed via the API.
Fire-and-forget (on-demand) delete DML.
Fire-and-forget (on-demand) insert DML.
Fire-and-forget (on-demand) update DML.
View retaining the very first event.
Represents the "firstever" aggregation function.
A length-first view takes the first N arriving events.
Factory for
FirstLengthWindowView.Factory for
FirstLengthWindowView.Represents the "first" aggregation function.
Factory for
FirstTimeView.Factory for
FirstTimeView.This view retains the first event for each multi-key of distinct property values.
Factory for
FirstUniqueByPropertyView instances.Factory for
FirstUniqueByPropertyView instances.Buffer for events - accumulates events until flushed.
A for-clause is a means to specify listener and observer delivery.
An item in a for-clause for controlling delivery of result events to listeners and subscribers.
Keywords for use in the for-clause.
Provides an event type for a property of an event.
Factory for event fragments for use with DOM getters.
Factory for fragments for DOM getters.
Factory for event fragments for use with DOM getters.
Fragment factory for use with XPath explicit properties.
Encapsulates a parameter specifying a frequency, i.e.
The from-clause names the streams to select upon.
Plan for a full table scan.
Plan for a full table scan.
Lookup on an unindexed table returning the full table as matching events.
Plan for a full table scan.
Plan for a full table scan.
Lookup on an unindexed table returning the full table as matching events.
Value-object for rendering support of a simple property value (non-nested).
Exception to represent a circular dependency.
Utility for working with acyclic graph: determines cyclic dependency and dependency-satisfying processing order.
The group-by clause consists of a list of expressions that provide the grouped-by values.
Base interface for group-by clause expressions, covers all possible combinations
of expressions, parenthesis-expression-combinations, rollup, cube and grouping sets
and their parameters.
A combination of expressions is for example "(a, b)", wherein the list of expressions provided
together logically make up a grouping level.
Represents the "grouping sets" keywords.
Represents a rollup or cube in a group-by clause.
Represents a single expression (non-combined, rollup/cube or grouping set) as part of a group-by expression.
Factory for
GroupByView instances.Factory for
GroupByView instances.The group view splits the data in a stream to multiple subviews, based on a key index.
Grouping-function for use with rollup, cube or grouping sets.
Grouping_id-function for use with rollup, cube or grouping sets.
Guard instances inspect a matched events and makes a determination on whether to let it pass or not.
Enum for all build-in guards.
Enum for all build-in guards.
Interface for a factory for
Guard instances.Thrown to indicate a validation error in guard parameterization.
Multi-key made up of multiple values providing hashcode and equals semantics using
Object.hashCode() and Arrays.equals(Object[], Object[])Annotation for providing a statement execution hint.
Enumeration of hint values.
Implementations serve as caches for historical or reference data retrieved
via lookup keys consisting or one or more rows represented by a list of events.
For use in iteration over historical joins, a
HistoricalDataCache implementation
that serves to hold EventBean rows generated during a join evaluation
involving historical streams stable for the same cache lookup keys.Implements an expiry-time cache that evicts data when data becomes stale
after a given number of seconds.
Factory for data caches for use caching database query results and method invocation results.
Query result data cache implementation that uses a least-recently-used algorithm
to store and evict query results.
Null implementation for a data cache that doesn't ever hit.
Execution node for executing a join or outer join against a historical data source,
using an lookup strategy for looking up into cached indexes, and an indexing strategy for indexing poll results
for future lookups.
Query plan for performing a historical data lookup.
Query plan for performing a historical data lookup.
Query strategy for use with
HistoricalEventViewable
to perform lookup for a given stream using the poll method on a viewable.Interface for views that poll data based on information from other streams.
Implements a poller viewable that uses a polling strategy, a cache and
some input parameters extracted from event streams to perform the polling.
Implements a poller viewable that uses a polling strategy, a cache and
some input parameters extracted from event streams to perform the polling.
Implements a poller viewable that uses a polling strategy, a cache and
some input parameters extracted from event streams to perform the polling.
Strategy for use in poll-based joins to reduce a cached result set (represented by
EventTable), in
which the cache result set may have been indexed, to fewer rows following the join-criteria in a where clause.Full table scan strategy for a poll-based cache result.
Full table scan strategy for a poll-based cache result.
Descriptor for an index requirement on a historical stream.
Manages index-building and sharing for historical streams by collecting required indexes during the
query planning phase, and by providing the right lookup strategy and indexing strategy during
query execution node creation.
A lookup strategy for use in outer joins onto historical streams.
Use this annotation to install a statement-specific hook or callback at time of statement creation.
Enumeration for the different types of statement-processing hooks (callbacks) that can be provided for a statement.
Utility class around indenting and formatting text.
Writer that uses an underlying PrintWriter to indent output text for easy reading.
Holds property information for joined properties in a lookup.
Represents an indexed property or array property, ie.
Plan to perform an indexed table lookup.
Plan to perform an indexed table lookup.
In-expresson checks that a value is in (or not in) a set of values, equivalent to the syntax "color in ('red', 'blue')".
View for the on-delete statement that handles removing events from a named window.
View for the on-delete statement that handles removing events from a named window.
View for the on-delete statement that handles removing events from a named window.
View for the on-delete statement that handles removing events from a named window.
Factory for handles for updates/inserts/deletes/select
Factory for handles for updates/inserts/deletes/select
View for the on-delete statement that handles removing events from a named window.
View for the on-select statement that handles selecting events from a named window.
View for the on-delete statement that handles removing events from a named window.
Interface for providing the compiler with code that allocates and initializes an instance of some class
Provides the compiler with code that allocates and initializes an instance of some class
by using "new" and by using setters.
Lookup on an index using a set of expression results as key values.
Lookup on an index using a set of expression results as key values.
Plan to perform an indexed table lookup.
Plan to perform an indexed table lookup.
Plan to perform an indexed table lookup.
Plan to perform an indexed table lookup.
An insert-into clause consists of a stream name and column names and an optional stream selector.
Descriptor generated by INSERT-INTO clauses specified in expressions to insert the
results of statement as a stream to further statements.
Class to hold a current latch per statement that uses an insert-into stream (per statement and insert-into stream
relationship).
A spin-locking implementation of a latch for use in guaranteeing delivery between
a single event produced by a single statement and consumable by another statement.
A suspend-and-notify implementation of a latch for use in guaranteeing delivery between
a single event produced by a single statement and consumable by another statement.
Instance-of expression checks if an expression returns a certain type.
General-purpose pair of values of any type.
Interface for a service that routes events within the runtimefor further processing.
Interface for a service that routes events within the runtimefor further processing.
Routing implementation that allows to pre-process events.
Pre-Processing entry for routing an event internally.
Routing implementation that allows to pre-process events.
Interface for a service that routes events within the runtimefor further processing.
View for use with pre-processing statement such as "update istream" for indicating previous and current event.
A view that represents an intersection of multiple data windows.
A view that represents an intersection of multiple data windows.
A view that represents an intersection of multiple data windows.
Factory for union-views.
Factory for union-views.
After.
Before.
Coincides.
During And Includes.
Finishes-By.
Finishes.
Meets.
Met-By.
OverlappedBy.
Overlaps.
Started-by.
Starts.
Into-table clause.
Parameter supplying a single int value is a set of numbers.
Indicates an invalid combination of context declaration and context partition selector, i.e.
Returns true for insert stream and false for remove stream, same as the "istream()" builtin function.
For use with length and time window views that must provide random access into data window contents
provided for the "previous" expression if used.
Provides relative access to insert stream events for certain window.
For indicating that the collection has been updated.
Provides random access into a rank-window's data.
Provides random access into a rank-window's data.
Getter for an iterable property backed by a field, identified by a given index, using vanilla reflection.
Defines a map that can be iterated directly without needing to create an entry set.
Getter for an iterable property identified by a given index, using vanilla reflection.
An iterator over an array of iterables.
An iterator over a list of iterables.
Annotation for use in EPL statements for making an unbound stream iterable returning the last event without
requiring a data window to be declared.
Helper for questions about EPType and Classes.
Translates codepoints to their Unicode escaped value suitable for Java source.
This class reacts to any new data buffered by registring with the dispatch service.
Strategy for looking up, in some sort of table or index, an event, potentially based on the
events properties, and returning a set of matched events.
Strategy for executing a join.
Join execution strategy based on a 3-step getSelectListEvents of composing a join set, filtering the join set and
indicating.
Method for preloading events for a given stream onto the stream's indexes, from a buffer already associated with a stream.
Implements a method for pre-loading (initializing) join indexes from a filled buffer.
Implements a method for pre-loading (initializing) join that does not return any events.
Interface for populating a join tuple result set from new data and old data for each stream.
Implements the function to determine a join result for a all-unidirectional full-outer-join (all streams),
in which a single stream's events are ever only evaluated and repositories don't exist.
Implements the function to determine a join result set using tables/indexes and query strategy
instances for each stream.
Implements the function to determine a join result set using tables/indexes and query strategy
instances for each stream.
Implements the function to determine a join result set using tables/indexes and query strategy
instances for each stream.
Interface for a prototype populating a join tuple result set from new data and old data for each stream.
Implements the function to determine a join result for a unidirectional stream-to-window joins,
in which a single stream's events are ever only evaluated using a query strategy.
Marker interface for indicators to join set processors.
Processes a join result set constisting of sets of tuples of events.
This class serves as the entry point to the minimal-json API.
Represents a JSON array, an ordered collection of JSON values.
Copy method for Json-underlying events.
Copy method for Json-underlying events.
Writer method for writing to Json-type events.
Annotation for use with Json to provide an adapter for a given class field.
All JSON underlying event objects implement this interface.
Renderer for an event into the JSON textual format.
JSON event renderer
Implementation of the EventType interface for handling JavaBean-type classes.
JSON field adapter.
JSON field adapter for strings.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
A getter that works on POJO events residing within a Map as an event property.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
Property getter for Json underlying fields.
A handler for parser events.
JSON number.
Represents a JSON object, a set of name/value pairs, where the names are strings and the values
are JSON values.
A streaming parser for JSON text.
Render for the JSON format.
JSON rendering options.
Annotation for use with JSON schemas.
Annotation for use with Json to provide an adapter for a given event property name.
Represents a JSON value.
Base junction for conjunction (and) and disjunction (or).
This view is a keep-all data window that simply keeps all events added.
Factory for keep-all-views.
Getter for a key property identified by a given key value, using vanilla reflection.
Getter for a key property identified by a given key value, using vanilla reflection.
Getter for a key property identified by a given key value, using vanilla reflection.
Defines a simple key value pair.
Lambda-expression is an expression of the form "parameter => body" where-in the "=>" reads as goes-to.
This view is a very simple view presenting the last event posted by the parent view to any subviews.
Factory for
LastEventView instances.Factory for
LastEventView instances.Represents the "lastever" aggregation function.
Observer interface to a stream publishing new and old events.
A view that retains the last update.
Represents the "last" aggregation function.
Assembly node for an event stream that is a leaf with a no child nodes below it.
Assembly node factory for an event stream that is a leaf with a no child nodes below it.
A data view that aggregates events in a stream and releases them in one batch when a maximum number of events has
been collected.
Same as the
LengthBatchView, this view also supports fast-remove from the batch for remove stream events.This view is a moving window extending the specified number of elements into the past.
This view is a moving window extending the specified number of elements into the past,
allowing in addition to remove events efficiently for remove-stream events received by the view.
Utility for string comparison based on the Levenshtein algo.
SQL-Like expression for matching '%' and '_' wildcard strings following SQL standards.
Utility for performing a SQL Like comparsion.
Getter for a list property backed by a field, identified by a given index, using vanilla reflection.
Getter for a list property identified by a given index, using vanilla reflection.
Represents a list of values in a set of numeric parameters.
An immutable object that represents a location in the parsed text.
Enumeration of blocking techniques.
Models a pipe between two operators.
Execution for a lookup instruction to look up in one or more event streams with a supplied event
and using a given set of lookup strategies, and adding any lookup results to a lighweight repository object
for later result assembly.
Execution for a set of lookup instructions and for a set of result assemble instructions to perform
joins and construct a complex result.
Receives result rows posted by result set assembly nodes.
Plan for lookup using a from-stream event looking up one or more to-streams using a specified lookup plan for each
to-stream.
Plan for lookup using a from-stream event looking up one or more to-streams using a specified lookup plan for each
to-stream.
Query plan for executing a set of lookup instructions and assembling an end result via
a set of assembly instructions.
Query plan for executing a set of lookup instructions and assembling an end result via
a set of assembly instructions.
Translates a value using a lookup table.
Simple read-write lock based on
ReentrantReadWriteLock that associates a
name with the lock and traces read/write locking and unlocking.A getter that works on POJO events residing within a Map as an event property.
A getter that works on arrays residing within a Map as an event property.
Getter for Map-entries with well-defined fragment type.
A getter for use with Map-based events simply returns the value for the key.
Wrapper for events represented by a Map of key-value pairs that are the event properties.
Getter for an array of event bean using a nested getter.
Getter for array events.
Returns the event bean or the underlying array.
Copy method for Map-underlying events.
Copy method for Map-underlying events.
Copy method for Map-underlying events.
Copy method for Map-underlying events.
A getter that works on EventBean events residing within a Map as an event property.
A getter for use with Map-based events simply returns the value for the key.
Writer method for writing to Map-type events.
Writer method for writing to Map-type events.
Property getter for Map-underlying events.
Property getter for Map-underlying events.
Property getter for Map-underlying events.
Implementation of the
EventType interface for handling plain Maps containing name value pairs.Getter for map array.
Getter for a dynamic indexed property for maps.
Defines an iterator that operates over a
Map.Getter for a dynamic mappeds property for maps.
A getter that interrogates a given property in a map which may itself contain nested maps or indexed entries.
A getter that works on EventBean events residing within a Map as an event property.
A getter that works on EventBean events residing within a Map as an event property.
A getter that works on EventBean events residing within a Map as an event property.
Getter for one or more levels deep nested properties of maps.
Getter for one or more levels deep nested properties of maps.
For events that are maps of properties.
Represents a mapped property or array property, ie.
Encapsulates the parse result parsing a mapped property as a class and method name with args.
A getter that works on POJO events residing within a Map as an event property.
Getter for map entry.
Getter for map entry.
Getter for map entry.
Getter for map entry.
Converts from a map of prior matching events to a events per stream for resultion by expressions.
Converts from a map of prior matching events to a events per stream for resultion by expressions.
Collection for internal use similar to the MatchedEventMap class in the client package
that holds the one or more events that could match any defined event expressions.
Collection for internal use similar to the MatchedEventMap class in the client package
that holds the one or more events that could match any defined event expressions.
Specification of matches available.
Enum for match recognize pattern atom types.
Match-recognize clause.
Define-clause in match-recognize expression.
Specification for a "define" construct within a match_recognize.
Interval specification within match_recognize.
Interval used within match recognize.
Specification for measure definition item within match_recognize.
Interface representing an expression for use in match-recognize.
Interface representing an expression for use in match-recognize.
Atom representing an expression for use in match-recognize.
Interface representing an expression for use in match-recognize.
Atom representing an expression for use in match-recognize.
Interface representing a permutation expression for use in match-recognize.
For use in match recognize pattern expression as a placeholder to represent its child nodes.
Match-recognize pattern descriptor for repetition
Specification for the skip-part of match_recognize.
Skip clause enum for match recognize.
Skip-enum for match_recognize.
Specification for match_recognize.
Enumeration for the type of arithmatic to use.
Computer for type-specific arith.
Computer for math op.
Computer for type-specific arith.
Computer for math op.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Interface for number cruncher.
Computer for type-specific arith.
Computer for math op.
Computer for type-specific arith.
Computer for math op.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for math op.
Computer for type-specific arith.
Computer for math op.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for math op.
Computer for type-specific arith.
Computer for math op.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Computer for type-specific arith.
Math context member
Maximum of the (distinct) values returned by an expression.
Maximum-value per-row expression (not aggregating) determines the maximum value among a set of values.
Median projection (aggregation) in the distinct and regular form.
Represents a member of a JSON object, a pair of a name and a value.
An stream that polls from a method.
Used for retrieving static and instance method objects.
Exception for resolution of a method failed.
Exception for resolution of a method failed.
Specification object for historical data poll via database SQL statement.
Base metric event.
Interface for routing metric events for processing.
Interface for producing a metric events.
Metrics execution producing runtime metric events.
Metrics execution producing statement metric events.
Execution context for metrics reporting executions.
Metrics reporting service for instrumentation data publishing, if enabled.
Scheduling for metrics execution is handles=d by this service.
Executor for metrics executions.
Metrics executor relying on a cached threadpool.
Metrics executor executing in-thread.
Interface for the time of the metrics generation.
Utility for CPU and wall time metrics.
Enumeration for the type of arithmatic to use.
Executes child expression nodes and compares results.
Determines minimum/maximum using BigDecimal.compareTo.
Determines minimum/maximum using BigInteger.compareTo.
Determines maximum using Number.doubleValue().
Determines minimum using Number.doubleValue().
Minimum of the (distinct) values returned by an expression.
Minimum-value per-row expression (not aggregating) determines the minimum value among a set of values.
Represent a deployment unit consisting of deployment declarative information (module name, uses and imports)
as well as EPL statements represented by
ModuleItem.Represents an EPL statement as part of a
Module.Holds an ordered list of modules considering each module's uses-dependencies on other modules.
Exception indicates a problem when determining delpoyment order and uses-dependency checking.
Options class passed to #getModuleOrder(java.util.Collection, ModuleOrderOptions)} for controlling the behavior of ordering and dependency checking logic.
Module ordering utility.
Provides well-known module properties.
An event table for holding multiple tables for use when multiple indexes of the same dataset must be entered into a cache
for use in historical data lookup.
Interface for use with multi-keys made up of multiple values and providing hashcode and equals semantics
Functions as a key value for Maps where keys need to be composite values.
This is a very fast, non-cryptographic hash suitable for general hash-based
lookup.
=============
Without MVEL dependencies in classpath, this call verifies and compiles an MVEL script.
Quad tree.
Annotation for use in EPL statement to define a statement name.
Visibility modifiers for EPL objects.
Named parameter expression of the form "name:expression" or "name:(expression, expression...)"
Class to hold a current latch per named window.
A no-latch implementation of a latch for use in guaranteeing delivery between
a named window delta result and consumable by another statement.
A spin-locking implementation of a latch for use in guaranteeing delivery between
a delta stream produced by a named window and consumable by another statement.
A suspend-and-notify implementation of a latch for use in guaranteeing delivery between
a named window delta result and consumable by another statement.
Specification for use of an existing named window.
Represents a consumer of a named window that selects from a named window via a from-clause.
A holder for events posted by a named window as an insert and remove stream.
Service to manage named window dispatches, locks and processors on an runtime level.
An instance of this class is associated with a specific named window.
Service to manage named windows on an runtime level.
The root window in a named window plays multiple roles: It holds the indexes for deleting rows, if any on-delete statement
requires such indexes.
The root window in a named window plays multiple roles: It holds the indexes for deleting rows, if any on-delete statement
requires such indexes.
Selected properties for a create-window expression in the model-after syntax.
This view is hooked into a named window's view chain as the last view and handles dispatching of named window
insert and remove stream results via
NamedWindowManagementService to consuming statements.This view is hooked into a named window's view chain as the last view and handles dispatching of named window
insert and remove stream results via
NamedWindowManagementService to consuming statements.This view is hooked into a named window's view chain as the last view and handles dispatching of named window
insert and remove stream results via
NamedWindowManagementService to consuming statements.A hash key that include a name and a count, wherein the combination of name and count defines
the uniqueness.
Pair of namespace and name.
Marker interface for event types that need not transpose their property.
An event that is carries multiple representations of event properties:
A synthetic representation that is designed for delivery as
EventBean to client update listener code,
and a natural representation as a bunch of Object-type properties for fast delivery to client
subscriber objects via method call.Value-object for rendering support of a nested property value.
Execution node that performs a nested iteration over all child nodes.
Plan to perform a nested iteration over child nodes.
Plan to perform a nested iteration over child nodes.
This class represents a nested property, each nesting level made up of a property instance that
can be of type indexed, mapped or simple itself.
Getter for one or more levels deep nested properties.
The "new instance" operator instantiates a host language object.
The "new" operator is useful to format an event or event property from a list of column names and expressions.
Node is the structure to hold results of event lookups in joined streams.
Iterator over a set of nodes supplying node and event-within-node position information in a
Cursor.Annotation for use in EPL statements to suppress any statement-level locking (use with caution, see below).
Negates the contained-within subexpression.
Builds a query plan for 3 or more streams in a outer join.
Builds a query plan for 3 or more streams in a join.
Encapsulates the chain information.
A generic class to hold an object that may itself be a null value versus an undefined (not existing) value.
Iterator that never returns an elements.
Provides an enumeration of each combination of numbers between zero and N-1
with N must be at least 1,
with each combination cannot have duplicates,
with each combination at least one element,
with the longest combination gets returned first and the least long combination of the highest N-1 value last.
Interface to generate a set of integers from parameters that include ranges, lists and frequencies.
Based on the
PermutationEnumeration this enumeration provides, among a set of supplied integer
values, all permutations of order these values can come in, ie.Enumeration that first returns a round-shift-left of all numbers
and when that is exhausted it returns number sets using grouped algo until exhausted.
A getter that works on POJO events residing within a Map as an event property.
A getter that works on arrays residing within a Map as an event property.
Getter for Map-entries with well-defined fragment type.
For events that are array of properties.
Getter for a dynamic property (syntax field.inner?), using vanilla reflection.
A getter for use with Map-based events simply returns the value for the key.
Getter for an array of event bean using a nested getter.
Getter for array events.
Returns the event bean or the underlying array.
Copy method for Object array-underlying events.
Copy method for Object array-underlying events.
Copy method for Map-underlying events.
Copy method for Map-underlying events.
A getter that works on EventBean events residing within a Map as an event property.
A getter for use with Map-based events simply returns the value for the key.
Writer method for writing to Object-array-type events.
Writer method for writing to Object-Array-type events.
Property getter for Objectarray-underlying events.
Property getter for Object-array-underlying events.
Property getter for Map-underlying events.
Getter for map array.
Getter for a dynamic indexed property for maps.
Getter for a dynamic mappeds property for maps.
A getter that works on EventBean events residing within a Map as an event property.
A getter that works on EventBean events residing within a Map as an event property.
A getter that works on EventBean events residing within a Map as an event property.
A getter that works on POJO events residing within a Map as an event property.
Getter for map entry.
Getter for map entry.
Getter for map entry.
A comparator on objects that takes a boolean array for ascending/descending.
A comparator on objects that takes a boolean array for ascending/descending.
Encapsulates the information required to specify an object identification and construction.
Receives an object and writes to
DataOutput.Context for use with
ObjectToDataOutputCollector carries object and data output.Writes a
Serializable object to DataOutput.For Avro use widener or transformer of object values to Avro record values
For Avro types for widening objects to Avro record values, see
ObjectValueTypeWidenerFactoryEnum for all build-in observers.
For use by
EventObserver instances to place an event for processing/evaluation.Interface for factories for making observer instances.
Thrown to indicate a validation error in guard parameterization.
A clause to delete from a named window based on a triggering event arriving and correlated to the named window events to be deleted.
A clause to delete from a named window based on a triggering event arriving and correlated to the named window events to be deleted.
Simple collection that exposes a limited add-and-get interface and that is optimized towards holding
a single event, but can hold multiple events.
View for the on-delete statement that handles removing events from a named window.
View for the on-delete statement that handles removing events from a named window.
View for the on-delete statement that handles removing events from a named window.
View for the on-select statement that handles selecting events from a named window.
View for the on-delete statement that handles removing events from a named window.
View for the on-delete statement that handles removing events from a named window.
View for the on-delete statement that handles removing events from a named window.
A clause to insert into zero, one or more streams based on criteria.
Items within the split-stream syntax to contain a tuple of insert-into, select and where-clause.
A clause to insert, update or delete to/from a named window based on a triggering event arriving and correlated to the named window events to be updated.
Marker interface for an on-merge clause action item.
For use with on-merge clauses, deletes from a named window if matching rows are found.
For use with on-merge clauses, inserts into a named window if matching rows are not found.
For use with on-merge clauses, updates rows in a named window if matching rows are found.
As part of on-merge, this represents a single "matched" or "not matched" entry.
A clause to delete from a named window based on a triggering event arriving and correlated to the named window events to be deleted.
A clause to assign new values to variables based on a triggering event arriving.
A view that handles the setting of variables upon receipt of a triggering event.
Specification for on-trigger statements.
Specification for the merge statement insert/update/delete-part.
Specification for the merge statement delete-part.
Specification for the merge statement insert-part.
Specification for the merge statement update-part.
Specification for the merge statement.
Specification for the merge statement insert/update/delete-part.
Specification for the merge statement insert/update/delete-part.
Descriptor for an on-set assignment.
Specification for the on-set statement.
Split-stream description.
Specification for the on-select splitstream statement.
Enum for the type of on-trigger statement.
Specification for the on-select and on-delete and on-update (via subclass) (no split-stream) statement.
Specification for the on-select and on-delete (no split-stream) statement.
A clause to update a named window based on a triggering event arriving and correlated to the named window events to be updated.
An order-by clause consists of expressions and flags indicating if ascending or descending.
A single entry in an order-by clause consisting of an expression and order ascending or descending flag.
Specification object to an element in the order-by expression.
A processor for ordering output events according to the order specified in the order-by clause.
A processor for ordering output events according to the order specified in the order-by clause.
Factory for
OrderByProcessor processors.An order-by processor that sorts events according to the expressions
in the order_by clause.
Sorter and row limiter in one: sorts using a sorter and row limits
An order-by processor that sorts events according to the expressions
in the order_by clause.
An order-by processor that sorts events according to the expressions
in the order_by clause.
For use in view parameter lists, this is a wrapper expression
that adds an ascending or descending sort indicator to its single child expression.
This class represents outer-join relationships between outer and inner tables.
Analyzes an outer join descriptor list and builds a query graph model from it.
Contains the ON-clause criteria in an outer join.
Qualifies a join by providing the outer join type (full/left/right) and joined-on properties.
Enum for the type of outer join.
A wrapper for the callback from the output limit condition to the output handler.
A condition that must be satisfied before output processing
is allowed to continue.
Output limit condition that is satisfied when either
the total number of new events arrived or the total number
of old events arrived is greater than a preset value.
Output condition handling crontab-at schedule output.
Output condition handling crontab-at schedule output.
Output condition handling crontab-at schedule output.
Output condition for output rate limiting that handles when-then expressions for controlling output.
Output condition for output rate limiting that handles when-then expressions for controlling output.
Output condition for output rate limiting that handles when-then expressions for controlling output.
Factory for output condition instances.
An empty output condition that is always satisfied.
Output limit condition that is satisfied when either
the total number of new events arrived or the total number
of old events arrived is greater than a preset value.
Output limit condition that is satisfied when either
the total number of new events arrived or the total number
of old events arrived is greater than a preset value.
Output limit condition that is satisfied when either
the total number of new events arrived or the total number
of old events arrived is greater than a preset value.
Output condition handling crontab-at schedule output.
Output condition handling crontab-at schedule output.
Output condition handling crontab-at schedule output.
Output condition for output rate limiting that handles when-then expressions for controlling output.
Output condition for output rate limiting that handles when-then expressions for controlling output.
Output condition for output rate limiting that handles when-then expressions for controlling output.
Output condition for output rate limiting that handles when-then expressions for controlling output.
Factory for output condition instances that are polled/queried only.
Output condition that is satisfied at the end
of every time interval of a given length.
Output condition that is satisfied at the end
of every time interval of a given length.
An output limit clause defines how to limit output of statements and consists of
a selector specifiying which events to select to output, a frequency and a unit.
Enum for describing the type of output limit within an interval.
Enum for the type of rate for output-rate limiting.
Selector for use in output rate limiting.
Spec for defining an output rate
Unit for output rate limiting.
A view that prepares output events, batching incoming
events and invoking the result set processor as necessary.
A view that prepares output events, batching incoming
events and invoking the result set processor as necessary.
A view that handles the "output snapshot" keyword in output rate stabilizing.
Handles output rate limiting for FIRST, only applicable with a having-clause and no group-by clause.
Handles output rate limiting for FIRST, only applicable with a having-clause and no group-by clause.
Handles output rate limiting for LAST and without order-by.
A view that handles the "output snapshot" keyword in output rate stabilizing.
A view that handles the "output snapshot" keyword in output rate stabilizing.
A view that handles the "output snapshot" keyword in output rate stabilizing.
Output process view that does not enforce any output policies and may simply
hand over events to child views, does not handle distinct.
Output process view that does not enforce any output policies and may simply
hand over events to child views, but works with distinct and after-output policies
Output process view that does not enforce any output policies and may simply
hand over events to child views, but works with distinct and after-output policies
Output process view that does not enforce any output policies and may simply
hand over events to child views, but works with distinct and after-output policies
Output process view that does not enforce any output policies and may simply
hand over events to child views, but works with distinct and after-output policies
Factory for output process view that does not enforce any output policies and may simply
hand over events to child views, does not handle distinct.
Factory for output processing views.
Factory for factories for output processing views.
Factory for factories for output processing views.
An output strategy that handles routing (insert-into) and stream selection.
An output strategy that handles routing (insert-into) and stream selection.
Annotation for use with data flow operator forges to provide output type information
Annotation for use with data flow operator forges to provide output type information
For rendering an output value returned by a property.
Renderer for a Object values that can simply be output via to-string.
For rendering an output value returned by a property.
Renderer for a String-value into JSON strings.
Renderer for a String-value into XML strings.
General-purpose pair of values of any type.
An unchecked exception to indicate that an input does not qualify as valid JSON.
Exception thrown when an EPL text could not be parsed.
Contains handles to implementations of services needed by evaluation nodes.
Logical AND for use in pattern expressions.
Contains handles to implementations of services needed by evaluation nodes.
Every-Distinct construct for use in pattern expressions.
Pattern 'every' expression that controls the lifecycle of pattern sub-expressions.
Interface representing a pattern expression.
Abstract base class for all pattern expressions.
Utility for evaluating pattern expressions.
For use in pattern expression as a placeholder to represent its child nodes.
Pattern precendences.
Filter for use in pattern expressions.
Followed-by for use in pattern expressions.
Guard is the where timer-within pattern object for use in pattern expressions.
Specification for a pattern guard object consists of a namespace, name and guard object parameters.
Callback interface for anything that requires to be informed of matching events which would be stored
in the MatchedEventMap structure passed to the implementation.
Match-Until construct for use in pattern expressions.
Not-expression for negating a pattern sub-expression for use in pattern expressions.
This exception is thrown to indicate a problem with a view expression.
Helper producing a repository of built-in pattern objects.
Factory service for resolving pattern objects such as guards and observers.
Resolves pattern object namespace and name to guard or observer factory class, using configuration.
Choice for type of pattern object.
Pattern observer expression observes occurances such as timer-at (crontab) and timer-interval.
Specification for a pattern observer object consists of a namespace, name and object parameters.
Logical OR for use in pattern expressions.
View to handle pattern discarding for a single stream (no join).
Convenience factory for creating
PatternExpr instances, which represent pattern expression trees.A stream of events that is generated by pattern matches.
Specification for building an event stream out of a pattern statement and views staggered onto the
pattern statement.
Pattern specification in unvalidated, unoptimized form.
Provides a N! (n-faculty) number of permutations for N elements.
Exception to indicate a parse error in parsing placeholders.
Parser for strings with substitution parameters of the form ${parameter}.
Fragment is a parse result, a parse results in an ordered list of fragments.
Represents a parameter in a parsed string of texts and parameters.
Represents a piece of text in a parse string with placeholder values.
Repository for pluggable objects of different types that follow a "namespace:name" notation.
Enumeration for types of plug-in objects.
Represents a plug-in aggregation function.
Quad tree.
Interface for polling data from a data source such as a relational database.
Viewable providing historical data from a database.
A strategy for converting a poll-result into a potentially indexed table.
Strategy of indexing that simply builds an unindexed table of poll results.
Strategy of indexing that simply builds an unindexed table of poll results.
Enables human readable JSON output by inserting whitespace between values.after commas and
colons.
Previous function for obtaining property values of previous events.
Previous function type.
Represents the 'prior' prior event resolution strategy for use in an expression node tree.
Buffers view-posted insert stream (new data) and remove stream (old data) events for
use with determining prior results in these streams, for multiple different prior events.
Buffers view-posted insert stream (new data) and remove stream (old data) events for
use with serving prior results in these streams, for a single prior event.
Buffer class for insert stream events only for use with unbound streams that inserts data only, to serve
up one or more prior events in the insert stream based on an index.
View that provides access to prior events posted by the parent view for use by 'prior' expression nodes.
Factory for making
PriorEventView instances.Expression representing the prior function.
An execution directive for use in an EPL statement, by which processing of an event by statements
start with the statement that has the highest priority, applicable only if multiple statements must process the same event.
Annotation that is the public access modifier
Abstract base class for streams that can be projected via views providing data window, uniqueness or other projections
or deriving further information from streams.
Interface for a property of an event of type BeanEventType (JavaBean event).
This exception is thrown to indicate a problem with a accessing a property of an
EventBean.All properties have a property name and this is the abstract base class that serves up the property name.
For use when the index comprises of either two or more ranges or a unique key in combination with a range.
For use when the index comprises of either two or more ranges or a unique key in combination with a range.
Atom in a specification for property evaluation.
Specification for property evaluation.
Interface for a function that evaluates the properties of an event and returns event representing the properties.
A property evaluator that returns a full row of events for each stream, i.e.
A property evaluator that returns a full row of events for each stream, i.e.
Interface for a function that evaluates the properties of an event and returns event representing the properties.
Factory for property evaluators.
A property evaluator that considers nested properties and that considers where-clauses
but does not consider select-clauses.
A property evaluator that considers nested properties and that considers where-clauses
but does not consider select-clauses.
Property evaluator that considers a select-clauses and relies
on an accumulative property evaluator that presents events for all columns and rows.
Property evaluator that considers a select-clauses and relies
on an accumulative property evaluator that presents events for all columns and rows.
Property evaluator that considers only level one and considers a where-clause,
but does not consider a select clause or N-level.
Property evaluator that considers only level one and considers a where-clause,
but does not consider a select clause or N-level.
Property-exists checks if a dynamic property exists.
Unique index.
This class offers utility methods around introspection.
Interface for an introspector that generates a list of event property descriptors
given a clazz.
Introspector that considers explicitly configured event properties only.
Factory for creates a builder/introspector for determining event property descriptors
based on a given class.
Implementation for a property list builder that considers JavaBean-style methods
as the exposed event properties, plus any explicitly configured props.
Implementation for a property list builder that considers any public method
and public field as the exposed event properties, plus any explicitly configured props.
Exception to indicate that a property name used in a filter doesn't resolve.
Parser similar in structure to:
http://cogitolearning.co.uk/docs/cogpar/files.html
Encapsulates the result of resolving a property and optional stream name against a supplied list of streams
StreamTypeService.Enumeration of different resolution styles for resolving property names.
Descriptor of a property set.
Descriptor of a property item.
Index that organizes events by the event property values into a single TreeMap sortable non-nested index
with Object keys that store the property values.
Index that organizes events by the event property values into a single TreeMap sortable non-nested index
with Object keys that store the property values.
Index that organizes events by the event property values into a single TreeMap sortable non-nested index
with Object keys that store the property values.
Iterator for use by
PropertySortedEventTable.Encapsulates the event property information available after introspecting an event's class members
for getter methods.
Expression returning a property value.
Pair of expressions with "equals" operator between.
Annotation that is the public access modifier
Annotation that is the public access modifier
Model of relationships between streams based on properties in both streams that are
specified as equal in a filter expression.
Key consisting of 2 integer stream numbers, for use by
QueryGraphForge.Property lists stored as a value for each stream-to-stream relationship, for use by
QueryGraphForge.Property lists stored as a value for each stream-to-stream relationship, for use by
QueryGraphForge.Property lists stored as a value for each stream-to-stream relationship, for use by
QueryGraphForge.Holder for query meta data information obtained from interrogating statements.
Contains the query plan for all streams.
Build a query plan based on filtering information.
Contains the query plan for all streams.
Specifies an index to build as part of an overall query plan.
Build query index plans.
Specifies an index to build as part of an overall query plan.
Specifies an index to build as part of an overall query plan.
Specifies an index to build as part of an overall query plan.
Specification node for a query execution plan to be extended by specific execution specification nodes.
Specification node for a query execution plan to be extended by specific execution specification nodes.
Encapsulates the strategy use to resolve the events for a stream into a tuples of events in a join.
Receiver for quit events for use by guards.
Random access interface to insert stream and remove stream data based on an index.
Getter that provides an index at runtime.
For indicating that the collection has been updated.
Represents a range of numbers as a parameter.
Iterator for use by
RankWindowView.Window sorting by values in the specified field extending a specified number of elements
from the lowest value up or the highest value down and retaining only the last unique value per key.
Factory for rank window views.
Factory for rank window views.
Reference-counting map based on a HashMap implementation that stores as a value a pair of value and reference counter.
reference-counting set based on a HashMap implementation that stores keys and a reference counter for
each unique key value.
A
Map implementation that allows mappings to be
removed by the garbage collector.Property getter for fields using Java's vanilla reflection.
Property getter for methods using Java's vanilla reflection.
Regular expression evaluates a "regexp" regular expression.
A view that calculates regression on two fields.
Factory for
RegressionLinestView instances.Factory for
RegressionLinestView instances.Enum representing relational types of operation.
Computer for relational op.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Computer for relational op compare.
Comparison using one of the relational operators (=, !=, <, <=, >, >=, is, is not).
Provides access to prior events given an event from which to count back, and an index to look at.
Provides random-access into window contents by event and index as a combination.
Provides random-access into window contents by event and index as a combination.
Renderer cache for event type metadata allows fast rendering of a given type of events.
Options for use by
RendererMeta with rendering metadata.An interface for a repository of events in a lookup/join scheme
that supplies events for event stream table lookups and receives results of lookups.
Implements a repository for join events and lookup results.
Defines an iterator that can be reset back to an initial state.
Utility class for loading or resolving external resources via URL and class path.
Interface for indicating a result in the form of a single row of multiple events, which could
represent either a full result over all streams or a partial result over a subset of streams.
Processor for result sets coming from 2 sources.
Result-set processor prototype for the aggregate-grouped case:
there is a group-by and one or more non-aggregation event properties in the select clause are not listed in the group by,
and there are aggregation functions.
Result-set processor for the aggregate-grouped case:
there is a group-by and one or more non-aggregation event properties in the select clause are not listed in the group by,
and there are aggregation functions.
Iterator for group-by with aggregation.
Processor prototype for result sets for instances that apply the select-clause, group-by-clause and having-clauses
as supplied.
Factory for output processors.
Result set processor prototype for the hand-through case:
no aggregation functions used in the select clause, and no group-by, no having and ordering.
Method to transform an event based on the select expression.
Result set processor prototype for the case: aggregation functions used in the select clause, and no group-by,
and all properties in the select clause are under an aggregation function.
Result set processor for the case: aggregation functions used in the select clause, and no group-by,
and all properties in the select clause are under an aggregation function.
Result set processor prototype for the case: aggregation functions used in the select clause, and no group-by,
and not all of the properties in the select clause are under an aggregation function.
Result set processor for the case: aggregation functions used in the select clause, and no group-by,
and not all of the properties in the select clause are under an aggregation function.
Iterator for aggregation results that aggregate all rows.
Result set processor prototype for the fully-grouped case:
there is a group-by and all non-aggregation event properties in the select clause are listed in the group by,
and there are aggregation functions.
Result set processor for the fully-grouped case:
there is a group-by and all non-aggregation event properties in the select clause are listed in the group by,
and there are aggregation functions.
Iterator for the group-by case with a row per group.
Result set processor prototype for the fully-grouped case:
there is a group-by and all non-aggregation event properties in the select clause are listed in the group by,
and there are aggregation functions.
Result set processor prototype for the simplest case: no aggregation functions used in the select clause, and no group-by.
Result set processor for the simplest case: no aggregation functions used in the select clause, and no group-by.
Reversed iterator for an array of events.
Event buffer of a given size provides a random access API into the most current event to prior events
up to the given size.
Assembly node for an event stream that is a root with a two or more child nodes below it.
Assembly factory node for an event stream that is a root with a two or more child nodes below it.
Assembly node for an event stream that is a root with a one optional child node below it.
Assembly factory node for an event stream that is a root with a one optional child node below it.
Assembly node for an event stream that is a root with a one required child node below it.
Assembly node factory for an event stream that is a root with a one required child node below it.
View for processing split-stream syntax.
Handler for incoming events for split-stream syntax, encapsulates where-clause evaluation strategies.
Handler for split-stream evaluating the all where-clauses and their matching select-clauses.
Handler for split-stream evaluating the first where-clause matching select-clause.
Specification object for a row limit.
An limit-processor for use with "limit" and "offset".
A factory for row-limit processor instances.
A factory for row-limit processor instances.
Spec for defining a row limit.
Base node for
Or-condition in a regex expression tree.
Atom in a regex expression tree.
Concatenation of atoms in a regular expression tree.
Nested () regular expression in a regex expression tree.
Permute () regular expression in a regex expression tree.
Precendence levels for expressions.
Helper for match recognize.
Iteration result for row regex.
State holder for matches, backed by an array, for fast copying and writing.
Match-recognize NFA states provides this information.
Any-quantifier.
Any-quantifier.
Base for states.
End state in the regex NFA states.
End state in the regex NFA states.
State for a partial NFA match.
NFA state for a single match that applies a filter.
NFA state for a single match that applies a filter.
Match-recognize NFA states provides this information.
Base for states.
The '?' state in the regex NFA states.
The '?' state in the regex NFA states.
The '?' state in the regex NFA states.
The '+' state in the regex NFA states.
The '+' state in the regex NFA states.
The '+' state in the regex NFA states.
The '*' state in the regex NFA states.
The '*' state in the regex NFA states.
The '*' state in the regex NFA states.
A strand of one or more NFA states that has a list of start states, end states and a list of all states in the strand.
A result of computing a strand of one or more NFA states that has a list of start states and a list of all states in the strand.
Enum for NFA types.
View for match recognize support.
View factory for match-recognize view.
View factory for match-recognize view.
Plan match-recognize.
Service interface for match recognize.
All current state holding partial NFA matches.
Service for holding partition state.
Partition-by implementation for partition state.
State for when no partitions (single partition) is required.
Service for holding schedule state.
Getter that provides an index at runtime.
Interface for random access to a previous event.
"Prev" state for random access to event history.
Service for creating match-recognize factory and state services.
Reports runtime-level instrumentation values.
Service for runtime-level settings around threading and concurrency.
A concurrency-safe iterator that iterates over events representing statement results (pull API)
in the face of concurrent event processing by further threads.
This class acts as a buckets for sorting schedule service callbacks that are scheduled to occur at the same
time.
Calendar class for use in scheduling, specifically for use in computing the next invocation time.
For a crontab-like schedule, this class computes the next occurance given a start time and a specification of
what the schedule looks like.
Interface for scheduled callbacks.
Type of schedule item.
This exception is thrown to indicate a problem with schedule parameters.
This exception is thrown to indicate a problem with scheduling.
Holds a schedule specification which consists of a set of integer values or a null
value for each schedule unit to indicate a wildcard.
Utility for computing from a set of parameter objects a schedule specification carry a
crontab-like schedule definition.
Enumeration of units in a specification of schedule, which contains elements for each of the following units:
minute, hour, day of month, month, day of week and seconds.
Interface for a service that allows to add and remove handles (typically storing callbacks)
for a certain time which are returned when
the evaluate method is invoked and the current time is on or after the handle's registered time.
Descriptor for use in create-schema syntax to define property name and type of an event property.
Schema element is a simple or complex element.
Represents a complex element possibly with attributes, simple elements, other complex child elements
and may itself have a simple type.
Represents a simple value in a schema.
Marker interface for a schema (simple or complex) element or attribute.
Represents an attribute in a schema.
Represents a XSD schema or other metadata for a class of XML documents.
Utility class for querying schema information via Xerces implementation classes.
EventType for xml events that have a Schema.
Parses event property names and transforms to XPath expressions using the schema information supplied.
Helper for asserting conditions.
Script-expression is external scripting language expression such as JavaScript, Groovy or MVEL, for example.
A select-clause consists of a list of selection elements (expressions, wildcard(s), stream wildcard and the like)
and an optional stream selector.
Item in a select-clause to describe individual select-clause expressions or wildcard(s).
Marker interface for elements in a select clause that is in the compiled form.
Marker interface for elements in a select clause that is in the raw (storable) form.
Represents a wildcard as a select clause element.
Represents a single item in a SELECT-clause, with a name assigned
either by the runtimeor by the user specifying an "as" tag name.
Part of a select-clause to describe individual select-clause expressions.
Represents a single item in a SELECT-clause, potentially unnamed
as no "as" tag may have been supplied in the syntax.
Encapsulates the parsed select expressions in a select-clause in an EPL statement.
Encapsulates the parsed select expressions in a select-clause in an EPL statement.
For use in select clauses for specifying a selected stream: select a.* from MyEvent as a, MyOther as b
Enumeration for representing select-clause selection of the remove stream or the insert stream, or both.
For use in a select clause, this element in a select clause defines that for a given stream we want to
select the underlying type.
Represents a wildcard in the select-clause.
Processor for select-clause expressions that handles wildcards.
Processor for select-clause expressions that handles wildcards.
Processor for select-clause expressions that handles wildcards.
Processor for select-clause expressions that handles wildcards.
Processor for select-clause expressions that handles wildcards for single streams with no insert-into.
Processor for select-clause expressions that handles wildcards for single streams with no insert-into.
Interface for processors of select-clause items, implementors are computing results based on matching events.
Factory for select expression processors.
Interface for methodForges for processors of select-clause items, implementors produce a processor for computing results based on matching events.
Processor for select-clause expressions that handles a list of selection items represented by
expression nodes.
For use with high-availability and scale-out only, provider for serde (serializer and deserializer) information
to the compiler.
For use with high-availability and scale-out only, this class provides additional information passed to serde provider, for use with
SerdeProviderInformation that the serde applies to an aggregation.
Information that the serde applies to an distinct-value expression of an aggregation.
Information that the serde applies to a derived-value view property.
Information about the event property for which to obtain a serde.
Information about the event type for which to obtain a serde.
Information that the serde applies to a filter.
Information that the serde applies to an index.
Information about the multikey for which to obtain a serde.
Information about the variable for which to obtain a serde.
For use with high-availability and scale-out only, this class provides contextual information about the class that we
looking to serialize or de-serialize, for use with
SerdeProviderFor use with high-availability and scale-out only, this class provides contextual information about the event type that we
looking to serialize or de-serialize, for use with
SerdeProviderFactory for serde providers.
Context provided to serde provider factories for runtime-contextual information.
For use with high-availability and scale-out only, this class provides information to the compiler how to
resolve the serializer and de-serializer (serde) at deployment-time.
For use with high-availability and scale-out only, this class instructs the compiler that the serializer and de-serializer (serde)
is available for a given component type and component type serde
For use with high-availability and scale-out only, this class instructs the compiler that the serializer and de-serializer (serde)
is available via a singleton-pattern-style static field named "INSTANCE" (preferred) or by has a default constructor.
For use with high-availability and scale-out only, this class instructs the compiler that the serializer and de-serializer (serde)
is available using a parameterized constructor that accepts expressions as represents by the functions provided.
Utility class for copying serializable objects via object input and output streams.
Input stream that relies on a simple byte array, unchecked.
Output stream that relies on a simple byte array, unchecked.
Interface for number coercion resulting in BigInteger.
Interface for number coercion resulting in BigInteger.
Interface for number coercion.
Factory for conversion/coercion and widening implementations for numbers.
Represents a simple property of a given name.
Interface for casting.
Cast implementation for non-numeric values that caches allowed casts assuming there is a small set of casts allowed.
Factory for casters, which take an object and safely cast to a given type, performing coercion or dropping
precision if required.
Cast implementation for BigDecimal from object.
Cast implementation for BigInteger from object.
Cast implementation for char values.
Parser of a String input to an object.
A factory for creating an instance of a parser that parses a String and returns a target type.
Parser of a String input to an object.
Optimistic try to resolve the property string into an appropiate xPath,
and use it as getter.
Parses event property names and transforms to XPath expressions.
A utility class for an iterator that has one element.
A utility class for an iterator that has one element.
A utility class for an iterator that has zero or one element and can be reset with a new value.
Generic single-row method call consists of a method name and parameters, possibly chained.
View to dispatch for a single stream (no join).
This view is a very simple view presenting the number of elements in a stream or view.
Factory for
SizeView instances.Factory for
SizeView instances.Sorted, reference-counting set based on an ArrayList implementation that it being kept sorted.
Sorted, reference-counting set based on a TreeMap implementation that stores keys and a reference counter for
each unique key value.
Plan to perform an indexed table lookup.
Plan to perform an indexed table lookup.
Lookup on an index that is a sorted index on a single property queried as a range.
Iterator for use by
SortWindowView.Window sorting by values in the specified field extending a specified number of elements
from the lowest value up or the highest value down.
Factory for sort window views.
Factory for sort window views.
For use with
SQLColumnTypeConversion, context of column conversion.Implement this interface when providing a callback for SQL input parameter and column result processing for a statement,
converting an input parameter or converting an output column value into any other value.
For use with
SQLColumnTypeConversion, context of column conversion.For use with
SQLColumnTypeConversion, context of parameter conversion.Implement this interface when providing a callback for SQL row result processing for a statement,
converting each row's values into a POJO.
For use with
SQLOutputRowConversion, context of row conversion.For use with
SQLOutputRowConversion, context of row conversion.Hold a raw SQL-statements parameter information that were specified in the form ${name}.
An SQL stream that polls via SQL for events via join.
Utility for mapping SQL types of
Types to Java classes.Records minimal statement filter version required for processing.
Factory for the managed lock that provides statement resource protection.
Provides statement-level locks.
A Statement-lock implementation that doesn't lock.
Simple read-write lock based on
ReentrantReadWriteLock that associates a
name with the lock and traces read/write locking and unlocking.Simple read-write lock based on
ReentrantReadWriteLock that associates a
name with the lock and logs read/write locking and unlocking.Analysis result of analysing annotations for a statement.
Reports statement-level instrumentation values.
Holder for statement group's statement metrics.
Handle for statements metric reporting by runtime.
A repository for all statement metrics that organizes statements into statement groups.
Provides well-known statement properties.
Interface for a statement-level service for coordinating the insert/remove stream generation,
native deliver to subscribers and the presence/absence of listener or subscribers to a statement.
Specification object representing a complete EPL statement including all EPL constructs.
Context for mapping a SODA statement to a statement specification, or multiple for subqueries,
and obtaining certain optimization information from a statement.
Helper for mapping internal representations of a statement to the SODA object model for statements.
Specification object representing a complete EPL statement including all EPL constructs.
Un-mapping context for mapping from an internal specifications to an SODA object model.
Return result for unmap operators unmapping an intermal statement representation to the SODA object model.
Type of the statement.
Static method call consists of a class name and method name.
Standard deviation of the (distinct) values returned by an expression.
Starts and provides the stop method for EPL statements.
General purpose callback to stop a resource and free it's underlying resources.
Stop callback that performs no action.
An abstract base class for a named or unnamed stream.
Analysis result for joins.
Exception to indicate that a stream name could not be resolved.
Enumeration for representing selection of the remove stream or the insert stream, or both.
Specification for a stream, consists simply of an optional stream name and a list of views
on to of the stream.
Abstract base specification for a stream, consists simply of an optional stream name and a list of views
on to of the stream.
Validated stream specifications generally have expression nodes that are valid and event types exist.
Abstract base specification for a stream, consists simply of an optional stream name and a list of views
on to of the stream.
An uncompiled, unoptimize for of stream specification created by a parser.
Service supplying stream number and property type information.
Implementation that provides stream number and property type information.
Base class for stream and property name resolution errors.
Represents "stream.*" in for example "mystream.*"
Escapes and unescapes
Strings for
Java, Java Script, HTML and XML.Convenience wrapper for
StringBuilder providing escape methods.Implementation match a string against a pattern.
Regular expression matcher.
Pattern matching utility.
Holds a range of double values with a minimum (start) value and a maximum (end) value.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries.
Lookup on an unindexed table returning the full table as matching events.
Factory for lookup on an unindexed table returning the full table as matching events.
Factory for lookup on an unindexed table returning the full table as matching events.
Index lookup strategy for subqueries.
Index lookup strategy for tables.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries against tables, full table scan.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries for in-keyword single-index sided.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries for in-keyword single-index sided.
Holds property information for joined properties in a lookup.
Holds property information for joined properties in a lookup.
Holds property information for joined properties in a lookup.
Holds property information for joined properties in a lookup.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries.
Index lookup strategy for subqueries.
Strategy for looking up, in some sort of table or index, or a set of events, potentially based on the
events properties, and returning a set of matched events.
Strategy for looking up, in some sort of table or index, or a set of events, potentially based on the
events properties, and returning a set of matched events.
Strategy for looking up, in some sort of table or index, or a set of events, potentially based on the
events properties, and returning a set of matched events.
Strategy for looking up, in some sort of table or index, or a set of events, potentially based on the
events properties, and returning a set of matched events.
Strategy for looking up, in some sort of table or index, or a set of events, potentially based on the
events properties, and returning a set of matched events.
A lookup strategy that receives an additional match expression.
Exists-expression for a set of values returned by a lookup.
Subquery-expression returns values returned by a lookup modelled by a further
EPStatementObjectModel.Implements a stop callback for use with subqueries to clear their indexes
when a statement is stopped.
In-expression for a set of values returned by a lookup.
Exists-expression for a set of values returned by a lookup.
View handling the insert and remove stream generated by a subselect
for application to aggregation state.
Observer to a buffer that is filled by a subselect view when it posts events,
to be added and removed from indexes.
Strategy for evaluation of a subselect.
Strategy for subselects with "=/!=/>< ALL".
Strategy for subselects with "=/!=/>< ALL".
Strategy for subselects with "=/!=/>< ALL".
Strategy for subselects with "=/!=/>< ALL".
Represents a in-subselect evaluation strategy.
Represents a in-subselect evaluation strategy.
Represents a in-subselect evaluation strategy.
Represents a subselect in an expression tree.
Represents a subselect in an expression tree.
Factory for subselect evaluation strategies.
Represents a substitution parameter
Sum of the (distinct) values returned by an expression.
Table access expression.
Execution node for lookup in a table.
Execution node for lookup in a table.
Specifies exection of a table lookup using the supplied plan for performing the lookup.
Specifies exection of a table lookup using the supplied plan for performing the lookup.
Abstract specification on how to perform a table lookup.
Abstract specification on how to perform a table lookup.
Service to manage named windows on an runtime level.
Execution node for lookup in a table for outer joins.
Specifies exection of a table lookup with outer join using the a specified lookup plan.
Specifies exection of a table lookup with outer join using the a specified lookup plan.
Specification for use of an existing table.
Annotation for use in EPL statement to tag a statement with a name-value pair.
Interface for composite events in which a property is itself an event.
Interface for composite event type in which each property is itself an event.
Threading profile.
Utility class for logging threading-related messages.
A data window view that holds events in a stream and only removes events from a stream (rstream) if
no more events arrive for a given time interval.
A data window view that holds events in a stream and only removes events from a stream (rstream) if
no more events arrive for a given time interval, also handling the remove stream
by keeping set-like semantics.
A data view that aggregates events in a stream and releases them in one batch at every specified time interval.
Factory for
TimeBatchView.Factory for
TimeBatchView.Same as the
TimeBatchView, this view also supports fast-remove from the batch for remove stream events.A data view that aggregates events in a stream and releases them in one batch if either one of these
conditions is reached, whichever comes first: One, a time interval passes.
Factory for
TimeLengthBatchView.Window retaining timestamped events up to a given number of seconds such that
older events that arrive later are sorted into the window and released in timestamp order.
Factory for views for time-ordering events.
Represents a time period.
Represent an expression
Provider of internal system time.
Observer implementation for indicating that a certain time arrived, similar to "crontab".
Factory for 'crontab' observers that indicate truth when a time point was reached.
Factory for 'crontab' observers that indicate truth when a time point was reached.
Observer that will wait a certain interval before indicating true (raising an event).
Factory for making observer instances.
Factory for making observer instances.
Factory for ISO8601 repeating interval observers that indicate truth when a time point was reached.
Observer implementation for indicating that a certain time arrived, similar to "crontab".
Factory for ISO8601 repeating interval observers that indicate truth when a time point was reached.
Factory for ISO8601 repeating interval observers that indicate truth when a time point was reached.
Guard implementation that keeps a timer instance and quits when the timer expired,
letting all
MatchedEventMap instances pass until then.Factory for
TimerWithinGuard instances.Forge for
TimerWithinGuard instances.Guard implementation that keeps a timer instance and quits when the timer expired,
and also keeps a count of the number of matches so far, checking both count and timer,
letting all
MatchedEventMap instances pass until then.Allow for different strategies for getting VM (wall clock) time.
Time source type.
Container for events per time slot.
This view is a moving timeWindow extending the specified amount of milliseconds into the past.
Factory for
TimeWindowView.Iterator for reading and transforming a source event iterator.
Interface that transforms one event into another event, for use with
TransformEventIterator.Builds a query plan for the simple 2-stream scenario.
Type-of expression return the type name, as a string value, of the events in the stream if passing a stream name or
the fragment event type if passing a property name that results in a fragment event otherwise
the class simple name of the expression result or null if the expression returns a null value.
For Avro schemas for mapping a given type to a given Avro schema.
For Avro customized type mapping, use with
TypeRepresentationMapperInterface for a type widener.
Widerner that coerces to a widened boxed number.
Factory for type widening.
Type widner that coerces from String to char if required.
Interface for a type widener.
Thrown to indicate a precondition violation for undeploy.
Enumeration of blocking techniques.
Translates codepoints to their Unicode escaped value.
General-purpose pair of values of any type.
Simple table of events without an index.
Factory for simple table of events without an index.
Simple table of events without an index.
Simple table of events without an index, based on a List implementation rather then a set
since we know there cannot be duplicates (such as a poll returning individual rows).
A view that represents a union of multiple data windows wherein at least one is asymetric:
it does not present a insert stream for each insert stream event received.
A view that represents a union of multiple data windows.
Factory for union-views.
Factory for union-views.
This view includes only the most recent among events having the same value for the specified field or fields.
Factory for
UniqueByPropertyView instances.Factory for
UniqueByPropertyView instances.View for computing statistics, which the view exposes via fields representing the sum, count, standard deviation
for sample and for population and variance.
Factory for
UnivariateStatisticsView instances.Factory for
UnivariateStatisticsView instances.Iterator that does not allow remove.
Specification for the update clause.
Specification for the update statement.
Update dispatch view to indicate statement results to listeners.
Utility for inspecting and comparing URI.
Unique id generator based on Java 5
UUID, generates 36-character unique ids.A callback interface for indicating a change in variable value.
Indicates that a variable cannot be set.
Exception indicating a problem in a variable declaration.
Exception indicating a a variable already exists.
Variables service for reading and writing variables, and for setting a version number for the current thread to
consider variables for.
Variables service for reading and writing variables, and for setting a version number for the current thread to
consider variables for.
Indicates that a variable was not found.
Reads and writes variable values.
A convenience class for dealing with reading and updating multiple variable values.
A convenience class for dealing with reading and updating multiple variable values.
Interface for a plug-in to
VariableManagementService to handle variable persistent state.Exception indicating a variable type error.
Indicates that a variable value could not be assigned.
Thread-specific state in regards to variable versions.
A wrapper for a thread-local to hold the current version for variables visible for a thread, as well
as uncommitted values of variables for a thread.
A variant event is a type that can represent many event types.
An event bean that represents multiple potentially disparate underlying events and presents a unified face
across each such types or even any type.
Event type for variant event streams.
Descriptor for a variant stream property.
A thread-safe cache for property getters per event type.
Strategy for resolving a property against any of the variant types.
A property resolution strategy that allows any type, wherein all properties are Object type.
A property resolution strategy that allows only the preconfigured types, wherein all properties
that are common (name and type) to all properties are considered.
Specification for a variant event stream.
Holds a version of a value and a timestamp when that version is taken.
A self-cleaning list of versioned-values.
A view provides a projection upon a stream, such as a data window, grouping or unique.
The View interface provides a way for a stream, data provider, or another view,
to notify an object of additions and deletions to its data set.
Enum for all build-in views.
Helper producing a repository of built-in views.
Enumerates the valid values for each view's public fields.
Thrown to indicate a validation error in view parameterization.
This exception is thrown to indicate a problem with a view expression.
Factory service for resolving view names and for creating view instances based on a view specification including view name and namespace.
Resolves view namespace and name to view factory class, using configuration.
Coordinates between view factories and requested resource (by expressions) the
availability of view resources to expressions.
Coordinates between view factories and requested resource (by expressions) the
availability of view resources to expressions.
Specification for a view object consists of a namespace, name and view object parameters.
A general-purpose collection interface for collections updated by view data.
A virtual data window exposes externally-managed data transparently as a named window without the need
to retain any data in memory.
Context for use with virtual data window factory
VirtualDataWindowFactory provides
contextual information about the named window and the type of events held,
handle for posting insert and remove streams and factory for event bean instances.Base class for events related to virtual data windows.
Event indicating a named-window consuming statement is being added.
Base class for events indicating a named-window consumer management.
Event indicating a named-window consuming statement is being removed.
Event raised when an index gets created or started via the "create index" syntax.
Captures virtual data window indexed field information.
Event to indicate that for a virtual data window an exitsing index is being stopped or destroyed.
This event is raised when a virtual data window is stopped.
Factory for virtual data windows.
Context for use with virtual data window factory
VirtualDataWindowFactory provides
contextual information as well as the handle for posting insert and remove streams and factory for event bean instances.A factory that the runtime invokes at deployment time to obtain the virtual data window factory.
Context for use with a virtual data window factory factory
VirtualDataWindowFactoryFactory.Describes to the compiler how it should manage code for the virtual data window factory.
Use this class to provide a virtual data window factory wherein there is no need to write code that generates code.
Factory for
VirtualDataWindow.Context for use with virtual data window forge
VirtualDataWindowForge provides
contextual information about the named window and the type of events held.Provides a range as a start and end value, for use as a paramater to the lookup values passed to the
VirtualDataWindowLookup lookup method.Represents a lookup strategy object that an EPL statement that queries a virtual data window obtains
to perform read operations into the virtual data window.
Context passed to
VirtualDataWindow upon obtaining a lookup strategy for use by an EPL statement
that queries the virtual data window.As part of a lookup context, see
VirtualDataWindowLookupContext, this object encapsulates information about a single
property in a correlated where-clause.Enumeration for indicating the type of operator for a lookup against a virtual data window, see
VirtualDataWindowLookupContext.For use with virtual data windows, handles any insert stream and remove stream events that a
virtual data window may post to consuming statements.
Factory for serde implementations that provides a serde for a given Java built-in type.
View for computing a weighted average.
Factory for
WeightedAverageView instances.Factory for
WeightedAverageView instances.Represents "*" in for example "last(*)"
Represents a wildcard as a parameter.
Represents the "window" aggregation function.
Event bean that wraps another event bean adding additional properties.
Copy method for wrapper events.
Copy method for wrapper events.
Copy method for wrapper events.
Copy method for wrapper events.
Writer for wrapper events.
Writer for a set of wrapper event object values.
Copy method for underlying events.
Copy method for underlying events.
Writer for values to a wrapper event.
An event type that adds zero or more fields to an existing event type.
Descriptor for writable properties.
Controls the formatting of the JSON output.
A lightweight writing buffer to reduce the amount of write operations to be performed on the
underlying writer.
EventBean wrapper for XML documents.
Renderer for an event into the XML textual format.
Renderer for XML-formatted properties.
XML rendering options.
Annotation for use with XML schemas.
Annotation for use with XML to set a given event property name to use XPath.
Annotation for use with XML schemas to define a namespace prefix.
Provides the namespace context information for compiling XPath expressions.
Getter for XPath explicit properties returning an element in an array.
Getter for properties of DOM xml events.
Event stream implementation that does not keep any window by itself of the events coming into the stream,
however is itself iterable and keeps the last event.
Event stream implementation that does not keep any window by itself of the events coming into the stream,
however is itself iterable and keeps the last event.
Event stream implementation that does not keep any window by itself of the events coming into the stream,
without the possibility to iterate the last event.