WO2023159976A1 - Data segmented writing method, data reading method and apparatus - Google Patents

Abstract

Disclosed in the embodiments of the present application are a data segmented writing method, a data reading method and an apparatus, which are applied to the technical field of computers, and used for reducing data writing time delay. The data segmented writing method in the embodiments of the present application is applied to a database system, the database system comprising a second storage space and N first storage spaces, and N being a positive integer. The data segmented writing method in the embodiments of the present application comprises: a first thread obtains a redo log according to target data, the redo log being used for representing the target data and a write operation for the target data, and the write operation being used for converting the target data into graph model data and writing the graph model data into the second storage space; and writing the redo log into a target storage space, the target storage space being one of the N first storage spaces, so that a second thread can execute the write operation by replaying the redo log in the target storage space so as to write the graph model data into the second storage space.

Description

Data segmentation writing method, data reading method and device

This application claims the priority of the Chinese patent application submitted to the China Patent Office on February 28, 2022, the application number is CN202210189511.7, and the application name is "data segment writing method, data reading method and device", all of which The contents are incorporated by reference in this application.

technical field

The present application relates to the field of computer technology, and in particular to a data segment writing method, a data reading method and a device.

Background technique

To model the real world, the most effective modeling method is to use the entity-relationship (Entity-Relationship, ER) model for modeling. The current most popular relational model database system is a simplification of the ER model, which cannot express the function mapping relationship in the ER model. In contrast, the graph model (Graph model) can better express the function mapping relationship in the ER model, and then better model the real world.

The method of using the graph model to model the real world is as follows: convert the real world data into graph model data, and then import the graph model data into the graph database system.

The above method can also be understood as the writing process of graph model data, while the reading process of graph model data is the opposite, that is, the graph model data is first read, and then the graph model data is converted into real-world data.

However, due to the complex relationship between the data in the real world, it is necessary to identify and extract the relationship between the data in the real world during the conversion process of the graph model data, resulting in the conversion process between the data in the real world and the graph model data. It takes a long time, making the processing delay of real-world data long, such as: write delay or read delay.

Contents of the invention

The embodiment of the present application provides a data segmentation writing method, a data reading method and a device, and the method can reduce the time delay of synchronous writing to the graph database system.

In the first aspect, the present application provides a data segment writing method, which is applied to a database system. The database system includes a second storage space and N first storage spaces, and the first storage space and the second storage space are independent of each other. , the first storage space can be directly connected by the client to perform read or write operations, and the second storage space is used to store graph model data, where N is a positive integer. The graph database system can be used by various businesses, and when N is greater than 1, each first storage space can correspond to one business.

The method includes: the first thread obtains a redo log according to the target data, and the redo log includes a write operation of the target data, and the write operation is used to convert the target data into graph model data and write the graph model data into the second storage space; The first thread may also be called a main thread, a business thread or a working thread, and specifically refers to a thread of a client running a database. The first thread writes the redo log into the target storage space, so that the second thread can perform the above-mentioned write operation by replaying the redo log in the target storage space, so as to write the graph model data into the second storage space, and the target storage space is one of the N first storage spaces, and the second thread refers to a working thread of the database.

The first thread writes the redo log containing the write operation of the target data into the target storage space, so the redo log is stored in the target storage space, not the graph model data; the second thread saves the target data by playing back the redo log The corresponding graph model data is written into the second storage space, so the graph model data is stored in the second storage space. It can be seen that the conversion between the target data and the graph model data that takes a long time occurs in the process of playing back the redo log, but it will not happen when the first thread writes the redo log to the target storage space. The conversion of the graph model data, therefore, the process of the first thread encapsulating the target data into redo logs and writing them into the target storage space takes less time; in this way, after writing the redo logs, it returns the result of successful writing, The target data can be synchronously written into the graph database system under the premise of low latency, which ensures the low latency of synchronous writing.

As an implementable manner, the method further includes: the second thread reads the redo logs in the target storage space; and the second thread plays back the redo logs in the target storage space to perform a write operation.

The second thread replays the redo logs in the target storage space to perform write operations, thereby writing the graph model data into the second storage space, so that the conversion between the target data and the graph model data that takes a long time takes place in the playback redo Logging process, not in the process of writing redo logs to the target storage space. In this way, after the redo log is written, the result of successful writing is returned, and the target data can be synchronously written to the graph database system under the premise of low latency, ensuring low latency of synchronous writing.

As an implementable manner, the method further includes: the first thread sends a request to the second thread, and the request is used to instruct the second thread to replay the redo logs in the target storage space.

The first thread sends a request to the second thread, so that the second thread plays back the redo log, so that the data merging from the target storage space to the second storage space is realized under the active request of the first thread.

As an implementable manner, the first thread sending the request to the second thread includes: when the used storage space in the target storage space reaches a first threshold, the first thread sends the request to the second thread.

When the used storage space in the target storage space reaches the first threshold, the first thread sends a request to the second thread, thereby reserving storage space for the redo log of newly added data, ensuring that subsequent new data can also be Synchronous writes are achieved with lower latency.

As an implementable manner, the first thread sending the request to the second thread includes: in response to a business requirement, the first thread sending the request to the second thread. The business requirement can be set according to the actual situation. For example, the business requirement includes: the need to read the latest data in the graph database system. Based on this, if the redo logs in the first storage space have not been played back, the data in the second storage space is not up-to-date. At this time, in response to the business requirement, the first thread can actively send a request to the second thread.

In response to business requirements, the first thread sends a request to the second thread, so that the second thread plays back redo logs, thereby realizing data merging from the target storage space to the second storage space when the business requirements are met.

As an achievable manner, when N is greater than 1, the method further includes; the first thread determines from the N first storage spaces according to the label corresponding to the target data and the corresponding relationship between the label and the first storage space The target storage space, the label indicates the table used to store the target data.

In the database, data is stored in the form of tables, so according to the label corresponding to the target data and the corresponding relationship between the label and the first storage space, the first storage space where the table used to store the target data is located can be determined, that is, the target storage.

As an achievable manner, writing the redo log into the target storage space by the first thread includes: writing the redo log into the target storage space by the first thread through a strict two-stage lock mechanism of a physical lock.

Compared with other lock mechanisms, the strict two-stage lock mechanism of physical locks has a simpler read and write process, so it can ensure a lower delay in writing redo logs; moreover, the strict two-stage lock mechanism of physical locks does not include database objects Locks, possibly reducing lock overhead.

As an achievable manner, after the first thread writes the redo log into the target storage space, the method further includes: the first thread writes the transaction commit log into the target storage space, and the transaction commit log is used to represent the writing of the target data The entry transaction has been committed; the user can read the data written in the write transaction, thus ensuring the atomicity and consistency of the write transaction.

In the second aspect, the present application provides a data segment writing method, which is applied to a database system. The database system includes a second storage space and N first storage spaces, where N is a positive integer. The relevant description of the graph database system Refer to the related description of the first aspect.

The method includes: the second thread reads the redo log in the target storage space, the target storage space is one of the N first storage spaces, the redo log is used to represent the target data and the write operation of the target data, and the write operation uses Converting the target data into graph model data and writing the graph model data into the second storage space; the second thread replays the redo logs in the target storage space to perform the write operation.

In the process of replaying the redo log, the second thread will execute the write operation of the target data, thereby converting the target data into graph model data. This conversion operation and the operation of writing the redo log by the first thread can be performed asynchronously. Therefore, after the first thread completes the write operation of the redo log, it can return the result of successful synchronous writing, thereby ensuring low latency of synchronous writing. Moreover, the second thread can merge the graph model data of the target data into the second storage space by playing back the redo log, so that the graph model data stored in the second storage space is consistent with the target data actually written by the user, This ensures data consistency.

As an implementable manner, the second thread reading the redo log in the target storage space includes: the second thread periodically reads the redo log in the target storage space, wherein the second thread reads the redo log The cycle can be set according to the actual situation.

The second thread periodically reads the redo logs in the target storage space. When the second thread takes the initiative, it realizes the data merging from the target storage space to the second storage space, and makes the first storage space have enough The remaining space to store new data in the redo logs.

As an achievable manner, the second thread reading the redo logs in the target storage space includes: upon receiving a request from the first thread, the second thread reads the redo logs in the target storage space, The request is used to instruct the second thread to replay the redo logs in the target storage space, so as to store the graph model data in the second storage space.

In the case of receiving a request from the first thread, the second thread reads the redo logs in the target storage space, thereby realizing data merging from the target storage space to the second storage space under the active request of the first thread .

As an implementable manner, the second thread playing back the redo logs in the target storage space includes: the second thread plays back the redo logs in the target storage space through a multi-version two-stage lock mechanism.

The cost of read and write operations of the multi-version two-stage lock mechanism is relatively small, so replaying redo logs through the multi-version two-stage lock mechanism can reduce the lock overhead.

As an implementable manner, after the second thread plays back the redo logs in the target storage space, the method further includes: the second thread deletes the redo logs in the target storage space.

After replaying the redo log, deleting the redo log can ensure that there is enough remaining space in the target storage space so that the first thread can write the redo log of new data.

In a third aspect, the present application provides a method for reading data, which is applied to a database system. The database system includes a second storage space and N first storage spaces, where N is a positive integer; the method includes: the third thread acquires the target The database primary key corresponding to the data. The third thread refers to the data reading thread, which can be the same as the first thread in the first aspect. The database primary key is usually part of the data selected from the target data, and its value can uniquely identify the data in the table. each row. The third thread reads redo logs from the target storage space according to the primary key of the database. For example, the third thread queries the index according to the primary key of the database. Do the storage location of the log, and then read the redo log. Alternatively, the third thread reads the graph model data from the second storage space according to the primary key of the database. The graph model data is obtained from the redo logs in the target storage space played back by the second thread. It should be noted that the process of reading the model data Similar to the process of reading the redo log; the target storage space is one of the N first storage spaces, the redo log is used to represent the target data and the write operation of the target data, and the write operation is used to convert the target data into a graph model data and write the graph model data into the second storage space. It can be seen that when the target data is stored in the target storage space in the form of redo logs, the third thread can read the target data from the target storage space. When the target data is stored in the second storage space, the third thread may read the target data from the second storage space. Therefore, this application can ensure the consistency of data in the graph database system.

Moreover, since the third thread can obtain the target data by reading the redo log without performing a conversion operation from the graph model data to the target data, the time delay for reading the target data can be reduced.

As an implementable manner, before the third thread reads the redo log from the target storage space according to the database primary key, the method further includes: the third thread determines the identifier of the writing transaction of the target data according to the database primary key; the third thread According to the identifier of the write transaction, it is determined that the target storage space contains a transaction commit log, and the transaction commit log is used to indicate that the write transaction has been committed. The target data in the target storage space is read only when the target storage space contains a transaction commit log indicating that the write transaction has been committed, thereby ensuring the atomicity and consistency of the write transaction.

In a fourth aspect, the present application provides a device for writing data segments, which is applied to a database system. The database system includes a second storage space and N first storage spaces, where N is a positive integer; the device includes a packaging unit, which uses The redo log is obtained according to the target data, and the redo log is used to represent the target data and the write operation of the target data, and the write operation is used to convert the target data into graph model data and write the graph model data into the second storage space.

The write unit is configured to write redo logs into a target storage space, where the target storage space is one of the N first storage spaces.

As a practicable manner, the device further includes: a sending unit, configured to send a request to the second thread, and the request is used to instruct the second thread to replay the redo logs in the target storage space, so that the graph model data corresponding to the target data Write to the second storage space.

As an implementable manner, the sending unit is configured to send a request to the second thread when the used storage space in the target storage space reaches a first threshold.

As an implementable manner, the sending unit is configured to send a request to the second thread in response to a service requirement.

As a practicable manner, the device further includes: a determining unit, configured to determine a target storage space from the N first storage spaces.

As a practicable manner, the determining unit is configured to determine the target storage space from the N first storage spaces according to the label corresponding to the target data and the corresponding relationship between the label and the first storage space. table of data.

As an achievable way, the write unit is used to write the redo log into the target storage space through the strict two-stage lock mechanism of the physical lock.

Wherein, for the specific implementation, relevant description and technical effect of each of the above units, please refer to the relevant description of the first aspect.

In a fifth aspect, the present application provides a device for writing data segments, which is applied to a database system. The database system includes a second storage space and N first storage spaces, where N is a positive integer; the device includes: a reading unit , used for the second thread to read the redo log in the target storage space, the target storage space is one of the N first storage spaces, the redo log is used to represent the target data and the write operation of the target data, and the write operation is used for The target data is converted into graph model data and the graph model data is written into the second storage space; the replay unit is used to replay redo logs in the target storage space to perform write operations.

As an implementable manner, the reading unit is used to periodically read redo logs in the target storage space.

As an implementable manner, the reading unit is used to read the redo logs in the target storage space when receiving a request from the first thread, and the request is used to instruct the second thread to play back the redo logs in the target storage space Redo logs to store graph model data in the second storage space.

As an implementable manner, the replay unit is used for the second thread to replay the redo logs in the target storage space through a multi-version two-segment lock mechanism.

As an implementable manner, the device further includes a deletion unit, configured to delete redo logs in the target storage space.

Wherein, for the specific implementation, relevant description and technical effect of each of the above units, please refer to the relevant description of the second aspect.

In a sixth aspect, the present application provides a data reading device, which is applied to a database system, and the database system includes a second storage space and N first storage spaces, where N is a positive integer; the device includes: an acquisition unit for Acquire the database primary key corresponding to the target data; the reading unit is used to read the redo log from the target storage space according to the database primary key, or to read the graph model data from the second storage space according to the database primary key, and the graph model data is based on The redo log in the target storage space played back by the second thread is obtained; the target storage space is one of the N first storage spaces, and the redo log is used to represent the target data and the write operation of the target data, and the write operation is used to write The target data is converted into graph model data and the graph model data is written into the second storage space.

As a practicable manner, the reading unit is configured to query the target storage space according to the primary key of the database, so as to obtain the target data.

As an achievable way, the reading unit is used to determine the identifier of the writing transaction of the target data according to the primary key of the database; according to the identifier of the writing transaction, it is determined that the target storage space contains a transaction commit log, and the transaction commit log is used to represent Write transaction committed.

Wherein, for the specific implementation, relevant description and technical effect of each of the above units, please refer to the relevant description of the third aspect.

The seventh aspect of the embodiment of the present application provides a terminal device, including: one or more processors and a memory; wherein, computer-readable instructions are stored in the memory; one or more processors read the computer-readable instructions to Make the computer device implement the method in any implementation manner of the first aspect, or the method in any implementation manner of the second aspect, or the method in any implementation manner of the third aspect.

The eighth aspect of the embodiment of the present application provides a computer-readable storage medium, including computer-readable instructions. When the computer-readable instructions are run on a computer, the computer can perform any of the following aspects of the first aspect, the second aspect, or the third aspect. A method of implementation.

A ninth aspect of the embodiments of the present application provides a chip, including one or more processors. Part or all of the processor is used to read and execute the computer program stored in the memory, so as to execute the method in any possible implementation manner of the first aspect, the second aspect or the third aspect above.

Optionally, the chip includes a memory, and the memory and the processor are connected to the memory through a circuit or wires. Further optionally, the chip further includes a communication interface, and the processor is connected to the communication interface. The communication interface is used to receive data and/or information to be processed, and the processor obtains the data and/or information from the communication interface, processes the data and/or information, and outputs the processing result through the communication interface. The communication interface may be an input-output interface.

In some implementations, some of the one or more processors can also implement some steps in the above method through dedicated hardware. For example, the processing related to the neural network model can be performed by a dedicated neural network processor or graphics processor to achieve.

The method provided in the embodiment of the present application may be implemented by one chip, or may be implemented by multiple chips in cooperation.

The tenth aspect of the embodiment of the present application provides a computer program product, the computer program product includes computer software instructions, and the computer software instructions can be loaded by a processor to implement any of the above-mentioned first aspect, second aspect or third aspect. A method of implementation.

Description of drawings

Fig. 1 is a schematic diagram of a stand-alone database system;

Fig. 2 is a schematic diagram of the hardware architecture of the graph database system applied in the embodiment of the present application;

Fig. 3 is a schematic diagram of the software architecture of the graph database system applied in the embodiment of the present application;

FIG. 4 is a schematic diagram of the relationship between the graph database system applied in the embodiment of the present application and external systems;

FIG. 5 is a schematic diagram of an embodiment of a data segment writing method provided by the present application;

Fig. 6 is a schematic diagram of the process of replaying redo logs by the second thread;

FIG. 7 is a schematic diagram of the process of writing target data using the method provided by the embodiment of the present application;

Fig. 8 is a schematic diagram of an embodiment of the data reading method provided by the embodiment of the present application;

FIG. 9 is a schematic diagram of an embodiment of a data segment writing device provided in an embodiment of the present application;

FIG. 10 is a schematic diagram of an embodiment of a data segment writing device provided in an embodiment of the present application;

FIG. 11 is a schematic diagram of an embodiment of a data reading device provided in an embodiment of the present application;

FIG. 12 is a schematic structural diagram of a terminal device provided by an embodiment of the present application.

Detailed ways

Embodiments of the present application are described below in conjunction with the accompanying drawings. Apparently, the described embodiments are only part of the embodiments of the present application, not all of the embodiments. Those of ordinary skill in the art know that, with the development of technology and the emergence of new scenarios, the technical solutions provided in the embodiments of the present application are also applicable to similar technical problems.

The terms "first", "second" and the like in the specification and claims of the present application and the above drawings are used to distinguish similar objects, and are not necessarily used to describe a specific sequence or sequence. It is to be understood that the terms so used are interchangeable under appropriate circumstances such that the embodiments described herein can be practiced in sequences other than those illustrated or described herein. Furthermore, the terms "comprising" and "having", as well as any variations thereof, are intended to cover a non-exclusive inclusion, for example, a process, method, system, product or device comprising a sequence of steps or elements is not necessarily limited to the expressly listed Those steps or elements may instead include other steps or elements not explicitly listed or inherent to the process, method, product or apparatus.

The method provided in the embodiment of the present application can be applied to a database system. A database system (database system) generally consists of the following three parts: (1) database (database, DB), which refers to a collection of organized and shareable data stored in a computer for a long time. The data in the database is organized, described and stored according to a certain mathematical model, which has less redundancy, higher data independence and easy scalability, and can be shared by various users. (2) Hardware, including data storage required to store data, such as memory and/or disks. (3) Software, including DBMS (database management system, database management system). DBMS is the core software of the database system. It is a system software for scientifically organizing and storing data, and efficiently obtaining and maintaining data. core components.

Specifically, as shown in Figure 1, Figure 1 is a schematic diagram of a stand-alone database system, including a database management system and a data store (Data Store), the database management system is used to provide services such as database query and modification, and the database management system will The data is stored in the data memory. In a stand-alone database system, the database management system and data storage are usually located on a single device. The device can include multiple processors, all of which share resources such as buses, memory, and I/O systems. The functions of the database management system can be implemented by one or more processors executing programs in memory.

FIG. 2 is a schematic diagram of the hardware architecture of the graph database system applied in the embodiment of the present application. The embodiment of the present application can be applied to the graph database system shown in FIG. 2 . The graph database system includes a first memory and a second memory, where the first memory and the second memory can be understood as the data storage in FIG. 1 .

The first memory refers to the memory that can be directly connected by the client, and the client can perform read or write operations; the embodiment of the present application does not specifically limit the storage method of the first memory, for example, the storage method of the first memory can be It is a paged memory storage method.

The number of the first memory can be one or more, wherein, Figure 1 shows three first memories; since there are many kinds of services, usually, the number of the first memory is multiple, Each first memory corresponds to a service.

The second memory can be understood as an independent memory separate from the first memory; the embodiment of the present application does not specifically limit the storage method of the second memory, for example, the storage method of the second memory can be a segment page memory storage method; The quantity of the second memory is generally one, and may also be multiple.

It should be noted that, hereinafter, the first memory is also called DeltaStore, and the second memory is called MainStore.

Since the conversion process between real-world data and graph model data takes a long time, if the real-world data is written into the graph database system by synchronous writing, there will be a problem of long delay in synchronous writing .

Among them, synchronous writing can be understood as an access mode, and synchronous means that the client program has been in a waiting state after sending out a writing request, and returns the processing result of the writing request until the writing is completed.

In order to solve the above problems, based on the graph database system shown in Figure 2, an embodiment of the present application provides a method for writing data segments, in which the client can directly connect to the first memory and rewrite the target data in a logical manner. It is written into the first memory in the form of redo log, and then the result of successful synchronous writing can be returned. Wherein, the redo log is used to represent the target data and the write operation of the target data, and the write operation is used to convert the target data into graph model data and write the graph model data into the second storage space. Then, the logical redo log in the first memory can be played back asynchronously. During the playback process, the write operation of the aforementioned target data will be performed, that is, the target data will be converted into graph model data and the graph model data will be written into the second memory to complete the goal The process of writing data to the graph database system. The logical redo log represents the transaction log in the database; hereinafter, the logical redo log is also referred to as the redo log for short.

Asynchronous playback means that after the client program sends a write request, it first returns the processing result of the client program's write request, and then executes the playback operation.

The target data can be arbitrary data.

According to the existing synchronous writing method, the client program has been in a waiting state after sending the writing request, and will not return the processing result of the writing request until the target data is converted into graph model data and the graph model data is stored. Since the conversion process between the target data and the graph model data takes a long time, the existing synchronous writing method has a relatively long writing time delay.

However, according to the synchronous write method adopted in the embodiment of the present application, the client program is in a waiting state after sending out the write request, and after obtaining the redo log according to the target data and writing the redo log into the first memory, it can return to the client. The end program writes the processing result of the request; after the processing result is returned, the redo log is played back to complete the conversion with the graph model data and the writing of the graph model data.

Since the conversion process between the target data and the graph model data occurs after returning the processing result of the writing request of the client program, the waiting time of the client program is short, and the waiting time of the client program is the writing delay; therefore, relatively Compared with the existing synchronous writing methods, the writing delay of the synchronous writing method of the embodiment of the present application is shorter (also can be understood as low latency).

Among them, low latency can be understood as short end-to-end execution time, generally reaching the nanosecond level.

In addition, the aforementioned low latency is deterministic and predictable for the following reasons. Since the client can directly connect to the first memory to perform the data writing operation, there is no scheduling overhead caused by the client scheduling other programs to complete the writing operation, and the scheduling overhead is often uncertain; moreover, the process of data writing It is to write the target data into the first memory in the form of logical redo redo logs. The data volume of redo logs is definite and is not affected by other factors such as indexes in the first memory, so the delay of data writing is definite , can be estimated.

FIG. 2 shows the hardware part of the graph database system. In addition, the graph database system also includes a software part. FIG. 3 is a schematic diagram of the software architecture of the graph database system applied in the embodiment of the present application. As shown in Figure 3, the graph database system includes an execution engine (Execution Engine) module, a storage engine (Storage Engine) module, a resource manager (resource manager) and a lock manager (lock manager).

Wherein, the execution engine module includes a first memory manager, and the first memory manager is used to store logical redo logs in the first memory; the storage engine includes a first memory merging unit, and the first memory merging unit is used to be responsible for the storage of the first memory Playback of logical redo logs in the middle; the resource manager is responsible for storing graph model data in the second memory; the lock manager is used for managing lock resources.

As shown in Figure 3, in practical applications, in response to the request of the application program, the first memory manager stores the logical redo log obtained from the target data into the first memory; then the logical redo log is played back by the first memory merging unit, The graph model data of the target data is merged into the second memory, and the resource manager manages the graph model data in the second memory. In the process of storing logical redo logs and playing back logical redo logs, concurrency may exist (that is, during the process of storing or playing back logical redo logs, the client program needs to read or modify the target data in logical redo logs), when In case of concurrency, the lock resource in the lock manager can be used for concurrent processing.

FIG. 4 is a schematic diagram of the relationship between the graph database system applied in the embodiment of the present application and external systems. As shown in Figure 4, the external system includes management plane, control plane, analysis plane, DLR (Data Logical Replication) distributed components and some related tools (such as development tools or operation and maintenance testing tools).

Among them, the management plane, control plane, and analysis plane are the divisions of services in the field of communication technology. The management plane is used for business related to configuration data in the network, the control plane is used for protocol calculation and forwarding management business, and the analysis plane is used for For the business of analyzing the running status of devices, the DLR distributed component is used to synchronize data between different devices.

For the management plane and the control plane, what is needed is a graph database system with graph data management capabilities; compared with the management plane and the control plane, the interactive operations between the management plane, the control plane and the graph database system can be divided into Active operation and passive notification operation, wherein the active operation may include DDL/DML operation, and the passive notification operation may include pub/sub operation.

For the analysis side, what is needed is a graph database system with time series capabilities. Compared with the analysis plane, the interactive operations between the analysis plane and the graph database system can be divided into active operations and passive notification operations. Among them, active operations include timing DDL/DML operations, and passive notification operations include setting timing rules. A notification action or a notification action that satisfies rule data.

The graph database system can be accessed through the DLR distributed component. Specifically, the updated data in the graph database system can be synchronized to other graph database systems through the DLR distributed component, or the data in other graph database systems can be synchronized to the graph. in the database system.

The graph database system applied in the embodiment of the present application can be deployed in various terminal devices, and the embodiment of the present application does not specifically limit the types of terminal devices; for example, it can be deployed in routers, switches, firewalls, and WLAN products.

The method provided in the embodiment of the present application will be specifically introduced below.

Application scenario of the method provided by the embodiment of the present application: the method provided by the embodiment of the present application can be applied to the database system, and the database system can not only be the above-mentioned graph database system, but also a time series database system, a flow database system or a flow graph database system .

Taking the graph database system as an example, since the method provided by the embodiment of the present application can guarantee a low delay in synchronous writing, the embodiment of the present application is especially suitable for some graph database systems with high performance requirements. For example, the business of a graph database system with high performance requirements can be forwarding management business. Forwarding management business is the core business of switches and has great requirements on data read and write performance.

As shown in Figure 5, this application provides an embodiment of a method for writing data segments, which is applied to a graph database system. The graph database system includes a second storage space and N first storage spaces, where N is positive integer.

Among them, the graph database system can be understood as the above graph database system, the first storage space can be understood as the first memory in Figure 1, and the second storage space can be understood as the second memory in Figure 1; for details, refer to Figure 1 The relevant descriptions of .understand the first storage space and the second storage space.

Based on the above graph database system, this embodiment includes:

Step 101, the first thread determines a target storage space from N first storage spaces.

It can be understood that step 101 needs to be performed only when N is greater than 1, so step 101 is optional.

The first thread may also be called a main thread, a business thread or a working thread, and specifically refers to a thread of a client running a database.

It should be understood that in the first storage space, data is usually stored in the form of tables, and the tables in the first storage space may be marked with tags.

Based on this, step 101 may include: the first thread determines the target storage space from the N first storage spaces according to the label corresponding to the target data and the corresponding relationship between the label and the first storage space, and the label indicates the storage space used to store the target data surface.

Step 102, the first thread obtains the redo log according to the target data, the redo log is used to represent the target data and the write operation of the target data, and the write operation is used to convert the target data into graph model data and write the graph model data into the second storage.

It should be noted that since the foregoing descriptions are made on redo logs, the redo logs can be understood by referring to the foregoing descriptions; there are various formats of redo logs, which are not specifically limited in this embodiment of the present application. In addition, the method of obtaining the redo log according to the target data is a relatively mature technology, which is not described in detail in this embodiment of the present application.

Step 103, the first thread writes the redo log into the target storage space, where the target storage space is one of the N first storage spaces.

The second thread refers to a worker thread of the database.

It can be understood that, when the first thread writes redo logs to the target storage space, a concurrency situation may occur, wherein the concurrency situation refers to the situation that other threads need to perform read or write operations on the target storage space.

When concurrency occurs, the corresponding lock mechanism can be used to control the concurrency.

The selection method of the locking mechanism is as follows.

First of all, for the target storage space, the load characteristics are as follows: Based on the description of the first memory in the previous section, it can be known that, usually, each type of service corresponds to a first storage space, and other types of services perform read operations or write operations on the target storage space. Operation is very unlikely. Generally, only when the first thread writes redo logs to the first storage space, and the second thread plays back the redo logs in the target storage space, concurrency may occur; however, based on the data merging mechanism, usually, The operation of writing the redo log by the first thread and playing back the redo log by the second thread will be performed at different times, and the data merging mechanism will be described below.

Normally, the combination of physical locks and transaction locks can handle various conflict scenarios, but based on the above load characteristics, when the first thread writes to the target storage space, the possibility of concurrency is less, that is, in the target storage space The conflicts that arise are minor. Therefore, only the physical lock can be selected to handle the concurrency that occurs, and for the physical lock, there are multiple locking mechanisms for handling the concurrency. Based on the load characteristics of small conflicts, the embodiment of the present application can adopt a simple lock mechanism. To reduce the delay in the process of synchronous writing. Specifically, step 103 may include:

The first thread writes the redo log into the target storage space through the strict two-stage lock mechanism of the physical lock.

It should be noted that compared with other locking mechanisms of physical locks, the strict two-phase locking mechanism of physical locks (Strict 2Phase Locking) is relatively simple, so it can reduce the delay of writing redo logs; and, the strict two-phase locking mechanism of physical locks The segment lock mechanism does not include database object locks, which can reduce the overhead of locks.

After step 103 is executed, the data in the target storage space may be merged into the second storage space based on the set data merging mechanism.

There are multiple data merging mechanisms, which are not specifically limited in this embodiment of the present application. The data merging mechanism is introduced below through step 104 and step 107 .

Step 104, the first thread sends a request to the second thread, and the request is used to instruct the second thread to replay the redo logs in the target storage space.

After step 103 is executed, step 104 may be used to notify the second thread to play back the redo log, so as to merge the data in the first storage space into the second storage space; it should be noted that if the notification is not received, the second thread The second thread can also replay the redo log by itself, so step 104 is optional.

There are many situations in which the first thread sends a request to the second thread, which is not specifically limited in this embodiment of the present application.

As an implementable manner, step 104 includes: when the used storage space in the target storage space reaches a first threshold, the first thread sends a request to the second thread.

It can be understood that since the used storage space in the target storage space reaches the first threshold, it indicates that the remaining space in the target storage space is limited, so a request may be actively sent to the second thread.

Specifically, when the first thread needs to write the redo log of new data, it judges the used storage space in the target storage space, so as to prevent the situation that the remaining space in the target storage space is limited and cannot store new data. Redo logs.

As another implementable manner, step 104 includes: the first thread sends a request to the second thread in response to a service requirement.

It should be noted that, the embodiment of the present application does not specifically limit the content of the service requirement.

For example, the business requirement includes: the latest data in the graph database system needs to be read from the second storage space. Based on this, if the redo logs in the first storage space have not been played back, the data in the second storage space is not up-to-date. At this time, in response to the business requirement, the first thread can actively send a request to the second thread.

Step 105, the second thread reads the redo log in the target storage space, the target storage space is one of the N first storage spaces, the redo log is used to represent the target data and the write operation of the target data, and the write operation is used for converting the target data into graph model data and writing the graph model data into the second storage space;

The reading of redo logs by the second thread may include active reading and passive reading, which will be described in detail below.

As an implementable manner, step 105 includes: the second thread periodically reads redo logs in the target storage space.

Specifically, a timed task can be set for the second thread, so that the second thread regularly checks each first storage space including the target storage space, and if the target storage space does not currently have a designated data merge operation, it will actively read Redo logs in the target storage space to complete the data consolidation operation.

The above situation can be understood as the situation where the second thread actively reads the redo log, and the following describes the situation where the second thread passively reads the redo log.

As another practicable manner, step 105 includes:

When receiving a request from the first thread, the second thread reads the redo logs in the target storage space, and the request is used to instruct the second thread to play back the redo logs in the target storage space The redo log is used to write the graph model data corresponding to the target data into the second storage space.

It should be noted that the request can be specifically understood with reference to the situation in step 104 .

Step 106, the second thread plays back the redo logs in the target storage space to perform the write operation.

Specifically, the second thread can replay the redo log line by line, so as to realize data merging.

The process of replaying redo logs by the second thread will be described below with reference to FIG. 6 .

As shown in Figure 6, redo logs generally include start transaction (T1) operation, write (write) A (T1) operation, start transaction (T2) operation, write B (T1) operation, write C ( T2) operation, commit (T1) operation, and commit (T2) operation.

In the process of playing back the redo log, the second thread will call the corresponding application programming interface (Application Programming Interface, API) of the database to write the graph model data corresponding to the target data into the second storage space.

As shown in Figure 6, the APIs called by the second thread are start transaction API (used to execute the start transaction T1 operation), write API (used to execute the write A operation), start transaction API (used to execute the start transaction T2 operation) , write API (used to execute write B operation), write API (used to execute write C operation), start transaction API (used to execute and complete T1 operation), start transaction API (used to execute and complete T2 operation).

When the second thread plays back the redo log, it needs to perform a write operation to the second storage space, which is similar to the first thread writing the redo log, and the second thread may also have concurrency in the process of playing back the redo log; When concurrency occurs, the corresponding lock mechanism can be used to control the concurrency.

The selection method of the locking mechanism is as follows.

First of all, for the second storage space, the load characteristics are as follows: the transactions in the second storage space mainly include data write transactions and read-only transactions of threads; although there may be multiple first storage spaces, each first storage space corresponds to The write transaction in the first storage space is only responsible for merging the data in the first storage space to a specific storage location in the second storage space, so there is no conflict between the write transactions corresponding to multiple first storage spaces; based on this, Conflicts mainly occur between a thread's write transaction and a thread's read-only transaction.

Based on the above load characteristics, when the second thread performs a write operation on the target storage space, a lock mechanism with a lower cost for read and write operations can be selected.

Specifically, step 106 includes: the second thread replays the redo logs in the target storage space through a multi-version two-phase locking mechanism (Multi-Version 2Phase Locking, MV2PL) mechanism.

When a concurrent situation (which can be understood as requiring both data read and write operations) occurs, the two-stage lock mechanism of the MV2PL multi-version allows read operations and write operations to be performed at the same time without waiting for an operation ( For example, another operation (such as a read operation) is performed after the completion of the write operation, so the cost is small, and the overhead of the second thread in the playback redo log process can be reduced.

Step 107, the second thread deletes redo logs in the target storage space.

After replaying the redo log, deleting the redo log can ensure that there is enough remaining space in the target storage space so that the first thread can write new data into the redo log.

It can be seen that in the embodiment of this application, the target storage space is mainly responsible for storing the redo logs of newly added data. Simply put, the target storage space is responsible for storing incremental data; correspondingly, the second storage space is responsible for storing the full amount data.

According to the description of step 101 to step 107, it can be seen that in the embodiment of the present application, the transaction of writing target data in the graph database is decomposed into two transactions: user transaction and system transaction. User transaction refers to the transaction running in the first storage space, which is used to write the redo log encapsulated by the target data into the target storage space, and do some necessary checks, which include constraint checks and uniqueness checks wait. In addition, user transactions are also used to implement data visibility control through reverse order access, and achieve concurrency control through the lock mechanism, ensuring the correctness of concurrent read and write in the first storage space. System transactions refer to transactions running in the second storage space, used to play back redo logs, maintain the index of graph model data in the second storage space, and trigger operations such as subscription push.

Reverse order access refers to accessing data in the order from late to early when the data is generated. Taking logs as an example, the database can contain many logs, and different logs correspond to different generation times. Reverse order access refers to accessing the logs generated later. Revisit earlier generated logs.

The above two transactions ensure the transactionality of the graph database system and improve the reliability and availability of the database system.

As shown in Figure 7, the process of writing target data using the method provided by the embodiment of the present application includes: the first thread writes the redo log of the target data into the target storage space, and returns the result of successful writing; the second thread reads Redo logs in the target storage space, and replay the redo logs; after replaying the redo logs, delete the redo logs that have been played back in the target storage space.

The process of writing to the graph database system is introduced above, and the process of reading the graph database system is introduced below.

Based on the foregoing description, it can be known that the database system includes a second storage space and N first storage spaces, and the following description will be made by taking a target storage space among the N first storage spaces as an example.

It can be understood that, during the writing process, the target data is first stored in the target storage space in the form of redo logs, and then stored in the second storage space after redo log playback.

Therefore, when the target data needs to be read, the target data may be stored in the target storage space or in the second storage space.

Therefore, the third thread can query the target storage space first, and then query the second storage space; the third thread can also directly query the second storage space.

Taking querying the target storage space first, and then querying the second storage space as an example, there are two cases: the first case is that the redo logs corresponding to the target data are stored in the target storage space, but the target data is not stored in the second storage space ; The second case is that the target data is stored in the second storage space.

For the first case above, please refer to FIG. 8 , the data reading method includes the following steps.

Step 108, the third thread obtains the database primary key corresponding to the target data.

A database primary key is usually a selected portion of the target data whose value uniquely identifies each row in the table.

It can be understood that in the database, data is stored in the form of a table, and the table contains multiple rows, and each row stores data.

Step 109, the third thread reads redo logs from the target storage space according to the database primary key.

The target storage space is one of the N first storage spaces. The redo log is used to represent the target data and the write operation of the target data. The write operation is used to convert the target data into graph model data and write the graph model data into the second storage.

The third thread refers to the data reading thread, which may be the same as the first thread mentioned above.

Since the third thread can obtain the target data by reading the redo log without performing a conversion operation from the graph model data to the target data, the time delay for reading the target data can be reduced.

As an implementable manner, before step 109, the method further includes:

The third thread determines the identifier of the writing transaction of the target data according to the database primary key;

The third thread determines that the target storage space contains a transaction commit log according to the identifier of the write transaction, and the transaction commit log is used to indicate that the write transaction has been committed.

It can be understood that, for a transaction in the database, the transaction commit log is used to indicate that the transaction has been committed; similarly, in the embodiment of the present application, the transaction commit log is also used to indicate that the writing transaction has been committed.

If the write transaction has been submitted, it means that the target data has completed the writing process, and other users can read the target data; if the write transaction is not committed, it means that the target data has not completed the writing process, and other users cannot read it the target data.

It should be noted that since the storage location of the transaction commit log is usually after the storage location of the log written to the transaction, when looking for whether the target storage space contains the transaction commit log, you can use the reverse order access method mentioned above to traverse, so that Find out whether the target storage space contains transaction commit logs as soon as possible.

For the second case above, the data reading method includes the following steps.

The third thread queries the target storage space according to the primary key of the database; if the target storage space does not contain the target data, the third thread queries the second storage space according to the primary key of the database to obtain the target data.

In this embodiment, the third thread queries the target storage space first, and then queries the second storage space if the target data is not found.

Based on the above description, in the data writing process, the target data is first written into the target storage space in the form of redo logs, and then the target data is written into the second storage process through redo log playback; correspondingly, in During the data reading process, the target storage space and the second storage space may be queried successively to obtain the target data.

It can be seen that, in the embodiment of the present application, two reads may be required to obtain the target data. Therefore, the embodiment of the present application reduces the writing delay of the target data by increasing the read delay.

Based on the previous description, the third thread can also directly query the second storage space. Specifically, the third thread reads the graph model data from the second storage space according to the database primary key, and the graph model data is stored in the target storage space played back by the second thread. The redo log obtained.

FIG. 9 is a schematic diagram of an embodiment of an apparatus for writing data segments according to an embodiment of the present application. As shown in FIG. 9, the present application provides an embodiment of a device for writing data segments, which is applied to a database system. The database system includes a second storage space and N first storage spaces, where N is a positive integer; The device includes: an encapsulation unit 201, configured to obtain a redo log according to the target data, the redo log is used to represent the target data and the write operation of the target data, and the write operation is used to convert the target data into graph model data and write the graph model data into the second storage space.

The writing unit 202 is configured to write redo logs into a target storage space, where the target storage space is one of the N first storage spaces.

As an implementable manner, the device further includes: a sending unit 203, configured to send a request to the second thread, and the request is used to instruct the second thread to replay the redo logs in the target storage space, so as to model the graph corresponding to the target data Data is written into the second storage space.

As an implementable manner, the sending unit 203 is configured to send a request to the second thread when the used storage space in the target storage space reaches a first threshold.

As an implementable manner, the sending unit 203 is configured to send a request to the second thread in response to a service requirement.

As a practicable manner, the device further includes: a determining unit 204, configured to determine a target storage space from the N first storage spaces.

As a practicable manner, the determining unit 204 is configured to determine the target storage space from the N first storage spaces according to the label corresponding to the target data and the corresponding relationship between the label and the first storage space, and the label indicates that it is used to store A table of target data.

As a practicable manner, the writing unit 202 is configured to write the redo log into the target storage space through the strict two-stage locking mechanism of the physical lock.

Wherein, for the specific implementation, relevant description and technical effects of the above units, please refer to the relevant description in the method part.

FIG. 10 is a schematic diagram of an embodiment of an apparatus for writing data segments according to an embodiment of the present application. As shown in Figure 10, the present application provides another embodiment of a device for writing data segments, which is applied to a database system, and the database system includes a second storage space and N first storage spaces, where N is a positive integer The device includes: a reading unit 301, used for the second thread to read the redo log in the target storage space, the target storage space is one of the N first storage spaces, and the redo log is used to represent the target data and the target data The write operation is used to convert the target data into graph model data and write the graph model data into the second storage space; the replay unit 302 is used to replay redo logs in the target storage space to perform the write operation.

As a practicable manner, the reading unit 301 is configured to periodically read redo logs in the target storage space.

As an implementable manner, the reading unit 301 is configured to read the redo logs in the target storage space when receiving a request from the first thread, and the request is used to instruct the second thread to replay the target storage space Redo logs in to store the graph model data in the secondary storage space.

As an implementable manner, the replay unit 302 is used for the second thread to replay the redo logs in the target storage space through a multi-version two-segment lock mechanism.

As a practicable manner, the device further includes a deletion unit 303, configured to delete redo logs in the target storage space.

Wherein, for the specific implementation, relevant description and technical effects of the above units, please refer to the relevant description in the method part.

FIG. 11 is a schematic diagram of an embodiment of a data reading device provided in an embodiment of the present application. As shown in Figure 11, the present application provides an embodiment of a data reading device, which is applied to a database system, and the database system includes a second storage space and N first storage spaces, wherein N is a positive integer; the device includes : the obtaining unit 401 is used to obtain the database primary key corresponding to the target data; the reading unit 402 is used to read the redo log from the target storage space according to the database primary key, or to read the redo log from the second storage space according to the database primary key Graph model data, the graph model data is obtained according to the redo log in the target storage space played back by the second thread; the target storage space is one of the N first storage spaces, and the redo log is used to represent the target data and the target data A write operation, the write operation is used to convert the target data into graph model data and write the graph model data into the second storage space.

As a practicable manner, the reading unit 402 is configured to query the target storage space according to the primary key of the database, so as to obtain the target data.

As an achievable manner, the reading unit 402 is configured to determine the identifier of the write transaction of the target data according to the database primary key; according to the identifier of the write transaction, determine that the target storage space contains a transaction commit log, and the transaction commit log is used for Indicates that the write transaction has committed.

Wherein, for the specific implementation, relevant description and technical effect of each of the above units, please refer to the relevant description of the third aspect.

Please refer to Figure 12, Figure 12 is a schematic structural diagram of a terminal device provided in the embodiment of the present application, which is specifically used to realize the function of the data segment writing device in the embodiment corresponding to Figure 9, and the data segment in the embodiment corresponding to Figure 10 The function of the writing device or the function of the data reading device in the corresponding embodiment in FIG. 11; the terminal device 1800 may have relatively large differences due to different configurations or performances, and may include one or more central processing units (central processing units, CPUs) ) 1822 (eg, one or more processors) and memory 1832, one or more storage media 1830 (eg, one or more mass storage devices) that store application programs 1842 or data 1844. Wherein, the memory 1832 and the storage medium 1830 may be temporary storage or persistent storage. The program stored in the storage medium 1830 may include one or more modules (not shown in the figure), and each module may include a series of instruction operations on the terminal device. Furthermore, the central processing unit 1822 may be configured to communicate with the storage medium 1830 , and execute a series of instruction operations in the storage medium 1830 on the terminal device 1800 .

The terminal device 1800 can also include one or more power supplies 1826, one or more wired or wireless network interfaces 1850, one or more input and output interfaces 1858, and/or, one or more operating systems 1841, such as Windows Server™, Mac OS XTM, UnixTM, LinuxTM, FreeBSDTM, etc.

In the embodiment of the present application, the central processing unit 1822 may be configured to execute the data segment writing method performed by the data segment writing device in the embodiment corresponding to FIG. 9 . Specifically, the central processing unit 1822 can be used for:

A redo log is obtained according to the target data, and the redo log is used to represent the target data and a write operation of the target data, and the write operation is used to convert the target data into graph model data and write the graph model data into the second storage space;

Write the redo log into the target storage space, where the target storage space is one of the N first storage spaces.

In the embodiment of the present application, the central processing unit 1822 may be configured to execute the data segment writing method performed by the data segment writing device in the embodiment corresponding to FIG. 10 . Specifically, the central processing unit 1822 can be used for:

Read the redo log in the target storage space. The target storage space is one of the N first storage spaces. The redo log is used to represent the target data and the write operation of the target data. The write operation is used to convert the target data into a graph Model data and write the graph model data into the second storage space;

Replay the redo logs in the target storage space for write operations.

In the embodiment of the present application, the central processing unit 1822 may be used to execute the data reading method performed by the data reading device in the embodiment corresponding to FIG. 11 . Specifically, the central processing unit 1822 can be used for:

Obtain the database primary key corresponding to the target data;

Read the redo logs from the target storage space according to the database primary key, or, the third thread reads the graph model data from the second storage space according to the database primary key, and the graph model data is based on the redo logs in the target storage space played back by the second thread owned;

The target storage space is one of the N first storage spaces. The redo log is used to represent the target data and the write operation of the target data. The write operation is used to convert the target data into graph model data and write the graph model data into the second storage.

The embodiment of the present application also provides a chip, including one or more processors. Part or all of the processor is used to read and execute the computer program stored in the memory, so as to execute the methods of the foregoing embodiments.

Optionally, the chip includes a memory, and the memory and the processor are connected to the memory through a circuit or wires. Further optionally, the chip further includes a communication interface, and the processor is connected to the communication interface. The communication interface is used to receive data and/or information to be processed, and the processor obtains the data and/or information from the communication interface, processes the data and/or information, and outputs the processing result through the communication interface. The communication interface may be an input-output interface.

In some implementations, some of the one or more processors may implement some of the steps in the above method through dedicated hardware, for example, the processing related to the neural network model may be performed by a dedicated neural network processor or graphics processor to achieve.

The method provided in the embodiment of the present application may be implemented by one chip, or may be implemented by multiple chips in cooperation.

The embodiment of the present application also provides a computer storage medium, which is used for storing computer software instructions used by the above-mentioned computer equipment, including instructions for executing a program designed for the computer equipment.

The computer device may have the same functions as the data segment writing device in the embodiment corresponding to FIG. 9 , the data segment writing device in the embodiment corresponding to FIG. 10 , or the data reading device in the embodiment corresponding to FIG. 11 .

The embodiment of the present application also provides a computer program product, the computer program product includes computer software instructions, and the computer software instructions can be loaded by a processor to implement the procedures in the methods shown in the foregoing embodiments.

The above is only the specific implementation of the application, but the scope of protection of the application is not limited thereto. Anyone familiar with the technical field can easily think of changes or replacements within the technical scope disclosed in the application, and should cover Within the protection scope of this application.

Claims (22)

1. A data segment writing method, characterized in that it is applied to a database system, and the database system includes a second storage space and N first storage spaces, where N is a positive integer;

   The methods include:

   The first thread obtains a redo log according to the target data, the redo log is used to represent the target data and a write operation of the target data, and the write operation is used to convert the target data into graph model data and The graph model data is written into the second storage space;

   The first thread writes the redo log into a target storage space, and the target storage space is one of the N first storage spaces.
2. The method according to claim 1, further comprising:

   The second thread reads the redo logs in the target storage space;

   The second thread plays back redo logs in the target storage space to perform the write operation.
3. The method according to claim 1 or 2, characterized in that the method further comprises:

   The first thread sends a request to the second thread, and the request is used to instruct the second thread to play back the redo log in the target storage space.
4. The method according to claim 3, wherein the first thread sending a request to the second thread comprises:

   When the used storage space in the target storage space reaches a first threshold, the first thread sends a request to the second thread.
5. The method according to claim 3, wherein the first thread sending a request to the second thread comprises:

   In response to business requirements, the first thread sends a request to the second thread.
6. The method according to claim 5, wherein when N is greater than 1, the method further comprises:

   The first thread determines the target storage space from the N first storage spaces according to the label corresponding to the target data and the corresponding relationship between the label and the first storage space, the label indicating A table used to store the target data.
7. The method according to any one of claims 1 to 6, wherein writing the redo log into the target storage space by the first thread comprises:

   The first thread writes the redo log into the target storage space through the strict two-stage lock mechanism of the physical lock.
8. The method according to any one of claims 1 to 6, wherein after the first thread writes the redo log into the target storage space, the method further comprises:

   The first thread writes a transaction commit log into the target storage space, and the transaction commit log is used to indicate that the write transaction of the target data has been committed.
9. A data segment writing method, characterized in that it is applied to a database system, and the database system includes a second storage space and N first storage spaces, wherein N is a positive integer;

   The methods include:

   The second thread reads a redo log in a target storage space, where the target storage space is one of the N first storage spaces, and the redo log is used to represent the target data and the target data a write operation, the write operation is used to convert the target data into graph model data and write the graph model data into the second storage space;

   The second thread plays back redo logs in the target storage space to perform the write operation.
10. The method according to claim 9, wherein reading the redo logs in the target storage space by the second thread comprises:

    The second thread periodically reads redo logs in the target storage space.
11. The method according to claim 9, wherein reading the redo logs in the target storage space by the second thread comprises:

    When receiving a request from the first thread, the second thread reads the redo logs in the target storage space, and the request is used to instruct the second thread to play back the redo logs in the target storage space The redo log is used to store the graph model data in the second storage space.
12. The method according to any one of claims 9 to 11, wherein playing back the redo logs in the target storage space by the second thread comprises:

    The second thread plays back the redo logs in the target storage space through a multi-version two-segment lock mechanism.
13. The method according to any one of claims 9 to 12, wherein after the second thread plays back the redo logs in the target storage space, the method further comprises:

    The second thread deletes redo logs in the target storage space.
14. A data reading method, characterized in that it is applied to a database system, and the database system includes a second storage space and N first storage spaces, where N is a positive integer;

    The methods include:

    The third thread obtains the database primary key corresponding to the target data;

    The third thread reads redo logs from the target storage space according to the database primary key, or the third thread reads graph model data from the second storage space according to the database primary key, and the graph model The data is obtained by replaying the redo logs in the target storage space by the second thread;

    The target storage space is one of the N first storage spaces, the redo log is used to represent the target data and a write operation of the target data, and the write operation is used to store the target data converting into graph model data and writing the graph model data into the second storage space.
15. The method according to claim 14, wherein before the third thread reads redo logs from the target storage space according to the database primary key, the method further comprises:

    The third thread determines the identifier of the writing transaction of the target data according to the database primary key;

    The third thread determines, according to the identifier of the write transaction, that the target storage space contains a transaction commit log, and the transaction commit log is used to indicate that the write transaction has been committed.
16. A data segment writing device, characterized in that it is applied to a database system, and the database system includes a second storage space and N first storage spaces, where N is a positive integer;

    The devices include:

    An encapsulation unit, configured to obtain a redo log according to the target data, where the redo log is used to represent the target data and a write operation of the target data, and the write operation is used to convert the target data into graph model data and writing the graph model data into the second storage space;

    A writing unit, configured to write the redo log into a target storage space, where the target storage space is one of the N first storage spaces.
17. A data segment writing device, characterized in that it is applied to a database system, and the database system includes a second storage space and N first storage spaces, where N is a positive integer;

    The devices include:

    A reading unit, configured to read a redo log in a target storage space, the target storage space is one of the N first storage spaces, the redo log is used to represent target data and the target data A write operation, the write operation is used to convert the target data into graph model data and write the graph model data into the second storage space;

    The replay unit is used to replay the redo logs in the target storage space to execute the write operation.
18. A data reading device, characterized in that it is applied to a database system, and the database system includes a second storage space and N first storage spaces, where N is a positive integer;

    The devices include:

    The obtaining unit is used to obtain the database primary key corresponding to the target data;

    A reading unit, configured to read redo logs from the target storage space according to the database primary key, or to read graph model data from the second storage space according to the database primary key, the graph model data according to Obtained from the redo logs in the target storage space played back by the second thread;

    The target storage space is one of the N first storage spaces, and the redo log is used to represent the target data and a write operation of the target data, and the write operation is used to store the target data converting into graph model data and writing the graph model data into the second storage space.
19. A terminal device, characterized in that the terminal device includes: a memory and a processor, wherein N is a positive integer;

    The processor is configured to execute computer programs or instructions stored in the memory, so that the terminal device executes the method according to any one of claims 1-15.
20. A computer-readable storage medium, characterized in that the computer-readable storage medium has program instructions, and when the program instructions are executed directly or indirectly, the method according to any one of claims 1 to 15 is executed accomplish.
21. A chip system, characterized in that the chip system includes at least one processor, and the processor is used to execute a computer program or an instruction stored in a memory, when the computer program or the instruction is executed on the at least one processor When executed, the method according to any one of claims 1 to 15 is realized.
22. A computer program product, characterized by comprising instructions, which, when run on a computer, cause the computer to execute the method according to any one of claims 1 to 15.

Images