Data processing method and device, electronic equipment and storage medium

Abstract

Embodiments of the present disclosure provide a data processing method and device, electronic equipment and storage medium, and relate to the field of databases, for example, the field of distributed databases. The method comprises determining first data according to to-be-backfilled data; updating full-amount data based on the first data, taking a data row in the full-amount data that has been updated based on the first data as second data; determining third data according to the second data and submitting the third data; the first data comprises a data row in the to-be-backfilled data that is locked by a DML transaction, and the third data comprises a data row in the second data that is locked by a DML transaction; if each data row in incremental data has been submitted, it is determined that a DDL transaction is submitted completely; for the data row locked by the DML transaction, if a row lock of the data row is released by the DML transaction, the data row is processed based on a submission result of the DML transaction. Embodiments of the present disclosure eliminate incremental data locking and avoid blocking of user transactions caused by locking.

Description

TECHNICAL FIELD

[0001] The present disclosure relates to the technical field of database, and in particular, the present disclosure relates to a data processing method and device, electronic equipment and storage medium. BACKGROUND

[0002] DDL (Data Definition Language) refers to a language used to define and manage data structures in a database. Currently, when performing a DDL operation on a data object in a database, the data object is usually locked, thereby causing blocking of user transactions. SUMMARY

[0003] The present disclosure provides a data processing method, device, electronic equipment and storage medium, which can solve the problem of blocking of user transactions caused by locking of a data object when performing a DDL operation in the prior art. The technical solution provided by the present disclosure is as follows:

[0004] According to an aspect of an embodiment of the present disclosure, a data processing method is provided, which comprises:

[0005] In response to a data definition language (DDL) transaction execution instruction for a data table, determining full data and incremental data corresponding to the data table; determining to-be-backfilled data based on the incremental data; the to-be-backfilled data is part or all of data rows in the incremental data;

[0006] determining first data according to the to-be-backfilled data, wherein for each data row of the to-be-backfilled data, if the data row is locked by a data manipulation language (DML) transaction, the first data does not include the data row, and if the data row is not locked by the DML transaction, the first data includes the data row;

[0007] updating the full data based on the first data, and taking data rows in the full data that have been updated based on the first data as second data;

[0008] determining third data according to the second data, and submitting the third data, wherein for each data row of the second data, if the data row is locked by the DML transaction, the third data does not include the data row, and if the data row is not locked by the DML transaction, the third data includes the data row;

[0009] if each data row in the incremental data has been submitted, determining that the DDL transaction is completed;

[0010] If the row lock of the data row is released by the DML transaction, a commit result of the DML transaction is obtained, if the commit result is a commit success, it is determined that the data row is committed, if the commit result is a commit failure, the data row is re-considered as the data to be backfilled.

[0011] Optionally, the method further comprises:

[0012] For the data row locked by the DML transaction, the row identifier of the data row is recorded in the row lock conflict processing record.

[0013] The row lock conflict processing record is sent to a row lock conflict processor, so that the row lock conflict processor performs a row lock conflict processing operation on each data row in the row lock conflict processing record.

[0014] Optionally, the row lock conflict processing operation comprises:

[0015] For each data row in the row lock conflict processing record, the row lock conflict processor is set as a listener of the row lock of the data row, and listener information of the row lock of the data row is added in the row lock of the data row, if the row lock release notification of the row lock of the data row is received, it is determined that the row lock of the data row is released.

[0016] The row lock release notification of the row lock of the data row is that a first worker releases the row lock of the data row locked by the DML transaction after committing the DML transaction, and sends the row lock release notification of the row lock of the data row to the corresponding listener of the row lock of the data row based on the listener information of the row lock of the data row, and the first worker is used to execute the DML transaction locking the data row.

[0017] Optionally, the row lock conflict processing operation further comprises:

[0018] For each data row in the row lock conflict processing record, if the commit result of the DML transaction locking the data row is a commit success, the row identifier of the data row is deleted from the row lock conflict processing record.

[0019] If the commit result of the DML transaction locking the data row is a commit failure, the row identifier of the data row is deleted from the row lock conflict processing record when it is determined that the full data has been updated based on the data row.

[0020] Optionally, the determining the data to be backfilled based on the incremental data comprises:

[0021] a range in which a field value of a target field of a data row in the full data is located is taken as a data interval; the target field is a field related to the DDL transaction in the data row;

[0022] The data interval is divided into a plurality of sub-intervals.

[0023] For each sub-interval, a set of at least one data row belonging to the sub-interval in the incremental data is taken as the to-be-backfilled data.

[0024] Each to-be-backfilled data obtained based on the incremental data corresponds to a worker; each worker processes the to-be-backfilled data corresponding to the worker in parallel.

[0025] Optionally, in response to a data definition language (DDL) transaction execution instruction for a data table, the full data and the incremental data corresponding to the data table are determined, and the method comprises the following steps.

[0026] In response to receiving the DDL transaction execution instruction for the data table at a first time, the data table is scanned, and a data object corresponding to the DDL transaction obtained at a second time when the scanning is completed is taken as the full data, and data updated between the first time and the second time of the data table is taken as the incremental data.

[0027] Optionally, each data row in the incremental data comprises a commit identifier; the commit identifier is used to represent whether the data row is committed.

[0028] The method further comprises the following steps.

[0029] For each data row in the incremental data, if a DML transaction locking the data row is committed and the commit result is commit success, or the data row is committed through the DDL transaction, it is determined that the commit identifier of the data row is commit completed.

[0030] If the commit identifier of each data row in the incremental data is commit completed, it is determined that each data row in the incremental data is committed.

[0031] According to another aspect of the embodiments of the present disclosure, a data processing apparatus is provided, and the apparatus comprises:

[0032] A to-be-backfilled data determination module is configured to determine full data and incremental data corresponding to a data table in response to a data definition language (DDL) transaction execution instruction for the data table; determine to-be-backfilled data based on the incremental data; the to-be-backfilled data is part or all of data rows in the incremental data.

[0033] The first row lock processing module is configured to determine first data according to the to-be-backfilled data, wherein for each data row of the to-be-backfilled data, if the data row is locked by a data manipulation language (DML) transaction, the first data does not include the data row, and if the data row is not locked by the DML transaction, the first data includes the data row;

[0034] The updating module is configured to update the full-amount data based on the first data, and take a data row of the full-amount data that has been updated based on the first data as second data.

[0035] The second row lock processing module is configured to determine third data according to the second data and submit the third data, wherein for each data row of the second data, if the data row is locked by the DML transaction, the third data does not include the data row, and if the data row is not locked by the DML transaction, the third data includes the data row.

[0036] The submitting module is configured to determine that the DDL transaction is submitted completely if each data row of the incremental data is submitted.

[0037] For the data row locked by the DML transaction, if the row lock of the data row is released by the DML transaction, a submission result of the DML transaction is obtained, if the submission result is submission success, it is determined that the data row is submitted, and if the submission result is submission failure, the data row is taken as to-be-backfilled data again.

[0038] According to another aspect of the embodiments of the present disclosure, an electronic device is provided, which includes a memory, a processor, and a computer program stored in the memory and executable on the processor, and the processor implements the steps of any of the above data processing methods when executing the program.

[0039] According to another aspect of the embodiments of the present disclosure, a computer readable storage medium is provided, which stores a computer program, and the computer program implements the steps of any of the above data processing methods when executed by a processor.

[0040] According to an aspect of the embodiments of the present disclosure, a computer program product is provided, which includes a computer program, and the computer program implements the steps of any of the above data processing methods when executed by a processor.

[0041] The technical scheme provided by the embodiments of the present disclosure has the following beneficial effects:

[0042] The row lock detection is performed on the data to be backfilled and the data to be submitted, and the processing of the data row locked by the DML transaction is skipped, so as to avoid the blocking of the DML transaction to the advancement of the DDL transaction, and further avoid the situation that the DDL transaction is stuck in the execution process (i.e., the DDL transaction cannot be advanced all the time due to repeated modification of the data row by the DML transaction), thereby improving the efficiency and success rate of the DDL transaction execution. The data row locked by the DML transaction is processed again in the case that the row lock of the data row is released, so as to eliminate the step of locking the incremental data in the process of backfilling the incremental data, thereby avoiding the blocking of the user transaction caused by the row lock in the process of backfilling the incremental data, so as to realize the execution of the DDL transaction without sensing the execution of the DML transaction, and facilitate to improve the efficiency of the DML transaction execution. BRIEF DESCRIPTION OF DRAWINGS

[0043] In order to more clearly illustrate the technical solutions in the embodiments of the present disclosure, the drawings needed to be used in the description of the embodiments of the present disclosure will be briefly introduced.

[0044] Figure 1 A flowchart of a data processing method provided by the embodiments of the present disclosure is shown.

[0045] Figure 2 A schematic diagram of a DDL transaction backfill process provided by the embodiments of the present disclosure is shown.

[0046] Figure 3 A flowchart of another data processing method provided by the embodiments of the present disclosure is shown.

[0047] Figure 4 A structural schematic diagram of a data processing device provided by the embodiments of the present disclosure is shown.

[0048] Figure 5 A structural schematic diagram of an electronic device provided by the embodiments of the present disclosure is shown. DETAILED DESCRIPTION

[0049] The embodiments of the present disclosure will be described below in combination with the drawings in the present disclosure. It should be understood that the embodiments described below in combination with the drawings are exemplary descriptions for explaining the technical solutions of the embodiments of the present disclosure, and do not limit the technical solutions of the embodiments of the present disclosure.

[0050] Those skilled in the art can understand that the singular forms "a", "an" and "the" used herein include plural forms unless otherwise stated. It should be further understood that the terms "include" and "contain" used in the embodiments of the present disclosure mean that the corresponding features can be implemented as the presented features, information, data, steps, operations, elements and / or components, but do not exclude other features, information, data, steps, operations, elements, components and / or their combinations supported by the present technology. It should be understood that when we say that an element is "connected" or "coupled" to another element, the element can be directly connected or coupled to the other element, or it can mean that the element and the other element are connected through an intermediate element. In addition, "connected" or "coupled" used herein can include wireless connection or wireless coupling. The term "and / or" used herein means that at least one of the items defined by the term, for example, "A and / or B" or "A, B" means that A is implemented, or B is implemented, or A and B are implemented.

[0051] For the purpose, technical solutions and advantages of the present disclosure to be clearer, the embodiments of the present disclosure will be described in further detail below with reference to the drawings.

[0052] DDL (Data Definition Language, data definition language) statement refers to a language used to define and manage the data structure in the database.

[0053] Currently, when performing a DDL operation on a certain data object in the database, it is divided into online DDL and offline DDL. Offline DDL usually needs to add an MLD lock to the data object to block the modification of data in the data object by other transactions during the execution of the DDL statement.

[0054] Because the offline DDL blocks the user business for a long time, the online DDL is more widely used. For online DDL, a full-amount combined log chasing method can be used to implement, but during the backfill stage of online DLL, the data rows involved in the backfill still need to be added row locks, thereby causing the blocking of user transactions.

[0055] The data processing method, device, electronic equipment and storage medium provided by the present disclosure aim to solve the above technical problems of the prior art.

[0056] The technical solutions of the embodiments of the present disclosure and the technical effects produced by the technical solutions of the present disclosure will be described below through the description of several exemplary embodiments. It should be pointed out that the following embodiments can be mutually referenced, borrowed or combined. For the same terms, similar features and similar implementation steps in different embodiments, they will not be described repeatedly.

[0057] Figure 1 This is a flowchart illustrating a data processing method provided in an embodiment of the present disclosure, as shown below. Figure 1 As shown, the method includes:

[0058] Step S110: In response to the Data Definition Language (DDL) transaction execution instruction for the data table, determine the full data and incremental data corresponding to the data table; determine the data to be backfilled based on the incremental data; the data to be backfilled is part or all of the data rows in the incremental data.

[0059] Specifically, the data processing method provided in this disclosure can be applied to a database system, such as a distributed database system. The data processing method provided in this disclosure can be executed by a DDL worker, which can be a worker used to execute DDL transactions. The worker can be a node in the database system, or a thread or process. The worker can be specifically configured according to the actual resources in the database system, and this disclosure does not limit this.

[0060] In a database system, data can be stored in the form of tables. When a DDL transaction for a table is executed, the full and incremental data of the table can be obtained in response to the DDL transaction execution instructions.

[0061] The full data corresponding to the data table can be the data object corresponding to the DDL transaction obtained during the scanning process of the data table, and the incremental data corresponding to the data table can be the data that has changed during the scanning process.

[0062] It should be noted that the data processing method provided in this disclosure can be applied to any DDL transaction that adopts a processing flow of first obtaining the full amount of data and then backfilling the full amount of data with incremental data, such as a DDL transaction for creating an index, or a DDL transaction for modifying the data type of a certain field.

[0063] Optionally, in response to Data Definition Language (DDL) transaction execution instructions for the data table, the full and incremental data corresponding to the data table are determined, including:

[0064] In response to receiving a DDL transaction execution instruction for a data table at the first moment, the data table is scanned. The data object corresponding to the DDL transaction obtained at the second moment when the scan is completed is taken as the full data, and the data updated in the data table between the first moment and the second moment is taken as the incremental data.

[0065] Specifically, upon receiving the DDL transaction execution instruction for the data table at the first moment, a scan of the data table begins. The start time of the scan is designated as the first moment, and the data objects corresponding to the DDL transaction obtained during this scan are considered the full dataset. The completion time of the scan is designated as the second moment, and the data objects corresponding to the DDL transaction obtained at that time are considered the full dataset. Data updated in the table between the first and second moments is considered incremental data. The full dataset can be backfilled using the incremental data, and the backfilled full dataset is used as the execution result of the DDL transaction.

[0066] For example, a DDL transaction can be an index-adding transaction. The data table for which the index is to be created is treated as the data table to be processed. The data table is scanned from the first moment, and the corresponding index is created based on the DDL transaction. The index created when the scan of the data table is completed is used as the full data.

[0067] It should be noted that the data object corresponding to the DDL transaction can be determined based on the specific transaction type of the DDL transaction, and this disclosure does not limit this.

[0068] After obtaining the incremental data, the data to be filled can be determined based on the incremental data. For example, all data rows in the incremental data can be used as the data to be filled, or only some data rows in the incremental data can be used as the data to be filled.

[0069] Step S120: Determine the first data based on the data to be backfilled. For each data row of the data to be backfilled, if the data row is locked by a Data Manipulation Language (DML) transaction, the first data does not include the data row; if the data row is not locked by a DML transaction, the first data includes the data row.

[0070] Specifically, while the database system is executing DDL transactions, DML transactions may also be executing. When a DML transaction needs to update a data row, it will acquire a row lock on that data row to block other transactions from modifying the data in that data row, thereby ensuring the consistency of the data in that data row.

[0071] If a data row is modified by both DDL and DML transactions, it is considered that there is a row lock conflict. Before backfilling the data, row lock detection can be performed on each data row in the backfill data to obtain the first data.

[0072] Each data row in the data to be backfilled can be scanned sequentially. For each scanned data row, it is checked whether the data row is locked by a DML transaction. If the data row is not locked by a DML transaction, it can be kept in the first data set; if the data row is locked by a DML transaction, it is not included in the first data set. The first data set can be understood as the set of data rows that need to be backfilled.

[0073] Optionally, the database system may include a lock manager for managing row locks on data rows. The lock manager may store information about the row locks on locked data rows in the data table, such as the row identifier of the locked data row, information about the transaction that locked the data row, and the status of the row lock on the data row.

[0074] A worker can be started as a row lock detector, or a DDL worker can be used as a row lock detector. When the row lock detector scans each data row, it can send a row lock check request for that data row to the lock manager, so that the lock manager can determine whether the data row is locked by a DML transaction based on the row lock information of the stored data row, and return the result to the row lock detector; alternatively, the lock manager can send the row lock information of the data row to the row lock detector, and the row lock detector can determine whether each scanned data row is locked by a DML transaction based on the received row lock information. The embodiments of this disclosure do not limit the method of detecting whether a data row is locked by a DML transaction.

[0075] Step S130: Update the entire dataset based on the first data, and use the data rows in the entire dataset that have been updated based on the first data as the second data.

[0076] Specifically, after determining the first data, the full data can be updated based on the first data. That is, the data rows in the first data are replayed based on the corresponding data rows in the full data. For example, the full data includes a data row with the row identifier of account A and the data of the data row is the balance of account A of 100. The incremental data includes the transfer of account A's account balance of 20. Then, for the data row corresponding to account A, subtracting 20 from 100 will give the latest balance of account A of 80.

[0077] The data rows in the full dataset that have been updated based on the first data are used as the second data to be submitted. For example, if the full dataset includes 100 data rows and the first data includes 10 data rows, meaning that the data in 10 data rows has been updated, then the second data includes these 10 updated data rows.

[0078] Step S140: Determine the third data based on the second data and submit the third data. For each data row of the second data, if the data row is locked by a DML transaction, the third data does not include the data row; if the data row is not locked by a DML transaction, the third data includes the data row.

[0079] Specifically, during the backfilling of data, the row lock status of data rows locked by DML transactions may be updated. For example, during the scan phase, it may be detected that a data row in the data to be backfilled is locked by a DML transaction that has not yet been committed. However, if the DML transaction is committed during the backfilling process, the row lock on that data row will be released. Alternatively, it may be detected during the scan phase that a data row is not locked by a DML transaction, but it is locked by a DML transaction during the backfilling process. Therefore, during the commit phase, row lock checks are performed again on each data row in the second set of data to be committed.

[0080] For each data row in the second set of data, check whether the data row is locked by a DML transaction. If the data row is not locked by a DML transaction, it can be retained in the third set of data; if the data row is locked by a DML transaction, it is not included in the third set of data. The third set of data can be understood as the set of data rows that need to be committed.

[0081] After obtaining the third data, you can submit it.

[0082] In this embodiment of the disclosure, for data rows locked by DML transactions in incremental data, the processing of these data rows locked by DML transactions (including backfilling and commit) is skipped, thereby avoiding the blocking of DDL transaction progress by data rows locked by DML transactions. This avoids the situation where DDL transactions are stuck during execution (i.e., DML transactions repeatedly modify certain data rows, causing DDL transactions to be unable to proceed), improves the efficiency and success rate of DDL transaction execution, and reduces the impact of DDL backfilling transactions on DML transactions.

[0083] For data rows detected in incremental data that were locked by DML transactions, once the row lock on that data row is released, the data row is processed based on the commit result of the DML transaction that locked it. If the commit result is successful, it is determined that the entire data has been updated based on that data row; if the commit result is unsuccessful, the data row is then treated as data to be populated again.

[0084] In other words, if the DML transaction corresponding to the data row is successfully committed, it means that the DML transaction has completed the update of the entire data for that data row; if the DML transaction corresponding to the data row fails to commit, the data row will be treated as data to be backfilled.

[0085] Step S150: If each data row in the incremental data has been committed, then the DDL transaction is determined to be committed.

[0086] Specifically, committing data rows in incremental data can be achieved in the following ways: For data rows in incremental data that are locked by DML transactions, if the DML transaction commits successfully, the latest data of that data row can be used to update the corresponding data row in the full data, i.e., committing via DML transaction; if the DML transaction commit fails, the data row can be backfilled and then committed via DDL transaction; for data rows in incremental data that are not locked by DML transactions, the data row can be backfilled and then committed via DDL transaction.

[0087] When it is determined that each row of data in the incremental data has been committed, the DDL transaction can be considered committed successfully.

[0088] Optionally, each data row in the incremental data includes a commit identifier; the commit identifier is used to indicate whether the data row has been committed.

[0089] The method also includes:

[0090] For each data row in the incremental data, if the DML transaction that locks the data row has been committed and the commit result is successful, or the data row has been committed through a DDL transaction, then the commit flag of the data row is determined to be committed complete.

[0091] If the commit identifier of each data row in the incremental data is "commit complete", then it is determined that each data row in the incremental data has been committed.

[0092] Specifically, a commit flag can be added to the data rows of incremental data. The commit flag is used to indicate whether the data row has been committed. The commit flag is initially set to uncommitted. After the data row is backfilled and committed, or after the DML transaction that locks the data row is successfully committed, the commit flag can be set to committed. If the commit flag of each data row in the incremental data is committed, then it is determined that each data row in the incremental data has been committed.

[0093] The data processing method provided in this disclosure performs row lock detection on both the data to be backfilled and the data to be committed, and skips the processing of data rows locked by DML transactions. This avoids the blocking of DDL transaction progress by data rows locked by DML transactions, thereby preventing DDL transactions from being stuck during execution (i.e., DML transactions repeatedly modifying certain data rows, causing the DDL transaction to be unable to proceed), and improving the efficiency and success rate of DDL transaction execution. By processing data rows locked by DML transactions only after the row locks on those data rows are released, the step of adding row locks to incremental data during the backfilling of incremental data is eliminated. This avoids the blocking of user transactions caused by adding row locks during the backfilling of incremental data, enabling DDL transactions to be executed seamlessly during the execution of DML transactions, which is beneficial to improving the efficiency of DML transaction execution.

[0094] As an optional embodiment, the method further includes:

[0095] For data rows locked by DML transactions, the row identifier of the data row is recorded in the row lock conflict handling record;

[0096] The row lock conflict resolution record is sent to the row lock conflict processor so that the row lock conflict processor performs row lock conflict resolution operations on each data row in the row lock conflict resolution record.

[0097] Specifically, a row lock conflict handling record can be set up. During the scan phase, when performing row lock checks on each data row in the data to be backfilled, if it is determined that a data row is locked by a DML transaction, the row identifier of that data row can be added to the row lock conflict handling record. During the commit phase, when performing row lock checks on each data row in the second data to be committed, the row lock conflict handling record has already recorded the row identifiers of the locked data rows detected during the scan phase. For each data row in the second data, if it is detected that the data row is locked by a DML transaction, it can be determined whether the row lock conflict handling record includes the row identifier of that data row. If the row lock conflict handling record includes the row identifier of that data row, then it is not necessary to add the row identifier of that data row to the row lock conflict handling record. If the row lock conflict handling record does not include the row identifier of that data row, it means that the data row was not locked by a DML transaction during the scan phase, but a DML transaction locked the data row during the backfilling process of the updated data to be backfilled, then the row identifier of that data row is added to the row lock conflict handling record.

[0098] At least one worker can be restarted as a row lock conflict processor to handle data rows locked by DML transactions. After obtaining the row lock conflict handling record, the row lock conflict handling record can be sent to the row lock conflict processor so that the row lock conflict processor can perform row lock conflict handling operations on each data row in the row lock conflict handling record.

[0099] In this embodiment of the disclosure, by restarting a new worker to process the data rows in the row lock conflict processing record, the processing of data rows not locked by DML transactions and data rows locked by DML transactions are processed asynchronously through different workers, so as to further improve the efficiency of incremental data backfilling.

[0100] As an optional embodiment, the row lock conflict handling operation includes:

[0101] For each data row in the row lock conflict handling record, the row lock conflict handler is used as the listening object of the row lock of the data row, and the listening object information of the row lock of the data row is added to the row lock of the data row. If a row lock release notification of the row lock of the data row is received, it is determined that the row lock of the data row has been released.

[0102] Among them, the row lock release notification for the data row is that after the first worker commits the DML transaction, it releases the row lock of the data row that was locked by the DML transaction, and sends the row lock release notification to the listener object corresponding to the row lock of the data row based on the listener object information of the row lock of the data row. The first worker is used to execute the DML transaction that locks the data row.

[0103] Specifically, for each data row in the row lock conflict handling record, the row lock conflict handler can register to listen to the row locks of that data row, that is, the row lock conflict handler acts as the listening object for the row locks of that data row. For example, the listening to the row locks of locked data rows can be implemented based on the watch mechanism. The listening object information for listening to the row locks of that data row is added to the row locks of that data row. The listening object information may include the identifier of the listening object or the address of the listening object.

[0104] Optionally, the monitoring object information may include the address of the monitoring object, and may also include the identifier of the monitoring object. The address of the monitoring object is obtained based on a preset correspondence between the identifier and the address of the monitoring object, and the identifier of the monitoring object. This embodiment of the present disclosure does not limit this.

[0105] The worker that executes the DML transaction that locks the data row is designated as the first worker. After the first worker commits the DML transaction, it releases the row locks of the data rows locked by the DML transaction. Based on the listener object information in the row locks of each locked data row, it obtains the address of the listener object listening to the row lock of that data row. Based on the obtained listener object address, it sends the row lock release notification of the data row to the listener object of the row lock of that data row.

[0106] The row lock conflict processor receives a row lock release notification for the data row, and can determine that the row lock for the data row has been released based on the row lock release notification.

[0107] Optionally, for data rows locked by DML transactions, a row lock conflict information field can be added to the row lock of the data row. This field records row lock conflict information for that data row and may include a row lock conflict identifier and listener object information. The row lock conflict identifier indicates that a row lock conflict exists for that data row. Based on this, when the first worker commits a DML transaction, if it detects that a row lock on a data row includes a row lock conflict identifier, it can send a row lock release notification to the listener object of that row lock when releasing the row lock.

[0108] Optionally, when there are multiple row lock conflict handlers, the range of primary keys of data rows in the full dataset can be divided into multiple first sub-intervals. The number of first sub-intervals is the same as the number of row lock conflict handlers, and each row lock conflict handler corresponds to one first sub-interval, thereby enabling parallel processing of data rows in the row lock conflict processing record. In this case, for each data row in the row lock conflict processing record, the monitoring object for that data row is the row lock conflict handler that performs the row lock conflict processing operation on that data row.

[0109] In this embodiment, a row lock conflict handling record stores information about data rows where row lock conflicts exist between DDL and DML transactions. The row lock conflict processor, upon determining that the row lock on a data row locked by a DML transaction has been released, processes the data row based on the DML transaction's commit result. This eliminates the step of adding row locks during incremental data backfilling, thus avoiding the blocking of user transactions caused by adding row locks to data rows during incremental data backfilling. This allows DDL transactions to execute seamlessly during DML transaction execution. It also avoids blocking DDL transactions after DML transactions lock data rows being backfilled. In other words, when backfilling incremental data, DDL transactions can skip the backfilling of data rows locked by DML transactions, avoiding the waiting time for these row locks to be released. This prevents DDL transactions from being stuck during execution, improving the efficiency and success rate of DDL transaction execution.

[0110] Furthermore, by adding listener information to the row lock of the data row locked by the DML transaction, the corresponding listener can be notified in a timely manner when the row lock of the data row is detected to be released, thereby realizing real-time monitoring of whether the row lock of the locked data row has been released.

[0111] As an optional embodiment, the row lock conflict handling operation further includes:

[0112] For each data row in the row lock conflict handling record, if the DML transaction that locked the data row was successfully committed, then the row identifier of that data row is deleted from the row lock conflict handling record.

[0113] If the DML transaction that locks the data row fails to commit, the row identifier of the data row will be removed from the row lock conflict handling record once it is determined that the entire data has been updated based on the data row.

[0114] Specifically, after determining that the row lock on a data row has been released, the row lock conflict processor can also obtain the commit result of the DML transaction that locked the data row. The row lock release notification for the data row can include the commit result of the corresponding DML transaction.

[0115] If the submission is successful, it indicates that the entire data has been updated based on that data row, and the data for that row will not be backfilled. The row identifier of that data row will be deleted from the row conflict handling record. If the submission fails, the data row will be treated as data to be backfilled again. If it is determined that the entire data has been updated based on that data row, the row identifier of that data row will be deleted from the row lock conflict handling record, so that the row lock conflict handling record always records information about unprocessed data rows with row lock conflicts.

[0116] In other words, when the row lock conflict handling record still retains information about a certain data row, the DDL transaction commit is not yet complete. The data rows retained in the row lock conflict handling record still need to be processed until the row lock conflict handling record no longer contains information about any data rows.

[0117] Once a data row is designated as data to be backfilled, it can be processed according to the data backfilling process described above. If the data row is not locked by a DML transaction, then after the data row is backfilled and committed, it is determined that all data has been updated based on the data row. If the data row is locked by a DML transaction, then when the DML transaction that locked the data row is successfully committed, it is also determined that all data has been updated based on the data row.

[0118] Among them, the row lock conflict processor can restart at least one worker to process the data to be backfilled based on the data rows determined in the row lock conflict processing record.

[0119] As an optional implementation, determining the data to be backfilled based on incremental data includes:

[0120] The range of values ​​in the target field within a data row of the entire dataset is defined as the data interval; the target field is the field in the data row that is related to the DDL transaction.

[0121] Divide the data range into multiple sub-ranges;

[0122] For each sub-interval, the set of at least one data row in the incremental data that belongs to that sub-interval is taken as the data to be backfilled;

[0123] Each piece of data to be backfilled, obtained from incremental data, corresponds to a worker; each worker processes its corresponding piece of data in parallel.

[0124] Specifically, after obtaining the full data, the range of field values ​​in the target field of the data rows in the full data can be used as the data interval; where the target field is the field in the data row that is related to the DDL transaction.

[0125] For example, when a DDL transaction is an indexed transaction, the fields in each data row for which the index is to be created can be used as the target fields.

[0126] Divide the obtained data interval into multiple sub-intervals, for example, the data interval can be divided into multiple sub-intervals evenly.

[0127] For each sub-interval, the data rows in the incremental data whose field values ​​in the target field are the corresponding sub-data rows in that sub-interval are taken as the sub-data for that sub-interval.

[0128] Each sub-data obtained by dividing the incremental data is used as the data to be backfilled. Each data to be backfilled is assigned to a corresponding worker. By having multiple workers execute in parallel, the incremental data backfilling task is divided into multiple sub-tasks. The parallel execution of multiple sub-tasks by multiple workers can improve the efficiency of incremental data backfilling.

[0129] As an optional embodiment, Figure 2 This is a schematic diagram of a DDL transaction backfilling process provided in an embodiment of the present disclosure, as shown below. Figure 2 As shown, after determining the data to be backfilled, during the scanning phase, row lock detection is performed on each data row in the data to be backfilled. For each data row in the data to be backfilled, if it is detected that the data row is not locked by a DML transaction, then the data row is treated as the first data; if it is detected that the data row is locked by a DML transaction, then the data row is deleted from the first data corresponding to this backfill task (i.e., the first data does not include the data row), and the row identifier of the data row is added to the row lock conflict handling record, establishing a listener for the row lock of the data row in the corresponding DML transaction. If the row lock of the data row is detected to be released, the commit result of the DML transaction is obtained. If the commit result is successful, the data row is deleted from the row lock conflict handling record; if the commit result is unsuccessful, the data row is treated as data to be backfilled.

[0130] The entire dataset is updated based on the first data to obtain the second data to be committed. The third data is then determined based on the second data and committed. During the commit phase, row lock checks are performed on each row of the second data. For each row in the second data, if it is detected that the row is not locked by a DML transaction, it is included in the third data. If it is detected that the row is locked by a DML transaction, it is removed from the third data corresponding to this commit task (i.e., the third data does not include the row), and a row identifier for that row is added to the row lock conflict handling record. A listener is established for the row lock on that row in the corresponding DML transaction. If the row lock on that row is released, the commit result of the DML transaction is obtained. If the commit result is successful, the row is removed from the row lock conflict handling record; if the commit result is a failure, the row is included as data to be backfilled.

[0131] The following describes the flow of the data processing method provided in the embodiments of this disclosure, using a DDL transaction as the index creation transaction. Figure 3 This is a flowchart illustrating a data processing method provided in an embodiment of the present disclosure, as shown below. Figure 3 As shown, the method includes:

[0132] 1. Set a timestamp to start scanning the full data, and start scanning the data table to be indexed and prepare the full data (i.e., temp index) at this timestamp. Record the data that changes in the data table during the scanning process into the incremental data;

[0133] 2. After the full data preparation is completed, the index creation task enters the incremental data preparation stage. Subtasks are divided according to the range of tempindex. Parallel tasks can be distributed and executed based on the concurrency of the index creation task and the number of nodes that can participate in distributed execution.

[0134] 3. Scanning Phase: Parallel processing workers are started to scan the data rows of the subtask. For each worker, for each data row scanned, the worker sends a row lock detection request to the storage engine (the row lock detection logic can be embedded in the storage engine). After receiving the row lock detection request, the storage engine determines whether the data row is locked by a DML transaction and returns the detection result to the worker.

[0135] 4. For unlocked data rows, the worker can perform data backfilling for those data rows; for locked data rows, the worker can skip processing those data rows in this backfilling task.

[0136] 5. For locked data rows, one or more workers can be started to handle the asynchronous processing of these data rows. The data row is registered (i.e., its row identifier is recorded in the row lock conflict handling record), and the row lock conflict information is sent to the corresponding row lock conflict handler. The row lock conflict handler adds a row lock conflict identifier to the row lock conflict information field added to the data row's row lock and sets the currently processing worker as a watcher (i.e., the listening object). When the row lock is released after the DML transaction is committed, if the data row's row lock includes a row lock conflict identifier, the corresponding watcher is notified according to the watcher's address information in the row lock conflict handling structure. After confirming that the row lock has been released, if the DML transaction is successfully committed, no further processing of the data row is required, and the data row is deleted from the row lock conflict handling record. If the DML transaction is rolled back, the data row needs to be refilled and deleted from the row lock conflict handling record. The watcher then checks if there are any unprocessed data rows in the row lock conflict handling record; if so, it continues to listen for whether the row lock of that data row has been released.

[0137] 6. Commit Phase: For data rows that are not locked, after the worker has completed the data backfilling for the data row, it starts to commit the DDL transaction. For each data row to be committed, the processing worker sends a row lock detection request to the storage engine. After receiving the row lock detection request, the storage engine determines whether the data row is locked by the DML transaction and returns the detection result to the worker.

[0138] 7. For unlocked data rows, the worker can commit the data for that data row; for locked data rows, the worker can skip the processing of those data rows in this commit task.

[0139] 8. Determine if there is any other data to be processed in this subtask. If so, continue processing the remaining data. If not, determine if there are any remaining subtasks to be processed. If so, continue processing the remaining subtasks. If not, determine if there is any remaining data in the row lock conflict handling record. If so, continue processing the remaining data in the row lock conflict handling record. If not, confirm that the DDL transaction has been committed.

[0140] The method provided in this disclosure maintains zero impact of online indexing DDL on business transaction commits, solves the problem that may cause the indexing stage to get stuck during the indexing process, and further improves the efficiency of incremental change backfilling during the DDL index creation process.

[0141] Figure 4 This is a schematic diagram of the structure of a data processing apparatus provided in an embodiment of the present disclosure, as shown below. Figure 4 As shown, the apparatus of this embodiment may include:

[0142] The data to be backfilled module 210 is used to determine the full data and incremental data corresponding to the data table in response to a Data Definition Language (DDL) transaction execution instruction for the data table; and to determine the data to be backfilled based on the incremental data; the data to be backfilled is part or all of the data rows in the incremental data.

[0143] The first row lock processing module 220 is used to determine the first data based on the data to be backfilled, wherein, for each data row of the data to be backfilled, if the data row is locked by a Data Manipulation Language (DML) transaction, the first data does not include the data row; if the data row is not locked by a DML transaction, the first data includes the data row.

[0144] Update module 230 is used to update the full data based on the first data, and to take the data rows in the full data that have been updated based on the first data as the second data;

[0145] The second row lock processing module 240 is used to determine the third data based on the second data and submit the third data, wherein, for each data row of the second data, if the data row is locked by a DML transaction, the third data does not include the data row; if the data row is not locked by a DML transaction, the third data includes the data row.

[0146] The commit module 250 is used to determine that the DDL transaction has been committed if each data row in the incremental data has been committed.

[0147] Specifically, for a data row locked by a DML transaction, if the row lock of the data row is released by the DML transaction, the commit result of the DML transaction is obtained. If the commit result is successful, it is determined that the data row has been committed. If the commit result is unsuccessful, the data row is re-entered as data to be backfilled.

[0148] As an optional embodiment, the device further includes:

[0149] The row lock conflict handling module is used to record the row identifier of a data row that is locked by a DML transaction in the row lock conflict handling record;

[0150] The row lock conflict processing record is sent to the row lock conflict processor so that the row lock conflict processor performs a row lock conflict processing operation on each data row in the row lock conflict processing record.

[0151] As an optional embodiment, the row lock conflict handling operation includes:

[0152] For each data row in the row lock conflict handling record, the row lock conflict processor is used as the listening object of the row lock of the data row, and the listening object information of the row lock of the data row is added to the row lock of the data row. If a row lock release notification of the row lock of the data row is received, it is determined that the row lock of the data row has been released.

[0153] Specifically, the row lock release notification for the data row is initiated by the first worker after submitting the DML transaction. The first worker releases the row lock of the data row that was locked by the DML transaction and sends the row lock release notification to the listening object corresponding to the row lock of the data row based on the listening object information of the row lock of the data row. The first worker is used to execute the DML transaction that locked the data row.

[0154] As an optional embodiment, the row lock conflict handling operation further includes:

[0155] For each data row in the row lock conflict handling record, if the DML transaction that locked the data row was successfully committed, then the row identifier of the data row is deleted from the row lock conflict handling record.

[0156] If the DML transaction that locks the data row fails to commit, then when it is determined that the full data has been updated based on the data row, the row identifier of the data row is deleted from the row lock conflict handling record.

[0157] As an optional embodiment, the data to be backfilled determination module, when determining the data to be backfilled based on the incremental data, is used to:

[0158] The range of field values ​​in the target field within the data rows of the full dataset is defined as the data interval; the target field is the field in the data row that is related to the DDL transaction.

[0159] The data interval is divided into multiple sub-intervals;

[0160] For each sub-interval, the set of at least one data row belonging to the sub-interval in the incremental data is taken as the data to be backfilled;

[0161] Each piece of data to be backfilled, obtained based on the incremental data, corresponds to a worker; each worker processes its corresponding piece of data to be backfilled in parallel.

[0162] As an optional embodiment, the data to be backfilled determination module, in response to a Data Definition Language (DDL) transaction execution instruction for a data table, determines the full data and incremental data corresponding to the data table by:

[0163] In response to receiving a DDL transaction execution instruction for a data table at a first moment, the data table is scanned, and the data object corresponding to the DDL transaction obtained at a second moment when the scan is completed is taken as the full data, while the data updated in the data table between the first moment and the second moment is taken as the incremental data.

[0164] As an optional embodiment, each data row in the incremental data includes a commit identifier; the commit identifier is used to indicate whether the data row has been committed successfully.

[0165] The method further includes:

[0166] For each data row in the incremental data, if the DML transaction that locks the data row has been committed and the commit result is successful, or the data row has been committed through a DDL transaction, then the commit identifier of the data row is determined to be completed.

[0167] If the commit identifier of each data row in the incremental data is "commit complete", then it is determined that each data row in the incremental data has been committed.

[0168] The apparatus of this disclosure embodiment can execute the method provided in this disclosure embodiment, and its implementation principle is similar, and it has corresponding technical effects. The actions performed by each module in the apparatus of each embodiment of this disclosure correspond to the steps in the method of each embodiment of this disclosure. For a detailed functional description of each module of the apparatus, please refer to the description in the corresponding method shown above, and it will not be repeated here.

[0169] In this disclosure, the terms "module" or "unit" refer to a computer program or part of a computer program that has a predetermined function and works with other related parts to achieve a predetermined goal, and can be implemented wholly or partially using software, hardware (such as processing circuitry or memory), or a combination thereof. Similarly, a processor (or multiple processors or memory) can be used to implement one or more modules or units. Furthermore, each module or unit can be part of an overall module or unit that includes the functionality of that module or unit.

[0170] This disclosure provides an electronic device including a memory, a processor, and a computer program stored in the memory. The processor executes the computer program to implement the steps of the method provided in any optional embodiment of this disclosure. Compared with the prior art, it achieves the following: by performing row lock detection on both the data to be backfilled and the data to be committed, and skipping the processing of data rows locked by DML transactions, the blocking of DDL transaction progress by data rows locked by DML transactions is avoided, thereby preventing the DDL transaction from being stuck during execution (i.e., the DML transaction repeatedly modifies certain data rows, causing the DDL transaction to be unable to proceed), thus improving the efficiency and success rate of DDL transaction execution. By processing the data row locked by the DML transaction only after the row lock on the data row is released, the step of adding row locks to incremental data during the backfilling of incremental data is eliminated, thereby avoiding the blocking of user transactions caused by adding row locks during the backfilling of incremental data. This enables the DDL transaction to be executed seamlessly during the execution of DML transactions, which is beneficial to improving the efficiency of DML transaction execution.

[0171] In one alternative embodiment, an electronic device is provided, such as Figure 5 As shown, Figure 5The illustrated electronic device 4000 includes a processor 4001 and a memory 4003. The processor 4001 and the memory 4003 are connected, for example, via a bus 4002. Optionally, the electronic device 4000 may further include a transceiver 4004, which can be used for data interaction between the electronic device and other electronic devices, such as sending and / or receiving data. It should be noted that in practical applications, the transceiver 4004 is not limited to one type, and the structure of the electronic device 4000 does not constitute a limitation on the embodiments of this disclosure.

[0172] Processor 4001 may be a CPU (Central Processing Unit), a general-purpose processor, a DSP (Digital Signal Processor), an ASIC (Application Specific Integrated Circuit), an FPGA (Field Programmable Gate Array), or other programmable logic devices, transistor logic devices, hardware components, or any combination thereof. It may implement or execute the various exemplary logic blocks, modules, and circuits described in conjunction with this disclosure. Processor 4001 may also be a combination that implements computational functions, such as including one or more microprocessor combinations, a combination of a DSP and a microprocessor, etc.

[0173] Bus 4002 may include a pathway for transmitting information between the aforementioned components. Bus 4002 may be a PCI (Peripheral Component Interconnect) bus or an EISA (Extended Industry Standard Architecture) bus, etc. Bus 4002 can be divided into address bus, data bus, control bus, etc. For ease of representation, Figure 5 The bus is represented by a single thick line, but this does not mean that there is only one bus or one type of bus.

[0174] The memory 4003 may be ROM (Read Only Memory) or other types of static storage devices capable of storing static information and instructions, RAM (Random Access Memory) or other types of dynamic storage devices capable of storing information and instructions, or EEPROM (Electrically Erasable Programmable Read Only Memory), CD-ROM (Compact Disc Read Only Memory) or other optical disc storage, optical disc storage (including compressed optical discs, laser discs, optical discs, digital universal optical discs, Blu-ray discs, etc.), magnetic disk storage media, other magnetic storage devices, or any other medium capable of carrying or storing computer programs and capable of being read by a computer, without limitation herein.

[0175] The memory 4003 is used to store computer programs that execute embodiments of the present disclosure, and is controlled by the processor 4001 to execute them. The processor 4001 is used to execute the computer programs stored in the memory 4003 to implement the steps shown in the foregoing method embodiments.

[0176] Among them, electronic devices include, but are not limited to: mobile terminals such as mobile phones, laptops, digital radio receivers, PDAs (personal digital assistants), PADs (tablet computers), PMPs (portable multimedia players), in-vehicle terminals (such as in-vehicle navigation terminals), wearable devices, etc., as well as fixed terminals such as digital TVs, desktop computers, etc.

[0177] This disclosure provides a computer-readable storage medium storing a computer program, which, when executed by a processor, can implement the steps and corresponding content of the aforementioned method embodiments.

[0178] This disclosure also provides a computer program product, including a computer program that, when executed by a processor, can implement the steps and corresponding content of the aforementioned method embodiments.

[0179] It should be understood that although arrows indicate various operation steps in the flowcharts of the embodiments of this disclosure, the order in which these steps are implemented is not limited to the order indicated by the arrows. Unless explicitly stated herein, in some implementation scenarios of the embodiments of this disclosure, the implementation steps in each flowchart can be executed in other orders as required. Furthermore, some or all of the steps in each flowchart may include multiple sub-steps or multiple stages based on the actual implementation scenario. Some or all of these sub-steps or stages can be executed at the same time, and each sub-step or stage can also be executed at different times. In scenarios where execution times differ, the execution order of these sub-steps or stages can be flexibly configured as required, and the embodiments of this disclosure do not limit this.

[0180] The above description is only an optional implementation method for some implementation scenarios of this disclosure. It should be noted that for those skilled in the art, other similar implementation methods based on the technical concept of this disclosure without departing from the technical concept of this disclosure also fall within the protection scope of the embodiments of this disclosure.

Claims

1. A data processing method, characterized in that, include: In response to a Data Definition Language (DDL) transaction execution instruction for a data table, determine the full data and incremental data corresponding to the data table; Based on the incremental data, determine the data to be backfilled; The data to be backfilled is part or all of the data rows in the incremental data; The first data is determined based on the data to be backfilled, wherein, for each data row of the data to be backfilled, if the data row is locked by a Data Manipulation Language (DML) transaction, the first data does not include the data row; if the data row is not locked by a DML transaction, the first data includes the data row. The full data is updated based on the first data, and the data rows in the full data that have been updated based on the first data are used as the second data; The third data is determined based on the second data and the third data is submitted. For each data row of the second data, if the data row is locked by a DML transaction, the third data does not include the data row; if the data row is not locked by a DML transaction, the third data includes the data row. If each data row in the incremental data has been committed, then the DDL transaction is determined to be committed successfully. Specifically, for a data row locked by a DML transaction, if the row lock of the data row is released by the DML transaction, the commit result of the DML transaction is obtained. If the commit result is successful, it is determined that the data row has been committed. If the commit result is unsuccessful, the data row is re-entered as data to be backfilled.

2. The method according to claim 1, characterized in that, The method further includes: For data rows locked by DML transactions, the row identifier of the data row is recorded in the row lock conflict handling record; The row lock conflict processing record is sent to the row lock conflict processor so that the row lock conflict processor performs a row lock conflict processing operation on each data row in the row lock conflict processing record.

3. The method according to claim 2, characterized in that, The row lock conflict handling operation includes: For each data row in the row lock conflict handling record, the row lock conflict processor is used as the listening object of the row lock of the data row, and the listening object information of the row lock of the data row is added to the row lock of the data row. If a row lock release notification of the row lock of the data row is received, it is determined that the row lock of the data row has been released. Specifically, the row lock release notification for the data row is initiated by the first worker after submitting the DML transaction. The first worker releases the row lock of the data row that was locked by the DML transaction and sends the row lock release notification to the listening object corresponding to the row lock of the data row based on the listening object information of the row lock of the data row. The first worker is used to execute the DML transaction that locked the data row.

4. The method according to claim 2, characterized in that, The row lock conflict handling operation also includes: For each data row in the row lock conflict handling record, if the DML transaction that locked the data row was successfully committed, then the row identifier of the data row is deleted from the row lock conflict handling record. If the DML transaction that locks the data row fails to commit, then when it is determined that the full data has been updated based on the data row, the row identifier of the data row is deleted from the row lock conflict handling record.

5. The method according to any one of claims 1 to 4, characterized in that, The step of determining the data to be backfilled based on the incremental data includes: The range of field values ​​in the target field within the data rows of the full dataset is defined as the data interval; the target field is the field in the data row that is related to the DDL transaction. The data interval is divided into multiple sub-intervals; For each sub-interval, the set of at least one data row belonging to the sub-interval in the incremental data is taken as the data to be backfilled; Each piece of data to be backfilled, obtained based on the incremental data, corresponds to a worker; each worker processes its corresponding piece of data to be backfilled in parallel.

6. The method according to any one of claims 1 to 4, characterized in that, The step of determining the full and incremental data corresponding to the data table in response to a Data Definition Language (DDL) transaction execution instruction for the data table includes: In response to receiving a DDL transaction execution instruction for a data table at a first moment, the data table is scanned, and the data object corresponding to the DDL transaction obtained at a second moment when the scan is completed is taken as the full data, while the data updated in the data table between the first moment and the second moment is taken as the incremental data.

7. The method according to any one of claims 1 to 4, characterized in that, Each data row in the incremental data includes a commit identifier; the commit identifier is used to indicate whether the data row has been committed successfully. The method further includes: For each data row in the incremental data, if the DML transaction that locks the data row has been committed and the commit result is successful, or the data row has been committed through a DDL transaction, then the commit identifier of the data row is determined to be completed. If the commit identifier of each data row in the incremental data is "commit complete", then it is determined that each data row in the incremental data has been committed.

8. A data processing apparatus, characterized in that, include: The module for determining the data to be backfilled is used to determine the full data and incremental data corresponding to the data table in response to the Data Definition Language (DDL) transaction execution command for the data table. Based on the incremental data, determine the data to be backfilled; The data to be backfilled is part or all of the data rows in the incremental data; The first row lock processing module is used to determine the first data based on the data to be backfilled, wherein, for each data row of the data to be backfilled, if the data row is locked by a Data Manipulation Language (DML) transaction, the first data does not include the data row; if the data row is not locked by a DML transaction, the first data includes the data row. The update module is used to update the full data based on the first data, and to take the data rows in the full data that have been updated based on the first data as the second data; The second row lock processing module is used to determine the third data based on the second data and submit the third data. For each data row of the second data, if the data row is locked by a DML transaction, the third data does not include the data row; if the data row is not locked by a DML transaction, the third data includes the data row. The commit module is used to determine that the DDL transaction has been committed if each data row in the incremental data has been committed. Specifically, for a data row locked by a DML transaction, if the row lock of the data row is released by the DML transaction, the commit result of the DML transaction is obtained. If the commit result is successful, it is determined that the data row has been committed. If the commit result is unsuccessful, the data row is re-entered as data to be backfilled.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory, characterized in that, The processor executes the computer program to implement the method according to any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements the method described in any one of claims 1 to 7.

11. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the method described in any one of claims 1 to 7.

Images