Click or drag to resize

com.espertech.esper.common.client.soda Namespace

[Missing <summary> documentation for "N:com.espertech.esper.common.client.soda"]

Classes
  ClassDescription
Public classAccessProjectionExpressionBase
Represents the base expression for "first", "last" and "window" aggregation functions.
Public classAnnotationAttribute
Public classAnnotationPart
Represents a single annotation.
Public classArithmaticExpression
Arithmatic expression for addition, subtraction, multiplication, division and modulo.
Public classArrayExpression
Array expression forms array results, similar to the syntax of "{element 1, element 2, ... element n}".
Public classAssignment
An assignment is an expression specifically for the purpose of usage in updates. Usually an assignment is an equal-expression with the lhs being an event property or variable and the rhs being the new value expression.
Public classAvedevProjectionExpression
Mean deviation of the (distinct) values returned by an expression.
Public classAvgProjectionExpression
Average of the (distinct) values returned by an expression.

Expects a single child expression providing the values to aggregate.

Public classBetweenExpression
Between checks that a given value is in a range between a low endpoint and a high endpoint.

Closed and open ranges (endpoint included or excluded) are supported by this class, as is not-between.

Public classBitwiseOpExpression
Bitwise (binary) operator for binary AND, binary OR and binary XOR.
Public classCaseSwitchExpression
Case-expression that acts as a switch testing a value against other values.

The first child expression provides the value to switch on. The following pairs of child expressions provide the "when expression then expression" results. The last child expression provides the "else" result.

Public classCaseWhenThenExpression
Case expression that act as a when-then-else.
Public classCastExpression
Cast expression casts the return value of an expression to a specified type.
Public classCoalesceExpression
Coalesce-function which returns the first non-null value in a list of values.
Public classCompareListExpression
Represents a list-compare of the format "expression operator all/any (expressions)".
Public classConcatExpression
Concatenation expression that concatenates the result of child expressions to the expression.
Public classConjunction
Conjunction represents a logical AND allowing multiple sub-expressions to be connected by AND.
Public classConstantExpression
Constant value returns a fixed value for use in expressions.
Public classContainedEventSelect
Represents a contained-event selection.
Public classContextDescriptorCategory
Category-segmented context.
Public classContextDescriptorCategoryItem
Context descriptor for categories.
Public classContextDescriptorConditionCrontab
Context condition that start/initiated or ends/terminates context partitions based on a crontab expression.
Public classContextDescriptorConditionFilter
Context condition that start/initiated or ends/terminates context partitions based on a filter expression.
Public classContextDescriptorConditionImmediate
Context condition that starts/initiates immediately.
Public classContextDescriptorConditionNever
Context condition that starts/initiates immediately.
Public classContextDescriptorConditionPattern
Context condition that start/initiated or ends/terminates context partitions based on a pattern.
Public classContextDescriptorConditionTimePeriod
Context condition that start/initiated or ends/terminates context partitions based on a time period.
Public classContextDescriptorHashSegmented
Hash-segmented context.
Public classContextDescriptorHashSegmentedItem
Context detail for a library-func and filter pair for the hash segmented context.
Public classContextDescriptorInitiatedTerminated
Context dimension descriptor for a start-and-end temporal (single instance) or initiated-terminated (overlapping) context
Public classContextDescriptorKeyedSegmented
Context dimension information for keyed segmented context.
Public classContextDescriptorKeyedSegmentedItem
Context detail for a key-filter pair for the keyed segmented context.
Public classContextDescriptorNested
Nested context.
Public classCountEverProjectionExpression
Represents the "countever" aggregation function.
Public classCountProjectionExpression
Count of the (distinct) values returned by an expression, equivalent to "count(distinct property)"
Public classCountStarProjectionExpression
Count of (distinct) rows, equivalent to "count(*)"
Public classCreateContextClause
Create a context.
Public classCreateDataFlowClause
Represents a create-variable syntax for creating a new variable.
Public classCreateExpressionClause
Clause for creating an expression for use across one or more statements.

Both expressions and scripts can be created using this clause.

Public classCreateIndexClause
Create an index on a named window.
Public classCreateIndexColumn
Create an index on a named window.
Public classCreateIndexColumnType
Enumeration to represents the index type.
Public classCreateSchemaClause
Represents a create-schema syntax for creating a new event type.
Public classCreateSchemaClauseTypeDef
Represents a type definition for use with the create-schema syntax for creating a new event type.
Public classCreateSchemaClauseTypeDefExtensions
Public classCreateTableClause
Represents a create-variable syntax for creating a new variable.
Public classCreateTableColumn
Public classCreateVariableClause
Represents a create-variable syntax for creating a new variable.
Public classCreateWindowClause
Create a named window, defining the parameter of the named window such as window name and data window view name(s).
Public classCrontabFrequencyExpression
Frequency expression for use in crontab expressions.
Public classCrontabParameterExpression
Parameter expression such as last/lastweek/weekday/wildcard for use in crontab expressions.
Public classCrontabParameterSetExpression
An expression for use in crontab provides all child expression as part of a parameter list.
Public classCrontabRangeExpression
Parameter expression for use in crontab expressions and representing a range.
Public classCurrentEvaluationContextExpression
Current execution context supplies the current expression execution context.
Public classCurrentTimestampExpression
Current timestamp supplies the current runtime time in an expression.
Public classDataFlowOperator
Object model of a data flow operator declaration.
Public classDataFlowOperatorInput
Represents an input port of an operator.
Public classDataFlowOperatorOutput
Represents an output port of an operator.
Public classDataFlowOperatorOutputType
Represents type information for data flow operators.
Public classDataFlowOperatorParameter
Object model of a data flow operator parameter.
Public classDisjunction
Disjunction represents a logical OR allowing multiple sub-expressions to be connected by OR.
Public classDotExpression
Dot-expresson is for use in "(inner_expression).dot_expression".
Public classDotExpressionItem
Dot-expresson item is for use in "(inner_expression).dot_expression".

Each item represent an individual chain item and may either be a method name with method parameters, or a (nested) property name typically with an empty list of parameters or for mapped properties a non-empty list of parameters.

Public classEPBaseNamedObject
Base class for named runtime objects such as views, patterns guards and observers.
Public classEPStatementFormatter
Public classEPStatementObjectModel
Object model of an EPL statement.

Applications can create an object model by instantiating this class and then setting the various clauses. When done, use the administrative interface to deploy from the model.

Use the toEPL method to generate a textual EPL from an object model.

Minimally, and EPL statement consists of the select-clause and the where-clause.These are represented by { @link SelectClause } and respectively.

Here is a short example that create a simple EPL statement such as "select page, responseTime from PageLoad" :

                        EPStatementObjectModel model = new EPStatementObjectModel();
                        model.setSelectClause(SelectClause.create("page", "responseTime"));
                        model.setPropertyEvalSpec(FromClause.create(FilterStream.create("PageLoad")));
                    

The select-clause and from-clause must be set for the statement object model to be useable by the administrative API.All other clauses a optional.

Please see the documentation set for further examples.

Public classEPStatementObjectModelHelper
Helper methods for use by the statement object model.
Public classExpressionBase
Base expression.
Public classExpressionDeclaration
Represents a single expression declaration that applies to a given statement.
Public classExpressionPlaceholder
For use in expression as a placeholder to represent its child nodes.
Public classExpressionPrecedenceEnum
Precendence levels for expressions.
Public classExpressions
Convenience factory for creating instances.

Provides quick-access methods to create all possible expressions and provides typical parameter lists to each.

Note that only the typical parameter lists are provided and expressions can allow adding additional parameters.

Many expressions, for example logical AND and OR (conjunction and disjunction), allow adding an unlimited number of additional sub-expressions to an expression. For those expressions there are additional add methods provided.

Public classFilter
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.
Public classFilterStream
A stream upon which projections (views) can be added that selects events by name and filter expression.
Public classFireAndForgetDelete
Fire-and-forget (on-demand) delete DML.
Public classFireAndForgetInsert
Fire-and-forget (on-demand) insert DML.

The insert-into clause holds the named window name and column names. The select-clause list holds the values to be inserted.

Public classFireAndForgetUpdate
Fire-and-forget (on-demand) Update DML.
Public classFirstEverProjectionExpression
Represents the "firstever" aggregation function.
Public classFirstProjectionExpression
Represents the "first" aggregation function.
Public classForClause
A for-clause is a means to specify listener and observer delivery.
Public classForClauseItem
An item in a for-clause for controlling delivery of result events to listeners and subscribers.
Public classForClauseKeyword
Keywords for use in the for-clause.
Public classForClauseKeywordExtensions
Public classFromClause
The from-clause names the streams to select upon.

The most common projected stream is a filter-based stream which is created by .

Multiple streams can be joined by adding each stream individually.

Outer joins are also handled by this class. To create an outer join consisting of 2 streams, add one that defines the outer join relationship between the 2 streams. The outer joins between N streams, add N-1 qualifiers.

Public classGroupByClause
The group-by clause consists of a list of expressions that provide the grouped-by values.
Public classGroupByClauseExpressionCombination
A combination of expressions is for example "(a, b)", wherein the list of expressions provided together logically make up a grouping level.
Public classGroupByClauseExpressionGroupingSet
Represents the "grouping sets" keywords.
Public classGroupByClauseExpressionRollupOrCube
Represents a rollup or cube in a group-by clause.
Public classGroupByClauseExpressionSingle
Represents a single expression (non-combined, rollup/cube or grouping set) as part of a group-by expression.
Public classGroupingExpression
Grouping-function for use with rollup, cube or grouping sets.
Public classGroupingIdExpression
Grouping_id-function for use with rollup, cube or grouping sets.
Public classGuardEnum
Public classGuardEnumExtensions
Enum for all build-in guards.
Public classInExpression
In-expresson checks that a value is in (or not in) a set of values, equivalent to the syntax "color in ('red', 'blue')".
Public classInsertIntoClause
An insert-into clause consists of a stream name and column names and an optional stream selector.
Public classInstanceOfExpression
Instance-of expression checks if an expression returns a certain type.
Public classIntoTableClause
Into-table clause.
Public classIStreamBuiltinExpression
Returns true for insert stream and false for remove stream, same as the "istream()" builtin function.
Public classJunction
Base junction for conjunction (and) and disjunction (or).
Public classLambdaExpression
Lambda-expression is an expression of the form "parameter => body" where-in the "=>" reads as goes-to.

The form "x => x * x" reads as "x goes to x times x", for an example expression that yields x multiplied by x.

Used with expression declaration and with enumeration methods, for example, to parameterize by an expression.

Public classLastEverProjectionExpression
Represents the "lastever" aggregation function.
Public classLastProjectionExpression
Represents the "last" aggregation function.
Public classLikeExpression
SQL-Like expression for matching '%' and '_' wildcard strings following SQL standards.
Public classMatchRecogizePatternElementType
Enum for match recognize pattern atom types.
Public classMatchRecogizePatternElementTypeExtensions
Public classMatchRecognizeClause
Match-recognize clause.
Public classMatchRecognizeDefine
Define-clause in match-recognize expression.
Public classMatchRecognizeIntervalClause
Interval used within match recognize.
Public classMatchRecognizeRegEx
Interface representing an expression for use in match-recognize.

Event row regular expressions are organized into a tree-like structure with nodes representing sub-expressions.

Public classMatchRecognizeRegExAlteration
Interface representing an expression for use in match-recognize.

Event row regular expressions are organized into a tree-like structure with nodes representing sub-expressions.

Public classMatchRecognizeRegExAtom
Atom representing an expression for use in match-recognize.

Event row regular expressions are organized into a tree-like structure with nodes representing sub-expressions.

Public classMatchRecognizeRegExConcatenation
Interface representing an expression for use in match-recognize.

Event row regular expressions are organized into a tree-like structure with nodes representing sub-expressions.

Public classMatchRecognizeRegExNested
Atom representing an expression for use in match-recognize.

Event row regular expressions are organized into a tree-like structure with nodes representing sub-expressions.

Public classMatchRecognizeRegExPermutation
Interface representing a permutation expression for use in match-recognize.
Public classMatchRecognizeRegExPlaceholder
For use in match recognize pattern expression as a placeholder to represent its child nodes.
Public classMatchRecognizeRegExRepeat
Match-recognize pattern descriptor for repetition
Public classMatchRecognizeSkipClause
Skip clause enum for match recognize.
Public classMatchRecognizeSkipClauseExtensions
Public classMaxProjectionExpression
Maximum of the (distinct) values returned by an expression.
Public classMaxRowExpression
Maximum-value per-row expression (not aggregating) determines the maximum value among a set of values.
Public classMedianProjectionExpression
Median projection (aggregation) in the distinct and regular form.
Public classMethodInvocationStream
An stream that polls from a method.
Public classMinProjectionExpression
Minimum of the (distinct) values returned by an expression.
Public classMinRowExpression
Minimum-value per-row expression (not aggregating) determines the minimum value among a set of values.
Public classNamedParameterExpression
Named parameter expression of the form "name:expression" or "name:(expression, expression...)"
Public classNewInstanceOperatorExpression
The "new instance" operator instantiates a host language object.
Public classNewOperatorExpression
The "new" operator is useful to format an event or event property from a list of column names and expressions.

Useful with enumeration methods and with case-when clauses that return multiple result values, for example.

Column names are part of the state and the number of column names must match the number of sub-expressions to the expression.

Public classNotExpression
Negates the contained-within subexpression.

Has a single child expression to be negated.

Public classOnClause
A clause to delete from a named window based on a triggering event arriving and correlated to the named window events to be deleted.
Public classOnDeleteClause
A clause to delete from a named window based on a triggering event arriving and correlated to the named window events to be deleted.
Public classOnInsertSplitStreamClause
A clause to insert into zero, one or more streams based on criteria.
Public classOnInsertSplitStreamItem
Items within the split-stream syntax to contain a tuple of insert-into, select and where-clause.
Public classOnMergeClause
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.
Public classOnMergeMatchedDeleteAction
For use with on-merge clauses, deletes from a named window if matching rows are found.
Public classOnMergeMatchedInsertAction
For use with on-merge clauses, inserts into a named window if matching rows are not found.
Public classOnMergeMatchedUpdateAction
For use with on-merge clauses, updates rows in a named window if matching rows are found.
Public classOnMergeMatchItem
As part of on-merge, this represents a single "matched" or "not matched" entry.
Public classOnSelectClause
A clause to delete from a named window based on a triggering event arriving and correlated to the named window events to be deleted.
Public classOnSetClause
A clause to assign new values to variables based on a triggering event arriving.
Public classOnUpdateClause
A clause to Update a named window based on a triggering event arriving and correlated to the named window events to be updated.
Public classOrderByClause
An order-by clause consists of expressions and flags indicating if ascending or descending.
Public classOrderByElement
A single entry in an order-by clause consisting of an expression and order ascending or descending flag.
Public classOrderedObjectParamExpression
For use in view parameter lists, this is a wrapper expression that adds an ascending or descending sort indicator to its single child expression.
Public classOuterJoinQualifier
Qualifies a join by providing the outer join type (full/left/right) and joined-on properties.
Public classOutputLimitClause
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.
Public classOutputLimitSelector
Selector for use in output rate limiting.
Public classOutputLimitSelectorExtensions
Public classOutputLimitUnit
Unit for output rate limiting.
Public classOutputLimitUnitExtensions
Public classPatternAndExpr
Logical AND for use in pattern expressions.
Public classPatternEveryDistinctExpr
Every-Distinct construct for use in pattern expressions.
Public classPatternEveryExpr
Pattern 'every' expression that controls the lifecycle of pattern sub-expressions.
Public classPatternExprBase
Abstract base class for all pattern expressions.
Public classPatternExprPlaceholder
For use in pattern expression as a placeholder to represent its child nodes.
Public classPatternExprPrecedenceEnum
Pattern precendences.
Public classPatternExprPrecedenceEnumExtensions
Public classPatternFilterExpr
Filter for use in pattern expressions.
Public classPatternFollowedByExpr
Followed-by for use in pattern expressions.
Public classPatternGuardExpr
Guard is the where timer-within pattern object for use in pattern expressions.
Public classPatternMatchUntilExpr
Match-Until construct for use in pattern expressions.
Public classPatternNotExpr
Not-expression for negating a pattern sub-expression for use in pattern expressions.
Public classPatternObserverExpr
Pattern observer expression observes occurances such as timer-at (crontab) and timer-interval.
Public classPatternOrExpr
Logical OR for use in pattern expressions.
Public classPatterns
Convenience factory for creating PatternExpr instances, which represent pattern expression trees.

Provides quick-access method to create all possible pattern expressions and provides typical parameter lists to each.

Note that only the typical parameter lists are provided and pattern expressions can allow adding additional parameters.

Many expressions, for example logical AND and OR (conjunction and disjunction), allow adding an unlimited number of additional sub-expressions to a pattern expression. For those pattern expressions there are additional add methods.

Public classPatternStream
A stream of events that is generated by pattern matches.

Patterns matches are events that match pattern expressions. Pattern expressions are built using .

Public classPlugInProjectionExpression
Represents a plug-in aggregation function.
Public classPreviousExpression
Previous function for obtaining property values of previous events.
Public classPreviousExpressionType
Previous function type.
Public classPriorExpression
Expression representing the prior function.
Public classProjectedStream
Abstract base class for streams that can be projected via views providing data window, uniqueness or other projections or deriving further information from streams.
Public classPropertyExistsExpression
Property-exists checks if a dynamic property exists.
Public classPropertyValueExpression
Expression returning a property value.
Public classPropertyValueExpressionPair
Pair of expressions with "Equals" operator between.
Public classRegExpExpression
Regular expression evaluates a "regexp" regular expression.
Public classRelationalOpExpression
Comparison using one of the relational operators (=, !=, <, <=, >, >=, is, is not).
Public classRowLimitClause
Specification object for a row limit.
Public classScheduleItemType
Type of schedule item.
Public classScheduleItemTypeExtensions
Public classSchemaColumnDesc
Descriptor for use in create-schema syntax to define property name and type of an event property.
Public classScriptExpression
Script-expression is external scripting language expression such as JavaScript, for example.
Public classSelectClause
A select-clause consists of a list of selection elements (expressions, Wildcard(s), stream wildcard and the like) and an optional stream selector.
Public classSelectClauseElementExtension
Public classSelectClauseExpression
Part of a select-clause to describe individual select-clause expressions.
Public classSelectClauseStreamWildcard
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. Most often used in joins to select wildcard from one of the joined streams.

For example:

select streamOne.* from StreamOne as streamOne, StreamTwo as
            streamTwo
Public classSelectClauseWildcard
Represents a wildcard in the select-clause.
Public classSingleRowMethodExpression
Generic single-row method call consists of a method name and parameters, possibly chained.
Public classSQLStream
An SQL stream that polls via SQL for events via join.
Public classStaticMethodExpression
Static method call consists of a class name and method name.
Public classStddevProjectionExpression
Standard deviation of the (distinct) values returned by an expression.
Public classStream
An abstract base class for a named or unnamed stream.

Named streams provide an as-name for the stream, for example "select * from MyEvents(id=10) as StreamZero". Unnamed streams provide no as-name for the stream, for example "select * from MyEvents(id=10)".

Public classStreamSelector
Enumeration for representing selection of the remove stream or the insert stream, or both.
Public classStreamSelectorExtensions
Public classStreamWildcardExpression
Represents "stream.*" in for example "mystream.*"
Public classSubqueryExistsExpression
Exists-expression for a set of values returned by a lookup.
Public classSubqueryExpression
Subquery-expression returns values returned by a lookup modelled by a further .
Public classSubqueryInExpression
In-expression for a set of values returned by a lookup.
Public classSubqueryQualifiedExpression
Exists-expression for a set of values returned by a lookup.
Public classSubstitutionParameterExpression
Represents a substitution parameter
Public classSumProjectionExpression
Sum of the (distinct) values returned by an expression.
Public classTableAccessExpression
Table access expression.
Public classTimePeriodExpression
Represent an expression
Public classTypeOfExpression
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.
Public classUpdateClause
Specification for the Update clause.
Public classView
A view provides a projection upon a stream, such as a data window, grouping or unique. For views, the namespace is an optional value and can be null for any-namespace.
Public classWildcardExpression
Represents "*" in for example "last(*)"
Public classWindowProjectionExpression
Represents the "window" aggregation function.
Interfaces
  InterfaceDescription
Public interfaceContextDescriptor
Interface for context dimension descriptors.
Public interfaceContextDescriptorCondition
For use with overlapping or non-overlapping contexts, implementations represents a condition for starting/initiating or ending/terminating a context.
Public interfaceExpression
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.

Expressions are organized into a tree-like structure with nodes representing sub-expressions.

Certain types of nodes have certain requirements towards the number or types of nodes that are expected as sub-expressions to an expression.

Public interfaceFireAndForgetClause
Marker interface used for fire-and-forget (on-demand) queries such as "Update...set" and "delete from..." that can be executed via the API.
Public interfaceGroupByClauseExpression
Base interface for group-by clause expressions, covers all possible combinations of expressions, parenthesis-expression-combinations, rollup, cube and grouping sets and their parameters.
Public interfaceOnMergeMatchedAction
Marker interface for an on-merge clause action item.
Public interfacePatternExpr
Interface representing a pattern expression.

Pattern expressions are organized into a tree-like structure with nodes representing sub-expressions (composite).

Certain types of nodes have certain requirements towards the number or types of nodes that are expected as pattern sub-expressions to an pattern expression.

Public interfaceSelectClauseElement
Item in a select-clause to describe individual select-clause expressions or Wildcard(s).