CN111290714A - Data reading method and device - Google Patents

Abstract

The embodiment of the application provides a data reading method and device, and relates to the technical field of distributed storage. The specific implementation scheme is as follows: determining that the identifier of the data page to be read is a first identifier from the computing node, the data page to be read is a sub data page of a first father data page in the computing node, and sending a data page reading request to the storage node, wherein the data page reading request comprises the first identifier; the storage node determines that a first data page identified as a first identifier in the storage node corresponds to a page splitting process, and sends a target data page to the slave computing node according to the occurrence time of the page splitting process, wherein the target data page is the first data page or the second data page. According to the data reading method and device, the parent data page and the child data page in the slave computing node can be matched, and therefore the fact that the slave computing node reads correct data from the storage node is guaranteed.

Description

Data reading method and device

technical field

The embodiments of the present application relate to computer technologies, and in particular, to a distributed storage technology.

Background technique

With the support of cloud computing technology and services, the scale of business has expanded rapidly, which has put forward higher requirements for the core infrastructure service built on the cloud - database service, so a new generation of cloud-native database architecture has emerged, which has greatly improved the cloud. Database service capabilities.

The cloud native database architecture includes master computing nodes, slave computing nodes, and storage nodes. The master computing node is responsible for reading and writing data, and the slave computing nodes can only read data. Among them, the data is no longer directly written to the storage node, but the main computing node generates the redo log, and transmits the redo log to the storage node, and the storage node replays the redo log into data. At the same time, the redo log is transmitted to the slave computing node, and when needed, the slave computing node replays the redo log into data to keep the data in the slave computing node cache up-to-date.

Since the storage node and the slave computing node play back redo logs independently to generate data, the update progress of the same data page may be inconsistent at a certain period of time. For example, the slave computing node needs to read the child data page of a parent data page. Since the update progress of the data pages between the storage node and the slave computing node is inconsistent, there may be the following situations: a page split related to child data pages occurs only in the storage node or the slave computing node, so that the slave computing node reads from the storage node to The child data pages may not match the parent data pages in the slave compute node, that is, the slave compute node may read incorrect data.

SUMMARY OF THE INVENTION

The embodiments of the present application provide a data reading method and apparatus, which can make the parent data page in the slave computing node match the child data page, that is, ensure that the computing node reads correct data from the storage node.

In a first aspect, an embodiment of the present application provides a data reading method, which is applied to a storage node. The method includes: receiving a data page reading request from a computing node, where the data page reading request includes a first identifier; The first data page identified as the first identifier in the storage node corresponds to a page splitting process; according to the occurrence timing of the page splitting process, a target data page is sent to the computing node, and the target data page is the target data page. the first data page or the second data page. Optionally, the first identifier is an identifier of a data page to be read determined by the computing node, and the data page to be read is a child data page of a first parent data page in the computing node.

In this aspect, the computing node is a slave computing node. In this solution, when a sub-data page of a certain data page needs to be read from the computing node, it can be determined whether the sub-data page corresponds to a page-splitting process according to the split information, so that if the sub-data page corresponds to a page-splitting process , according to the occurrence timing of the page splitting process, determine the correct read data page, so that the parent data page and the child data page in the slave computing node match each other, that is, the slave computing node can read correct data.

In a possible implementation manner, the storage node stores partial split information; the partial split information includes the identifier of the split data page corresponding to the partial page split process and the log sequence number LSN of the log that triggers the page split process, The split data pages corresponding to the partial page splitting process are stored in the storage node; and determining that the first data page identified as the first identifier in the storage node corresponds to a page splitting process includes: determining the The first identifier exists in the identifier of the split data page included in the partial split information.

In this solution, the specific implementation of determining whether a data page corresponds to a page splitting process through splitting information makes it simple and easy to implement determining whether a data page corresponds to a page splitting process.

In a possible implementation manner, the data page read request further includes a third LSN of the first parent data page; when the page splitting process occurs, the data page is sent to the computing node. Before the target data page, the method further includes: determining the page splitting process according to the first LSN of the log that triggers the page splitting process, the second LSN and the third LSN of the first data page in the storage node time of occurrence.

This solution provides a specific implementation for determining the occurrence timing of the page splitting process, that is, it is determined by the LSN of the corresponding log. Since the data is obtained from the log playback, the occurrence timing of the page splitting process is determined according to the size of the LSN of the corresponding log. more accurate.

In a possible implementation manner, the determining when the page splitting process occurs includes: if the third LSN is smaller than the first LSN and the first LSN is smaller than or equal to the second LSN, then determine that the page splitting process occurs after the storage node obtains the first parent data page; if the first LSN is smaller than the second LSN and the first LSN is smaller than the third LSN, then determine The page splitting process occurs before the storage node obtains the first parent data page; if the second LSN is less than the first LSN and the first LSN is less than or equal to the third LSN, determine The data playback speed of the storage node is slower than the data playback speed of the computing node and the page splitting process is pending in the storage node.

In a possible implementation manner, the page splitting process occurs after the storage node obtains the first parent data page; before sending the target data page to the computing node, the method further includes: sending the computing node to the computing node Send first information, where the first information is used by the computing node to determine a target data page; and receive a read request of the target data page from the computing node.

This embodiment provides a specific implementation of how to trigger the determination of the correct data page to be read from the computing node when the page splitting process corresponding to the first data page occurs after the storage node obtains the first parent data page .

In a possible implementation manner, the first information includes: a first LSN of a log that triggers the page splitting process and indication information, where the indication information indicates that the page splitting process occurs when the storage node obtains the after the first parent data page.

In a possible implementation manner, the page splitting process occurs before the storage node obtains the first parent data page, and the target data page is the first data page in the storage node.

In a possible implementation manner, the data playback speed of the storage node is slower than the data playback speed of the computing node, and the page splitting process is to occur in the storage node, and the target data page is the the first data page in a storage node; before sending the first data page identified as the first identifier to the computing node, further comprising: determining that the pair of storage nodes is the LSN as the first LSN The log playback is complete.

In a second aspect, an embodiment of the present application provides a data reading method, which is applied to a computing node. The method includes: determining an identifier of a data page to be read as a first identifier, and the data page to be read is the computing node. A child data page of the first parent data page in the node; send a data page read request to the storage node, where the data page read request includes a first identifier, and the first identifier is used by the storage node to determine that the identifier is the first identifier The occurrence timing of the page splitting process corresponding to the identified first data page and sending the target data page to the computing node according to the occurrence timing; receiving the target data page from the storage node, the target data page is the storage node the first data page or the second data page of the node.

In this aspect, the computing node is a slave computing node. In this solution, when the sub-data page of a certain data page needs to be read from the computing node, it can be determined whether the sub-data page corresponds to a page-splitting process according to the split information, so that there is a page-splitting process corresponding to the sub-data page Next, according to the occurrence timing of the page splitting process, determine the correct read data page, so that the parent data page and the child data page in the slave computing node match each other, that is, the slave computing node can read correct data.

In a possible implementation manner, before receiving the target data page from the storage node, the method further includes: receiving first information from the storage node, where the first information includes: a log for triggering the page splitting process the first log sequence number LSN and indication information, the indication information indicates that the page splitting process occurs after the storage node obtains the first parent data page; according to the first information, determine the target data page; The storage node sends a request to read the target data page.

This solution gives a solution on how to trigger the computing node to determine the target data page.

In a possible implementation manner, the determining the target data page according to the first information includes: determining, according to the first information, that there is no page corresponding to the first parent data page in the storage node splitting process; read a second parent data page from the storage node, the second parent data page is the first parent data page updated after the page splitting process occurs; Describe the target data page.

This solution can obtain the updated data page of the first parent data page—the second parent data page caused by the page splitting process corresponding to the first data page from the computing node, so that the correct to-be-read data page can be determined according to the second parent data page Take the data page—the target data page, so that the parent data page and the child data page in the slave computing node are matched with each other, and the correct data can be read from the computing node.

In a possible implementation manner, the determining the target data page according to the first information includes: determining, according to the first information, that there is a page splitting process corresponding to the first parent data page in the storage node ; Read each data page from the second parent data page to the target parent data page from the storage node, wherein the target parent data page does not correspond to a page splitting process and is located between the root data page and the second parent data page Or the target parent data page is the root data page, the second parent data page is the split data page of the first parent data page, and the second parent data page is the first data page. A parent data page; determining the target data page according to each data page from the second parent data page to the target parent data page. It can be understood that the identifier of the second parent data page is also the second identifier.

This solution can make each data page updated due to the page splitting process corresponding to the first data page obtained from the computing node - each data page from the second parent data page to the target parent data page, so that the data pages can be obtained according to the second data page. Each data page from the parent data page to the target parent data page determines the correct data page to be read—the target data page, so that the parent data page and the child data page in the slave computing node match each other, and the correct data page can be read from the computing node. data.

In a possible implementation manner, the computing node stores full amount of split information, and the full amount of split information includes the identifier of the split data page corresponding to each page split process and the LSN of the log that triggers each page split process; Determining, according to the first information, that there is a page splitting process corresponding to the first parent data page in the storage node, comprising: determining, according to the indication information, among the identifiers of the split data pages included in the full split information The LSN that has the second identifier and triggers the corresponding page splitting process is the first LSN, and the second identifier is the identifier of the first parent data page.

This solution provides a specific implementation for determining that the first parent data page in the storage node corresponds to a page splitting process, and the network overhead in this solution is less.

In a possible implementation manner, the computing node does not store the full amount of split information, and the management node stores the full amount of split information; the full amount of split information includes the identifier of the split data page corresponding to each page split process and the LSN of the log that triggers each page splitting process; the determining, according to the first information, that the first parent data page in the storage node corresponds to a page splitting process, including: according to the indication information, reporting to the management The node sends a query request, the query request includes the first LSN and the second identifier, the query request instructs the management node to determine the first parent data in the storage node according to the full split information Whether a page corresponds to a page splitting process; receiving a query result from the management node, the query result indicating that the first parent data page in the storage node corresponds to a page splitting process.

This solution provides another specific implementation of determining that the first parent data page in the storage node corresponds to a page splitting process. In this solution, the storage space of the slave computing node can be saved.

In a third aspect, an embodiment of the present application provides a data reading method, which is applied to a computing node. The method includes: determining an identifier of a data page to be read as a first identifier, and the data page to be read is the computing node. the child data page of the first parent data page in the node; determine that the first data page marked as the first identifier in the storage node corresponds to a page splitting process; determine the target data page according to the occurrence timing of the page splitting process; The target data page is read from the storage node.

In this aspect, the computing node is a slave computing node. In this solution, when the sub-data page of a certain data page needs to be read from the computing node, it can be determined whether the sub-data page corresponds to a page-splitting process according to the split information, so that there is a page-splitting process corresponding to the sub-data page Next, according to the occurrence timing of the page splitting process, determine the correct read data page, so that the parent data page and the child data page in the slave computing node match each other, that is, the slave computing node can read correct data.

In a possible implementation manner, the computing node stores full split information, and the full split information includes the identifier of the split data page corresponding to each page split process and the LSN of the log that triggers each page split process; Determining that the first data page identified as the first identification in the storage node corresponds to a page splitting process includes: determining that the first identification exists in the identification of the split data page included in the full amount of splitting information.

In this solution, it is determined by the split information that the first data page marked as the first identifier in the storage node corresponds to a page splitting process, which is simple and easy to implement, and has low network overhead.

In a possible implementation manner, the computing node does not store the full amount of split information, the management node stores the full amount of split information, and the full amount of split information includes the split data pages corresponding to each page split process. The LSN of the log that identifies and triggers the splitting process of each page;

In this solution, it is determined through the split information that the first data page identified as the first identifier in the storage node corresponds to a page split process, which is simple and easy to implement.

In a possible implementation manner, before determining the target data page according to the occurrence timing of the page splitting process, the method further includes: according to the first LSN of the log that triggers the page splitting process, all the data in the storage node The second LSN of the first data page and the third LSN of the first parent data page in the computing node are used to determine the occurrence timing of the page splitting process.

This solution provides a specific implementation for determining the occurrence timing of the page splitting process, that is, it is determined by the LSN of the corresponding log. Since the data is obtained from the log playback, the occurrence timing of the page splitting process is determined according to the size of the LSN of the corresponding log. more accurate.

In a possible implementation manner, the determining when the page splitting process occurs includes: if the third LSN is smaller than the first LSN and the first LSN is smaller than or equal to the second LSN, then determine that the page splitting process occurs after the storage node obtains the first parent data page; if the first LSN is smaller than the second LSN and the first LSN is smaller than the third LSN, then determine The page splitting process occurs before the storage node obtains the first parent data page; if the second LSN is smaller than the first LSN, and the first LSN is smaller than or equal to the third LSN, determine The data playback speed of the storage node is slower than the data playback speed of the computing node and the page splitting process is pending in the storage node.

In a possible implementation manner, if the page splitting process occurs after the storage node obtains the first parent data page, the determining the target data page includes: determining that the storage node is in the storage node The first parent data page does not correspond to a page splitting process; the second parent data page is read from the storage node, and the second parent data page is the first parent data page updated after the page split occurs; The second parent data page determines the target data page.

This solution enables to obtain the updated data page—the second parent data page caused by the page splitting process corresponding to the first data page from the computing node, so that the correct data page to be read—target data can be determined according to the second parent data page page, so that the parent data page and the child data page in the slave computing node match each other, and the slave computing node can read correct data.

In a possible implementation manner, if the page splitting process occurs after the storage node obtains the first parent data page, determining the target data page according to the occurrence timing of the page splitting process includes: determining In the storage node, the first parent data page corresponds to a page splitting process; each data page from the second parent data page to the target parent data page is read from the storage node, wherein the target parent data page does not correspond to a page splitting process; Page splitting process and located between the root data page and the second parent data page or the target parent data page is the root data page, and the second parent data page is the split of the first parent data page A data page and the second parent data page is a parent data page of the first data page; the target data page is determined according to each data page from the second parent data page to the target parent data page.

This solution can make each data page updated due to the page splitting process corresponding to the first data page obtained from the computing node - each data page from the second parent data page to the target parent data page, so that the data pages can be obtained according to the second data page. Each data page from the parent data page to the target parent data page determines the correct data page to be read—the target data page, so that the parent data page and the child data page in the slave computing node match each other, and the correct data page can be read from the computing node. data.

In a possible implementation manner, if the page splitting process occurs before the storage node obtains the first parent data page, the determining the target data page includes: determining the The first data page is the target data page.

In a possible implementation manner, if the data playback speed of the storage node is slower than the data playback speed of the computing node and the page splitting process in the storage node is about to occur, the determining the target data page includes: determining the storage node The log playback of the first LSN is completed; the first data page in the storage node is determined as the target data page.

In a fourth aspect, an embodiment of the present application provides a data reading device, including: a transceiver module for receiving a data page reading request from a computing node, where the data page reading request includes a first identifier; a processing module for It is determined that the first data page marked as the first identifier in the data reading device corresponds to a page splitting process; the transceiver module is further configured to send the target data page to the computing node according to the occurrence timing of the page splitting process , the target data page is the first data page or the second data page.

In a possible implementation manner, the data reading device stores partial split information; the partial split information includes an identifier of a split data page corresponding to a partial page split process and a log sequence of a log that triggers the page split process number LSN, and the split data pages corresponding to the partial page splitting process are all stored in the data reading device; the processing module is specifically configured to determine that the split data pages included in the partial split information exist in the identifiers the first identifier.

In a possible implementation manner, the first identifier is an identifier of the data page to be read determined by the computing node, and the data page to be read is a child data page of the first parent data page in the computing node .

In a possible implementation manner, the data page read request includes the first identifier and the third LSN of the first parent data page in the calculation point; The occurrence timing of the splitting process, before sending the target data page to the computing node, the processing module is further configured to: according to the first LSN of the log triggering the page splitting process, the first LSN in the data reading device The second LSN and the third LSN of the data page determine the occurrence timing of the page splitting process.

In a possible implementation manner, the processing module is specifically configured to: determine the page split if the third LSN is smaller than the first LSN and the first LSN is smaller than or equal to the second LSN The process occurs after the data reading device obtains the first parent data page; if the first LSN is less than the second LSN and the first LSN is less than the third LSN, then the page is determined to be split The process occurs before the data reading device obtains the first parent data page; if the second LSN is less than the first LSN and the first LSN is less than or equal to the third LSN, determining the The data playback speed of the data reading device is slower than the data playback speed of the computing node and the page splitting process is to take place in the data reading device.

In a possible implementation manner, the page splitting process occurs after the data reading device obtains the first parent data page; before the transceiver module sends the target data page to the computing node, the The transceiver module is further configured to: send first information to the computing node, where the first information is used by the computing node to determine the target data page to be read; receive the target data from the computing node page read request.

In a possible implementation manner, the first information includes: a first LSN of a log that triggers the page splitting process and indication information, where the indication information indicates that the page splitting process occurs in the data reading device After getting the first parent data page.

In a possible implementation manner, the page splitting process occurs before the data reading device obtains the first parent data page, and the target data page is the first parent data page in the data reading device data page.

In a possible implementation, the data playback speed of the data reading device is slower than the data playback speed of the computing node and the page splitting process is to occur in the data reading device, the target data The page is the first data page in the data reading device. Before the transceiver module sends the first data page to the computing node, the processing module is further configured to: determine that the data reading device has finished playing back the log whose LSN is the first LSN.

In a fifth aspect, an embodiment of the present application provides a data reading device, comprising: a processing module configured to determine an identifier of a data page to be read as a first identifier, and the data page to be read is the data reading device The child data page of the first parent data page in the data page; the transceiver module is configured to send a data page read request to the storage node, where the data page read request includes the first identifier, and the first identifier is used for the The storage node determines the occurrence timing of the page splitting process corresponding to the first data page identified as the first identification, and sends the target data page to the data reading device according to the occurrence timing; The storage node receives a target data page, where the target data page is the second data page or the first data page.

In a possible implementation manner, before the transceiver module receives the target data page from the storage node: the transceiver module is further configured to receive first information from the storage node, where the first information includes : the first log sequence number LSN and indication information of the log that triggers the page splitting process, the indication information indicates that the page splitting process occurs after the storage node obtains the first parent data page; the processing module is further configured to determine a target data page according to the first information; the transceiver module is further configured to send a request for reading the target data page to the storage node.

In a possible implementation manner, the processing module is specifically configured to: determine, according to the first information, that the first parent data page in the storage node does not correspond to a page splitting process; read from the storage node A second parent data page, the second parent data page is the first parent data page updated after the page splitting process occurs; the target data page is determined according to the second parent data page.

In a possible implementation manner, the processing module is specifically configured to: determine, according to the first information, that there is a page splitting process corresponding to the first parent data page in the storage node; read the second data page from the storage node Each data page from the parent data page to the target parent data page, wherein the target parent data page does not correspond to a page splitting process and is located between the root data page and the second parent data page or the target parent data page is the root data page, the second parent data page is a split data page of the first parent data page, and the second parent data page is a parent data page of the first data page; Each data page from two parent data pages to the target parent data page is determined to determine the target data page.

In a possible implementation manner, the data storage device stores full amount of split information, and the full amount of split information includes an identifier of a split data page corresponding to each page split process and an LSN of a log that triggers each page split process; The processing module is specifically configured to: determine, according to the first information, that the second identifier exists in the identifier of the split data page included in the full split information and the LSN that triggers the corresponding page splitting process is the first identifier LSN, the second identifier is the identifier of the first parent data page.

In a possible implementation manner, the data storage device does not store the full amount of split information, and the management node stores the full amount of split information; the full amount of split information includes the split data pages corresponding to each page split process. an LSN that identifies and triggers the log of each page splitting process; the processing module is specifically configured to: control the transceiver module to send a query request to the management node according to the indication information, where the query request includes the first LSN and all the second identifier, the query request instructs the management node to determine whether there is a page splitting process corresponding to the first parent data page in the storage node according to the full split information; The query result of the management node, it is determined that the first parent data page in the storage node corresponds to a page splitting process, and the query result indicates that the first parent data page in the storage node corresponds to a page splitting process.

In a sixth aspect, an embodiment of the present application provides a data reading device, comprising: a processing module configured to determine an identifier of a data page to be read as a first identifier, and the data page to be read is the data reading device The child data page of the first parent data page in the storage node; determine that the first data page marked as the first identifier in the storage node corresponds to a page splitting process; according to the occurrence timing of the page splitting process, determine the target data page; from The storage node reads the target data page.

In a possible implementation manner, the data reading device stores full split information, and the full split information includes an identifier of a split data page corresponding to each page split process and an identifier of a log that triggers each page split process. LSN; the processing module is specifically configured to: determine that the first identifier exists in the identifiers of the split data pages included in the full split information.

In a possible implementation manner, it further includes a transceiver module; the data reading device does not store full split information, the management node stores full split information, and the full split information includes each page split process The identifier of the corresponding split data page and the LSN of the log that triggers the splitting process of each page; the processing module is specifically configured to control the transceiver module to send a query request to the management node, and the query request includes the first identifier, The query request instructs the management node to determine, according to the full split information, that the first data page corresponds to a page splitting process in the storage node; The first data page corresponds to a page splitting process in the storage node, and the query result indicates that the first data page corresponds to a page splitting process in the storage node.

In a possible implementation manner, before the processing module determines the target data page according to the occurrence timing of the page splitting process, the processing module is further configured to: according to the first log of triggering the page splitting process The LSN, the second LSN of the first data page in the storage node, and the third LSN of the first parent data page in the data reading device determine the occurrence timing of the page splitting process.

In a possible implementation manner, the processing module is specifically configured to: determine the page split if the third LSN is smaller than the first LSN and the first LSN is smaller than or equal to the second LSN The process occurs after the storage node obtains the first parent data page; if the first LSN is smaller than the second LSN and the first LSN is smaller than the third LSN, it is determined that the page splitting process occurs Before the storage node obtains the first parent data page; if the second LSN is less than the first LSN, and the first LSN is less than or equal to the third LSN, determine the data of the storage node The playback speed is slower than the data playback speed of the data reading device and the page splitting process is to take place in the storage node.

In a possible implementation manner, if the page splitting process occurs after the storage node obtains the first parent data page, the processing module is specifically configured to: determine the first parent data page in the storage node. A parent data page does not correspond to a page splitting process; the second parent data page is read from the storage node, and the second parent data page is the first parent data page updated after the page split occurs; according to the second The parent data page determines the target data page.

In a possible implementation manner, if the page splitting process occurs after the storage node obtains the first parent data page, the processing module is specifically configured to: determine the first parent data page in the storage node The data page corresponds to a page splitting process; each data page from the second parent data page to the target parent data page is read from the storage node, wherein the target parent data page does not correspond to a page splitting process and is located between the root data page and the Between second parent data pages or the target parent data page is the root data page, the second parent data page is a split data page of the first parent data page, and the second parent data page is The parent data page of the first data page; the target data page is determined according to each data page from the second parent data page to the target parent data page.

In a possible implementation manner, if the page splitting process occurs before the storage node obtains the first parent data page, the processing module is specifically configured to: determine the first data in the storage node page is the target data page.

In a possible implementation manner, if the data playback speed of the storage node is slower than the data playback speed of the data reading device and the page splitting process in the storage node is about to occur, the processing module is specifically configured to: determine the The storage node finishes replaying the log of the first LSN; the first data page in the storage node is determined as the target data page.

In a seventh aspect, an embodiment of the present application provides an electronic device, comprising: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores data that can be processed by the at least one processor instructions executed by a processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the first aspect and the method described in any possible design of the first aspect or to perform the second aspect and the The method described in any possible design of the second aspect or perform the method described in the third aspect and any possible design of the third aspect.

In an eighth aspect, the present application provides a non-transitory computer-readable storage medium storing computer instructions, the computer instructions being used to cause the computer to execute the method described in the first aspect and any possible design of the first aspect or Perform the method described in the second aspect and any possible design of the second aspect or perform the method described in the third aspect and any possible design of the third aspect.

An embodiment in the above application has the following advantages or beneficial effects: the parent data page in the slave computing node can be matched with the child data page, that is, it is ensured that the computing node reads correct data from the storage node. Because by determining whether the first data page identified as the first identifier in the storage node corresponds to a page splitting process (the first identifier is the identifier of the data page to be read initially determined by the computing node), if so, then split according to the page The timing of the process determines the correct data page to be read, and reads the correct data page from the storage node; therefore, it overcomes the inconsistency in the speed of replaying the log into data from the computing node and the storage node in the prior art. When the node reads data from the storage node, there may be a technical problem that the parent data page in the slave computing node does not match the child data page. Ensure that the parent data page in the slave computing node matches the child data page, that is, ensure that the slave data page matches the child data page. The technical effect that the computing node reads the correct data from the storage node.

Other effects of the above-mentioned optional manners will be described below with reference to specific embodiments.

Description of drawings

The accompanying drawings are used for better understanding of the present solution, and do not constitute a limitation to the present application. in:

1 is a schematic structural diagram of a second-order B-tree provided by an embodiment of the present application;

2 is a schematic structural diagram of a multi-order B-tree provided by an embodiment of the present application;

3 is a schematic diagram of a page splitting process of a B-tree provided by an embodiment of the present application;

4 is a schematic structural diagram of a B+ tree provided in an embodiment of the present application;

5 is a schematic diagram of a page splitting process of a B+ tree provided by an embodiment of the present application;

FIG. 6 is a system architecture diagram provided by an embodiment of the present application;

7 is a schematic diagram of a data reading scenario provided by an embodiment of the present application;

FIG. 8 is a flowchart 1 of a data acquisition method provided by an embodiment of the present application;

9 is a second flowchart of a data acquisition method provided by an embodiment of the present application;

10 is a schematic structural diagram of a data acquisition apparatus provided by an embodiment of the present application;

FIG. 11 is a block diagram of an electronic device used to implement the data acquisition method of the embodiment of the present application.

Detailed ways

Exemplary embodiments of the present application are described below with reference to the accompanying drawings, which include various details of the embodiments of the present application to facilitate understanding, and should be considered as exemplary only. Accordingly, those of ordinary skill in the art will recognize that various changes and modifications of the embodiments described herein can be made without departing from the scope and spirit of the present application. Also, descriptions of well-known functions and constructions are omitted from the following description for clarity and conciseness.

In this application, "at least one" means one or more, and "plurality" means two or more. "And/or", which describes the relationship of the associated objects, indicates that there can be three kinds of relationships, for example, A and/or B, it can indicate that A exists alone, A and B exist at the same time, and B exists alone, where A, B can be singular or plural. The character "/" generally indicates that the associated objects are an "or" relationship. "At least one item(s) below" or similar expressions thereof refer to any combination of these items, including any combination of single item(s) or plural items(s). For example, at least one item (a) of a, b, or c can represent: a, b, c, a-b, a-c, b-c, or a-b-c, where a, b, c may be single or multiple . The terms "first", "second" and the like in this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence.

First, the elements involved in the present application will be described.

In some data storage scenarios, such as a distributed database, data is stored in the form of pages, and each data page can be 4k bytes (16k or any other size). Data is sequentially added to the data pages until the data fills up. In a database in which data is organized by B-tree or a variant of B-tree (such as B+ tree, B* tree), if data pages are filled, page splitting may occur, that is, a data page is split into two data pages, and new Data is inserted into the corresponding data pages in order.

In a B-tree or a variant of a B-tree, it includes non-leaf nodes and leaf nodes, and all non-leaf nodes have children. In this embodiment, the "son" of a non-leaf node is called a child of a non-leaf node. Node, non-leaf node is the "parent node" of its son.

The following is a brief description of the B-tree and the B+ tree.

1. Second-order B-tree, that is, binary search tree: (1) All non-leaf nodes have at most two child nodes (Left and Right); (2) Each node stores a keyword; (3) Non-leaf nodes The left pointer of a point points to a child node less than its key, and the right pointer points to a child node greater than its key. FIG. 1 is a schematic structural diagram of a B-tree according to an embodiment of the present application. Referring to Figure 1, each node corresponds to a data page, and each data page is framed by a square box; the bottom node is a leaf node, the rest of the nodes are non-leaf nodes, and the top node of non-leaf nodes is the root node. For example, node 101 is the parent node of node 102 and node 103, and node 102 and node 103 are child nodes of node 101. The data page corresponding to node 101 is the parent data page of the data page corresponding to node 102 and the data page corresponding to node 103, the data page corresponding to node 102 and the data page corresponding to node 103 are the data corresponding to node 101 Page's child data pages.

The search of the second-order B-tree starts from the root node. If the query keyword is equal to the node keyword, it will hit; otherwise, if the query keyword is smaller than the node keyword, it will enter the left child node. ; If the query keyword is larger than the node keyword, enter the right child node; if the pointer of the left child node or the right child node is empty, it will report that the corresponding keyword cannot be found.

2. Multi-order B-tree is a multi-way search tree (not binary). For M-order B-tree: (1) Any non-leaf node has at most M child nodes, and M>2; ( 2) The number of child nodes of the root node is [2, M]; (3) The number of child nodes of non-leaf nodes other than the root node is [M/2, M]; (4) Each node stores at least M/2-1 (rounded up) and at most M-1 keywords; (at least 2 keywords) (5) The number of keywords of non-leaf nodes is equal to the number of pointers to child nodes minus 1; (6) Keywords of non-leaf nodes: K ₁ , K ₂ ,...,K _M-1 , and K _i <K _i+1 ; that is, each node in the M-order B-tree has at most M-1 keys Word; (7) Pointers of non-leaf nodes: P[1], P[2],...,P[M], where P[1] points to the subtree whose keyword is less than K ₁ , and P[M] points to The subtree whose key is greater than K _M-1 , other P[i] points to the subtree (8) whose key belongs to (K _i-1 , K _i ), and all leaf nodes are located at the same level. When M=3, a schematic diagram of a structure of a multi-order B-tree is shown in FIG. 2 . Referring to Figure 2, each node corresponds to a data page, and each data page is framed by a square frame; the bottom node is a leaf node, the rest of the nodes are non-leaf nodes, and the top node of non-leaf nodes is the root node. For example, node 201 is the parent node of node 202 , node 203 and node 204 , and node 202 , node 203 and node 204 are child nodes of node 201 . The data page corresponding to node 201 is the parent data page of the data page corresponding to node 202, the data page corresponding to node 203, and the corresponding data page of node 204, the data page corresponding to node 202, the data page corresponding to node 203 The data page and the data page corresponding to the node 204 are child data pages of the data page corresponding to the node 201 .

The search of a multi-order B-tree starts from the root node, and performs a binary search on the (ordered) sequence of keywords in the node. If it hits, it ends, otherwise it enters the child node of the range to which the query keyword belongs; repeat until all The corresponding child node pointer is empty, or is already a leaf node.

The following takes the splitting of a fifth-order B-tree as an example to describe the page splitting process involved in the embodiment of the present application.

FIG. 3 is a schematic diagram of a page splitting process of a B-tree according to an embodiment of the present application.

As shown in Figure A in Figure 3, insert 39 in the empty tree (that is, insert data whose keyword key is 39, and insert "Y" in the embodiment of the present application to insert a data record whose keyword is Y), At this time, the root node includes a keyword, and the root node is also a leaf node. Referring to Figure B in Figure 3, continue to insert 22, 97 and 41, at this time the root node includes 4 keys (ie, includes 4 data records, each data record corresponds to a key). Referring to Figure C in Figure 3, continue to insert 53. After the insertion of 53, the maximum number of keywords allowed by the node exceeds 4, and the page is split with 41 as the center. After the split, as shown in Figure D in Figure 3, where, The identification of the data page including the data records with keys 22 and 39 is the same as the identification of the data page including the data records 39, 22, 41 and 97 before insertion 53.

Inserting 13, 21, 40 in sequence will also cause splitting, as shown in Figure E in Figure 3, and then insert 30, 27, 33, 36, 35, 34, 24, 29 in sequence, as shown in Figure F in Figure 3. Show. As shown in the G diagram in Figure 3, continue to insert 26. The node where 26 is located contains more than 4 keywords. It is necessary to split the page with 27 as the center, and carry 27 to the parent node. The result of the split As shown in the H diagram in Figure 3, the identification of the page including the key words 24 and 26 is the same as the identification of the data page including the data records of 24, 26, 29 and 30 before inserting 26; The node also needs to perform page splitting. The result of splitting is shown in Figure I in Figure 3, which includes the identifiers of the data pages of the data records with keywords 22 and 27 and the data pages including 22, 33, 36 and 41 before inserting 27. The data pages of the data records have the same identification.

3. B+ tree: B+ tree is a variant of B tree and a multi-way search tree: its definition is basically the same as that of B tree, except for the following differences: (1) Child node pointers of non-leaf nodes The same as the number of keywords, the non-leaf node child node pointer P[i] points to the child node whose keywords belong to [K _i ,K _i+1 ]; (3) All leaf nodes add a chain pointer; ( 4) All keywords appear in leaf nodes. In addition, the B+ tree also has the following characteristics: (1) all keywords appear in the linked list of leaf nodes (dense index), and the keywords in the linked list are just in order; (2) it is impossible to search in the Non-leaf node hit: This is because the non-leaf node is equivalent to the index (sparse index) of the leaf node, and the leaf node is equivalent to the data layer that stores data.

In this embodiment, for the convenience of expression, although no data is stored in the non-leaf nodes in the B+ tree, since all keywords appear in the leaf nodes, in this embodiment, it is also considered that the non-leaf nodes in the B+ tree Each non-leaf node corresponds to a data page, that is, each node corresponds to a data page.

FIG. 4 is a schematic structural diagram of a B+ tree provided by an embodiment of the present application, as shown in FIG. 4 . Referring to Figure 4, the bottom node is a leaf node, the rest of the nodes are non-leaf nodes, and the top node of the non-leaf nodes is the root node. For example, node 401 is the parent node of node 402 , node 403 and node 404 , and node 402 , node 403 and node 404 are child nodes of node 401 . The data page corresponding to node 401 is the parent data page of the data page corresponding to node 402, the data page corresponding to node 403, and the data page corresponding to node 404, the data page corresponding to node 402, the data page corresponding to node 403 The data page and the data page corresponding to the node 404 are child data pages of the data page corresponding to the node 401 .

The B+ tree in FIG. 4 has the same number of keywords as the number of child nodes, and is a B+ tree of order 4. In another way, the number of keys of a B+ tree is one less than the number of child nodes.

The following takes the splitting of a fifth-order B+ tree as an example to describe the page splitting process involved in the embodiments of the present application.

FIG. 5 is a schematic diagram of a page splitting process of a B+ tree provided by an embodiment of the present application.

As shown in Figure A in Figure 5, 5 is inserted into the empty tree. At this time, the root node includes a keyword, and the root node is also a leaf node. Referring to Figure B in Figure 5, continue to insert 8, 10 and 15, at this time the root node includes 4 keywords. Referring to Figure C in Figure 5, 16 is continued to be inserted. After 16 is inserted, the maximum number of keywords allowed by the node is 4, so page splitting is performed. When the leaf node is split, the split left node has 2 data records, the right 3 data records, and the middle keyword becomes the keyword in the index node. After splitting, as shown in Figure D in Figure 5, where, The identification of the data page including the data records with keys 5 and 8 is the same as the identification of the data page including the data records 5, 8, 10 and 15 before insertion 16.

As shown in Figure E in Figure 5, 17 is then inserted. As shown in Figure 5F, continue to insert 18. The node where 18 is located contains more than 4 keywords, and page splitting is required. The split left node has 2 data records, the right node has 3 data records, and the keyword 16 Carry into the parent node (index type), the result after splitting is shown in Figure G in Figure 5, which includes the identifiers of the data pages of the data records with keywords 10 and 15 and before inserting 18, including 10, 15, The data pages of data records 16 and 17 have the same identification.

After inserting some data, a B+ tree as shown in the H diagram in Figure 5 is obtained. Next, as shown in Figure I in Figure 5 and Figure J in Figure 5, continue to insert 7, the node where 7 is located contains more than 4 keywords, and page splitting needs to be performed, and the split left node 2 data record, right node 3 data records, the keyword 7 is carried to the parent node, which includes the identification of the data page of the data records with the keywords 5 and 6 and the data records including 5, 6, 8 and 9 before inserting 7 The identifiers of the data pages are the same; after the carry, the current root node also needs to be split, and the result of the split is shown in the K diagram in Figure 5, which includes the identifiers and insertions of the data pages of the data records with keywords 7 and 10. The identification of the data pages before 7 including the data records 10, 16, 18 and 20 is the same.

After the B-tree and the B+ tree are described, the system architecture involved in the present application will be described next.

FIG. 6 is a system architecture diagram provided by an embodiment of the present application. Referring to FIG. 6 , the system architecture of this embodiment includes a computing layer and a distributed storage layer, and may also include a management layer. The computing layer may include multiple nodes, and the multiple nodes include a master computing node and a slave computing node. The master computing node is used to read and write data, and other slave computing nodes can read data from the distributed storage layer. The distributed storage layer includes multiple storage nodes for storing data. The management layer includes one or more management nodes.

In the above system architecture, data is no longer directly written to the main computing node for local storage, nor directly written to the storage node, but the main computing node generates redo logs and transmits the redo logs to the storage nodes. The storage node replays the redo log into data. At the same time, the redo log is transmitted to the slave computing node. If necessary, the slave computing node will replay the redo log into data to keep the data in the slave computing node cache up-to-date. Among them, the redo log can be identified by a unique value, which is called the log sequence number (log sequence number, LSN for short). The LSN of the log generated first is smaller than the LSN of the log generated later.

That is, the data in the data pages organized by B-tree or B-tree variants from the computing node and the storage node are all obtained by the redo log playback. If the data 1 is played back by the redo log 1, the data 1 and the redo log 1 corresponds. If the LSN of the first log in the redo logs corresponding to the data included in the data page is the largest, the LSN of the first redo log is the LSN of the data page. Correspondingly, if the LSN of the second log is the largest among the redo logs corresponding to the data records that trigger the above-mentioned page splitting process, the second redo log is the redo log that triggers the above-mentioned page splitting process.

As mentioned above, the storage node and the slave computing node play back the redo log independently to generate data, so it is possible that the update progress of the same data page is inconsistent at a certain period of time. For example, the slave computing node needs to read the child data of a parent data page. page, and due to the inconsistent update progress of data pages between the storage node and the slave computing node, there may be the following situations: a page split related to child data pages occurs only in the storage node or slave computing node, so that the slave computing node and the storage node are split. The read child data page may not match the parent data page in the slave compute node, that is, the slave compute node may read incorrect data. For example, both the slave computing node and the storage node organize data or data pages in the form of a 5th-order B-tree. As shown in (a) in Figure 7, the slave computing node stores data pages 601, but no data pages are stored. The sub-data page of 601, the sub-data page is stored in the storage node, and the sub-data page of the data page 601 needs to be read from the computing node. If the B-tree in the storage node is as shown in (b) of FIG. 7 , the child data pages of the data page 601 stored in the storage node at this time match the data page 601 stored from the computing node. However, if the playback speed of the storage node is faster than the playback speed of the slave computing node, as shown in (c) to (e) in Figure 7, due to the insertion of 26, a page split occurs in the storage node, and the final storage node The B-tree is shown in (e) of Figure 7. At this time, the slave computing node cannot read the child data page that matches the parent data page 601 in the slave computing node from the storage node, because the storage node The data page shown in 601 no longer exists in the B-tree.

In order to solve the above technical problems, the data acquisition method in this embodiment is proposed. The data acquisition method of the present application will be described below using specific embodiments.

First, a specific embodiment is used to describe the data reading method corresponding to the split information stored in the storage node and the full amount of split information stored in the computing node and/or the management node.

FIG. 8 is a flowchart 1 of a data acquisition method provided by an embodiment of the present application. Referring to FIG. 8, the method of this embodiment includes:

Step S801 , the slave computing node determines that the identifier of the data page to be read is the first identifier, and the data page to be read is the child data page of the first parent data page in the slave computing node.

The first parent data page is stored in the computing node, and when the child data page of the first parent data page needs to be read, the identifier of the child data page is determined as the first identifier.

Step S802: Send a data page read request from the computing node to the storage node, where the data page read request includes the first identifier.

Determine from the computing node whether the sub-data page identified as the first identification is included in its cache, and if so, obtain the sub-data page from the cache and apply the sub-data page. Wherein, the application of the sub-data page may be, for example, sent to a terminal device to display the data corresponding to the sub-data page.

If the computing node determines that the sub-data page is not included in its cache, it sends a data page read request to the storage node, wherein the data page read request indication includes the first identifier. In one manner, the data page read request further includes the LSN of the first parent data page in the slave computing node (for convenience of subsequent descriptions, the LSN of the first parent data page is hereinafter referred to as the third LSN).

Step S803, the storage node determines that the first data page identified as the first identifier in the storage node corresponds to a page splitting process.

The storage node receives the data page read request from the computing node, and determines whether the first data page marked as the first identifier in the storage node corresponds to a page splitting process, if not, the storage node sends the stored identifier as the first identifier. to the slave computing node; if yes, execute step S804.

In one way, the storage node determines whether the first data page identified as the first identifier in the storage node corresponds to a page splitting process, including: the storage node determines, according to the split information, the first data page identified as the first identifier in the storage node. Whether a data page corresponds to a page splitting process. The split information includes the identifier of the split data page corresponding to the page split process and the LSN of the redo log that triggers the page split process; and may also include the identifier of the parent data page of the split data page.

Table 1 shows at least part of the content included in the split information.

Table 1

Referring to Table 1, the page splitting process is that the original data page C is split into a new data page C and a new data page D, the original data page C is split into a new data page C with the same identifier, and the parent data of the new data page C and the new data page D The page is P, and the LSN of the log that triggers this page splitting process is 24. As shown in Figure D and Figure E in Figure 3, after inserting 13, 21, 40 (assuming 40 is the last one of the 3 keywords inserted), data records including keywords 22, 39, 13, and 21 The data page is split into a data page of data records including keywords 13 and 21 and a data page of data records including keywords 39 and 40, and the data page of data records including keywords 22 and 41 is split into two data pages The page's parent data page.

That is, for a page splitting process, the splitting information may include the identifier of the split data page corresponding to the page splitting process and the LSN of the log that triggers the page splitting process, wherein the split data page corresponding to the page splitting process The identification of can include the identification of the two data pages (C and D above) involved in the page splitting process. In addition, the split information may further include the identifiers of the parent data pages of the two data pages.

If a page splitting process occurs again after a data page is split, the split information also includes the identifier of the split data page corresponding to the page splitting process that occurs again and the LSN of the log that triggers the page splitting process that occurs again. Correspondingly, at least part of the content of the split information can be shown in Table 2:

Table 2

Referring to Table 2, the page splitting process is that the original data page C is split into a new data page C and a new data page D. The original data page C has the same identifier as the split new data page C, and the new data page C and the new data page D have the same identifier. The parent data page is P, and the LSN of the log that triggers the page splitting process is 24. The new data page C is split into an updated data page C and a new data page D ₂ . The updated data page C has the same identifier as the new data page C, and the parent data page of the updated data page C and the new data page D ₂ is P , the LSN of the log that triggers this page splitting process is 24.

If a page splitting process causes its parent data page to also split, the splitting information also includes an identifier of the split data page corresponding to the page splitting process of the parent data page and the LSN of the log that triggers the page splitting process of the parent data page. If each page split results in the split of the parent data page at the same time, then the root data page will be uniformly cycled, and at least part of the corresponding split information can be shown in Table 3:

table 3

ID of the split data page ID of the split data page ID of the parent data page LSN of the log that triggered the page split C D P1 twenty four P1 P2 PP1 twenty four PP1 PP2 PP3 twenty four ... ... ... twenty four PPPPP1 PPPPP2 root twenty four

Therefore, if the storage node determines that the identifier of the split data page included in the split information has the first identifier, it is determined that the first data page corresponds to a page splitting process.

In addition, the split information can be divided into partial split information and full split information.

The full split information includes: the identifiers of the split data pages corresponding to all the page split processes and the LSN of the redo log that triggers each page split process; and may also include the identifiers of the parent data pages of each split data page. The full amount of split information may be stored in the slave computing node and/or the management node, and may also be stored in the storage node.

At least part of the full split information can be shown in Table 4:

Table 4

ID of the split data page ID of the split data page ID of the parent data page LSN of the log that triggered the page split 100 101 12 twenty four 110 111 15 39 201 202 18 89 210 211 19 99

The partial split information may include the identifier of the split data page corresponding to the partial page split process and the LSN of the redo log that triggers the partial page split process; and may also include the identifier of the parent data page of the split data page. The partial split information may be stored in the storage node. Accordingly, the split data pages corresponding to the partial page split process included in the partial split information stored in the storage node are stored in the storage node, that is, the split data pages included in the partial split information. The data page indicated by the identifier is stored in the storage node; in other words, the partial page splitting process included in the partial splitting information stored in the storage node is the page splitting of at least part of the data pages stored in the data pages of the storage node process.

The storage node can store the full amount of split information, and can also store part of the split information. When the partial split information is stored in the storage node, the storage space of the storage node can be saved, and the efficiency of determining whether the first data page corresponds to a page splitting process can be improved.

When at least part of the full split information is shown in Table 4, the partial split information may be as shown in Table 5 and Table 6:

table 5

Table 6

Step S804: The storage node sends a target data page to the slave computing node according to the occurrence timing of the page splitting process corresponding to the first data page, where the target data page is the first data page or the second data page in the storage node.

Wherein, before the storage node sends the target data page to the slave computing node according to the occurrence timing of the page splitting process corresponding to the first data page, the storage node further includes: determining the occurrence timing of the page splitting process corresponding to the first data page.

In one solution, the storage node determines the occurrence timing of the page splitting process corresponding to the first data page, including: according to the first LSN of the log that triggers the page splitting process, the first LSN of the data page marked as the first identifier in the storage node The second LSN and the third LSN of the first parent data page in the computing node determine the occurrence timing of the page splitting process corresponding to the first data page.

Wherein, if the third LSN is smaller than the first LSN and the first LSN is smaller than or equal to the second LSN, it is determined that the page splitting process corresponding to the first data page occurs after the storage node obtains the first parent data page. If the first LSN is smaller than the second LSN and the first LSN is smaller than the third LSN, it is determined that the page splitting process corresponding to the first data page occurs before the first parent data page is obtained from the storage node. If the second LSN is smaller than the first LSN and the first LSN is smaller than or equal to the third LSN, it is determined that the data playback speed of the storage node is slower than the data playback speed of the computing node, and the page splitting process corresponding to the first data page in the storage node is to be happens (is about to happen).

It can be understood that if the page splitting process corresponding to the first data page occurs before the storage node obtains the first parent data page, it means that after obtaining the first parent data page from the storage node, the first data page in the storage node does not The corresponding page splitting process, that is, the first data page marked as the first identifier in the storage node is a child data page that matches the first parent data page, and the storage node directly sends the data page marked as the first identifier to the slave computing node, It is possible to obtain correct data from the computing nodes. That is, at this time, the target data page is the data page identified as the first identification in the storage node.

If the occurrence timing of the page splitting process corresponding to the first data page includes: the data playback speed of the storage node is slower than the data playback speed of the slave computing node, and the page splitting process corresponding to the first data page is about to occur in the storage node, then determine After the storage node finishes replaying the log of the first LSN, it sends the data page identified as the first identification to the slave computing node. At this time, the target data page is the data page identified as the first identification in the storage node.

Among them, since the log of the first LSN is the log that triggers the page splitting process corresponding to the first data page, after the storage node finishes replaying the log of the first LSN, the page splitting process corresponding to the first data page is also completed. , sending the data page identified as the first identifier to the slave computing node, and the slave computing node can obtain the child data page matching the first parent data page, that is, the correct data can be obtained.

If the page splitting process corresponding to the first data page occurs after the storage node obtains the first parent data page, before the storage node sends the target data page to the slave computing node according to the occurrence timing of the page splitting process corresponding to the first data page , and also includes the following steps S805 to S808:

Step S805, the storage node sends the first information to the slave computing node.

The first information may include: the first LSN of the log that triggers the page splitting process corresponding to the first data page and indication information, where the indication information indicates that the page splitting process corresponding to the first data page occurs when the storage node obtains the first parent data page after.

Step S806, the slave computing node determines the target data page according to the first information.

In one solution, the slave computing node determines the target data page according to the first information, including the following a1 to a3:

a1. According to the first information, the slave computing node determines that there is no page splitting process corresponding to the first parent data page in the storage node.

If the full amount of split information is stored from the computing node, determining, according to the first information, that the first parent data page in the storage node does not correspond to a page split process, including: according to the indication of the indication information, judging the split data included in the full amount of split information Whether there is a second identifier in the identifier of the page and the LSN that triggers the corresponding page splitting process is the above-mentioned first LSN, the second identifier is the identifier of the first parent data page, and the obtained judgment result is no.

If the full amount of split information is not stored in the slave computing node and the full amount of split information is stored in the management node, the slave computing node determines, according to the first information, that the first parent data page in the storage node does not correspond to a page split process, including: The computing node sends a query request to the management node according to the instruction of the instruction information, the query request includes the second identifier of the first parent data page and the above-mentioned first LSN, and the query request instructs the management node to determine whether the first parent data page is based on the full split information. There is a page splitting process; the query result from the management node is received from the computing node, and the query result indicates that the first parent data page does not correspond to a page splitting process. After receiving the query request, the management node determines whether there is a second identifier in the identifiers of the split data pages included in the full split information and the LSN that triggers the corresponding page splitting process is the above-mentioned first LSN, and the obtained determination result is no.

a2. Read the second parent data page from the storage node from the computing node. The second parent data page is the first parent data page that is updated after the page splitting process corresponding to the first data page occurs, that is, the second parent data page marked as the second identifier in the storage node, and the second identifier is the first parent data page The ID of the page. It can be understood that the identifier of the second parent data page is also the second identifier.

Although there is no page splitting process corresponding to the first parent data page in the storage node, the first data page in the storage node corresponds to a page splitting process after the first parent data page is obtained from the storage node. Before the page splitting process corresponding to the page occurs, the parent data page corresponding to the data page identified as the first identifier is the first parent data page. After the page splitting process corresponding to the first data page occurs, the first parent data page will be The second parent data page is updated. Therefore, the computing node needs to read the second parent data page from the storage node, and the identifier of the second parent data page is the same as the identifier of the first parent data page. For example, as shown in Figures F to G in FIG. 5, after inserting 18, the data pages of the data records including the keywords 10, 15, 16, and 17 are split into the data pages of the data records including the keywords 10 and 15 and the data pages including the data records of the keywords 10 and 15. For the data pages of the data records of keywords 10, 16, and 17, the parent data page is updated from the data page of the data records including the keyword 10 to the data pages of the data records of the keywords 10 and 16.

Wherein, reading the second parent data page from the storage node from the computing node includes: sending a data read request from the computing node to the storage node, where the data read request includes the identifier of the first parent data page (that is, the above-mentioned second parent data page). identification), receiving the second parent data page from the storage node from the compute node.

a3. The slave computing node determines the target data page according to the second parent data page.

The target data page determined from the computing node according to the second parent data page may be the first data page identified as the first identifier in the storage node, or the storage node may be the second data page different from the first data page.

The target data page may be determined according to the second parent data page according to the current search method of the B-tree or a variant of the B-tree, which will not be repeated here.

In another solution, the slave computing node determines the target data page according to the first information, including the following b1-b3:

b1. According to the first information, the slave computing node determines that there is a page splitting process corresponding to the first parent data page in the storage node.

Wherein, the first data page corresponds to a page splitting process, and the first parent data page also corresponds to a page splitting process. A schematic diagram shown in Figure G to Figure I in FIG. 3 , or, Figure I to Figure 5 in FIG. 5 K is shown in Fig.

If the full amount of split information is stored in the computing node, then according to the first information, it is determined that the first parent data page in the storage node corresponds to a page split process, including: according to the indication of the indication information, judging the split data pages included in the full amount of split information Whether there is a second identifier in the identifier of , and the LSN that triggers the corresponding page splitting process is the above-mentioned first LSN, and the second identifier is the identifier of the first parent data page, and the obtained judgment result is yes.

If the full amount of splitting information is not stored in the slave computing node and the full amount of splitting information is stored in the management node, the slave computing node determines, according to the first information, that there is a page splitting process corresponding to the first parent data page in the storage node, including: The node sends a query request to the management node according to the instruction of the instruction information, the query request includes the second identifier of the first parent data page and the above-mentioned first LSN, and the query request instructs the management node to determine whether the first parent data page corresponds to the first parent data page according to the full split information There is a page splitting process; the query result from the management node is received from the computing node, and the query result indicates that the first parent data page corresponds to a page splitting process. After receiving the query request, the management node determines whether there is a second identifier in the identifiers of the split data pages included in the full split information and the LSN that triggers the corresponding page splitting process is the above-mentioned first LSN, and the obtained determination result is yes.

It can be understood that the first parent data page corresponds to a page splitting process, then the first parent data page is split into a second parent data page and a third parent data page, and the identifier of the second parent data page is the same as the first parent data page. The identifiers are the same, and the second parent data page is the parent data page of the data page after the first data page is split. If the first parent data page is the root data page before the first parent data page is split, a new root parent data page will be generated after the first parent data page is split, and the new root parent data page is the second parent data page and The parent data page of the third parent data page. If the first parent data page is not the root data page before the first parent data page is split, at least the parent data pages of the second parent data page and the third parent data page will be updated, and a page splitting process may also occur.

b2. Read each data page from the second parent data page to the target parent data page from the computing node from the storage node, wherein the target parent data page does not correspond to a page splitting process and is located between the root data page and the second parent data page Or the target parent data page is a root data page, the second parent data page is a split data page of the first parent data page, and the second parent data page is a parent data page of the first data page.

Specifically, after determining from the computing node that there is a page splitting process corresponding to the first parent data page in the storage node, continue to determine the parent data page of the second parent data page split from the first parent data page (hereinafter referred to as the fourth parent data page). data page) whether page splitting occurs (refer to the method for determining whether the first parent data page corresponds to a page splitting process), if the fourth parent data page does not correspond to a page splitting process, obtain the second parent data page and the fourth parent data page Page (the fourth parent data page is the target parent data page at this time), if the fourth parent data page corresponds to a page splitting process, continue to determine the parent data page of the fourth parent data page (hereinafter referred to as the fifth parent data page) Whether page splitting occurs; repeat the above process until it is determined that the target parent data page does not correspond to a page splitting process. It can be understood that there is a situation in which the target parent data page is the root data page corresponding to the root node.

b3. The computing node determines the target data page according to each data page from the second parent data page to the target parent data page.

Similarly, the target data page determined from the computing node according to the second parent data page may be the first data page identified as the first identifier in the storage node, or the storage node may be the second data page different from the first data page.

The target data page can be determined according to each data page from the second parent data page to the target parent data page according to the current search method of the B-tree or a variant of the B-tree, which will not be repeated here.

Step S807: Send a read request of the target data page from the computing node to the storage node.

Wherein, the read request of the target data page may include the identifier of the target data page.

Step S808, the storage node acquires the target data page according to the request for reading the target data page.

The storage node obtains the target data page according to the identifier of the target data page.

After the storage node obtains the target data page, it sends the target data page to the slave computing node, and receives the target data page from the computing node. The target data page matches the second parent data page obtained from the computing node or the second parent data page to Each data page of the target parent data page matches, and correct data can be obtained from the computer node.

In this embodiment, when the sub-data page of a certain data page needs to be read from the computing node, it can be determined whether the sub-data page corresponds to a page-splitting process according to the split information, so that the sub-data page corresponds to a page-splitting process. In this case, the correct read data page is determined according to the occurrence timing of the page splitting process, so that the parent data page and the child data page in the slave computing node match each other, that is, the slave computing node can read correct data.

Next, a specific embodiment is used to describe a data reading method corresponding to no split information stored in the storage node but full amount of split information stored in the computing node and/or the management node.

FIG. 9 is a second flowchart of a data reading method provided by an embodiment of the present application. Referring to FIG. 9 , the method of this embodiment includes:

Step S901, the slave computing node determines that the identifier of the data page to be read is the first identifier, and the data page to be read is the child data page of the first parent data page in the slave computing node.

The first parent data page is stored in the computing node, and when the child data page of the first parent data page needs to be read, the identifier of the child data page is determined as the first identifier. Determine from the computing node whether the sub-data page identified as the first identification is included in its cache, and if so, obtain the sub-data page from the cache and apply the sub-data page. Wherein, the application of the sub-data page may be, for example, sent to a terminal device to display the data corresponding to the sub-data page. If it is determined from the computing node that the sub-data page identified as the first identifier is not included in its cache, the computing node determines to read the sub-data page from the storage node.

Step S902: Determine from the computing node that the first data page identified as the first identifier in the storage node corresponds to a page splitting process.

In one approach, the full amount of split information is stored from the computing node. Correspondingly, determining from the computing node that there is a page splitting process corresponding to the first data page in the storage node includes: determining that the identifier of the split data page included in the full amount of splitting information has the first identifier.

This method can improve data reading efficiency and reduce network overhead.

In another way, the slave computing node does not store the full amount of split information, and the management node stores the full amount of split information. Correspondingly, determining from the computing node that the first data page corresponds to a page splitting process includes: sending a query request from the computing node to the management node, where the query request includes a first identifier, and the query request instructs the management node to determine the first data page according to the full amount of split information. Whether there is a page splitting process; the query result from the management node is received from the computing node, and the query result indicates that the first data page corresponds to a page splitting process. Wherein, after receiving the query request, the management node determines whether there is a first identifier in the identifiers of the split data pages included in the full split information, and the obtained determination result is yes.

This method can save the storage space of the slave computing nodes.

Step S903, the slave computing node determines the target data page according to the occurrence timing of the page splitting process corresponding to the first data page.

The specific implementation of determining the occurrence timing of the page splitting process corresponding to the first data page from the computing node refers to the specific implementation of determining the occurrence timing of the page splitting process corresponding to the first data page by the storage node in the embodiment shown in FIG. 8 .

If the page splitting process corresponding to the first data page occurs after the storage node obtains the first parent data page, in one manner, determining the target data page from the computing node includes: determining from the computing node the first parent data page in the storage node The data page does not correspond to a page splitting process; the second parent data page is read from the storage node, and the second parent data page is the first parent data page updated after the page splitting process corresponding to the first data page occurs; according to the second parent data page The data page determines the target data page. For the specific implementation of each step in this manner, refer to the description in the embodiment shown in FIG. 8 .

If the page splitting process corresponding to the first data page occurs after the storage node obtains the first parent data page, and the first data page is a child data page of the first parent data page, in one method, the target data is determined from the computing node. Pages, including: determining from the computing node that the first parent data page in the storage node corresponds to a page splitting process; reading the data pages from the second parent data page to the target parent data page from the storage node, wherein the target parent data page is not There is a page splitting process and is located between the root data page and the second parent data page or the target parent data page is the root data page, and the second parent data page is the split data page of the first parent data page and the second parent data page. The data page is the parent data page of the first data page; the target data page is determined according to each data page from the second parent data page to the target parent data page. For the specific implementation of each step in this manner, refer to the description in the embodiment shown in FIG. 8 .

If the page splitting process corresponding to the first data page occurs before the storage node obtains the first parent data page, determining the target data page includes: determining the first data page in the storage node as the target data page.

If the occurrence timing of the page splitting process corresponding to the first data page includes: the data playback speed of the storage node is slower than the data playback speed of the slave computing node and the page splitting process corresponding to the first data page in the storage node is about to occur, the process includes: determining The storage node finishes replaying the log of the first LSN; it is determined that the first data page in the storage node is the target data page.

Step S904, read the target data page from the computing node from the storage node.

In this embodiment, when the sub-data page of a certain data page needs to be read from the computing node, it can be determined whether the sub-data page corresponds to a page-splitting process according to the split information, so that the sub-data page corresponds to a page-splitting process. In this case, the correct read data page is determined according to the occurrence timing of the page splitting process, so that the parent data page and the child data page in the slave computing node match each other, that is, the slave computing node can read correct data.

To sum up, for the embodiment shown in FIG. 9 , if the full amount of split information is stored in the management node, but not in the slave computing node, and the storage node does not store the full amount of split information or part of the split information, the slave computing node needs to To read data from a storage node, it is necessary to request from the management node whether the data page to be read corresponds to a page splitting process, and the network overhead is large. An improved way is that in the embodiment shown in FIG. 9, the full amount of split information is stored in the slave computing node. In this case, the slave computing node does not need to request the management node whether the data page to be read corresponds to a page splitting process, reducing the need for page splitting. network overhead. Another improved way is that in the embodiment shown in FIG. 8 , the storage node stores partial split information. At this time, when the storage node receives a data page read request sent from the computing node, the storage node stores the partial split information according to the stored partial split information. Determine whether the data page to be read corresponds to a page splitting process, and the full splitting information will be used only when the data page to be read corresponds to a page splitting process and the page splitting process occurs at a certain timing, regardless of whether the full splitting information is stored from Computational nodes or management nodes have less network overhead than the scheme in which the full amount of splitting information is stored in the management node, and neither is stored in the slave computing nodes nor in the storage node, nor does the full amount of splitting information or part of the splitting information are stored.

Next, the creation and cleaning processes of split information are described with specific embodiments.

Since all write operations are performed on the main computing node, when a data page is split, all the involved data pages should be in the cache of the main computing node, so the main computing node stores the information of all relevant data pages, so , the splitting information can be created by the master computing node. In the initial process, the master computing node sends the newly created splitting information to other nodes, such as sending the full splitting information to the slave computing node or management node, and sending part of the splitting information to the storage node. . In the subsequent process, the master node sends the newly added split information to the node where the split information is stored, so as to update the split information stored in the node.

As the data increases, page splits will continue to occur, and the amount of information in the split information will increase, so we need to clean up the split information. The cleanup process can be controlled by the management node.

Among them, in the slave computing nodes and storage nodes, the playback of redo logs is played back in the order of LSN size, so logs whose LSN is smaller than the currently played back LSN will not be seen. Based on this fact, cleaning can be done according to the LSNs of the logs currently played back from the compute nodes and storage nodes. For example, in one solution, the management node determines the smaller LSN among the LSN of the latest replayed log from the computing node and the LSN of the latest replayed log of the storage node, and sends the smaller LSN to each node that stores the split information , so that each node that stores the split information deletes the information corresponding to the smaller LSN in the split information. For example, since the computing node has been applied to the log with an LSN of 100, and the storage node has been applied to the log with an LSN of 120, then we can clear the information of the page splitting process whose LSN is less than 100 in the log that triggers the page splitting process in the split information.

This embodiment provides a specific implementation of the generation and deletion of split information, which is used in the above-mentioned data reading process.

The data reading method in the embodiment of the present application has been described above, and the device involved in the embodiment of the present application will be described below.

FIG. 10 is a schematic structural diagram of a data reading apparatus provided by an embodiment of the present application. As shown in FIG. 10 , the data reading apparatus 1000 may be the above-mentioned slave computing node, or may be a component (eg, an integrated circuit, a chip, etc.) of the above-mentioned slave computing node. The data reading apparatus 1000 may also be the above storage node, or may be a component (eg, an integrated circuit, a chip, etc.) of the above storage node. The data reading apparatus 1000 may include: a processing module 1002 (processing unit). Optionally, a transceiver module 1001 (transceiver unit) and a storage module 1003 (storage unit) may also be included.

In a possible design, one or more modules as shown in FIG. 10 may be implemented by one or more processors, or by one or more processors and memory; or by one or more processors and a transceiver; or implemented by one or more processors, a memory, and a transceiver, which is not limited in this embodiment of the present application. The processor, memory, and transceiver can be set independently or integrated.

The data reading device has the function of implementing the slave computing node described in the embodiment of the present application. For example, the data reading device includes a module or unit corresponding to the slave computing node executing the steps involved in the slave computing node described in the embodiment of the present application. or means (means), the function or unit or means (means) can be implemented by software, or by hardware, or by executing corresponding software by hardware, or by a combination of software and hardware. For details, further reference may be made to the corresponding descriptions in the foregoing corresponding method embodiments.

Or the data reading device has the function of implementing the storage node described in the embodiments of the present application. For example, the data reading device includes modules or units corresponding to the storage node performing the steps involved in the storage node described in the embodiments of the present application. or means (means), the function or unit or means (means) can be implemented by software, or by hardware, or by executing corresponding software by hardware, or by a combination of software and hardware. For details, further reference may be made to the corresponding descriptions in the foregoing corresponding method embodiments.

Optionally, each module in the data reading apparatus 1000 in the embodiment of the present application may be used to execute the method described in the method embodiment of the present application.

In a first possible design, a data reading device 1000 may include a transceiver module 1001 and a processing module 1002 .

The transceiver module 1001 is configured to receive a data page read request from the computing node, the data page read request includes a first identifier; the processing module 1002 is configured to determine the first identifier identified as the first identifier in the data reading device A data page corresponds to a page splitting process; the transceiver module 1001 is further configured to send a target data page to the computing node according to the occurrence timing of the page splitting process, where the target data page is the first data page or the first data page Two data pages.

Optionally, the data reading device stores partial split information; the partial split information includes the identifier of the split data page corresponding to the partial page split process and the log sequence number LSN of the log that triggers the page split process, and the The split data pages corresponding to the partial page splitting process are all stored in the data reading device; the processing module 1002 is specifically configured to determine that there is the first split data page identifier included in the partial split information logo.

Optionally, the first identifier is an identifier of a data page to be read determined by the computing node, and the data page to be read is a child data page of a first parent data page in the computing node.

Optionally, the data page read request includes the first identifier and the third LSN of the first parent data page in the calculation point; in the transceiver module 1001, according to the occurrence of the page splitting process timing, before sending the target data page to the computing node, the processing module 1002 is further configured to: according to the first LSN of the log triggering the page splitting process, the data reading device of the first data page The second LSN and the third LSN determine the occurrence timing of the page splitting process.

Optionally, the processing module 1002 is specifically configured to: if the third LSN is smaller than the first LSN and the first LSN is smaller than or equal to the second LSN, determine that the page splitting process occurs in the After the data reading device obtains the first parent data page; if the first LSN is smaller than the second LSN and the first LSN is smaller than the third LSN, it is determined that the page splitting process occurs at the before the data reading device obtains the first parent data page; if the second LSN is less than the first LSN and the first LSN is less than or equal to the third LSN, determine that the data reading device The data playback speed of is slower than the data playback speed of the computing node and the page splitting process is to take place in the data reading device.

Optionally, the page splitting process occurs after the data reading device obtains the first parent data page; before the transceiver module 1001 sends the target data page to the computing node, the transceiver module 1001 is further used for: sending first information to the computing node, where the first information is used by the computing node to determine the target data page to be read; receiving a read of the target data page from the computing node fetch request.

Optionally, the first information includes: a first LSN of a log that triggers the page splitting process and indication information, the indication information indicates that the page splitting process occurs when the data reading device obtains the first parent data page after.

Optionally, the page splitting process occurs before the data reading device obtains the first parent data page, and the target data page is the first data page in the data reading device.

Optionally, the data playback speed of the data reading device is slower than the data playback speed of the computing node, and the page splitting process is to occur in the data reading device, and the target data page is the data The first data page in the device is read. Before the transceiver module 1001 sends the first data page to the computing node, the processing module 1002 is further configured to: determine that the data reading device has finished playing back the log whose LSN is the first LSN.

The data reading device in the above-mentioned first possible design may be the storage node or a part of the storage node in the implementation of the method shown in FIG. 8 above.

In a second possible design, a data reading device 1000 may include a transceiver module 1001 and a processing module 1002 .

The processing module 1002 is used to determine that the identifier of the data page to be read is the first identifier, and the data page to be read is the child data page of the first parent data page in the computing node; the transceiver module 1001 is used to send The storage node sends a data page read request, where the data page read request includes the first identifier, and the first identifier is used by the storage node to determine the page splitting process corresponding to the first data page identified as the first identifier occurrence timing and sending a target data page to the data reading device according to the occurrence timing; the transceiver module 1001 is further configured to receive a target data page from the storage node, and the target data page is the second data page or the first data page.

Optionally, before the transceiver module 1001 receives the target data page from the storage node: the transceiver module 1001 is further configured to receive first information from the storage node, where the first information includes: triggering all The first log sequence number LSN and indication information of the log of the page splitting process, the indication information indicates that the page splitting process occurs after the storage node obtains the first parent data page; the processing module 1002, further is configured to determine a target data page according to the first information; the transceiver module 1001 is further configured to send a request for reading the target data page to the storage node.

Optionally, the processing module 1002 is specifically configured to: determine, according to the first information, that the first parent data page in the storage node does not correspond to a page splitting process; read the second parent data from the storage node page, the second parent data page is the first parent data page updated after the page splitting process occurs; the target data page is determined according to the second parent data page.

Optionally, the processing module 1002 is specifically configured to: determine, according to the first information, that there is a page splitting process corresponding to the first parent data page in the storage node; read the second parent data page from the storage node to Each data page of the target parent data page, wherein the target parent data page does not correspond to a page splitting process and is located between the root data page and the second parent data page or the target parent data page is the root data page page, the second parent data page is a split data page of the first parent data page and the second parent data page is a parent data page of the first data page; according to the second parent data page To each data page of the target parent data page, the target data page is determined.

Optionally, the data storage device stores full amount of split information, and the full amount of split information includes the identifier of the split data page corresponding to each page split process and the LSN of the log that triggers each page split process; the processing module 1002 , is specifically used to: determine, according to the first information, that the identifier of the split data page included in the full split information has the second identifier and the LSN that triggers the corresponding page splitting process is the first LSN, and the The second identifier is the identifier of the first parent data page.

Optionally, the data storage device does not store the full amount of split information, and the management node stores the full amount of split information; the full amount of split information includes the identifier of the split data page corresponding to each page split process and the trigger for each page. LSN of the log of the splitting process; the processing module 1002 is specifically configured to: control the transceiver module 1001 to send a query request to the management node according to the indication information, where the query request includes the first LSN and the second LSN identifier, the query request instructs the management node to determine whether there is a page splitting process corresponding to the first parent data page in the storage node according to the full split information; The query result of the node, it is determined that the first parent data page in the storage node corresponds to a page splitting process, and the query result indicates that the first parent data page in the storage node corresponds to a page splitting process .

The data reading device in the above second possible design may be a slave computing node or a part of the slave computing node in the implementation of the above method.

In a third possible design, a data reading device 1000 may include a transceiver module 1001 and a processing module 1002 .

A processing module 1002, configured to determine an identifier of a data page to be read as a first identifier, and the data page to be read is a child data page of the first parent data page in the data reading device; determine a storage node The first data page identified as the first identifier in the middle corresponds to a page splitting process; a target data page is determined according to the occurrence timing of the page splitting process; and the target data page is read from the storage node.

Optionally, the data reading device stores full amount of split information, and the full amount of split information includes the identifier of the split data page corresponding to each page split process and the LSN of the log that triggers each page split process; the processing Module 1002 is specifically configured to: determine that the first identifier exists in the identifier of the split data page included in the full split information.

Optionally, it also includes a transceiver module 1001; the data reading device does not store full split information, the management node stores full split information, and the full split information includes splits corresponding to each page split process The identifier of the data page and the LSN of the log that triggers the splitting process of each page; the processing module 1002 is specifically configured to control the transceiver module 1001 to send a query request to the management node, where the query request includes the first identifier, the The query request instructs the management node to determine, according to the full split information, that the first data page corresponds to a page splitting process in the storage node; The first data page corresponds to a page splitting process in the storage node, and the query result indicates that the first data page corresponds to a page splitting process in the storage node.

Optionally, before the processing module 1002 determines the target data page according to the occurrence timing of the page splitting process, the processing module 1002 is further configured to: according to the first LSN of the log triggering the page splitting process, store The second LSN of the first data page in the node and the third LSN of the first parent data page in the data reading device determine the occurrence timing of the page splitting process.

Optionally, the processing module 1002 is specifically configured to: if the third LSN is smaller than the first LSN and the first LSN is smaller than or equal to the second LSN, determine that the page splitting process occurs in the After the storage node obtains the first parent data page; if the first LSN is smaller than the second LSN and the first LSN is smaller than the third LSN, it is determined that the page splitting process occurs in the storage Before the node obtains the first parent data page; if the second LSN is less than the first LSN, and the first LSN is less than or equal to the third LSN, it is determined that the data playback speed of the storage node is slower than The data playback speed of the data read device and the page splitting process is to take place in the storage node.

Optionally, if the page splitting process occurs after the storage node obtains the first parent data page, the processing module 1002 is specifically configured to: determine the first parent data page in the storage node There is no corresponding page splitting process; the second parent data page is read from the storage node, and the second parent data page is the first parent data page updated after the page split occurs; determined according to the second parent data page Target data page.

Optionally, if the page splitting process occurs after the storage node obtains the first parent data page, the processing module 1002 is specifically configured to: determine that the first parent data page in the storage node corresponds to a Page splitting process; read each data page from the second parent data page to the target parent data page from the storage node, wherein the target parent data page does not correspond to the page splitting process and is located between the root data page and the second parent data page Between pages or the target parent data page is the root data page, the second parent data page is a split data page of the first parent data page, and the second parent data page is the first data page The parent data page of the data page; the target data page is determined according to each data page from the second parent data page to the target parent data page.

Optionally, if the page splitting process occurs before the storage node obtains the first parent data page, the processing module 1002 is specifically configured to: determine that the first data page in the storage node is the target data Page.

Optionally, if the data playback speed of the storage node is slower than the data playback speed of the data reading device and the page splitting process in the storage node is about to occur, the processing module 1002 is specifically configured to: determine whether the storage node has any The log playback of the first LSN is completed; the first data page in the storage node is determined as the target data page.

The data reading device in the third possible design may be the slave computing node or a part of the slave computing node in the implementation of the method shown in FIG. 9 .

The apparatus of this embodiment can be used to implement the technical solutions of the foregoing method embodiments, and the implementation principles and technical effects thereof are similar, and details are not described herein again.

According to the embodiments of the present application, the present application further provides an electronic device and a readable storage medium.

As shown in FIG. 11 , it is a block diagram of an electronic device implementing the data reading method of the embodiment of the present application. Electronic devices are intended to represent various forms of digital computers, such as laptops, desktops, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. Electronic devices may also represent various forms of mobile devices, such as personal digital processors, cellular phones, smart phones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are by way of example only, and are not intended to limit implementations of the application described and/or claimed herein.

As shown in FIG. 11, the electronic device includes: one or more processors 1101, a memory 1102, and interfaces for connecting various components, including a high-speed interface and a low-speed interface. The various components are interconnected using different buses and may be mounted on a common motherboard or otherwise as desired. The processor may process instructions executed within the electronic device, including instructions stored in or on memory to display graphical information of the GUI on an external input/output device, such as a display device coupled to the interface. In other embodiments, multiple processors and/or multiple buses may be used with multiple memories and multiple memories, if desired. Likewise, multiple electronic devices may be connected, each providing some of the necessary operations (eg, as a server array, a group of blade servers, or a multiprocessor system). In FIG. 11, a processor 1101 is used as an example.

The memory 1102 is the non-transitory computer-readable storage medium provided by the present application. Wherein, the memory stores instructions executable by at least one processor, so that the at least one processor executes the data reading method provided by the present application. The non-transitory computer-readable storage medium of the present application stores computer instructions, and the computer instructions are used to cause the computer to execute the data reading method provided by the present application.

As a non-transitory computer-readable storage medium, the memory 1102 can be used to store non-transitory software programs, non-transitory computer-executable programs and modules, such as program instructions/modules corresponding to the data reading method in the embodiments of the present application (for example, The processing module 1002 and the transceiver module 1001 shown in FIG. 10 ). The processor 1101 executes various functional applications and data processing of the server by running the non-transitory software programs, instructions and modules stored in the memory 1102, ie, implements the data reading method in the above method embodiments.

The memory 1102 may include a stored program area and a stored data area, wherein the stored program area may store an operating system and an application program required for at least one function; the storage data area may store data created by using the electronic device implementing the data reading method Wait. Additionally, memory 1102 may include high speed random access memory, and may also include non-transitory memory, such as at least one magnetic disk storage device, flash memory device, or other non-transitory solid state storage device. In some embodiments, the memory 1102 may optionally include memory located remotely relative to the processor 1101, and these remote memories may be connected to the electronic device implementing the data reading method through a network. Examples of such networks include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

The electronic device implementing the data reading method may further include: an input device 1103 and an output device 1104 . The processor 1101 , the memory 1102 , the input device 1103 and the output device 1104 may be connected by a bus or in other ways, and the connection by a bus is taken as an example in FIG. 11 .

The input device 1103 can receive input numerical or character information, and generate key signal input related to user settings and function control of the electronic device implementing the data reading method, such as touch screen, keypad, mouse, trackpad, touchpad, pointer A stick, one or more mouse buttons, a trackball, a joystick, and other input devices. Output devices 1104 may include display devices, auxiliary lighting devices (eg, LEDs), haptic feedback devices (eg, vibration motors), and the like. The display device may include, but is not limited to, a liquid crystal display (LCD), a light emitting diode (LED) display, and a plasma display. In some implementations, the display device may be a touch screen.

Various implementations of the systems and techniques described herein can be implemented in digital electronic circuitry, integrated circuit systems, application specific ASICs (application specific integrated circuits), computer hardware, firmware, software, and/or combinations thereof. These various embodiments may include being implemented in one or more computer programs executable and/or interpretable on a programmable system including at least one programmable processor that The processor, which may be a special purpose or general-purpose programmable processor, may receive data and instructions from a storage system, at least one input device, and at least one output device, and transmit data and instructions to the storage system, the at least one input device, and the at least one output device an output device.

These computational programs (also referred to as programs, software, software applications, or codes) include machine instructions for programmable processors, and may be implemented using high-level procedural and/or object-oriented programming languages, and/or assembly/machine languages calculation program. As used herein, the terms "machine-readable medium" and "computer-readable medium" refer to any computer program product, apparatus, and/or apparatus for providing machine instructions and/or data to a programmable processor ( For example, magnetic disks, optical disks, memories, programmable logic devices (PLDs), including machine-readable media that receive machine instructions as machine-readable signals. The term "machine-readable signal" refers to any signal used to provide machine instructions and/or data to a programmable processor.

To provide interaction with a user, the systems and techniques described herein may be implemented on a computer having a display device (eg, a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user ); and a keyboard and pointing device (eg, a mouse or trackball) through which a user can provide input to the computer. Other kinds of devices can also be used to provide interaction with the user; for example, the feedback provided to the user can be any form of sensory feedback (eg, visual feedback, auditory feedback, or tactile feedback); and can be in any form (including acoustic input, voice input, or tactile input) to receive input from the user.

The systems and techniques described herein may be implemented on a computing system that includes back-end components (eg, as a data server), or a computing system that includes middleware components (eg, an application server), or a computing system that includes front-end components (eg, a user's computer having a graphical user interface or web browser through which a user may interact with implementations of the systems and techniques described herein), or including such backend components, middleware components, Or any combination of front-end components in a computing system. The components of the system may be interconnected by any form or medium of digital data communication (eg, a communication network). Examples of communication networks include: Local Area Networks (LANs), Wide Area Networks (WANs), and the Internet.

A computer system can include clients and servers. Clients and servers are generally remote from each other and usually interact through a communication network. The relationship of client and server arises by computer programs running on the respective computers and having a client-server relationship to each other.

In the present application, when a sub-data page of a data page in a storage node needs to be read, it can be determined whether the sub-data page corresponds to a page-splitting process according to the splitting information, so that if the sub-data page corresponds to a page-splitting process , according to the occurrence timing of the page splitting process, determine the data page to be read, so that the parent data page and the child data page obtained from the computing node match each other, that is, correct data can be read from the computing node.

It should be understood that steps may be reordered, added or deleted using the various forms of flow shown above. For example, the steps described in the present application can be performed in parallel, sequentially or in different orders, and as long as the desired results of the technical solutions disclosed in the present application can be achieved, no limitation is imposed herein.

The above-mentioned specific embodiments do not constitute a limitation on the protection scope of the present application. It should be understood by those skilled in the art that various modifications, combinations, sub-combinations and substitutions may occur depending on design requirements and other factors. Any modifications, equivalent replacements and improvements made within the spirit and principles of this application shall be included within the protection scope of this application.

Claims (35)

1. A data reading method applied to a storage node, the method comprising:

receiving a data page read request from a compute node, the data page read request including a first identification;

determining that a first data page identified as the first identifier in the storage node corresponds to a page splitting process;

and sending a target data page to the computing node according to the occurrence opportunity of the page splitting process, wherein the target data page is the first data page or the second data page.

2. The method of claim 1, wherein the storage node stores partial split information; the partial splitting information comprises an identifier of a splitting data page corresponding to a partial page splitting process and a log serial number LSN of a log triggering the page splitting process, and the splitting data page corresponding to the partial page splitting process is stored in the storage node;

determining that a first data page identified as the first identification in the storage node corresponds to a page splitting process, comprising: determining that the first identifier exists in the identifiers of the split data pages included in the partial split information.

3. The method according to claim 1 or 2, wherein the first identifier is an identifier of a data page to be read determined by the compute node, and the data page to be read is a child data page of a first parent data page in the compute node.

4. The method of claim 3, wherein the data page read request further includes a third LSN of the first parent data page;

before the sending the target data page to the computing node according to the occurrence opportunity of the page splitting process, the method further includes: and determining the occurrence opportunity of the page splitting process according to the first LSN of the log triggering the page splitting process, the second LSN of the first data page in the storage node and the third LSN.

5. The method of claim 4, wherein the determining the occurrence of the page splitting process comprises:

if the third LSN is less than the first LSN and the first LSN is less than or equal to the second LSN, determining that the page splitting process occurs after the storage node obtains the first parent data page;

if the first LSN is less than the second LSN and the first LSN is less than the third LSN, determining that the page splitting process occurs before the storage node obtains the first parent data page;

if the second LSN is less than the first LSN and the first LSN is less than or equal to the third LSN, then it is determined that the data playback speed of the storage node is slower than the data playback speed of the compute node and the page splitting process is pending to occur in the storage node.

6. The method according to any one of claims 3 to 5, wherein the page splitting process occurs after the storage node obtains the first parent data page and before sending a target data page to the compute node, further comprising:

sending first information to the computing node, wherein the first information is used for the computing node to determine a target data page;

receiving a read request for the target page of data from the compute node.

7. The method according to any one of claims 3 to 5, wherein the first information comprises: triggering a first LSN of a log of the page splitting process and indicating information indicating that the page splitting process occurs after the storage node obtains the first parent data page.

8. The method according to any one of claims 3 to 5, wherein the page splitting process occurs before the storage node obtains the first parent data page, and the target data page is the first data page in the storage node.

9. The method according to any one of claims 3 to 5, wherein the data playback speed of the storage node is slower than the data playback speed of the computing node and the page splitting process is to occur in the storage node, the target data page being the first data page in the storage node; prior to sending the first data page identified as the first identification to the compute node, further comprising:

and determining that the log playback of the storage node with the LSN as the first LSN is finished.

10. A data reading method applied to a compute node, the method comprising:

determining that an identifier of a data page to be read is a first identifier, wherein the data page to be read is a child data page of a first parent data page in the computing node;

sending a data page reading request to a storage node, wherein the data page reading request comprises the first identifier, and the first identifier is used for the storage node to determine the occurrence time of a page splitting process corresponding to the first data page identified as the first identifier and send a target data page to the computing node according to the occurrence time;

receiving a target data page from the storage node, the target data page being a second data page or the first data page.

11. The method of claim 10, further comprising, prior to receiving a target page of data from the storage node:

receiving first information from the storage node, the first information comprising: triggering a first Log Sequence Number (LSN) of a log of the page splitting process and indicating information indicating that the page splitting process occurs after the storage node obtains the first parent data page;

determining a target data page according to the first information;

and sending a request for reading the target data page to the storage node.

12. The method of claim 11, wherein determining a target data page based on the first information comprises:

determining that the first father data page does not correspond to a page splitting process in the storage node according to the first information;

reading a second parent data page from the storage node, wherein the second parent data page is a first parent data page updated after the page splitting process occurs;

and determining the target data page according to the second parent data page.

13. The method of claim 11, wherein determining a target data page based on the first information comprises:

determining a corresponding page splitting process of the first parent data page in the storage node according to the first information;

reading each data page from a second father data page to a target father data page from a storage node, wherein the target father data page does not correspond to a page splitting process and is positioned between a root data page and the second father data page or the target father data page is the root data page, the second father data page is a data page after the first father data page is split, and the second father data page is a father data page of the first data page;

and determining the target data page according to the data pages from the second father data page to the target father data page.

14. The method of claim 13, wherein the compute node has stored therein full split information, the full split information including an identification of a split data page corresponding to each page split process and an LSN of a log that triggered each page split process;

determining that the first parent data page corresponds to a page splitting process in the storage node according to the first information, including: and according to the indication information, determining that the second identifier exists in the identifiers of the split data pages included in the full split information and the LSN triggering the corresponding page splitting process is the first LSN, and the second identifier is the identifier of the first father data page.

15. The method of claim 13, wherein the compute node has no full split information stored therein, and a management node has the full split information stored therein; the full splitting information comprises the identifier of a splitting data page corresponding to each page splitting process and the LSN of the log triggering each page splitting process;

determining that the first parent data page corresponds to a page splitting process in the storage node according to the first information, including:

sending a query request to a management node according to the indication information, wherein the query request comprises the first LSN and the second identifier, and the query request indicates the management node to determine whether the first father data page corresponds to a page splitting process in the storage node according to the full splitting information;

receiving a query result from the management node, the query result indicating that the first parent data page corresponds to a page splitting process in the storage node.

16. A data reading method applied to a compute node, the method comprising:

determining that an identifier of a data page to be read is a first identifier, wherein the data page to be read is a child data page of a first parent data page in the computing node;

determining that a first data page identified as the first identifier in the storage node corresponds to a page splitting process;

determining a target data page according to the occurrence opportunity of the page splitting process;

reading the target page of data from the storage node.

17. The method of claim 16, wherein the compute node stores therein full split information, the full split information including an identifier of a split data page corresponding to each page split process and an LSN of a log that triggers each page split process;

determining that a first data page identified as the first identifier in the storage node corresponds to a page splitting process, including: and determining that the first identifier exists in the identifiers of the split data pages included in the full split information.

18. The method according to claim 16, wherein the compute node does not store therein full split information, and the management node stores therein full split information, wherein the full split information includes an identifier of a split data page corresponding to each page split process and an LSN of a log that triggers each page split process;

determining that a first data page identified as the first identifier in the storage node corresponds to a page splitting process, including:

sending a query request to the management node, wherein the query request comprises the first identifier, and the query request indicates the management node to determine that the first data page corresponds to a page splitting process in the storage node according to the full splitting information;

and receiving a query result from the management node, wherein the query result indicates that the first data page corresponds to a page splitting process in the storage node.

19. A data reading apparatus, comprising:

a transceiver module for receiving a data page read request from a compute node, the data page read request including a first identifier;

the processing module is used for determining that a first data page identified as the first identification in the data reading device corresponds to a page splitting process;

and the transceiver module is further configured to send a target data page to the computing node according to the occurrence opportunity of the page splitting process, where the target data page is the first data page or the second data page.

20. The apparatus of claim 19, wherein the data reading means has stored therein partial fragmentation information; the partial splitting information comprises an identifier of a splitting data page corresponding to a partial page splitting process and a Log Serial Number (LSN) of a log triggering the page splitting process, and the splitting data pages corresponding to the partial page splitting process are stored in the data reading device;

the processing module is specifically configured to determine that the first identifier exists in identifiers of split data pages included in the partial split information.

21. The apparatus according to claim 19 or 20, wherein the first identifier is an identifier of a data page to be read determined by the compute node, and the data page to be read is a child data page of a first parent data page in the compute node.

22. The apparatus of claim 21, wherein the data page read request further comprises a third LSN of the first parent data page in the compute node;

before the transceiver module sends the target data page to the computing node according to the occurrence opportunity of the page splitting process, the processing module is further configured to:

and determining the occurrence opportunity of the page splitting process according to the first LSN of the log triggering the page splitting process, the second LSN of the first data page in the data reading device and the third LSN.

23. The apparatus of claim 22, wherein the processing module is specifically configured to:

if the third LSN is less than the first LSN and the first LSN is less than or equal to the second LSN, determining that the page splitting process occurs after the data reading device obtains the first parent data page;

if the first LSN is less than the second LSN and the first LSN is less than the third LSN, determining that the page splitting process occurs before the data reading device obtains the first parent data page;

if the second LSN is less than the first LSN and the first LSN is less than or equal to the third LSN, then it is determined that the data playback speed of the data reading device is slower than the data playback speed of the compute node and the page splitting process is pending to occur in the data reading device.

24. The apparatus according to any of claims 21 to 23, wherein the page splitting process occurs after the data reading means obtains the first parent data page; before the transceiver module sends the target data page to the computing node, the transceiver module is further configured to:

sending first information to the computing node, wherein the first information is used for the computing node to determine the target data page;

receiving a read request for the target page of data from the compute node.

25. The apparatus of claim 24, wherein the first information comprises: triggering a first LSN of a log of the page splitting process and indicating information indicating that the page splitting process occurs after the data reading device obtains the first parent data page.

26. The apparatus of any of claims 21 to 23, wherein the page splitting process occurs before the data reading apparatus obtains the first parent data page, and the target data page is the first data page in the data reading apparatus.

27. The apparatus according to any one of claims 19 to 22, wherein the data playback speed of the data reading apparatus is slower than the data playback speed of the computing node and the page splitting process is to occur in the data reading apparatus, the target data page being the first data page in the data reading apparatus; before the transceiver module sends the first data page to the computing node, the processing module is further configured to: and determining that the log playback of the LSN as the first LSN by the data reading device is finished.

28. A data reading apparatus, comprising:

the processing module is used for determining that the identifier of the data page to be read is a first identifier, and the data page to be read is a child data page of a first parent data page in the computing node;

a receiving and sending module, configured to send a data page reading request to a storage node, where the data page reading request includes the first identifier, and the first identifier is used for the storage node to determine an occurrence time of a page splitting process corresponding to a first data page identified as a first identifier, and send a target data page to the data reading apparatus according to the occurrence time;

the transceiver module is further configured to receive a target data page from the storage node, where the target data page is a second data page or the first data page.

29. The apparatus of claim 28, wherein prior to the transceiver module receiving a target data page from the storage node:

the transceiver module is further configured to receive first information from the storage node, where the first information includes: triggering a first Log Sequence Number (LSN) of a log of the page splitting process and indicating information, wherein the indicating information indicates that the page splitting process occurs after a first parent data page is obtained by the storage node;

the processing module is further used for determining a target data page according to the first information;

the transceiver module is further configured to send a request for reading the target data page to the storage node.

30. The apparatus of claim 29, wherein the processing module is specifically configured to:

determining that the first father data page does not correspond to a page splitting process in the storage node according to the first information;

reading a second parent data page from the storage node, wherein the second parent data page is a first parent data page updated after the page splitting process occurs;

and determining the target data page according to the second parent data page.

31. The apparatus of claim 29, wherein the processing module is specifically configured to:

determining a corresponding page splitting process of the first parent data page in the storage node according to the first information;

reading each data page from a second father data page to a target father data page from a storage node, wherein the target father data page does not correspond to a page splitting process and is positioned between a root data page and the second father data page or the target father data page is the root data page, the second father data page is a data page after the first father data page is split, and the second father data page is a father data page of the first data page;

and determining the target data page according to the data pages from the second father data page to the target father data page.

32. The apparatus according to claim 31, wherein the data reading apparatus stores therein full splitting information, the full splitting information including an identifier of a split data page corresponding to each page splitting process and an LSN of a log that triggers each page splitting process;

the processing module is specifically configured to: and according to the first information, determining that the second identifier exists in the identifiers of the split data pages included in the full split information and the LSN triggering the corresponding page splitting process is the first LSN, and the second identifier is the identifier of the first father data page.

33. The apparatus of claim 31, wherein the data reading apparatus does not store therein full split information, and a management node stores therein the full split information; the full splitting information comprises the identifier of a splitting data page corresponding to each page splitting process and the LSN of the log triggering each page splitting process;

the processing module is specifically configured to:

according to the indication information, controlling the transceiver module to send an inquiry request to a management node, wherein the inquiry request comprises the first LSN and the second identifier, and the inquiry request indicates the management node to determine whether the first father data page corresponds to a page splitting process in the storage node according to the full splitting information;

determining that the first parent data page corresponds to a page splitting process in the storage node according to a query result received by the transceiver module from the management node, wherein the query result indicates that the first parent data page corresponds to the page splitting process in the storage node.

34. An electronic device, comprising:

at least one processor; and

a memory communicatively coupled to the at least one processor; wherein,

the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of any one of claims 1-9 or the method of any one of claims 10-15 or the method of any one of claims 16-18.

35. A non-transitory computer readable storage medium having stored thereon computer instructions for causing a computer to perform the method of any one of claims 1-9 or the method of any one of claims 10-15 or the method of any one of claims 16-18.

Images