A query term analytics system receives a search query from a user device. The system has an engine enhanced with the ability to track query terms using in-memory counters and leveraging an inverted index of content stored in a content repository. The search query is run on the content and, contemporaneously the engine performs a query term analysis on the query terms to produce query term analytics. The query term analysis includes an impact analysis that determines an impact of removing a keyword or keyword criteria from the search query. A compressed bitset can be used to indicate whether a keyword is in the content. The engine can accumulate statistics using the in-memory counters while the search query is being processed. Using the statistics thus accumulated, a query term analytics report is generated and provided to the user device for presentation on the user device.

A system and method for the automatic linking of expired, current, and future insurance policies is provided. Within each insurance policy is a plurality of conditions frequently used in the determination of an insurance policy premium or rate quote. Such terms are calculated based upon information either associated with or obtained from a particular policyholder. By automatically linking policy information and policy terms from prior insurance policies, information previously submitted by a policyholder or calculated in regards to activity on a particular policy is used in automatic calculation and generation of a future policy term. Thus, straight-thru processing is achieved via organizing of prior policies for assistance in renewals, loss ratio calculations, shifts in payroll numbers (i.e., the number of employees insured under a single policy), and previous claim activity under the same type of policy.

To the standard operations of an inverted index database, a new “To” operator is added. The “To” operator treats the standard single-level linear collection of records as being organized into localized clusters. Techniques for hierarchical clusters are presented. During indexing, hierarchical clusters are serialized according to a uniform visitation procedure. Serialization produces bit maps, one for each hierarchical level, that preserve the hierarchical level of each record and its location in the serialization sequence. For non-hierarchical clusters, byte maps can be produced. The “To” operator accepts a list of records, each at a same hierarchical level in a cluster, and a specification of a hierarchical level that all the input records should be converted into. The “To” operator outputs a list of records, representing a conversion of the input records to the specified new level. Logical Forms, against which frame extraction rules match, can be stored in hierarchical clusters. A database query can be formulated, that matches against such Logical Forms, that provides the same or similar functionality to a frame extraction rule. Such queries extend the range of applications of a particular inverted index database and/or can aid in the development of new frame extraction rules.

Embodiments of the present disclosure provide a method, device, and computer program product for managing index tables. There is provided a method of managing index tables, comprising: determining the number of indexing requests for documents, the indexing requests being received within a predetermined period of time; obtaining information related to a processing index table in an index processing system, the processing index table being used for storing indices generated based on the indexing requests, the index processing system further comprising a receiving index table, the receiving index table being used for storing at least a part of the indices in the processing index table; and adjusting, based on the number of indexing requests and the obtained information, the number of processing index tables in the index processing system. Embodiments of the present disclosure can improve indexing throughput of an index processing system when massive data arrive, and avoid the problem of infinite growth of index tables.

Systems and methods are described herein for concurrently storing and searching an index in the working memory of a computing system. The present approach has multiple levels of storage block pools, each level made up of one or more storage block subdivided into slices, the slices being larger in size at higher pool levels, where additional storage pool blocks are allocated at a given level when there are no more slices available at that level. Further, the index is encoded as straight integer values, rather than using delta encoding or variable integer compression. The stored values can therefore be directly searchable without first having to flush the index from working memory into long term storage.

Methods and systems allow indexing references to documents of a database according to database reference profiles. Documents may then be located in the database using decoding protocols based on the database reference profiles. To this end, the documents are stored in the database and searchable terms extracted therefrom are associated with posting lists. Each posting list is divided into blocks of M database references. The blocks are encoded according to a pattern that depends on the M database references. A corresponding pointer to a table of encoding patterns is appended to each block. When a query is received for a searchable term, blocks are extracted from a posting list corresponding to the searchable term and a pointer for each block is used to extract a decoding protocol related to an encoding pattern for the block.

The embodiments of the invention allows retrieval of information or processing of commands through a speech interface and/or a combination of a speech interface and a non-speech interface. Thus, facilitating verbal search of religious and non-religious texts, and publishing resulting finds, along with exegesis and/or explanations. Beneficial uses can be gotten in the fields of, but not limited to those fields, of religious worship, and education. The embodiments of the invention eases interaction of the user(s) with the text(s) and allows for chances of in-depth comprehension and greater access to knowledge, but not limited only to those benefits. The scope and ramifications of the use(s) and benefits cannot be measured in a limited manner. As technology and imagination increases, the true scope and ramifications would increase as well.

Techniques are described herein for creating an algorithm for batch mode processing against big data. The techniques involve receiving one or more user commands from a set number of commands that correspond one-to-one with a set number of low-level database operations. In a preferred embodiment, the set of database operations includes only FILTERS, SORTS, AGREGGATES, and JOINS. In the algorithm formation process, database operations are performed on a sample population of records. The user drills down to a set of useful records by performing database operations against the results of the previous database operations. While the database cluster is receiving operations, the system is tracking the operations in a dependency graph. The chains selected within the dependency graph indicate which operations are used to create the algorithm. To generate the algorithm, the database cluster reverse engineers the logic for performing those operations against big data.

An index generation device 100 generates key presence information for a plurality of input files when lexical analysis on the plurality of input files are executed, the key presence information including information whether each of a plurality of keys is present in the plurality of input files and and presence positions of the respective plurality of keys when the respective plurality of keys are present in the plurality of input files. The index generation device 100 generates index information about the keys and the positions for the plurality of input files based on the key presence information.

Some computer applications, such as database applications, generate sparse arrays that map identifiers to field values. To reduce memory usage, only those blocks of the array with non-empty entries are stored, and only the entries between and including the first non-empty entry and the last non-empty entry are stored. The offset and length of this range of non-empty entries is stored. To retrieve a value for an entry of the array, it is determined whether the entry is in an empty block or a non-empty block. If the entry is in an empty block, a null value is returned for the entry. If the entry is not in the stored range of entries for a non-empty block, a null value is returned for the entry. Otherwise, the value stored in the block for that entry is returned.