CN117807161A - Compensation transaction realization method for distributed database - Google Patents

Abstract

The invention discloses a compensation transaction realization method for a distributed database, which belongs to the technical field of the distributed database and specifically comprises the following steps: the client initiates a transaction request, judges whether the transaction SQL exceeds a limit value through executing the catalog, the coordination node distributes a time stamp for the transaction initiated by the client in the step S1, simultaneously sends related operation of the transaction to the data node, after receiving the transaction request, the data node judges that the transaction is submitted or rolled back, returns an execution result to the coordination node for confirmation and verification, if the verification fails, the coordination node notifies the data node and performs compensation operation, the operation is completed, the coordination node submits the transaction, and performs timing cleaning, and returns the execution result to the client, thereby ensuring the consistency of the data in a distributed environment and reducing the complexity of the transaction processing process.

Description

A Compensation Transaction Implementation Method for Distributed Database

Technical field

The invention belongs to the technical field of distributed databases, and in particular is a compensation transaction implementation method for distributed databases.

Background technique

Distributed systems have become a central part of modern software architecture to provide high availability, scalability and failure recovery. In these systems, business operations need to be processed across multiple services, which has led to the need for distributed transactions. Distributed transactions refer to transaction participants and servers that support transactions. Currently, distributed transactions mainly have the following modes: AT mode, Saga mode, TCC mode, XA mode and compensation transaction mode. AT mode is a non-intrusive distributed transaction solution with zero learning cost, but SQL is managed and executed uniformly by the framework, and there will be dirty write problems; Saga mode is a long transaction solution, and the DB is operated in the first stage. There will be problems with dirty reads; TCC mode is suitable for scenarios with high performance requirements such as core systems. If a transaction is executed for too long, rows will be locked, avoiding dirty reads; XA mode is a strong consistency solution, but its performance is low and it is used Less; the core idea of compensating transactions is to undo completed business operations by performing a series of reverse operations. These reverse operations are called "compensating operations". They can ensure that when an error or abnormal situation occurs, the system Being able to restore to a consistent state has the advantages of decoupling, fault tolerance, and flexibility.

For example, the Chinese patent application with publication number CN112182103A discloses a distributed database and a method for achieving strong consistency in cross-node transactions. It is characterized in that the distributed database adopts a storage and computing separation architecture, including: coordination nodes, There are three types of nodes: data nodes and catalog nodes. Each type of node can be expanded horizontally. The coordination node is responsible for distributing requests to the data nodes that need to participate. The data nodes are responsible for data access and storage. The catalog nodes store system metadata and partition related Information, a transaction is initiated through the coordination node and sent to one or more data node groups for operation. The distributed database introduces transaction negotiation and transaction compensation mechanisms between data nodes as participants, and a local failure occurs in the system. When participants cannot normally receive transaction control messages from the coordination node as the coordinator, the participants confirm each other's status to determine whether the transaction should be submitted or rolled back to avoid data inconsistencies.

For example, the Chinese patent with the authorization announcement number CN110019469B discloses a distributed database data processing method, device, storage medium and electronic device. The present invention includes: the database import and export management node receives an export request for exporting data in the distributed database. Afterwards, obtain the current active transaction list and export table distribution information; the database import and export management node notifies the corresponding database to perform the data export operation according to the export table distribution information; the database import and export management node determines that the corresponding database has completed the data export operation, Send the active transaction list to the database agent node of the corresponding database; after receiving the data consistency reverse compensation statement returned by the database agent node, the database import and export management node imports the data exported by the corresponding database into the scheduled database and instructs the reservation The database executes data consistency reverse compensation statements.

The above existing technologies all have the following problems: 1) The implementation is complex, has a great impact on database performance, and is not suitable for high-concurrency and high-performance scenarios; 2) Compensation tasks are lost after node restarts.

Contents of the invention

In view of the shortcomings of the existing technology, the present invention proposes a compensation transaction implementation method for distributed databases, which specifically includes: the client initiates a transaction request, executes the directory to determine whether the transaction SQL exceeds the limit value, and after the data node receives the transaction request , determine whether the transaction is committed or rolled back, and return the execution result to the coordination node for confirmation and verification. When the operation is completed, the coordination node submits the transaction and performs scheduled cleaning, and returns the result to the client, ensuring data in a distributed environment. consistency and reduce the complexity of transaction processing.

In order to achieve the above objects, the present invention provides the following technical solutions:

A compensation transaction implementation method for distributed databases, including:

Step S1: The client initiates a transaction request and determines whether the transaction SQL exceeds the limit value through the execution directory. If it exceeds the limit, the back-end database returns an error, and the transaction information is stored in the transaction SQL mapping module;

Step S2: The coordination node assigns a timestamp to the transaction initiated by the client in step S1, and at the same time sends the operation of the transaction to the data node;

Step S3: After receiving the transaction request, the data node determines whether the transaction is committed or rolled back, and returns the execution result to the coordination node for confirmation and verification. If the verification fails, the coordination node notifies the data node and performs compensation operations;

Step S4: The operation is completed, the coordination node submits the transaction, cleans it regularly, and returns the execution result to the client.

Specifically, the specific steps of step S1 include:

Step S101: Determine the directory path for transaction execution and read the included SQL script file;

Step S102: Analyze the content of the SQL script file to determine whether there are SQL statements or operations that may cause the transaction to exceed the limit value and output the analysis results. Based on the analysis results, determine whether the SQL statement of the transaction exceeds the predetermined limit value;

Step S103: Start the transaction and monitor its execution. If the limit value is exceeded during transaction execution, the back-end database responds and returns an error immediately;

Step S104: Receive the error and process it. If the transaction is executed successfully, continue to process other transactions or close the connection.

Specifically, the specific steps of step S2 include:

Step S201: The client sends a transaction request to the coordination node. After receiving the transaction request, the coordination node parses and processes it;

Step S202: The coordination node generates a globally unique timestamp according to the compensation rules, and assigns the generated timestamp to the transaction initiated by the client in step S1;

Step S203: The coordination node forwards the generated timestamp together with the transaction request to the relevant data node.

Specifically, the timestamp in step S202 specifically includes: transaction start time, transaction commit time and transaction rollback time.

Specifically, the specific steps of step S3 include:

Step S301: The data node receives the transaction request forwarded by the coordinating node, sorts and executes it according to the timestamp, and determines whether to perform read, write or other operations;

Step S302: According to the judgment result, the data node reads or modifies local data and judges the status of the transaction;

Step S303: If the data node determines that the transaction can be submitted, it will persist the operation results in the database and return a confirmation message to the coordination node. If the transaction needs to be rolled back, the relevant operations performed previously will be revoked and the database will be restored to the state before the transaction started. status, and then returns a confirmation message to the coordinating node;

Step S304: After receiving the confirmation message from the data node, the coordination node uses the three-phase submission strategy to verify the operation result. If the verification passes, it means that the operation of the data node is successfully completed. If the verification fails, a rollback is required.

Specifically, the three-phase submission strategy in step S304 is as follows: a pre-submission phase is added between the preparation phase and the submission phase, so that the coordination node sends a pre-submission request to all participating nodes, and the submission is judged based on the responses of the participating nodes. or rollback the operation.

Specifically, the specific steps of the compensation operation in step S304 include:

Step S3041: Determine the transactions requiring compensation and define compensation rules;

Step S3042: According to the compensation rules, map operations in the distributed transaction to compensation operations through transaction compensation mapping;

Step S3043: Record the compensation execution status of each operation through the compensation execution flag mapping;

Step S3044: If the compensation operation is successfully executed, the database is submitted, and the submission status of each operation is recorded through the submission success mapping.

Specifically, the compensation rules in step S3041 include: reverse operation, data repair, transaction rollback, state recovery, sequential execution, repeatability and consistency guarantee.

Specifically, the specific steps of step S4 include:

Step S401: After receiving responses from all participating nodes, the coordination node confirms that all operations have been completed;

Step S402: The coordination node submits the transaction to the database or distributed transaction manager, and uses the submission success mapping to record the submission status;

Step S403: After confirming that the transaction is successfully submitted, the coordination node regularly cleans up historical data and releases resource operations;

Step S404: Return the transaction processing result to the client.

A compensation transaction implementation system for distributed databases, including: transaction SQL mapping module, transaction submission success mapping module, transaction rollback mapping module, compensation Tmp mapping module, compensation mapping module, compensation execution flag mapping module,

The transaction SQL mapping module is used to determine whether the transaction SQL exceeds the upper limit or submits a limit value;

The transaction submission success mapping module is used to record the transaction mapping of distributed transaction submission success, and clean the data when there are scheduled tasks;

The transaction rollback mapping module is used to record rolled-back distributed transactions and clean the data therein when there are scheduled tasks;

The compensation Tmp mapping module module is used to record temporary node transactions to be compensated;

The compensation mapping module is used to record node transactions to be compensated;

The compensation execution flag mapping module is used to mark that a certain node is compensating for a transaction.

Compared with the prior art, the beneficial effects of the present invention are:

1. The present invention proposes a compensation transaction implementation system for distributed databases, and optimizes and improves the architecture, operation steps and processes. The system has the advantages of simple processes, low investment and operation costs, and low production work costs, while ensuring On the basis of complete functions, unchanged request method, and subtle performance loss, a compensation transaction plan that does not affect data is implemented.

2. The present invention proposes a compensation transaction implementation method for distributed databases. In terms of data, the transaction status and SQL situation of each node are recorded through local files, which can not only ensure the SQL compensation efficiency, but also realize the node restart compensation transaction without interruption. Lost; in terms of function, when entering the compensation transaction, only the directory level is locked to minimize the impact on the business. The scheduled thread will automatically perform the compensation task. When the compensation is successful, the lock will be released. The business is unaware of this process. of.

3. The present invention proposes a compensation transaction implementation method for distributed databases, which uses a combination of memory and local files to record transactions that need to be compensated, which can not only ensure efficiency but also ensure that the compensation task is not lost after restarting. On the basis of complete functions, unchanged request method, and subtle performance loss, a compensation transaction plan that does not affect data is implemented.

Description of drawings

Figure 1 is a flow chart of a compensation transaction implementation method for distributed databases according to the present invention;

Figure 2 is a system analysis flow chart of a compensation transaction implementation method for distributed databases according to the present invention;

Figure 3 is a three-stage submission coordinator state transition flow chart of a compensation transaction implementation method for distributed databases of the present invention;

Figure 4 is a three-stage submission participant state transition flow chart of a compensation transaction implementation method for distributed databases of the present invention;

FIG5 is a diagram showing the architecture of a system for implementing compensation transactions for distributed databases according to the present invention.

Detailed ways

In order to make the technical means, creative features, objectives and effects of the present invention easy to understand, in the description of the present invention, it should be noted that the terms "center", "upper", "lower", "left", "left" The orientations or positional relationships indicated by "right", "vertical", "horizontal", "inner", "outer", etc. are based on the orientations or positional relationships shown in the drawings, and are only for the convenience of describing the present invention and simplifying the description. It is not intended to indicate or imply that the device or element referred to must have a specific orientation, be constructed and operate in a specific orientation, and therefore is not to be construed as a limitation of the invention. Furthermore, the terms "No. 1," "No. 2," and "No. 3" are used for descriptive purposes only and are not to be construed as indicating or implying relative importance. The present invention will be further described below in conjunction with specific embodiments.

Example 1

Referring to Figures 1-4, an embodiment provided by the present invention: a compensation transaction implementation method for distributed databases, including the following steps:

Step S1: The client initiates a transaction request and determines whether the transaction SQL exceeds the limit value through the execution directory. If it exceeds the limit, the back-end database returns an error, and the transaction information is stored in the transaction SQL mapping module;

The four major characteristics of transactions include: atomicity, consistency, isolation and durability.

The predetermined limit values of the SQL statement of the transaction include: (1) Execution time: Set the maximum execution time of the transaction. If this time is exceeded, the transaction will be considered to have failed to complete within the limited time, and an error may be returned or the transaction may be rolled back; ( 2) Resource usage: You can set the maximum limit on the resources used by the transaction during execution; (3) The amount of data; (4) The number of concurrent accesses.

The advantages of setting limit values for transaction SQL: (1) It can ensure that the transaction will not be interfered by other transactions during execution and maintain data consistency; (2) When an error occurs during transaction execution, the transaction can be rolled back to cancel it. Operations that have been performed to avoid data inconsistency; (3) By setting the lock level and concurrency control method of the transaction, you can control the transaction isolation level and lock competition during concurrent access, and improve the performance and response time of the system; (4) Data consistency can be restored by rolling back and committing transactions; (5) The logical flow of the program can be controlled through transaction settings.

Step S2: The coordination node assigns a timestamp to the transaction initiated by the client in step S1, and at the same time sends the operation of the transaction to the data node;

In a distributed database, a coordinating node is a special node used to coordinate the search and aggregation operations of shards. When a client sends a search request, the coordinating node forwards the request to the data node storing the relevant shards and returns the results to the client. The coordinating node does not store data and does not participate in data searches.

Step S3: After receiving the transaction request, the data node determines whether the transaction is committed or rolled back, and returns the execution result to the coordination node for confirmation and verification. If the verification fails, the coordination node notifies the data node and performs compensation operations;

Transaction rollback refers to undoing the update operation of the database that has been completed by the transaction. In the transaction, each correct atom will be executed sequentially until an incorrect atomic operation is encountered.

Step S4: When the operation is completed, the coordination node submits the transaction, cleans it regularly, and returns the execution result to the client.

The steps for coordinating nodes to perform scheduled cleanup are as follows:

(1) The coordination node will first receive the query request and broadcast the request to each data node. The shards of each data node will process the query request, perform data query, and place qualified data in a priority queue. middle;

(2) After each shard performs a data query, it returns the document ID, node information, and shard information to the coordination node, which aggregates all the results and performs global sorting.

(3) The coordination node sends a get request to the shards containing these document IDs, and the corresponding shards return the document data to the coordination node;

(4) Finally, the coordination node returns the data to the client.

The specific steps of step S1 include:

Step S101: Determine the directory path for transaction execution and read the included SQL script file;

Step S102: analyzing the content of the SQL script file to determine whether there is an SQL statement or operation that may cause the transaction to exceed the limit value and outputting the analysis result, and judging whether the SQL statement of the transaction exceeds the predetermined limit value according to the analysis result;

Step S103: Start the transaction and monitor its execution. If the limit value is exceeded during transaction execution, the back-end database responds and returns an error immediately;

Step S104: Receive the error and process it. If the transaction is executed successfully, continue to process other transactions or close the connection.

The specific steps of step S2 include:

Step S201: The client sends a transaction request to the coordination node. After receiving the transaction request, the coordination node parses and processes it;

Specific steps include: (1) The coordination node first needs to parse the transaction request and extract the operations and related parameters that need to be performed; (2) After parsing the transaction request, the coordination node needs to verify the legality of the operation; (3) Once the operation is If verified to be legal, the coordination node needs to assign the operation to the appropriate transaction participating node; (4) After assigning the operation to the participant, the coordination node needs to monitor the execution process of the transaction.

Step S202: The coordination node generates a globally unique timestamp according to the compensation rules, and assigns the generated timestamp to the transaction initiated by the client in step S1;

Step S203: The coordination node forwards the generated timestamp together with the transaction request to the relevant data node.

The specific content of the timestamp in step S202 includes: transaction start time, transaction commit time and transaction rollback time.

In a distributed database, the generation and distribution of timestamps need to ensure global uniqueness and consistency to avoid conflicts and data inconsistencies. Common timestamp generation methods include: using physical clocks, distributed clock servers or through algorithms Generate pseudo clock.

The specific steps of step S3 include:

Step S301: The data node receives the transaction request forwarded by the coordination node, sorts and executes it according to the timestamp, and determines whether to perform reading, writing or other operations;

When performing timestamp sorting, the data to be sorted needs to be passed to the sorting function together with the corresponding timestamp. The sorting function will arrange the data in ascending or descending order according to the timestamp.

Step S302: According to the judgment result, the data node reads or modifies local data and judges the status of the transaction;

Step S303: If the data node determines that the transaction can be committed, it will persist the operation result in the database and return a confirmation message to the coordination node. If the transaction needs to be rolled back, the previously executed related operations will be canceled and the database will be restored to the state before the transaction started, and then a confirmation message will be returned to the coordination node;

Among them, transaction commit and rollback transactions are stored in the corresponding transaction commit success mapping and transaction rollback mapping modules. Successful transaction submission mapping refers to mapping the result of successful transaction submission to an object or system. The specific steps include: determining the mapping object, defining mapping rules, performing mapping operations, verifying mapping results, and recording mapping logs; transaction rollback mapping is A mechanism in the database management system that is used to restore the database state to the state before the transaction started when an error or abnormality occurs during transaction execution. The specific steps include: error detection, preparing for rollback, and generating rollback logs. , perform rollback and commit transactions.

Step S304: After receiving the confirmation message from the data node, the coordination node uses the three-phase submission strategy to verify the operation result. If the verification passes, it means that the operation of the data node is successfully completed. If the verification fails, a rollback is required.

The three-phase submission strategy in step S304 is specifically: a pre-commit phase is added between the preparation phase and the submission phase, so that the coordination node sends a pre-commit request to all participating nodes, and determines the submission or rollback operation based on the responses of the participating nodes.

In distributed databases, common strategies include: two-phase submission and three-phase submission. The present invention selects a three-phase submission strategy, which can reduce the blocking problem caused by waiting for responses from all participating nodes. The three-stage submission content includes:

(1) Preparation phase: The coordinating node sends a readiness request to all participating nodes and waits for responses from the participating nodes;

(2) Pre-commit phase: While waiting for responses from all participating nodes, the coordinating node decides whether to perform a pre-commit operation based on the response of the participating nodes. If all participating nodes return an "agree" response, the coordinating node enters the commit phase; otherwise, the coordinating node enters the rollback phase;

(3) Submission phase: After the pre-submission phase, if all participating nodes return an "agree" response, the coordinating node sends a submission request to all participating nodes; after receiving the submission request, the participating nodes perform relevant operations and Persist the results into the database; the coordinating node waits for all participating nodes to complete the operation and return a confirmation message; when all participating nodes have completed the operation and have been confirmed and verified by the coordinating node, the coordinating node submits the transaction and reports it to the client The end returns a successful result.

The specific steps of the compensation operation in step S304 include:

Step S3041: determine the transaction that needs to be compensated and define the compensation rules;

Transaction compensation rules include: 1) Determine the compensation point: During the transaction execution process, determine the steps and status that require compensation, thereby determining the scope of rollback; 2) Determine the rollback scope; 3) Based on the rollback scope and compensation point, Generate the corresponding rollback command; 4) Perform the corresponding rollback operation according to the generated rollback command; 5) Record the compensation operation information to the compensation log; 6) After executing the compensation operation, check whether the compensation result is as expected ;7) Notify the relevant users or systems of the results of the compensation operation.

Step S3042: According to the compensation rule, the operations in the distributed transaction are mapped to compensation operations through transaction compensation mapping;

Compensation mapping refers to performing compensation operations to restore data to the state before the start of the transaction to ensure data consistency and integrity when transaction execution fails or an abnormality occurs.

Step S3043: Record the compensation execution status of each operation through the compensation execution flag mapping;

The advantage of compensated execution flag mapping is that it can accurately record the results and status of each operation, so that when a transaction fails, the undo or recovery operation can be accurately performed to ensure data consistency. At the same time, by combining the operation results and execution flags, A mapping relationship is established between them, so the present invention uses compensation execution flag mapping to record the compensation execution status.

The implementation of compensation execution flag mapping includes the following steps:

(1) Generate a unique execution flag for each operation;

(2) Establishing a mapping relationship between the execution flag and the operation result;

(3) During transaction execution, record execution flags and operation results;

(4) If an operation fails, find the corresponding mapping relationship based on the execution flag, and then undo or restore the completed operation based on the mapping relationship;

(5) All operations are completed successfully, or compensation operations have been performed, the transaction ends and the client is notified.

Step S3044: If the compensation operation is successfully executed, the database is submitted, and the submission status of each operation is recorded through the submission success mapping.

The compensation rules in step S3041 include: reverse operation, data repair, transaction rollback, state recovery, sequential execution, repeatability and consistency guarantee.

Submission methods for compensation operations include: direct submission, asynchronous submission and scheduled submission.

The specific steps of step S4 include:

Step S401: After receiving responses from all participating nodes, the coordination node confirms that all operations have been completed;

Step S402: the coordinating node submits the transaction to the database or distributed transaction manager, and records the submission status with a submission success mapping;

Step S403: After confirming that the transaction submission is successful, the coordination node regularly cleans historical data and releases resource operations;

Step S404: Return the transaction processing result to the client.

Example 2

Please refer to FIG5 , another embodiment provided by the present invention: a compensation transaction implementation system for a distributed database, comprising:

Transaction SQL mapping module, transaction submission success mapping module, transaction rollback mapping module, compensation Tmp mapping module, compensation mapping module, compensation execution flag mapping module,

The transaction SQL mapping module is used to determine whether the transaction SQL exceeds the upper limit or submission limit value;

The transaction submission success mapping module is used to record the transaction mapping of distributed transaction submission success, and clean the data when there are scheduled tasks;

The transaction rollback mapping module is used to record rolled-back distributed transactions and clean the data therein when there are scheduled tasks;

The compensation Tmp mapping module module is used to record temporary node transactions to be compensated;

The compensation mapping module is used to record node transactions to be compensated;

The compensation execution flag mapping module is used to mark that a certain node is compensating for a transaction.

The embodiments of the present invention have been described above in conjunction with the accompanying drawings. However, the present invention is not limited to the above-mentioned specific implementations. The above-mentioned specific implementations are only illustrative and not restrictive. Those of ordinary skill in the art will Under the inspiration of the present invention, many forms can be made without departing from the spirit of the present invention and the scope protected by the claims, and these all fall within the protection of the present invention.

Claims (10)

1. A distributed database-oriented compensation transaction implementation method is characterized by comprising the following steps:

step S1: the client initiates a transaction request, judges whether the transaction SQL exceeds a limit value through the execution directory, if so, the back-end database returns an error, and meanwhile, the transaction information is stored in the transaction SQL mapping module;

step S2: the coordination node allocates a time stamp for the transaction initiated by the client in the step S1, and simultaneously sends the operation of the transaction to the data node;

step S3: after receiving the transaction request, the data node judges that the transaction is submitted or rolled back, and returns an execution result to the coordination node for confirmation and verification, if the verification fails, the coordination node notifies the data node and performs compensation operation;

step S4: and after the operation is completed, the coordination node submits the transaction, performs timing cleaning, and returns an execution result to the client.

2. The method for implementing the distributed database-oriented compensation transaction according to claim 1, wherein the specific steps of step S1 include:

step S101: determining a directory path of transaction execution and reading an SQL script file contained in the directory path;

step S102: analyzing the content of the SQL script file to determine whether SQL sentences or operations which possibly cause the transaction to exceed a limit value exist or not, outputting analysis results, and judging whether the SQL sentences of the transaction exceed a preset limit value or not according to the analysis results;

step S103: starting the transaction and monitoring the execution condition of the transaction, and if the execution process of the transaction exceeds a limit value, responding and immediately returning an error by the back-end database;

step S104: and receiving and processing the errors, and if the transaction execution is successful, continuing to process other transactions or closing the connection.

3. The method for implementing the distributed database-oriented compensation transaction according to claim 2, wherein the specific steps of step S2 include:

step S201: the client sends a transaction request to the coordination node, and the coordination node analyzes and processes the transaction request after receiving the transaction request;

step S202: the coordination node generates a globally unique time stamp according to the compensation rule, and distributes the generated time stamp to the transaction initiated by the client in the step S1;

step S203: the coordinating node forwards the generated timestamp with the transaction request to the associated data node.

4. The method for implementing a distributed database-oriented compensation transaction according to claim 3, wherein the time stamp in step S202 specifically includes: transaction start time, transaction commit time, and transaction rollback time.

5. The method for implementing a distributed database-oriented compensation transaction according to claim 4, wherein the specific step of step S3 includes:

step S301: the data node receives the transaction request forwarded by the coordination node, performs sequencing and execution according to the time stamp, and judges whether the transaction request is read, written or other operations;

step S302: according to the judging result, the data node reads or modifies the local data and judges the state of the transaction;

step S303: the data node judges that the transaction can be submitted, the operation result is persisted into the database, a confirmation message is returned to the coordination node, the transaction needs to be rolled back, the related operation executed before the transaction is canceled, the database is restored to the state before the transaction is started, and then the confirmation message is returned to the coordination node;

step S304: after receiving the confirmation message of the data node, the coordination node verifies the operation result by utilizing a three-stage submitting strategy, if the verification passes, the successful completion of the operation of the data node is indicated, and if the verification fails, rollback is needed.

6. The method for implementing a distributed database-oriented compensation transaction according to claim 5, wherein the three-phase commit policy in step S304 is specifically: a pre-commit phase is added between the preparation phase and the commit phase, so that the coordination node sends pre-commit requests to all the participating nodes, and commit or rollback operations are judged according to responses of the participating nodes.

7. The method for implementing the compensation transaction for the distributed database according to claim 6, wherein the specific steps of the compensation operation in step S304 include:

step S3041: determining a transaction needing compensation, and defining a compensation rule;

step S3042: mapping operations in the distributed transaction to compensation operations through transaction compensation mapping according to compensation rules;

step S3043: recording the compensation execution state of each operation through the compensation execution mark mapping;

step S3044: and if the compensation operation is successfully executed, submitting the database, and recording the submitting state of each operation through the successful submitting mapping.

8. The method for implementing the compensation transaction for the distributed database according to claim 7, wherein the compensation rule in step S3041 comprises: reverse operations, data repair, transaction rollback, state restoration, sequential execution, repeatability, and consistency guarantees.

9. The method for implementing the distributed database-oriented compensation transaction according to claim 8, wherein the specific step of step S4 includes:

step S401: after the coordination node receives the responses of all the participating nodes, confirming that all the operations are completed;

step S402: the co-regulator submits the transaction to a database or a distributed transaction manager, and records the submitting state by using the successful submitting mapping;

step S403: after confirming that the transaction is submitted successfully, the coordination node regularly cleans historical data and releases resource operation;

step S404: and returning the result of the transaction to the client.

10. The method for implementing a distributed database oriented compensation transaction of claim 9, comprising: a transaction SQL mapping module, a transaction commit success mapping module, a transaction rollback mapping module, a compensation Tmp mapping module, a compensation execution flag mapping module,

the transaction SQL mapping module is used for judging whether the transaction SQL exceeds an upper limit or submits a limiting value;

the transaction submitting success mapping module is used for recording transaction mapping of successful distributed transaction submitting and cleaning data when timing tasks exist;

the transaction rollback mapping module is used for recording the rolled-back distributed transaction and cleaning the data in the rolled-back distributed transaction when a timing task exists;

the compensation Tmp mapping module is used for recording temporary node transactions to be compensated;

the compensation mapping module is used for recording node transactions to be compensated;

the compensation execution flag mapping module is used for marking that a certain node is compensating a transaction.