[This topic is pre-release documentation and is subject to change in future releases. Blank topics are included as placeholders.]

Classes

  ClassDescription
public classAggregationServiceBase
All aggregation services require evaluation nodes which supply the value to be aggregated (summed, averaged, etc.) and aggregation state factories to make new aggregation states.

public classAggregationServiceFactory
Factory for aggregation service instances.

public classAggregationServiceGroupAllImpl
Implementation for handling aggregation without any grouping (no group-by).

public classAggregationServiceGroupByImpl
Implementation for handling aggregation with grouping by group-keys.

public classAggregationServiceNull
A null object implementation of the AggregationService interface.

public classAliasNodeSwapper
A utility class for replacing select-clause aliases with their definitions in expression node trees.

public classAutoImportServiceImpl
A service that allows users to refer to classes by partial names.

public classDuplicatePropertyException
Indicates a property exists in multiple streams.

public classOrderByProcessorFactory
Factory for net.esper.eql.core.OrderByProcessor processors.

public classOrderByProcessorSimple
An order-by processor that sorts events according to the expressions in the order_by clause.

public classPropertyNotFoundException
Exception to indicate that a property name used in a filter doesn't resolve.

public classPropertyResolutionDescriptor
Encapsulates the result of resolving a property and optional stream name against a supplied list of streams net.esper.eql.core.StreamTypeService.

public classResultSetProcessorAggregateAll
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. This processor does not perform grouping, every event entering and leaving is in the same group. The processor generates one row for each event entering (new event) and one row for each event leaving (old event). Aggregation state is simply one row holding all the state.

public classResultSetProcessorAggregateGrouped
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. This processor does perform grouping by computing MultiKey group-by keys for each row. The processor generates one row for each event entering (new event) and one row for each event leaving (old event). Aggregation state is a table of rows held by ${AggregationService} where the row key is the group-by MultiKey.

public classResultSetProcessorFactory
Factory for output processors. Output processors process the result set of a join or of a view and apply aggregation/grouping, having and some output limiting logic.

The instance produced by the factory depends on the presence of aggregation functions in the select list, the presence and nature of the group-by clause.

In case (1) and (2) there are no aggregation functions in the select clause.

Case (3) is without group-by and with aggregation functions and without non-aggregated properties in the select list:

 Copy imageCopy Code
select sum(volume)
. Always produces one row for new and old data, aggregates without grouping.

Case (4) is without group-by and with aggregation functions but with non-aggregated properties in the select list:

 Copy imageCopy Code
select price, sum(volume)
. Produces a row for each event, aggregates without grouping.

Case (5) is with group-by and with aggregation functions and all selected properties are grouped-by. in the select list:

 Copy imageCopy Code
select customerId, sum(volume) group by customerId
. Produces a old and new data row for each group changed, aggregates with grouping, see !:ResultSetProcessorRowGroup

Case (6) is with group-by and with aggregation functions and only some selected properties are grouped-by. in the select list:

 Copy imageCopy Code
select customerId, supplierId, sum(volume) group by customerId
. Produces row for each event, aggregates with grouping.


public classResultSetProcessorRowForAll
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.

This processor does not perform grouping, every event entering and leaving is in the same group. Produces one old event and one new event row every time either at least one old or new event is received. Aggregation state is simply one row holding all the state.


public classResultSetProcessorRowPerGroup
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.

Produces one row for each group that changed (and not one row per event). Computes MultiKey group-by keys for each event and uses a set of the group-by keys to generate the result rows, using the first (old or new, anyone) event for each distinct group-by key.


public classResultSetProcessorSimple
Result set processor for the simplest case: no aggregation functions used in the select clause, and no group-by.

The processor generates one row for each event entering (new event) and one row for each event leaving (old event).


public classSelectExprEvalProcessor
Processor for select-clause expressions that handles a list of selection items represented by expression nodes. Computes results based on matching events.

public classSelectExprJoinWildcardProcessor
Processor for select-clause expressions that handles wildcards. Computes results based on matching events.

public classSelectExprProcessorFactory
Factory for select expression processors.

public classStreamNotFoundException
Exception to indicate that a stream name could not be resolved.

public classStreamTypeServiceImpl
Implementation that provides stream number and property type information.

public classStreamTypesException
Base class for stream and property name resolution errors.

public classUniqueValueAggregator
Aggregator for use on top of another aggregator that handles unique value aggregation (versus all-value aggregation) for the underlying aggregator.

Interfaces

  InterfaceDescription
public interfaceAggregationResultFuture
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.

public interfaceAggregationService
Service for maintaing aggregation state. Processes events entering (a window, a join etc,) and events leaving. Answers questions about current aggrataion state for a given row.

public interfaceAggregator
Maintains aggregation state applying values as entering and leaving the state.

Implementations must also act as a factory for further independent copies of aggregation states such that new aggregation state holders and be created from a prototype.


public interfaceAutoImportService
Interface for a service that resolves a class name to type instances. Implementations typically allow some sort of configuration on which namespaces are automatically checked for presence of a type.

public interfaceOrderByProcessor
A processor for ordering output events according to the order specified in the order-by clause.

public interfaceResultSetProcessor
Processor for result sets coming from 2 sources. First, out of a simple view (on join). And second, out of a join of event streams. The processor must apply the select-clause, grou-by-clause and having-clauses as supplied. It must state what the event type of the result rows is.

public interfaceSelectExprProcessor
Interface for processors of select-clause items, implementors are computing results based on matching events.

public interfaceStreamTypeService
Service supplying stream number and property type information.