New! View global litigation for patent families

US20100057737A1 - Detection of non-occurrences of events using pattern matching - Google Patents

Detection of non-occurrences of events using pattern matching Download PDF

Info

Publication number
US20100057737A1
US20100057737A1 US12548281 US54828109A US2010057737A1 US 20100057737 A1 US20100057737 A1 US 20100057737A1 US 12548281 US12548281 US 12548281 US 54828109 A US54828109 A US 54828109A US 2010057737 A1 US2010057737 A1 US 2010057737A1
Authority
US
Grant status
Application
Patent type
Prior art keywords
event
pattern
state
binding
time
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Abandoned
Application number
US12548281
Inventor
Anand Srinivasan
Rakesh Komuravelli
Shailendra Mishra
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Oracle International Corp
Original Assignee
Oracle International Corp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06KRECOGNITION OF DATA; PRESENTATION OF DATA; RECORD CARRIERS; HANDLING RECORD CARRIERS
    • G06K9/00Methods or arrangements for reading or recognising printed or written characters or for recognising patterns, e.g. fingerprints
    • G06K9/62Methods or arrangements for recognition using electronic means

Abstract

Techniques for detecting non-occurrence of an event within a time period following the occurrence of another event. In one embodiment, language extensions are provided to a language that enable queries to be formulated for detecting non-occurrences using that language.

Description

    CROSS-REFERENCES TO RELATED APPLICATIONS
  • [0001]
    This application claims the benefit and priority under 35 U.S.C. 119(e) of U.S. Provisional Application Ser. No. 61/092,983, filed Aug. 29, 2008, entitled FRAMEWORK FOR SUPPORTING REGULAR EXPRESSION-BASED PATTERN MATCHING IN DATA STREAMS, the contents of which are herein incorporated by reference in their entirety for all purposes.
  • [0002]
    The present application incorporates by reference for all purposes the entire contents of the following related applications filed concurrently with the present application:
  • [0003]
    (1) U.S. application Ser. No. ______ titled FRAMEWORK FOR SUPPORTING REGULAR EXPRESSION-BASED PATTERN MATCHING IN DATA STREAMS (Attorney Docket No. 021756-056000US; OID-2008-153-01US);
  • [0004]
    (2) U.S. application Ser. No. ______ titled TECHNIQUES FOR MATCHING A CERTAIN CLASS OF REGULAR EXPRESSION-BASED PATTERNS IN DATA STREAMS (Attorney Docket No. 021756-056500US; OID-2008-152-01US);
  • [0005]
    (3) U.S. application Ser. No. ______ titled TECHNIQUES FOR PERFORMING REGULAR EXPRESSION-BASED PATTERN MATCHING IN DATA STREAMS (Attorney Docket No. 021756-056700US; OID-2008-153-02US); and
  • [0006]
    (4) U.S. application Ser. No. ______ titled DETECTION OF RECURRING NON-OCCURRENCES OF EVENTS USING PATTERN MATCHING (Attorney Docket No. 021756-058900US; OID-2008-269-02US).
  • BACKGROUND OF THE INVENTION
  • [0007]
    The present application relates to processing of data streams and more particularly to techniques for detecting the non-occurrence of an event within a time period following the occurrence of another event.
  • [0008]
    Databases have traditionally been used in applications that require storage of data and querying capability on the stored data. Existing databases are thus best equipped to run queries over finite stored data sets. However, the traditional database model is not well suited for a growing number of modern applications in which data is received as a stream of data events instead of a bounded data set. A data stream, also referred to as an event stream, is characterized by a real-time, potentially continuous, sequence of events. A data or event stream thus represents unbounded sets of data. Examples of sources that generate data streams include sensors and probes (e.g., RFID sensors, temperature sensors, etc.) configured to send a sequence of sensor readings, financial tickers, network monitoring and traffic management applications sending network status updates, click stream analysis tools, and others.
  • [0009]
    Pattern matching is commonly used for analyzing data. For example, data stored in a database may be analyzed to determine if the data matches a pattern. It is desirable to efficiently perform pattern matching on data received in the form of data or event streams.
  • BRIEF SUMMARY OF THE INVENTION
  • [0010]
    Embodiments of the present invention provide techniques for detecting non-occurrence of an event within a time period following the occurrence of another event. In one embodiment, language extensions are provided for a querying language that enable queries to be formulated for detecting non-occurrences of events.
  • [0011]
    In one embodiment, during runtime processing of a query, the query is analyzed to determine if the query is for detection of a non-occurrence of an event. If so, the pattern specified in the query is modified by suffixing a special symbol (e.g., ‘#’) to the pattern, where the ‘#’ symbol represents timer events. An FSA is then built for the modified pattern and used during runtime to guide detection of the non-occurrences.
  • [0012]
    According to an embodiment of the present invention, techniques are provided for processing a data stream of events. A query may be received for detecting non-occurrence of a first event within a time period following occurrence of a second event. The query may specify a pattern. A modified pattern is generated by adding a first symbol to the pattern specified in the query. An automaton may then be generated for the query based upon the modified pattern. An instance of non-occurrence of the first event within the time period following occurrence of the second event in the data stream may be detected using the generated automaton. One or more actions may be performed upon determining an instance of non-occurrence of the first event within a time period following occurrence of the second event. In one embodiment, the time period may be determined from the query itself.
  • [0013]
    In one embodiment, a determination is made as to whether the query is for detecting a non-occurrence of an event. Upon determining that the query is for detecting non-occurrence of an event, the pattern specified in the query by adding a first symbol to it, thereby generating a modified pattern.
  • [0014]
    In one embodiment, detecting the non-occurrences may comprise associating a target time with a binding, wherein the target time is based upon the time of the first element in the binding and the time period. An input may then be received. The input may be a heartbeat or another event received in the data stream. The time associated with the input may then be compared with the target time. Processing may then be contingent based upon the results of this comparison.
  • [0015]
    In one embodiment, if the time associated with the input equals or exceeds the target time, then the processing may force the automaton to move to a final state (force the modified pattern to be matched).
  • [0016]
    In one embodiment, the query may comprise a language extension that indicates whether or not the query is for detecting the non-occurrence of an event.
  • [0017]
    The foregoing, together with other features and embodiments will become more apparent when referring to the following specification, claims, and accompanying drawings.
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • [0018]
    FIG. 1 is a simplified block diagram of a system that incorporates an embodiment of the present invention;
  • [0019]
    FIG. 2 depicts an example of a query comprising a regular expression specifying a pattern to be matched according to an embodiment of the present invention;
  • [0020]
    FIG. 3 is a simplified flowchart depicting a method of performing pattern matching on an event stream according to an embodiment of the present invention;
  • [0021]
    FIG. 4 is a simplified flowchart depicting a method of performing pattern matching on an event stream based upon the type of the pattern according to an embodiment of the present invention;
  • [0022]
    FIG. 5 depicts an example of a query 500 identifying a Class A pattern according to an embodiment of the present invention;
  • [0023]
    FIG. 6 depicts a simplified flowchart depicting a method of maintaining bindings for Class A patterns according to an embodiment of the present invention;
  • [0024]
    FIG. 7 is a simplified flowchart depicting a method for performing pattern matching for Class A patterns after receiving each event in an event stream according to an embodiment of the present invention;
  • [0025]
    FIG. 8 is an example of a query specifying a Class B pattern but not a Class A pattern according to an embodiment of the present invention;
  • [0026]
    FIG. 9 is a simplified flowchart depicting a method for performing operations at compile time including constructing an automaton for a general Class B pattern according to an embodiment of the present invention;
  • [0027]
    FIGS. 10A and 10B depict a simplified flowchart depicting runtime processing performed for detecting a Class B pattern in an input event stream according to an embodiment of the present invention;
  • [0028]
    FIGS. 11A-11I depict various state machines for generating an automata for a regular expression according to an embodiment of the present invention;
  • [0029]
    FIGS. 12A-12D depict state machines for constructing an automata for an example regular expression according to an embodiment of the present invention;
  • [0030]
    FIG. 13 depicts an example of a query that may be used to detect the non-occurrence of an event within a time period following the occurrence of another event according to an embodiment of the present invention;
  • [0031]
    FIG. 14 depicts a simplified flowchart depicting additional processing performed at compile time for a query for detecting non-occurrences according to an embodiment of the present invention;
  • [0032]
    FIG. 15 depicts a simplified flowchart depicting processing for detecting non-occurrences according to an embodiment of the present invention.
  • [0033]
    FIG. 16 depicts an example of a query that may be used to detect recurring non-occurrences of an event according to an embodiment of the present invention;
  • [0034]
    FIG. 17 depicts a simplified flowchart depicting processing for detecting recurring non-occurrences according to an embodiment of the present invention;
  • [0035]
    FIG. 18 is a simplified block diagram illustrating components of a system environment 1800 that may be used in accordance with an embodiment of the present invention; and
  • [0036]
    FIG. 19 is a simplified block diagram of a computer system 1900 that may be used in accordance with embodiments of the present invention.
  • DETAILED DESCRIPTION OF THE INVENTION
  • [0037]
    In the following description, for the purposes of explanation, specific details are set forth in order to provide a thorough understanding of embodiments of the invention. However, it will be apparent that the invention may be practiced without these specific details.
  • [0038]
    Embodiments of the present invention provide techniques for detecting patterns in data or event streams. A pattern to be detected may be specified using a regular expression. Events received in data streams are processed during runtime to detect occurrences of the pattern specified by the regular expression in the data stream. Techniques are provided for detecting non-occurrence of an event within a time period following the occurrence of another event. In one embodiment, language extensions are provided to a language that enable queries to be formulated for detecting non-occurrences using that language.
  • [0039]
    FIG. 1 is a simplified block diagram of a system 100 that may incorporate an embodiment of the present invention. As depicted in FIG. 1, system 100 comprises an events processing server 102 that is configured to process one or more incoming data or event streams 104, 106, and 108. Streams 104, 106, and 108 may be received from different sources including a database, a file, a messaging service, various applications, devices such as various types of sensors (e.g., RFID sensors, temperature sensors, etc.), tickers, and the like. Server 102 may receive the streams via a push-based mechanism or a pull-based mechanism or other mechanisms.
  • [0040]
    A data or event stream is a real-time sequence of events. Multiple events may be received in a stream. The data stream can thus be considered as a stream of unbounded sets of data. In one embodiment, a data stream is a sequence of <tuple, timestamp> pairs. The tuple refers to the data portion of a stream. A tuple may be considered as similar to a row in a table. The tuples in a stream have a schema. A stream can include multiple tuples. Timestamps define an order over the tuples in a data stream. The timestamps in a data stream may reflect an application's notion of time. For example, the timestamp may be set by an application on the system receiving an event stream. The receiving system may timestamp an event on receipt as configured by the application, for example, if specified in the CREATE STREAM DDL that is used to define a structure of the events stream and the mechanism used to use application time or system time as the timestamp. In other embodiments, the timestamp associated with a tuple may correspond to the time of the application sending the data events. The timestamp is part of the schema of a stream. There could be one or multiple tuples with the same timestamp in a stream. The tuples in a stream can be viewed as a series of events and accordingly the data stream is also referred to as an event stream. An event stream can thus be considered to comprise a series of events, each with an associated timestamp. For example, an event stream may comprise a series of temperature readings from a sensor such as 10°, 15°, 20°, etc. and associated time stamps. For purposes of this application, the terms “tuple” and “event” are being used interchangeably.
  • [0041]
    System 100 comprises an event processing server 102 that is configured to process event streams. Event processing server 102 may receive one or more event streams. As shown in FIG. 1, event processing server 102 receives streams 104, 106, and 108. Each event stream comprises one or more events. The events in a stream are received by server 102 in a sequence at specific time points. Server 102 is configured to perform various types of processing on the incoming streams. According to an embodiment of the present invention, server 102 is configured to detect patterns in the incoming event streams based upon the events in the event streams received by server 102. In one embodiment, server 102 performs the pattern matching without doing any backtracking processing on the events of the stream being analyzed as the events are received by server 102. Pattern matching may be performed using a type of continuous query that is applied to the incoming streams. Server 102 may also perform other types of processing on the input streams such as running other continuous queries on the incoming event streams, and other operations. An example of an event processing server is the Oracle Complex Event Processor from Oracle™ Corporation.
  • [0042]
    In the embodiment depicted in FIG. 1, server 102 comprises a pattern matching module 110 that is configured to perform processing related to pattern matching for one or more event streams. As depicted in FIG. 1, pattern matching module 110 comprises a pattern input interface 112, a class-technique determinator 113, an automaton generator 114, and a matcher 116. Pattern input interface 112 provides an interface for receiving information specifying patterns to be matched in the event streams. Pattern input interface 112 may provide a graphical user interface that allows information to be entered specifying one or more patterns to be matched, a command line interface for specifying the patterns to be matched, or some other interface. A pattern to be matched may be specified by a user of server 102. Information identifying a pattern to be matched may also be received from other sources, for example, from other components or modules of event processing server 102, or other systems or applications.
  • [0043]
    In one embodiment, patterns to be matched are specified using regular expressions. A regular expression is a string of symbols (also referred to as correlation names or correlation variables) representing the pattern to be matched. The regular expression is built using one or more symbols and may use one or more operators. Examples of operators include but are not limited to a concatenation operator (e.g., an “AND” operator between symbols in a regular expression may be used to indicate an AND relationship between the symbols), alternation operator (e.g., a vertical bar “|” may separate symbols in a regular expression indicating an OR condition for the symbols), one or more quantifiers, grouping operator (e.g., indicated by parentheses), and the like. Examples of quantifiers include an asterisk ‘*’ implying zero or more occurrences of the symbol with which the quantifier is associated, a plus sign ‘+’ implying one or more occurrences of the symbol with which the quantifier is associated, a question mark ‘?’ implying zero or one occurrences of the symbol with which the quantifier is associated, reluctant quantifiers, and the like. Examples of operators and quantifiers that may be used, including associated syntax for the regular expressions, are provided and described in Fred Zemke et al., “Pattern Matching in Sequence of Rows (12),” ISO/IEC JTCi/SC32 WG3:URC-nnn, ANSI NCITS H2-2006-nnn, Jul. 31, 2007, the entire contents of which are herein incorporated by reference for all purposes.
  • [0044]
    In the past, regular expressions have been mainly used to find patterns in strings. In embodiments of the present invention, the power of regular expressions is used to match patterns in event streams received by event processing server 102. Regular expressions provide a simple, concise, and flexible way for specifying patterns to be matched. In the embodiment depicted in FIG. 1, event processing server 102 may receive pattern information 118 specifying a regular expression to be matched in one or more event streams. In one embodiment, the pattern may be specified using pattern input interface 112 of pattern matching module 110.
  • [0045]
    Pattern information 118 may be provided using different languages. In one embodiment, a programming language such as SQL, which is commonly used to query databases, may be used. Extensions may be provided to SQL to express the pattern to be matched for event streams. For example, pattern information 118 may specify a SQL query comprising a regular expression specifying a pattern to be matched in one or more event streams received by event processing server 102.
  • [0046]
    Oracle supports a CQL (Continuous Query Language) language in Complex Events Processing (CEP) products. CQL is very similar to SQL with extensions for stream processing. Pattern matching constructs proposed to extend SQL to specify pattern matching via regular expressions (e.g., the constructs described in Fred Zemke et al., “Pattern Matching in Sequence of Rows (12),” ISO/IEC JTCi/SC32 WG3:URC-nnn, ANSI NCITS H2-2006-nnn, Jul. 31, 2007, the entire contents of which are herein incorporated by reference for all purposes) have been adopted in CQL to extend CQL for the purpose of specifying pattern matching requirements over event streams.
  • [0047]
    Typically, pattern matching for a query pattern occurs only over a single input stream. Pattern matching may also be performed over multiple event streams, for example, using CQL. In one embodiment, this may be done by first performing a UNION of all the relevant input streams over which pattern matching is to be done with the result defining a view corresponding to an intermediate stream, and the pattern to be matched can be specified over this single intermediate stream. The pattern will then be matched to all the streams included in the view.
  • [0048]
    FIG. 2 depicts an example of a query 200 that may be provided specifying a pattern to be matched over an event stream according to an embodiment of the present invention. Query 200 comprises a FROM clause 202 that specifies an event stream “Ticker” over which pattern matching is to be performed. “Ticker” may represent a single event stream or a UNION of multiple streams.
  • [0049]
    Query 200 comprises a PATTERN component 203 that specifies a regular expression 204 identifying the pattern to be recognized in the event stream “Ticker”. The regular expression (A B C A B D) in query 200 comprises several symbols or correlation names. The pattern specified in FIG. 2 is an example of a simple nonrecurring pattern. It is nonrecurring since each symbol in the pattern specifies only a single occurrence of that symbol and does not include recurrences of the symbol. The alphabet set for a pattern comprises distinct symbols in the pattern. For the above example, the alphabet set is {A, B, C, D}. Each symbol in the alphabet corresponds to a variable name corresponding to a Boolean condition that is specified in the DEFINE component 206 of the query.
  • [0050]
    The DEFINE component 206 of query 200 specifies Boolean conditions (or predicates) that define the symbols declared in the regular pattern. For the example depicted in FIG. 2, the symbols declared in pattern 204 include A, B, C, and D. The predicates or Boolean conditions associated with the symbols are defined by the DEFINE component as follows:
  • [0000]
    Symbol Predicate
    A 30 <= A.price <= 40
    B B.price < PREV(B.price)
    C C.price <= PREV(C.price)
    D D.price > PREV(D.price)

    It should be understood that all symbols defined in regular expression do not require an associated predicate. A symbol with no associated predicate is by default assumed to be always matched or true. Such a symbol may be used to match any event in an event stream.
  • [0051]
    The predicates depicted above are all related to the price attribute of an event. An event may have one or more attributes. The predicates may be based upon these attributes. A particular symbol is deemed to be matched by an input event received in an event stream if the predicate associated with the symbol is matched or satisfied due to the input event. For example, symbol A in FIG. 2 is matched by a received event if the price attribute of the received event is greater than or equal to 30 and less than or equal to 40. Whether or not a predicate associated with a symbol is matched may depend on the present event and/or previously received events. For example, symbol B in FIG. 2 is matched by a received event if the price attribute of the received event is less than the price attribute of the event received just immediately preceding the presently received event. For the “Symbol” partition, when a PARTITION BY is specified (as in this example), PREV is the previous input received for that partition. A received input event in an event stream may cause zero or more symbols of the regular expression to be matched.
  • [0052]
    For the symbols and associated predicates depicted in FIG. 2:
    • (1) the symbol A is matched by an event received in the Ticker event stream if the value of the price attribute of the event is greater than or equal to 30 and less than or equal to 40;
    • (2) the symbol B is matched by an event received in the Ticker event stream if the value of the price attribute of the received event is less than the price of the event received just immediately preceding the presently received event;
    • (3) the symbol C is matched by an event received in the Ticker event stream if the value of the price attribute of the received event is less than or equal to the price of the event received just immediately preceding the presently received event; and
    • (4) the symbol D is matched by an event received in the Ticker event stream if the value of the price attribute of the received event is greater than the price of the event received just immediately preceding the presently received event. As discussed earlier, for the “Symbol” partition, when a PARTITION BY is specified (as in this example), PREV is the previous input received for that partition.
  • [0057]
    As evident from the above, matching of symbols in a regular expression to events received in an event stream is quite different from conventional pattern matching in strings using regular expressions. In event stream pattern matching, a symbol in a regular expression is considered matched by a received event only if the predicate associated with the symbol is satisfied by the event. This is unlike character string matching using regular expressions wherein a symbol is matched if that symbol itself is present in the string to be matched. Further, in event stream pattern matching, multiple predicates can be satisfied at the same time and as a result multiple symbols may be matched by a received input event. This is not the case in regular string matching. Several other differences exist between pattern matching in strings and pattern matching in event streams.
  • [0058]
    For the pattern specified in FIG. 2, the pattern corresponding to (ABCABD) is matched in the event stream when symbol A is matched, followed by a match of B, followed by a match of C, followed by a match of A, followed by a match of B, and followed by a match of D. An example of runtime pattern matching processing performed for the pattern depicted in FIG. 2 is described below.
  • [0059]
    As indicated above, a pattern may be specified using a query, such as a CQL query depicted in FIG. 2. In one embodimemt, the syntax for such a query follows the query standards specified in Fred Zemke et al., “Pattern Matching in Sequence of Rows (12),” ISO/IEC JTCi/SC32 WG3:URC-nnn, ANSI NCITS H2-2006-nnn, Jul. 31, 2007, the entire contents of which are herein incorporated by reference for all purposes. Some of the components of the query include:
    • FROM<data_stream_name>—specifies the event stream over which pattern matching is to be performed.
    • MATCH_RECOGNIZE—Clause that contains all the sub-clauses or components relevant to the pattern specification.
    • PARTITION BY—Used to specify how the event stream is to be partitioned. If this clause is not used, then all the events constitute one partition.
    • AFTER MATCH SKIP TO—This clause determines the resumption point of pattern matching after a match has been found in the event stream.
    • PATTERN—Used to specify a regular expression built using one or more symbols and may contains operators.
    • DEFINE—This component is used to specify the predicates that define the symbols declared in the pattern.
  • [0066]
    As described above, SQL extensions are provided for specifying a query for performing pattern matching over event streams. The query may comprise a regular expression identifying the pattern to be matched and predicates defining or associated with symbols in the regular expression. The extensions enhance the ability to use SQL for performing pattern matching on event streams.
  • [0067]
    Referring back to FIG. 1, pattern information 118 is provided to class-technique determinator module 113 for further processing. Class-technique determinator module 113 is configured to identify a type or class of pattern based upon information 118 and to further determine a pattern matching technique to be used for performing pattern matching for the identified pattern type or class. Pattern matching module 110 is capable of performing for different types of patterns. In one embodiment, the type of class for a pattern is determined based upon the regular expression specified in information 118 and/or based upon the predicates associated with the symbols in the regular expression. Class-technique determinator module 113 is configured to analyze the regular expression and predicates specified in information 118 and determine a pattern class or type based upon the analysis.
  • [0068]
    In one embodiment, class-technique determinator uses pattern type information 120 identifying to determine the pattern class or type for the information provided in 118. Pattern type information 120 may identify different pattern types or classes and characteristics associated with the different pattern classes. Pattern matching module 110 may use pattern type information 120 to automatically identify a particular type or class of pattern for the pattern specified in pattern information 118 from among multiple pattern classes that module 110 is capable of processing. In another embodiment, pattern type information 120 is not needed, and pattern matching module 110 may be configured to automatically determine a type of pattern by analyzing the information provided in pattern information 118.
  • [0069]
    In one embodiment, pattern matching module 110 is configured to apply different pattern matching techniques for different types or classes of patterns. After a pattern type has been determined for the pattern specified in pattern information 118, module 113 is configured to determine a particular pattern matching technique, from among multiple available techniques, that is suited for performing pattern matching for the determined pattern. In this manner, a customized pattern matching technique or a technique that is best suited for performing pattern matching for the determined pattern type is determined. This helps to improve the efficiency of the pattern matching process for specific types of patterns.
  • [0070]
    In one embodiment, class-to-technique information 124 may be provided to pattern matching module 110 identifying one or more pattern classes and one or more pattern matching techniques to be used for detecting pattern matches for each pattern class. After a class of pattern specified in pattern information 118 has been determined, pattern matching module 110 may use class-to-technique information 124 to determine a specific pattern matching technique to be used for finding matches in the event stream. For example, if the pattern is determined to be a Class A pattern, then a pattern matching technique appropriate for a Class A pattern may be used for performing the pattern matching. Whereas, if the pattern is determined to be a Class B pattern, then a pattern matching technique appropriate for a Class B pattern may be used for performing the pattern matching.
  • [0071]
    In one embodiment, the pattern matching process comprises constructing a finite state automaton (FSA) for a given pattern and then using the constructed FSA to guide the pattern matching process during runtime as events are received. Automaton generator 114 is configured to parse the input regular expression received via interface 112 and build an automaton for the pattern to be matched. One or more automata constructed by generator 114 may be stored as automata information 122. The automaton generated for a pattern is then used in runtime by matcher 116 to guide detection of the pattern in event streams 104, 106, and 108.
  • [0072]
    As previously indicated, the pattern matching process may be customized for certain classes of patterns. In one embodiment, automaton generator 114 may receive information from class-technique module 113 identifying the class of the pattern and the technique to be used for performing the pattern matching for the identified class of pattern. Automaton generator 114 may then generate an automaton using the selected pattern matching technique.
  • [0073]
    Matcher 116 is configured to process the events received in the events streams during runtime to detect occurrences of the specified pattern in the incoming event streams. Matcher 116 uses the automaton generated by automaton generator 114 to guide the pattern matching process. For each event stream, the automaton is used as a guide to indicate how much of the specified pattern is matched by the events received in the event stream at any point in time. In one embodiment, bindings are maintained by matcher 116 after each event in an event stream is processed to capture the state of partial or full matches of the pattern at any point in time. A binding is like an assignment of contiguous events (and in the case of PARTITIONS, contiguous within the PARTITION) to one or more correlation names that corresponds to a partial (or possibly full) match that satisfies all the DEFINE predicates associated with the pattern. A binding indicates that degree to which a pattern is matched as a result of the last received event. Bindings stored after receiving an event may indicate partial matches that have the potential of becoming longer matches or full matches. If a particular pattern matching technique has been selected, matcher 116 may perform the processing according to the selected technique.
  • [0074]
    Matcher 116 may be configured to take one or more actions when a particular pattern is matched or detected in an event stream. For example, when a pattern is matched, matcher 116 may send a signal indicating that the pattern has been matched. The signal may be forwarded to one or more components of events processing server 102 or some other system for further processing. In one embodiment, the action may include outputting the events that resulted in the pattern being matched.
  • [0075]
    System 100 depicted in FIG. 1 is an example of a system which may incorporate an embodiment of the present invention. Various other embodiments and variations are possible. Similarly, the various modules depicted in FIG. 1 are shown as examples and are not intended to limit the scope of the present invention. In alternative embodiments, more or less modules may be present. The various modules depicted in FIG. 1 may be implemented in software (e.g., code, program, instructions) executed by a processor, hardware, or combinations thereof. For example, in some embodiments, a separate class-technique determinator module 113 may not be provided. In such embodiments, the processing performed by module 113 may instead be performed by automaton generator 114 and matcher 116. In one such embodiment, automaton generator 114 may be configured to automatically determine a pattern class or type for the pattern specified in pattern information 118 and build an automaton. Matcher 116 may be configured to determine a pattern matching technique to be used for the determined pattern and then apply the determined technique during runtime processing of events received in an event stream.
  • [0076]
    FIG. 3 is a simplified flowchart 300 depicting a method of performing pattern matching on an event stream according to an embodiment of the present invention. In one embodiment, the method depicted in FIG. 3 is performed by pattern matching module 110 depicted in FIG. 1. The processing depicted in FIG. 3 may be performed by software (e.g., code, program, instructions) executed by a processor, in hardware, or combinations thereof. The software may be stored in a computer-readable storage medium. The method depicted in FIG. 3 may be applied to multiple event streams.
  • [0077]
    As depicted in FIG. 3, processing is initiated upon receiving information identifying a pattern to be matched (step 302). In one embodiment, the information received in 302 comprises a regular expression specifying the pattern to be matched. For example, a query may be received in 302 specifying a regular expression identifying a pattern to be matched. The information received in 302 may also identify the event streams that are to be analyzed to determine if events received in the event streams match the specified pattern. The information received in 302 may also specify predicates associated with the symbols in the regular expression.
  • [0078]
    An automaton is then constructed for the pattern received in 302 (step 304). The automaton generated in 304 may be a finite state automaton (FSA).
  • [0079]
    The automaton constructed in 304 is then used during runtime to guide the pattern matching process to detect presence of the specified pattern in the specified event streams (step 306). As part of the processing, the event streams to be analyzed are passed through a state machine corresponding to the automaton generated in 304. As part of the processing in 306, bindings are maintained after each event received in an event stream has been analyzed to store the state of pattern matches, including partial matches that have the potential to turn into full matches, after processing the received event. As previously described, a binding is used to encapsulate a full or partial pattern match and maintains references to the received events of the stream that comprise the full or partial matched pattern.
  • [0080]
    One or more actions may be performed upon detecting a pattern match in an input event stream being analyzed (step 308). The actions performed may include sending a signal indicating a match, outputting the events in the event stream that resulted in the pattern match, and other actions.
  • [0081]
    Steps 302 and 304 typically represent design time or compile time activities that are performed before the pattern matching analysis may be performed. Steps 306 and 308 represent runtime activities that are performed in real time as events in an event stream are received and processed.
  • [0082]
    As indicated above, in one embodiment of the present invention, the type or class of the pattern to be matched is determined and then used to customize the pattern matching processing. FIG. 4 is a simplified flowchart 400 depicting a method of performing pattern matching on an event stream based upon the type of the pattern according to an embodiment of the present invention. In one embodiment, the method depicted in FIG. 4 is performed by pattern matching module 110 depicted in FIG. 1. The processing depicted in FIG. 4 may be performed by software (e.g., code, program, instructions) executed by a processor, in hardware, or combinations thereof The software may be stored in a computer-readable storage medium.
  • [0083]
    As depicted in FIG. 4, processing is initiated upon receiving information identifying a pattern to be matched (step 402). The information received in 402 may comprise a regular expression identifying the pattern to be detected in an event stream and information identifying predicates associated with the one or more symbols in the regular expression.
  • [0084]
    Processing is then performed to determine a type or class of pattern for the pattern received in 402 (step 404). In one embodiment, the class of pattern may be determined based upon the regular expression received in 402 and/or the predicates defined for the symbols in the regular expression. For example, the type or class of pattern may be determined based upon the contents of the PATTERN and DEFINE clauses. Accordingly, in one embodiment, as part of the processing performed in 404, the information received in 402 is parsed to determine the contents of the PATTERN and DEFINE clauses. A type or class is then determined based upon analysis of the extracted contents.
  • [0085]
    In one embodiment, preconfigured information identifying different types of patterns and their associated characteristics may be used to facilitate the pattern type identification in 404. For example, as depicted in FIG. 1, pattern type information 120 depicted may be used to facilitate determination of the class or type. In one embodiment, pattern type information 120 may identify different types or classes of patterns and information specifying characteristics of each type and class.
  • [0086]
    A technique to be used for performing the pattern matching processing is then determined based upon the pattern class or type determined in 404 (step 406). In one embodiment, preconfigured information identifying different types of patterns and techniques to be used for each class may be used to facilitate identification of the technique in 406. For example, as depicted in FIG. 1, class-to-technique information 124 may be used to facilitate determination of a technique to be used based upon the class or type determined in 404.
  • [0087]
    Pattern matching processing is then performed by applying the technique determined in 406 (step 408). The processing performed in 408 may include constructing an an automaton for the pattern received in 402. The automaton generation may be performed according to the technique determined in 406. Accordingly, the automaton generated in 408 may be customized for the particular class or type determined in 404.
  • [0088]
    Further, as part of the processing performed in 408, the automaton that is constructed may then be used during runtime to guide the pattern matching process to detect presence of the specified pattern in a specified event stream. The pattern detection may be performed per the technique determined in 406. In this manner, a pattern matching technique that is customized for or well suited for the type or class determined in 404 is used in 408.
  • [0089]
    As part of the processing performed in 408, the events received in an event stream are processed and passed through a state machine corresponding to the automaton generated in 408. As part of the processing in 408, bindings are maintained after each received event to represent the state of pattern matches including partial matches that have the potential to turn into full matches.
  • [0090]
    One or more actions may be performed upon detecting a full pattern match in the input event stream (step 410). The actions performed may include sending a signal indicating a match, outputting event instances that resulted in the full pattern match, and other actions.
  • [0091]
    Steps 402, 404, and 406 represent design time or compile time activities that are performed before the runtime pattern matching may be performed. Steps 408 and 410 represent runtime activities that are performed in real time as events in an event stream are received and processed.
  • [0092]
    As described above, an automaton such as a finite state automaton (FSA) is generated for a pattern to be matched prior to runtime processing. For example, an automaton is generated for the pattern corresponding to the regular expression (A B C A B D) depicted in FIG. 2. In one embodiment, the automaton generated for the example in FIG. 2 has seven states including a start state Q0 and one state for each symbol position in the pattern with state Qi corresponding to pattern symbol position Pi. Since there are six symbol positions in the pattern (A B C A B D), the seven states for this pattern are Q0 (initial state), Q1 (state representing partial match of the 1st symbol “A”), Q2 (state representing partial match of the 1st and 2nd symbols “AB”), Q3 (state representing partial match of the 1st, 2nd, and 3rd symbols “ABC”), Q4 (state representing partial match of the 1st, 2nd, 3rd, and 4th symbols “ABCA”), Q5 (state representing partial match of the 1st, 2nd, 3rd, 4th, and 5th symbols “ABCAB”), and Q6 (final state representing full match of pattern “ABCABD”). The alphabet for the pattern is {A, B, C, D}. An extra symbol may be added to represent an event that does not match any of the specified symbols in the pattern. In this example, this extra symbol may be represented by letter R. Hence, the alphabet for the above pattern depicted in FIG. 2 is the set {A, B, C, D, R}.
  • [0093]
    Table A (shown below) depicts a state transition function table created for the FSA generated for the pattern identified in FIG. 2 according to an embodiment of the present invention.
  • [0000]
    TABLE A
    State Alphabet(s) Next State
    Q0 A Q1
    Q0 B, C, D, R Q0
    Q1 B Q2
    Q1 A, C, D, R Q0
    Q2 C Q3
    Q2 A, B, D, R Q0
    Q3 A Q4
    Q3 B, C, D, R Q0
    Q4 B Q5
    Q4 A, C, D, R Q0
    Q5 D Q6
    Q5 A, B, C, R Q0
  • [0094]
    In Table A, the first column shows an initial state. The third column of the table identifies a state to which a transition is made from the initial state upon receiving an event that matches the symbols identified in the second column of the table. For example, as shown by the first two rows of Table A, the FSA starts in state Q0. If an event received in the event stream causes the first symbol A in the pattern to be matched, then the FSA transitions from state Q0 to state Q1. However, if any other symbol (e.g., B, C, D, or R) is matched by the received event, then the FSA continues to be in state Q0. Likewise, when in state Q1, if the next event causes symbol B to be matched, then the FSA transitions to state Q2 and if the event matches a A, C, D, or R, then the state reverts to state Q0. In this manner, Table A specifies the automaton for the pattern identified by regular expression (A B C A B D).
  • [0095]
    The general idea for the FSA is to have one state per prefix of the pattern to be matched. There is a forward transition from a state Qi only corresponding to the matching of the symbol that when concatenated with the prefix associated with state Qi produces the prefix associated with the state Qi+1. For all other symbols the transition is to state Q0. For example consider state Q5. The prefix corresponding to this state is ABCAB. If the next event in the event stream matches the symbol D, the FSA machine will transition to state Q6 since the prefix associated with state is ABCABD which is the concatenation of ABCAB (the prefix associated with state Q5) and the matched symbol D. On the other hand, if the next event in the event stream matches the symbol C, the FSA state machine will transition to state Q0.
  • [0096]
    The FSA generated for the pattern identified by (A B C A B D) is then used at runtime to guide the detection of the specified pattern in an event stream. For purposes of illustrating how the FSA of Table A may be applied to an event stream, it is assumed that the event stream comprises events as shown below in Table B and are received in the sequence depicted in Table B. The event stream may be for example a ticker event stream comprising the price of a stock.
  • [0000]
    TABLE B
    Seq #
    0 1 2 3 4 5 6 7
    Price 36 35 35 34 32 32 31 45
    Matching A A A A A A A D
    Symbols B C B B C B
    C C C C

    As shown in Table B, events are received in sequence (as determined by the time stamp associated with each event) and have price attributes: 36, 35, 35, 34, 32, 32, 31, 45. The third row in Table B depicts, for each sequence time point, the symbols of the pattern that are matched by the price attribute of the event received at that time point. For example, at sequence #0, an event is received having a price attribute of 36 that results in symbol A being matched since 30 <=36<=40, satisfying the predicate associated with symbol A. Price 35 received at sequence #1 causes the following matches: A (since 30<=35<=40), B (since 35<36 (the previous price)), and C (since 35<=36 (the previous price)). Likewise, price 35 received at seq #2 results in the following matches: A (since 30<=35<=40) and C (since 35<=35). Price 34 received at seq #3 results in the following matches: A (since 30<=34<=40), B (since 34<35) and (since 34<=35). Price 32 received at seq #4 results in the following matches: A (since 30<=32<=40), B (since 32<34), and C (since 32<=35). Price 32 received at seq #5 results in the following matches: A (since 30<=32<=40) and C (since 32<=32). Price 31 received at #6 results in the following matches: A (since 30<=31<=40), B (since 31<32), and C (since 31<=32). Price 45 received at seq #7 results in the following matches: only D (since 45>31).
  • [0097]
    Table C shows the state of the FSA (of Table A) after receipt of each event in the event stream according to the sequence indicated in Table B.
  • [0000]
    TABLE C
    Matched
    Seq # Price Symbol State of FSA Stored Bindings
    {Q0} Q0: (*, *, *, *, *, *)
    0 36 A {Q0, Q1} Q0: (*, *, *, *, *, *)
    Q1: (0, *, *, *, *, *)
    1 35 A {Q0, Q1, Q2} Q0: (*, *, *, *, *, *)
    B Q1: (1, *, *, *, *, *)
    C Q2: (0, 1, *, *, *, *)
    2 35 A {Q0, Q1, Q3} Q0: (*, *, *, *, *, *)
    C Q1: (2, *, *, *, *, *)
    Q3: (0, 1, 2, *, *, *)
    3 34 A {Q0, Q1, Q2, Q4} Q0: (*, *, *, *, *, *)
    B Q1: (3, *, *, *, *, *)
    C Q2: (2, 3, *, *, *, *)
    Q4: (0, 1, 2, 3, *, *)
    4 32 A {Q0, Q1, Q2, Q3, Q5} Q0: (*, *, *, *, *, *)
    B Q1: (4, *, *, *, *, *)
    C Q2: (3, 4, *, *, *, *)
    Q3: (2, 3, 4, *, *, *)
    Q5: (0, 1, 2, 3, 4, *)
    5 32 A {Q0, Q1, Q3, Q4} Q0: (*, *, *, *, *, *)
    C Q1: (5, *, *, *, *, *)
    Q3: (3, 4, 5, *, *, *)
    Q4: (2, 3, 4, 5, *, *)
    6 31 A {Q0, Q1, Q2, Q3, Q5} Q0: (*, *, *, *, *, *)
    B Q1: (6, *, *, *, *, *)
    C Q2: (5, 6, *, *, *, *)
    Q4: (3, 4, 5, 6, *, *)
    Q5: (2, 3, 4, 5, 6, *)
    7 45 D {Q0, Q6} Q0: (*, *, *, *, *, *)
    Q6: (2, 3, 4, 5, 6, 7)
  • [0098]
    The first column of Table C “Seq #” identifies the sequence number indicating the sequence time point at which an event is received. The second column “Price” indicates, for each sequence, the value of the price attribute of the event received in the event stream in that sequence point. The third column “Matched Symbol” identifies, for each event, the symbol or correlation name(s) that is matched by the event received at the sequence. Zero or more symbols may be matched by an event. The fourth column “State of FSA” identifies, for each sequence, the different states in which the FSA may be in after processing the event received in that sequence. The fifth column “Stored Bindings”, for each sequence time point, indicates the bindings that are stored for a sequence time point after processing an event received at that sequence time point. Each binding identifies a partial or full match of the pattern to be matched. In Table C, each binding identifies a state representing a partial or full match after processing an event. Each binding also identifies the events that cause the binding to be in that state. For example, a binding Q2: (2,3,*,*,*,*) represents a partial match (of the first two symbols) of the pattern being matched and corresponds to the FSA being in state Q2 due to prices associated with events received in seq #2 and seq #3. As another example, a binding Q3: (3,4,5,*,*,*) indicates that the binding corresponds to the FSA being in state Q3 due to a partial match due to prices associated with events received in sequences #3, #4, and #5. A Q0: (*,*,*,*,*,*) indicates a binding corresponding to the Q0 state, which is the starting state, and represents no match of the pattern being matched.
  • [0099]
    Bindings stored after processing an event encapsulate partial or full matches. A binding indicates that degree to which a pattern is matched as a result of the last received event. Bindings stored after receiving an event may indicate partial matches that have the potential of becoming longer matches or full matches. They contain the mapping information between a symbol and the event from the stream. At any point in time, for the pattern identified by regular expression depicted in FIG. 2, one instance of a binding is maintained per state that the machine is in. For example, after seq #3, four bindings are maintained, one binding for each of states Q0, Q1, Q2, and Q4. This follows from the construction of the FSA. Each state of the FSA corresponds to a unique prefix of the pattern. For the simple pattern (A B C A B D), the length of the prefix associated with each state is fixed. The number of elements in the binding associated with a state that are not ‘*’, i.e., they are valid event associations, is equal to the length of the pattern prefix associated with the state. The set of valid event associations in a binding are always contiguous events of the event stream and are the last k events of the event stream, where k is the length of the pattern prefix associated with the state. Accordingly, exactly one instance of a binding is maintained per state that the FSA machine is in after receiving each event. As will be discussed below in further detail, for certain type of patterns, like the pattern depicted in FIG. 2, the number of bindings at any point in time is bound from above by the number of possible states of the FSA, which is one plus the number of symbols in the regular expression specifying the pattern. Accordingly, for the regular expression (A B C A B D), the maximum number of bindings that are maintained at any time is 6+1=7. A binding can be thought of as a vector of length m, with position i of the vector corresponding to the symbol Pi of the pattern. Its sequence number in the event stream indicates the event that is bound to this position.
  • [0100]
    The processing depicted in Table C may be described as follows:
  • [0101]
    (1) The FSA starts in state Q0.
  • [0102]
    (2) At seq #0, an event is received with price 36. This results in a match with symbol A and causes the FSA to be in two possible states Q0 and Q1. The binding corresponding to state Q0 is Q0: (*,*,*,*,*,*) indicating that the binding represents no partial pattern match. The binding corresponding to this state is Q1: (0,*,*,*,*,*) indicating that the binding represents a partial pattern match (“A”) due to the event received in seq #0.
  • [0103]
    (3) At seq #1, an event is received with price 35. This results in a match with symbols A, B, and C and causes the FSA to be in three possible states Q0, Q1, and Q2. The binding corresponding to state Q0 is Q0: (*,*,*,*,*,*) indicating that the binding represents no partial pattern match. The binding corresponding to state Q1 is Q1: (1,*,*,*,*,*) indicating that the binding represents a partial pattern match (“A”) due to the event received in seq #1. The binding corresponding to state Q2 is Q2: (0,1,*,*,*,*) indicating that the binding represents a partial pattern match (“AB”) due to the events received in seq #0 and seq #1.
  • [0104]
    (4) At seq #2, an event is received with price 35. This results in a match with symbols A and C and causes the FSA to be in three possible states Q0, Q1, and Q3. The binding corresponding to state Q0 is Q0: (*,*,*,*,*,*) indicating that the binding represents no pattern match. The binding corresponding to state Q1 is Q1: (2,*,*,*,*,*) indicating that the binding represents a partial pattern match (“A”) due to the event received in seq #2. The binding corresponding to state Q3 is Q3: (0,1,2,*,*,*) indicating that the binding represents a partial pattern match (“ABC”) due to the events received in seq #0, seq #1, and seq #2.
  • [0105]
    (5) At seq #3, an event is received with price 34. This results in a match with symbols A, B, and C and causes the FSA to be in four possible states Q0, Q1, Q2, and Q4. The binding corresponding to state Q0 is Q0: (*,*,*,*,*,*) indicating that the binding represents no pattern match. The binding corresponding to state Q1 is Q1: (3,*,*,*,*,*) indicating that the binding represents a partial pattern match (“A”) due to the event received in seq #3. The binding corresponding to state Q2 is Q2: (2,3,*,*,*,*) indicating that the binding represents a partial pattern match (“AB”) due to the events received in seq #2 and seq #3. The binding corresponding to state Q4 is Q4: (0,1,2,3,*,*) indicating that the binding represents a partial pattern match (“ABCA”) due to the events received in seq #0, seq #1, seq #2, and seq #3.
  • [0106]
    (6) At seq #4, an event is received with price 32. This results in a match with symbols A, B, and C and causes the FSA to be in five possible states Q0, Q1, Q2, Q3, and Q5. The binding corresponding to state Q0 is Q0: (*,*,*,*,*,*) indicating that the binding represents no pattern match. The binding corresponding to state Q1 is Q1: (4,*,*,*,*,*) indicating that the binding represents a partial pattern match (“A”) due to the event received in seq #4. The binding corresponding to state Q2 is Q2: (3,4,*,*,*,*) indicating that the binding represents a partial pattern match (“AB”) due to the events received in seq #3 and seq #4. The binding corresponding to state Q3 is Q3: (2,3,4,*,*,*) indicating that the binding represents a partial pattern match (“ABC”) due to the events received in seq #2, seq #3, and seq #4. The binding corresponding to state Q5 is Q5: (0,1,2,3,4,*) indicating that the binding represents a partial pattern match (“ABCAB”) due to the events received in seq #0, seq #1, seq #2, seq #3, and seq #4. It should be noted here that binding Q5 is just one match from a complete pattern match.
  • [0107]
    (7) At seq #5, an event is received with price 32. This results in a match with symbols A and C and causes the FSA to be in four possible states Q0, Q1, Q3, and Q4. The binding corresponding to state Q0 is Q0: (*,*,*,*,*,*) indicating that the binding represents no pattern match. The binding corresponding to state Q1 is Q1: (5,*,*,*,*,*) indicating that the binding represents a partial pattern match (“A”) due to the event received in seq #5. The binding corresponding to state Q3 is Q3: (3,4,5,*,*,*) indicating that the binding represents a partial pattern match (“ABC”) due to the events received in seq #3, seq #4, and seq #5. The binding corresponding to state Q4 is Q4: (2,3,4,5,*,*) indicating that the binding represents a partial pattern match (“ABCA”) due to the events received in seq #2, seq #3, seq #4, and seq #5.
  • [0108]
    (8) At seq #6, an event is received with price 31. This results in a match with symbols A, B, and C and causes the FSA to be in five possible states Q0, Q1, Q2, Q4, and Q5. The binding corresponding to state Q0 is Q0: (*,*,*,*,*,*) indicating that the binding represents no pattern match. The binding corresponding to state Q1 is Q1: (6,*,*,*,*,*) indicating that the binding represents a partial pattern match (“A”) due to the event received in seq #6. The binding corresponding to state Q2 is Q2: (5,6,*,*,*,*) indicating that the binding represents a partial pattern match (“AB”) due to the events received in seq #5 and seq #6. The binding corresponding to state Q4 is Q4: (3,4,5,6,*,*) indicating that the binding represents a partial pattern match (“ABCA”) due to the events received in seq #3, seq #4, seq #5, and seq #6. The binding corresponding to state Q5 is Q5: (2,3,4,5,6,*) indicating that the binding represents a partial pattern match (“ABCAB”) due to the events received in seq #2, seq #3, seq #4, seq #5, and seq #6.
  • [0109]
    At seq #7, an event is received with price 45. This results in a match with symbol D and causes the FSA to be in two possible states Q0 and Q6. The binding corresponding to state Q0 is Q0: (*,*,*,*,*,*) indicating that the binding represents no partial pattern match. The binding corresponding to state Q6 is Q6: (2,3,4,5,6,7) indicating that the binding represents a full pattern match (“ABCABD”) due to the event received in seq #2, seq #3, seq #4, seq #5, seq #6 and seq #7.
  • [0110]
    State Q6, that is reached after the event in seq #7, represents that final state of the FSA representing a full pattern match. In the above example, the full pattern is matched due to events received in sequences 2, 3, 4, 5, 6, and 7. The events received at these sequence are italicized in Table B and in Table C and their corresponding states that resulted in a full match have been underlined. One or more actions may be initiated after the pattern match. The actions may include outputting the events that resulted in the final state. For the pattern indicated in FIG. 2, after the final state is reached, the state of the FSA machine is set back to {Q0}, the initial state. This is done since the length of the matching bindings at the final state is always fixed.
  • [0111]
    After a match is found, the resumption point of the pattern matching is determined based upon the AFTER MATCH SKIP TO clause (shown in FIG. 2) in the query. With reference to a match contained in another full match, the AFTER MATCH SKIP TO clause determines if overlapping matches are to be reported. By default, the AFTER MATCH SKIP TO clause is set to TO PAST LAST ROW, which indicates that once a match is obtained, overlapping partial matches are discarded and pattern matching is resumed anew. For details on the AFTER MATCH SKIP TO clause, please refer to Fred Zemke et al., “Pattern Matching in Sequence of Rows (12),” ISO/IEC JTCi/SC32 WG3:URC-nnn, ANSI NCITS H2-2006-nnn, Jul. 31, 2007.
  • [0112]
    An interesting thing to note in the above example is the transitions that occur after processing the event at seq #5. After the event received at seq #4, the FSA is one event away from a full pattern match. However, the event received at seq #5 does not complete a full pattern match. However, binding Q3: (2,3,4,*,*,*) representing a partial match (“ABC”) after seq #4 is progressed to a Q4: (2,3,4,5,*,*) binding after seq #5 representing a partial match (“ABCA”).
  • [0113]
    As described above, pattern matching after receiving an event is performed based upon the received event and events received prior to the received event. The bindings that are stored after processing of an event enable the pattern matching to be performed without backtracking or re-scanning of the received events. In one embodiment, an event is processed upon its receipt by server 102. After an event is received and processed, the extent to which the pattern specified by the regular expression is matched based upon the most recently received event and one or more events received prior to the most recently received event is determined. The bindings stored after receipt and processing of an event encapsulate the extent of the matches. The bindings stored after the receipt of the last received event are then used to determine pattern matches after receipt of the next event. As a result of the use of bindings, the one or more events that have been received prior to the most recently received event do not have to be processed again for the pattern matching processing. In this manner, for purposes of pattern matching, an event is processed only once upon receipt of the event by server 102. After an event has been received and processed, the event does not have to be processed again as more events are received by server 102. The bindings after a sequence store the match information that is used for evaluating the DEFINE predicates and evaluating the MEASURES clause on obtaining a full match. In this manner, backtracking of events is not performed for the pattern matching according to an embodiment of the present invention.
  • [0114]
    As another example, consider the sequence of events depicted in Table D and the matched symbols:
  • [0000]
    TABLE D
    Seq No.
    0 1 2 3 4 5 6 7 8
    Price 36 25 25 34 25 25 31 25 45
    Matching A B C A B C A B D
    Symbols C D C D C
  • [0115]
    Table E shows the state of the FSA (of Table A) after receipt of each event in an event stream according to the sequence indicated in Table D.
  • [0000]
    TABLE E
    Seq # Price Matched Symbol State of FSA Stored Bindings
    {Q0} Q0: (*, *, *, *, *, *)
    0 36 A {Q0, Q1} Q0: (*, *, *, *, *, *)
    Q1: (0, *, *, *, *, *)
    1 25 B {Q0, Q2} Q0: (*, *, *, *, *, *)
    C Q2: (0, 1, *, *, *, *)
    2 25 C {Q0, Q3} Q0: (*, *, *, *, *, *)
    Q3: (0, 1, 2, *, *, *)
    3 34 A {Q0, Q1, Q4} Q0: (*, *, *, *, *, *)
    D Q1: (3, *, *, *, *, *)
    Q4: (0, 1, 2, 3, *, *)
    4 25 B {Q0, Q2, Q5} Q0: (*, *, *, *, *, *)
    C Q2: (3, 4, *, *, *, *)
    Q5: (0, 1, 2, 3, 4, *)
    5 25 C {Q0, Q3} Q0: (*, *, *, *, *, *)
    Q3: (3, 4, 5, *, *, *)
    6 31 A {Q0, Q1, Q4} Q0: (*, *, *, *, *, *)
    D Q1: (6, *, *, *, *, *)
    Q4: (3, 4, 5, 6, *, *)
    7 25 B {Q0, Q2, Q5} Q0: (*, *, *, *, *, *)
    C Q2: (6, 7, *, *, *, *)
    Q5: (3, 4, 5, 6, 7, *)
    8 45 D {Q0, Q6} Q0: (*, *, *, *, *, *)
    Q6: (3, 4, 5, 6, 7, 8)
  • [0116]
    As depicted in Table E, the final state Q6 is reached due to events received at sequence numbers 3, 4, 5, 6, 7, and 8. The events resulting in a full match are italicized in the second column and the corresponding symbols that result in the match are underlined in the third column.
  • Class A Patterns
  • [0117]
    As indicated above, the technique used for performing pattern matching may be different for different types or classes of patterns. This section describes a pattern matching technique used for a specific simplified pattern referred to as a Class A pattern. The customized processing described in this section may be applied for detecting Class A patterns in one or more event streams.
  • [0118]
    In one embodiment, a Class A pattern is defined as follows:
    • Let the pattern to be matched be P=(P1, P2, . . . , Pm), where m>=1.
    • A Class A pattern is one where each Pi is only one of the following:
      • Ci—a symbol without any quantifier
      • Ci*—a symbol followed by a greedy * quantifier, indicating zero or more occurrences of Ci
      • Ci+—a symbol followed by a greedy + quantifier, indicating one or more occurrences of Ci
      • Ci?—a symbol followed by a greedy ? quantifier, indicating zero or one occurrences of Ci
  • [0125]
    Further, for a Class A pattern, the predicate defined for a symbol cannot be dependent on any other symbols. In other words, the predicate for a symbol has to be independent of other symbols. Accordingly, a predicate defined for a symbol in a Class A pattern does not include other symbols. For example, the predicate for a symbol A cannot have the following predicate (A.price<B.price) in which the predicate for A is dependent on symbol B. Also, aggregation operators (e.g., sum) over the same symbol are not permitted in the DEFINE clause for a Class A pattern. Further, for Class A patterns, only the regular expression concatenation operator is allowed to link the symbols in the regular expression, as shown above. Other, regular expression operators such as ALTERNATION (or |) and GROUPING are not permitted.
  • [0126]
    As described above, in order for a pattern specified in a query to be classified as a Class A pattern, the pattern and the predicates associated with symbols in the pattern have to satisfy certain restrictions described above. Accordingly, as part of determining a pattern type for a pattern specified in a query, pattern matching module 110 is configured to extract the regular expressions and predicates from the query and determine if the various characteristics (limitations) of a Class A pattern are satisfied. The pattern is classified as a Class A pattern only if the restrictions are satisfied. This processing may be performed, for example, in step 404 depicted in FIG. 4.
  • [0127]
    Without loss of generality, it can be assumed that each Ci is distinct (although this is not a requirement for Class A patterns). It can be shown that the other cases, where the Ci's are not distinct, can be reduced to an instance of the case where the Ci's are distinct. This can be done by, for each repetition, replacing the repeated symbol with a new symbol defined using the same predicate.
  • [0128]
    The example query 500 depicted in FIG. 5 depicts an example of a Class A pattern and will be used to illustrate detection of Class A patterns in an event stream according to an embodiment of the present invention. Query 500 comprises a regular expression 502 (AB*C) specifying the pattern to be detected. The pattern specified by regular expression 502 is an example of a recurring pattern due to the B* portion since it specifies zero or more recurrences of B. The predicates for the symbols A, B, and C are defined by DEFINE clause 504. As can be seen in FIG. 5, the predicate for each symbol is defined such that it is not dependent on any other symbol. In other words, a predicate for a symbol does not include other symbols. For example, the predicate for A does not include B, or C.
  • [0129]
    Pattern matching module 110 is configured to analyze query 500 as specifying a pattern that is a Class A pattern. Upon recognizing a pattern as a Class A pattern, pattern matching module 110 is configured to determine and apply a technique that is specified for Class A pattern processing. In one embodiment, according to the selected technique, a finite state automaton (FSA) is created for the pattern. The following definitions are introduced to formally describe the structure of the automaton.
  • [0130]
    Let Σ (alphabet)={Ci|1≦i≦m}
    • Let ei denote the ith event of the input event stream
    • Let C(i)Σ be defined as C(i)={Ci|ei satisfies the predicate defining correlation name Ci}
    • FOLLOW(i), for 0≦i≦m, is defined as follows
  • [0134]
    FOLLOW(m)={$} where $ is a special symbol
  • [0135]
    For 0≦i≦m−1,
  • [0000]
    FOLLOW ( i ) = FOLLOW ( i + 1 ) C i + 1 if ( P i + 1 = C i + 1 * or P i + 1 = C i + 1 ? ) = C i + 1 otherwise
  • [0136]
    The automaton corresponding to the pattern M(P) =(Q, Σ, δ, Q0, F) is defined as follows:
  • [0000]

    Q=Q0∪{Qi|1≦i≦m}.
  • [0000]
    Intuitively, there is one initial state and then one state per pattern symbol (or per correlation name since it is assumed without loss of generality that the symbols are distinct).
  • [0137]
    Σ is the alphabet given by Σ={Ci|1≦i≦m}
  • [0138]
    δ is the state transition function (defined in detail below)
  • [0139]
    Q0 is the initial state
  • [0140]
    F is the set of final states; F={Qi|QiεQ and FOLLOW(i) contains $}
  • [0141]
    The state transition function for a state Qi, for 0≦i≦m, is defined as follows:
  • [0000]
    δ ( Qi , Cj ) = Qj where j > i and Cj FOLLOW ( i ) - { $ } = Qi if P i = C i * or P i = C i + = Q 0 otherwise
  • [0142]
    Applying the above construction technique to the example depicted in FIG. 5 yields the following automaton:
  • [0000]

    FOLLOW(3)={$}
  • [0000]

    FOLLOW(2)={C}
  • [0000]

    FOLLOW(1)={C, B}
  • [0000]

    FOLLOW(0)={A}
  • [0143]
    Table F depicts the state transition for the automaton constructed for the pattern specified in FIG. 5.
  • [0000]
    TABLE F
    State Alphabet Next State
    Q0 A Q1
    Q1 B Q2
    Q1 C Q3
    Q2 C Q3
    Q2 B Q2
    All other transitions lead to the next state of Q0.
  • [0144]
    The following observation follows directly from the construction above:
      • (1) If state QiεF, then for all j>i, QjεF
      • (2) If δ(Qi, Cj)!=Q0 for j>i, then δ(Qi−1, Cj) also !=Q0
  • [0147]
    The FSA constructed for the Class A pattern is then used during pattern matching to guide detection of the specified Class A pattern in event streams during runtime processing. Table G depicts an example of an input event stream for illustrating the processing that occurs at runtime for detecting a Class A pattern. As with previous examples, Table G indicates the sequence in which events are received in the event stream. For each event, the table shows the position of the event in the event stream, the price attribute of the event, and, for each sequence point, the symbols that are matched by the input event received at that sequence point. A symbol is considered matched by an event if the predicate associated with the symbol is satisfied by the event. As explained below, the underlined items in Table G constitute an instance of a full pattern match for pattern (AB*C).
  • [0000]
    TABLE G
    Seq No.
    1 2 3 4 5
    Price 40 20 10 10 40
    Matching A A A A A
    Symbols B B B
    C C
  • [0148]
    During runtime, the FSA machine of Table F is used to detect the specified pattern in any one of several events based upon the prices associated with the input events. For a Class A pattern, multiple event matches may arise due to the non-determinism (since one event may match multiple correlation names) in the input events. For example, in the above example, upon receiving event e5, the FSA machine is (logically) looking for a pattern match in one of 18 event matches such as {AAAAA, AAABA, AAACA, ABAAA . . . }.
  • [0149]
    At every point in time (i.e., at any sequence number), after processing an input event ei, the state of the automaton machine may be defined as follows:
  • [0000]

    S(i)={q|qεQ} with S(0)={Q0}
  • [0000]
    Now S(i+1) is given as follows:
  • [0000]

    S(i+1)=∪qεS(i){δ(q, a) where aεC(i+1)}UNION Q0
  • [0000]
    Accordingly, for each state in S(i), the next state is found for each symbol that the input event can be bound to. S(i+1) represents the union of all these states. Maintaining S(i) is the way to simulate simultaneous detection of the pattern in any one of several matches. This may be implemented by maintaining S(i) at any point in the manner described above with the addition that Q0 is always in S(i).
  • [0150]
    Table H shown below illustrates application of the automaton depicted in Table F to the events received according to Table G.
  • [0000]
    TABLE H
    Seq # Event
    ei (price) Matching Symbol State of FSA
    {Q0}
    1 40 A {Q0, Q1}
    2 20 A {Q0, Q1, Q2}
    B
    3 10 A {Q0, Q1, Q2, Q3}
    B
    C
    4 10 A {Q0, Q1, Q2, Q3}
    B
    C
    5 40 A {Q0, Q1}
  • [0151]
    As depicted in Table H, the event received at seq #1 (price=40) results in symbol A being matched and causes the FSA to be in states Q0 and Q1 (“A”). The event received at seq #2 (price=20) results in symbols A and B being matched and causes the FSA to be in states Q0, Q1 (“A”), and Q2 (“AB*”). The event received at seq #3 (price=10) results in symbols A, B, and C being matched and causes the FSA to be in states Q0, Q1 (“A”), Q2 (“AB*”), and Q3 (“AB*C”). Since Q3 is the final state (underlined in Table H), it indicates a full pattern match for pattern AB*C. Even though a full pattern match has been found, in one embodiment, the full pattern match is not output and pattern matching continues to find the longest pattern match. The event received at seq #4 (price=10) results in symbols A, B, B and C being matched and causes the FSA to be in states Q0, Q1, Q2, and Q3. Since Q3 is the final state, it again indicates a match for pattern AB*C. The event received at seq #5 (price=40) results in symbol A being matched and causes the FSA to be in states Q0, and Q1. At this point, there is no longer match possible and the matched pattern at seq #4 is output. In this manner, pattern matching on the input events is performed.
  • [0152]
    For a Class A pattern, preferment rules are used to determine which matches to store. For example, all matches may be stored or only the longest match may be stored. Rules that control such behavior are referred to as preferment rules. In one embodiment, preferment may be given to matches based upon the following priorities:
    • (1) A match that begins at an earlier event is preferred over a match that begins at a later event.
    • (2) Of two matches matching a greedy quantifier, the longer match is preferred.
    • (3) Of two matches matching a reluctant quantifier, the shorter match is preferred.
      Matches are then chosen and maintained per the preferment rules. For information on preferment rules, please also refer to Fred Zemke et al., “Pattern Matching in Sequence of Rows (12),” ISO/IEC JTCi/SC32 WG3:URC-nnn, ANSI NCITS H2-2006-nnn, Jul. 31, 2007. For example, in the example of Table H, if seq #5 were to evaluate to a C, then the longest match would be A B B B C (since seq #4 also evaluates to a B) and not the current A B B C. Further, if seq #5 were a C, then as per the default SKIP clause (which is SKIP PAST LAST ROW), the overlapping match A B B C would not be reported.
  • [0156]
    Bindings are maintained to facilitate the pattern matching without performing backtracking on the input events. A binding indicates that degree to which a pattern is matched as a result of the last received event. Bindings stored after receiving an event may indicate partial matches that have the potential of becoming longer matches or full matches. For simple non-recurring patterns, as specified in FIG. 2 and described above, for a state Qi, the length of the binding (the number of non-star elements in the binding, i.e., the number of elements that have an associated event from the stream mapped) is “i” and since this is always the last “i” events of the event stream, the binding is unique for a state and thus there is one binding per state. However, for recurring patterns, such as the pattern specified in FIG. 5, there could be multiple bindings applicable for a given state at any point in time. For example in Table H, after processing e3 (i.e., event received at seq #3 ) for state Q2 (state representing matching of the first two symbols of the pattern), both (1) (A=2, B=3) (i.e., A matched by the event at seq #2 and B matched by the event at seq #3 ) and (2) (A=1, B=2, B=3) are valid bindings. However, since the predicate defining a symbol is defined independent of other symbols (a feature of Class A patterns), it follows that the set of symbols that an event can be bound to is independent of the current bindings. This is a feature of Class A patterns (and as will be described below differentiates it from Class B patterns).
  • [0157]
    As is evident from the above, a full match state for a Class A pattern may have multiple bindings associated with it. Preferment rules may be preconfigured for the pattern matching system for selecting a particular binding from the multiple bindings. For example, as depicted in FIG. 1, preferment rules 126 may be configured that are used by pattern matching module 110 to select which binding, from among many, to select. In one embodiment, these preferment rules may be configured to follow the preferment rules defined by a specification being supported by the pattern matching system. For example, the preferment rules for an embodiment of the present invention may be configured to follow and support the preferment rules defined by the “Pattern Matching in Sequences of Rows (12)” specification. Preferment rules may be preconfigured for the pattern matching system specifying rules for selecting a partial binding for a state for further processing from among multiple partial bindings associated with that state.
  • [0158]
    Since an FSA is a right-invariant equivalence relation over Σ* (that is if xRMy then xzRMyz for strings x,y and any string z), and the preferment rules used for the processing are prefix based, only one of these bindings needs to be maintained (for the SKIP PAST LAST ROW case). From the above, it follows that the number of active bindings stored at any point in time for a Class A pattern is bound by the number of states and is one plus the length of the specified pattern, i.e., one plus the number of symbol positions in the specified Class A pattern. For example, for the pattern AB*C, the maximum number of bindings maintained at any point is 3+1=4 bindings. Thus, in the default SKIP case (SKIP PAST LAST ROW) where the requirement is NOT to report overlapping matches, after processing every input event, there need be at most only one binding per state of the automaton.
  • [0159]
    For example, consider the previous example depicted in Table H where after the event received at seq #3 (referred as e3), there are two possible bindings that are associated with state Q2: (1) (A=2, B=3) and (2) (A=1, B=2, B=3). Now suppose “x” is the sequence of events corresponding to the first binding (i.e., x=(A=2, B=3)) and “y” is the sequence of events corresponding to the second binding (i.e., y=(A=1, B=2, B=3)), then for every following sequence of events “z”, both “xz” and “yz” will be in the same state of the automaton. This indicates right equivalence. The reason for this is due to the nature of a Class A pattern where predicates are independent of other symbols and hence the set of correlation names or symbols that an event can be bound to is independent of binding context.
  • [0160]
    Further, it can be shown that, whenever, “xz” is in final state, “yz” would be the match preferred over the match “xz” if and only if “y” is preferred over “x” per the preferment rules. Hence, it suffices to maintain the second binding (corresponding to “y”) and discard the first binding (corresponding to “x”) after processing input event e3, for state Q2.
  • [0161]
    For simple non-recurring patterns as specified in FIG. 2 and described above, when a state S(i) contains a final state (a state that is a member of F), the binding associated with the state is immediately output and S(i) is reset to {Q0}. This could be done since the length of matching bindings was always fixed, which meant that one could not get two matching bindings where one was properly contained in the other. In the case of simple recurring patterns as depicted in FIG. 5, it is possible to get two matches where one is properly contained in the other. For instance, in the example above, after processing e3, S(i) contains the final state Q3. For example, if the associated binding is (A=1, B=2, C=3), it cannot be concluded at this point that this is part of the output since the binding (A=1, B=2, B=3) could develop into a longer match that would take precedence over (A=1, B=2, C=3) by the preferment rules. This is exactly what happens after processing e4.
  • [0162]
    Based on the above, in one embodiment, bindings may be classified into 3 categories:
    • (1) Matched and reported bindings: These are bindings that constitute a full pattern match and are output;
    • (2) Matched but unsure bindings: These are bindings that constitute a full pattern match but there are other partial matches that could develop into matches and contain this binding. Hence, these bindings are not output at this point in time;
    • (3) Partial matches: These are bindings that are partial matches that have the potential to become full matches.
  • [0166]
    Further, the following may be defined for bindings:
    • Let “b” be a binding.
    • Interval of a binding INT(b)=(i,j) where i is the least sequence number of an event that is part of this binding and j is the highest sequence number of an event in the binding. For example, for the binding b=(A=1, B=2, C=3), INT(b)=(1,3)
    • Left(b)=i where INT(b)=(i,j)
    • Right(b)=j where INT(b)=(i,j)
    • Length(b)=j−i+1 where INT(b)=(i,j)
    • For a set TB of bindings, min(TB)={min left(b)|bεTB}, max(TB)={max right(b)|bεTB}
  • [0173]
    Based upon the above, it can be shown that in the case of Class A recurrent patterns as specified in FIG. 5, there can be at most one binding that is in the matched but unsure category at any point in time. Further, we can show that left(d)=min(TB) (where ‘d’ is the unique binding in the matched but unsure category). This essentially follows from the above based on the structure of the automaton constructed.
  • [0174]
    Accordingly, maintaining bindings during runtime processing essentially involves maintaining the vector (d, B) where d is the binding (if any) in the matched but unsure category and B is the set of partial match bindings. On processing ei, let F1 denote the set of final states in S(i) and let B1 denote the set of bindings associated with the states in F1. FIG. 6 depicts a simplified flowchart 600 depicting a method of maintaining bindings for Class A patterns according to an embodiment of the present invention. The method may be performed by software (program, code, instructions executed by a processor), in hardware, or combinations thereof. In one embodiment, the processing is performed by matcher 116 depicted in FIG. 1.
  • [0175]
    As depicted in FIG. 6, a determination is to check if F1 and d are empty or non-empty (step 602). Here, “d” refers to the value of the symbol after processing event e(i−1) and “F1” refers to the set after processing event ei. B corresponds to the set of partial match bindings after processing event ei. Processing is then performed based upon the determinations in 602. There can be one of four situations:
    • (1) If F1 and d are both determined to be empty, then the set of stored bindings B is updated (step 604). Accordingly, on processing ei, there will be a change to the set of stored bindings and B is updated. Nothing else is done in 604.
    • (2) If F1 is determined to be non-empty and d is determined to be empty, then among the bindings in B1, a unique binding b is picked after applying preferment rules (step 606). A determination is then made if left(b) is less than min(B) and if there is no transition from the final state corresponding to b (step 608). If the condition is 608 is met, then b is output and all bindings h from B and their corresponding states from S(i) are removed except for Q0 (step 610). If the condition in 608 is not satisfied then it implies that left(b)=min(B) since it is not possible that left(b)>min(B). In this case, d is set to b and all bindings h from B where left(h)>left(b) are removed and also all their corresponding states from S(i) are removed, except for Q0 (step 612).
    • (3) If F1 is non-empty and d is non-empty, then the old d is discarded (step 614). Processing then proceeds with step 606.
    • (4) If F1 is empty, d is non-empty, then if left(d)<min(B) (step 616), d is output (step 618) and then set to null (step 620). Else (i.e., left(d)==min(B), since left(d) cannot be greater than min(B)), then nothing is done.
  • [0180]
    Table I shown below depicts the processing after receipt of each event according the automaton depicted in Table F.
  • [0000]
    TABLE I
    State Matched but
    Si Ei C S(i) Update Bindings Apply Preferment Partial Bindings unsure Output
    {Q0} Q0: ( ) Q0: ( ) Q0: ( )
    1 40 A {Q0, Q0: ( ) Q0: ( ) Q0: ( )
    Q1} Q1: (A = 1) Q1: (A = 1) Q1: (A = 1)
    2 20 A {Q0, Q0: ( ) Q0: ( ) Q0: ( )
    B Q1, Q1: (A = 2) Q1: (A = 2) Q1: (A = 2)
    Q2} Q2: (A = 1, B = 2) Q2: (A = 1, B = 2) Q2: (A = 1, B = 2)
    3 10 A {Q0, Q0: ( ) Q0: ( ) Q0: ( ) Q3: (A = 1,
    B Q1, Q1: (A = 3)
    Figure US20100057737A1-20100304-P00001
    Figure US20100057737A1-20100304-P00001
    B = 2, C = 3)
    C Q2, Q2: (A = 2, B = 3)
    Figure US20100057737A1-20100304-P00002
    Figure US20100057737A1-20100304-P00002
    Q3} Q2: (A = 1, B = 2, B = 3) Q2: (A = 1, B = 2, B = 3) Q2: (A = 1, B = 2, B = 3)
    Q3: (A = 2, C = 3)
    Figure US20100057737A1-20100304-P00003
    Figure US20100057737A1-20100304-P00003
    Q3: (A = 1, B = 2, C = 3) Q3: (A = 1, B = 2, C = 3)
    4 10 A {Q0, Q0: ( ) Q0: ( ) Q0: ( ) Q3:
    B Q1, Q1: (A = 4)
    Figure US20100057737A1-20100304-P00004
    Figure US20100057737A1-20100304-P00005
    (A = 1, B = 2,
    C Q2, Q2: (A = 1, B = 2, B = 3, B = 4) Q2: Q2: B = 3, C = 4)
    Q3} Q3: (A = 1, B = 2, B = 3, C = 4) (A = 1, B = 2, B = 3, B = 4) (A = 1, B = 2, B = 3, B = 4)
    Q3:
    (A = 1, B = 2, B = 3, C = 4)
    5 40 A {Q0, Q0: ( ) Q0: ( ) Q0: ( ) (A = 1, B =
    Q1} Q1: (A = 5) Q1: (A = 5) Q1: (A = 5) 2, B = 3,
    C = 4)
  • [0181]
    In Table I, the first column shows the sequence in which events are received. The price attribute of each event is depicted in the second column. The third column shows the symbol matches after processing an event. The fourth column “State(S(i)” depicts the possible states of the finite automaton after processing each received event. The fifth column “Update Bindings” identifies the updated bindings corresponding to the states after processing an event. It should be noted that in the fifth column, a state may have multiple bindings associated with it. The sixth column “Apply Preferment” identifies bindings selected after applying preferment rules and/or deleting bindings as per steps 610 and 612 from FIG. 6 to the states and associated bindings depicted in the fifth column. As previously described, preferment rules are used to select a binding for a state from a set of bindings. Preferment rules are used in conjunction with the SKIP clause. It is sufficient to maintain only one binding per state. At times, after processing an input there may be states with more than one binding (as in this example). For each such state, the most “preferred” binding is retained and others are discarded. This is because, as mentioned earlier, it can be shown that (right equivalence) the retained binding will always yield a match that would be preferred compared to equivalent matches resulting from the same suffix applied on the other competing bindings that are discarded (for the same state). In Table I, the bindings that are deleted as a result of applying preferment rules are shown with a strikethrough. The seventh column “Partial Bindings” identifies partial bindings after processing an event after applying the preferment rules. The eight column “Matched but unsure” identifies the matched but unsure bindings after processing an event after applying the preferment rules. The ninth column “Output” identifies a binding that results in a pattern match that is output.
  • [0182]
    As indicated above, for Class A patterns, a state after processing an event can have multiple bindings associated with. After applying preferment rules, one or more of the bindings associated with a state may be deleted. In situations where you do not want overlapping matches (e.g., if the SKIP PAST LAST ROW clause is used), then some bindings may be deleted even if the deleted binding is a single binding for a state. For example, in Table I, after S3, it is known for sure that the first 3 events will participate in a full but unsure match, and since overlapping matches are not needed (SKIP PAST LAST ROW), there is no point in keeping A=3 in Q1 since it intersects with a previous match. Accordingly, after applying preferment rules, the binding A=3 in Q1 is deleted. In this manner, those bindings that can yield full matches that will be lower in preferment than an already determined full match can be deleted. If a state does not have any bindings associated with it, it is referred to as an inactive state and is also deleted. For example, in Table I, state Q1 is deleted after S3 and S4.
  • [0183]
    The following example illustrates how bindings are stored after receiving each event according to an embodiment of the present invention. For this example, let S(c1 integer) be an input event stream. A query Q may be received specifying a pattern to be detected in event stream S as follows:
  • [0000]
    SELECT
            *
    FROM
            S MATCH_RECOGNIZE (
            MEASURES
               A.c1 as c1,
               B.c1 as c2,
               C.c1 as c3,
               D.c1 as c4
            PATTERN(A B+ C D*)
            DEFINE
               A as A.c1 % 2 == 0,
               B as B.c1 % 3 == 0,
               C as C.c1 % 5 == 0,
               D as D.c1 % 7 == 0,
        ) as T
  • [0184]
    In the above example, the (X.c1% Y==0) predicates test whether X.c1 is divisible by Y. The pattern specified in the query is a Class A pattern. Table J shows a sequence of events received in event stream S and the matched symbols for the pattern (AB+CD*)
  • [0000]
    TABLE J
    Seq No.
    0 1 2 3 4 5
    c1 2 3 30 14 77 4
    Matching A B A A D A
    Symbols B D
    C
  • [0185]
    The FSA for the above query will have the following states:
    • Q0—initial state
    • Q1—corresponding to A
    • Q2—corresponding to AB+
    • Q3—corresponding to AB+C
    • Q4—corresponding to AB+CD*
      Among these, Q3 and Q4 are the final states. It should also be noted that both the final states have an out transition, from Q3 to Q4 on D, and from Q4 to itself on D.
  • [0191]
    Processing of the input events, per the flowchart depicted in FIG. 6 and described above, occurs as shown below. In the description below, “d” refers to the value of the symbol after processing event e(i−1) and “F1” refers to the set after processing event ei. B refers to the set of partial bindings after processing event ei.
  • [0192]
    Sequence #1
    • Current Input=2
    • Matching symbols=A
    • F1={ }—empty
    • d={ }—empty
      This is the case where d is empty and F1 is also empty.
    • S(1)={Q0, Q1}
      B={<(A=2), Q1>} where <. . . > represents a single binding and (A=2) is the symbol to input mapping and Q represents the state associated with this binding.
  • [0198]
    Sequence #2
    • Current Input=3
    • Matching symbols=B
    • F1={ }—empty
    • d={ }—empty
      This is the case where d is empty and F1 is also empty.
    • S(2)={Q0, Q2}
    • B={<(A=2, B=3), Q2>}
  • [0205]
    Sequence #3
    • Current Input=30
    • Matching symbols=A, B, C
    • F1={Q3}
      This is the case where d is empty and F1 is not empty.
    • S(3)={Q0, Q1, Q2, Q3}
    • B={<(A=2, B=3, B=30), Q2>, <(A=30), Q1>}
    • b is the unique binding in the final state namely—<(A=2, B=3, C=30), Q3>
    • left(b)=seq#1=min(B)=seq#1
    • Thus, d=b=<(A=2, B=3, C=30), Q3>
      Also, the binding <(A=30), Q1>with seq#4>left(b) is deleted and its associated state Q1 is removed from S(3).
    So,
  • [0000]
    • S(3)={Q0, Q2, Q3}
    • B={<(A=2, B=3, B=30), Q2>}
  • [0216]
    Sequence #4
    • Current Input=14
    • Matching symbols=A, D
    • F1={Q4}
      This is the case where d is not empty and F1 is also not empty.
    • S(4)={Q0, Q1, Q4}
    • B={<(A=14), Q1>}
    • b is the unique binding in the final state namely—<(A=2, B=3, C=30, D=14), Q4>
    • left(b)=seq#1 <min(B)=seq#4. However, there is a transition out of state Q4.
    • Thus, old d=<(A=2, B=3, C=30), Q3> is discarded and now
    • d=<(A=2, B=3, C=30, D=14), Q4>
      Also, S(1) is reset to {Q0, Q4} since the binding <(A=14), Q1> is deleted and its associated state
    • Q1 is removed from S(4). Thus B={ }
    • Sequence #5
    • Current Input=77
    • Matching symbols=D
    • F1={Q4}
      This is the case where d is not empty and F1 is also not empty.
    • S(5)={Q0, Q4}
    • B={ }
    • b is the unique binding in the final state namely—<(A=2, B=3, C=30, D=14, D=77), Q4>
    • left(b)=seq#1 =min(B) is not defined, also there is a transition out of state Q4.
    • Thus, old d=<(A=2, B=3, C=30, D=14), Q4> is discarded and now d=<(A=2, B=3, C=30, D=14, D=77), Q4>
  • [0236]
    Sequence #6
    • Current Input=4
    • Matching symbols=A
    • F1={Q0}
      This is the case where d is not empty and F1 is empty.
    • S(6)={Q0, Q1}
    • B={<(A=4), Q1>}
    • left(d)=seq#1<min(B)=seq#6
      Thus, d=<(A=2, B=3, C=30, D=14, D=77), Q4> is output and d reset back to empty.
      Note that S(6) and B={<(A=4), Q1>} remain as they are and nothing is deleted in this case.
  • [0243]
    FIG. 7 is a simplified flowchart 700 depicting a method for performing pattern matching for Class A patterns after receiving each event in an event stream according to an embodiment of the present invention. The method may be performed by software (program, code, instructions executed by a processor), in hardware, or combinations thereof. The software may be stored on a computer-readable storage medium. In one embodiment, the processing is performed by matcher 116 depicted in FIG. 1.
  • [0244]
    The processing is initiated upon receiving an event (step 702). Symbols, if any, that are matched due to the event received in 702 are determined (step 704). One or more states for the automaton are determined based upon the symbols determined to be matched in 704 and based upon bindings, if any, stored prior to receiving the event received in 702 (step 706). For example, the bindings stored upon receiving and processing the event received prior to the event received in 702 may be used to determine the state(s) of the automaton.
  • [0245]
    Updated bindings are then determined and maintained for the states determined in 706 (step 708). In one embodiment, the processing depicted in FIG. 6 may be performed in step 708 as part of determining which bindings to update and maintain. The processing in step 708 may comprise updating the previously stored bindings, applying preferment rules to select bindings from among bindings associated with the same state, determining matched but unsure bindings, and determining matched bindings that are to be output. Full pattern matches, if any, that are to be output are then determined based upon whether or not the updated bindings comprise any bindings representing full pattern matches which are to be output (step 710). Events corresponding to the full pattern matches, if any, determined in 710 are then output (step 712). Other actions, triggered by a full pattern match, may also be performed in 712. The processing depicted in FIG. 7 is performed upon receiving each event in the event stream. The bindings determined and maintained in 708 are then used during processing of the next received event.
  • [0246]
    In one embodiment, the processing depicted in FIG. 6 and described above is performed in steps 708, 710, and 712 of FIG. 7.
  • [0247]
    The technique described above is capable of detecting Class A patterns, including recurring and non-recurring patterns, in input event streams without performing any backtracking of the input events. Further, due to application of preferment rules, only one binding associated with a given state of the FSA is maintained at any point in time. As a result, the number of bindings to be maintained at any time point after processing an event is bounded by the number of states, which in turn is proportional to the length of the pattern to be matched. This enables pattern matching of Class A patterns to be performed efficiently in polynomial space and time over the number of symbols making up the pattern to be matched. The technique is thus very scalable and pattern matching can be performed at reduced costs.
  • [0248]
    Further, since the predicates defining symbols for Class A patterns are defined independent of other symbols, it follows that the set of symbols that an input event can be bound to is independent of the current bindings. Further, since an FSA is a right-invariant equivalence relation over S* (that is if xRMy then xzRMyz for strings x,y and any string z), and the preferment rules are prefix based, only one of these bindings is maintained per state. Accordingly, the number of active bindings at any point in time is bound by the number of states and is equal to one plus the length of the pattern to be matched.
  • [0249]
    In the manner described above, embodiments of the present invention are capable of automatically identifying Class A pattern based upon the input pattern to be matched and based upon the predicates associated with the pattern symbols. Upon identifying a pattern as a Class A pattern, embodiments of the present invention are configured to select and apply a pattern matching technique that is appropriate for processing Class A patterns. The application of the selected technique enables processing of event streams for detecting Class A patterns to be performed efficiently (e.g., in terms of memory and processing resources used) and in a manner that is scalable.
  • [0250]
    Class A patterns represent a class of patterns which can be used to model a large number of use cases. Since the number of patterns that can be generally specified can be quite large and may require a significant amount of computing resources, it becomes beneficial to identify a subclass (e.g., Class A patterns) of the global universe of patterns that is widely used and for which an efficient customized pattern matching solution is applied as described above.
  • [0251]
    As described above, Class A patterns represent a subset of patterns that may be specified for pattern matching. The following section describes a more generalized technique for performing pattern matching in input event streams for patterns that may not fall under the umbrella of Class A patterns.
  • Class B Patterns (General Patterns)
  • [0252]
    The above section described a technique for identifying Class A patterns and performing pattern matching for this specific subclass of patterns in polynomial space and polynomial time. However, there are several patterns that do not qualify as Class A patterns. This section describes a technique for performing pattern matching for general patterns, which will be referred to as Class B patterns to differentiate them from Class A patterns. A Class B pattern may include a Class A pattern.
  • [0253]
    Class B patterns are general patterns that are not restricted by the limitations imposed on Class A patterns. One of the differences between processing of Class A patterns and the Class B patterns is that there may be multiple bindings in the Class B patterns scenario that are associated with a given state of the FSA at any point in time and that need to be maintained for processing of the next event while in the Class A pattern case at most one binding associated with a given state of the FSA may be maintained at any point in time. As a result, for Class A patterns that the number of bindings that is maintained after processing an event is bounded by the number of states, which itself is proportional to the number of symbols in the pattern to be matched, thus yielding a solution that is polynomial in space and time over the number of symbols making up that pattern.
  • [0254]
    Further, unlike Class A patterns, a predicate associated with a symbol in a Class B pattern may contain references to other symbols (e.g. a predicate associated with a symbol A be defined as (A.price<B.price), where B is another symbol having its own associated predicate). Accordingly, a predicate for a symbol in Class B patterns may be dependent on other symbols.
  • [0255]
    The framework for performing Class B pattern matching may be divided into two stages: (1) a compile or design time stage during which an automaton is constructed for the query; and (2) a runtime stage during which the automaton generated in (1) is used to guide the pattern matching process. Bindings representing partial and/or full matches are maintained during the runtime stage processing. In the first stage, if the pattern is included in a query, the query is compiled into an execution plan that comprises the automaton for the query. The plan is then executed at runtime.
  • [0256]
    FIG. 8 is an example of a query 800 specifying a Class B pattern 802 according to an embodiment of the present invention. The pattern tkpattern_q10 depicted in FIG. 8 is a Class B pattern but not a class A pattern (e.g., the aggregate “avg(B.c1)” in the predicate defining C is not allowed in a Class A pattern; also the predicate for B is dependent on A, which is not allowed in a Class A pattern). The predicates for the symbols in the pattern are defined by DEFINE clause 804. As can be seen from DEFINE clause 804, the predicate for one symbol may be dependent upon another symbol. For example, the predicate for symbol B is dependent upon symbol A, and the predicate for symbol C is dependent on symbol B. At compile time processing, query 800 may be compiled into an execution plan that is used for runtime processing. A Finite State Automaton (FSA) is constructed corresponding to regular expression and the predicates specified in query 800. As an example, the following sequence matches the pattern depicted in FIG. 8
  • [0000]
    10 11 12 13 2
    A B B B C
  • [0257]
    FIG. 9 is a simplified flowchart 900 depicting a method for performing operations at compile time including constructing an automaton for a general Class B pattern according to an embodiment of the present invention. The method may be performed by software (program, code, instructions executed by a processor), in hardware, or combinations thereof. In one embodiment, the processing is performed by automaton generator 114 depicted in FIG. 1. Flowchart 900 assumes that the input regular expression has been already been determined to specify a Class B pattern.
  • [0258]
    As depicted in FIG. 9, a standard grammar for regular expressions is used to create a parse tree for the specified regular expression specifying the pattern (step 902). The parse tree obtained in 902 is then used as a guide to recursively construct the FSA (step 904). The base case for recursion is a simple symbol (e.g., A) or symbol followed by a quantifier (e.g.,: A*).
  • [0259]
    The out-transitions from each state are ordered to handle the preferment rules (step 906). In order to identify the most preferred match, while applying transitions to a binding in state S, the transitions are applied in a specific order. This order (among the set of transitions from a state) is determined at compile time and stored as part of the automaton. Included in this order, is a rank for the “finality” of the state (applicable only for final states). This is done to accommodate the preferment rules. In the presence of reluctant quantifiers (such as *?) sometimes “shorter” matches are preferred. However, for greedy quantifiers (such as *) “longer” matches are preferred. Using this technique of introducing a rank amongst the set of out transitions for an “imaginary” transition corresponding to the finality of a state (applies only to a final state), such decisions can be made in a manner consistent with the overall framework (and without having to special case the final state during runtime processing) that handles the preferment rules. The following is an invariant there will be only one start state and the start state does not have any incoming edges.
  • [0260]
    Several operators such as CONCATENATION, ALTERNATION, and various QUANTIFIERS (e.g., *, ?, +) may be used for one or a group of symbols. Examples of operators and quantifiers that may be used are described in “Pattern matching in sequences of rows (12)” document. These operators and quantifiers are handled in the recursion step in 904. For example, the CONCATENATION operator may be handled in the recursive step in the following manner. Consider an example R.S where R is the left regular expression and S is the right regular expression. Let F be the FSA corresponding to R and G be the FSA corresponding to S. Let Y be the set of final states in F. Let J be the start state of G. The FSA corresponding to the union of F and G may be called as H. Accordingly, all the out-transitions from state J in FSA G are copied to each state Y in FSA H. These new transitions are introduced to each state in Y at the position of its “finality” rank in the same order as they appeared in state J of FSA G (note that all states in Y were final in F and hence would have a “finality” rank in the order of their out transitions). Note that each state in Y remains final if and only if J was a final state in G. State J is then removed from H. Other operators such as ALTERNATION, GROUPING, and Quantifiers across groups may also handled individually in a similar manner.
  • [0261]
    Referring back to FIG. 9, all referenced aggregations are aggregated and “init” and “incr” evaluators for the aggregations and their corresponding input expressions are prepared (step 908). As part of processing every input and updating the bindings, the specified aggregations are also incrementally maintained. These aggregations are stored along with the bindings. For example, suppose there is a reference to sum(B.c1) (where this could be referenced in one of the DEFINE predicates or the MEASURES clause), then this would be dependent on the binding. For a binding with (A=1, B=2, B=3), sum(B.c1) would be 2+3=5 while for another binding (A=1, B=2) sum(B.c1)=2. Init and Incr evaluators are mechanisms used to initialize the aggregations when a binding is newly created and to incrementally maintain the aggregation as the binding is “grown”.
  • [0262]
    Evaluators are then prepared for each of the defined predicates (e.g., predicates specified by the DEFINE clause in a query) (step 910). Evaluators are also prepared for the expressions in the MEASURES clause (step 912). These evaluators are the mechanism used to evaluate a DEFINE predicate to determine the set of symbols that an input event corresponds to. For Class B patterns, this is done in the context of the binding, i.e., for a binding b1, the same input may evaluate to a symbol A while for binding b2, it may evaluate to B.
  • [0263]
    The FSA constructed as described above and depicted in FIG. 9 may then be used to guide detection of Class B patterns in input event streams during runtime processing. In one embodiment, the FSA constructed at compile time is used as a guide to indicate how much of the specified pattern has matched at any point in time. As with Class A patterns, bindings are also used to capture the partial or full match states at any point in time during the runtime processing. As previously indicated, a binding can be thought of as an assignment of contiguous events to symbols that corresponds to a partial or full match that satisfies all the DEFINE predicates.
  • [0264]
    The runtime pattern matching processing may be explained using the following definitions. Consider a situation where an input tuple or event i has been processed and an input tuple or event (i+1) is to be processed. A binding after processing of e(i) may be in one of following three disjoint states:
    • (1) Partial Active (PA) state—binding not in a final state. A binding is in this state if it represents a binding that is not in a final state but has to potential of growing into a full match;
    • (2) Only Matched but unsure (MU) state—binding in a final state with no out-transitions (i.e., no transitions to another state or the same final state); or
    • (3) Both active and matched but unsure state (AMU)—binding in a final state with out-transitions to another or the same final state.
      Further, let AB be the set of active bindings (i.e., bindings in states PA and AMU).
      Let FB be the set of final bindings (i.e., bindings in states MU and AMU)
      Let AFB=AB union FB
      Let AFBL be an ordered list of bindings from set AFB in decreasing order of preferment. (It may be noted that preferment rules may be defined not only for bindings in FB but for all bindings.)
  • [0268]
    Derived bindings may also be defined. Consider a binding b1 in AB after event i has been processed. Now suppose on processing event (i+1), this binding can be “grown” to bd1, bd2, . . . bdk. Then all these bindings are considered to be derived from b1.
  • [0269]
    Based upon the above definitions, the following observations/invariants may be made.
    • (1) The “last” event (by event sequence number) in every binding in AB is the same and is event i.
    • (2) For every pair of bindings fb1, fb2 in FB, INT(fb1) and INT(fb2) do not intersect.
    • (3) For every binding fb in FB, there exists a binding ab in AB such that ab==fb OR ab !=fb and ab is preferred to fb as per preferment rules.
    • (4) Consider distinct bindings fb in FB, ab in AB. If fb is preferred to ab as per preferment rules, then INT(ab) does not intersect with INT(fb).
    • (5) Suppose bd1 is derived from b1 and bd2 is derived from b2. Then bd1 is preferred to bd2 iff b1 is preferred to b2.
  • [0275]
    Based on the above, the following invariants also hold:
    • (1) If list AFBL is not empty, then the first binding in the list AFBL is in AB (follows from 3 above); and
    • (2) If there was a binding that moved into set FB for the first time during processing event i, and if it is still in FB, then this is the last binding in the list AFBL (follows from 1, 2, 4 above).
  • [0278]
    FIGS. 10A and 10B depict a simplified flowchart 1000 depicting runtime processing performed for detecting a Class B pattern in an input event stream according to an embodiment of the present invention. The method may be performed by software (program, code, instructions executed by a processor), in hardware, or combinations thereof. In one embodiment, the processing is performed by matcher 116 depicted in FIG. 1. The method depicted in FIGS. 10A and 10B show processing that is performed upon receiving an event ei+1.
  • [0279]
    As depicted in FIG. 10A, processing is initiated upon receiving an event ei+1 (step 1001). A new list of bindings NEW_AFBL is initialized to an empty list (step 1002). The AFBL list is accessed (step 1004). As described above, the AFBL list is an ordered list of bindings from set AFB in decreasing order of preferment, wherein the set AFB is a union of bindings in set AB (the set of active bindings (i.e., bindings in states PA and AMU)) and bindings in set FB (the set of final bindings (i.e., bindings in states MU and AMU)).
  • [0280]
    Bindings are then iteratively selected from list AFBL in decreasing order of preferment and processing according to steps 1006, 1008, 1010, 1012, 1014, 1016, 1017, 1018, 1020, and 1022. A binding from list AFBL is selected in decreasing order of preferment (step 1006). The binding selected in step 1006 will be referred to as binding “b”. A check is then made to see if b is in AB (step 1008). If binding b is determined to not be in AB, then binding b is inserted into list NEW AFBL (step 1010). Processing then continues with step 1022.
  • [0281]
    If it is determined in 1008 that b is in AB, then ALPHA is set to the symbols that are matched by event ei+1 (step 1012). The symbols in ALPHA are then selected iteratively in order of the out-transitions on the corresponding state of the FSA and processed according to steps 1014, 1016, 1017, 1018, and 1020. A symbol is selected from ALPHA for processing (step 1014). The symbol selected in 1014 will be referred to as symbol “a”. A check is then made to see if there is a binding ba gotten by applying symbol a on binding b (step 1016). If such a binding ba exists then the binding ba is inserted into list NEW_AFBL (step 1017). Further, if ba is moving into FB for the first time then newFinal(ba) is set to TRUE (step 1018). This is to identify whether in this iteration there is a binding that has moved into a final state. This means that all bindings that would be created following this need not be considered (hence need not be inserted into NEW_AFBL). Nothing is done if no such binding ba exists. A check is then done to see if all symbols in ALPHA have been processed (step 1020). If all symbols in ALPHA have not been processed, then processing continues with step 1014 wherein the next symbol that has not yet been processed is selected. Else processing continues with step 1022.
  • [0282]
    A check is then made to see if all bindings in AFBL have been processed (in decreasing order of preferment) (step 1022). If it is determined in 1022 that all bindings in AFBL have not been processed, then processing continues with step 1006 wherein another unprocessed binding is selected. If it is determined in 1022 that all bindings in AFBL have not been processed, then, in order to handle state Q0, new bindings are inserted into NEW_AFBL in appropriate order (step 1024). The order would correspond to iterating through the out-transitions of state Q0 in the order in which they appear in the FSA. The processing would correspond to b is in AB.
      • 1. Let ALPHA be the alphabets that tuple (i+1) evaluates to for the binding b
      • 2. Iterate through the alphabets in ALPHA in order of their occurrence in the out transitions of the current state of the binding
        • 1. Let a be the alphabet for this iteration
        • 2. Insert binding ba got by applying alphabet a on binding b into NEW AFBL. Further if ba is moving into FB for this first time then mark newFinal(ba)=true
        • 3. If there is no such binding by applying alphabet a on binding b then do nothing
  • [0288]
    The bindings in list NEW_AFBL are then processed. In order to facilitate the processing, a variable “delete_remaining” is set to FALSE and another variable “found_ab” is set to FALSE (step 1026). The bindings in list NEW_AFBL are processed according to steps 1028 onwards (1028 to 1054). A binding is selected from NEW_AFBL for processing (step 1028). The binding selected in 1028 will be referred to as b.
  • [0289]
    Processing is then performed based upon the state of the selected binding, whether it is MU, AMU, or PA. A check is performed to see if the state of the binding selected in 1028 is MU (step 1030). If the state of binding b is not MU, then processing continues with step 1042. If it is determined in 1030 that the state of the binding is MU, then if delete_remaining is TRUE then the binding b is deleted from NEW_AFBL (step 1032). Then, if newFinal(b) is TRUE, delete_remaining is set to TRUE (step 1034). Then, if found_ab is FALSE (i.e., !found_ab), then binding b is reported as a match and binding b is deleted from NEW_AFBL (step 1040).
  • [0290]
    A check is made to see if the state of binding b selected in 1028 is AMU (step 1042). If the state of binding b is not AMU, then processing continues with step 1050. If it is determined in 1042 that the state of the binding is AMU, then if delete_remaining is FALSE (i.e., !delete_remaining) and newFinal(b) is true, then delete_remaining is set to TRUE (step 1044). Else, if delete_remaining is TRUE then binding b is deleted from NEW_AFBL (step 1046). The variable found_ab is then set to TRUE (step 1048).
  • [0291]
    If the state of binding b is neither MU nor AMU, then the state of b is PA. In such a case, if delete_remaining is set to TRUE then binding b is deleted from NEW_AFBL (step 1050). The variable found_ab is set to TRUE (step 1052). Processing then continues with step 1054.
  • [0292]
    A check is then made to see if all bindings in list NEW_AFBL have been processed (step 1054). If all bindings in NEW_AFBL are determined to have been processed then the processing ends, else processing continues with step 1028 wherein a new binding is selected for processing.
  • [0293]
    At the end of processing of event ei+1, it can be verified that the seven invariants listed above hold. It should be noted that the method depicted in FIG. 10 and described above may also be used for detecting Class A, including Class A simple recurring patterns, since these patterns are just a subclass of the general Class B patterns. The method depicted in FIG. 10 and described above may be implemented with two separate lists: i) Partial Active PA and ii) Both active and Matched but unsure list AMU. In one embodiment, rather than have a single AFB list, it is also possible to have two lists—AB and FB.
  • Output Ordering for Partition by Support for Patterns
  • [0294]
    In an embodiment of the present invention, an input event stream may be partitioned into multiple different streams based for example upon a symbol. The pattern matching techniques described above may, then, be applied over each sub-stream. In this scenario, a query comprising a regular expression is compiled into a PLAN that is then used at runtime processing for detecting the pattern over the partitioned multiple streams. The compilation process comprises building an FSA for the regular expression. This may involve building a base FSA for each symbol and then combining the FSAs to form a single FSA, which is then used at runtime processing.
  • [0295]
    The following SQL query provides an example of how an input event stream may be partitioned using a symbol, and pattern matching may then be applied over each sub-stream.
  • [0000]
    create query double_bottom as
    select symbol, start_price, end_price
    from Ticker MATCH_RECOGNIZE (
         PARTITION BY symbol
         MEASURES
            A.symbol    as symbol,
            A.price    as start_price,
            LAST(Z.price) as end_price
         PATTERN (A W+ X+ Y+ Z+)
         DEFINE
            W as (W.price < PREV(W.price)),
            X as (X.price > PREV(X.price)),
            Y as (Y.price < PREV(Y.price)),
            Z as (Z.price > PREV(Z.price))
     )
  • [0296]
    The complex pattern that this query specifies is what is known as a “double bottom” or “W” shaped pattern. The requirement is to match non-overlapping maximal “W” patterns and from all the events constituting a match, output a single event corresponding to the match that reports the symbol, the price at the beginning of the fall and the price at the end of the last rise.
  • [0297]
    The following definitions are used to describe the pattern matching processing:
    • 1) ReadyToOutputList—This list contains all the potential output bindings in the increasing order of output timestamp. These bindings are on hold because there exists an unsure binding with lesser output timestamp in some other partition.
  • [0299]
    The pattern matching process proceeds as follows:
    • (1) After processing the current input tuple, collect all the bindings in the current partition, which can be output and move them to ReadyToOutputList.
    • (2) Get minimum matched timestamp (minMatchedTs) of all the unsure bindings of all the partitions.
    • (3) Emit all the bindings in the ReadyToOutputList whose matched timestamp is less than minMatchedTs.
  • [0303]
    The processing described above ensures that ready to output bindings are on hold until all the potential output bindings (unsure bindings) whose matched timestamp is less than the ready to output bindings either become ready to output or cannot be developed further.
  • [0304]
    Responsibility of pattern processor is to output the matched events in order of time. In one partition there may be a match ready for output and in another partition there is a match that is being held back by preferment.
  • [0305]
    As described above, extensions are provided to SQL that transform SQL into a rich expressive language for performing pattern matching using regular expressions. The extensions enhance the ability of SQL to support pattern matching on events. Extensions to support or model regular expression-based pattern matching on event streams may also be provided for other programming languages.
  • [0306]
    Pattern matching using regular expressions over continuously arriving events of an event stream, as described above, has wide applicability in various fields and applications. Examples include financial services, RFID based applications such as inventory management, click stream analysis applications, electronic health systems, and the like. For example, in financial services, a trader may use the pattern matching techniques described above to identify trends in the stock market based upon a stream of incoming ticker stock prices. As another example, in RFID-based tracking and monitoring, the pattern matching techniques described above may be used to track valid paths of shipments and detect anomalies.
  • [0307]
    While embodiments of the present invention have been described above with respect to Class A and Class B patterns, in alternative embodiments various different types of patterns may be recognized and processed accordingly. For a particular class of pattern that is detected, an embodiment of the present invention is configured to select and apply a pattern matching technique that is appropriate for that type of pattern. In this manner, embodiments of the present invention optimize and increase the efficiency of pattern matching performed over event streams.
  • Automaton Construction
  • [0308]
    This section describes techniques for constructing a nondeterministic finite state automata (NFSA) given a regular expression used to express a pattern to be recognized according to an embodiment of the present invention. Description is provided for generating an NFSA for a basic regular expression such as ‘A’. Description is then provided for the necessary transformations for each of the regular expression operators such as Concatenation, Alternation, Greedy Quantifiers—‘*’,‘+’,‘?’ and Lazy Quantifiers—‘*?’, ‘+?’, ‘??’.
  • [0309]
    In one embodiment, a regular expression is maintained in a tree representation (which is actually a unique parse tree for that regular expression) constructed by taking into account the precedence and associativity of regular expression operators. Like most algorithms operating on tree data structure, the process of construction of NFSA given a regular expression in tree form is also recursive in nature. A standard NFSA is constructed for basic regular expression that is nothing but a single correlation variable and then gradually the entire NFSA is built by applying the transformations for different operators involved.
  • (a) Machine for a Basic Regular Expression
  • [0310]
    A basic regular expression is simply a single correlation variable e.g. A. The machine for this basic regular expression consists of two states: 0 and 1.
    • State 0: This is the start state and it has a transition going to state 1 on encountering the alphabet A in the input.
    • State 1: This is the final state and has one transition going to “undefined” state (state number-1) on the alphabet “Final” (indicated by F in FIGS. 11A-11).
  • [0313]
    A state diagram for a single correlation variable e.g. ‘A’ is shown in FIG. 11A. In FIGS. 11A-11I, a rectangular box below the state shows the <alphabet, dest state> pairs (transitions) of that state in the decreasing order of preference.
  • (b) Concatenation Operator (.)
  • [0314]
    The concatenation operator is a binary operator. First, the NFSA for the left and right operands are obtained and then merged to get the NFSA for the concatenated regular expression.
  • [0315]
    Let ‘L’—number of states in left operand NFSA
      • ‘R’—number of states in right operand NFSA
        The start state of right NFSA is not considered and so the number of states in the merged NFSA is L+R−1. Also the states are numbered 0 through L+R−2.
  • [0317]
    The steps for merging the two NFSAs are as follows:
    • (1) For every state ‘S’ in the left NFSA
      • Copy all the transitions (<alphabet, destination state> pairs) of ‘S’ to the corresponding state of merged NFSA.
    • (2) For every final state of left NFSA
      • In the corresponding state of merged NFSA, add all the start state transitions of right NFSA, in the order in which they appear, at a position, where ‘Final’ transition appears for that state. In the process that ‘Final’ transition is removed.
      • If the start state of right NFSA is final (i.e. the language of the right regular expression accepts ‘ε’) then make this state of merged NFSA a final state.
    • (3) For every state ‘S’ of right NFSA except the start state
      • Copy the transitions of state ‘S’ to the state ‘S+L−1’ of the merged NFSA incrementing the destination state field by L−1.
      • Make the state ‘S+L−1’ of merged NFSA final, if the state ‘S’ of right NFSA is final.
        FIG. 11B depicts how the state diagram of ‘AB’ is obtained from the state diagrams of ‘A’ and ‘B’ by following the above technique.
    (c) Alternation Operator (|)
  • [0326]
    The alternation operator is a binary operator. First, the NFSA for the left and right regular expressions are obtained and then join them together to get the NFSA for the complete regular expression.
  • [0327]
    Let ‘L’—number of states in left operand NFSA and
      • ‘R’—number of states in right operand NFSA
        In the joined NFSA, a new state is created for start state that has all the transitions of start states of left as well as right NFSA. We do away with the start states of left and right NFSA. So the number of states in the joined NFSA is L+R−1. Also the states are numbered 0 through L+R−2.
  • [0329]
    The two NFSAs are joined as follows:
    • (1) For every state ‘S’ in the left NFSA
      • Copy all the transitions (<alphabet, destination state> pairs) of ‘S’ to the corresponding state of joined NFSA.
      • Also mark the state ‘S’ of joined NFSA as final if state ‘S’ of left NFSA is final.
    • (2) If start states of both left and right NFSA are final then
      • Append all the start state transitions of right NFSA excluding the ‘Final’ transition, in the order in which they appear, to the transitions of the start state of the joined NFSA. While appending increment the destination state field by L−1.
      • Else Append all the start state transitions of right NFSA, in the order in which they appear, to the transitions of the start state of the joined NFSA. While appending increment the destination state field by L−1.
      • Make the start state of joined NFSA final, if the start state of right NFSA is final.
    • 3. For every state ‘S’ of right NFSA except the start state
      • Copy the transitions of state ‘S’ to the state ‘S+L−1’ of the joined NFSA incrementing the destination state field by L−1.
      • Make the state ‘S+L−1’ of joined NFSA final, if the state ‘S’ of right NFSA is final.
  • [0340]
    FIG. 11C depicts an example of how to get state diagram for (A|B) from state diagrams of alternation components.
  • (d) Quantifiers
  • [0341]
    Quantifiers that may be supported in a regular expression include greedy quantifiers (*, +, ?) and lazy (*?, +?, ??) quantifiers. These quantifiers can be applied over simple regular expressions like A, B, etc. or over complex regular expressions formed by applying ‘concatenation’ and/or ‘alternation’ over simple regular expressions e.g., (AB)*, (A|B)*, etc. Repeated applications of these quantifiers in any order is also allowed yielding regular expressions like (A*)?, (A*?B+C?)+, etc. In the techniques described below for handling quantifiers, a machine constructed for the unary operand (whether simple/complex) of the quantifier is first obtained and then the constructed NFSA is appropriately modified depending on the quantifier, as per the rules stated below.
  • [0342]
    (1) ‘*’ Quantifier (Greedy)
    • Let P=R*
      Case 1—L(R) does not contain epsilon
  • [0000]
    Start state of R is Cannot be the case (since L(R) does
    final not contain epsilon)
    Start state of R is Make start state final and the rank of “final” is
    not final the lowest (do this start state processing last)
    Non-start final For each such state, copy over all start-state
    states transitions between current
    “final” and its predecessor. Then,
    for each duplicate transition, remove the
    lower ranked duplicate. (Here duplicate
    transition is one where alphabet and
    destination state are identical)

    Case 2—L(R) contains epsilon
  • [0000]
    Start state of R is No change, leave it as is
    final
    Start state of R is Cannot be the case (since L(R) contains epsilon)
    not final
    Non-start final For each such state, copy over all start-state
    states transitions between current “final” and its predecessor.
    This includes the “final transition” from the start
    state. Remove the original “final transition”
    of this final state. Then, for each duplicate transition,
    remove the lower ranked duplicate. (Here duplicate
    transition is one where alphabet and destination
    state are identical)
  • [0344]
    FIG. 11D depicts an example of the state machine for ‘A*’ obtained by applying rules for ‘*’ over state machine for ‘A’.
  • [0345]
    (2) ‘+’ Quantifier (Greedy)
    • Let P=R+
      Case 1—L(R) does not contain epsilon
  • [0000]
    Start state of R is Cannot be the case (since L(R) does not contain
    final epsilon)
    Start state of R is No change, leave it as is.
    not final
    Non-start final For each such state, copy over all start-state
    states transitions between current “final” and its predecessor.
    Then, for each duplicate transition, remove the
    lower ranked duplicate. (Here duplicate transition
    is one where alphabet and destination state are
    identical)

    Case 2—L(R) contains epsilon
  • [0000]
    Start state of R is No change, leave it as is
    final
    Start state of R is Cannot be the case (since L(R) contains epsilon)
    not final
    Non-start final For each such state, copy over all start-state
    states transitions between current “final” and its predecessor.
    This includes the “final transition” from the start
    state. Remove the original “final transition”
    of this final state. Then, for each duplicate transition,
    remove the lower ranked duplicate. (Here duplicate
    transition is one where alphabet and destination
    state are identical)
  • [0347]
    FIG. 11E depicts an example of the state machine for ‘A+’ obtained by applying rules for ‘+’ over the state machine for ‘A’.
  • [0348]
    (3) ‘?’ Quantifier (Greedy)
    • Let P=R?
      Case 1—L(R) does not contain epsilon
  • [0000]
    Start state of R is final Cannot be the case (since
    L(R) does not contain epsilon)
    Start state of R is not final Make the start state final
    and the rank of “final” is the lowest.
    Non-start final states Nothing needs to be done

    Case 2—L(R) contains epsilon
  • [0000]
    Start state of R is final No change, leave it as is
    Start state of R is not final Cannot be the case (since L(R) contains
    epsilon)
    Non-start final states Nothing needs to be done.
  • [0350]
    FIG. 11F depicts an example of the state machine for ‘A?’ obtained by applying rules for ‘?’ over state machine for ‘A’.
  • [0351]
    (4) ‘*?’ quantifier (Lazy)
    • Let P=R*?
      Case 1—L(R) does not contain epsilon
  • [0000]
    Start state of R is final Cannot be the case (since
    L(R) does not contain epsilon)
    Start state of R is not final Make the start state final and the
    rank of “final” is first (do this
    processing last) (Since epsilon is
    to be given more preference
    over any non-empty string, rank of final is
    first).
    Non-start final states For each such state, copy all
    start state transitions between
    current ‘final’ and its immediate
    successor. Then for each duplicate transition,
    remove the lower ranked duplicate

    Case 2—L(R) contains epsilon
  • [0000]
    Start state of R is final Remove the original ‘final’ transition and put
    it in the first place. (Since epsilon is to be
    given more preference over any non-empty
    string, rank of final is first)
    Start state of R is not final Cannot be the case
    (since L(R) contains epsilon)
    Non-start final states For each such state, copy all start
    state transitions between current “final” and
    its immediate successor. No need to include
    the “final transition” from the start state.
    Then, for each duplicate transition, remove
    the lower ranked duplicate.
  • [0353]
    FIG. 11G depicts an example of the state machine for ‘A*?’ obtained by applying the rules for ‘*?’ over state machine for ‘A’.
  • [0354]
    (5) ‘+?’ Quantifier (Lazy)
    • Let P=R+?
      Case 1—L(R) does not contain epsilon
  • [0000]
    Start state of R is final Cannot be the case (since L(R)
    does not contain epsilon)
    Start state of R is not final No change, leave it as is.
    Non-start final states For each such state, copy all start
    state transitions between current ‘final’ and
    its immediate successor. Then for each
    duplicate transition, remove the lower
    ranked duplicate.

    Case 2—L(R) contains epsilon
  • [0000]
    Start state of R is final No change, leave it as is. (No change in
    preference of epsilon needed here)
    Start state of R is not final Cannot be the case (since L(R) contains
    epsilon)
    Non-start final states For each such state, copy all start state
    transitions between current “final” and its
    immediate successor. No need to include
    the “final transition” from the start state.
    Then, for each duplicate transition, remove
    the lower ranked duplicate.
  • [0356]
    FIG. 11H depicts an example of a state machine for ‘A+?’ obtained by applying the rules for ‘+?’ over state machine for ‘A’.
  • [0357]
    (6) ‘??’ Quantifier (Lazy)
    • Let P=R??
      Case 1—L(R) does not contain epsilon
  • [0000]
    Start state of R is final Cannot be the case (since L(R)
    does not contain epsilon)
    Start state of R is not final Make the start state ‘final’ and
    rank of ‘final’ is first. (Since
    epsilon is to be given more preference over
    any non-empty string rank of final is first)
    Non-start final states Nothing needs to be done

    Case 2—L(R) contains epsilon
  • [0000]
    Start state of R is final Remove the original final transition and put
    it in the first place. (Since epsilon is to be
    given more preference over any non-empty
    string, rank of final is first)
    Start state of R is not final Cannot be the case (since L(R) contains
    epsilon)
    Non-start final states Nothing needs to be done
  • [0359]
    FIG. 11I depicts an example of a state machine for ‘A??’ obtained by applying rules for ‘??’ over state machine for ‘A’.
  • Example
  • [0360]
    This section provides an example of constructing an NFSA based upon the rules described above. Consider a regular expression “(A?B*|C*?)+”. Here ‘+’ is applied over the expression in brackets. The expression inside brackets has two alternation components: ‘A?B*’ and ‘C*?’. The first one of these components is concatenation of ‘A?’ and ‘B*’. The process of constructing a state machine for this regular expression is as follows:
    • (1) The state machine for first alternation component ‘A?B*’ is obtained by applying rules of concatenation operator on the state machines for ‘A?’ and ‘B*’. This is shown in FIG. 12A.
    • (2) The state diagram for second alternation component ‘C*?’ is shown in FIG. 12B.
    • (3) The rules of alternation operator are applied on state machines of the two components to get the state machine for ‘(A?B*|C*?)’, as shown in FIG. 12C.
    • (4) Finally, the rules for ‘+’ quantifier on the state machine obtained in last step are applied to get the state machine for complete regular expression, as shown in FIG. 12D.
    Analysis of Technique for Constructing NFSA
  • [0365]
    Let ‘N’ be the number of alphabets in the regular expression and ‘S’ be the number of states in the state diagram of that regular expression constructed by using the algorithms described in this document. Then S=N+1 always, which means S is linear in ‘N’. This can be proven using the principle of induction as follows:
    • (1) Basic case: When N=1, (single correlation variable case) the number of states is two. So S=N+1 holds.
    • (2) Assumption: Let S=N+1 holds for all N<=K.
    • (3) Induction Step: To Prove for N=K+1, we have the following cases:
    • Concatenation: State diagram of regular expression with ‘n1’ variables is joined by using concatenation to another state diagram of regular expression with ‘n2’ variables where n1 and n2 both <=K, then the number of states in resultant state diagram is: S=S1+S2−1 (since the initial state of second NFSA is removed in the process) Where S1—number of states in first NFSA=n1+1 (follows from step 2)
  • [0370]
    S2—number of states in the second NFSA=n2+1 (follows from step 2)
      • Therefore, S=n1+1+n2+1−1=n1+n2+1=N+1 since N=n1+n2.
    • Alternation: State diagram of regular expression with ‘n1’ variables is joined by using alternation to another state diagram of regular expression with ‘n2’ variables where n1 and n2 both <=K, then the number of states in resultant state diagram is:
      • S=S1+S2−1 (since the initial states of both NFSA are removed in the process and a new initial state is added)
      • Where S1—number of states in first NFSA=n+1 (follows from step 2)
        • S2—number of states in the second NFSA=n2+1 (follows from step 2).
      • Therefore, S=n1+1+n2+1−1=n1+n2+1=N+1 since N=n1+n2.
    • Quantifiers: Algorithms for quantifiers don't change the number of states.
    • So in all cases S=N+1 is proved. Hence the number of states is linear in N.
    • The worst case bound on the number of transitions (M) is
    • M=number of alphabets (N)*number of states (S).
    • This follows easily from the following invariant, there can be at most one transition for a given
    • <state, alphabet> pair.
    • So in the worst case, every state will have one transition on every alphabet.
    • M=N*S=N*(N+1)=O(N̂2).
    • So in the worst case, M is quadratic in N.
    Detection of Non-Occurrences of Events
  • [0386]
    In the embodiments described above, pattern matching processing is performed during runtime upon receiving an event. Accordingly, the pattern matching described above is based upon the arrival of events in a data stream. There are several situations across different industry domains where there is a need to detect that a specific event has NOT happened within a time period following the occurrence of another event. In other words, in such situations it is important to detect the non-occurrence of an event within a time period following the occurrence of another event. These use cases may be referred to as “non-event” detection use cases.
  • [0387]
    For example, in an airline baggage check-in application, the application may be required to detect situations where a passenger's bag has not been scanned within a certain period of time (e.g., 5 minutes) following the passenger's check-in. Non detection of a bag scan within the time period after a passenger's check-in may indicate a potential lost bag scenario. Early detection of such situations allows the airline company time to react and take actions to resolve a missed bag situation.
  • [0388]
    The pattern matching techniques discussed above may be used to detect such non-occurrences. For example, pattern matching module 110 may be configured to detect such non-occurrences. In one embodiment, language extensions are provided to a language (such as CQL) that enable a user to formulate queries for detection of non-occurrences of events using that language. One language extension may enable a user to specify in the query that the query is for detection of non-occurrences of events. Another language extension may enable the user to specify a time period during which the non-occurrence is to be monitored. For purposes of the description below, the event that starts the time period within which non-occurrence of an event is to be detected will be referred to below as the “trigger event” since it triggers that start of the time period. The event whose non-occurrence is to be monitored during the time period will be referred to as a “non-event”.
  • [0389]
    FIG. 13 depicts an example of a query 1300 that may be used to detect the non-occurrence of an event within a time period following the occurrence of another event according to an embodiment of the present invention. Query 1300 depicted in FIG. 13 is merely an example of a query that may be used and is not intended to limit the scope of the invention as recited in the claims. Other queries may be used in alternative embodiments.
  • [0390]
    As depicted in FIG. 13, query 1300 comprises a new language extension “INCLUDE TIMER EVENTS” clause 1304 that indicates that query 1300 is a special query for detecting non-occurrence of an event within a time period following the occurrence of another event. Pattern 1302 may be used to specify the trigger event. Another new language extension “DURATION” clause 1306 enables a user to specify the time period after the occurrence of a trigger event within which non-occurrence of a non-event is to be monitored. One or more actions may be performed upon the detection of non-occurrence of the non-event within the defined time period. Various different types of actions may be performed such as raising an alert, preventative actions, and others.
  • [0391]
    In the example depicted in FIG. 13, “baggageCheckIn_u_baggageTracking” is an input stream being analyzed. This input stream may comprise events of different types including an event that indicates a passenger check-in (cType=0) and an event that indicates a baggage scan (cType=1) following a check-in. In query 1300, the pattern 1302 comprises two symbols A and B. The condition or predicate for symbol A is defined such that event A occurs when a check-in event (cType=0) is received in the data stream. Accordingly, symbol A matches a check-in event. B* matches all events other than the required baggage scan, i.e., it is used to ignore all irrelevant events relative to the bag in question. Now, this pattern will match (i.e., the automaton for this pattern will transition to a final state) 5 minutes following the occurrence of the check-in event unless the corresponding baggage scan occurs prior to this. A pattern match in this context corresponds to raising an alert signaling a potential missed bag situation.
  • [0392]
    As with previously described queries, at compile time, an FSA is constructed for query 1300 and the constructed FSA then used to guide the pattern matching during runtime processing. The FSA is constructed as previously described for Class A and Class B patterns with some additional processing as depicted in FIG. 14. FIG. 14 depicts a simplified flowchart 1400 depicting additional processing performed at compile time for a query for detecting non-occurrences according to an embodiment of the present invention. The processing depicted in FIG. 14 may be performed by software (e.g., code, program, instructions) executed by a processor, in hardware, or combinations thereof. The software may be stored on a computer-readable storage medium.
  • [0393]
    As depicted in FIG. 14, determination is made whether the query is one for detecting non-occurrences of a non-event (step 1402). In one embodiment, automaton-generator 114 may determine this based upon the presence or absence of a special language extension clause (e.g., the “INCLUDE TIMER EVENTS” clause in the query). As part of 1402, the input query may be processed to determine the existence of the INCLUDE TIMER EVENTS clause. If such a clause is detected in 1402, then a new variable or symbol (e.g., ‘#’) is introduced into the pattern specified by the query (step 1404). The ‘#’ symbol represents timer events. In one embodiment, the original pattern specified in the query is modified by suffixing a ‘#’ symbol to the pattern. For example, the original “AB*” pattern in FIG. 13 is modified to “AB*#”. This may be done internally by pattern matching module 110. The user or system providing the query need not be aware of this modification. The modified pattern is then treated as a Class B pattern and an FSA is constructed for the modified pattern using the techniques described above for Class B patterns (step 1406). The FSA constructed in 1406 is then used during runtime to guide the detection of non-occurrences of a specific event within a time period following the occurrence of the trigger event. If it is determined in 1402 that the query is not one for detecting non-occurrences, then processing proceeds for construction of a FSA as described above for Class A or Class B patterns (step 1408).
  • [0394]
    As described above, the newly inserted symbol represents a timer event. Unlike the processing described above for Class A and Class B where the arrival of an event triggers the pattern matching analysis and triggers state transitions in an FSA, in case of detection of non-occurrences, the passage of time may also trigger a transition of the FSA to a final state and thus cause an action to be performed. This time-based transition is represented by the ‘#’ symbol.
  • [0395]
    There are different ways in which the passage of time may be detected by pattern matching module 110. In one embodiment, as events are received in the data stream, the timestamps associated with the events are used to detect the passage of time. As previously described, the timestamps associated with events in a data stream may reflect an application's notion of time. For example, the timestamp may be set by an application on the system receiving an event stream or alternatively the timestamp associated with an event may correspond to the time of the application sending the data events. In either scenario, the timestamps associated with events may be used to determine passage of time. For example, a trigger event e1 (e.g., check-in) may have an associated time stamp of t=3. If the time duration for which non-occurrence is to be detected is t=5, then an alert is to be raised if the bag scan event does not arrive within t=(3+5), i.e., before t=8. In this scenario, if an event is received in the data stream with an associated time stamp of t=10, pattern matching module 110 infers the passage of time to t=10, i.e., it denotes a passage of time beyond t=8 and that the non-event has not occurred in the specified time period. In this manner, time stamps associated with events received after the trigger event may be used to determine the passage of time, and thus used to determine non-occurrence of a non-event within the specified time period after the occurrence of a trigger event.
  • [0396]
    In addition to timestamps associated with events, a heartbeat event (or heartbeat) may also be used to determine the passage of time. The heartbeat may be generated by the event processing server based upon a clock of the event processing server or some other time or may be provided by the application. The heartbeat event may be periodically fed to pattern matching module 110 to indicate the passage of time. The heartbeat allows pattern matching module 110 to determine the passage of time without being reliant on the arrival of events in the data stream. This is especially useful when the arrival of events in a data stream is very intermittent and cannot be relied on to determine passage of time. For example, when a data stream goes silent or has not received an event for a certain period of time, pattern matching module 110 may use the heartbeat information to determine passage of time.
  • [0397]
    The runtime processing performed for detecting non-occurrences generally follows the runtime processing performed for detecting presence of Class B patterns as described above with additional processing performed to handle timer events. FIG. 15 depicts a simplified flowchart 1500 depicting processing for detecting non-occurrences according to an embodiment of the present invention. The processing depicted in FIG. 1500 may be performed by software (e.g., code, program, instructions) executed by a processor, in hardware, or combinations thereof. The software may be stored on a computer-readable storage medium. It should be noted that there may be several active bindings present when an input is received. The processing in FIG. 15 and described below would be applied to all these bindings.
  • [0398]
    As depicted in FIG. 15, a new input is received (step 1502). The new input may be an actual event received in the data stream or a heartbeat event. A list of active bindings BINDING_LIST is then accessed (step 1504). In one embodiment, the bindings in the BINDING_LIST are sorted in non-decreasing order based upon the target times associated with the bindings in the list. Accordingly, in the sorted BINDING_LIST, the top element in the list is a binding with the least associated value of target time.
  • [0399]
    A target time associated with a binding is defined as the time of the first element of the binding plus the duration specified in the query. The first element is the triggering event. For example, in the “AB*” example of FIG. 13, the event matching symbol “A” would be the first event or trigger event. The trigger event is the event that results in the construction of a new binding (see 1524 below) (as opposed to other events, the B's in the AB* example, that result in “growing” an existing binding but not creating a new binding). As an example, if the time of the first element (the trigger element) is t=1, and the time duration is t=5 units, then the target time associated with the active binding is t=6. For example, if the active binding is for AB*#, then the target time is the time of event A plus the time duration.
  • [0400]
    The top element (i.e., the binding with the least associated target time) is then selected from BINDING_LIST and referred to as binding B (step 1506). A check is then made to see if B is null (step 1508). If B is determined to be null then processing continues with step 1524 described below. If B is determined not to be null, then a check is made to see if the input time (i.e., the time associated with the input received in 1502) is greater than or equal to the target time associated with binding B (step 1510). If it is determined in 1510 that the input time is greater than or equal to the target time associated with binding B, then it is inferred that the time period has elapsed without the occurrence of the event in the context of binding B, i.e., a non-occurrence is detected in the context of binding B. In this situation, it is assumed that a heartbeat event is received at target time associated with binding B that moves the FSA to the final state due to the special symbol # being matched (step 1512). Processing is then performed according to usual Class B processing corresponding to the heartbeat at target time associated with binding B (step 1514). As part of the processing in 1514, an action may be performed such as outputting an alert indicating the non-occurrence of an event in the context of binding B. The timestamp associated with the output event (indicating non-event) is the target time for binding B. As part of the processing in 1514, the current binding B is removed from BINDING_LIST since it was output.
  • [0401]
    The next unprocessed binding from BINDING_LIST is then selected and referred to as binding B (step 1518). Processing then continues with 1508.
  • [0402]
    Referring back to step 1510, if it is determined that the input time is not greater than or equal to the target time associated with binding B (i.e., the input time is less than the target time), then a check is made to see if the input is a heartbeat event (step 1520). If it is determined that the input event received in 1502 is a heartbeat, then no further processing is needed and processing ends. If the input event is not a heartbeat event then the input event is treated as the data event received at the input time and usual Class B processing is performed to determine if any correlation variable predicates are matched by the input event in the context of binding B (step 1522). Processing then continues with step 1518.
  • [0403]
    Referring back to step 1508, if it is determined that B is null then a new binding is created if applicable (input matches alphabet out of start state). A target time is associated with the newly created binding, where the target time is the time of the first element of the new binding (i.e., the current input time) plus the duration specified in the query. The new binding is then inserted into the end of BINDING_LIST. Processing then ends.
  • [0404]
    For example, consider the AB* example of FIG. 13. Suppose A happens at t=1 and target time is t=6. Now, if a non-heartbeat input event “e” is next received is at t=10. In this case, there is only one active binding B. The “implicit/imaginary” heartbeat event at t=6 (with respect to binding B) moves the FSA to a final state (since target time in this case is t=6). There is a round of Class B processing at this time for processing the heartbeat event at t=6. Further Class B processing is then performed to see if the non-heartbeat (data) event with t=10 causes any predicates to be matched.
  • [0405]
    Although steps 1512 and 1514 are shown as separate steps in FIG. 15, the processing performed in these steps may be performed as part of the processing performing in step 1514.
  • [0406]
    The following depicts an example of a stream of events and the corresponding FSA states per the processing depicted in FIG. 15. The example is based upon the query depicted in FIG. 13. The FSA for the query is indicated by the following transition table, where Q0 is the starting state and Q3 is the final state.
  • [0000]
    Transition Table
    Source State Symbol Destination State
    Q0 A Q1
    Q1 B Q2
    Q2 B Q2
    Q2 # Q3
    Q1 # Q3
  • [0407]
    As indicated in the transition table, when in the initial state Q0, if the input event matches A, then the FSA transitions from Q0 to Q1. In state Q1, when the input event matches B, then the FSA moves from Q1 to Q2. In state Q2, when the input event matches B, then the FSA remains in state Q2. In either state Q1 or Q2, upon the detection of a non-occurrence of an event, symbol # is matched, that forces the FSA to move to the final state Q3.
  • [0408]
    For purposes of this example, let the schema of the input stream
    • baggageCheckIn_u_baggageTracking be
    • baggageCheckIn_u_baggageTracking(ctype, reservationLocator, bagId, flightNumber, flightSegment)
      Further, assume that the events on the data stream are:
    • Event e1=(0, p1, bag1, FL100, A-B) at t=1
    • Event e2=(0, p2, bag2, FL100, A-B) at t=2
    • Event e3=(1, p2, bag2, FL100, A-B) at t=3
    • Event e4=(0, p3, bag3, FL100, A-B) at t=4
    • Event e5=(0, p4, bag4, FL100, A-B) at t=15
  • [0416]
    The following depicts that processing that happens at runtime:
  • [0000]
    Before receiving any events there are no bindings.
    • (1) Event e1=(0, p1, bag1, FL100, A-B) at t=1
      A new binding b1 is created where b1=(A=e1, target time=6), state=Q1.
    • (2) Event e2=(0, p2, bag2, FL100, A-B) at t=2
    • For binding b1, the input time is less than the target time (per 1510), so b1 becomes b1=(A=e1, B=e2, target time=6), state=Q2.
      Also since it is ALL MATCHES, a new binding b2 is created with b2=(A=e2, target_time=7), state=Q1.
    • (3) Event e3=(1, p2, bag2, FL100, A-B) at t=3
      For binding b1, the input time is less than the target time (per 1510), so b1 becomes b1=(A=e1,B=e2,B=e3, target time=6), state=Q2.
      For binding b2, the input time is less than the target time (per 1510), however the event does not match symbol B, hence binding b2 is destroyed since it cannot be grown further. Note that this corresponds to passenger p2's bag being scanned within 5 time units of his checkin (p2's check in event was e2).
    • (4) Event e4=(0, p3, bag3, FL100, A-B) at t=4
      For binding b1, the input time is less than the target time (per 1510), so b1 becomes, b1=(A=e1,B=e2,B=e3,B=e4 target time=6), state=Q2.
      Also new binding b3 is created with b3=(A=e4,target time=9) state=Q1.
    • (5) Event e5=(0, p4, bag4, FL100, A-B) at t=15
      For binding b1, the input time is no longer less than the target time (per 1510), so the event is first treated as a heartbeat at t=6 (per 1512).
      Now, b1=(A=e1,B=e2,B=e3,B=e4, #=e5′ target_time=6), state=Q3 where e5′ is the heartbeat inferred from event e5 at t=6. Since Q3 is final state, the non-event corresponding to missed bag scan for passenger p1's bag bag1 is reported.
      But, there is another binding b3 and for binding b3, the input time is not less than the target time (per 1510), so first treat as heartbeat at t=9 (per 1512).
      Now, b3=(A=e4,#=e5″ target time=9) state=Q3 where e5″ is the heartbeat inferred from event e5 at t=9. Since Q3 is final state, the non-event corresponding to missed bag scan for passenger p3's bag bag3 is reported.
      A new binding b4 is created and b4=(A=e5, target time=20) state=Q1
  • [0423]
    In the manner described above, embodiments of the present invention provide language extensions to a querying language such as CQL that enable a user to formulate queries that cause pattern matching module 110 to detect non-occurrences of events for a time period after the occurrence of a trigger event. Various different queries for various different use cases may be formulated using the language extensions. During runtime processing, the pattern specified in the query is modified by suffixing a special symbol (e.g., ‘#’) to the pattern. The ‘#’ symbol represents timer events. An FSA is then built for the modified pattern and used during runtime to guide detection of non-occurrences of non-events.
  • [0424]
    While the description above has described detecting the non-occurrence of an event within a certain time period following occurrence of another event, the teachings described above may also be applied to detecting non-occurrence of an event within a time period following the occurrence of a pattern of events. Further, the teachings described above may also be applied to detecting non-occurrence of a pattern of events within a time period following the occurrence of a pattern of events or the occurrence of an event.
  • [0425]
    In the context of non-event detection, the processing in the case with the PARTITION BY clause is by and large very similar to the case where there is no PARTITION BY clause except for the following differences:
    • (1) The set of bindings when input time>=target time, independent of which partition the binding is associated with, are processed first as per steps 1512, 1514.
    • (2) However when input time is less than the target time, only those bindings that belong to the same partition as the current input are considered. Of course, only case 1 above applies (and this case does not apply) if current event is a heartbeat since a heartbeat is not associated with any specific partition.
  • [0428]
    In one embodiment, to implement the above, the following two sets of data structures are used:
    • (1) A global linked list containing bindings from all partitions sorted in non-decreasing order of target time.
    • (2) A HashTable that is indexed on the partition key. The value for each partition key is the list of all bindings associated with that particular partition.
  • [0431]
    In the case where there is no PARTITION BY clause, only the first data structure is present (this is referred to in FIG. 15 and the description above as BINDING_LIST). The second is not required (does not make sense since there is no partition key since there is no PARTITION BY clause).
  • Detection of Recurring Non-Occurrences of an Event
  • [0432]
    As described above, there is a need in several applications to detect the non-occurrence of an event within a time period following the occurrence of another event. In yet other applications, there is a need to detect recurring instances of such a non-occurrence. These situations may be referred to as “recurring non-event” detection use cases. In these situations, the non-occurrence of a specific event within a time period is to be detected where the time period gets incremented until the occurrence of another event or some stoppage condition is met. It should be noted that the detection of such recurring non-occurrences is not a simple application of multiple detections of non-occurrences described above.
  • [0433]
    For example, consider a flight monitoring application. The requirement in such an application may be to prompt EVERY 5 minutes after a flight's scheduled departure time has passed until the time the flight actually takes off. Such a prompting system may be used by the airport authorities to monitor flight delays and to initiate actions for addressing the causes for the delay.
  • [0434]
    As with detection of a single non-occurrence (described above), in the detection of recurring non-occurrences, the occurrence of a trigger events starts the first time period during which the non-occurrence of a specific event is to be detected. In the above example, the trigger event is the changing of the flight status to FLIGHT DEPARTURE. The trigger event initiates the first timer period of a series of recurring time periods in sequence. The non-occurrence of the FLIGHT TAKE OFF is detected for each time period in the recurring series of time periods. If the non-occurrence of the specified event is detected during a time period then an action, such as an alert, may be taken at the end of that time period (e.g., a prompt every 5 minutes in the above example). The recurring time periods continue until a stoppage condition is met. The stoppage condition may be the occurrence of the specific event, the occurrence of some other event, after the recurrence had occurred for a certain number of times, etc. In this manner, the recurring non-occurrence of a specified event is detected.
  • [0435]
    The pattern matching techniques discussed above may be used to detect such recurring non-occurrences. For example, pattern matching module 110 may be configured to detect such recurring non-occurrences. In one embodiment, language extensions are provided to a language (e.g., to CQL) that enable a user to formulate queries for detection of recurrences of non-occurrences of events using that language. One language extension may enable a user to specify in the query that the query is for detection of non-occurrences of events. Another language extension may enable the user to specify a length of the time period the frequency of recurrence of the time period during which the non-occurrences are to be detected.
  • [0436]
    FIG. 16 depicts an example of a query 1600 that may be used to detect recurring non-occurrences of an event according to an embodiment of the present invention. Query 1600 depicted in FIG. 16 is merely an example of a query that may be used and is not intended to limit the scope of the invention as recited in the claims. Other queries may be used in alternative embodiments.
  • [0437]
    Query 1600 models the delayed flight example discussed above. As depicted in FIG. 16, query 1600 comprises a new language extension “INCLUDE TIMER EVENTS” clause 1604 that indicates that query 1600 is a special query for detecting non-occurrence of an event. Pattern 1602 may be used to specify the trigger event. Another new language extension “DURATION MULTIPLES OF” clause 1606 enables a user to specify a length of a time period and the recurring frequency of the time period after the occurrence of a trigger event within which non-occurrence of a specific event is to be detected. For each time period in the recurring sequence of time periods, one or more actions may be performed upon the detection of a non-occurrence of the specific event within that time period. Various different types of actions may be performed such as raising an alert, preventative actions, and others.
  • [0438]
    In the example depicted in FIG. 16, “Flight_departure_takeoff_stream” is an input stream comprising events including “flights departure announced” and “flight take off” events. In query 1600, the symbol A matches an event where the departure for the flight has been announced. The symbol B* matches all events other than the flight takeoff event for the flight in question. Now, pattern 1606 will match EVERY 5 minutes following the event of the flight departure announcement until the flight takeoff event arrives. In this example, the flight takeoff event is the stoppage condition. A pattern match (i.e., detection of non-occurrence of an event) in this context may take an action such as alerting the concerned authority to take necessary action arising due to delay in the flight takeoff. In the above, example, the stoppage condition is the occurrence of the flight takeoff event, which is also the event whose non-occurrence is being detected.
  • [0439]
    As described above for detection of non-occurrence of an event, the passage of time may be determined based upon times associated with events received via the data stream and/or based upon a heartbeat. This is also the case for detecting recurring non-occurrences.
  • [0440]
    At compile time, an FSA is constructed for query 1600 and the constructed FSA then used to guide the pattern matching during runtime processing. The FSA is constructed as previously described for Class A and Class B patterns with some additional processing as depicted in FIG. 14 and describe above. As part of the processing, upon determining that the query is for detection of non-occurrences of an event (e.g., due to the presence of INCLUDE TIME EVENTS clause 1606 in the query), a special symbol (e.g., ‘#’) is introduced into the pattern specified by the query. For example, the original “AB*” pattern in FIG. 16 is modified to “AB*#”. The modified pattern is then treated as a Class B pattern and an FSA is constructed for the modified pattern using the techniques described above for Class B patterns. The constructed FSA is then used during runtime to guide the detection of recurring non-occurrences after the occurrence of a trigger event and until the stoppage condition is satisfied.
  • [0441]
    FIG. 17 depicts a simplified flowchart 1700 depicting processing for detecting recurring non-occurrences according to an embodiment of the present invention. The processing depicted in FIG. 1700 may be performed by software (e.g., code, program, instructions) executed by a processor, in hardware, or combinations thereof. The software may be stored on a computer-readable storage medium. It should be noted that there may be several active bindings present when an input is received. The processing in FIG. 17 and described below would be applied to these bindings.
  • [0442]
    Flowchart 1700 depicted in FIG. 17 is quite similar to flowchart 1500 depicted in FIG. 15 with step 1702 replacing step 1514 in FIG. 15. The other steps are as described above with respect to FIG. 15. In step 1702, processing is performed according to usual Class B processing corresponding to the heartbeat at target time associated with binding B. As part of the processing in 1702, an action may be performed such as outputting an alert indicating the non-occurrence of an event in the context of binding B. The timestamp associated with the output event (indicating non-event) is the target time for binding B. As part of the processing in 1702, the current binding B is removed from BINDING_LIST since it was output. Further, as part of the processing in 1702, a new binding is created based upon the binding that was output. An incremented target time is associated with the new binding, where the target time is the previous target time incremented by the period specified in the query. The new binding with the associated new target time is then inserted at the end of BINDING_LIST. Processing then continues with step 1518.
  • [0443]
    The following example is based upon the query depicted in FIG. 16. The FSA for the query is indicated by the transition table shown below, where Q0 is the starting state and Q3 is the final state.
  • [0000]
    Transition Table
    Source State Symbol Destination State
    Q0 A Q1
    Q1 B Q2
    Q2 B Q2
    Q2 # Q3
    Q1 # Q3
  • [0444]
    For purposes of this example, let the schema of the input stream
    • Flight_departure_takeoff_stream be
    • Flight_departure_takeoff_stream (ctype, flightNumber)
    • Ctype=0 indicates a departure announcement event
    • Ctype=1 indicates a flight take off event
  • [0449]
    Further, assume that the events received on the data stream are:
    • Event e1=(0, FL100) at t=1
    • Event e2=(0, FL101) at t=3
    • Event e3=heartbeat at t=6
    • Event e4=(1, FL101) at t=7
    • Event e5=(0, FL102) at t=13
    • Event e6=(1, FL100) at t=15
      The following depicts that processing that happens at runtime for the events received as shown above:
  • [0456]
    Before receiving any events there are no bindings.
    • (1) Event e1=(0, FL100) at t=1
      A new binding b1 is created where b1=(A=e1, target time=6), state=Q1.
    • (2) Event e2=(0, FL101) at t=3
      For binding b1, the input time (3) is less than the target time (6), so b1 becomes b1=(A=e1,
    • B=e2, target time=6), state=Q2.
      A new binding b2 is created with b2=(A=e2, target time=8), state=Q1.
    • (3) Event e3=heartbeat at t=6
      For binding b1, input time=target time, hence b1 becomes b1=(A=e1, B=e2, #=e3, target time=6) state=Q3. Since Q3 is final, the non-event corresponding to flight takeoff delayed is reported. Further, new binding b3 is created based on b1 and its target time is further incremented by 5 units. So b3=(A=e1,B=e2, target time=11) state=Q2
      For binding b2, input time<target time, so there is no further processing since input is a heartbeat.
    • (4) Event e4=(1, FL101) at t=7
      For binding b2, input time (7) <target_time (8), but the binding cannot be grown since event does not match symbol B (for this binding). Hence the binding is deleted. This corresponds to takeoff of flight within the time limit following the departure announcement, i.e., there is no delay in flight takeoff.
      For binding b3, input time(7) <target_time(11), so b3 becomes b3=(A=e1,B=e2, B=e4 target time=11) state=Q2
    • (5) Event e5=(0, FL102) at t=13
      For binding b3, input_time (13)>target_time (11).
      The event is first treated as a heartbeat event e5′ at t=1.
      Hence b3 becomes b3=(A=e1,B=e2, B=e4, #=e5′,target time=11) state=Q3. Since the non-event corresponding to flight takeoff delayed is reported (for a second time for flight FL100) at t=11.
      Further, new binding b4 is created based on b3 and its target time is further incremented by 5 units. So b4=(A=e1, B=e2, B=e4 target time=16 ) state=Q2. b4 is added to the end of the BINDING_LIST.
      Now treat as data event e5 at t=13
      But there is binding b4 yet to process. For binding b4, input time (13) <target time (16), so b4 becomes b4=(A=e1,B=e2, B=e4, B=e5 target time=16) state=Q2
      A new binding b5 is created with b5=(A=e5, target time=18), state=Q1.
    • (6) Event e6=(1, FL100) at t=15
      For binding b4, input_time (15) <target_time (16), but the binding cannot be grown since event does not match symbol B (for this binding). Hence the binding is deleted. This corresponds to takeoff of flight—thus no further monitoring for takeoff delays for this flight.
      For binding b5, input_time (15) <target_time (18), hence b5 becomes b5=(A=e5, B=e6, target_time=18), state=Q2.
  • [0464]
    In the manner described above, embodiments of the present invention provide language extensions (e.g., ANSI extensions) to a querying language such as CQL that enable a user to formulate queries that cause pattern matching module 110 to detect non-occurrences of a specific event for recurring time periods following the occurrence of a trigger event until a stoppage condition is met.
  • [0465]
    While the description above has described detecting the non-occurrence of an event over recurring time periods following occurrence of another event, the teachings described above may also be applied to detecting non-occurrence of an event over recurring time periods following the occurrence of a pattern of events. Further, the teachings described above may also be applied to detecting non-occurrence of a pattern of events over recurring time periods following the occurrence of a pattern of events or the occurrence of an event.
  • [0466]
    FIG. 18 is a simplified block diagram illustrating components of a system environment 1800 that may be used in accordance with an embodiment of the present invention. As shown, system environment 1800 includes one or more client computing devices 1802, 1804, 1806, 1808, which are configured to operate a client application such as a web browser, proprietary client (e.g., Oracle Forms), or the like. In various embodiments, client computing devices 1802, 1804, 1806, and 1808 may interact with a server 1812.
  • [0467]
    Client computing devices 1802, 1804, 1806, 1808 may be general purpose personal computers (including, by way of example, personal computers and/or laptop computers running various versions of Microsoft Windows and/or Apple Macintosh operating systems), cell phones or PDAs (running software such as Microsoft Windows Mobile and being Internet, e-mail, SMS, Blackberry, or other communication protocol enabled), and/or workstation computers running any of a variety of commercially-available UNIX or UNIX-like operating systems (including without limitation the variety of GNU/Linux operating systems). Alternatively, client computing devices 1802, 1804, 1806, and 1808 may be any other electronic device, such as a thin-client computer, Internet-enabled gaming system, and/or personal messaging device, capable of communicating over a network (e.g., network 1810 described below). Although exemplary system environment 1800 is shown with four client computing devices, any number of client computing devices may be supported. Other devices such as devices with sensors, etc. may interact with server 1812.
  • [0468]
    System environment 1800 may include a network 1810. Network 1810 may be any type of network familiar to those skilled in the art that can support data communications using any of a variety of commercially-available protocols, including without limitation TCP/IP, SNA, IPX, AppleTalk, and the like. Merely by way of example, network 1810 can be a local area network (LAN), such as an Ethernet network, a Token-Ring network and/or the like; a wide-area network; a virtual network, including without limitation a virtual private network (VPN); the Internet; an intranet; an extranet; a public switched telephone network (PSTN); an infra-red network; a wireless network (e.g., a network operating under any of the IEEE 802.11 suite of protocols, the Bluetooth protocol known in the art, and/or any other wireless protocol); and/or any combination of these and/or other networks.
  • [0469]
    System environment 1800 also includes one or more server computers 1812 which may be general purpose computers, specialized server computers (including, by way of example, PC servers, UNIX servers, mid-range servers, mainframe computers, rack-mounted servers, etc.), server farms, server clusters, or any other appropriate arrangement and/or combination. In various embodiments, server 1812 may be adapted to run one or more services or software applications described in the foregoing disclosure. For example, server 1812 may correspond to a events processing server as depicted in FIG. 1 that include a pattern matching module as depicted in FIG. 1.
  • [0470]
    Server 1812 may run an operating system including any of those discussed above, as well as any commercially available server operating system. Server 1812 may also run any of a variety of additional server applications and/or mid-tier applications, including HTTP servers, FTP servers, CGI servers, Java servers, database servers, and the like. Exemplary database servers include without limitation those commercially available from Oracle, Microsoft, Sybase, IBM and the like.
  • [0471]
    System environment 1800 may also include one or more databases 1814, 1816. Databases 1814, 1816 may reside in a variety of locations. By way of example, one or more of databases 1814, 1816 may reside on a storage medium local to (and/or resident in) server 1812. Alternatively, databases 1814, 1816 may be remote from server 1812, and in communication with server 1812 via a network-based or dedicated connection. In one set of embodiments, databases 1814, 1816 may reside in a storage-area network (SAN) familiar to those skilled in the art. Similarly, any necessary files for performing the functions attributed to server 1812 may be stored locally on server 1812 and/or remotely, as appropriate. In one set of embodiments, databases 1814, 1816 may include relational databases, such as Oracle 10 g, that are adapted to store, update, and retrieve data in response to SQL-formatted commands.
  • [0472]
    FIG. 19 is a simplified block diagram of a computer system 1900 that may be used in accordance with embodiments of the present invention. For example server 102 may be implemented using a system such as system 1900. Computer system 1900 is shown comprising hardware elements that may be electrically coupled via a bus 1924. The hardware elements may include one or more central processing units (CPUs) 1902, one or more input devices 1904 (e.g., a mouse, a keyboard, etc.), and one or more output devices 1906 (e.g., a display device, a printer, etc.). Computer system 1900 may also include one or more storage devices 1908. By way of example, the storage device(s) 1908 may include devices such as disk drives, optical storage devices, and solid-state storage devices such as a random access memory (RAM) and/or a read-only memory (ROM), which can be programmable, flash-updateable and/or the like.
  • [0473]
    Computer system 1900 may additionally include a computer-readable storage media reader 1912, a communications subsystem 1914 (e.g., a modem, a network card (wireless or wired), an infra-red communication device, etc.), and working memory 1918, which may include RAM and ROM devices as described above. In some embodiments, computer system 1900 may also include a processing acceleration unit 1916, which can include a digital signal processor (DSP), a special-purpose processor, and/or the like.
  • [0474]
    Computer-readable storage media reader 1912 can further be connected to a computer-readable storage medium 1910, together (and, optionally, in combination with storage device(s) 1908 ) comprehensively representing remote, local, fixed, and/or removable storage devices plus storage media for temporarily and/or more permanently containing computer-readable information. Communications system 1914 may permit data to be exchanged with network 1610 and/or any other computer described above with respect to system environment 1600.
  • [0475]
    Computer system 1900 may also comprise software elements, shown as being currently located within working memory 1918, including an operating system 1920 and/or other code 1922, such as an application program (which may be a client application, Web browser, mid-tier application, RDBMS, etc.). In an exemplary embodiment, working memory 1918 may include executable code and associated data structures (such as caches) used for pattern matching method described above. It should be appreciated that alternative embodiments of computer system 1900 may have numerous variations from that described above. For example, customized hardware might also be used and/or particular elements might be implemented in hardware, software (including portable software, such as applets), or both. Further, connection to other computing devices such as network input/output devices may be employed.
  • [0476]
    Storage media and computer readable media for containing code, or portions of code, can include any appropriate media known or used in the art, including storage media and communication media, such as but not limited to volatile and non-volatile, removable and non-removable media implemented in any method or technology for storage and/or transmission of information such as computer readable instructions, data structures, program modules, or other data, including RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disk (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, data signals, data transmissions, or any other medium which can be used to store or transmit the desired information and which can be accessed by a computer.
  • [0477]
    Although specific embodiments of the invention have been described, various modifications, alterations, alternative constructions, and equivalents are also encompassed within the scope of the invention. Embodiments of the present invention are not restricted to operation within certain specific data processing environments, but are free to operate within a plurality of data processing environments. Additionally, although embodiments of the present invention have been described using a particular series of transactions and steps, it should be apparent to those skilled in the art that the scope of the present invention is not limited to the described series of transactions and steps.
  • [0478]
    Further, while embodiments of the present invention have been described using a particular combination of hardware and software, it should be recognized that other combinations of hardware and software are also within the scope of the present invention. Embodiments of the present invention may be implemented only in hardware, or only in software, or using combinations thereof.
  • [0479]
    The specification and drawings are, accordingly, to be regarded in an illustrative rather than a restrictive sense. It will, however, be evident that additions, subtractions, deletions, and other modifications and changes may be made thereunto without departing from the broader spirit and scope as set forth in the claims.

Claims (20)

  1. 1. A computer-readable storage medium storing a plurality of instructions for controlling a processor to process a data stream of events, the plurality of instructions comprising:
    instructions that cause the processor to receive a query for detecting non-occurrence of a first event within a time period following occurrence of a second event, the query specifying a pattern;
    instructions that cause the processor to generate a modified pattern by adding a first symbol to the pattern;
    instructions that cause the processor to generate an automaton for the query based upon the modified pattern; and
    instructions that cause the processor to detect an instance in the data stream of non-occurrence of the first event within the time period following occurrence of the second event using the automaton.
  2. 2. The computer-readable storage medium of claim 1 wherein the plurality of instructions further comprises:
    instructions that cause the processor to determine whether the query is for detecting non-occurrence of the first event; and
    instructions that cause the processor to, generate the modified pattern only upon determining that the query is for detecting non-occurrence of the first event.
  3. 3. The computer-readable storage medium of claim 1 wherein the plurality of instructions comprises instructions that cause the processor to determine the time period from the query.
  4. 4. The computer-readable storage medium of claim 1 wherein the plurality of instructions that cause the processor to detect the one or more instances comprises:
    instructions that cause the processor to, associate a target time with a binding, wherein the target time is based upon the time of the first element in the binding and the time period;
    instructions that cause the processor to receive an input; and
    instructions that cause the processor to compare a time associated with the input with the target time.
  5. 5. The computer-readable storage medium of claim 4 wherein the input is a heartbeat.
  6. 6. The computer-readable storage medium of claim 4 wherein the input is another event received in the data stream.
  7. 7. The computer-readable storage medium of claim 4 wherein the plurality of instructions further comprise:
    instructions that cause the processor to, upon determining that the time associated with the input equals or exceeds the target time, cause the automaton to move to a final state.
  8. 8. A system for processing a data stream of events, the system comprising:
    a memory storing a plurality of instructions: and
    a processor coupled to the memory, the processor configured to execute the plurality of instructions to:
    receive a query for detecting non-occurrence of a first event within a time period following occurrence of a second event, the query specifying a pattern;
    generate a modified pattern by adding a first symbol to the pattern;
    generate an automaton for the query based upon the modified pattern; and
    detect an instance in the data stream of non-occurrence of the first event within the time period following occurrence of the second event using the automaton.
  9. 9. The system of claim 8 wherein the processor is configured to:
    determine whether the query is for detecting non-occurrence of the first event; and
    generate the modified pattern only upon determining that the query is for detecting non-occurrence of the first event.
  10. 10. The system of claim 8 wherein the processor is configured to determine the time period from the query.
  11. 11. The system of claim 8 wherein the processor is configured to:
    associate a target time with a binding, wherein the target time is based upon the time of the first element in the binding and the time period;
    receive an input; and
    compare a time associated with the input with the target time.
  12. 12. The system of claim 11 wherein the input is a heartbeat.
  13. 13. The system of claim 11 wherein the input is another event received in the data stream.
  14. 14. The system of claim 11 wherein the processor is configured to, upon determining that the time associated with the input equals or exceeds the target time, cause the automaton to move to a final state.
  15. 15. A computer-implemented method of processing a data stream of events, the method comprising:
    receive, by a processing system, a query for detecting non-occurrence of a first event within a time period following occurrence of a second event, the query specifying a pattern;
    generating, by the processing system, a modified pattern by adding a first symbol to the pattern string;
    generating, by the processing system, an automaton for the query based upon the modified pattern; and
    detecting, by the processing system, an instance an instance in the data stream of non-occurrence of the first event within the time period following occurrence of the second event using the automaton.
  16. 16. The method of claim 15 further comprising:
    determining, by the processing system, whether the query is for detecting non-occurrence of the first event; and
    generating, by the processing system, a modified pattern by adding a first symbol to the pattern only upon determining that the query is for detecting non-occurrence of the first event.
  17. 17. The method of claim 15 further comprising determining, by the processing system, the time period from the query.
  18. 18. The method of claim 15 wherein detecting the one or more instances comprises:
    associating a target time with a binding, wherein the target time is based upon the time of the first element in the binding and the time period;
    receiving an input; and
    comparing a time associated with the input with the target time.
  19. 19. The method of claim 18 wherein the input is a heartbeat or another event received in the data stream.
  20. 20. The method of claim 18 further comprising, upon determining that the time associated with the input equals or exceeds the target time, causing the automaton to move to a final state.
US12548281 2008-08-29 2009-08-26 Detection of non-occurrences of events using pattern matching Abandoned US20100057737A1 (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
US9298308 true 2008-08-29 2008-08-29
US12548281 US20100057737A1 (en) 2008-08-29 2009-08-26 Detection of non-occurrences of events using pattern matching

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
US12548281 US20100057737A1 (en) 2008-08-29 2009-08-26 Detection of non-occurrences of events using pattern matching

Publications (1)

Publication Number Publication Date
US20100057737A1 true true US20100057737A1 (en) 2010-03-04

Family

ID=41726784

Family Applications (5)

Application Number Title Priority Date Filing Date
US12548281 Abandoned US20100057737A1 (en) 2008-08-29 2009-08-26 Detection of non-occurrences of events using pattern matching
US12548222 Active 2030-05-25 US8589436B2 (en) 2008-08-29 2009-08-26 Techniques for performing regular expression-based pattern matching in data streams
US12548290 Active 2029-08-29 US8676841B2 (en) 2008-08-29 2009-08-26 Detection of recurring non-occurrences of events using pattern matching
US12548209 Active 2031-09-10 US8498956B2 (en) 2008-08-29 2009-08-26 Techniques for matching a certain class of regular expression-based patterns in data streams
US12548187 Active 2030-01-25 US9305238B2 (en) 2008-08-29 2009-08-26 Framework for supporting regular expression-based pattern matching in data streams

Family Applications After (4)

Application Number Title Priority Date Filing Date
US12548222 Active 2030-05-25 US8589436B2 (en) 2008-08-29 2009-08-26 Techniques for performing regular expression-based pattern matching in data streams
US12548290 Active 2029-08-29 US8676841B2 (en) 2008-08-29 2009-08-26 Detection of recurring non-occurrences of events using pattern matching
US12548209 Active 2031-09-10 US8498956B2 (en) 2008-08-29 2009-08-26 Techniques for matching a certain class of regular expression-based patterns in data streams
US12548187 Active 2030-01-25 US9305238B2 (en) 2008-08-29 2009-08-26 Framework for supporting regular expression-based pattern matching in data streams

Country Status (1)

Country Link
US (5) US20100057737A1 (en)

Cited By (38)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20100057663A1 (en) * 2008-08-29 2010-03-04 Oracle International Corporation Techniques for matching a certain class of regular expression-based patterns in data streams
US20100223606A1 (en) * 2009-03-02 2010-09-02 Oracle International Corporation Framework for dynamically generating tuple and page classes
US20100223305A1 (en) * 2009-03-02 2010-09-02 Oracle International Corporation Infrastructure for spilling pages to a persistent store
US20110023055A1 (en) * 2009-07-21 2011-01-27 Oracle International Corporation Standardized database connectivity support for an event processing server
US20110022618A1 (en) * 2009-07-21 2011-01-27 Oracle International Corporation Standardized database connectivity support for an event processing server in an embedded context
US20110029484A1 (en) * 2009-08-03 2011-02-03 Oracle International Corporation Logging framework for a data stream processing server
US20110029485A1 (en) * 2009-08-03 2011-02-03 Oracle International Corporation Log visualization tool for a data stream processing server
US20110137942A1 (en) * 2009-12-09 2011-06-09 Sap Ag Scheduling for Fast Response Multi-Pattern Matching Over Streaming Events
US20110161321A1 (en) * 2009-12-28 2011-06-30 Oracle International Corporation Extensibility platform using data cartridges
US20110161328A1 (en) * 2009-12-28 2011-06-30 Oracle International Corporation Spatial data cartridge for event processing systems
US20110295894A1 (en) * 2010-05-27 2011-12-01 Samsung Sds Co., Ltd. System and method for matching pattern
US20110302264A1 (en) * 2010-06-02 2011-12-08 International Business Machines Corporation Rfid network to support processing of rfid data captured within a network domain
US8145859B2 (en) 2009-03-02 2012-03-27 Oracle International Corporation Method and system for spilling from a queue to a persistent store
US20120150887A1 (en) * 2010-12-08 2012-06-14 Clark Christopher F Pattern matching
CN102662735A (en) * 2012-03-08 2012-09-12 中国科学院自动化研究所 Composite event detection method and system for real-time perception environment
US20140095533A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Fast path evaluation of boolean predicates
US8713049B2 (en) 2010-09-17 2014-04-29 Oracle International Corporation Support for a parameterized query/view in complex event processing
US20140149419A1 (en) * 2012-11-29 2014-05-29 Altibase Corp. Complex event processing apparatus for referring to table within external database as external reference object
US20140201225A1 (en) * 2013-01-15 2014-07-17 Oracle International Corporation Variable duration non-event pattern matching
US20140365524A1 (en) * 2013-06-10 2014-12-11 International Business Machines Corporation Incremental aggregation-based event pattern matching
US8959106B2 (en) 2009-12-28 2015-02-17 Oracle International Corporation Class loading using java data cartridges
US8990416B2 (en) 2011-05-06 2015-03-24 Oracle International Corporation Support for a new insert stream (ISTREAM) operation in complex event processing (CEP)
US9047249B2 (en) 2013-02-19 2015-06-02 Oracle International Corporation Handling faults in a continuous event processing (CEP) system
US20150227373A1 (en) * 2014-02-07 2015-08-13 King Fahd University Of Petroleum And Minerals Stop bits and predication for enhanced instruction stream control
US20150302055A1 (en) * 2013-05-31 2015-10-22 International Business Machines Corporation Generation and maintenance of synthetic context events from synthetic context objects
US9189280B2 (en) 2010-11-18 2015-11-17 Oracle International Corporation Tracking large numbers of moving objects in an event processing system
US9244978B2 (en) 2014-06-11 2016-01-26 Oracle International Corporation Custom partitioning of a data stream
US9262479B2 (en) 2012-09-28 2016-02-16 Oracle International Corporation Join operations for continuous queries over archived views
US20160119217A1 (en) * 2014-10-24 2016-04-28 Tektronix, Inc. Hardware trigger generation from a declarative protocol description
US9329975B2 (en) 2011-07-07 2016-05-03 Oracle International Corporation Continuous query language (CQL) debugger in complex event processing (CEP)
US9390135B2 (en) 2013-02-19 2016-07-12 Oracle International Corporation Executing continuous event processing (CEP) queries in parallel
US20160210021A1 (en) * 2015-01-21 2016-07-21 Microsoft Technology Licensing, Llc Computer-Implemented Tools for Exploring Event Sequences
US9418113B2 (en) 2013-05-30 2016-08-16 Oracle International Corporation Value based windows on relations in continuous data streams
US20170024439A1 (en) * 2015-07-21 2017-01-26 Oracle International Corporation Accelerated detection of matching patterns
US20170154080A1 (en) * 2015-12-01 2017-06-01 Microsoft Technology Licensing, Llc Phasing of multi-output query operators
US9712645B2 (en) 2014-06-26 2017-07-18 Oracle International Corporation Embedded event processing
US9886486B2 (en) 2014-09-24 2018-02-06 Oracle International Corporation Enriching events with dynamically typed big data for event processing
US9934279B2 (en) 2014-12-03 2018-04-03 Oracle International Corporation Pattern matching across multiple input data streams

Families Citing this family (20)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
WO2010071998A1 (en) * 2008-12-23 2010-07-01 Andrew Wong System, method and computer program for pattern based intelligent control, monitoring and automation
US9507880B2 (en) * 2010-06-30 2016-11-29 Oracle International Corporation Regular expression optimizer
US9477537B2 (en) * 2010-12-13 2016-10-25 Microsoft Technology Licensing, Llc Reactive coincidence
US20120158768A1 (en) * 2010-12-15 2012-06-21 Microsoft Corporation Decomposing and merging regular expressions
US9246928B2 (en) * 2011-05-02 2016-01-26 International Business Machines Corporation Compiling pattern contexts to scan lanes under instruction execution constraints
JP5589952B2 (en) * 2011-05-12 2014-09-17 富士通株式会社 Verification device and collation program
EP2600326A1 (en) 2011-11-29 2013-06-05 ATS Group (IP Holdings) Limited Processing event data streams to recognize event patterns, with conditional query instance shifting for load balancing
US9213735B1 (en) * 2012-01-25 2015-12-15 Google Inc. Flow control in very large query result sets using a release message to confirm that a client computer is ready to receive the data associated with a data collection operation
US9116947B2 (en) 2012-03-15 2015-08-25 Hewlett-Packard Development Company, L.P. Data-record pattern searching
EP2856332A4 (en) * 2012-05-30 2016-02-24 Hewlett Packard Development Co Parameter adjustment for pattern discovery
US8793251B2 (en) * 2012-07-31 2014-07-29 Hewlett-Packard Development Company, L.P. Input partitioning and minimization for automaton implementations of capturing group regular expressions
US20140201355A1 (en) * 2013-01-15 2014-07-17 Oracle International Corporation Variable duration windows on continuous data streams
US9047343B2 (en) 2013-01-15 2015-06-02 International Business Machines Corporation Find regular expression instruction on substring of larger string
US20140280220A1 (en) * 2013-03-13 2014-09-18 Sas Institute Inc. Scored storage determination
EP2784692A1 (en) * 2013-03-28 2014-10-01 Hewlett-Packard Development Company, L.P. Filter regular expression
US9710360B2 (en) 2013-06-27 2017-07-18 Nxp Usa, Inc. Optimizing error parsing in an integrated development environment
US9923767B2 (en) * 2014-04-15 2018-03-20 Splunk Inc. Dynamic configuration of remote capture agents for network data capture
US9804951B2 (en) * 2014-10-08 2017-10-31 Signalfx, Inc. Quantization of data streams of instrumented software
US9846574B2 (en) * 2014-12-19 2017-12-19 Signalfx, Inc. Representing result data streams based on execution of data stream language programs
US20160283854A1 (en) 2015-03-27 2016-09-29 International Business Machines Corporation Fingerprinting and matching log streams

Citations (84)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5706494A (en) * 1995-02-10 1998-01-06 International Business Machines Corporation System and method for constraint checking bulk data in a database
US6011916A (en) * 1998-05-12 2000-01-04 International Business Machines Corp. Java I/O toolkit for applications and applets
US6041344A (en) * 1997-06-23 2000-03-21 Oracle Corporation Apparatus and method for passing statements to foreign databases by using a virtual package
US6341281B1 (en) * 1998-04-14 2002-01-22 Sybase, Inc. Database system with methods for optimizing performance of correlated subqueries by reusing invariant results of operator tree
US20020023211A1 (en) * 2000-06-09 2002-02-21 Steven Roth Dynamic kernel tunables
US6353821B1 (en) * 1999-12-23 2002-03-05 Bull Hn Information Systems Inc. Method and data processing system for detecting patterns in SQL to allow optimized use of multi-column indexes
US20020038313A1 (en) * 1999-07-06 2002-03-28 Compaq Computer Corporation System and method for performing database operations on a continuous stream of tuples
US6367034B1 (en) * 1998-09-21 2002-04-02 Microsoft Corporation Using query language for event filtering and aggregation
US20020049788A1 (en) * 2000-01-14 2002-04-25 Lipkin Daniel S. Method and apparatus for a web content platform
US6389436B1 (en) * 1997-12-15 2002-05-14 International Business Machines Corporation Enhanced hypertext categorization using hyperlinks
US6507834B1 (en) * 1999-12-22 2003-01-14 Ncr Corporation Method and apparatus for parallel execution of SQL from stored procedures
US20030046673A1 (en) * 2001-06-29 2003-03-06 Microsoft Corporation Linktime recognition of alternative implementations of programmed functionality
US20030065655A1 (en) * 2001-09-28 2003-04-03 International Business Machines Corporation Method and apparatus for detecting query-driven topical events using textual phrases on foils as indication of topic
US20040010496A1 (en) * 2002-06-05 2004-01-15 Sap Aktiengesellschaft Apparatus and method for integrating variable subsidiary information with main office information in an enterprise system
US6681343B1 (en) * 1999-08-24 2004-01-20 Nec Electronics Corporation Debugging device and method as well as storage medium
US20040019592A1 (en) * 2000-12-15 2004-01-29 Crabtree Ian B. Method of retrieving entities
US20040024773A1 (en) * 2002-04-29 2004-02-05 Kilian Stoffel Sequence miner
US6718278B1 (en) * 1998-06-11 2004-04-06 At&T Laboratories Cambridge Limited Location system
US20040073534A1 (en) * 2002-10-11 2004-04-15 International Business Machines Corporation Method and apparatus for data mining to discover associations and covariances associated with data
US20040151382A1 (en) * 2003-02-04 2004-08-05 Tippingpoint Technologies, Inc. Method and apparatus for data packet pattern matching
US6850925B2 (en) * 2001-05-15 2005-02-01 Microsoft Corporation Query optimization by sub-plan memoization
US6856981B2 (en) * 2001-09-12 2005-02-15 Safenet, Inc. High speed data stream pattern recognition
US20060007308A1 (en) * 2004-07-12 2006-01-12 Ide Curtis E Environmentally aware, intelligent surveillance device
US20060015482A1 (en) * 2004-06-30 2006-01-19 International Business Machines Corporation System and method for creating dynamic folder hierarchies
US6996557B1 (en) * 2000-02-15 2006-02-07 International Business Machines Corporation Method of optimizing SQL queries where a predicate matches nullable operands
US20060047696A1 (en) * 2004-08-24 2006-03-02 Microsoft Corporation Partially materialized views
US7020696B1 (en) * 2000-05-20 2006-03-28 Ciena Corp. Distributed user management information in telecommunications networks
US20060085592A1 (en) * 2004-09-30 2006-04-20 Sumit Ganguly Method for distinct count estimation over joins of continuous update stream
US20060106797A1 (en) * 2004-11-17 2006-05-18 Narayan Srinivasa System and method for temporal data mining
US20060106786A1 (en) * 2004-11-12 2006-05-18 International Business Machines Corporation Adjusting an amount of data logged for a query based on a change to an access plan
US20070016467A1 (en) * 2005-07-13 2007-01-18 Thomas John Method and system for combination of independent demand data streams
US7167848B2 (en) * 2003-11-07 2007-01-23 Microsoft Corporation Generating a hierarchical plain-text execution plan from a database query
US20070050340A1 (en) * 2002-03-16 2007-03-01 Von Kaenel Tim A Method, system, and program for an improved enterprise spatial system
US7203927B2 (en) * 2001-09-20 2007-04-10 International Business Machines Corporation SQL debugging using XML dataflows
US20080005093A1 (en) * 2006-07-03 2008-01-03 Zhen Hua Liu Techniques of using a relational caching framework for efficiently handling XML queries in the mid-tier data caching
US20080010093A1 (en) * 2006-06-30 2008-01-10 Laplante Pierre System and Method for Processing Health Information
US20080033914A1 (en) * 2006-08-02 2008-02-07 Mitch Cherniack Query Optimizer
US20080034427A1 (en) * 2006-08-02 2008-02-07 Nec Laboratories America, Inc. Fast and scalable process for regular expression search
US20080077570A1 (en) * 2004-10-25 2008-03-27 Infovell, Inc. Full Text Query and Search Systems and Method of Use
US20080077587A1 (en) * 2003-02-07 2008-03-27 Safenet, Inc. System and method for determining the start of a match of a regular expression
US20080082484A1 (en) * 2006-09-28 2008-04-03 Ramot At Tel-Aviv University Ltd. Fast processing of an XML data stream
US20080086321A1 (en) * 2006-10-05 2008-04-10 Paul Walton Utilizing historical data in an asset management environment
US20080098359A1 (en) * 2006-09-29 2008-04-24 Ventsislav Ivanov Manipulation of trace sessions based on address parameters
US20090007098A1 (en) * 2005-02-22 2009-01-01 Connectif Solutions, Inc. Distributed Asset Management System and Method
US20090006320A1 (en) * 2007-04-01 2009-01-01 Nec Laboratories America, Inc. Runtime Semantic Query Optimization for Event Stream Processing
US20090006346A1 (en) * 2007-06-29 2009-01-01 Kanthi C N Method and Apparatus for Efficient Aggregate Computation over Data Streams
US20090019045A1 (en) * 2002-01-11 2009-01-15 International Business Machines Corporation Syntheszing information-bearing content from multiple channels
US20090024622A1 (en) * 2007-07-18 2009-01-22 Microsoft Corporation Implementation of stream algebra over class instances
US7483976B2 (en) * 1998-08-11 2009-01-27 Computer Associates Think, Inc. Transaction recognition and prediction using regular expressions
US20090070785A1 (en) * 2007-09-11 2009-03-12 Bea Systems, Inc. Concurrency in event processing networks for event server
US20090076899A1 (en) * 2007-09-14 2009-03-19 Gbodimowo Gbeminiyi A Method for analyzing, searching for, and trading targeted advertisement spaces
US20090088962A1 (en) * 2004-09-10 2009-04-02 Alan Henry Jones Apparatus for and method of providing data to an external application
US7519962B2 (en) * 2004-10-07 2009-04-14 Thomson Financial Llc Command script parsing using local and extended storage for command lookup
US7519577B2 (en) * 2003-06-23 2009-04-14 Microsoft Corporation Query intermediate language method and system
US20090106321A1 (en) * 2007-10-17 2009-04-23 Dinesh Das Maintaining and Utilizing SQL Execution Plan Histories
US20090112853A1 (en) * 2007-10-29 2009-04-30 Hitachi, Ltd. Ranking query processing method for stream data and stream data processing system having ranking query processing mechanism
US20090125550A1 (en) * 2007-11-08 2009-05-14 Microsoft Corporation Temporal event stream model
US20100017379A1 (en) * 2008-07-16 2010-01-21 Alexis Naibo Systems and methods to create continuous queries via a semantic layer
US20100017380A1 (en) * 2008-07-16 2010-01-21 Alexis Naibo Systems and methods to create continuous queries associated with push-type and pull-type data
US20100023498A1 (en) * 2004-06-25 2010-01-28 International Business Machines Corporation Relationship management in a data abstraction model
US20100049710A1 (en) * 2008-08-22 2010-02-25 Disney Enterprises, Inc. System and method for optimized filtered data feeds to capture data and send to multiple destinations
US7672964B1 (en) * 2003-12-31 2010-03-02 International Business Machines Corporation Method and system for dynamically initializing a view for a streaming data base system
US7689622B2 (en) * 2007-06-28 2010-03-30 Microsoft Corporation Identification of events of search queries
US20100094838A1 (en) * 2008-10-10 2010-04-15 Ants Software Inc. Compatibility Server for Database Rehosting
US7702629B2 (en) * 2005-12-02 2010-04-20 Exegy Incorporated Method and device for high performance regular expression pattern matching
US7702639B2 (en) * 2000-12-06 2010-04-20 Io Informatics, Inc. System, method, software architecture, and business model for an intelligent object based information technology platform
US20100106946A1 (en) * 2008-10-29 2010-04-29 Hitachi, Ltd. Method for processing stream data and system thereof
US7870124B2 (en) * 2007-12-13 2011-01-11 Oracle International Corporation Rewriting node reference-based XQuery using SQL/SML
US7877381B2 (en) * 2006-03-24 2011-01-25 International Business Machines Corporation Progressive refinement of a federated query plan during query execution
US20110040746A1 (en) * 2009-08-12 2011-02-17 Hitachi, Ltd. Computer system for processing stream data
US7895187B2 (en) * 2006-12-21 2011-02-22 Sybase, Inc. Hybrid evaluation of expressions in DBMS
US7912853B2 (en) * 2007-05-07 2011-03-22 International Business Machines Corporation Query processing client-server database system
US7917299B2 (en) * 2005-03-03 2011-03-29 Washington University Method and apparatus for performing similarity searching on a data stream with respect to a query string
US7930322B2 (en) * 2008-05-27 2011-04-19 Microsoft Corporation Text based schema discovery and information extraction
US20110093162A1 (en) * 2009-08-11 2011-04-21 Certusview Technologies, Llc Systems and methods for complex event processing of vehicle-related information
US8099400B2 (en) * 2006-08-18 2012-01-17 National Instruments Corporation Intelligent storing and retrieving in an enterprise data system
US20120041934A1 (en) * 2007-10-18 2012-02-16 Oracle International Corporation Support for user defined functions in a data stream management system
US8134194B2 (en) * 2008-05-22 2012-03-13 Micron Technology, Inc. Memory cells, memory cell constructions, and memory cell programming methods
US8155880B2 (en) * 2008-05-09 2012-04-10 Locomatix Inc. Location tracking optimizations
US8392402B2 (en) * 2008-12-03 2013-03-05 International Business Machines Corporation Hybrid push/pull execution of continuous SQL queries
US8676841B2 (en) * 2008-08-29 2014-03-18 Oracle International Corporation Detection of recurring non-occurrences of events using pattern matching
US20140095529A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Configurable data windows for archived relations
US20140095444A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation State initialization for continuous queries over archived views
US8713049B2 (en) * 2010-09-17 2014-04-29 Oracle International Corporation Support for a parameterized query/view in complex event processing

Family Cites Families (276)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5051947A (en) 1985-12-10 1991-09-24 Trw Inc. High-speed single-pass textual search processor for locating exact and inexact matches of a search pattern in a textual stream
US4996687A (en) 1988-10-11 1991-02-26 Honeywell Inc. Fault recovery mechanism, transparent to digital system function
US5339392A (en) 1989-07-27 1994-08-16 Risberg Jeffrey S Apparatus and method for creation of a user definable video displayed document showing changes in real time data
US5761493A (en) 1990-04-30 1998-06-02 Texas Instruments Incorporated Apparatus and method for adding an associative query capability to a programming language
US5495600A (en) * 1992-06-03 1996-02-27 Xerox Corporation Conversion of queries to monotonically increasing incremental form to continuously query a append only database
US5918225A (en) 1993-04-16 1999-06-29 Sybase, Inc. SQL-based database system with improved indexing methodology
US5664172A (en) 1994-07-19 1997-09-02 Oracle Corporation Range-based query optimizer
EP0702294A3 (en) 1994-09-13 1997-05-02 Sun Microsystems Inc Method and apparatus for diagnosing lexical errors
US6397262B1 (en) 1994-10-14 2002-05-28 Qnx Software Systems, Ltd. Window kernel
US5829006A (en) 1995-06-06 1998-10-27 International Business Machines Corporation System and method for efficient relational query generation and tuple-to-object translation in an object-relational gateway supporting class inheritance
US6158045A (en) 1995-11-13 2000-12-05 Object Technology Licensing Corporation Portable debugging services utilizing a client debugger object and a server debugger object with flexible addressing support
US5913214A (en) 1996-05-30 1999-06-15 Massachusetts Inst Technology Data extraction from world wide web pages
US5802523A (en) 1996-06-21 1998-09-01 Oracle Corporation Method and apparatus for reducing the memory required to store bind variable descriptors in a database
US5893104A (en) 1996-07-09 1999-04-06 Oracle Corporation Method and system for processing queries in a database system using index structures that are not native to the database system
US5920716A (en) 1996-11-26 1999-07-06 Hewlett-Packard Company Compiling a predicated code with direct analysis of the predicated code
US5937195A (en) 1996-11-27 1999-08-10 Hewlett-Packard Co Global control flow treatment of predicated code
US5937401A (en) 1996-11-27 1999-08-10 Sybase, Inc. Database system with improved methods for filtering duplicates from a tuple stream
US5857182A (en) 1997-01-21 1999-01-05 International Business Machines Corporation Database management system, method and program for supporting the mutation of a composite object without read/write and write/write conflicts
US6108666A (en) * 1997-06-12 2000-08-22 International Business Machines Corporation Method and apparatus for pattern discovery in 1-dimensional event streams
US5822750A (en) 1997-06-30 1998-10-13 International Business Machines Corporation Optimization of correlated SQL queries in a relational database management system
US6112198A (en) 1997-06-30 2000-08-29 International Business Machines Corporation Optimization of data repartitioning during parallel query optimization
US6081801A (en) 1997-06-30 2000-06-27 International Business Machines Corporation Shared nothing parallel execution of procedural constructs in SQL
US6278994B1 (en) 1997-07-10 2001-08-21 International Business Machines Corporation Fully integrated architecture for user-defined search
US6006220A (en) 1997-09-30 1999-12-21 International Business Machines Corporation Determining the optimal access path for a query at execution time using an actual value for each variable in a query for estimating a filter factor
US6006235A (en) 1997-11-26 1999-12-21 International Business Machines Corporation Method and apparatus for invoking a stored procedure or a user defined interpreted language function in a database management system
US6092065A (en) * 1998-02-13 2000-07-18 International Business Machines Corporation Method and apparatus for discovery, clustering and classification of patterns in 1-dimensional event streams
US6263332B1 (en) 1998-08-14 2001-07-17 Vignette Corporation System and method for query processing of structured documents
US6988271B2 (en) * 1998-10-02 2006-01-17 Microsoft Corporation Heavyweight and lightweight instrumentation
US6546381B1 (en) * 1998-11-02 2003-04-08 International Business Machines Corporation Query optimization system and method
US6763353B2 (en) 1998-12-07 2004-07-13 Vitria Technology, Inc. Real time business process analysis method and apparatus
US6108659A (en) 1998-12-22 2000-08-22 Computer Associates Think, Inc. Method and apparatus for executing stored code objects in a database
US6370537B1 (en) 1999-01-14 2002-04-09 Altoweb, Inc. System and method for the manipulation and display of structured data
US6427123B1 (en) 1999-02-18 2002-07-30 Oracle Corporation Hierarchical indexing for accessing hierarchically organized information in a relational system
US7080062B1 (en) 1999-05-18 2006-07-18 International Business Machines Corporation Optimizing database queries using query execution plans derived from automatic summary table determining cost based queries
US6453314B1 (en) 1999-07-30 2002-09-17 International Business Machines Corporation System and method for selective incremental deferred constraint processing after bulk loading data
US20020029207A1 (en) 2000-02-28 2002-03-07 Hyperroll, Inc. Data aggregation server for managing a multi-dimensional database and database management system having data aggregation server integrated therein
US7457279B1 (en) 1999-09-10 2008-11-25 Vertical Communications Acquisition Corp. Method, system, and computer program product for managing routing servers and services
US6766330B1 (en) 1999-10-19 2004-07-20 International Business Machines Corporation Universal output constructor for XML queries universal output constructor for XML queries
US6721727B2 (en) 1999-12-02 2004-04-13 International Business Machines Corporation XML documents stored as column data
US6418448B1 (en) 1999-12-06 2002-07-09 Shyam Sundar Sarkar Method and apparatus for processing markup language specifications for data and metadata used inside multiple related internet documents to navigate, query and manipulate information from a plurality of object relational databases over the web
US20020116371A1 (en) 1999-12-06 2002-08-22 David Dodds System and method for the storage, indexing and retrieval of XML documents using relation databases
JP3937380B2 (en) 1999-12-14 2007-06-27 富士通株式会社 The path search circuit
US6615203B1 (en) 1999-12-17 2003-09-02 International Business Machines Corporation Method, computer program product, and system for pushdown analysis during query plan generation
US6594651B2 (en) * 1999-12-22 2003-07-15 Ncr Corporation Method and apparatus for parallel execution of SQL-from within user defined functions
WO2001059602A9 (en) 2000-02-11 2002-10-17 Acta Technologies Inc Nested relational data model
US7072896B2 (en) 2000-02-16 2006-07-04 Verizon Laboratories Inc. System and method for automatic loading of an XML document defined by a document-type definition into a relational database including the generation of a relational schema therefor
US20020055915A1 (en) 2000-02-28 2002-05-09 Greg Zhang System and method for high speed string matching
US6449620B1 (en) 2000-03-02 2002-09-10 Nimble Technology, Inc. Method and apparatus for generating information pages using semi-structured data stored in a structured manner
US7823066B1 (en) 2000-03-03 2010-10-26 Tibco Software Inc. Intelligent console for content-based interactivity
US6745386B1 (en) * 2000-03-09 2004-06-01 Sun Microsystems, Inc. System and method for preloading classes in a data processing device that does not have a virtual memory manager
US6751619B1 (en) 2000-03-15 2004-06-15 Microsoft Corporation Methods and apparatus for tuple management in data processing system
US6523102B1 (en) * 2000-04-14 2003-02-18 Interactive Silicon, Inc. Parallel compression/decompression system and method for implementation of in-memory compressed cache improving storage density and access speed for industry standard memory subsystems and in-line memory modules
US20050096124A1 (en) 2003-01-21 2005-05-05 Asip Holdings, Inc. Parimutuel wagering system with opaque transactions
US6578032B1 (en) 2000-06-28 2003-06-10 Microsoft Corporation Method and system for performing phrase/word clustering and cluster merging
US7139844B2 (en) 2000-08-04 2006-11-21 Goldman Sachs & Co. Method and system for processing financial data objects carried on broadcast data streams and delivering information to subscribing clients
US7958025B2 (en) 2000-08-04 2011-06-07 Goldman Sachs & Co. Method and system for processing raw financial data streams to produce and distribute structured and validated product offering objects
US6708186B1 (en) 2000-08-14 2004-03-16 Oracle International Corporation Aggregating and manipulating dictionary metadata in a database system
US7095744B2 (en) 2000-11-22 2006-08-22 Dune Networks Method and system for switching variable sized packets
US7062749B2 (en) 2000-12-15 2006-06-13 Promenix, Inc. Measuring, monitoring and tracking enterprise communications and processes
US7185232B1 (en) 2001-02-28 2007-02-27 Cenzic, Inc. Fault injection methods and apparatus
US6542911B2 (en) 2001-03-01 2003-04-01 Sun Microsystems, Inc. Method and apparatus for freeing memory from an extensible markup language document object model tree active in an application cache
WO2002071260A8 (en) * 2001-03-01 2002-12-27 Christian Soendergaard Jensen Adaptable query optimization and evaluation in temporal middleware
GB0108959D0 (en) 2001-04-10 2001-05-30 I2 Ltd Method for identifying patterns
US6748386B1 (en) 2001-04-24 2004-06-08 Nec Corporation System and method for automated construction of URL, cookie, and database query mapping
US6785677B1 (en) 2001-05-02 2004-08-31 Unisys Corporation Method for execution of query to search strings of characters that match pattern with a target string utilizing bit vector
US7540011B2 (en) 2001-06-11 2009-05-26 Arrowsight, Inc. Caching graphical interface for displaying video and ancillary data from a saved video
WO2003027908A3 (en) 2001-09-28 2004-02-12 Oracle Int Corp Providing a consistent hierarchical abstraction of relational data
US7120645B2 (en) 2002-09-27 2006-10-10 Oracle International Corporation Techniques for rewriting XML queries directed to relational database constructs
US6915290B2 (en) 2001-12-11 2005-07-05 International Business Machines Corporation Database query optimization apparatus and method that represents queries as graphs
US7475058B2 (en) 2001-12-14 2009-01-06 Microsoft Corporation Method and system for providing a distributed querying and filtering system
US20030135304A1 (en) 2002-01-11 2003-07-17 Brian Sroub System and method for managing transportation assets
CA2473446A1 (en) 2002-01-14 2003-07-24 Jerzy Lewak Identifier vocabulary data access method and system
US7225188B1 (en) 2002-02-13 2007-05-29 Cisco Technology, Inc. System and method for performing regular expression matching with high parallelism
US6985904B1 (en) * 2002-02-28 2006-01-10 Oracle International Corporation Systems and methods for sharing of execution plans for similar database statements
CA2374271A1 (en) 2002-03-01 2003-09-01 Ibm Canada Limited-Ibm Canada Limitee Redundant join elimination and sub-query elimination using subsumption
US7567953B2 (en) * 2002-03-01 2009-07-28 Business Objects Americas System and method for retrieving and organizing information from disparate computer network information sources
US20080010241A1 (en) * 2002-04-02 2008-01-10 Mcgoveran David O Computer-implemented method for managing through symbolic abstraction of a membership expression multiple logical representations and storage structures
EP1361526A1 (en) 2002-05-08 2003-11-12 Accenture Global Services GmbH Electronic data processing system and method of using an electronic processing system for automatically determining a risk indicator value
US20030236766A1 (en) 2002-05-14 2003-12-25 Zenon Fortuna Identifying occurrences of selected events in a system
US7093023B2 (en) 2002-05-21 2006-08-15 Washington University Methods, systems, and devices using reprogrammable hardware for high-speed processing of streaming data to find a redefinable pattern and respond thereto
US7224185B2 (en) 2002-08-05 2007-05-29 John Campbell System of finite state machines
US7451143B2 (en) 2002-08-28 2008-11-11 Cisco Technology, Inc. Programmable rule processing apparatus for conducting high speed contextual searches and characterizations of patterns in data
US8165993B2 (en) 2002-09-06 2012-04-24 Oracle International Corporation Business intelligence system with interface that provides for immediate user action
US7386568B2 (en) 2003-05-01 2008-06-10 Oracle International Corporation Techniques for partial rewrite of XPath queries in a relational database
FR2846181B1 (en) 2002-10-16 2005-09-02 Canon Kk Method and data selection device in a communication network
US7653645B1 (en) 2002-10-29 2010-01-26 Novell, Inc. Multi-epoch method for saving and exporting file system events
US7213040B1 (en) 2002-10-29 2007-05-01 Novell, Inc. Apparatus for policy based storage of file data and meta-data changes over time
US20040088404A1 (en) 2002-11-01 2004-05-06 Vikas Aggarwal Administering users in a fault and performance monitoring system using distributed data gathering and storage
GB0228447D0 (en) 2002-12-06 2003-01-08 Nicholls Charles M System for detecting and interpreting transactions events or changes in computer systems
US7051034B1 (en) 2002-12-18 2006-05-23 Oracle International Corporation Dynamic optimization for processing a restartable sub-tree of a query execution plan
US7804852B1 (en) 2003-01-24 2010-09-28 Douglas Durham Systems and methods for definition and use of a common time base in multi-protocol environments
US7437675B2 (en) 2003-02-03 2008-10-14 Hewlett-Packard Development Company, L.P. System and method for monitoring event based systems
US7634501B2 (en) 2003-02-05 2009-12-15 Next Generation Software Method and apparatus for mediated cooperation
US7062507B2 (en) 2003-02-24 2006-06-13 The Boeing Company Indexing profile for efficient and scalable XML based publish and subscribe system
US7185315B2 (en) 2003-02-25 2007-02-27 Sheet Dynamics, Ltd. Graphical feedback of disparities in target designs in graphical development environment
US7693810B2 (en) 2003-03-04 2010-04-06 Mantas, Inc. Method and system for advanced scenario based alert generation and processing
US7324108B2 (en) 2003-03-12 2008-01-29 International Business Machines Corporation Monitoring events in a computer network
US7392239B2 (en) 2003-04-14 2008-06-24 International Business Machines Corporation System and method for querying XML streams
CA2427209A1 (en) 2003-04-30 2004-10-30 Ibm Canada Limited - Ibm Canada Limitee Optimization of queries on views defined by conditional expressions having mutually exclusive conditions
US6836778B2 (en) 2003-05-01 2004-12-28 Oracle International Corporation Techniques for changing XML content in a relational database
US7103611B2 (en) 2003-05-01 2006-09-05 Oracle International Corporation Techniques for retaining hierarchical information in mapping between XML documents and relational data
US7222123B2 (en) 2003-05-28 2007-05-22 Oracle International Corporation Technique for using a current lookup for performing multiple merge operations using source data that is modified in between the merge operations
US7546284B1 (en) 2003-06-11 2009-06-09 Blue Titan Software, Inc. Virtual message persistence service
US7146352B2 (en) 2003-06-23 2006-12-05 Microsoft Corporation Query optimizer system and method
CA2433750A1 (en) 2003-06-27 2004-12-27 Ibm Canada Limited - Ibm Canada Limitee Automatic collection of trace detail and history data
EP1649344A4 (en) 2003-07-07 2010-02-10 Netezza Corp Sql code generation for heterogeneous environment
US20050010896A1 (en) 2003-07-07 2005-01-13 International Business Machines Corporation Universal format transformation between relational database management systems and extensible markup language using XML relational transformation
WO2005010727A3 (en) 2003-07-23 2005-06-09 Elliot I Bricker Extracting data from semi-structured text documents
WO2005013053A3 (en) 2003-07-25 2005-07-28 Arthur R Zingher Apparatus and method for software debugging
US7873645B2 (en) 2003-09-05 2011-01-18 Oracle International Corporation Method and mechanism for handling arbitrarily-sized XML in SQL operator tree
US20050097128A1 (en) 2003-10-31 2005-05-05 Ryan Joseph D. Method for scalable, fast normalization of XML documents for insertion of data into a relational database
GB0327589D0 (en) 2003-11-27 2003-12-31 Ibm Searching in a computer network
US7508985B2 (en) * 2003-12-10 2009-03-24 International Business Machines Corporation Pattern-matching system
US7308561B2 (en) 2003-12-12 2007-12-11 Alcatel Lucent Fast, scalable pattern-matching engine
US8775412B2 (en) 2004-01-08 2014-07-08 International Business Machines Corporation Method and system for a self-healing query access plan
US7376656B2 (en) 2004-02-10 2008-05-20 Microsoft Corporation System and method for providing user defined aggregates in a database system
US7194451B2 (en) 2004-02-26 2007-03-20 Microsoft Corporation Database monitoring system
US20050204340A1 (en) 2004-03-10 2005-09-15 Ruminer Michael D. Attribute-based automated business rule identifier and methods of implementing same
US7398265B2 (en) 2004-04-09 2008-07-08 Oracle International Corporation Efficient query processing of XML data using XML index
US20050273352A1 (en) 2004-05-07 2005-12-08 Lombardi Software, Inc. Business method for continuous process improvement
US20050273450A1 (en) * 2004-05-21 2005-12-08 Mcmillen Robert J Regular expression acceleration engine and processing model
US7552365B1 (en) 2004-05-26 2009-06-23 Amazon Technologies, Inc. Web site system with automated processes for detecting failure events and for selecting failure events for which to request user feedback
US7516121B2 (en) 2004-06-23 2009-04-07 Oracle International Corporation Efficient evaluation of queries using translation
US7668806B2 (en) 2004-08-05 2010-02-23 Oracle International Corporation Processing queries against one or more markup language sources
US7310638B1 (en) 2004-10-06 2007-12-18 Metra Tech Method and apparatus for efficiently processing queries in a streaming transaction processing system
EP1825395A4 (en) * 2004-10-25 2010-07-07 Yuanhua Tang Full text query and search systems and methods of use
US7403945B2 (en) 2004-11-01 2008-07-22 Sybase, Inc. Distributed database system providing data and space management methodology
US7533087B2 (en) 2004-11-05 2009-05-12 International Business Machines Corporation Method, system, and program for executing a query having a union all operator and data modifying operations
US20060100969A1 (en) * 2004-11-08 2006-05-11 Min Wang Learning-based method for estimating cost and statistics of complex operators in continuous queries
JP2006155404A (en) 2004-11-30 2006-06-15 Toshiba Corp Time information extraction device, time information extraction method and time information extraction program
US7383253B1 (en) 2004-12-17 2008-06-03 Coral 8, Inc. Publish and subscribe capable continuous query processor for real-time data streams
US20060155719A1 (en) 2005-01-10 2006-07-13 International Business Machines Corporation Complex event discovery in event databases
EP1684192A1 (en) 2005-01-25 2006-07-26 Ontoprise GmbH Integration platform for heterogeneous information sources
KR100690787B1 (en) 2005-02-25 2007-03-09 엘지전자 주식회사 Method for notifying event in the wireless communication system
US8463801B2 (en) 2005-04-04 2013-06-11 Oracle International Corporation Effectively and efficiently supporting XML sequence type and XQuery sequence natively in a SQL system
US7428555B2 (en) 2005-04-07 2008-09-23 Google Inc. Real-time, computer-generated modifications to an online advertising program
US7685150B2 (en) 2005-04-19 2010-03-23 Oracle International Corporation Optimization of queries over XML views that are based on union all operators
JP4687253B2 (en) 2005-06-03 2011-05-25 株式会社日立製作所 Query processing method of the stream data processing system
US20060294095A1 (en) 2005-06-09 2006-12-28 Mantas, Inc. Runtime thresholds for behavior detection
US9792351B2 (en) 2005-06-10 2017-10-17 International Business Machines Corporation Tolerant and extensible discovery of relationships in data using structural information and data analysis
US7818313B1 (en) 2005-07-18 2010-10-19 Sybase, Inc. Method for distributing processing of queries over a cluster of servers in a continuous processing system
JP4723301B2 (en) * 2005-07-21 2011-07-13 株式会社日立製作所 Stream data processing system and the stream data processing method
US7962616B2 (en) * 2005-08-11 2011-06-14 Micro Focus (Us), Inc. Real-time activity monitoring and reporting
WO2007022560A1 (en) 2005-08-23 2007-03-01 Position Networks Pty Ltd A stream-oriented database machine and method
US7990646B2 (en) 2005-09-30 2011-08-02 Seagate Technology Llc Data pattern detection using adaptive search windows
US7937257B2 (en) * 2005-10-10 2011-05-03 Oracle International Corporation Estimating performance of application based on automatic resizing of shared memory for messaging
KR100813000B1 (en) 2005-12-01 2008-03-13 한국전자통신연구원 Stream data processing system and method for avoiding duplication of data processing
US20070136254A1 (en) 2005-12-08 2007-06-14 Hyun-Hwa Choi System and method for processing integrated queries against input data stream and data stored in database using trigger
US7730023B2 (en) 2005-12-22 2010-06-01 Business Objects Sotware Ltd. Apparatus and method for strategy map validation and visualization
US7502889B2 (en) 2005-12-30 2009-03-10 Intel Corporation Home node aware replacement policy for caches in a multiprocessor system
US7814111B2 (en) 2006-01-03 2010-10-12 Microsoft International Holdings B.V. Detection of patterns in data records
US7844829B2 (en) 2006-01-18 2010-11-30 Sybase, Inc. Secured database system with built-in antivirus protection
US20070192301A1 (en) 2006-02-15 2007-08-16 Encirq Corporation Systems and methods for indexing and searching data records based on distance metrics
US20070198479A1 (en) 2006-02-16 2007-08-23 International Business Machines Corporation Streaming XPath algorithm for XPath expressions with predicates
US7446352B2 (en) 2006-03-09 2008-11-04 Tela Innovations, Inc. Dynamic array architecture
US7689582B2 (en) 2006-03-10 2010-03-30 International Business Machines Corporation Data flow system and method for heterogeneous data integration environments
US7536396B2 (en) 2006-03-21 2009-05-19 At&T Intellectual Property Ii, L.P. Query-aware sampling of data streams
US20070226188A1 (en) 2006-03-27 2007-09-27 Theodore Johnson Method and apparatus for data stream sampling
WO2007113533A1 (en) 2006-03-31 2007-10-11 British Telecommunications Public Limited Company Xml-based transfer and a local storage of java objects
US7644066B2 (en) 2006-03-31 2010-01-05 Oracle International Corporation Techniques of efficient XML meta-data query using XML table index
WO2007122347A1 (en) 2006-04-20 2007-11-01 France Telecom Method of optimizing the collecting of events, method of supervision, corresponding computer program products and devices
US7636703B2 (en) * 2006-05-02 2009-12-22 Exegy Incorporated Method and apparatus for approximate pattern matching
US7548937B2 (en) 2006-05-04 2009-06-16 International Business Machines Corporation System and method for scalable processing of multi-way data stream correlations
US8131696B2 (en) 2006-05-19 2012-03-06 Oracle International Corporation Sequence event processing using append-only tables
US7613848B2 (en) 2006-06-13 2009-11-03 International Business Machines Corporation Dynamic stabilization for a stream processing system
US20070294217A1 (en) 2006-06-14 2007-12-20 Nec Laboratories America, Inc. Safety guarantee of continuous join queries over punctuated data streams
US7921046B2 (en) 2006-06-19 2011-04-05 Exegy Incorporated High speed processing of financial information using FPGA devices
US20080016095A1 (en) 2006-07-13 2008-01-17 Nec Laboratories America, Inc. Multi-Query Optimization of Window-Based Stream Queries
US7496683B2 (en) * 2006-07-27 2009-02-24 International Business Machines Corporation Maximization of sustained throughput of distributed continuous queries
WO2008018080A3 (en) 2006-08-11 2008-12-11 Bizwheel Ltd Smart integration engine and metadata-oriented architecture for automatic eii and business integration
KR100778314B1 (en) 2006-08-21 2007-11-22 한국전자통신연구원 System and method for processing continuous integrated queries on both data stream and stored data using user-defined shared trigger
US8260910B2 (en) 2006-09-19 2012-09-04 Oracle America, Inc. Method and apparatus for monitoring a data stream to detect a pattern of data elements using bloom filters
US20080082514A1 (en) * 2006-09-29 2008-04-03 International Business Machines Corporation Method and apparatus for integrating relational and hierarchical data
JP4933222B2 (en) * 2006-11-15 2012-05-16 株式会社日立製作所 Indexing method and a computer system
US20080120283A1 (en) 2006-11-17 2008-05-22 Oracle International Corporation Processing XML data stream(s) using continuous queries in a data stream management system
US9436779B2 (en) 2006-11-17 2016-09-06 Oracle International Corporation Techniques of efficient XML query using combination of XML table index and path/value index
US7899977B2 (en) 2006-12-08 2011-03-01 Pandya Ashish A Programmable intelligent search memory
US7716210B2 (en) * 2006-12-20 2010-05-11 International Business Machines Corporation Method and apparatus for XML query evaluation using early-outs and multiple passes
US8359333B2 (en) 2006-12-29 2013-01-22 Teradata Us, Inc. Virtual regulator for multi-database systems
US20080195577A1 (en) 2007-02-09 2008-08-14 Wei Fan Automatically and adaptively determining execution plans for queries with parameter markers
US7630982B2 (en) 2007-02-24 2009-12-08 Trend Micro Incorporated Fast identification of complex strings in a data stream
US20090327102A1 (en) 2007-03-23 2009-12-31 Jatin Maniar System and method for providing real time asset visibility
US7827146B1 (en) 2007-03-30 2010-11-02 Symantec Operating Corporation Storage system
US8098248B2 (en) 2007-04-02 2012-01-17 International Business Machines Corporation Method for semantic modeling of stream processing components to enable automatic application composition
US8370812B2 (en) 2007-04-02 2013-02-05 International Business Machines Corporation Method and system for automatically assembling processing graphs in information processing systems
US7818292B2 (en) 2007-04-05 2010-10-19 Anil Kumar Nori SQL change tracking layer
JP2008262046A (en) 2007-04-12 2008-10-30 Hitachi Ltd Conference visualizing system and method, conference summary processing server
US8156247B2 (en) 2007-04-30 2012-04-10 Lsi Corportion Systems and methods for reducing network performance degradation
US7945540B2 (en) 2007-05-04 2011-05-17 Oracle International Corporation Method to create a partition-by time/tuple-based window in an event processing service
US7953728B2 (en) 2007-05-18 2011-05-31 Oracle International Corp. Queries with soft time constraints
US8122006B2 (en) 2007-05-29 2012-02-21 Oracle International Corporation Event processing query language including retain clause
US7975109B2 (en) 2007-05-30 2011-07-05 Schooner Information Technology, Inc. System including a fine-grained memory and a less-fine-grained memory
US7933894B2 (en) 2007-06-15 2011-04-26 Microsoft Corporation Parameter-sensitive plans for structural scenarios
FR2918794B1 (en) * 2007-07-09 2009-01-16 Commissariat Energie Atomique Cell memory nonvolatile SRAM endowed of transistors grate and piezoelectric actuation.
US8055653B2 (en) * 2007-08-09 2011-11-08 International Business Machines Corporation Processing overlapping continuous queries
US7827299B2 (en) 2007-09-11 2010-11-02 International Business Machines Corporation Transitioning between historical and real time data streams in the processing of data change messages
US7979420B2 (en) 2007-10-16 2011-07-12 Oracle International Corporation Handling silent relations in a data stream management system
US8296316B2 (en) 2007-10-17 2012-10-23 Oracle International Corporation Dynamically sharing a subtree of operators in a data stream management system operating on existing queries
US7996388B2 (en) 2007-10-17 2011-08-09 Oracle International Corporation Adding new continuous queries to a data stream management system operating on existing queries
US7739265B2 (en) * 2007-10-18 2010-06-15 Oracle International Corporation Deleting a continuous query from a data stream management system continuing to operate on other queries
US7673065B2 (en) * 2007-10-20 2010-03-02 Oracle International Corporation Support for sharing computation between aggregations in a data stream management system
US8521867B2 (en) 2007-10-20 2013-08-27 Oracle International Corporation Support for incrementally processing user defined aggregations in a data stream management system
US7991766B2 (en) 2007-10-20 2011-08-02 Oracle International Corporation Support for user defined aggregations in a data stream management system
US8103655B2 (en) 2007-10-30 2012-01-24 Oracle International Corporation Specifying a family of logics defining windows in data stream management systems
US8019747B2 (en) 2007-10-30 2011-09-13 Oracle International Corporation Facilitating flexible windows in data stream management systems
US8315990B2 (en) 2007-11-08 2012-11-20 Microsoft Corporation Consistency sensitive streaming operators
US8191074B2 (en) 2007-11-15 2012-05-29 Ericsson Ab Method and apparatus for automatic debugging technique
US8156134B2 (en) 2007-11-15 2012-04-10 International Business Machines Corporation Using different groups of query graph transform modules to generate execution plans for queries for different database types
US8429601B2 (en) 2007-11-29 2013-04-23 Red Hat, Inc. Code completion for object relational mapping query language (OQL) queries
CA2710346A1 (en) 2007-12-20 2009-07-02 Hsbc Technologies Inc. Automated methods and systems for developing and deploying projects in parallel
US7882087B2 (en) 2008-01-15 2011-02-01 At&T Intellectual Property I, L.P. Complex dependencies for efficient data warehouse updates
US9489495B2 (en) 2008-02-25 2016-11-08 Georgetown University System and method for detecting, collecting, analyzing, and communicating event-related information
US8812487B2 (en) 2008-03-06 2014-08-19 Cisco Technology, Inc. Addition and processing of continuous SQL queries in a streaming relational database management system
US8055649B2 (en) 2008-03-06 2011-11-08 Microsoft Corporation Scaled management system
WO2009114615A1 (en) 2008-03-11 2009-09-17 Virtual Agility, Inc. Techniques for integrating parameterized information request into a system for collaborative work
US7958114B2 (en) 2008-04-04 2011-06-07 Microsoft Corporation Detecting estimation errors in dictinct page counts
US7872948B2 (en) 2008-04-14 2011-01-18 The Boeing Company Acoustic wide area air surveillance system
US8122050B2 (en) 2008-04-16 2012-02-21 International Business Machines Corporation Query processing visualization system and method of visualizing query processing
JP5198929B2 (en) 2008-04-25 2013-05-15 株式会社日立製作所 Stream data processing method and a computer system
US8886637B2 (en) 2008-05-12 2014-11-11 Enpulz, L.L.C. Web browser accessible search engine which adapts based on user interaction
US8850409B2 (en) 2008-05-21 2014-09-30 Optumsoft, Inc. Notification-based constraint set translation to imperative execution
US8291006B2 (en) 2008-05-30 2012-10-16 International Business Machines Corporation Method for generating a distributed stream processing application
US8918507B2 (en) 2008-05-30 2014-12-23 Red Hat, Inc. Dynamic grouping of enterprise assets
US8112378B2 (en) 2008-06-17 2012-02-07 Hitachi, Ltd. Methods and systems for performing root cause analysis
US20090319501A1 (en) 2008-06-24 2009-12-24 Microsoft Corporation Translation of streaming queries into sql queries
US8316012B2 (en) 2008-06-27 2012-11-20 SAP France S.A. Apparatus and method for facilitating continuous querying of multi-dimensional data streams
CN102077236A (en) 2008-07-03 2011-05-25 松下电器产业株式会社 Impression degree extraction apparatus and impression degree extraction method
US8086644B2 (en) * 2008-07-10 2011-12-27 International Business Machines Corporation Simplifying complex data stream problems involving feature extraction from noisy data
US8037040B2 (en) 2008-08-08 2011-10-11 Oracle International Corporation Generating continuous query notifications
US20110173235A1 (en) 2008-09-15 2011-07-14 Aman James A Session automated recording together with rules based indexing, analysis and expression of content
US8032544B2 (en) 2008-09-24 2011-10-04 The Boeing Company Methods and apparatus for generating dynamic program files based on input queries that facilitate use of persistent query services
US8538981B2 (en) 2008-11-20 2013-09-17 Sap Ag Stream sharing for event data within an enterprise network
US8145621B2 (en) 2008-12-19 2012-03-27 Ianywhere Solutions, Inc. Graphical representation of query optimizer search space in a database management system
US8352517B2 (en) 2009-03-02 2013-01-08 Oracle International Corporation Infrastructure for spilling pages to a persistent store
US8145859B2 (en) 2009-03-02 2012-03-27 Oracle International Corporation Method and system for spilling from a queue to a persistent store
US8935293B2 (en) 2009-03-02 2015-01-13 Oracle International Corporation Framework for dynamically generating tuple and page classes
US8285709B2 (en) 2009-05-12 2012-10-09 Teradata Us, Inc. High-concurrency query operator and method
US8161035B2 (en) 2009-06-04 2012-04-17 Oracle International Corporation Query optimization by specifying path-based predicate evaluation in a path-based query operator
US8868725B2 (en) 2009-06-12 2014-10-21 Kent State University Apparatus and methods for real-time multimedia network traffic management and control in wireless networks
US20100332401A1 (en) 2009-06-30 2010-12-30 Anand Prahlad Performing data storage operations with a cloud storage environment, including automatically selecting among multiple cloud storage sites
US8180801B2 (en) 2009-07-16 2012-05-15 Sap Ag Unified window support for event stream data management
US8321450B2 (en) 2009-07-21 2012-11-27 Oracle International Corporation Standardized database connectivity support for an event processing server in an embedded context
US8387076B2 (en) * 2009-07-21 2013-02-26 Oracle International Corporation Standardized database connectivity support for an event processing server
US8386466B2 (en) 2009-08-03 2013-02-26 Oracle International Corporation Log visualization tool for a data stream processing server
US8527458B2 (en) 2009-08-03 2013-09-03 Oracle International Corporation Logging framework for a data stream processing server
US8204873B2 (en) 2009-08-26 2012-06-19 Hewlett-Packard Development Company, L.P. System and method for query expression optimization
US8195648B2 (en) 2009-10-21 2012-06-05 Microsoft Corporation Partitioned query execution in event processing systems
US9430494B2 (en) 2009-12-28 2016-08-30 Oracle International Corporation Spatial data cartridge for event processing systems
US8959106B2 (en) 2009-12-28 2015-02-17 Oracle International Corporation Class loading using java data cartridges
US9305057B2 (en) 2009-12-28 2016-04-05 Oracle International Corporation Extensible indexing framework using data cartridges
US9307038B2 (en) 2009-12-29 2016-04-05 Motorola Solutions, Inc. Method for presence notification based on a sequence of events
US8423576B2 (en) 2010-01-11 2013-04-16 International Business Machines Corporation System and method for querying data streams
US8762297B2 (en) 2010-05-17 2014-06-24 Microsoft Corporation Dynamic pattern matching over ordered and disordered data streams
US8442863B2 (en) 2010-06-17 2013-05-14 Microsoft Corporation Real-time-ready behavioral targeting in a large-scale advertisement system
US20110314019A1 (en) 2010-06-18 2011-12-22 Universidad Politecnica De Madrid Parallel processing of continuous queries on data streams
US8627329B2 (en) 2010-06-24 2014-01-07 International Business Machines Corporation Multithreaded physics engine with predictive load balancing
US8260803B2 (en) 2010-09-23 2012-09-04 Hewlett-Packard Development Company, L.P. System and method for data stream processing
US20130191370A1 (en) 2010-10-11 2013-07-25 Qiming Chen System and Method for Querying a Data Stream
CN103250147B (en) 2010-10-14 2016-04-20 惠普发展公司,有限责任合伙企业 Continuous data stream query
US20120130963A1 (en) 2010-11-24 2012-05-24 Teradata Us, Inc. User defined function database processing
EP2469420A1 (en) 2010-12-22 2012-06-27 Software AG CEP engine and method for processing CEP queries
US8478743B2 (en) 2010-12-23 2013-07-02 Microsoft Corporation Asynchronous transfer of state information between continuous query plans
US8788484B2 (en) 2010-12-27 2014-07-22 Software Ag Systems and/or methods for user feedback driven dynamic query rewriting in complex event processing environments
US8799271B2 (en) 2011-01-25 2014-08-05 Hewlett-Packard Development Company, L.P. Range predicate canonization for translating a query
US9350567B2 (en) 2011-01-25 2016-05-24 International Business Machines Corporation Network resource configurations
US8655825B2 (en) 2011-03-10 2014-02-18 Sap Ag Efficient management of data quality for streaming event data
US8751639B2 (en) 2011-04-27 2014-06-10 Rackspace Us, Inc. Event queuing and distribution system
WO2012152315A1 (en) 2011-05-10 2012-11-15 Telefonaktiebolaget L M Ericsson (Publ) Optimised data stream management system
US20120324453A1 (en) 2011-06-17 2012-12-20 Microsoft Corporation Efficient logical merging over physically divergent streams
US20130031567A1 (en) 2011-07-25 2013-01-31 Microsoft Corporation Local event processing
US9286354B2 (en) 2011-08-15 2016-03-15 Software Ag Systems and/or methods for forecasting future behavior of event streams in complex event processing (CEP) environments
US8635208B2 (en) 2011-11-03 2014-01-21 Sap Ag Multi-state query migration in data stream management
US9424150B2 (en) 2011-12-06 2016-08-23 Sap Se Fault tolerance based query execution
EP2823412A1 (en) 2012-03-08 2015-01-14 Telefonaktiebolaget L M Ericsson (PUBL) Data stream management systems
US20130332240A1 (en) 2012-06-08 2013-12-12 University Of Southern California System for integrating event-driven information in the oil and gas fields
US9053210B2 (en) 2012-12-14 2015-06-09 Microsoft Technology Licensing, Llc Graph query processing using plurality of engines

Patent Citations (101)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5706494A (en) * 1995-02-10 1998-01-06 International Business Machines Corporation System and method for constraint checking bulk data in a database
US6041344A (en) * 1997-06-23 2000-03-21 Oracle Corporation Apparatus and method for passing statements to foreign databases by using a virtual package
US6389436B1 (en) * 1997-12-15 2002-05-14 International Business Machines Corporation Enhanced hypertext categorization using hyperlinks
US6341281B1 (en) * 1998-04-14 2002-01-22 Sybase, Inc. Database system with methods for optimizing performance of correlated subqueries by reusing invariant results of operator tree
US6011916A (en) * 1998-05-12 2000-01-04 International Business Machines Corp. Java I/O toolkit for applications and applets
US6718278B1 (en) * 1998-06-11 2004-04-06 At&T Laboratories Cambridge Limited Location system
US7483976B2 (en) * 1998-08-11 2009-01-27 Computer Associates Think, Inc. Transaction recognition and prediction using regular expressions
US6367034B1 (en) * 1998-09-21 2002-04-02 Microsoft Corporation Using query language for event filtering and aggregation
US20020038313A1 (en) * 1999-07-06 2002-03-28 Compaq Computer Corporation System and method for performing database operations on a continuous stream of tuples
US6681343B1 (en) * 1999-08-24 2004-01-20 Nec Electronics Corporation Debugging device and method as well as storage medium
US6507834B1 (en) * 1999-12-22 2003-01-14 Ncr Corporation Method and apparatus for parallel execution of SQL from stored procedures
US6353821B1 (en) * 1999-12-23 2002-03-05 Bull Hn Information Systems Inc. Method and data processing system for detecting patterns in SQL to allow optimized use of multi-column indexes
US20020049788A1 (en) * 2000-01-14 2002-04-25 Lipkin Daniel S. Method and apparatus for a web content platform
US6996557B1 (en) * 2000-02-15 2006-02-07 International Business Machines Corporation Method of optimizing SQL queries where a predicate matches nullable operands
US7020696B1 (en) * 2000-05-20 2006-03-28 Ciena Corp. Distributed user management information in telecommunications networks
US20020023211A1 (en) * 2000-06-09 2002-02-21 Steven Roth Dynamic kernel tunables
US7702639B2 (en) * 2000-12-06 2010-04-20 Io Informatics, Inc. System, method, software architecture, and business model for an intelligent object based information technology platform
US20040019592A1 (en) * 2000-12-15 2004-01-29 Crabtree Ian B. Method of retrieving entities
US6850925B2 (en) * 2001-05-15 2005-02-01 Microsoft Corporation Query optimization by sub-plan memoization
US20030046673A1 (en) * 2001-06-29 2003-03-06 Microsoft Corporation Linktime recognition of alternative implementations of programmed functionality
US6856981B2 (en) * 2001-09-12 2005-02-15 Safenet, Inc. High speed data stream pattern recognition
US7203927B2 (en) * 2001-09-20 2007-04-10 International Business Machines Corporation SQL debugging using XML dataflows
US20030065655A1 (en) * 2001-09-28 2003-04-03 International Business Machines Corporation Method and apparatus for detecting query-driven topical events using textual phrases on foils as indication of topic
US20090019045A1 (en) * 2002-01-11 2009-01-15 International Business Machines Corporation Syntheszing information-bearing content from multiple channels
US20070050340A1 (en) * 2002-03-16 2007-03-01 Von Kaenel Tim A Method, system, and program for an improved enterprise spatial system
US20040024773A1 (en) * 2002-04-29 2004-02-05 Kilian Stoffel Sequence miner
US20040010496A1 (en) * 2002-06-05 2004-01-15 Sap Aktiengesellschaft Apparatus and method for integrating variable subsidiary information with main office information in an enterprise system
US20040073534A1 (en) * 2002-10-11 2004-04-15 International Business Machines Corporation Method and apparatus for data mining to discover associations and covariances associated with data
US20040151382A1 (en) * 2003-02-04 2004-08-05 Tippingpoint Technologies, Inc. Method and apparatus for data packet pattern matching
US20080077587A1 (en) * 2003-02-07 2008-03-27 Safenet, Inc. System and method for determining the start of a match of a regular expression
US7519577B2 (en) * 2003-06-23 2009-04-14 Microsoft Corporation Query intermediate language method and system
US7167848B2 (en) * 2003-11-07 2007-01-23 Microsoft Corporation Generating a hierarchical plain-text execution plan from a database query
US7672964B1 (en) * 2003-12-31 2010-03-02 International Business Machines Corporation Method and system for dynamically initializing a view for a streaming data base system
US20100023498A1 (en) * 2004-06-25 2010-01-28 International Business Machines Corporation Relationship management in a data abstraction model
US20060015482A1 (en) * 2004-06-30 2006-01-19 International Business Machines Corporation System and method for creating dynamic folder hierarchies
US20060007308A1 (en) * 2004-07-12 2006-01-12 Ide Curtis E Environmentally aware, intelligent surveillance device
US20060047696A1 (en) * 2004-08-24 2006-03-02 Microsoft Corporation Partially materialized views
US20090088962A1 (en) * 2004-09-10 2009-04-02 Alan Henry Jones Apparatus for and method of providing data to an external application
US20060085592A1 (en) * 2004-09-30 2006-04-20 Sumit Ganguly Method for distinct count estimation over joins of continuous update stream
US7519962B2 (en) * 2004-10-07 2009-04-14 Thomson Financial Llc Command script parsing using local and extended storage for command lookup
US20110055192A1 (en) * 2004-10-25 2011-03-03 Infovell, Inc. Full text query and search systems and method of use
US20080077570A1 (en) * 2004-10-25 2008-03-27 Infovell, Inc. Full Text Query and Search Systems and Method of Use
US20060106786A1 (en) * 2004-11-12 2006-05-18 International Business Machines Corporation Adjusting an amount of data logged for a query based on a change to an access plan
US20060106797A1 (en) * 2004-11-17 2006-05-18 Narayan Srinivasa System and method for temporal data mining
US20090007098A1 (en) * 2005-02-22 2009-01-01 Connectif Solutions, Inc. Distributed Asset Management System and Method
US7917299B2 (en) * 2005-03-03 2011-03-29 Washington University Method and apparatus for performing similarity searching on a data stream with respect to a query string
US20070016467A1 (en) * 2005-07-13 2007-01-18 Thomas John Method and system for combination of independent demand data streams
US7702629B2 (en) * 2005-12-02 2010-04-20 Exegy Incorporated Method and device for high performance regular expression pattern matching
US7877381B2 (en) * 2006-03-24 2011-01-25 International Business Machines Corporation Progressive refinement of a federated query plan during query execution
US20080010093A1 (en) * 2006-06-30 2008-01-10 Laplante Pierre System and Method for Processing Health Information
US20080005093A1 (en) * 2006-07-03 2008-01-03 Zhen Hua Liu Techniques of using a relational caching framework for efficiently handling XML queries in the mid-tier data caching
US20080034427A1 (en) * 2006-08-02 2008-02-07 Nec Laboratories America, Inc. Fast and scalable process for regular expression search
US20080033914A1 (en) * 2006-08-02 2008-02-07 Mitch Cherniack Query Optimizer
US8099400B2 (en) * 2006-08-18 2012-01-17 National Instruments Corporation Intelligent storing and retrieving in an enterprise data system
US20080082484A1 (en) * 2006-09-28 2008-04-03 Ramot At Tel-Aviv University Ltd. Fast processing of an XML data stream
US20080098359A1 (en) * 2006-09-29 2008-04-24 Ventsislav Ivanov Manipulation of trace sessions based on address parameters
US20080086321A1 (en) * 2006-10-05 2008-04-10 Paul Walton Utilizing historical data in an asset management environment
US7895187B2 (en) * 2006-12-21 2011-02-22 Sybase, Inc. Hybrid evaluation of expressions in DBMS
US20090006320A1 (en) * 2007-04-01 2009-01-01 Nec Laboratories America, Inc. Runtime Semantic Query Optimization for Event Stream Processing
US7912853B2 (en) * 2007-05-07 2011-03-22 International Business Machines Corporation Query processing client-server database system
US7689622B2 (en) * 2007-06-28 2010-03-30 Microsoft Corporation Identification of events of search queries
US20090006346A1 (en) * 2007-06-29 2009-01-01 Kanthi C N Method and Apparatus for Efficient Aggregate Computation over Data Streams
US20090024622A1 (en) * 2007-07-18 2009-01-22 Microsoft Corporation Implementation of stream algebra over class instances
US7676461B2 (en) * 2007-07-18 2010-03-09 Microsoft Corporation Implementation of stream algebra over class instances
US20090070786A1 (en) * 2007-09-11 2009-03-12 Bea Systems, Inc. Xml-based event processing networks for event server
US20090070785A1 (en) * 2007-09-11 2009-03-12 Bea Systems, Inc. Concurrency in event processing networks for event server
US20090076899A1 (en) * 2007-09-14 2009-03-19 Gbodimowo Gbeminiyi A Method for analyzing, searching for, and trading targeted advertisement spaces
US20090106321A1 (en) * 2007-10-17 2009-04-23 Dinesh Das Maintaining and Utilizing SQL Execution Plan Histories
US20120041934A1 (en) * 2007-10-18 2012-02-16 Oracle International Corporation Support for user defined functions in a data stream management system
US20090112853A1 (en) * 2007-10-29 2009-04-30 Hitachi, Ltd. Ranking query processing method for stream data and stream data processing system having ranking query processing mechanism
US20090125550A1 (en) * 2007-11-08 2009-05-14 Microsoft Corporation Temporal event stream model
US7870124B2 (en) * 2007-12-13 2011-01-11 Oracle International Corporation Rewriting node reference-based XQuery using SQL/SML
US8155880B2 (en) * 2008-05-09 2012-04-10 Locomatix Inc. Location tracking optimizations
US8134194B2 (en) * 2008-05-22 2012-03-13 Micron Technology, Inc. Memory cells, memory cell constructions, and memory cell programming methods
US7930322B2 (en) * 2008-05-27 2011-04-19 Microsoft Corporation Text based schema discovery and information extraction
US20100017379A1 (en) * 2008-07-16 2010-01-21 Alexis Naibo Systems and methods to create continuous queries via a semantic layer
US20100017380A1 (en) * 2008-07-16 2010-01-21 Alexis Naibo Systems and methods to create continuous queries associated with push-type and pull-type data
US20100049710A1 (en) * 2008-08-22 2010-02-25 Disney Enterprises, Inc. System and method for optimized filtered data feeds to capture data and send to multiple destinations
US8676841B2 (en) * 2008-08-29 2014-03-18 Oracle International Corporation Detection of recurring non-occurrences of events using pattern matching
US20100094838A1 (en) * 2008-10-10 2010-04-15 Ants Software Inc. Compatibility Server for Database Rehosting
US20100106946A1 (en) * 2008-10-29 2010-04-29 Hitachi, Ltd. Method for processing stream data and system thereof
US8392402B2 (en) * 2008-12-03 2013-03-05 International Business Machines Corporation Hybrid push/pull execution of continuous SQL queries
US20110093162A1 (en) * 2009-08-11 2011-04-21 Certusview Technologies, Llc Systems and methods for complex event processing of vehicle-related information
US20110040746A1 (en) * 2009-08-12 2011-02-17 Hitachi, Ltd. Computer system for processing stream data
US8713049B2 (en) * 2010-09-17 2014-04-29 Oracle International Corporation Support for a parameterized query/view in complex event processing
US20140095525A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Tactical query to continuous query conversion
US20140095446A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation State initialization algorithm for continuous queries over archived relations
US20140095533A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Fast path evaluation of boolean predicates
US20140095444A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation State initialization for continuous queries over archived views
US20140095543A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Parameterized continuous query templates
US20140095529A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Configurable data windows for archived relations
US20140095541A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Managing risk with continuous queries
US20140095483A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Processing events for continuous queries on archived relations
US20140095447A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Operator sharing for continuous queries over archived relations
US20140095473A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Managing continuous queries in the presence of subqueries
US20140095445A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Generation of archiver queries for continuous queries over archived relations
US20140095462A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Hybrid execution of continuous and scheduled queries
US20140095537A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Real-time business event analysis and monitoring
US20140095540A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Mechanism to chain continuous queries
US20140095471A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Join operations for continuous queries over archived views
US20140095535A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Managing continuous queries with archived relations

Non-Patent Citations (1)

* Cited by examiner, † Cited by third party
Title
Agrawal et al.: Jagrati Agrawal , Yanlei Diao , Daniel Gyllstrom , Neil Immerman, Efficient pattern matching over event streams, Proceedings of the 2008 ACM SIGMOD international conference on Management of data, June 09-12, 2008, Vancouver, Canada. Pages 147-160. ISBN: 978-1-60558-102-6 . *

Cited By (75)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8589436B2 (en) 2008-08-29 2013-11-19 Oracle International Corporation Techniques for performing regular expression-based pattern matching in data streams
US20100057735A1 (en) * 2008-08-29 2010-03-04 Oracle International Corporation Framework for supporting regular expression-based pattern matching in data streams
US20100057736A1 (en) * 2008-08-29 2010-03-04 Oracle International Corporation Techniques for performing regular expression-based pattern matching in data streams
US20100057663A1 (en) * 2008-08-29 2010-03-04 Oracle International Corporation Techniques for matching a certain class of regular expression-based patterns in data streams
US9305238B2 (en) 2008-08-29 2016-04-05 Oracle International Corporation Framework for supporting regular expression-based pattern matching in data streams
US8676841B2 (en) 2008-08-29 2014-03-18 Oracle International Corporation Detection of recurring non-occurrences of events using pattern matching
US8498956B2 (en) 2008-08-29 2013-07-30 Oracle International Corporation Techniques for matching a certain class of regular expression-based patterns in data streams
US20100223305A1 (en) * 2009-03-02 2010-09-02 Oracle International Corporation Infrastructure for spilling pages to a persistent store
US8145859B2 (en) 2009-03-02 2012-03-27 Oracle International Corporation Method and system for spilling from a queue to a persistent store
US20100223606A1 (en) * 2009-03-02 2010-09-02 Oracle International Corporation Framework for dynamically generating tuple and page classes
US8352517B2 (en) 2009-03-02 2013-01-08 Oracle International Corporation Infrastructure for spilling pages to a persistent store
US8387076B2 (en) 2009-07-21 2013-02-26 Oracle International Corporation Standardized database connectivity support for an event processing server
US8321450B2 (en) 2009-07-21 2012-11-27 Oracle International Corporation Standardized database connectivity support for an event processing server in an embedded context
US20110022618A1 (en) * 2009-07-21 2011-01-27 Oracle International Corporation Standardized database connectivity support for an event processing server in an embedded context
US20110023055A1 (en) * 2009-07-21 2011-01-27 Oracle International Corporation Standardized database connectivity support for an event processing server
US20110029485A1 (en) * 2009-08-03 2011-02-03 Oracle International Corporation Log visualization tool for a data stream processing server
US20110029484A1 (en) * 2009-08-03 2011-02-03 Oracle International Corporation Logging framework for a data stream processing server
US8527458B2 (en) 2009-08-03 2013-09-03 Oracle International Corporation Logging framework for a data stream processing server
US8386466B2 (en) 2009-08-03 2013-02-26 Oracle International Corporation Log visualization tool for a data stream processing server
US20110137942A1 (en) * 2009-12-09 2011-06-09 Sap Ag Scheduling for Fast Response Multi-Pattern Matching Over Streaming Events
US8433725B2 (en) * 2009-12-09 2013-04-30 Sap Ag Scheduling for fast response multi-pattern matching over streaming events
US9430494B2 (en) 2009-12-28 2016-08-30 Oracle International Corporation Spatial data cartridge for event processing systems
US9305057B2 (en) 2009-12-28 2016-04-05 Oracle International Corporation Extensible indexing framework using data cartridges
US20110161352A1 (en) * 2009-12-28 2011-06-30 Oracle International Corporation Extensible indexing framework using data cartridges
US8447744B2 (en) 2009-12-28 2013-05-21 Oracle International Corporation Extensibility platform using data cartridges
US20110161356A1 (en) * 2009-12-28 2011-06-30 Oracle International Corporation Extensible language framework using data cartridges
US20110161328A1 (en) * 2009-12-28 2011-06-30 Oracle International Corporation Spatial data cartridge for event processing systems
US20110161321A1 (en) * 2009-12-28 2011-06-30 Oracle International Corporation Extensibility platform using data cartridges
US8959106B2 (en) 2009-12-28 2015-02-17 Oracle International Corporation Class loading using java data cartridges
US9058360B2 (en) 2009-12-28 2015-06-16 Oracle International Corporation Extensible language framework using data cartridges
US20110295894A1 (en) * 2010-05-27 2011-12-01 Samsung Sds Co., Ltd. System and method for matching pattern
US9392005B2 (en) * 2010-05-27 2016-07-12 Samsung Sds Co., Ltd. System and method for matching pattern
US20110302264A1 (en) * 2010-06-02 2011-12-08 International Business Machines Corporation Rfid network to support processing of rfid data captured within a network domain
US9110945B2 (en) 2010-09-17 2015-08-18 Oracle International Corporation Support for a parameterized query/view in complex event processing
US8713049B2 (en) 2010-09-17 2014-04-29 Oracle International Corporation Support for a parameterized query/view in complex event processing
US9189280B2 (en) 2010-11-18 2015-11-17 Oracle International Corporation Tracking large numbers of moving objects in an event processing system
US20120150887A1 (en) * 2010-12-08 2012-06-14 Clark Christopher F Pattern matching
US9756104B2 (en) 2011-05-06 2017-09-05 Oracle International Corporation Support for a new insert stream (ISTREAM) operation in complex event processing (CEP)
US8990416B2 (en) 2011-05-06 2015-03-24 Oracle International Corporation Support for a new insert stream (ISTREAM) operation in complex event processing (CEP)
US9535761B2 (en) 2011-05-13 2017-01-03 Oracle International Corporation Tracking large numbers of moving objects in an event processing system
US9804892B2 (en) 2011-05-13 2017-10-31 Oracle International Corporation Tracking large numbers of moving objects in an event processing system
US9329975B2 (en) 2011-07-07 2016-05-03 Oracle International Corporation Continuous query language (CQL) debugger in complex event processing (CEP)
CN102662735A (en) * 2012-03-08 2012-09-12 中国科学院自动化研究所 Composite event detection method and system for real-time perception environment
US9715529B2 (en) 2012-09-28 2017-07-25 Oracle International Corporation Hybrid execution of continuous and scheduled queries
US9703836B2 (en) 2012-09-28 2017-07-11 Oracle International Corporation Tactical query to continuous query conversion
US9805095B2 (en) 2012-09-28 2017-10-31 Oracle International Corporation State initialization for continuous queries over archived views
US9852186B2 (en) 2012-09-28 2017-12-26 Oracle International Corporation Managing risk with continuous queries
US20140095533A1 (en) * 2012-09-28 2014-04-03 Oracle International Corporation Fast path evaluation of boolean predicates
US9256646B2 (en) 2012-09-28 2016-02-09 Oracle International Corporation Configurable data windows for archived relations
US9262479B2 (en) 2012-09-28 2016-02-16 Oracle International Corporation Join operations for continuous queries over archived views
US9286352B2 (en) 2012-09-28 2016-03-15 Oracle International Corporation Hybrid execution of continuous and scheduled queries
US9292574B2 (en) 2012-09-28 2016-03-22 Oracle International Corporation Tactical query to continuous query conversion
US9361308B2 (en) 2012-09-28 2016-06-07 Oracle International Corporation State initialization algorithm for continuous queries over archived relations
US9563663B2 (en) * 2012-09-28 2017-02-07 Oracle International Corporation Fast path evaluation of Boolean predicates
US20140149419A1 (en) * 2012-11-29 2014-05-29 Altibase Corp. Complex event processing apparatus for referring to table within external database as external reference object
US20140201225A1 (en) * 2013-01-15 2014-07-17 Oracle International Corporation Variable duration non-event pattern matching
US9098587B2 (en) * 2013-01-15 2015-08-04 Oracle International Corporation Variable duration non-event pattern matching
JP2016503216A (en) * 2013-01-15 2016-02-01 オラクル・インターナショナル・コーポレイション The duration variable events without pattern matching
CN104937591A (en) * 2013-01-15 2015-09-23 甲骨文国际公司 Variable duration non-event pattern matching
US9047249B2 (en) 2013-02-19 2015-06-02 Oracle International Corporation Handling faults in a continuous event processing (CEP) system
US9390135B2 (en) 2013-02-19 2016-07-12 Oracle International Corporation Executing continuous event processing (CEP) queries in parallel
US9262258B2 (en) 2013-02-19 2016-02-16 Oracle International Corporation Handling faults in a continuous event processing (CEP) system
US9418113B2 (en) 2013-05-30 2016-08-16 Oracle International Corporation Value based windows on relations in continuous data streams
US20150302055A1 (en) * 2013-05-31 2015-10-22 International Business Machines Corporation Generation and maintenance of synthetic context events from synthetic context objects
US20140365524A1 (en) * 2013-06-10 2014-12-11 International Business Machines Corporation Incremental aggregation-based event pattern matching
US9158824B2 (en) * 2013-06-10 2015-10-13 International Business Machines Corporation Incremental aggregation-based event pattern matching
US20150227373A1 (en) * 2014-02-07 2015-08-13 King Fahd University Of Petroleum And Minerals Stop bits and predication for enhanced instruction stream control
US9244978B2 (en) 2014-06-11 2016-01-26 Oracle International Corporation Custom partitioning of a data stream
US9712645B2 (en) 2014-06-26 2017-07-18 Oracle International Corporation Embedded event processing
US9886486B2 (en) 2014-09-24 2018-02-06 Oracle International Corporation Enriching events with dynamically typed big data for event processing
US20160119217A1 (en) * 2014-10-24 2016-04-28 Tektronix, Inc. Hardware trigger generation from a declarative protocol description
US9934279B2 (en) 2014-12-03 2018-04-03 Oracle International Corporation Pattern matching across multiple input data streams
US20160210021A1 (en) * 2015-01-21 2016-07-21 Microsoft Technology Licensing, Llc Computer-Implemented Tools for Exploring Event Sequences
US20170024439A1 (en) * 2015-07-21 2017-01-26 Oracle International Corporation Accelerated detection of matching patterns
US20170154080A1 (en) * 2015-12-01 2017-06-01 Microsoft Technology Licensing, Llc Phasing of multi-output query operators

Also Published As

Publication number Publication date Type
US20100057663A1 (en) 2010-03-04 application
US20100057735A1 (en) 2010-03-04 application
US9305238B2 (en) 2016-04-05 grant
US8676841B2 (en) 2014-03-18 grant
US8589436B2 (en) 2013-11-19 grant
US20100057727A1 (en) 2010-03-04 application
US20100057736A1 (en) 2010-03-04 application
US8498956B2 (en) 2013-07-30 grant

Similar Documents

Publication Publication Date Title
Derakhshan et al. RFID data management: Challenges and opportunities
Wu et al. High-performance complex event processing over streams
Ferrara et al. Web data extraction, applications and techniques: A survey
US8112425B2 (en) Time series search engine
Wen et al. A novel approach for process mining based on event types
US20050092825A1 (en) System and method for RFID system integration
US20120330971A1 (en) Itemized receipt extraction using machine learning
Dumas et al. Similarity search of business process models.
US20130007648A1 (en) Automatic Task Extraction and Calendar Entry
US8266148B2 (en) Method and system for business intelligence analytics on unstructured data
US20090037363A1 (en) Methods And Systems For Managing A Data Mining Model
Grigori et al. Business process intelligence
US7448048B1 (en) Method for performing real-time analytics using a business rules engine on real-time heterogeneous materialized data views
US8903717B2 (en) Method and system for generating a parser and parsing complex data
US20130246334A1 (en) System and method for providing data protection workflows in a network environment
US20100106710A1 (en) Stream data processing method and system
US20080196006A1 (en) Event-based process configuration
Mooney et al. Sequential pattern mining--approaches and algorithms
Kumar et al. Implementation of web usage mining using APRIORI and FP growth algorithms
US20110282812A1 (en) Dynamic pattern matching over ordered and disordered data streams
US20060277157A1 (en) Database query construction and handling
US7739221B2 (en) Visual and multi-dimensional search
US20080016502A1 (en) Extended Correlation Methods in a Content Transformation Engine
US20060288015A1 (en) Electronic content classification
US20090164441A1 (en) Method and apparatus for searching using an active ontology

Legal Events

Date Code Title Description
AS Assignment

Owner name: ORACLE INTERNATIONAL CORPORATION,CALIFORNIA

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:SRINIVASAN, ANAND;KOMURAVELLI, RAKESH;MISHRA, SHAILENDRA;SIGNING DATES FROM 20090811 TO 20090825;REEL/FRAME:023151/0858