CN107545015B - A processing method and processing device for querying faults - Google Patents

Abstract

The invention discloses a method for processing query faults, comprising: receiving a query statement and generating a corresponding query plan tree, wherein the query plan tree includes multi-layer operators with pipeline relationships, wherein each operator includes a logic operation The logical relationship formed; the query statement is executed according to the query plan tree; when a fault occurs during the execution of the query statement, the intermediate state information of the faulty operator is retrieved, and the intermediate state information is the backup at the backup time point before the execution failure occurs. , according to the query plan tree and the intermediate state information of the fault operator, update the operators of the fault operator and the logical relationship between the operators to obtain the reconstructed query plan tree; after the fault is recovered, according to the reconstructed query Plan the tree and continue to run the query statement to get the query result of the query statement. The embodiments of the present invention can ensure that the current query statement continues to be executed after the fault is recovered, thereby reducing the impact of query interruption on the entire query process.

Description

A processing method and processing device for querying faults

technical field

The invention relates to the technical field of computers, in particular to a processing method and processing device for querying faults.

Background technique

Database system is the most challenging and core part of the whole software building. A complete database system usually consists of two parts: database and database management system (DBMS). With the advent of the era of big data, the database usually needs to store massive data, and users can query the data in the database through the database management system. In order to meet the needs of different users for query services in different environments, the database system needs to have strong robustness to ensure the normal execution of query services. In fact, due to the complexity of the business environment and the diversity of factors affecting the stability of the database, the possibility of database system failures always exists.

For some query services with high complexity and long query time, the failure of the database system will cause the query service to be interrupted, and the subsequent job rerun will seriously affect the progress of the entire service. A job rerun is a re-query from scratch. In particular, for companies that need to ensure that business is closed on time and used for market analysis, a delay in schedule can have disastrous effects.

SUMMARY OF THE INVENTION

In order to solve the problem that a query failure affects the entire query business process in the prior art, the embodiment of the present invention provides a processing method for a query failure, which can ensure that the current query statement can continue to be executed after the database system failure is recovered, thereby reducing query interruption Impact on the entire query business process. The embodiment of the present invention also provides a corresponding processing device.

A first aspect of the present invention provides a processing method for querying faults, which is applied to a database management system. The database management system can be implemented by a database server. The database server communicates with an external storage device of the database through a communication network. The database management system is in When a query statement is executed, if a query failure occurs, the processing method for the query failure includes: receiving the query statement, and generating a query plan tree corresponding to the query statement. Including an operator, each operator includes operators and the logical relationship between the operators; the query statement is executed according to the query plan tree; when a fault occurs during the execution of the query statement, the fault operator is called. Intermediate state information. The intermediate state information is backed up at the backup time point before the execution failure occurs, and the intermediate state information includes the completed operations and uncompleted operations of the fault operator at the backup time point. The fault operator is the execution time when the failure occurs. The operator that is executing the query statement; according to the query plan tree and the intermediate state information of the faulty operator, update the operator of the faulty operator and the logical relationship between the operators to obtain the reconstructed query plan tree; when the fault is recovered , and continue to run the query statement according to the reconstructed query plan tree to obtain the query result of the query statement. The query failures described in the embodiments of the present invention may include execution node failures, machine failures, abnormal network interruptions, and the like. From the first aspect above, it can be seen that the query plan tree is reconstructed through the intermediate state information of the fault operator, which can ensure that the current query statement can continue to be executed after the database system fault is recovered, thereby reducing the impact of query interruption on the entire query business process. influences.

With reference to the first aspect, in a first possible implementation manner, the processing method for querying a fault further includes: selectively backing up the intermediate state information of the faulty operator based on the backup cost of the intermediate state of the faulty operator. The cost involved in the embodiment of the present invention can be understood as resource consumption, for example, the processor cost refers to the occupancy of the processor, and the page read cost refers to the amount of resources consumed for service reading. From the first possible implementation of the first aspect above, it can be seen that whether to back up the intermediate state information of the faulty operator is based on the backup cost, and the backup will be performed when the cost is small. This not only enables job continuation, but also saves hardware. resource.

With reference to the first possible implementation manner of the first aspect, in the second possible implementation manner, the step of selective backup in the first possible implementation manner is periodically performed.

In combination with the first possible or second possible implementation manner of the first aspect, in the third possible implementation manner, the steps in the above-mentioned first possible implementation manner: based on the backup cost of the intermediate state of the fault operator, select The intermediate state information of the faulty backup fault operator, including: when it is determined that the cost saved by continuing to run the faulty operator is greater than the sum of the cost of the completed operation of the backup faulty operator and the cost of restoring the uncompleted operation of the faulty operator, The intermediate state information of the faulty operator is backed up. From the third possible implementation of the first aspect above, it can be seen that only when the cost saved by continuing the operation is greater than the sum of the costs required for the operations completed by the backup fault operator and the operations not completed by the recovery fault operator Only the intermediate state information of the faulty operator is backed up, which can fully save hardware resources.

In combination with the first possible or second possible implementation manner of the first aspect, in the fourth possible implementation manner, the steps in the first possible implementation manner above: based on the backup cost of the intermediate state of the fault operator, select The intermediate state information of the backup fault operator, including: when it is determined that the cost of continuing the operation of the faulty operator is less than the sum of the completed operations of the backup faulty operator and the cost required to restore the uncompleted operations of the faulty operator, the backup Intermediate state information of the fault operator. From the fourth possible implementation of the first aspect above, it can be seen that only when the cost of continuing the operation is less than the sum of the costs of the operations completed by the backup fault operator and the operations that have not been completed by the recovery fault operator. Back up the intermediate state information of the faulty operator, which can fully save hardware resources.

With reference to the first aspect, the first or second possible implementation manner of the first aspect, in a fifth possible implementation manner, the steps in the first aspect: according to the query plan tree and the intermediate state information of the fault operator, Update the operator of the fault operator and the logical relationship between the operators to obtain the reconstructed query plan tree, including: recursively processing the unfinished operations and the completed operations to obtain the reconstruction information of the fault operator, so The reconstruction information includes reconstruction operators and the logical relationship between the reconstruction operators; according to the reconstruction information, update the original information corresponding to the reconstruction information in the fault operator of the query plan tree, so as to obtain the reconstruction information. A query plan tree is constructed, and the original information includes original operators and logical relationships between the original operators. It can be seen from the fifth possible implementation manner of the above-mentioned first aspect that the reconstruction of the query plan tree is completed by modifying the logical relationship between operators at the operator level, which can improve the efficiency and accuracy of reconstruction.

With reference to the fifth possible implementation manner of the first aspect, in the sixth possible implementation manner, the steps in the fifth possible implementation manner above: recursively process unfinished operations and completed operations to obtain the Reconstruction information of the faulty operator, including: setting the completed operator for the completed operation, and setting the start operator for marking the starting position of the incomplete operation in the incomplete operation, so as to obtain the reconstruction operator and the restart operator. logical relationship between operators. It can be seen from the sixth possible implementation manner of the above-mentioned first aspect that the reconstruction of the query plan tree is completed by modifying the logical relationship between operators at the operator level, which can improve the efficiency and accuracy of reconstruction.

Combined with the third possible implementation manner of the first aspect, in the seventh possible implementation manner, the processing method for querying the fault further includes: when it is determined that the cost saved by continuing running is less than the sum of the required costs, then record The query statement is used to regenerate the query plan tree after the query failure is recovered. It can be seen from the seventh possible implementation manner of the above-mentioned first aspect that when the cost is not saved, the query statement is directly recorded, thereby avoiding unnecessary resource consumption.

With reference to the fourth possible implementation manner of the first aspect, in the eighth possible implementation manner, the processing method for querying the fault further includes: when it is determined that the cost of continuing running is greater than the sum of the required costs, recording the A query statement, where the query statement is used to regenerate the query plan tree after the query failure is recovered. It can be seen from the eighth possible implementation manner of the above-mentioned first aspect that when the cost is not saved, the query statement is directly recorded, thereby avoiding unnecessary resource consumption.

In combination with the first aspect, the first, second or third possible implementation manners of the first aspect, in a ninth possible implementation manner, the processing method for a query fault further includes: a fault occurs when a query plan tree is generated , the query statement is recorded, and the query statement is used to regenerate the query plan tree after query failure recovery. It can be seen from the ninth possible implementation manner of the above-mentioned first aspect that a query failure occurs in the stage of generating the query plan tree, and the query statement is directly recorded, thereby avoiding unnecessary resource consumption.

A second aspect of the present invention provides a processing device for querying faults. The processing device is configured to implement the functions of the method provided in the first aspect or any optional implementation manner of the first aspect, and is implemented by hardware/software. /Software includes units corresponding to the above functions.

A third aspect of the present invention provides a device for querying fault processing, comprising: a transceiver, a processor and a memory, where the memory is used for backing up intermediate state information of a faulty operator; the transceiver is used for receiving a query statement; the processor is used for performing the following steps: A query plan tree corresponding to the query statement is generated, and the query plan tree includes multiple layers of operators in a pipeline relationship, wherein each layer includes at least one operator, and each operator includes an operator and a logical relationship between the operators; according to The query plan tree executes the query statement; when a fault occurs during the execution of the query statement, the intermediate state information of the faulty operator is retrieved. The intermediate state information is backed up at the backup time point before the execution failure, and the intermediate state information includes The completed and uncompleted operations of the fault operator at the backup time point. The fault operator is the operator that was executing the query statement when the fault occurred; the fault operator is updated according to the query plan tree and the intermediate state information of the fault operator. The operator and the logical relationship between the operators are used to obtain the reconstructed query plan tree; when the fault is recovered, the query statement is continued to run according to the reconstructed query plan tree to obtain the query result of the query statement. It can be seen from the above description that the query plan tree is reconstructed through the intermediate state information of the fault operator, which can ensure that the current query statement can continue to be executed after the database system fails to recover, thereby reducing the impact of query interruption on the entire query business process. From the third aspect above, it can be seen that the query plan tree is reconstructed by the intermediate state information of the fault operator, which can ensure that the current query statement can continue to be executed after the database system fault is recovered, thereby reducing the impact of query interruption on the entire query business process. influences.

With reference to the third aspect, in a first possible implementation manner, in the processing device for querying a fault, the processor is further configured to selectively back up the intermediate state information of the faulty operator based on the backup cost of the intermediate state of the faulty operator. From the first possible implementation of the third aspect above, it can be seen that whether to back up the intermediate state information of the faulty operator is based on the backup cost, and the backup will be performed when the cost is low. This not only enables job continuation, but also saves hardware. resource.

With reference to the first possible implementation manner of the third aspect, in the second possible implementation manner, the processor is specifically configured to: periodically execute the step of selective backup.

Combined with the first possible or second implementation manner of the third aspect, in the third possible implementation manner, the processor is specifically used for: when it is determined that the cost saved by continuing to run the faulty operator is greater than that of the backup faulty operator. When the sum of the completed operation and the cost required to restore the uncompleted operation of the faulty operator, the intermediate state information of the faulty operator is backed up. From the third possible implementation of the third aspect above, it can be seen that only when the cost saved by continuing to run is greater than the sum of the costs required for the operations completed by the backup fault operator and the operations not completed by the recovery fault operator Only the intermediate state information of the faulty operator is backed up, which can fully save hardware resources.

In combination with the first possible or second possible implementation manner of the first aspect, in the fourth possible implementation manner, the processor is specifically configured to: when it is determined that the cost of continuing the operation of the faulty operator is less than the cost of the backup faulty operator that has been completed. The intermediate state information of the faulty operator is backed up when the sum of the costs required to operate and restore the unfinished operations of the faulty operator is calculated. From the fourth possible implementation of the third aspect above, it can be seen that only when the cost of continuing the operation is less than the sum of the costs of the operations completed by the backup fault operator and the costs of recovering the operations not completed by the fault operator. Back up the intermediate state information of the faulty operator, which can fully save hardware resources.

In combination with the third aspect, the first or second possible implementation manner of the third aspect, in the fifth possible implementation manner, the processor is specifically used for: recursively processing unfinished operations and completed operations to obtain The reconstruction information of the fault operator, the reconstruction information includes the reconstruction operator and the logical relationship between the reconstruction operators; according to the reconstruction information, the original information corresponding to the reconstruction information in the fault operator of the query plan tree is updated, To obtain a reconstructed query plan tree, the original information includes the original operators and the logical relationship between the original operators. It can be seen from the fifth possible implementation manner of the above third aspect that the reconstruction of the query plan tree is completed by modifying the logical relationship between operators at the operator level, which can improve the efficiency and accuracy of reconstruction.

With reference to the fifth possible implementation manner of the third aspect, in the sixth possible implementation manner, the processor is specifically configured to: set a completed operator for a completed operation, and set a flag for an incomplete operation in an incomplete operation The start operator at the starting position of the operation to obtain the refactoring operator and the logical relationship between the refactoring operators. It can be seen from the sixth possible implementation manner of the above third aspect that the reconstruction of the query plan tree is completed by modifying the logical relationship between operators at the operator level, which can improve the efficiency and accuracy of reconstruction.

In combination with the third possible implementation manner of the third aspect, in the seventh possible implementation manner, the processor is further configured to record the query statement when it is determined that the cost saved by continuing running is less than the sum of the required costs, The query statement is used to rebuild the query plan tree after query failure recovery. It can be seen from the seventh possible implementation manner of the above third aspect that when the cost is not saved, the query statement is directly recorded, thereby avoiding unnecessary resource consumption.

Combined with the fourth possible implementation manner of the third aspect, in the eighth possible implementation manner, the processor is further configured to record the query statement when it is determined that the cost of continuing running is greater than the sum of the required costs. Used to rebuild the query plan tree after query failure recovery. It can be seen from the eighth possible implementation manner of the third aspect above, when the cost is not saved, the query statement is directly recorded, thereby avoiding unnecessary resource consumption.

In combination with the third aspect, the first, second or third possible implementation manners of the third aspect, in the ninth possible implementation manner, the processor is further configured to record the query plan tree when a fault occurs when generating the query plan tree. Query statement. The query statement is used to rebuild the query plan tree after query failure recovery. It can be seen from the ninth possible implementation manner of the above-mentioned third aspect that if a query failure occurs in the stage of generating the query plan tree, the query statement is directly recorded, thereby avoiding unnecessary resource consumption.

A fourth aspect of the present invention provides a computer storage medium, where the computer storage medium stores a fault query processing program according to the first aspect or any optional implementation manner of the first aspect.

A fifth aspect of the present invention provides a database management system, comprising: a processing device for querying faults and an external storage device, and the terminal device is the processing device of the second or third aspect.

Description of drawings

In order to illustrate the technical solutions in the embodiments of the present invention more clearly, the following briefly introduces the accompanying drawings used in the description of the embodiments. Obviously, the accompanying drawings in the following description are only some embodiments of the present invention. For those skilled in the art, other drawings can also be obtained from these drawings without creative effort.

1 is a schematic structural diagram of a hardware environment where a database management system is located in an embodiment of the present invention;

2A is a schematic diagram of an example of a query plan tree in an embodiment of the present invention;

2B is a schematic diagram of an example of database operation combined with a data table in an embodiment of the present invention;

Fig. 2C is the query result of the example scene in the embodiment of the present invention;

Figure 3 is a schematic diagram of the database management system;

4 is a schematic diagram of a representation form of a query plan tree in an embodiment of the present invention;

5 is a schematic diagram of an embodiment of a query fault processing process in an embodiment of the present invention;

6 is a schematic diagram of another embodiment of a query fault processing process in an embodiment of the present invention;

7 is a schematic diagram of an embodiment of a processing method for querying a fault in an embodiment of the present invention;

FIG. 8 is a schematic diagram of an embodiment of a server in an embodiment of the present invention.

Detailed ways

The embodiment of the present invention provides a method for processing a query fault, which can ensure that the current query statement can continue to be executed after the fault is recovered, thereby saving query time. The embodiment of the present invention also provides a corresponding device. Each of them will be described in detail below.

The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, but not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative efforts shall fall within the protection scope of the present invention.

The processing method for querying faults in the embodiment of the present invention may be implemented in the database server 1 as shown in FIG. 1 . The database server 1 has a memory, such as a memory and a hard disk, for storing data and computer executable programs; the database server 1 also includes at least one processor, such as a central processing unit (Central Processing Unit, CPU) capable of reading a computer-executable program from a memory and executing the program. An operating system 15 , a database management system (DBMS) 5 , and an application program (APP) 3 run on the database server 1 . The operating system (Operating System, OS) 15, the database management system 5, and the application program can be stored in the memory in the form of executable codes, and are executed by the processor to implement corresponding functions. The APP3 generates a query statement according to a user's operation or a system trigger, and the query statement may be, for example, a structured query language (Structured Query Language, SQL). The database management system 5 is used for receiving the query statement from the APP 3, executing the query statement and returning the query result to the APP 3 and the operating system 15, and the operating system can be Linux, for example. The operating system 15 is used to manage the hardware and software resources of the database server 1, and provides an interface to the upper-level database management system 5 and the APP 3, and the database management system 5 and the APP 3 can call corresponding hardware resources through the interface.

Further, as shown in FIG. 1 , the database server 1 and the external storage device 19 are communicatively connected via the communication network 17 .

External storage device 19 may be any device having storage resources. For example, the external storage device 19 may be a file server, a single disk drive (eg, a hard disk drive), or a storage system with multiple disk drives. The database 21 in the external storage device can store a plurality of indexes 25 and a plurality of tables 23 . The data of each index 25 includes, for example, the permutation item index 25A and the order index 25B shown in FIGS. 2A and 2B . The data of each table 23 includes, for example, a partial table 23A shown in FIG. 2B , a LINEITEM table 23B and an ORDER table 23C, each table including a plurality of rows, each row consisting of a plurality of row elements composition. Indexes are used to establish a relationship between one table and another. For example, the arrangement item index 25A shown in FIG. 2B is used for establishing the connection between the partial table and the arrangement item table, and the sequence index 25B is used for establishing the connection between the arrangement item table and the sequence table.

As shown in FIG. 1 , the DBMS 5 includes a query interface 7 , a query plan tree generator 11 , a query executor 9 , a query task manager 13 and a database buffer (DB buffer) 12 . The query interface 7 is used to receive the query statement from APP3, and the query plan tree generator 11 is used to generate a query plan tree such as shown in FIG. 2A . The query executor 9 is used to execute the query statement according to the query plan tree. The task manager 13 is used to manage query statements. The DB buffer 12 is a storage resource and can cache data required by the query executor 9 to execute tasks.

The following takes the data of FIG. 2A and FIG. 2B as examples to introduce the process of the DBMS5 executing the query statement and outputting the query result shown in FIG. 2C .

The DBMS5 receives the query statement from the application (eg, APP3) and generates the query plan tree shown in Figure 2A. As shown in FIG. 2A , the query plan tree includes five layers of operators in a pipeline relationship. From the bottom layer to the top layer, they are operator 1, operator 2, operator P3, operator 4 and operator 5, indicating that the five layers are Operators are executed sequentially in a pipelined manner. In the example shown in FIG. 2A , each layer of operators includes one operator, but this example is only a special case. In fact, in different example scenarios, each layer of operators may include one or more operators. In this embodiment of the present invention, the operation logic of each layer in the query plan tree is described by one or more operators. In other scenarios, the operation logic of the query plan tree may also be described by operation (Operation, OP), or it may be Described by nodes. However, no matter what is used for description, it should not limit the understanding of the embodiments of the present invention. Further, because a single operator usually has no logical meaning, an operator usually contains multiple operators and the logical relationship between these operators. Taking operator 3 as an example, the operator 3 includes a data extraction operation and an object identifier filtering operation, and a logical relationship between the data extraction operation and the object identifier filtering operation. Among them, both the data extraction operation and the object identifier filtering operation need to be composed of multiple operators and logical relationships between the operators. Operator 1 also includes the row search operation and the read data operation, as well as the logical relationship between the row search operation and the read data operation. Also, both row lookup operations and read data operations may require multiple operators and logical relationships between operators. 2A, operator 1 includes a partial table 23A, operator 3 includes an array item (LINEITEM) table 23B, operator 5 includes an order (ORDER) table 23C, and operator 2 includes an array item Index 25A, operator 4 includes a sequential index 25B. Among them, examples of the part table 23A, the arrangement item table 23B and the sequence table 23C are shown in FIG. 2B . The permutation item index 25A and the order index 25B may be stored in, for example, the external storage device 19 shown in FIG. 1 .

According to the query plan tree shown in Figure 2A. Operators 1 to 5 shown in FIG. 2A are sequentially executed by the query executor 9 until all rows in the partial table 23A are read.

In conjunction with the operators of Figures 2A and 2B, the row to be read is locked by row lookup during the execution of operator 1, and then by reading a row from part table 23A, for example, reading the second row, named BX01, Product identification PID=301. In the process of executing operator 2, the index PID is determined from the row data output by operator 1, for example, PID=301, and then the operation of LINEITEM index 25A is used to index the corresponding row in the array item table. In the process of executing operator 3, the index PID is used to search the corresponding data in the LINEITEM table 23B. When the second row is read by operator 1, the index PID=301 is determined when operator 2 is executed, and operator 3 reads the row with the corresponding PID=301 from the LINEITEM table 23B, and then uses the row identifier (ROW identifier, OID) to perform filtering, for example, only output rows with OID less than 504, because there are two rows with PID=301 in LINEITEM table 23B, and the corresponding OIDs are 500 and 503, then both rows can be output. Executing operator 4 is to execute the sequential indexing operation, that is, according to the row determined by executing operator 3, determine the index OID. For example, according to the above description, the determined indexes are OID=500 and OID=503, and then use the index OID to index to The corresponding row in the sequence table. In the process of executing operator 5, the OID is used to search for the corresponding OID in the ORDER table 23C, and the corresponding row in the ORDER table 23C is found. Then, using OID=500 and OID=503, the corresponding two rows of data in the ORDER table 23C can be determined.

After performing the above operations, you can return to operator 1, read the next row in the partial table, and then perform the corresponding operations from operators 1 to 5 in sequence until each row in the partial table is read. , and finally output the query result shown in Figure 2C.

In the embodiment of FIGS. 2A to 2C , the task of the operator is performed by the query executor 9 . If it is necessary to read the data of the external storage device 19 during the execution of the task, the query executor 9 will read the data and execute the operator task.

3 and 4 are used as examples to introduce the process of executing query statements in the database management system under normal conditions. The database management system 5 shown in FIG. 3 only shows some key modules, and other modules not shown. The function can be understood by referring to Figure 1 section.

As shown in FIG. 3, the database management system may include a query interface 7, a query plan generator 11 and a query executor 9. After the query interface 7 receives the query statement, the query plan generator 11 will generate a query plan according to the obtained query statement. Tree, where the query plan tree includes multiple layers of operators in a pipeline relationship, the operators of each layer are sequentially executed in a pipeline manner, and the input of the upper layer operator depends on the output of the adjacent lower layer operators with a direct flow relationship.

The query statement may be a structured query language (Structured Query Language, SQL) statement. It should be noted that some query statements with high complexity and long query execution time are collectively referred to as large queries in all embodiments of the present invention, such as large selection queries, data redistribution, and large update queries. In fact, the query statement corresponds to the query task, the query task is usually a user-oriented expression, and the query statement is the machine language corresponding to the query task.

The query plan tree can also be understood by referring to the representation in Figure 4. The 1-layer operator is the lowest-level operator, the input of the 2-layer operator depends on the output of the 1-layer operator, and the input of the 3-layer operator depends on the 2-layer operator. The output of the 4-layer operator depends on the output of the 3-layer operator. In the example shown in Figure 2, the 4-layer operator is the top-layer operator. Among them, the No. 1 and No. 2 operators on the 1st floor have a direct flow relationship with the No. 5 operator on the 2nd floor, and the No. 5 and No. 6 operators on the 2nd floor have a direct flow relationship with the No. 8 operator on the 3rd floor. , the No. 8 operator and No. 9 operator on the 3rd floor have a direct flow relationship with the No. 10 operator on the 4th floor. The flow direction relationship between other operators can be understood with reference to FIG. 4 and the foregoing exemplary description, and details are not repeated here.

FIG. 4 shows only one representation of the query plan tree. In fact, there are many representations of the query plan tree, and FIG. 4 should not be construed as a limitation on the representation of the query plan tree.

The query executor 9 will sequentially complete the function of each operator according to the query plan tree generated by the query plan generator 11, finally complete the query statement, obtain the query result, and feed the query result back to the user.

The above embodiment describes the normal query statement execution process. In fact, for the query business in the database management system, especially the large query business, there will be many operators in the entire query process. The input of the lower operator will produce the output of the upper operator. Therefore, when a query is interrupted at an operator, it is very likely that the operator has completed part of the business. Although the operator fails, the lower operator is still continuously input. As a result, the data input by the lower-level operator after the failure is lost and cannot be traced back, which makes it difficult to resume the job according to the state at the time of interruption. Job continuation refers to continuing to complete subsequent query statements from the query position that was completed when the query was interrupted. For a query statement, after the failure is recovered, the job cannot be resumed, and the query statement can only be completed by rerunning the job. Job reruns will inevitably increase the time of query jobs. Therefore, the key to solving such problems is whether the completed work can be used to continue the execution of this large query.

When the database management system executes the query business, according to the different types of systems, it can include non-pipeline query methods and pipeline query methods. Both Oracle and SQL Server systems belong to pipeline query methods.

Databases such as Oracle and SQL Server execute the query statement according to the pipeline, that is, the output of the upper layer operator depends on the input of the lower layer operator. Due to the execution mode of the pipeline, it is difficult to store the state of each operator at each moment. Therefore, this difference in execution mode makes it difficult for pipelined systems such as Oracle and SQL Server to solve the problem of continuous execution of queries.

In this embodiment of the present invention, the involved moments of failure mainly include two types.

The first is that the query executor 9 fails during execution.

The second is that a failure may occur when the query plan generator 11 generates the query plan tree, and this situation includes that the query plan tree has already been generated.

A method for processing a query fault that occurs when the query executor 9 executes each operator function in accordance with the embodiment of the present invention will be described with reference to FIG. 5 for the moment when the first type of fault occurs.

FIG. 5 is a schematic diagram of an embodiment of query fault processing in an embodiment of the present invention. The data block management system 5 shown in FIG. 5 is a schematic diagram, only some key modules are drawn, and the functions of other modules not shown can be understood by referring to FIG. 1 .

As shown in FIG. 5 , an embodiment of the processing method for querying a fault provided by an embodiment of the present invention includes:

The database management system may include a query interface 7 , a query plan generator 11 , a query executor 9 , a decision module 8 and a reconstruction module 10 .

After the query interface 7 receives the query statement, it transmits the query statement to the query plan generator 11, and the query plan generator 11 generates a query plan tree according to the query statement. That is, the input of the upper-layer operator depends on the output of the adjacent lower-layer operators with a direct flow relationship, wherein each layer includes at least one operator, and each operator contains logical operators and the logic between the operators relation. The query plan tree can be understood with reference to the representation in FIG. 4 .

The query executor 9 will obtain data from the database according to the query plan tree generated by the query plan generator 11 to complete the functions of each operator in turn. During the process of executing the functions of each operator, the query executor 9 will periodically The intermediate state information of the operator is backed up to the database, so that when the database management system fails, the intermediate state information will not be lost.

When the function of an operator is being executed, the intermediate state information of the operator is backed up at the backup time point, and the intermediate state information includes the completed operations and uncompleted operations in the operator at the time of storage. Backups can be periodic backups.

When a query fault occurs during the execution of the operator function, the operator becomes a faulty operator, that is, when the query statement is executed to the faulty operator in the multi-layer operator, a query fault occurs, then the operator becomes a faulty operator. Retrieve the intermediate state information of the faulty operator, the intermediate state information is backed up at the backup time point before the execution failure occurs, and the intermediate state information includes that the faulty operator has been completed at the backup time point operations and unfinished operations, the fault operator is an operator that is executing the query statement when the execution fault occurs.

For example, when the operator No. 5 shown in Figure 4 is executed, the intermediate state information of the operator No. 5 can be backed up. When a query failure occurs when the operator No. 5 has not been executed, the operator No. 5 can be retrieved when the fault occurs. The intermediate state information of the backup at the backup time point before the occurrence, the intermediate state information includes the completed operation and the uncompleted operation in the operator No. 5 at the backup time point.

In this embodiment of the present invention, the query executor 9 periodically backs up the intermediate state information of the faulty operator, and then the reconstruction module 10 updates the faulty operator according to the query plan tree and the intermediate state information of the faulty operator sub-operators and logical relationships between the operators to obtain a reconstructed query plan tree.

After the fault is recovered, continue to run the query statement according to the reconstructed query plan tree to obtain the query result of the query statement.

This query fault processing method can reconstruct the query plan tree according to the intermediate state information of the operator where the fault occurs when a fault occurs. After the fault is recovered, the continuation of the query statement can be realized according to the reconstructed query plan tree. Running, that is, continuing to execute the current query statement from the point where the failure occurred, thus saving query time.

Further, through testing, it is found that it is not necessarily profitable to save the intermediate state information of the operator every time. Therefore, the embodiment of the present invention further proposes a cost decision scheme, that is, for each operator being executed, based on the backup cost of the intermediate state of the operator, the intermediate state information of the operator is selectively backed up.

It can be understood that it is executed by the decision-making module 8 in FIG. 5 , that is, when the backup time point is reached in the process of executing the operator function of the query executor 9, it is determined whether the cost saved by the continued running of the faulty operator is not. greater than the sum of the costs required to back up the completed operations of the faulty operator and restore the uncompleted operations of the faulty operator; when it is determined that the cost saved by continuing to run the faulty operator is greater than the cost of backing up the faulty operator When the sum of the completed operation and the cost required to recover the uncompleted operation of the faulty operator is obtained, the intermediate state information of the faulty operator is backed up. In addition, it can also be determined whether the cost of continuing the operation of the faulty operator is less than the sum of the costs required for backing up the completed operation of the faulty operator and restoring the uncompleted operation of the faulty operator; When the cost of continuing the operation of the faulty operator is less than the sum of the cost of backing up the completed operation of the faulty operator and the cost of restoring the uncompleted operation of the faulty operator, the intermediate state information of the faulty operator is backed up. In this way, after the decision is made by the decision-making module 8, the intermediate state information is backed up, the query plan tree is reconstructed, and the reconstructed query plan tree is obtained. It can not only realize job continuation, save query time, but also save hardware resources.

The cost involved in the embodiment of the present invention can be understood as resource consumption, for example, the processor cost refers to the occupancy of the processor, and the page read cost refers to the amount of resources consumed for service reading.

The query failures described in the embodiments of the present invention may include execution node failures, machine failures, abnormal network interruptions, and the like.

When the decision module 8 determines that the cost saved by continued running is less than the sum of the required costs, the query statement is recorded, and the query statement is used to regenerate the query plan after the query failure is recovered. Tree.

It can also be that when the decision module 8 determines that the cost of continuing running is greater than the sum of the required costs, the query statement is recorded, and the query statement is used to regenerate the query plan after the query failure is recovered. Tree.

The key technology to complete the above core idea is to perform cost-based intermediate state information backup under the pipeline execution framework. To refine the cost estimation, we first employ operator-level isolated cost computation for the operators. For example, when operator No. 5 is a Hash Join operator, the Hash Join operator contains two parts of operations: the first part is to perform a build operation on the obtained right table, and the second part is to perform a build operation on the obtained right table. The left table performs the probe operation. In this way, you need to get the cost corresponding to each operator. Secondly, you can also refer to the basic cost provided by the query plan generator 11 when generating the query plan tree, such as the central processing unit (CPU) cost and the page read cost, etc., to calculate the cost required to store the current state. The cost required is mainly the cost of writing the state. Furthermore, according to the current execution state, estimate the cost saved by continuing running the current faulty operator. With these basic costs, you can decide whether to store: when the cost saved by continuing running is greater than the cost of storing and restoring execution, back up all the states of the operators involved in the current query plan tree; If the cost saved is less than the cost of storage and recovery, no storage processing will be performed. At this time, after the cluster is recovered, the query result can be obtained directly according to the query statement. In actual implementation, cost-based decision-making can be invoked in two ways: periodic evaluation or self-judgment through operators.

Optionally, updating the operator of the fault operator and the logical relationship between the operators according to the query plan tree and the intermediate state information of the fault operator, so as to obtain a reconstructed query plan. tree, which can include:

Recursively process the unfinished operations and the completed operations to obtain reconstruction information of the faulty operator, where the reconstruction information includes reconstruction operators and logical relationships between the reconstruction operators ;

According to the reconstruction information, the original information corresponding to the reconstruction information in the fault operator of the query plan tree is updated to obtain the reconstructed query plan tree, where the original information includes the original operator and the logical relationship between the primitive operators.

Wherein, the recursive processing of the unfinished operation and the completed operation to obtain the reconstruction information of the faulty operator, including:

A completed operator is set for the completed operation, and a start operator for marking the starting position of the incomplete operation is set in the incomplete operation, so as to obtain the reconstruction operator and the reconstruction operation logical relationship between characters.

After the intermediate state information of the operator is backed up in the embodiment of the present invention, the key point is that the query plan tree needs to be reconstructed according to the query plan tree and the intermediate state information of the operator to obtain a reconstructed query plan tree. The specific reconstruction process can be:

Unfinished operations and completed operations in the fault operator are determined according to the intermediate state information of the fault operator, the unfinished operations in the fault operator can be defined as the left subtree, The completed operation is defined as the right subtree.

Mark the completed operation result in the backup fault operator as the saved storage state, that is, set the completed operator and use it as the right subtree of the current operator for later scanning. At the same time, since there are still parts that need subsequent processing, it is necessary to add "UNION ALL" to the upper layer of the current operator, take the unfinished operation as the left subtree, and set the unfinished operation to mark the unfinished operation. The start operator that completes the start position of the operation. Then recursively process the left subtree and right subtree of the current operator.

The right subtree is a completed operation, and the left subtree is an uncompleted operation. This is just an example. In fact, it can also be that the right subtree is an uncompleted operation, and the left subtree is a completed operation.

After obtaining the reconstructed query plan tree, use the reconstructed query plan tree to continue the operation after the fault is recovered.

In order to illustrate the technical points involved in the embodiments of the present invention, an actual query statement will be constructed below to describe the query execution process of the embodiments of the present invention. The selected sql statement in the example of the embodiment of the present invention is "INSERT INTO C(C1, C2) SELECT A.col, B.col FROM A INNER JOIN B ONA.col=B.col GROUP BY 1, 2LIMIT 100".

A key point of the embodiments of the present invention is to reconstruct the query plan tree. Therefore, it is necessary to first obtain the above query plan tree generated according to the query statement. Because no matter how many operators there are in the query plan tree, the operators are executed one by one during the execution process. Therefore, the structure of an operator in the query plan tree is used as an example to illustrate the structure of an operator and the The cost of performing the corresponding operation in the operator:

Among them, the cost on the right represents the cost required to perform the corresponding operation. Because the HashJoin in the execution operation includes the build process and the probe process. Therefore, the operators of the two parts need to separately count the execution cost. When the fault scenario is: Hash Join has started to output, according to the intermediate state information backed up by the operator at the backup time point, it can be determined that the build operation has been completed, and part of the probe operation has not been completed. The combined identifier "UNION ALL" of completed and unfinished operations, and then the completed build operation is defined as the right subtree of this operator. The completed operator Scan(saved_B) can be set. If there is still a part of the probe operation unfinished, the start operator used to mark the starting position of the unfinished operation is set in the unfinished operation, for example: Scan in the probe operation (part of A), define the unfinished part (probe) Scan(partof A) in the probe operation as the left subtree of the operator. For the left subtree, the current Scan(A) operation is not over, so it is only necessary to record the scanned position without changing the state of the subtree. For the right subtree, the build operation has actually ended. In order to ensure the integrity, it is added to the original position of the Scan(B). The original Scan(B) has been completed due to the actual build operation, and the completed backup result is marked as saved_B. , as its right subtree. As operations and operational logical relationships are updated, the costs required by each operation are also modified. Therefore, the reconstruction information of the operator can be obtained as follows.

Use the reconstructed information to update the original information at the faulty operator to obtain the updated operator and the relationship between the operations. Refer to the following content for understanding.

After the fault operator is updated, the reconstructed query plan tree is obtained.

The reconstructed query plan tree generated according to the above is essentially the same as the original query plan tree in terms of execution. This is also the key to ensuring that queries can be executed after failure recovery.

The following describes the evaluation of the backup policy based on the cost in the embodiment of the present invention with reference to the above-mentioned cost example. Similarly, the query plan generated according to the above query statement is used as the initial cost. Consider the following scenarios:

When Hash Join is executing the build, assuming that Scan(B) has been executed for 30, the storage and recovery cost includes 40 required to restore Hash Join and 1 required to scan B, a total of 41, and the saved cost and the part that has been executed 30. At this time, the cost is less than the storage and recovery costs, and the storage can be abandoned and recalculated directly.

When the Hash Join has been built, the storage and recovery costs include the storage Scan(B) and HashJoin recovery costs, totaling 90. The cost savings includes 70 for Scan(B) and 60 for Build operation, totaling 130. The cost of saving is greater than the cost of storage and recovery, and the hash table of Hash Join is stored.

When Hash Join is already in the output state and Scan(A) has been performed 100 times, the storage and restoration costs include 30 required to store the partial output result of Hash Join and 1 required to restore Scan(A), totaling 31. The savings include 100 for Scan(A) and 70 for Scan(B) totaling 170. The saving cost is greater than the storage and recovery cost. The hash table of Hash Join and some output results of Hash Join are stored.

And so on, when the evaluation ends, all the results stored last time will be cleared.

Thanks to the large query, the intermediate state of the storage can be used to continue the query after the query failure is recovered, which ensures that the business can complete the continuation of the job at a lower cost after an unexpected failure occurs, so that the entire business process is not affected by the large-scale operation. Query job impact.

After the description of the query fault processing process involved in the moment when the second type of fault occurs, the following describes the query fault processing process involved in the moment when the second type of fault occurs in the embodiment of the present invention with reference to FIG. 6 .

FIG. 6 is a schematic diagram of another embodiment of query fault processing in an embodiment of the present invention. The data block management system 5 shown in FIG. 6 is a schematic diagram, only some key modules are drawn, and the functions of other modules not shown can be understood by referring to FIG. 1 .

As shown in FIG. 6 , the process of processing a query fault provided by an embodiment of the present invention includes:

The query management device may include a query interface 7, a query plan generator 11, and a query executor 9. After the query interface 7 receives the query statement, it transmits the query statement to the query plan generator 11, and the query plan generator 11 will, according to the obtained query statement , generate a query plan tree, the query plan tree includes multi-layer operators with pipeline relationships, that is, the input of the upper operator depends on the output of the adjacent lower operator with a direct flow relationship, wherein each operator contains A logical relationship formed by a logical operation.

A query failure occurs when the query plan generator 11 generates the query plan tree. Since the time required for the query plan generator 11 to generate the query plan tree is relatively small compared to the time for the query executor 9 to execute the operator function, therefore When a failure occurs, the query statement still stays in the optimizer processing stage, and the currently executed query statement can be directly recorded without saving any intermediate state. After the environment failure is recovered, the query statement can be re-parsed to generate an execution plan and handed over to the query executor 9 to complete the final query statement.

Referring to FIG. 7 , an embodiment of the processing method for querying a fault provided by an embodiment of the present invention includes:

101. Receive a query statement, and generate a query plan tree corresponding to the query statement, where the query plan tree includes multiple layers of operators in a pipeline relationship, wherein each layer includes at least one operator, and each operator includes an operator and the logical relationship between the operators.

102. Execute the query statement according to the query plan tree.

103. When a failure occurs during the execution of the query statement, retrieve intermediate state information of the faulty operator, where the intermediate state information is backed up at the backup time point before the execution failure occurs, and the intermediate state information is The state information includes completed operations and uncompleted operations of the fault operator at the backup time point, and the fault operator is an operator that is executing the query statement when the execution fault occurs.

104. Update the operator of the fault operator and the logical relationship between the operators according to the query plan tree and the intermediate state information of the fault operator, so as to obtain a reconstructed query plan tree.

104. After the fault is recovered, continue to run the query statement according to the reconstructed query plan tree to obtain a query result of the query statement.

Compared with the prior art, the method for processing a query fault provided by the embodiment of the present invention can reconstruct the query plan tree according to the intermediate state information of the operator where the fault occurs when a fault occurs. According to the reconstructed query plan tree, the continuation of the query statement is realized, that is, the current query statement continues to be executed from the point where the fault occurs, thereby reducing the impact of query interruption on the entire query business process.

The processing method of the query fault provided by the embodiment of the present invention can be understood by referring to the relevant descriptions in FIG. 1 to FIG. 6 , and details are not repeated here.

The modules included in the fault query processing apparatus 20 provided by the embodiment of the present invention and the relationship between the modules can be understood by referring to the database management systems in FIG. 5 and FIG. 6 , which will not be repeated here.

The database management system shown in FIG. 1 to FIG. 6 provided by the embodiment of the present invention or the processing device for querying faults may be implemented by a server or a physical host. The following takes the server as an example to introduce the process of implementing the processing method for querying faults by relying on the server. .

FIG. 8 is a schematic structural diagram of a server 60 provided by an embodiment of the present invention. The server 60 includes a processor 610 , a memory 650 and a transceiver 630 . The memory 650 may include read-only memory and random access memory, and provides operation instructions and data to the processor 610 . A portion of memory 650 may also include non-volatile random access memory (NVRAM).

In some embodiments, memory 650 stores the following elements, executable modules or data structures, or a subset thereof, or an extended set of them:

In this embodiment of the present invention, when the server executes the function of query fault processing described in the above-mentioned parts of FIG. 1 to FIG. 7 performed by the database management system shown in FIG. 1 to FIG. Operation instructions stored in the memory 650 (the operation instructions may be stored in the operating system),

for receiving query statements through the transceiver 630;

Generate a query plan tree corresponding to the query statement, where the query plan tree includes multiple layers of operators in a pipeline relationship, wherein each layer includes at least one operator, and each operator includes an operator and an operator between the operators the logical relationship;

Execute the query statement according to the query plan tree;

When a fault occurs during the execution of the query statement, the intermediate state information of the faulty operator is retrieved, the intermediate state information is backed up at the backup time point before the execution fault occurs, and the intermediate state information Including the completed operations and uncompleted operations of the fault operator at the backup time point, where the fault operator is the operator that is executing the query statement when the execution fault occurs;

According to the query plan tree and the intermediate state information of the fault operator, update the operator of the fault operator and the logical relationship between the operators to obtain a reconstructed query plan tree;

After the fault is recovered, continue to run the query statement according to the reconstructed query plan tree to obtain the query result of the query statement.

Compared with the prior art, the server provided by the embodiment of the present invention can reconstruct the query plan tree according to the intermediate state information of the operator where the fault occurs when a fault occurs. The query plan tree implements the continuation of the query statement, that is, the current query statement continues to be executed from the point of failure, thereby reducing the impact of query interruption on the entire query business process.

The processor 610 controls the operation of the server 60, and the processor 610 may also be referred to as a CPU (Central Processing Unit, central processing unit). Memory 650 may include read-only memory and random access memory, and provides instructions and data to processor 610 . A portion of memory 650 may also include non-volatile random access memory (NVRAM). In a specific application, various components of the server 60 are coupled together through a bus system 620, where the bus system 620 may include a power bus, a control bus, a status signal bus, and the like in addition to a data bus. However, for clarity of illustration, the various buses are labeled as bus system 620 in the figure.

The methods disclosed in the foregoing embodiments of the present invention may be applied to the processor 610 or implemented by the processor 610 . The processor 610 may be an integrated circuit chip with signal processing capability. In the implementation process, each step of the above-mentioned method can be completed by an integrated logic circuit of hardware in the processor 610 or an instruction in the form of software. The above-mentioned processor 610 may be a general-purpose processor, a digital signal processor (DSP), an application specific integrated circuit (ASIC), an off-the-shelf programmable gate array (FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components. Various methods, steps, and logical block diagrams disclosed in the embodiments of the present invention can be implemented or executed. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like. The steps of the method disclosed in conjunction with the embodiments of the present invention may be directly embodied as executed by a hardware decoding processor, or executed by a combination of hardware and software modules in the decoding processor. The software modules may be located in random access memory, flash memory, read-only memory, programmable read-only memory or electrically erasable programmable memory, registers and other storage media mature in the art. The storage medium is located in the memory 650, and the processor 610 reads the information in the memory 650, and completes the steps of the above method in combination with its hardware.

Optionally, the processor 610 is further configured to:

Based on the backup cost of the intermediate state of the faulty operator, the intermediate state information of the faulty operator is selectively backed up.

Optionally, the processor 610 is specifically configured to: periodically perform the step of the selective backup.

Optionally, the processor 610 is specifically configured to:

When it is determined that the cost saved by continuing the operation of the faulty operator is greater than the sum of the cost of backing up the completed operation of the faulty operator and the cost of restoring the uncompleted operation of the faulty operator, the faulty operator is backed up. Child's intermediate state information.

Optionally, the processor 610 is specifically configured to:

When it is determined that the cost of continuing the operation of the faulty operator is less than the sum of the cost of backing up the completed operation of the faulty operator and the cost of restoring the uncompleted operation of the faulty operator, then backup the operation of the faulty operator. Intermediate state information.

Optionally, the processor 610 is specifically configured to:

Recursively process the unfinished operations and the completed operations to obtain reconstruction information of the faulty operator, where the reconstruction information includes reconstruction operators and logical relationships between the reconstruction operators ;

According to the reconstruction information, the original information corresponding to the reconstruction information in the fault operator of the query plan tree is updated to obtain the reconstructed query plan tree, where the original information includes the original operator and the logical relationship between the primitive operators.

Optionally, the processor 610 is specifically configured to: set a completed operator for the completed operation, and set a start operator for marking the starting position of the incomplete operation in the incomplete operation, so as to obtain the completed operation. Describe the refactoring operators and the logical relationship between the refactoring operators.

Optionally, the processor 610 is further configured to:

When it is determined that the cost saved by continuing running is less than the sum of the required costs, the query statement is recorded, and the query statement is used to regenerate the query plan tree after the query failure is recovered.

Optionally, the processor 610 is further configured to:

When it is determined that the cost of continuing running is greater than the sum of the required costs, the query statement is recorded, and the query statement is used to regenerate the query plan tree after the query failure is recovered.

Optionally, the processor 610 is further configured to:

When a failure occurs when generating the query plan tree, the query statement is recorded, and the query statement is used to regenerate the query plan tree after the query failure is recovered.

The server described in FIG. 8 can be understood by referring to the query management device in FIG. 1 to FIG. 6 , and details are not repeated here.

Those of ordinary skill in the art can understand that all or part of the steps in the various methods of the above embodiments can be completed by instructing relevant hardware through a program, and the program can be stored in a computer-readable storage medium, and the storage medium can include: ROM, RAM, magnetic disk or optical disk, etc.

The processing method and device for querying faults provided by the embodiments of the present invention have been described in detail above. The principles and implementations of the present invention are described by using specific examples in this paper. The descriptions of the above embodiments are only used to help understand the present invention. At the same time, for those skilled in the art, according to the idea of the present invention, there will be changes in the specific implementation and application scope. In summary, the content of this specification should not be construed as Limitations of the present invention.

Claims (14)

1. A processing method for inquiring faults is characterized by comprising the following steps:

receiving a query statement and generating a query plan tree corresponding to the query statement, wherein the query plan tree comprises a plurality of layers of operators in a pipeline relationship, each layer at least comprises one operator, and each operator comprises operators and logic relationships among the operators;

executing the query statement according to the query plan tree;

when a fault occurs in the process of executing the query statement, calling intermediate state information of a fault operator, wherein the intermediate state information is backed up at a backup time point before the execution fault occurs, the intermediate state information comprises the completed operation and the uncompleted operation of the fault operator at the backup time point, and the fault operator is the operator which is executing the query statement when the execution fault occurs;

updating an operator of the fault operator and a logic relation between the operators according to the query plan tree and the intermediate state information of the fault operator to obtain a reconstructed query plan tree;

and after the fault is recovered, continuing running the query statement according to the reconstructed query plan tree to obtain a query result of the query statement.

2. The processing method according to claim 1, characterized in that the method further comprises:

and selectively backing up the intermediate state information of the fault operator based on the backup cost of the intermediate state of the fault operator.

3. The processing method of claim 2, further comprising: the step of selectively backing up is performed periodically.

4. The processing method according to claim 2 or 3, wherein the selectively backing up the intermediate state information of the fault operator based on the backup cost of the intermediate state of the fault operator comprises:

and when the cost saved by the fault operator running is determined to be greater than the sum of the cost required by the operation finished by the fault operator and the cost required by the operation unfinished by the fault operator, backing up the intermediate state information of the fault operator.

5. The processing method according to claim 2 or 3, wherein the selectively backing up the intermediate state information of the fault operator based on the backup cost of the intermediate state of the fault operator comprises:

and when the cost of the fault operator for running is determined to be less than the sum of the cost required for backing up the operation finished by the fault operator and the cost required for recovering the operation unfinished by the fault operator, backing up the intermediate state information of the fault operator.

6. The process of any one of claims 1 to 3, wherein said updating operators of said fault operator and logical relationships between said operators based on intermediate state information of said query plan tree and said fault operator to obtain a reconstructed query plan tree comprises:

recursively processing the incomplete operations and the completed operations to obtain reconstruction information of the fault operator, wherein the reconstruction information comprises a reconstruction operator and a logical relationship between the reconstruction operators;

and updating original information corresponding to the reconstruction information in the fault operator of the query plan tree according to the reconstruction information to obtain the reconstructed query plan tree, wherein the original information comprises an original operator and a logical relationship between the original operators.

7. The processing method of claim 6, wherein said recursively processing said incomplete operations and said completed operations to obtain reconfiguration information for said fault operator comprises:

setting a finished operator for the finished operation, and setting a starting operator for marking a starting position of an unfinished operation in the unfinished operation so as to obtain the reconstructed operator and a logical relationship between the reconstructed operator.

8. A processing apparatus for querying for faults, comprising: a query interface, a query plan generator, a query executor and a reconstruction module,

the query interface is used for receiving a query statement;

the query plan generator is used for generating a query plan tree corresponding to the query statement received by the query interface, wherein the query plan tree comprises a plurality of layers of operators in a pipeline relation, each layer at least comprises one operator, and each operator comprises operators and logic relations among the operators;

the query executor is used for executing the query statement according to the query plan tree generated by the query plan generator; when a fault occurs in the process of executing the query statement, calling intermediate state information of a fault operator, wherein the intermediate state information is backed up at a backup time point before the execution fault occurs, the intermediate state information comprises the completed operation and the uncompleted operation of the fault operator at the backup time point, and the fault operator is the operator which is executing the query statement when the execution fault occurs;

the reconstruction module is used for updating an operator of the fault operator and a logical relation between the operators according to the query plan tree generated by the query plan generator and the intermediate state information of the fault operator to obtain a reconstructed query plan tree;

and the query executor is further used for running through the query statement according to the reconstructed query plan tree after the fault is recovered so as to obtain a query result of the query statement.

9. The processing apparatus according to claim 8, wherein the processing apparatus further comprises a decision module,

and the decision module is used for selectively backing up the intermediate state information of the fault operator based on the backup cost of the intermediate state of the fault operator.

10. The processing apparatus according to claim 9,

the decision module is specifically configured to periodically perform the step of selectively backing up.

11. The processing apparatus according to claim 9 or 10,

the decision module is specifically configured to:

and when the cost saved by the fault operator running is determined to be greater than the sum of the cost required by the operation finished by the fault operator and the cost required by the operation unfinished by the fault operator, backing up the intermediate state information of the fault operator.

12. The processing apparatus according to claim 9 or 10,

the decision module is specifically configured to:

and when the cost of the fault operator for running is determined to be less than the sum of the cost required for backing up the operation finished by the fault operator and the cost required for recovering the operation unfinished by the fault operator, backing up the intermediate state information of the fault operator.

13. The processing apparatus according to any one of claims 8 to 10,

the reconstruction module is specifically configured to:

recursively processing the incomplete operations and the completed operations to obtain reconstruction information of the fault operator, wherein the reconstruction information comprises a reconstruction operator and a logical relationship between the reconstruction operators;

and updating original information corresponding to the reconstruction information in the fault operator of the query plan tree according to the reconstruction information to obtain the reconstructed query plan tree, wherein the original information comprises an original operator and a logical relationship between the original operators.

14. The processing apparatus according to claim 13,

the reconstruction module is specifically configured to:

setting a finished operator for the finished operation, and setting a starting operator for marking a starting position of an unfinished operation in the unfinished operation so as to obtain the reconstructed operator and a logical relationship between the reconstructed operator.

Images