Patent application number | Description | Published |
20080250024 | Mobile station with expanded storage space and method of retrieving files by the mobile station - Disclosed is a mobile station having an expanded storage space, and a method of retrieving a file stored in a remote storage server. The method may include determining whether the file is locally stored or remotely stored, deleting files in a local storage to provide space if the file is determined to reside in a remote storage server, downloading the file from a remote storage server over the Internet by prefetching a portion of the file from the remote storage server, and opening the prefetched portion of the file while concurrently downloading a remaining portion of the file from the remote storage server. | 10-09-2008 |
20080275891 | METHOD TO CREATE A PARTITION-BY TIME/TUPLE-BASED WINDOW IN AN EVENT PROCESSING SERVICE - A method to create a partition by time/tuple based window in an event processing service is provided. When continuous data streams are received, tuples are stored in a data structure with partitions based upon partition keys. Only a specified amount of tuples may be stored in each partition. When a partition exceeds the specified number of tuples, the oldest tuples are removed from the data structure. Tuples stored beyond a specified time period are also removed from the data structure. Two data structures may also be used to implement a time/tuple based window. Tuples are stored in both a data structure with a partition by window and a data structure with a range window. Tuples are removed in the partition by window when tuples exceed the amount in the partition. Tuples are removed in the range window when tuples exceed a specified time period. The two data structures are synchronized. | 11-06-2008 |
20090037370 | DISTRIBUTED EVENT PROCESSING - Methods and systems for distributed event processing are disclosed. In one embodiment, a system for distributed event processing includes a first event processor and a second event processor. The first event processor receives event data associated with an event stream. The second event processor receives a query associated with the event stream. A request to the first event processor is generated by the second event processor based on the query for a first portion of event data associated with the event stream. The second event processor receives the first portion of event data from the first event processor. The second event processor then generates an event based on the first portion of event data. | 02-05-2009 |
20090100029 | Handling Silent Relations In A Data Stream Management System - A new continuous query to a data stream management system (DSMS) may use a silent relation whose source does not provide any heartbeats. During execution of any given operator, the DSMS processes data from one input (“active input”) using its time stamp as if the same time stamp is received from another input whose relation has fallen silent (“empty input”), if one or more predetermined conditions are met. One predetermined condition is that the empty input's operator has all its own inputs silent. And another predetermined condition is that a maximum time stamp that is currently present among all the inputs of the empty input's operator is equal to a time stamp that was last received from these same inputs. When both conditions are met, previously received data from the empty input is time stamped with the same time stamp as the most recently received data from the active input. | 04-16-2009 |
20090106189 | Dynamically Sharing A Subtree Of Operators In A Data Stream Management System Operating On Existing Queries - A new continuous query to a data stream management system (DSMS) may use several operators that are equivalent to operators currently being used by continuous queries that have been previously registered in the DSMS. To determine equivalence of operators, the DSMS checks at least the function and the data input to the operators. On finding equivalence, the DSMS modifies a global plan being executed, to use at least an existing subtree of operators during execution of the new continuous query, to generate a modified plan. The DSMS is also programmed to cause each relation source operator (which outputs a relation) to propagate a current state of the relation to each operator newly coupled to the relational operator. After propagation of current state to newly-coupled operators, each operator in the modified plan processes any new data and supplies the result to all operators coupled thereto, including newly-coupled operators and existing operators. | 04-23-2009 |
20090106190 | Support For User Defined Functions In A Data Stream Management System - A data stream management system (DSMS) is designed to support a new user-defined function, by creating and using at least two structures as follows. A first structure (“metadata entry”) is created in response to a command for creation of the new function, and maps a single instance of a class to the function's name. A second structure is created with creation of an operator on receipt of each new continuous query that uses the new function. The second structure (“operator specific data structure”) contains a path to the newly-created instance, which path is obtained by looking up the first structure. Additional second structures are created on receipt of additional continuous queries which use the new function, but all second structures contain the same path. All continuous queries use the same instance. Repeated use of a single instance to compile and execute multiple queries eliminates repeated instantiation of the same function. | 04-23-2009 |
20090106198 | Support for sharing computation between aggregations in a data stream management system - A computer is programmed to process a continuous query that is known to perform a new aggregation on one or more stream(s) of data, using one or more other aggregations on the stream(s). The computer creates an operator to execute the continuous query, and schedules the operator for execution in a specific order. In several embodiments, the computer determines the order based on dependency of the new aggregation on other aggregation(s), and on the order of performance of the other aggregation(s). The new aggregation is scheduled for performance after performance of each of the other aggregations. The computer is further programmed to pass results of the other aggregations to the new aggregation, by execution of a predetermined function. Support for use of the other aggregations results within the new aggregation eliminates redundant computation of the other aggregations within the new aggregation. The new aggregation may be user defined or built-in. | 04-23-2009 |
20090106214 | ADDING NEW CONTINUOUS QUERIES TO A DATA STREAM MANAGEMENT SYSTEM OPERATING ON EXISTING QUERIES - A new continuous query to a data stream management system (DSMS) may use a stream or a relation which may or may not be used by continuous queries previously registered in the DSMS. The DSMS is programmed to modify an execution plan to accommodate execution of the new query while continuing to execute the previously registered continuous queries. The modified execution plan may include new operators and/or share existing operators. The DSMS is programmed to cause operators which output a relation to propagate a current state of the relation to each newly-coupled operator that uses the relation. The current state is propagated only to operators that have been newly coupled and have thus not yet received any state information previously. After propagation of current state to newly-coupled operators, results of processing any new data for the relation are supplied to all operators coupled thereto, including newly-coupled operators and existing operators. | 04-23-2009 |
20090106215 | DELETING A CONTINUOUS QUERY FROM A DATA STREAM MANAGEMENT SYSTEM CONTINUING TO OPERATE ON OTHER QUERIES - A first continuous query is deleted from several continuous queries that are being executed, by performing different actions that depend on how resources are shared therebetween. As an example, a second continuous query is deleted if a view is referenced by the first continuous query, and if the view is built on the second continuous query, and if the view is not referenced by any query other than the first continuous query. Such deletion is followed by compiling the second continuous query, followed by updating the view to refer to a newly-compiled version of the second continuous query. As another example, if an operator in the first continuous query is not used by any other query, this operator is de-scheduled from execution, and any exclusively-owned resources are released. Also, data to be read by the operator and data generated by the operator, if present in shared resources, are deleted therefrom. | 04-23-2009 |
20090106218 | Support for user defined aggregations in a data stream management system - A computer is programmed to accept a command to create a new aggregation defined by a user during execution of continuous queries on streams of data. The computer is further programmed to thereafter accept and process new continuous queries using the new aggregation, in a manner similar to built-in aggregations. The user typically writes a set of instructions to perform the new aggregation, and identifies in the command, a location of the set of instructions. In response to such a command, the computer creates metadata identifying the new aggregation. The metadata is used to instantiate one aggregation for each group of data in a current window, grouped by an attribute identified in a new query. | 04-23-2009 |
20090106440 | Support for incrementally processing user defined aggregations in a data stream management system - A computer is programmed to accept a command for creation of a new aggregation defined by a user to process data incrementally, one tuple at a time. One or more incremental function(s) in a set of instructions written by the user to implement the new aggregation maintain(s) locally any information that is to be passed between successive invocations, to support computing the aggregation for a given set of tuples as a whole. The user writes a set of instructions to perform the aggregation incrementally, including a plus function which is repeatedly invoked, only once, for each addition to a window of a message. The user also writes a minus function to be invoked with the message, to return the value of incremental aggregation over the window after removal of the message. In such embodiments, the computer does not maintain copies of messages in the window for use by aggregation function(s). | 04-23-2009 |
20090112802 | Facilitating Flexible Windows In Data Stream Management Systems - Facilitating flexible windows in querying continuous data streams. In one embodiment, a software code is associated with a window, wherein execution of the software code determines the values to be included in the window. On receiving a query indicating the window, the result of the query is generated based on the values in the window determined by execution of the software code. The software code may be identified by an identifier and thus used for different queries on the same or different continuous data streams. | 04-30-2009 |
20090112803 | Specifying A Family Of Logics Defining Windows In Data Stream Management Systems - Simplifying a user's task in specifying a family of logics, with each logic designed to potentially select different subsets of values from the same continuous data stream at the same time instant. In one embodiment, all the logics are together specified by a common user specified software code design to accept a set of parameters, with different logics resulting from execution of the software code with different parametric values. Thus, when closely related family of logics are to be developed, the common software code may be formulated, with the code being designed to accept parameters and providing different logics for different sets of parametric values corresponding to the parameters. | 04-30-2009 |
20090210489 | METHODS FOR PEER-CACHING FOR FASTER LOOKUPS IN PEER-TO-PEER SYSTEMS - The invention improves query response latency in a peer-to-peer network. The invention augments core neighbors included in a neighbor list of a peer node by selecting auxiliary neighbors for inclusion in the neighbor list of the peer node of a peer-to-peer network. In one embodiment, a method includes maintaining query frequency information associated with each of a plurality of peer nodes of the peer-to-peer network, selecting at least one of the peer nodes of the peer-to-peer network as an auxiliary neighbor using the query frequency information, and updating a neighbor list to include the at least one peer node selected as the at least one auxiliary neighbor. The core neighbors stored at a peer node attempt to minimize the worst-case query latency for that peer node. The auxiliary neighbors stored at the peer node attempt to reduce the average query latency for that peer node. The auxiliary neighbors may be used in any peer-to-peer system, such as Pastry, Tapestry, Chord, SkipGraph, and the like. | 08-20-2009 |
20100057663 | TECHNIQUES FOR MATCHING A CERTAIN CLASS OF REGULAR EXPRESSION-BASED PATTERNS IN DATA STREAMS - Techniques for detecting patterns in data streams. A pattern to be detected may be specified using a regular expression. Events received in data streams are then processed during runtime to detect occurrences of the pattern specified by the regular expression in the data stream. If the pattern to be matched belongs to a certain predetermined class of patterns, then a pattern matching technique that is customized for that class of patterns is used during the runtime events processing. | 03-04-2010 |
20100057727 | DETECTION OF RECURRING NON-OCCURRENCES OF EVENTS USING PATTERN MATCHING - Techniques for detecting recurring non-occurrences of an event. In one embodiment, techniques are provided for detecting the non-occurrence of an event within each of a series of time periods following the occurrence of another event. Language extensions are provided that enable queries to be formulated for detecting recurring non-occurrence of an event following occurrence of a triggering event. | 03-04-2010 |
20100057735 | FRAMEWORK FOR SUPPORTING REGULAR EXPRESSION-BASED PATTERN MATCHING IN DATA STREAMS - Techniques for detecting patterns in one or more data or event streams. A pattern to be detected may be specified using a regular expression. Events received in a data stream are processed during runtime to detect occurrences of the specified pattern in the data stream. In one embodiment, a pattern type or class is determined for the specified pattern and pattern matching is performed using a technique selected based upon the type or class determined for the specified pattern. | 03-04-2010 |
20100057736 | TECHNIQUES FOR PERFORMING REGULAR EXPRESSION-BASED PATTERN MATCHING IN DATA STREAMS - Techniques for detecting patterns in one or more data streams. A pattern to be detected may be specified using a regular expression. Events received in a data stream are processed during runtime to detect occurrences of the specified pattern in the data stream. | 03-04-2010 |
20100057737 | DETECTION OF NON-OCCURRENCES OF EVENTS USING PATTERN MATCHING - 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. | 03-04-2010 |
20100223305 | INFRASTRUCTURE FOR SPILLING PAGES TO A PERSISTENT STORE - Techniques for managing memory usage in a processing system are provided. This may be achieved by receiving a data stream including multiple tuples and determining a query plan that was generated for a continuous query applied to the multiple tuples in the data stream. The query plan may include one or more operators. Before scheduling an operator in the query plan, it is determined when an eviction is to be performed based a level of free memory of the processing system. An eviction candidate is determined and a page associated with the eviction candidate is evicted from the memory to a persistent storage. | 09-02-2010 |
20100223437 | METHOD AND SYSTEM FOR SPILLING FROM A QUEUE TO A PERSISTENT STORE - Techniques for managing memory usage of a processing system by spilling data from a memory to a persistent store based upon an evict policy are provided. A triggering event is detected. In response to the triggering event and based on the evict policy, it is determined whether data from the memory of the processing system is to be spilled to the persistent storage. The determination is made by comparing a level of free memory of the processing system with a threshold specified by the evict policy. The data is evicted from the memory. | 09-02-2010 |
20100223606 | FRAMEWORK FOR DYNAMICALLY GENERATING TUPLE AND PAGE CLASSES - Techniques for reducing the memory used for processing events received in a data stream are provided. This may be achieved by reducing the memory required for storing tuples. A method for processing a data stream includes receiving a tuple and determining a tuple specification that defines a layout of the tuple. The layout identifies one or more data types that are included in the tuple. A tuple class corresponding to the tuple specification may be determined. A tuple object based on the tuple class is instantiated, and during runtime of the processing system. The tuple object is stored in a memory. | 09-02-2010 |
20110022618 | STANDARDIZED DATABASE CONNECTIVITY SUPPORT FOR AN EVENT PROCESSING SERVER IN AN EMBEDDED CONTEXT - Techniques for facilitating communication between one or more client applications and an event processing server. In one set of embodiments, a framework is provided that enables a client application to communicate with an event processing server via a standard database connectivity API, such as Java Database Connectivity (JDBC). | 01-27-2011 |
20110023055 | STANDARDIZED DATABASE CONNECTIVITY SUPPORT FOR AN EVENT PROCESSING SERVER - Techniques for facilitating communication between one or more client applications and an event processing server. In one set of embodiments, a framework is provided that enables a client application to communicate with an event processing server via a standard database connectivity API, such as Java Database Connectivity (JDBC). | 01-27-2011 |
20110029484 | LOGGING FRAMEWORK FOR A DATA STREAM PROCESSING SERVER - Techniques for logging data pertaining to the operation of a data stream processing server. In one set of embodiments, logging configuration information can be received specifying a functional area of a data stream processing server to be logged. Based on the logging configuration information, logging can be dynamically enabled for objects associated with the functional area that are instantiated by the data stream processing server, and logging can be dynamically disabled for objects associated with the functional area that are discarded (or no longer used) by the data stream processing server. In another set of embodiments, a tool can be provided for visualizing the data logged by the data stream processing server. | 02-03-2011 |
20110029485 | LOG VISUALIZATION TOOL FOR A DATA STREAM PROCESSING SERVER - Techniques for logging data pertaining to the operation of a data stream processing server. In one set of embodiments, logging configuration information can be received specifying a functional area of a data stream processing server to be logged. Based on the logging configuration information, logging can be dynamically enabled for objects associated with the functional area that are instantiated by the data stream processing server, and logging can be dynamically disabled for objects associated with the functional area that are discarded (or no longer used) by the data stream processing server. In another set of embodiments, a tool can be provided for visualizing the data logged by the data stream processing server. | 02-03-2011 |
20110161321 | EXTENSIBILITY PLATFORM USING DATA CARTRIDGES - A framework for extending the capabilities of an event processing system using one or more plug-in components referred to herein as data cartridges. Generally speaking, a data cartridge is a self-contained unit of data that can be registered with an event processing system and can store information pertaining to one or more objects (referred to herein as extensible objects) that are not natively supported by the system. Examples of such extensible objects can include data types, functions, indexes, data sources, and others. By interacting with a data cartridge, an event processing system can compile and execute queries that reference extensible objects defined in the data cartridge, thereby extending the system beyond its native capabilities. | 06-30-2011 |
20110161328 | SPATIAL DATA CARTRIDGE FOR EVENT PROCESSING SYSTEMS - Techniques for extending the capabilities of an event processing system to support the processing of spatial data. In one set of embodiments, this extensibility can be provided via a plug-in extension component referred to herein as a spatial data cartridge. The spatial data cartridge can enable the event processing system to support spatial data types (e.g., point, polygon, etc.) and various operations related to such data types (e.g., proximity determinations, overlap determinations, etc.). The spatial data cartridge can also define an indexing scheme that can be integrated with the capabilities of the event processing system to support the indexing of spatial data. Using the spatial data cartridge, the event processing system can operate on spatial data even if spatial data formats are not natively supported by the system. | 06-30-2011 |
20110161352 | EXTENSIBLE INDEXING FRAMEWORK USING DATA CARTRIDGES - A framework or infrastructure (extensibility framework/infrastructure) for extending the indexing capabilities of an event processing system. The capabilities of an event processing system may be extended to support indexing schemes, including related data types and operations, which are not natively supported by the event processing system. The extensibility is enabled by one or more plug-in extension components called data cartridges. | 06-30-2011 |
20110161356 | EXTENSIBLE LANGUAGE FRAMEWORK USING DATA CARTRIDGES - A framework for extending the capabilities of an event processing system using one or more plug-in components referred to herein as data cartridges. In one set of embodiments, the data cartridge framework described herein can enable an event processing system to support one or more extension languages that are distinct from the native event processing language supported by the system. For example, certain “extension language” data cartridges can be provided that enable an event processing system to support complex data types and associated methods/operations that are common in object-oriented languages, but are not common in event processing languages. In these embodiments, an event processing system can access an extension language data cartridge to compile and execute queries that are written using a combination of the system's native event processing language and the extension language. | 06-30-2011 |
20110196891 | CLASS LOADING USING JAVA DATA CARTRIDGES - Techniques for loading Java classes referenced in a continuous query. In one set of embodiments, the Java classes can be loaded based on a class space defined for an application considered to be in scope for the query. In another set of embodiments, the Java classes can be loaded based on a server class space that includes all exported classes visible to the event processing system executing the query. | 08-11-2011 |
20110246445 | METHODS AND SYSTEMS FOR QUERYING EVENT STREAMS USING MULTIPLE EVENT PROCESSORS - In one embodiment, a system for distributed event processing includes a first event processor and a second event processor. The first event processor receives event data associated with an event stream. The second event processor receives a query associated with the event stream. A request to the first event processor is generated by the second event processor based on the query for a first portion of event data associated with the event stream. The second event processor receives the first portion of event data from the first event processor. The second event processor then generates an event based on the first portion of event data. | 10-06-2011 |
20110270879 | SUPPORT FOR USER DEFINED AGGREGATIONS IN A DATA STREAM MANAGEMENT SYSTEM - A computer is programmed to accept a command to create a new aggregation defined by a user during execution of continuous queries on streams of data. The computer is further programmed to thereafter accept and process new continuous queries using the new aggregation, in a manner similar to built-in aggregations. The user typically writes a set of instructions to perform the new aggregation, and identifies in the command, a location of the set of instructions. In response to such a command, the computer creates metadata identifying the new aggregation. The metadata is used to instantiate one aggregation for each group of data in a current window, grouped by an attribute identified in a new query. | 11-03-2011 |
20120041934 | SUPPORT FOR USER DEFINED FUNCTIONS IN A DATA STREAM MANAGEMENT SYSTEM - A data stream management system (DSMS) is designed to support a new user-defined function, by creating and using at least two structures as follows. A first structure (“metadata entry”) is created in response to a command for creation of the new function, and maps a single instance of a class to the function's name. A second structure is created with creation of an operator on receipt of each new continuous query that uses the new function. The second structure (“operator specific data structure”) contains a path to the newly-created instance, which path is obtained by looking up the first structure. Additional second structures are created on receipt of additional continuous queries which use the new function, but all second structures contain the same path. All continuous queries use the same instance. Repeated use of a single instance to compile and execute multiple queries eliminates repeated instantiation of the same function. | 02-16-2012 |
20120072455 | SUPPORT FOR A PARAMETERIZED QUERY/VIEW IN COMPLEX EVENT PROCESSING - The present invention includes a method for providing parameterized queries in complex event processing (CEP). The method includes providing a query template which includes one or more bind variables, providing sets of parameters corresponding to the one or more bind variables, and parsing the query template to determine positions of the one or more bind variables. The method further includes scanning the provided sets of parameters to determine which of the sets of parameters are to be bound to the one or more bind variables, binding the one or more bind variables which are determined to be bound to the sets of parameters, and substituting the bound one or more bind variables with the corresponding sets of parameters. The method further includes injecting all incarnations of the parameterized queries into the system, and one template/parameterized query is configured to run them all. | 03-22-2012 |
20120284420 | SUPPORT FOR A NEW INSERT STREAM (ISTREAM) OPERATION IN COMPLEX EVENT PROCESSING (CEP) - One embodiment of the invention includes a method of processing streaming data. The method includes initializing a stream of data and setting a time interval to apply to the stream of data. The time interval comprises a window for analyzing the data within the stream of data. The method further includes identifying one or more columns within the stream of data, designating one or more of the columns to be monitored for differences within the data over the time interval, and monitoring the designated columns over the time interval. Further, the method includes determining that at least one value from at least one of the designated columns has changed and in response to at least one value changing, outputting the changed values from the designated columns. | 11-08-2012 |
20140095444 | STATE INITIALIZATION FOR CONTINUOUS QUERIES OVER ARCHIVED VIEWS - A method may include receiving a continuous query identified by an archived view. The method may also include creating the archived view, the archived view identified by a join query related to two or more archived relations associated with an application and/or generating a query plan for the continuous query. The method may also include identifying a view root operator in the archived view, the view root operator identified as a join operator in the archived view and/or identifying a query operator in the query plan that topologically precedes the view root operator. Further, the method may include constructing an archiver query for the identified query operator that topologically precedes the view root operator, executing the archiver query to obtain a result set of data records related to the application, and/or generating a snapshot output of one or more data values related to the application. | 04-03-2014 |
20140095445 | GENERATION OF ARCHIVER QUERIES FOR CONTINUOUS QUERIES OVER ARCHIVED RELATIONS - A method may include receiving a continuous query identified by an archived relation associated with an application. The method may also include generating a physical query plan. Additionally, the method may include constructing a structured query language (SQL) equivalent expression corresponding to an attribute utilized by the operator and/or constructing an output SQL expression for the identified operator based at least in part on the SQL equivalent expression. Additionally, the method may include constructing the archiver query for the identified operator based at least in part on the output SQL expression. Further, the method may include executing the archiver query to obtain a result set of data records related to the application and/or generating a snapshot output of one or more data values related to the application based at least in part on the result set of data records. | 04-03-2014 |
20140095446 | STATE INITIALIZATION ALGORITHM FOR CONTINUOUS QUERIES OVER ARCHIVED RELATIONS - In some examples, a method may include receiving a continuous query, the continuous query being identified based at least in part on an archived relation associated with an application. The method may also include generating a physical query plan for the continuous query. In some examples, the method may also include identifying a query operator in the physical query plan and/or constructing an archiver query for the identified query operator. In some aspects, the method may also include executing the archiver query to obtain a result set of data records related to the application and/or initializing a state of the query operator based at least in part on the result set of data records. Further, the method may also include generating a snapshot output of one or more data values related to the application based at least in part on the state of the identified query operator. | 04-03-2014 |
20140095447 | OPERATOR SHARING FOR CONTINUOUS QUERIES OVER ARCHIVED RELATIONS - A continuous query identified by an archived relation of an application may be received. A physical query plan may be generated for the continuous query and/or a child operator plan may be identified. A buffer operator may be inserted between the child operator and its parent operator and/or the event information from the child operator may be stored in the buffer operator. A query operator may be identified in the physical query plan. It may be determined that the query operator identified in the physical query plan is a same type as a second query operator in a second continuous query concurrently executing. Further, a combined query plan may be generated based at least in part on the query operator identified in the physical query plan being the same type as the second query operator in the second continuous query. | 04-03-2014 |
20140095462 | HYBRID EXECUTION OF CONTINUOUS AND SCHEDULED QUERIES - Techniques for implementing the hybrid execution of continuous and scheduled queries are provided. In some examples, a query engine may be initialized with relational data from at least a first source. For example, the first source may include a database or other system that can provide historical data. Additionally, the query engine may be enabled to provide query results based at least in part on the relational data from at least the first source and streaming data from at least a second source. In some examples, the second source may be a data stream. | 04-03-2014 |
20140095471 | JOIN OPERATIONS FOR CONTINUOUS QUERIES OVER ARCHIVED VIEWS - A continuous query may be received, the continuous query being identified based at least in part on an archived view. The archived view may be created and/or identified based at least in part on a join query related to two or more archived relations associated with an application, at least one of the two or more archived relations being identified as a dimension relation. A query plan for the continuous query may be generated. A join operator in the query plan may be identified based at least in part on the dimension relation. A state of an operator corresponding to the dimension relation may be initialized. It may be identified if the state of the operator identifies an event that detects a change to the dimension relation. The continuous query may be re-started based at least in part on the event that detects the change to the dimension relation. | 04-03-2014 |
20140095473 | MANAGING CONTINUOUS QUERIES IN THE PRESENCE OF SUBQUERIES - Techniques for managing continuous queries that include subqueries are provided. In some examples, a continuous query that includes at least a subquery may be identified. Additionally, the subquery may be processed to obtain a first result or generate a logical subquery plan. Further, in some instances, the continuous query may then be processed based at least in part on the first result from the subquery or by merging a logical continuous query plan with the logical subquery plan. This may result in obtaining a second result via querying a data source with the continuous query that is based at least in part on the first result from the subquery and/or the merged plans. | 04-03-2014 |
20140095483 | PROCESSING EVENTS FOR CONTINUOUS QUERIES ON ARCHIVED RELATIONS - Techniques for counting event changes with archived relations are provided. In some examples, a query that identifies at least a data object may be identified. Additionally, the query may be evaluated against historical data associated with the data object. Additionally, in some instances, a listening service may be registered with the data object. Further, the query may be evaluated based at least in part on the data object and the historical data. | 04-03-2014 |
20140095529 | CONFIGURABLE DATA WINDOWS FOR ARCHIVED RELATIONS - Techniques for managing configurable data windows for streams and/or archived relations are provided. In some examples, a query that identifies at least a data stream or an archived relation may be identified. Additionally, a configurable window size may be identified. In some instances, the query may be initialized with at least a portion of the historical data based at least in part on the window size. Further, the query may be evaluated based at least in part on the data stream and the portion of the historical data. | 04-03-2014 |
20140095533 | FAST PATH EVALUATION OF BOOLEAN PREDICATES - Techniques for managing fast path evaluation of Boolean predicates are provided. In some examples, the fast path evaluation may be based at least in part on received queries and/or query statements associated with a database and/or streaming data. In some examples, a first instruction for enabling execution of a subset of logical operators of the query may be determined. The determination may be based at least in part on the logical operators of the query. Additionally, based at least in part on the first instruction, logical instructions for implementing the query may be generated. Further, the logical instructions may be compiled into machine-readable instructions for implementing only the subset of the logical operators of the query. | 04-03-2014 |
20140095535 | MANAGING CONTINUOUS QUERIES WITH ARCHIVED RELATIONS - Techniques for managing continuous queries with archived relations are provided. In some examples, a query that includes at least a data stream may be identified. Additionally, the query may be initialized with at least a portion of historical data. Further, in some instances, the query may be evaluated based at least in part on the data stream and the portion of the historical data. | 04-03-2014 |
20140095537 | REAL-TIME BUSINESS EVENT ANALYSIS AND MONITORING - Techniques for managing real-time business event analysis and monitoring are provided. In some examples, a logical request may be received at a business intelligence server configured with a continuous query service. Additionally, the continuous query service may be configured to translate the logical request into a physical request. Further, business intelligence information may be provided based at least in part on querying against an event data stream with a continuous query configured based at least in part on the physical request translated by the continuous query service. | 04-03-2014 |
20140095540 | MECHANISM TO CHAIN CONTINUOUS QUERIES - Techniques for implementing mechanisms for chaining continuous queries are provided. In some examples, results of a first continuous query may be stored in a data object. For example, the first continuous query may be configured to process business event data and store the results in the data object. Additionally, a second continuous query may then be processed based at least in part on the results stored in the data object. | 04-03-2014 |
20140136514 | SUPPORT FOR A PARAMETERIZED QUERY/VIEW IN COMPLEX EVENT PROCESSING - The present invention includes a method for providing parameterized queries in complex event processing (CEP). The method includes providing a query template which includes one or more bind variables, providing sets of parameters corresponding to the one or more bind variables, and parsing the query template to determine positions of the one or more bind variables. The method further includes scanning the provided sets of parameters to determine which of the sets of parameters are to be bound to the one or more bind variables, binding the one or more bind variables which are determined to be bound to the sets of parameters, and substituting the bound one or more bind variables with the corresponding sets of parameters. The method further includes injecting all incarnations of the parameterized queries into the system, and one template/parameterized query is configured to run them all. | 05-15-2014 |
20140201225 | VARIABLE DURATION NON-EVENT PATTERN MATCHING - Techniques for performing non-event pattern matching on continuous event streams using variable duration. The duration value used in non-event pattern matching can be variable. Accordingly, a first pattern match candidate can have a different associated duration from a second pattern match candidate for matches arising from events received via an event stream. In certain embodiments, the duration for a candidate pattern match may be based upon one or more attributes of an event that started the candidate pattern match or based upon an expression (e.g., an arithmetic expression) involving one or more attributes of the event. | 07-17-2014 |
20140201355 | VARIABLE DURATION WINDOWS ON CONTINUOUS DATA STREAMS - Improved techniques are provided for processing streams of data. The duration of the time that an event is eligible for remaining in a time-based window can be variable for different events received via the same event stream. In certain embodiments, the duration of time that an input event spends in a time-based window is a function of one or more values of one or more attributes of the event. Since different events can have different one or more attribute values, the different events can spend different amounts of time in the time-based window for that event stream. The amount of time that an event spends in a time-based window can be controlled via the one or more attributes of the event. | 07-17-2014 |
20140236983 | EXECUTING CONTINUOUS EVENT PROCESSING (CEP) QUERIES IN PARALLEL - A continuous event processing (CEP) query processor determines how and when a CEP query can be processed in a concurrent manner, such that multiple threads of execution can concurrently perform at least some of the CEP query's operations concurrently with each other. According to one technique, a user can instruct a CEP query processor to attempt to execute a CEP query in a concurrent manner. The CEP query processor responsively determines whether the CEP query's execution, or parts thereof, can be made concurrent based on certain constraints that can depend on inheritance and operation type. Based on this determination, the CEP query processor can execute at least certain parts of a CEP query in parallel relative to the same event within an event stream. | 08-21-2014 |
20140237289 | HANDLING FAULTS IN A CONTINUOUS EVENT PROCESSING (CEP) SYSTEM - The concept of faults and fault handling are added to the execution of continuous event processing (CEP) queries. By introducing fault handling techniques to the processing of CEP queries, users are enabled to instruct a CEP query processor to respond to faults in a customized manner that does not necessarily involve the halting of the CEP query relative to which the faults occurred. For example, a fault might be due to a temporary problem. Under such circumstances, the CEP query processor can be instructed to ignore the fault and allow the execution of the CEP query to continue relative to the remainder of the event stream. Alternatively, if the fault is due to a problem with the CEP query itself, then the CEP query processor can be instructed to propagate the fault through the query processing system until the fault ultimately causes the problematic CEP query to be halted. | 08-21-2014 |
20140358959 | VALUE BASED WINDOWS ON RELATIONS IN CONTINUOUS DATA STREAMS - Techniques for managing value-based windows on relations are provided. In some examples, an input relation is generated. The input relation is a bounded set of data records related to an application. A continuous query that identifies the input relation may be received. Additionally, a configurable window operator associated with processing the input relation may be identified. Then, the continuous query may be executed based at least in part on the configurable window operator to generate an output relation. Further, in some instances, the data records of the output relation may be provided based at least in part on execution of the continuous query. | 12-04-2014 |