CN115803715A - Intelligent Process Routing in Partitioned Database Management Systems - Google Patents

Abstract

A database system may include at least one load balancing node and multiple computing nodes. The load balancing node can receive a distributed transaction including a stored procedure, and select a predictive function for the stored procedure from multiple predictive functions. The load balancing node may extract one or more input parameters from the stored procedure and determine a compute node from among the plurality of compute nodes based at least in part on the one or more input parameters using a prediction function. Then, the load balancing node can forward the stored procedure to the computing node to process the stored procedure.

Description

Intelligent Process Routing in Partitioned Database Management Systems

Background technique

As the amount of data stored in various industries continues to increase, such as corporate data, shopping data, personal data, etc., Partitioned Distributed Database Management Systems (PDBMS) running on the cloud or server network are becoming more and more popular. In PDBM, a data table is divided horizontally into multiple parts, usually called data shards. Each data shard is a collection of rows and is hosted and replicated independently. Shards can be moved, split or merged to improve performance and resiliency.

Transactions involving data hosted on a single node (i.e. the database server) are called local transactions. These transactions are essentially indistinguishable from transactions in a traditional single database management system. On the other hand, a transaction involving data on multiple nodes is a global transaction, and a complex process called two-phase commit (2PC) is required when performing a commit operation. Therefore, global transactions are much slower than local transactions.

For better performance, database administrators (DBAs) typically specify data partitioning and placement strategies so that most transactions can be performed locally. For example, a database for an e-commerce application might include warehouse tables, customer tables, and so on. If the majority of orders submitted to an e-commerce application can be fulfilled by local warehouses, the database administrator may choose to partition the table based on geographic location such that rows representing warehouses and customers in the same location are in the same shard of their respective tables. The database administrator can also specify that the data shards of the customer table and the data shards of the warehouse table in the same location are hosted on the same node. In this way, better performance can be achieved by performing local transactions to service most orders.

This database partitioning works best for performance if the PDBMS can perform computations on the data, i.e. execute transactions directly on the nodes hosting or storing the data. However, this has proven difficult for the following reasons: 1) a transaction is best performed by a single node, aborting the transaction and restarting it on another node is feasible, but usually costly; 2) before the transaction starts It can be difficult to predict where related data resides, especially when most transactions involve multiple queries. Therefore, nodes performing transactions usually do not host transaction-related data, but need to forward query requests to actual hosting nodes, resulting in high communication costs. Worst of all, since the transaction has been assigned to a node, that node needs to act as a control node to coordinate the execution or processing of multiple queries contained in the transaction by other nodes, send a commit instruction to these other nodes to complete the 2-phase commit, and from Other nodes collect query results related to the execution or processing of multiple queries and send the query results to the database administrator's client device for presentation or viewing, thus transferring query results and instructions between the control node and other nodes Further communication costs and time are generated.

Contents of the invention

This Summary section introduces simplified concepts of intelligent process routing in partitioned database management systems, which are further described in the detailed description below. This summary is not intended to identify essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.

This disclosure describes example implementations of intelligent procedure routing in a partitioned database management system. In an implementation, one or more computing devices may perform static program analysis on a stored procedure to determine one or more input parameters. The one or more computing devices may also obtain stored data including multiple value sets for one or more input parameters of the stored procedure and identifications of multiple data slices. In an implementation, the one or more computing devices may use a plurality of value sets as input and use corresponding identifications of a plurality of data slices as output to train a classification model, and set the trained classification model as a prediction function, using It is used to map the new value set set by one or more input parameters of the stored procedure to the corresponding data fragment.

Description of drawings

The detailed description is set forth with reference to the accompanying drawings. In the figures, the left-most digit(s) in a reference number identifies the figure in which the reference number first appears. The use of the same reference numbers in different drawings indicates similar or identical items.

Figure 1 illustrates an example environment in which a database system may be used.

Figure 2 shows an example compute node in more detail.

Figure 3 shows an example load balancing node in more detail.

Figure 4 shows an example monitoring node in more detail.

Figure 5 illustrates an example method of determining a prediction function.

Figure 6 illustrates an example method of processing distributed database transactions.

Detailed ways

overview

As mentioned above, the existing partitioned distributed database system adopts a load balancing strategy, and cannot deterministically or strategically assign distributed database transactions to a specific node, which includes one or more data tables involved in the database transaction, And the node assigned to the database transaction may need to act as a control or coordinating node, coordinate other nodes to process the distributed database transaction and submit the distributed database transaction synchronously, and these other nodes include the data tables involved in the distributed database transaction. This not only increases communication cost and time for data and instructions transferred between nodes, but also wastes processing resources of control or coordination nodes that may not be needed for distributed database transactions.

This disclosure describes an example database system. In an implementation, the database system may include a load balancing node, a plurality of computing nodes, and a monitoring node. In an implementation, a database system may be associated with a plurality of procedures that are pre-registered and stored in a distributed database associated with the database system. Each stored procedure may include one or more database queries that access data slices of one or more database tables that are located or distributed across one or more computing nodes of the database system. In an implementation, a stored procedure may include one or more input parameters that may serve as placeholders to receive input values from a user for performing a database transaction. In an implementation, the database system may assign a unique identifier to each stored procedure of the plurality of stored procedures.

In an implementation, a database system may include or store one or more predictive functions. In an implementation, a predictive function of the one or more predictive functions may be used in one or more of the plurality of stored procedures. In an implementation, each prediction function may be labeled with a corresponding identifier, and the database system or load balancing node may include a first data structure (such as a table or map) that lists each of the one or more prediction functions Functions are associated or stored with corresponding identities. In addition, the database system may also include a second data structure (eg, a table or a map) that associates or stores identifications of one or more stored procedures with identifications of corresponding predictive functions.

In an implementation, the prediction function may be configured to predict or attempt to map a stored procedure to an identification of a data slice for a stored procedure that has a particular value for an input parameter, which may include a Data corresponding to at least one query. Optionally, the prediction function may be configured to predict or attempt to map a stored procedure, the stored procedure being a stored procedure having a specific value for an input parameter, to an identification of a computing node, the computing node may include at least one query corresponding to the stored procedure The data.

In an implementation, the database system may receive a stored procedure from a client device, the stored procedure having input values for input parameters of the stored procedure. The database system may select or determine a predictive function for the stored procedure from among the one or more predictive functions based on a second data structure that associates the plurality of stored procedures with the one or more predictive functions. In the implementation manner, the database system can determine or extract the input value of one or more input parameters of the stored procedure through static program analysis, and adopt the selected or determined prediction function (if the prediction function outputs the identifier of the data fragment, and If it is not the identifier of the computing node, then the mapping function) is also used to determine the computing node to which the stored procedure is forwarded or allocated, and the computing node is determined according to the extracted input value.

In an implementation, the one or more predictive functions may include one or more classification models obtained by the database system through training based on historical data collected by the plurality of computing nodes. In an implementation manner, the historical data of the prediction function may include, but not limited to, multiple value sets of corresponding one or more input parameters of one or more stored procedures associated with the prediction function, data shards or identifications of computing nodes, etc. . In an implementation manner, the one or more classification models may include but not limited to neural network models, deep learning models, decision tree models, and the like. In an implementation, the database system may update or retrain one or more prediction functions periodically or when the prediction error reaches a predetermined error threshold.

As described above, the exemplary database system may receive a stored procedure with input values for input parameters, and based on a prediction function predict or determine (determine that the stored procedure is forwarded or assigned) a computing node, which may store the The data shards of the data tables involved in at least one query of the stored procedure, thereby potentially avoiding the situation where the stored procedure is sent to a compute node that does not store any data shards queried or accessed by the procedure, thereby reducing the Waste of resources, communication costs, and processing delays resulting from additional requirements arising from interactions between nodes and other computing nodes that store data fragments queried or accessed by the stored procedure.

In an implementation, the functions described herein to be performed by a database system may be performed by a number of separate units or services. Furthermore, while in the examples described herein the database system may be implemented as a combination of software and hardware implemented and distributed across multiple devices, in other examples the database system may be implemented and distributed as a service that is accessed through provided by one or more computing devices on a network and/or cloud computing architecture.

This application describes a number of different embodiments and implementations. The following sections describe example frameworks suitable for practicing various implementations. Next, the application describes example systems, devices, and processes for implementing a database system.

example environment

Figure 1 illustrates an example environment 100 that may be used to implement a database system. Environment 100 may include database system 102 . In an implementation, database system 102 may include a plurality of servers or computing nodes 104-1, 104-2, ..., 104-N (collectively referred to as computing nodes 104). Compute nodes 104 may communicate data with each other over network 106 . In an implementation, the database system 102 may further include at least one load balancing node 108 for distributing workloads to servers or computing nodes 104 . In an implementation, one or more servers or compute nodes 104 may be designated or used as at least one load balancing node 108 . In an implementation, the database system 102 may also include a monitoring node 110 .

In an implementation, each server or computing node 104 may be implemented as any of a variety of computing devices, not limited to desktop computers, notebook or portable computers, handheld devices, netbooks, Internet appliances, tablet or tablet computers, Mobile devices (eg, mobile phones, personal digital assistants, smartphones, etc.), server computers, etc., or combinations thereof.

Network 106 may be a wireless network or a wired network, or a combination thereof. Network 106 may be a collection of separate networks interconnected to act as a single large network (eg, the Internet or an intranet). Examples of such separate networks include, but are not limited to, telephone networks, cable networks, local area networks (LANs), wide area networks (WANs), and metropolitan area networks (MANs). Additionally, the stand-alone network may be a wireless network or a wired network, or a combination thereof. A wired network may include electrical carrier connections (eg, communication cables, etc.) and/or optical carriers or connections (eg, fiber optic connections, etc.). Wireless networks may include, for example, WiFi networks, other radio frequency networks (eg, Bluetooth, Zigbee, etc.), and the like.

In an implementation, the environment 100 may also include a client device 112 . Client device 112 may be implemented as any of a variety of computing devices, not limited to desktop computers, notebook or portable computers, handheld devices, netbooks, Internet appliances, tablets or tablet computers, mobile devices (e.g., mobile phones, personal digital assistants, smartphones, etc.), server computers, etc., or a combination thereof.

In an implementation, database system 102 may receive a request from client device 112 to process a distributed database transaction. For example, a user 114 (eg, a database administrator, etc.) of a client device 112 may submit multiple query requests involving one or more data tables to the database system 102 as distributed database transactions. In response to receiving the request, the database system 102 may determine, based on the routing instructions, at least one computing node that includes the data portion of the data tables involved in the distributed database transaction, and send the distributed database transaction to the at least one computing node. The computing nodes process and return the processing result of the distributed database transaction to the client device 112 .

Sample Partitioned Database

In an implementation, the database system 102 may also include one or more databases partitioned or distributed among the plurality of computing nodes 104 . By way of example and not limitation, a partitioned or distributed database may include one or more data tables that are partitioned or partitioned, with each data table divided horizontally into portions known as data shards or simply shards . In an implementation, each shard can include a set of rows and can be independently hosted and replicated among one or more compute nodes 104 . Additionally, shards can be moved, split, or merged to improve database system 102 performance and resiliency.

In an implementation, transactions involving data hosted on a single computing node 104 or server (eg, a database server) may be referred to as local transactions. Local transactions are essentially no different from transactions in traditional monolithic DBMSs. On the other hand, transactions involving data on multiple computing nodes, ie, global transactions, need to go through a complex process called 2-phase commit (2PC) when committing. Therefore, the processing of global transactions is much slower than the processing of local transactions.

In an implementation manner, the data table may be horizontally partitioned based on column values or values combined by multiple columns. In the latter case, the values from each column can form tuples, and the columns can be treated as a single logical column for partitioning purposes. Without loss of generality, for simplicity, assume that the table is partitioned based on the partition column.

In implementations, rows with the same value in a partition column can be placed in the same data segment or shard. For example, an e-commerce application may include a database with a customer table including columns such as street, city, state, zip code, and so on. These columns can form the customer's address. A user 114 (eg, a database administrator) can use the column associated with zip code alone to partition the customer table such that all rows in the customer table with the same zip code are in the same data segment or shard.

In an implementation manner, the database system 102 may also include or provide a partition function for each data table, part _table (k)→shard_id, where k is called a partition key and is the value of a partition column. In an implementation, the output of this function may be an identification (ie, ID) of a shard that includes all rows whose partition column's value is equal to the partition key (ie, k).

其中place(.)是放置函数。In an implementation, database system 102 may allow user 114 to specify one or more partitioning and placement policies for data stored in a partitioned database. Continuing with the e-commerce application example above, a warehouse table could be included in addition to the customer table. Since most orders for the e-commerce application may need to be fulfilled from a local warehouse, the user 114 may decide to partition the database based on geographic location. In this case, the zip code of the warehouse location and the zip code of the customer address can be used as the corresponding partition columns of the warehouse table and customer table, respectively. Additionally, user 114 may instruct database system 102 to allow rows representing warehouses and customers at the same zip code to be hosted or stored in the same node so that most order processing can trigger local transactions. In other words, both the functions part _warehouse (k) and part _customer (k) have zip code as the partition key and satisfy

where place(.) is the placement function.

In an implementation, the partition function and placement function can be implemented by querying metadata, which includes a mapping from partition key to shard ID, and when the corresponding shard is hosted or stored, from shard ID to compute node map. This metadata may be replicated to some or all compute nodes 104 and/or load balancing nodes 108 in database system 102 .

In some implementations, a partition function may not exist or may be difficult to construct due to the potentially large amount of data involved and the need to store it upfront. In an implementation, the database system 102 may include or provide a prediction function predict _proc (parameters)→shard_id for a stored procedure, where the parameter represents a value entered by a user for an input parameter of the stored procedure. In an implementation manner, the output of the function may be shard_id, which may include an identification (ie, ID) of the shard to which the data row queried or accessed by at least one query request of the stored procedure belongs. After obtaining the identification of the shards that may include data rows to be queried or accessed by at least one query request of the stored procedure, database system 102 may use the put function as described above to obtain the compute The ID of the node.

Example Compute Node

Figure 2 shows compute node 104 in detail. In an implementation, a compute node 104 may include, but is not limited to, one or more processors 202 , input/output (I/O) interfaces 204 , and/or network interfaces 206 , and memory 208 . In an implementation, some functions of the computing node 104 may be implemented using hardware, such as ASIC (ie, application specific integrated circuit), FPGA (ie, field programmable gate array), and/or other hardware.

In an implementation, processor 202 may be configured to execute instructions stored in memory 208 and/or received from I/O interface 204 and/or network interface 206 . In an implementation, the processor 202 may be implemented as one or more hardware processors including, for example, a microprocessor, a special purpose instruction set processor, a physical processing unit (PPU), a central processing unit (CPU), a graphics processing unit, Digital signal processor, tensor processor. Additionally or alternatively, the functions described herein may be performed at least in part by one or more hardware logic components. Exemplary types of hardware logic components that may be used include, by way of example and without limitation, Field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), System on Chips (SOCs), Complex Programmable Logic devices (CPLD), etc.

Memory 208 may include computer readable media, which may be in the form of volatile memory, such as random access memory (RAM), and/or nonvolatile memory, such as read only memory (ROM) or flash RAM. Memory 208 is an example of a computer readable medium.

Computer readable media can include volatile or nonvolatile types, removable or non-removable media that implement information storage using any method or technology. The information may include computer readable instructions, data structures, program modules or other data. Examples of computer readable media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read only memory ( ROM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Flash Flash or other internal storage technology, Compact Disc Read-Only Memory (CD-ROM), Digital Versatile Disc (DVD) or other optical storage devices, magnetic tape, magnetic disk storage device, or other magnetic storage device, or any other non-transmission medium that can be used to store information that can be accessed by a computing device. As defined herein, computer-readable media does not include any transitory media, such as modulated data signals and carrier waves.

Although in this example only hardware components in compute node 104 are described, in other cases compute node 104 may also include other hardware components and/or other software components, such as program elements, to execute the instructions to perform various operations. For example, compute nodes 104 may also include a local or partitioned database 210 for storing data tables and other program data 212 . By way of example and not limitation, compute nodes 104 may store data segments or shards of one or more data tables in local or partitioned database 210 . In an implementation, one or more data tables may be partitioned and distributed according to respective partition keys of different computing nodes 104 .

Example load balancing node

Figure 3 shows the load balancing node 108 in more detail. In an implementation, load balancing node 108 may include, but is not limited to, one or more processors 302 , input/output (I/O) interfaces 304 , and/or network interfaces 306 , and memory 308 . In an implementation, some functions of the load balancing node 108 may be implemented using hardware, such as ASIC (ie, application specific integrated circuit), FPGA (ie, field programmable gate array), and/or other hardware.

In an implementation, processor 302 may be configured to execute instructions stored in memory 308 and/or received from I/O interface 304 and/or network interface 306 . In an implementation, the processor 302 may be implemented as one or more hardware processors including, for example, a microprocessor, a special purpose instruction set processor, a physical processing unit (PPU), a central processing unit (CPU), a graphics processing unit, Digital signal processor, tensor processing unit. Additionally or alternatively, the functions described herein may be performed at least in part by one or more hardware logic components. Exemplary types of hardware logic components that may be used include, by way of example and without limitation, Field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), System on Chips (SOCs), Complex Programmable Logic devices (CPLD), etc.

Memory 308 may include computer readable media, which may be in the form of volatile memory, such as random access memory (RAM), and/or nonvolatile memory, such as read only memory (ROM) or flash RAM. Memory 308 is an example of a computer readable medium as previously described.

Although in this example, only the hardware components in the load balancing node 108 are described, in other cases, the load balancing node 108 may also include other hardware components and/or other software components, such as program elements, for executing memory 308 Instructions stored in to perform various operations. For example, load balancing node 108 may also include mapping table 310 and other program data 312 . In an implementation, the mapping table 310 may include a mapping from a combination, which is a combination of data table information and partition key information, to information on a computing node that includes a data segment of a data table corresponding to the partition key or Fragmentation. By way of example and not limitation, given the name of the data table and the value of the partition key, load balancing node 108 may determine the identity or address of the compute node comprising the data segment or shard of the data table corresponding to the value of the partition key.

In an implementation, the load balancing node 108 may obtain the mapping table 310 in advance, for example, by receiving broadcast information from a plurality of computing nodes 104 . In an implementation, the broadcast information of each compute node 104 may include, but is not limited to, information about data segments or fragments of a data table included or stored in the corresponding compute node 104 corresponding to a particular value of the partition key.

Additionally or alternatively, in some implementations, load balancing node 108 may be associated with a mapping device (which may be a server or a computing device provided in database system 102). The mapping means may collect information from the plurality of compute nodes 104 about the data segments or shards of the data table included or stored in each compute node 104 corresponding to a particular value of the partition key, for example, by Nodes 104 broadcast information to collect. In this case, the load balancing node 108 can send the partition key information (such as value) and the information of the data table (such as the name) obtained from the distributed database transaction to the mapping device, and the mapping device sends the information of the data table and The information of the partition key is mapped to the information (eg, identification or address) of the computing node including the data segment or shard of the data table corresponding to the partition key. The load balancing node 108 may then receive the information of the computing nodes from the mapping device, thereby reducing the workload and complexity of the load balancing node while enabling the load balancing node to continuously handle the load balancing of incoming requests or data packets.

In an implementation, the load balancing node 108 may include one or more predetermined load balancing policies. By way of example and not limitation, one or more predetermined load balancing strategies may include: assigning received (e.g., from client device 112) distributed database transactions to computing nodes in a random manner, assigning distributed database transactions to Allocation to computing nodes in a circular manner, assigning distributed database transactions to computing nodes with the smallest current workload, or assigning distributed database transactions to computing nodes according to the mapping relationship between the IP address of the client device and computing nodes, etc.

In an implementation, the load balancing node 108 may also include an identification database 314 . The identification database 314 may include or store, for example, unique identifications (eg, unique names, etc.) of stored procedures registered and stored in the database 102, unique identifications of predictive functions, and the like. In an implementation, the load balancing node 108 may also include a relational database 316 . The relational database 316 may include or store, for example, the relationship between the unique identifier of the stored procedure and the unique identifier of the predictive function. In an implementation, the load balancing node 108 may also include a predictor database 318 . The predictor database 318 may include or store a plurality of predictive functions, for example, it may be queried or called by the identifier of the predictive function.

Example monitor node

Figure 4 shows the monitoring node 110 in more detail. In an implementation, monitoring node 110 may include, but is not limited to, one or more processors 402 , input/output (I/O) interfaces 404 , and/or network interfaces 406 , and memory 408 . In an implementation, some functions of the monitoring node 110 may be implemented using hardware, such as ASIC (ie, Application Specific Integrated Circuit), FPGA (ie, Field Programmable Gate Array), and/or other hardware.

In an implementation, processor 402 may be configured to execute instructions stored in memory 408 and/or received from I/O interface 404 and/or network interface 306 . In an implementation, the processor 402 may be implemented as one or more hardware processors including, for example, a microprocessor, a special purpose instruction set processor, a physical processing unit (PPU), a central processing unit (CPU), a graphics processing unit, Digital signal processor, tensor processing unit. Additionally or alternatively, the functions described herein may be performed at least in part by one or more hardware logic components. By way of example and not limitation, types of hardware logic components that may be used include Field Programmable Gate Arrays (FPGAs), Application Specific Integrated Circuits (ASICs), Application Specific Standard Products (ASSPs), System on Chips (SOCs), Complex Programmable Logic Devices (CPLD), etc.

Memory 408 may include computer readable media, which may be in the form of volatile memory, such as random access memory (RAM), and/or nonvolatile memory, such as read only memory (ROM) or flash RAM. Memory 408 is an example of a computer readable medium as previously described.

Although in this example, only the hardware components in the monitoring node 110 are described, in other cases, the monitoring node 110 may also include other hardware components and/or other software components, such as program elements, to execute the instructions to perform various operations. For example, monitoring node 110 may also include information database 410 and other program data 412 . In an implementation, the information database 410 may store data received from multiple computing nodes 104 and load balancing nodes 108, which may include but not limited to the following information: each stored procedure from the load balancing node 108 is individually invoked or used by the user Corresponding counts, identification of the miss process from each compute node 104 and corresponding miss counts, corresponding input and output data sets (including multiple value sets for one or more input parameters of the stored process and multiple prediction functions Identification of multiple data shards for each prediction function in ), etc.

example method

FIG. 5 shows a schematic diagram depicting an example method of determining a prediction function. FIG. 6 shows a schematic diagram depicting an example method of processing distributed database transactions. The methods in FIG. 5 and FIG. 6 can, but not necessarily, be implemented in the environment of FIG. 1 and using the computing nodes, load balancing nodes and monitoring nodes in FIG. 2 to FIG. 4 . For ease of explanation, method 500 and method 600 are described with reference to FIGS. 1-3 . However, methods 500 and 600 may alternatively be implemented in other environments and/or using other systems.

Method 500 and method 600 are described in the general context of computer-executable instructions. Generally, computer-executable instructions may include routines, programs, objects, components, data structures, procedures, modules, functions, etc. that perform particular functions or implement particular abstract data types. Furthermore, each of the example methods is illustrated as a collection of blocks in a logic flow diagram representing a sequence of operations that may be implemented in hardware, software, firmware, or a combination thereof. The order in which the method is described is not intended to be construed as a limitation, and any number of the described method blocks can be combined in any order to implement the method or alternative methods. Furthermore, individual blocks of the method may be omitted without departing from the spirit and scope of the subject matter described herein. In the context of software, blocks represent computer instructions that, when executed by one or more processors, perform described operations. In the context of hardware, some or all of the blocks may represent application specific integrated circuits (ASICs) or other physical components that perform the described operations.

Referring back to FIG. 5 , at block 502 the monitoring node 110 may select a stored procedure.

In an implementation, database system 102 may include a number of procedures stored in database system 102 . These procedures are written in a query language (such as SQL language), and registered in the database system 102 for users to call. In an implementation, a stored procedure may include one or more query requests that request one or more data analyzes for one or more database tables located in one or more compute nodes of database system 102 . The data of the slice is accessed or updated. In an implementation manner, the query request of the stored procedure may include a partition key and an input parameter, and the input parameter receives an input value from a user using the stored procedure. In an implementation, a stored procedure may include a parameter list of input parameters, which may be used as a placeholder to receive input values for the input parameters of the stored procedure from a user. In other implementation manners, the stored procedure may not include a parameter list of input parameters, and the input parameters are distributed in the stored procedures that need to be searched.

In an implementation manner, the monitoring node 110 may obtain one or more stored procedures newly added or registered in the database system 102, and there is no prediction function for these stored procedures, or there is no predicted function trained for these stored procedures. The monitoring node 110 may select a stored procedure from one or more stored procedures newly added or registered in the database system 102 . In an implementation, after a stored procedure has been used or invoked a predetermined number of times (e.g., 1,000, 10,000, etc.) Choose New to add or register a stored procedure. This allows a sufficient amount of training data to be available for training the prediction function against the stored procedure.

Additionally or alternatively, monitoring node 110 may select a stored procedure from a plurality of stored procedures associated with the predictive function to retrain periodically (eg, every week, every two weeks, every month, etc.). In an implementation manner, the frequency of selecting a certain stored procedure may depend on the frequency with which users in the database system 102 call or use the stored procedure. By way of example and not limitation, the more frequently a stored procedure is called or used, the more frequently that stored procedure is selected for retraining.

Additionally or alternatively, the monitoring node 110 may monitor the performance of multiple stored procedures in the database system 102 and determine whether to update or retrain the stored procedures based on the performance of the stored procedures. In an implementation, the performance of the stored procedure may include, but not limited to, an error rate of a prediction function used to map the stored procedure, and the like. For example, the load balancing node 108 can count the number of times each stored procedure is used or invoked by the user within a preset time interval (for example, every week, every two weeks, etc.), and compare the identifier of each stored procedure with the corresponding The usage or call count is stored in a data structure (e.g. table etc.). In addition, each compute node 104 may track the number of instances assigned to that compute node that suffered a miss in the corresponding compute node 104 (i.e., one or more stored procedures requested access to or updated data that does not exist in that compute node 104). One or more stored procedures. Each computing node 104 may store the identifier of such a stored procedure and the corresponding miss count of the stored procedure in a specific data structure (such as a list, etc.) within a preset time interval.

In an implementation manner, the monitoring node 110 may receive from the load balancing node 108 the information of the corresponding number of times the stored procedure is invoked or used by the user alone, and further collect the identifier of the miss procedure and the corresponding miss count from each computing node 104 . The monitoring node 110 can then determine a corresponding error rate for each stored procedure (eg, determine the fraction of stored procedures whose use or invocation resulted in a miss). The monitoring node 110 can compare the error rate of each stored procedure with a predetermined error threshold, and select the prediction function of the stored procedure with the highest error rate and the error rate higher than the predetermined error threshold to update or retrain.

At block 504, the monitoring node 110 may determine one or more input parameters for training the prediction function associated with the stored procedure.

In an implementation, upon selecting a stored procedure, monitoring node 110 may determine one or more input parameters that may be used to train a predictive function for the stored procedure. In an implementation, the stored procedure may include a parameter list including at least one input parameter, and the monitoring node 110 may use the at least one input parameter included in the parameter list as candidate input parameters for training the prediction function for the stored procedure.

Additionally or alternatively, monitoring node 110 may perform static program analysis to extract one or more candidate input parameters from the stored procedure. Static program analysis can also be called compile-time analysis, which is an algorithm that analyzes the program code before the program code runs to predict the runtime behavior of the program code. Monitoring node 110 may employ static program analysis to determine which input parameters determine or affect data slices on which one or more query requests in a stored procedure operate (eg, access or update). In an implementation, monitoring node 110 may identify one or more variables used as one or more partition keys in the stored procedure. For example, for a SELECT query request in a stored procedure, the monitoring node 110 can find distributed tables in the FROM clause, and identify variables that can be used for comparison with respective partition columns of these distributed tables. Similar methods are also available for UPDATE, INSERT, and DELETE query requests.

For example, a stored procedure, such as payment_proc, can be represented as follows. In this example, the first UPDATE is used to update the target table, the warehouse table, and the variable in_w_zip is compared to the corresponding partition column, warehouse_zip.

In an implementation, the monitoring node 110 may compute a transitive closure of all variables that may affect the value of a partition key in one or more query requests of the stored procedure. As described above, monitoring node 110 may employ data flow analysis to estimate possible values of variables of data flow between program points reachable according to the control flow graph. In order to locate all variables whose values may affect the partition key of the query request in the stored procedure, the monitoring node 110 can use the partition key of the query request as a starting point, trace back the value of the variable of the data flow, until all the chains reachable from the starting point are passed All roads are traversed. In an implementation, monitoring node 110 may use a graph traversal algorithm to perform such operations. In an implementation manner, after the monitoring node 110 obtains variables whose values may affect the partition key of the query request, these variables may be set as candidate input parameters. The monitoring node 110 may repeat the above operations for all partition keys of all query requests in the stored procedure, so as to obtain a set of candidate input parameters of partition keys that may affect all query requests of the stored procedure. In an implementation manner, the monitoring node 110 may set these candidate input parameters of the partition key that may affect the query request of the stored procedure as one or more input parameters for training the prediction function associated with the stored procedure.

At block 506, the monitoring node 110 may obtain historical data, including multiple value sets for one or more input parameters of the stored procedure and identifications of multiple data slices.

In an implementation, the monitoring node 110 may obtain historical data from the plurality of computing nodes 104 and load balancing nodes 108 . In an implementation manner, the historical data may include, but not limited to, multiple value sets of one or more input parameters of the stored procedure and identifiers of multiple data fragments. In an implementation, each data slice of the plurality of data slices may include a corresponding data slice that is evaluated by the stored procedure when one or more input parameters take a corresponding set of values of the plurality of value sets.

At block 508, the monitoring node 110 may train the classification model using the plurality of value sets as input and the corresponding identifications of the plurality of data shards as output.

In an implementation, the monitoring node 110 can train a classification model based on historical data, and the lightning protection model is used to learn or imitate the behavior of the prediction function of the stored procedure. In an implementation, the monitoring node 110 may use supervised training to train and obtain a classification model. In an implementation manner, the classification model may include but not limited to a neural network model, a deep learning model, a decision tree model, and the like.

By way of example and not limitation, in one example, a neural network model is used as a classification model to learn or mimic the behavior of a stored procedure's prediction function. In this example, one or more input parameters of the stored procedure obtained or determined at block 504 may be used as the input (or input features) of the neural network model, and the historical value (or set of values) of the one or more parameters is the training value of the input feature. In an implementation, each stored procedure may include one or more query requests and may perform operations (eg, access, update, etc.) on one or more data fragments of one or more database tables. In this case, the monitoring node 110 may select the most frequently operated data fragment from one or more data fragments of one or more database tables. In an implementation manner, the data fragment with the most frequent operation of the stored procedure may include but not limited to the data fragment with the largest number of rows accessed or affected by the query request in the stored procedure. In an implementation manner, the monitoring node 110 may regard the most frequently operated data slice as the corresponding output (or label) of the neural network model. In an implementation manner, such feature-label pairs can be obtained by monitoring the execution of the stored procedure, recording various input parameters and the corresponding data fragments being accessed and the corresponding number of rows being accessed or affected, and the like. The monitoring node 110 can then train the neural network model using conventional training or learning algorithms.

At block 510, the monitoring node 110 may set the trained classification model as a predictive function for mapping a new set of values for one or more input parameters of the stored procedure to corresponding data shards.

In an implementation, after completing the training of the classification model, the monitoring node 110 may use the trained classification model as a prediction function of the stored procedure. In an implementation, monitoring node 110 may send the prediction function to load balancing node 108 so that load balancing node 108 may use the prediction function to map stored procedures with any new set of input values for one or more input parameter settings to A corresponding data fragment (for example, an identifier of the data fragment), which may store data that will be accessed or updated by at least one query request of the stored procedure.

In an implementation, the monitoring node 110 may continue to receive new data and identifications of data fragments associated with new value sets for one or more input parameters of each stored procedure, the data fragments respectively including when a The corresponding data segment evaluated by each stored procedure when the or plurality of input parameters assumes a new value set, which is periodically obtained from the plurality of computing nodes 104 and load balancing nodes 108 . The monitoring node 110 may select a stored procedure and retrain the predictive function for the stored procedure according to operations as described in blocks 502 to 510 based on the new data and previously stored data.

Although in the above operations the prediction function is described as being trained for and associated with each stored procedure, in some cases the prediction function may be trained for and associated with a set of stored procedures. In this case, the input to the prediction function (i.e., the input parameters) may include combinations of candidate input parameters obtained from each stored procedure in the set of stored procedures as described in block 504, and the output of the predictor may include the possible The identification of the data shard that stores or contains data to be queried or updated by the corresponding stored procedure. In an implementation manner, the monitoring node 110 may automatically group stored procedures with similar candidate input parameters, or group stored procedures according to a user's request.

Referring back to FIG. 6, at block 602, the load balancing node 108 may receive a distributed database transaction including at least one query process.

In an implementation, database system 102 or load balancing node 108 of database system 102 may receive a distributed database transaction from client device 112 that includes at least one query process. In an implementation, the at least one query process may include one or more query requests that access or manipulate one of the one or more database tables located in one or more computing nodes (e.g., computing node 104) of database system 102. or more data shards.

At block 604, the load balancing node 108 may determine whether the at least one query procedure is a pre-stored procedure.

In an implementation, the query process can be a process that is pre-registered and stored in the database system 102 (i.e., a stored procedure), or it can be a process that is not registered in the database system 102 but is performed by the user 114 according to his/her needs in some way. A procedure written in a query language such as SQL. If the query procedure is a registered stored procedure, values for one or more input parameters of the stored procedure may be further provided by the user 114 when the stored procedure is sent to the database system 102 . In an implementation, the one or more input parameters may include one or more potential partition key values associated with one or more query requests included in the stored procedure.

In an implementation, a number of stored procedures can be registered and stored in database system 102 and can be invoked by users 114 . In order to distinguish different stored procedures, each stored procedure can be assigned a unique identifier, which can uniquely represent the corresponding stored procedure. The unique identifier of the stored procedure may include but not limited to a unique name of the stored procedure, a unique index of the stored procedure, and the like. In an implementation, a stored procedure may include one or more input parameters or objects through which a user 114 may provide input values to the stored procedure. For example, in the stored procedure of the above example (payment_proc), the stored procedure can be associated with a unique name, namely payment_proc, which can uniquely identify the stored procedure and distinguish the stored procedure from other stored procedures in the database system 102 open. Illustratively, the stored procedure may also include a parameter list that includes a number of input parameters provided or entered by the user 114 (i.e., in_w_idinteger, in_w_zip integer, in_c_idinteger, in_c_zip integer, in_payment_amountdecimal)

In an implementation, the load balancing node 10 determines whether the received query procedure is a registered stored procedure, and the load balancing node 10 judges whether the received query procedure is associated with an identifier (for example, a name, etc.) and the identifier is stored in the The identifier of the stored procedure registered in the database system 102 is registered or found in the data structure (for example, table or list, etc.) to determine whether the query procedure is a stored procedure. Continuing with the above example, the load balancing node 108 can determine whether the received query process is associated with a name (e.g. payment_proc), and if so, further determine whether the name is stored in the data structure of the identifier of the stored procedure registered in the database system 102 was registered or found in . If it is determined that the name is registered or found, the load balancing node 108 may determine that the received query procedure is a registered stored procedure. Optionally, if the received query procedure is not associated with any name, or the name associated with the received query procedure is not registered or found in the data structure storing the identification of the stored procedure registered in the database system 102, then The load balancing node 108 may determine that the received query procedure is not a registered stored procedure.

At block 606, the load balancing node 108 may employ a predetermined load balancing policy to distribute the distributed database transactions to the compute nodes in response to determining that the received query procedure is not a registered stored procedure.

In an implementation, if it is determined that the received query process is not a registered stored process, then the load balancing node 108 can use a predetermined load balancing strategy to distribute the distributed database transaction to one of the multiple computing nodes 104 included in the database system 102 calculate node. As an example and not a limitation, the predetermined load balancing strategy may include: randomly assigning distributed database transactions to computing nodes, distributing distributed database transactions to computing nodes in a round-robin manner, and assigning distributed database transactions to computing nodes with the smallest current workload Computing nodes, or assigning distributed database transactions to computing nodes based on the IP address of the client device from which the distributed database transactions came.

At block 608, in response to determining that the received query procedure is a registered stored procedure, the load balancing node 108 may determine or select a predictive function for the stored procedure from a plurality of predictive functions.

In an implementation, after determining that the received query procedure is a registered stored procedure, the load balancing node 108 may determine or select a prediction function for the stored procedure. In an implementation, the database system 102 may include or store multiple predictive functions, and each predictive function may be configured to perform prediction or mapping on one or more stored procedures. In an implementation, the load balancing node 108 can determine or select a prediction function for the stored procedure based at least in part on the stored procedure's identification (eg, name or index).

In an implementation, the load balancing node 108 or the database system 102 may include or store a data structure (such as a table, etc.), and the data structure includes a mapping relationship between multiple stored procedures and multiple predictive functions, such as multiple stored procedures The mapping relationship between identifiers of multiple predictive functions, or the mapping relationship between identifiers of multiple stored procedures and storage locations of multiple predictive functions, etc. The load balancing node 108 may determine or select a prediction function for a stored procedure from a data structure including a mapping relationship between a plurality of stored procedures and a plurality of prediction functions based at least in part on the identification of the stored procedure.

As an example and not a limitation, the load balancing node 108 may determine or obtain the identifier of the stored procedure, obtain the identifier of the predictive function based on the identifier of the stored procedure and the mapping relationship, and select a predictive function from multiple predictive functions based on the identifier of the predictive function.

In an implementation, each prediction function may include a classification model, the classification model is trained based on multiple partition key values and corresponding identifications of multiple fragments, and the multiple fragments include The data segment, and multiple shards can be stored in multiple computing nodes. By way of example and not limitation, classification models may include neural network models.

At block 610, the load balancing node 108 may extract or determine input values for one or more input parameters of the stored procedure.

In an implementation, a stored procedure may include a parameter list through which a user 114 may enter values for one or more input parameters of the stored procedure. The load balancing node 108 may extract or determine input values for one or more input parameters of the stored procedure from the parameter list. In an implementation, load balancing node 108 may use static program analysis to extract or determine input values for one or more input parameters of the stored procedure.

At block 612, the load balancing node 108 may determine the compute nodes to which the stored procedure is sent or assigned based at least in part on the prediction function and input values of one or more input parameters of the stored procedure.

In an implementation, after determining input values for the prediction function and one or more input parameters of the stored procedure, the load balancing node 108 may determine the compute nodes to which the stored procedure is sent or distributed. In an implementation, load balancing node 108 may apply a predictive function to input values of one or more input parameters of a stored procedure to produce an output of the predictive function. In an implementation, the output of the prediction function may be a label associated with a location of data potentially or likely to be accessed or queried by at least one query request of the stored procedure. In an implementation, the tag may include an identification of a data slice of a database table that includes or stores data potentially or likely to be accessed or queried by at least one query request of the stored procedure. In an implementation, the load balancing node 108 may then employ a placement function to map the identification of the data slice to the identification of the compute node that includes or stores the data slice.

In an implementation, each predictive function of the plurality of predictive functions may be combined with a partition function to form a corresponding combined predictive-partition function, and given the same identification as the corresponding predictive function. In this case, the load balancing node 108 can directly use the combined prediction-partition function to obtain the identity of the compute node to which the stored procedure is assigned.

At block 614, the load balancing node may send the stored procedure to the compute node.

After determining the identity of the computing node, the load balancing node can send the stored procedure to the computing node, so as to allow the computing node to process the stored procedure, and/or coordinate and manage the processing of the stored procedure as a control node.

Although the above method blocks are described as being performed in a particular order, in some implementations some or all of these method blocks may be performed in other orders or in parallel.

in conclusion

Although implementations have been described in language specific to structural features and/or methodological acts, it is to be understood that claims are not necessarily limited to the specific features or acts described. Rather, the specific features and acts are disclosed as example forms of implementing the claimed subject matter. Additionally or alternatively, some or all of the operations may be implemented by one or more ASICs, FPGAs, or other hardware.

The disclosure can be further understood using the following terms.

Clause 1: A method implemented by a load balancing node, the method comprising: receiving a distributed transaction including a stored procedure; selecting a predictive function for the stored procedure from a plurality of predictive functions; extracting one or a plurality of input parameters; using the predictive function to determine a compute node based at least in part on the one or more input parameters; and forwarding the stored procedure to the compute node for processing the stored procedure.

Clause 2: The method of Clause 1, wherein the one or more input parameters include one or more partition key values associated with one or more query requests included in the stored procedure.

Clause 3: The method of clause 1, wherein selecting the predictive function for the stored procedure from the plurality of predictive functions comprises: determining an identity of the stored procedure; mapping based on the identity of the stored procedure obtaining an identification of the predictive function; and selecting the predictive function from the plurality of predictive functions based on the identification of the predictive function.

Clause 4: The method of clause 1, wherein extracting the one or more input parameters from the stored procedure comprises extracting the one or more input parameters from a parameter list of the stored procedure or using a static Program analysis extracts the one or more input parameters from the stored procedure.

Clause 5: The method of clause 1, wherein the stored procedure comprises a stored procedure that is pre-registered and stored in the database system before being invoked.

Clause 6: The method of Clause 1, wherein determining the computing node based at least in part on the one or more input parameters comprises: using the predictive function to determine a relationship with the storing an identifier of the at least one query request associated with the data fragment; and based on the identifier of the data fragment, using a placement function to determine the identifier of the computing node storing the data fragment.

Clause 7: The method of Clause 1, wherein the prediction function comprises a classification model trained based on a plurality of partition key values and corresponding identifications of a plurality of shards, the plurality of shards comprising a database Each data segment corresponding to the multiple partition key values in the table, the multiple fragments are separately stored in multiple computing nodes.

Clause 8: The method of Clause 7, wherein the classification model comprises a neural network model.

Clause 9: A computer-readable medium storing executable instructions that, when executed by one or more processors, cause the one or more processors to perform the following actions: Execute a stored procedure Static program analysis to determine one or more input parameters; obtain stored data, the stored data includes a plurality of value sets for the one or more input parameters of the stored procedure, and identification of a plurality of data slices; The plurality of value sets are used as input, the corresponding identifiers of the plurality of data slices are used as output, and a classification model is trained; and the trained classification model is set as a prediction function, and the prediction function is used to use the stored A new set of values for the one or more input parameters of the process is mapped to a corresponding data slice.

Clause 10: The computer-readable medium of Clause 9, wherein each data slice of the plurality of data slices comprises when the one or more input parameters take a corresponding set of values in the plurality of sets of values The corresponding data segment evaluated by the stored procedure.

Clause 11: The computer-readable medium of Clause 9, wherein performing the static program analysis on the stored procedure to determine the one or more input parameters comprises: identifying at least one query representing a query included in the stored procedure A variable for the partition key in the request; and one or more input parameters for determining the variable using a graph traversal algorithm.

Clause 12: The computer-readable medium of Clause 9, wherein the classification model comprises a neural network model.

Clause 13: The computer-readable medium of Clause 9, further comprising: sending the classification model to a load balancing node.

Clause 14: The computer-readable medium of Clause 9, further comprising: receiving new data associated with a new set of values for the one or more input parameters of the stored procedure from a plurality of computing nodes, and data sharding An identification of , the data shard comprising corresponding data segments evaluated by the stored procedure when the one or more input parameters assume the new set of values.

Clause 15: The computer-readable medium of Clause 14, further comprising: retraining the classification model based at least in part on stored data and new data.

Clause 16: A system comprising: one or more processors; and memory storing executable instructions that, when executed by the one or more processors, cause the one or more The plurality of processors perform acts of: performing static program analysis on a stored procedure to determine one or more input parameters; obtaining stored data including a plurality of the one or more input parameters of the stored procedure Value set, and the identification of a plurality of data slices; Using the multiple value sets as input, using the corresponding identification of the multiple data slices as output, training classification model; and setting the trained classification model is a prediction function, and the prediction function is used to map the new value set of the one or more input parameters of the stored procedure to the corresponding data slice.

Clause 17: The system of Clause 16, wherein each data slice of the plurality of data slices comprises the The corresponding data segment for the stored procedure evaluation.

Clause 18: The system of Clause 16, wherein performing the static program analysis on the stored procedure to determine the one or more input parameters comprises: identifying an a variable for the partition key; and determining one or more input parameters for the variable using a graph traversal algorithm.

Clause 19: The system of Clause 16, wherein the classification model comprises a neural network model.

Clause 20: The system of Clause 16, wherein the actions further comprise: receiving from a plurality of computing nodes new data associated with a new set of values for the one or more input parameters of the stored procedure, and data identification of slices, said slices of data respectively comprising corresponding data segments evaluated by said stored procedure when said one or more input parameters assume said new set of values; and based at least in part on stored data and said new set of values data to retrain the classification model.

Claims (20)

1. A method implemented by a load balancing node, the method comprising: Receive distributed transactions including stored procedures; selecting a prediction function for the stored procedure from a plurality of prediction functions; extracting one or more input parameters from the stored procedure; determining a compute node based at least in part on the one or more input parameters using the prediction function; and The stored procedure is forwarded to the compute node for processing the stored procedure. 2. The method of claim 1, wherein the one or more input parameters include one or more partition key values associated with one or more queries included in the stored procedure. 3. The method of claim 1, wherein selecting the predictive function for the stored procedure from the plurality of predictive functions comprises: determining an identity of the stored procedure; obtaining the identifier of the predictive function according to the identifier of the stored procedure and the mapping relationship; and The predictive function is selected from the plurality of predictive functions based on the identification of the predictive function. 4. The method of claim 1, wherein extracting the one or more input parameters from the stored procedure comprises: The one or more input parameters are extracted from a parameter list of the stored procedure, or the one or more input parameters are extracted from the stored procedure using static program analysis. 5. The method of claim 1, wherein the stored procedure comprises a procedure that is pre-registered and stored in a database system before being invoked. 6. The method of claim 1 , wherein determining the compute node based at least in part on the one or more input parameters using the predictive function comprises: determining, using the predictive function, an identity of a data shard associated with at least one query included in the stored procedure based on the one or more input parameters; and Based on the identifier of the data slice, a placement function is used to determine the identifier of the computing node, and the computing node stores the data slice. 7. The method of claim 1, wherein the predictive function comprises a classification model trained based on a plurality of partition keys and corresponding identifications of a plurality of fragments, the plurality of fragments comprising a database Corresponding data segments corresponding to the multiple partition key values in the table, the multiple fragments are respectively stored in multiple computing nodes. 8. The method of claim 7, wherein the classification model comprises a neural network model. 9. A computer-readable medium storing executable instructions that, when executed by one or more processors, cause the one or more processors to perform the following actions: performing static program analysis on the stored procedure to determine one or more input parameters; obtaining stored data, the stored data including a plurality of value sets for the one or more input parameters of the stored procedure, and identifications of a plurality of data slices; Using the plurality of value sets as input and the corresponding identifiers of the plurality of data slices as output, training a classification model; and The trained classification model is set as a predictive function for mapping new sets of values of the one or more input parameters of the stored procedure to corresponding data slices. 10. The computer-readable medium of claim 9 , wherein each data slice of the plurality of data slices includes when the one or more input parameters take a corresponding set of values in the plurality of sets of values The corresponding data segment evaluated by the stored procedure. 11. The computer-readable medium of claim 9, wherein performing static program analysis on the stored procedure to determine the one or more input parameters comprises: identifying a variable representing a partition key in at least one query included in the stored procedure; and One or more input parameters for the variables are determined using a graph traversal algorithm. 12. The computer readable medium of claim 9, wherein the classification model comprises a neural network model. 13. The computer-readable medium of claim 9, further comprising: sending the classification model to a load balancing node. 14. The computer readable medium of claim 9, further comprising: Receive from a plurality of compute nodes new data associated with the new set of values for the one or more input parameters of the stored procedure, and an identification of a data slice, the data slices respectively including when the one or more The corresponding data segment evaluated by the stored procedure when an input parameter takes the new set of values. 15. The computer-readable medium of claim 14, further comprising retraining the classification model based at least in part on stored data and the new data. 16. A system comprising: one or more processors; and a memory storing executable instructions that, when executed by the one or more processors, cause the one or more processors to perform the following actions: performing static program analysis on the stored procedure to determine one or more input parameters; obtaining stored data, the stored data including a plurality of value sets for the one or more input parameters of the stored procedure, and identifications of a plurality of data slices; Using the plurality of value sets as input and the corresponding identifiers of the plurality of data slices as output, training a classification model; and The trained classification model is set as a predictive function for mapping new sets of values of the one or more input parameters of the stored procedure to corresponding data slices. 17. The system of claim 16 , wherein each data slice of the plurality of data slices includes the input parameters determined by the The corresponding data segment for the stored procedure evaluation. 18. The system of claim 16, wherein performing static program analysis on the stored procedure to determine the one or more input parameters comprises: identifying a variable representing a partition key in at least one query included in the stored procedure; and One or more input parameters for the variables are determined using a graph traversal algorithm. 19. The system of claim 16, wherein the classification model comprises a neural network model. 20. The system of claim 16, wherein the actions further comprise: Receive from a plurality of compute nodes new data associated with the new set of values for the one or more input parameters of the stored procedure and an identification of a data slice, the data slice respectively including when the one or more the corresponding data segment evaluated by the stored procedure when the input parameter assumes the new set of values; and The classification model is retrained based at least in part on the stored data and the new data.

Images