Abstract: Query processing using online transactional processing (OLTP) and/or online analytical processing (OLAP) use a distributed graph. Optimizations are described including compute pushdown OLTP mode, single thread OLTP mode, and automatic transition between OLTP mode and OLAP mode. A query processing engine comprises an OLTP processing engine, an OLAP processing engine, and a storage (e.g., a computer memory or storage). The OLTP processing engine is configured to process OLTP queries, and the OLAP processing engine is configured to process OLAP queries. The query processing engine may comprise a transition determination engine configured to determine when to transition query processing between OLTP query processing mode and OLAP query processing mode.

Abstract: A method for document similarity analysis. The method includes generating a reference document content identifier for a reference document, including identifying frequently occurring terms in reference document content, encoding each frequently occurring term in a term identifier and combining the term identifiers to form the reference document content identifier associated with the reference document. The method also includes obtaining at least one document similarity value by comparing the reference document content identifier to a set of archived document content identifiers stored in a document repository.

Abstract: Example embodiments relate to a method for training a predictive model from data. The method includes defining a multitude of predicates as binary functions operating on time sequences of the features or logical operations on the time sequences of the features. The method also includes iteratively training a boosting model by generating a number of new random predicates, scoring all the new random predicates by weighted information gain with respect to a class label associated with a prediction of the boosting model, selecting a number of the new random predicates with the highest weighted information gain and adding them to the boosting model, computing weights for all the predicates in the boosting model, removing one or more of the selected new predicates with the highest information gain from the boosting model in response to input from an operator. The method may include repeating the prior steps a plurality of times.

Abstract: The subject technology provides a framework for executable machine learning models that are executable in a zero-runtime operating environment. This allows the machine learning models to be deployed in limited memory environments such as embedded domains. A machine learning compiler is provided to generate the executable machine learning models.

Abstract: Methods, systems, and computer programs encoded on computer storage media, for processing user-defined functions in containers. One example system receives a query written in a primary query language that calls a user-defined function. The system assigns primary segment hosts to process portions of the query written in the primary query language and assigns first containers to process the call to the user-defined function. The primary segment hosts provide to the first containers the user-defined function and one or more arguments in the call to the user-defined function. The first containers execute the user-defined function. The primary segment hosts receive an initial result of the call to the user-defined function computed by the first containers. The primary segment hosts compute a final result of the query using the initial result. The primary segment hosts provide the final result of the query in response to receiving the query.

Abstract: In some example embodiments, there is provided a method that includes receiving a query for query plan generation and query plan optimization; detecting whether the query plan includes a restart pipeline, the restart pipeline including one or more first operators that cause a query plan restart; detecting whether the query plan includes a result pipeline, the result pipeline including one or more second operators that provide result streaming; determining whether there is a dependency between execution of the restart pipeline and execution of the result pipeline; in response to determining there is no dependency, reordering the restart pipeline in the query plan such that the restart pipeline will be executed before the result pipeline in order to enable result streaming optimization; and providing the reordered query plan for execution. Related systems and computer program products are also provided.

Abstract: A method for determining a configuration knob of a database is disclosed, and may be applied to a database management system. In this method, vectorization coding is performed on a query statement, to obtain a target feature vector of the query statement, and then a configuration knob set for determining the database is determined based on two aspects of double-state information: the target feature vector and current status information of the database (101). The configuration knob set is used to execute N query statements. The configuration knob of the database (101) may be dynamically determined based on the query statement and the current status information of the database (101), so that good performance of the database (101) in a case of different workload requirements, for example, performance in aspects of a delay and a throughput, can be ensured.

Abstract: A global and local row count limit associated with a limit query are received by a stop operator of a first execution node among a set of execution nodes that are assigned to process the limit query. Local distributed row count data is generated based on a local row count corresponding to a number of rows output by the first execution node in processing the query. Based on determining the local row count satisfies the local limit, the first execution node buffers rows produced in processing the query. The local distributed row count data is updated based on remote distributed row count data received from a second execution node. A stopping condition is detected based on determining the global limit is satisfied based on updated local distributed row count data and query processing by the first execution node based on detecting the stopping condition.

Abstract: The disclosure discloses a method for service processing and system, including: determining a first quantity parameter for acquiring index shards each time and a second quantity parameter of objects acquired by each of the index shards each time; assigning first weight to the first quantity parameter to obtain third quantity parameter for acquiring the index shards; listing, from a plurality of index shards at a bucket, index shards corresponding to the third quantity parameter, and listing, from each of the index shards which is listed, the objects corresponding to the second quantity parameter, so as to obtain a matrix which takes each index shard as a column and a plurality of objects corresponding to each shard as rows; successively extracting the plurality of the objects corresponding to each row of the matrix; and according to preset number of concurrent processing, processing the plurality of the objects extracted each time.

Abstract: Techniques are provided for gathering statistics in a database system. The techniques involve gathering some statistics using an “on-the-fly” technique, some statistics through a “high-frequency” technique, and yet other statistics using a “prediction” technique. The technique used to gather each statistic is based, at least in part, on the overhead required to gather the statistic. For example, low-overhead statistics may be gathered “on-the-fly” using the same process that is performing the operation that affects the statistic, while statistics whose gathering incurs greater overhead may be gathered in the background, while the database is live, using the high-frequency technique. The prediction technique may be used for relatively-high overhead statistics that can be predicted based on historical data and the current value of predictor statistics.

Abstract: Whether a logical query plan to derive a target dataset from one or more source datasets is available is determined. Responsive to determining that the logical query plan is not available for the transformation code in the first programming language, relationships between the source columns of the one or more source datasets and the respective target columns of the target dataset are inferred. Target column metadata for a target column of the target dataset is generated. The target column metadata reflects the inferred relationships between the source columns of the one or more source datasets and the respective target columns. The target column metadata for the target column of the target dataset is stored.

Abstract: Techniques for improving the execution of database queries in a multi-processor system or distributed processing system environment are provided. In a database system including multiple parsing engines (PEs) for parsing database queries, or requests, received by the system and generating execution plans for the requests, execution plans generated for requests can be saved in a global request cache accessible to each of the parsing engines. Requests which have been parsed and cached by a PE can be retrieved for use by other PEs, thereby avoiding unnecessarily parsing the same database request in multiple PEs. The global request cache may be a distributed cache consisting of request caches local to each parsing engine, with execution plans allocated to the local request caches using hashing techniques applied to the database requests associated with the execution plans.

Abstract: Embodiments of this application disclose a distributed retrieval method performed by a distributed retrieval system including a retrieval node and an access node. The retrieval node receives a retrieval request forwarded by an access node, at least two video memory blocks are searched for matching features matching a to-be-detected feature of an image, each video memory block being a unique physical storage unit with a fixed length, and then returns retrieval results to the access node, the retrieval results being used for indicating the features matching the to-be-detected feature. Because cache spaces are allocated between the at least two video memory blocks using a blockchain structure, the features can be continuously stored in the video memory blocks, thereby overcoming the problem of data discretization brought about by a storage hole caused by deletion in the related art.

Abstract: Systems and methods are described for distributed processing a query in a first query language utilizing a query execution engine intended for single-device execution. While distributed processing provides numerous benefits over single-device processing, distributed query execution engines can be significantly more difficult to develop that single-device engines. Embodiments of this disclosure enable the use of a single-device engine to support distributed processing, by dividing a query into multiple stages, each of which can be executed by multiple, concurrent executions of a single-device engine. Between stages, data can be shuffled between executions of the engine, such that individual executions of the engine are provided with a complete set of records needed to implement an individual stage. Because single-device engines can be significantly less difficult to develop, use of the techniques described herein can enable a distributed system to rapidly support multiple query languages.

Abstract: A parallel and distributed query engine for federated searching is disclosed herein. As contemplated by the present disclosure, the system may provide a single application programming interface that allows a user to access and analyze multiple enterprise data storage locations remotely and simultaneously while presenting and reporting information from the multiple sources in a single, uniform display. Such a solution may allow a user to analyze and cross-reference data stored in multiple locations by using multiple queries in real time without requiring the actual data files to be displaced or combined. The system may further implement interactive artificial intelligence assistant, natural language processing, and workflow-based operations for improved user access and functionality.

Abstract: Methods, systems, and apparatus, including computer programs encoded on computer storage media, for restarting a query using a token. One of the methods includes receiving, by a computer from a requesting device, a query; determining, using a data storage system, a current result responsive to the query; generating, using the current result, a restart token that represents operations performed to determine a plurality of results responsive to the query including the current result responsive to the query and that can be used to determine a new result responsive to the query that was not included in the plurality of results responsive to the query; and providing, to the requesting device, a message that includes a) first data for the restart token that represents operations performed to determine the plurality of results responsive to the query and b) second data for the current result responsive to the query.

Abstract: Provided are techniques for building and using a sparse Time Series Database (TSDB). Time series records are received from a native TSDB, where each of the time series records includes a timestamp and one or more tags. Timeslots are determined for shards for the sparse TSDB based on the timestamp included in each of the time series records. The sparse TSDB is built by creating the shards for the determined timeslots and storing the time series records in the shards, while filling in empty ranges in the shards. A query that specifies at least one of the one or more tags is received. It is determined whether to execute the query against the sparse TSDB, and, in response to a determination to execute the query against the sparse TSDB, the query is executed against the sparse TSDB to generate results that are returned.

Abstract: A method, a system, and a computer program product for executing a blocked index join. One or more join values for joining data stored in a database in response to a query for accessing data stored in the database are identified. The database stores data in a plurality of tables. Each table has a plurality of columns and a plurality of rows. A mapping of one or more rows in the plurality of rows corresponding to one or more join values to a number of rows including one or more join values is identified. Based on the mapping, a join of one or more join values based on the rows including one or more join values is executed. The joined values are outputted.

Abstract: A method selects a federation engine to process a query. The system receives a query that specifies retrieval of data from multiple data sources at distinct physical locations. The system generates multiple federated query plans. Each federated query plan specifies execution of the query using a respective data source as the federation engine. For each federated query plan, the system forms a feature vector including two or more of: (1) a remote cost estimate for executing query operators on data sources distinct from the respective data source; (2) a local cost estimate for executing query operators on the respective data source; and (3) a data transfer cost estimate for transferring partial results from external data sources to the respective data source. The system predicts runtime for each federated query plan, selects a preferred federated query plan using the predicted runtimes, and the preferred federated query plan specifies the federation engine.

Abstract: A method includes generating array field distribution data for an array field of a dataset. A query expression for execution that includes a query predicate indicating the array field of the dataset is received. The array field distribution data for the array field is utilized to generate query plan data for the query expression based on the query expression including the query predicate indicating the array field. Execution of the query expression is facilitated in accordance with the query plan data.

Abstract: Caching techniques can include: receiving a read I/O operation requesting to read from a logical address; determining whether a mapping cache includes a descriptor for the logical address, the mapping cache including two hash tables; responsive to determining that the mapping cache includes the descriptor for the logical address, performing read hit mapping cache processing which includes using a physical location identified by the descriptor to read content stored at the logical address; and responsive to determining that the mapping cache does not include the descriptor for the logical address, performing read miss mapping cache processing which includes adding the descriptor to the mapping cache. Read miss mapping cache processing can include adding the descriptor to a first hash table, used to access the descriptor by the logical address, and adding the descriptor to a second hash table used to access the descriptor by the physical location.

Abstract: A system and method for hierarchical database operation accelerator for scaling a single node database with a plurality of accelerator cards is provided, including: a host, receiving a query plan, generating a corresponding query operation and distributing them, receiving and processing aggregated execution results; a hierarchy accelerator module, which is connected to the host, receiving the query operation distributed and returning the aggregated execution results; the hierarchy accelerator module comprises a master accelerator card and at least one slave accelerator card, the slave accelerator card returns the execution results to the master accelerator card, by the master accelerator card completes the subsequent query operation which is aggregated and assigned by the execution results, returning the aggregated execution results to the host; the accelerator system having a multi-level storage architecture of accelerator chip on-chip cache, the accelerator card memory, the accelerator card storage, and the

Abstract: The present disclosure relates to systems, methods, and computer-readable media for determining optimal index configurations for processing workloads in a database management system. For instance, an index configuration system can efficiently determine a subset of indexes for processing a workload utilizing one or more reinforcement learning models. For example, in various implementations, the index configuration system utilizes a Markov decision process and/or a Monte Carlo tree search model to determine an optimal subset of indexes for processing a workload in a manner that effectively utilizes computing device resources while also avoiding significant interference with customer workloads.

Abstract: A distributed processing apparatus 1 includes: a selection unit 12 that lists execution plans for a query related to a plurality of database apparatuses 2 and selects any of the execution plans based on data transfer time periods of the individual execution plans; a transmission unit 13 that divides the query in accordance with the selected execution plan, and transmits instructions that include divided queries obtained by dividing the query and transfer destinations of execution results of the divided queries to the corresponding database apparatuses 2; and an output unit 14 that receives the execution result of the query from the database apparatus 2, and outputs the execution result.

Abstract: Joining data using a disjunctive operator using a lookup table is described. An example computer-implemented method can include receiving a query with a set of conjunctive predicates and a set of disjunctive predicates. The method may also include generating a lookup table for each predicate in the sets of conjunctive predicates and disjunctive predicates. The method, for each row in a probe-side table, may also further include looking up a value associated with that row in each of the lookup tables and adding the row to a results set when there is a match. Additionally, the method may also include returning the results set.

Abstract: Methods, systems, and computer programs are presented for scheduling and executing request plans using an opportunistic approach. An opportunistic scheduler generates a request plan for a request on a cloud data platform, the request plan comprising a plurality of operations and identifies a plurality of contingent operations from the plurality of operations of the request plan. The opportunistic scheduler schedules the plurality of contingent operations for execution and sets the scheduled plurality of contingent operations to execute at a specific position in the request plan. The opportunistic scheduler sets remaining operations for execution by any available thread as threads that are processing the request plan become available and processes the request plan according to the scheduled plurality of contingent operations.

Abstract: An embodiment generates an initial set of training data from monitoring data. The initial set of training data is generated by combining outputs from a plurality of pretrained classifiers. The embodiment trains a new classification model using the initial set of training data to identify anomalies in monitoring data. The embodiment performs a multiple-level clustering of the data samples resulting in a plurality of clusters of sub-clusters of data samples, and generates a review list of data samples by selecting a representative data sample from each of the clusters. The embodiment receives an updated data sample from the expert review that includes a revised target classification for at least one of the data samples of the expert review list. The embodiment then trains another replacement classification model using a revised set of training data that includes the updated data sample and associated revised target classification.

Abstract: A distributed database keeps user-defined functions separate from a query engine by using a frontend. The frontend allows a user-defined function to interact with a proxy application processing interface (API) that is based on an API of the query engine. The frontend sends serialized data to the query engine in order to interact with the API of the query engine. The user-defined function is executed in security environments separate from the frontend and the query engine.

Abstract: The subject technology receives a query, the query including a set of statements for performing the query. The subject technology populates a compilation context based at least in part the query. The subject technology invokes a compiler to perform a compilation process based on the compilation context. The subject technology performs a lookup operation on a stored plan cache for an exact match based on information from the compilation context. The subject technology, in response to determining an exact match, determines whether the particular query plan requires re-compilation based on a data dependent optimization. The subject technology determines whether a plan cache entry corresponding to the particular query plan includes a data property constraint. The subject technology determines whether the data property constraint still holds based on a set of data properties.

Abstract: A system and method for processing of queries including receiving a query including a set operation and a sort operation, wherein the set operation includes a first data structure and a second data structure and the sort operation requests a result set that is sorted based on a column or attribute of the first data structure and a column or attribute of the second data structure; generating a query plan in which a sort operation occurs prior to the set operation; determining a first, partial set of one or more resultant rows responsive to the query; sending the first, partial set of one or more resultant rows responsive to the query to a client; determining a second, partial set of one or more resultant rows responsive to the query; and sending the second, partial set of one or more resultant rows to the client.

Abstract: Techniques described herein propose a new RIDDecode operator in a QEP that uses ROWID lookup and fetch, instead of dictionary decoding, to retrieve decoded values, in order to reduce memory pressure and speed up processing.

Abstract: Technologies are provided for tracking learning progress of an end user of a cloud computing platform when the end user is not registered with an external learning platform that provides an external learning application. In response to the end user interacting with virtual learning entities provided at the cloud computing platform, learning progress information with respect to the external learning application is generated. When a user service of the external learning platform receives a request to persist the learning progress information for the end user, the user service can determine whether a corresponding user account exists at the external learning platform that corresponds to the end user. If a corresponding user account does not exist, the user service can automatically provision an escrow user account that is associated with the end user. The escrow user account persists the learning progress information of the end user.

Abstract: Methods, computer readable media, and devices for distributing risk of multiple realms across multiple resources based on a realm risk model are disclosed. One method may include determining a time score based on an average response, a traffic score based on an average client request rate, and a risk score based on the time score and the traffic score for a plurality of realms, distributing the plurality of realms across a fixed number of resources based on the risk scores of the plurality of realms, and in response to a change in a risk score of a realm, redistributing the plurality of realms across the fixed number of resources based on a difference between a maximum risk score and a minimum risk score.

Abstract: A computer-implemented method dynamically switches access plans for a query during concurrent query execution. The method includes receiving a first query configured to be processed by a database system. The method also includes generating, for the first query, an access plan for each of identified resource sets. The method includes determining a first set of available resources that represent an available capacity for the database system. The method further includes selecting a first resource set of the one or more resource sets, where the selecting is based on the first set of available resources being closest to the first resource set. The method also includes selecting, based on the first set of available resources, a first access plan of the one or more access plans. The method includes executing the first query and returning results of the first query to a source of the first query.

Abstract: Compiling optimized database statements including receiving, by a query compiler from a client computing system, a state specification of a graphical user interface in response to a user manipulating the graphical user interface on the client computing system, wherein the state specification is in a standard file format and describes modifications to a plurality of visual elements of the graphical user interface; compiling, by the query compiler, a database statement from the state specification such that a limit clause within the database statement is processed by a database before at least one join clause; and sending, by the query compiler, the optimized database statement to a database on a cloud-based data warehouse.

Abstract: Computer-readable media, methods, and systems are disclosed for proactively compiling in-memory database management system (DBMS) query plans upon startup of the in-memory DBMS. During normal operation of the in-memory DBMS, alternative query plans having associated execution statistics are collected and captured. Thereafter, the alternative query plans are selectively persisted and in response to detecting performance regressions, the regressed query plan is compared with prior query plans. In response to determining that a prior query plan performs better, the regressed query plan is replaced with the prior query plan. Upon a restart of the in-memory DBMS, a selected portion of the plurality of alternative query execution plans is loaded, and the plurality of alternative query execution plans are compiled. New queries are received and executed based on the proactively compiled query plans.

Abstract: A method includes receiving, by a first computing entity of a database system, a query request that is formatted in accordance with a generic query format. The method further includes generating, by the first computing entity, an initial query plan based on the query request and a query instruction set. The method further includes determining, by the first computing entity, storage parameters. The method further includes determining, by the first computing entity, processing resources for processing the query request based on the storage parameters. The method further includes generating, by the first computing entity, an optimized query plan from the initial query plan based on the storage parameters, the processing resources, and optimization tools. The method further includes sending, by the first computing entity, the optimized query plan to a second computing entity for distribution and execution of the optimized query plan.

Abstract: A large highly parallel database management system includes thousands of nodes storing huge volume of data. The database management system includes multiple query optimizers for determining low cost execution plans for queries. The database management system is adapted to receive a data query. An execution plan generator component of the database management system generates an initial execution plan for the query. The initial execution plan is fed as input to more than one query optimizers. Each optimizer starts with the initial execution plan, generates alternative execution plans, and determines a satisfactory execution plan that incurs the lowest cost. The database management system compares the selected execution plans by the optimizers and selects one with the lowest cost. The multiple query optimizers run in parallel.

Abstract: A computing system for querying multiple data sources and a method therefor is provided. The computing system may comprise one or more nodes in communication with at least one data source of the multiple data sources to access data therefrom. The computing system may further comprise a second node in communication with the one or more nodes. The second node may be configured to receive a query instance and process the query instance to generate one or more relational query instances. The one or more relational query instances may be distributed among the one or more nodes to extract data from the at least one data source in communication therewith corresponding to the respective one or more relational query instances. The second node may be further configured to receive extracted data from each of the one or more nodes queried. The second node may be further configured to aggregate the extracted data.

Abstract: Systems and methods for reducing latency of probing operations of remotely located linear hash tables are described herein. In an embodiment, a system receives a request to perform a probing operation on a remotely located linear hash table based on a key value. Prior to performing the probing operation, the system dynamically predicts a number of slots for a single read of the linear hash table to minimize total cost for an average probing operation. The system determines a hash value based on the key value and determines a slot of the linear hash table to which the hash value corresponds. After predicting the number of slots, the system issues an RDMA request to perform a read of the predicted number of slots from the linear hash table starting at the slot to which the hash value corresponds.

Abstract: A method for functionally rewriting iterative queries for a relational database management system (RDBMS) is provided. The method comprises receiving a first iterative query, the first iterative query having a first non-iterative part that defines a first main table and a first iterative part that generates values in rows of a first working table based on values in rows of the first main table, determining that the first iterative part modifies all of the rows of the first working table, and rewriting the first iterative part, including: adding a renaming operation to rename the first working table to a new first main table and to rename the first main table to a new first working table, adding a first Delete operation to delete each row of the new first working table, and adding a first loop operation to repeat the first iterative part until a first termination condition is met.

Abstract: Systems and methods include acquisition of a database system workload comprising a plurality of database queries, replay of the database system workload on each of a plurality of database systems to generate a plurality of failed events, each of the plurality of failed events associated with a plurality of attributes, assignment of a root cause to each of the plurality of failed events, and training of a classification model, based on the plurality of failed events an assigned root causes, to infer an output root cause based on an input plurality of attributes.

Abstract: Methods and computer systems for storing a query plan in a cache are provided. The method can include: determining a use frequency of the query plan; determining a target storage layer for storing the query plan based on the determined use frequency, wherein the cache includes at least two storage layers and each of the storage layers is associated with a compression level of query plans; processing the query plan according to the compression level of the target storage layer; and storing the processed query plan in the target storage layer.

Abstract: A method for processing a plurality of queries is provided according to embodiments of the present disclosure. In this method, based on a plurality of queries and an execution plan for the plurality of quires, a plurality of record identification (ID) numbers can be stored into a pool in a numerical order. Each of the plurality of record ID numbers can identify a data record in a database. Then, the execution plan can be performed to batch a plurality of data records corresponding to the plurality of record ID numbers in the database based on a distribution of the plurality of record ID numbers in the pool.

Abstract: A computer-implemented method that includes receiving an ingestion request to ingest data to a database comprising physical shards and detecting that the ingestion request is directed to a first hotspot shard. The first hotspot shard has a contention level over a threshold value. The method also detects context characteristics within the data and generates a first virtual shard based on a first virtual shard key selected from the detected context characteristics. The first virtual shard virtually duplicates at least a portion of the first hotspot shard. The method also includes ingesting the data to the first virtual shard.

Abstract: A computer-implemented method is disclosed that includes operations of parsing a query comprised of a sequence of operators to detect each operator of the sequence of operators, where the sequence of operators includes a machine learning (ML) operator representing a trained ML model. Additionally, a schema of the ML operator is determined through metadata. A filter or a projection is generated based on the schema of the ML operator, where the filter or projection is configured to reduce an amount of data retrieved upon application of the filter of the projection to an operator of the sequence of operators comprising the query. The schema of the ML operator indicates a schema of input data to be provided to the ML operator and a schema of output data to be provided by the ML operator following processing.

Abstract: The present disclosure relates to a home appliance and an operating method thereof. The home appliance according to the present disclosure includes: a user input interface; a storage configured to store a database of a response history, and a controller configured to: in response to receiving an input requesting to perform a previous operation through the user input interface, verify whether a first operation, corresponding to the request for performing the previous operation, is present in the operation history; in response to there being the first operation, verify a type of a first command, mapped to the first operation, among commands included in the database; in response to the type of the first command being a first type, determine the first operation to be the previous operation; and in response to the type of the first command being a second type, generate a second operation corresponding to the first command, and determines the second operation to be the previous operation.

Abstract: Systems and methods for processing structured queries over clusters are provided herein. An example system includes a plurality of clusters, wherein a local cluster is configured to receive, from a client, a structured query language (SQL) structured query, determine, based on the SQL structured query, a list of remote clusters of the plurality of clusters, process the SQL structured query to generate a local query executable by a local search engine of the local cluster and remote queries executable by remote search engines of the remote clusters, send the remote queries to the remote clusters to obtain remote results, execute the local query to obtain local results, combine the remote results and the local results to obtain an aggregated result, and return the aggregated result to the client.

Abstract: A documentation generation engine coupled to a mutation handler are provided, configured to traverse a knowledge base to derive selective views. Organizations may configure a documentation generator application running on generator hosts to summarize records of a knowledge base storing institutional knowledge, and relationships therebetween, as human-readable reference documents. It is undesired for the documentation generator to query the knowledge base on a naive basis in response to updates in order to derive views required to generate updated documentation.

Abstract: A method incorporates data visualization into conversational interfaces. The method receives a user input specifying a natural language command via a conversational interface. The method analyzes the natural language command to determine the type of question. The method also obtains a user preference for viewing responses based on text and/or visualizations. When the user preference includes visualizations and the type of question is answerable using data visualizations, the method: (i) extracts one or more independent analytic phrases from the natural language command; (ii) queries a database using a set of queries based on the extracted analytic phrases, thereby retrieving a data set; and (iii) generates and displays, in the conversational interface, a response incorporating one or more data visualizations, based on the type of question, using the data set.