Patent Description:
Usually, a small computer system is used for a distributed database, each computer may be placed in a separate place, each computer may have a complete copy or a partial copy of a database management system (DBMS), and has its own local database, and many computers in different locations are connected to one another through a network to jointly form a complete and global large database logically centralized and physically distributed.

A graphic database is a non-relational database in which relationship information between entities is stored using a graph theory. A most common example is an interpersonal relationship in a social network. A relational database has a poor effect of storing "relational" data, and its query is complex, slow and beyond expectation, and a unique design of the graphic database just makes up for the defect.

A distributed graph database system has advantages of both the distributed database and the graphic database, and has advantages of simplicity, easiness in use, a high performance, or the like. From <CIT>, a system and method for distributed query processing is known which may compile and optimize query plans for incoming query requests independent of hardware configurations and/or physical locations of data partitions in a distributed storage system (e.g., a data grid).

The present disclosure provides a query processing method and apparatus, an electronic device and a storage medium, as specified in the appended claims.

The drawings are used for better understanding the present solution and do not constitute a limitation of the present disclosure. In the drawings,.

The following part will illustrate exemplary embodiments of the present disclosure with reference to the drawings, including various details of the embodiments of the present disclosure for a better understanding.

It should be noted that a terminal device in the embodiments of the present disclosure may include, but is not limited to, a mobile phone, a personal digital assistant (PDA), a wireless handheld device, a tablet computer, and other smart devices; a display device may include, but not limited to, a personal computer, a television, and other devices with a display function.

In addition, the term "and/or" only describes an association relationship between associated objects, and indicates that three relationships may exist. For example, A and/or B may indicate three cases: only A exists; both A and B exist; and only B exists. In addition, in this specification, the symbol "/" generally indicates that associated objects have a relationship of "or".

In a distributed graph database system, computing nodes are separated from storage nodes. As a party receiving a request, the computing node splits an external retrieval request into a plurality of small query requests, and performs data query to the storage node based on each query request. When the retrieval request is complex, the split small query requests have a large number, and a storage request service is easily filled up.

After a storage node service is filled up, the storage node returns an error message of a busy service. At this point, the computing node may retry the query or directly return entire query failure to a user, resulting in a low query efficiency.

Pressure of the storage node may not be relieved by the retrying of the query when the storage node service is filled up. Since each retrieval request is desired to be completed as quickly as possible, the computing node resends all the query requests obtained by splitting the retrieval request to the storage node, and therefore, when the storage node is filled up, the retrying of the query still takes up a lot of responsiveness of the storage service, such that some simple small requests are difficult to complete.

For the direct return of the entire query failure, it seems that the busy service caused by the current request is solved, but in practice, completed calculation for the entire large query is wasted, and the calculation completed by a system consuming a lot of resources previously is wasted due to the direct return of the failure. At this point, the storage node may provide services, but not at a speed required by the computing node. Then, if the query failure is returned to the user, the user may retry the query by himself, and the practical problem is not solved. Based on the above, the technical solution of the present disclosure is provided to improve the query efficiency.

<FIG> is a schematic diagram according to a first embodiment of the present disclosure; as shown in <FIG>, the present embodiment provides a query processing method, which may be applied to a computing node side of a distributed graph database system, and include the following steps of:.

In the present embodiment, the retrieval request is sent externally, for example, by a user through an electronic device to a computing node of the distributed graph database system.

In practical applications, the computing node receives the retrieval request and directly splits the retrieval request into a plurality of query requests. Based on each query request, a storage node may be positioned according to a traditional method of positioning a storage node, and then, the query request is sent to the corresponding storage node to obtain a query result. Calculation is performed based on the query results of the plural query requests to obtain a result of the retrieval request, and the result is returned to the electronic device of the user to realize retrieval. The method of positioning a storage node may include, but is not limited to, a method of positioning a storage node by calculating a Hash value or by a pre-established storage relationship table. For example, the retrieval request may be a simple request of querying a certain number, or a complex request of first calculating an average of M numbers and an average of N numbers, and then taking a squared difference between the average of the M numbers and the average of the N numbers.

In the embodiment of the present disclosure, in order to improve the query efficiency, after receiving the retrieval request, the computing node firstly analyzes the type of the retrieval request, and then pertinently performs the query processing operation on the retrieval request based on the type of the retrieval request, so as to improve the query processing efficiency.

In the query processing method according to the present embodiment, the type of the received retrieval request is analyzed, and then, the query processing operation is performed on the retrieval request based on the type of the retrieval request, such that different query processing operations may be pertinently performed on different types of retrieval requests, thus effectively improving the query processing efficiency.

<FIG> is a schematic diagram according to a second embodiment of the present disclosure; the technical solution of a query processing method according to the present embodiment of the present disclosure is further described in more detail based on the technical solution of the above-mentioned embodiment shown in <FIG>. As shown in <FIG>, the query processing method according to the present embodiment includes the following steps of:
S201: splitting a retrieval request into several query requests.

Each retrieval request is split into a certain number of query requests. For example, the computing node receives a retrieval request of averaging plural numbers. The computing node is required to split the retrieval request into query requests for querying all the numbers, and then calculate an average based on each number queried by the query request.

S202: detecting whether a quantity of the several query requests exceeds a preset quantity threshold; if no, executing step S203; if yes, executing step S204.

S203: determining the retrieval request to be a simple query, and executing step S205.

S204: determining the retrieval request to be a complex query, and executing step S206.

In the present embodiment, the preset quantity threshold may be set according to practical experience, and may be, for example, <NUM>, or <NUM>, or other numbers, which is not limited herein.

If the quantity of the several query requests does not exceed the preset quantity threshold, that is, is less than or equal to the preset quantity threshold, it may be considered that the quantity of the query requests obtained by splitting the retrieval request is reduced at this point, and the retrieval request is a simple query. Otherwise, if the quantity of the several query requests is greater than the preset quantity threshold, it may be considered that the quantity of the query requests obtained by splitting the retrieval request is large at this point, and the retrieval request is a complex query.

The above-mentioned steps S201-S204 are an implementation of the above-mentioned step <NUM> in the embodiment shown in <FIG>. In the present embodiment, for example, the type of the retrieval request includes a simple query and a complex query. In practical applications, on the analogy of this principle, the query may be divided into more types based on different quantity thresholds; for example, the query may be divided into three types including a simple query, a general query and a complex query, and a number of the general query is between a number of the simple query and a number of the complex query. By adopting the solution, the retrieval request may be accurately classified, and different query processing operations may be effectively performed on different types of retrieval requests, thereby improving the query processing efficiency.

S205: after receiving a feedback message of a busy service returned by a first storage node based on a first query request in the several query requests, continuously sending the first query request to the first storage node, and ending.

The first query request may be any one of the several query requests. The first storage node is any storage node.

After obtaining the several query requests by the splitting operation, the computing node may traditionally position the storage node corresponding to each query request. To improve a processing efficiency of the computing node, the computing node in the distributed graph database system may be set to have high concurrency, and send plural query requests to plural storage nodes simultaneously. For example, the concurrency of the computing node may reach <NUM>, <NUM>, or other values. For each query request, if the service of the corresponding storage node is normal, data queried by the query request is returned to the computing node. However, each storage node has a limited service capability, and is required to simultaneously receive the query request of each computing node in the distributed graph database system, such that a service of the storage node may be filled up; at this point, the storage node is unable to provide a query service for the query request of the computing node, and may return the feedback message of a busy service to the computing node.

When the retrieval request is a simple query, since the number of the included query requests is limited, and the retrieval request may be guaranteed to have a response as far as possible, the computing node continuously sends the corresponding first query request to the first storage node when receiving the feedback message of a busy service returned by the first storage node.

S206: after receiving a feedback message of a busy service returned by a second storage node based on a second query request in the several query requests, lowering concurrency of requesting queries to all storage nodes; executing step S207.

S207: based on the adjusted concurrency, performing a query processing operation on the second query request; executing step S208.

In the present embodiment, the second query request may be any one of the several query requests, and the second storage node is any storage node.

When the retrieval request is a complex query, considering that the query requests obtained by splitting the retrieval request have a large number, if the retrieval request of each complex query is simultaneously sent to each storage node with high concurrency on each computing node, the storage node is unable to process all the query requests in time, such that all the retrieval requests may not have responses in time. At this point, in order to reduce query congestion of the storage node and strive a maximum resource for each retrieval request, the concurrency of requesting the queries to all the storage nodes may be lowered when the feedback message of a busy service returned by the second storage node is received; and then, based on the adjusted concurrency, the query processing operation is performed on the second query request.

The steps S206-S207 are an implementation of the step S102 in the embodiment shown in <FIG>. The steps S206-S207 may be applied in a scenario where the concurrency of the computing node is lowered for the first time. For example, when the concurrency is lowered for the first time, a lowered amplitude may be the maximum service capability supported by one storage node, such as <NUM> worker threads or other values, which is not limited herein.

According to the invention, step S207 specifically includes the following steps: detecting whether the current concurrency is less than the adjusted concurrency; and if yes, sending the second query request to the second storage node, and ending. Otherwise, if no, the detection continues, the second query request is not sent to the second storage node temporarily, and the second query request is sent to the second storage node only when the current concurrency is less than the adjusted concurrency.

In actual operations, when the concurrency N is constant, the computing node sends N query requests to plural storage nodes, and if query data of one query request is returned, the computing node sends a next query request in time, so as to fully utilize the high concurrency for the query.

In the scenario of the present embodiment, when the computing node lowers the concurrency, since the previous concurrency is high, the previously sent query request may not have a response, and at this point, the concurrency is not reduced immediately. Therefore, the next query request may not be sent immediately after reception of the returned data of a certain query request, and the corresponding query request is also not sent immediately after reception of the returned feedback message of a busy service. Instead, whether the current real-time concurrency is less than the adjusted concurrency is required to be detected first, if no, the detection continues, and the sending operation may be performed only when the concurrency is less than the adjusted concurrency. With the technology, stable transition may be performed after adjustment of the concurrency, thus effectively guaranteeing the query efficiency.

S208: based on the lowered concurrency, detecting whether the feedback message of a busy service returned by any storage node based on any one of the several query requests is received; if yes, executing step S209; if no, continuing the detection.

This step occurs after steps S206-S207, and at this point, the concurrency of the computing node is lowered, but the feedback message of a busy service fed back by the storage node may still be received. At this point, it may be considered that the service capability of the storage node is still exceeded.

S209: detecting whether the current concurrency is less than a first preset threshold; if no, executing step S210; if yes, executing step S212.

For example, in the present embodiment, the first preset threshold may be set based on practical experience, and may be, for example, the maximum service capability of one storage node.

S210: continuously lowering the concurrency of requesting the queries to all storage nodes; executing step S211.

When the concurrency is not less than the first preset threshold, the concurrency may be lowered by a constant amplitude, for example, by the maximum service capability of one storage node. Certainly, in practical applications, the lowered amplitudes may be the same or different.

S211: based on the adjusted concurrency, performing a query processing operation on the query request corresponding to the feedback message of a busy service, returning to step S208, and continuing the detection.

For the processing procedure of step S211, reference may be made to the specific implementation of step S207, which is not repeated herein.

S212: detecting whether the current concurrency is less than a second preset threshold; if no, executing step S213; if yes, feeding failure of the retrieval request back to the user, and ending.

The second preset threshold is less than the first preset threshold, and a numerical value of the second preset threshold in the present embodiment may also be set based on practical experience. The second preset threshold is a minimum service capability of the system.

If the concurrency is less than the second preset threshold, it is considered that further reduction of the concurrency has no sense, the system is likely to break down, and the failure of the retrieval request may be directly fed back to the user, so as to avoid meaningless waiting of the user.

S213: determining the failure of the retrieval request according to a preset probability.

In the present embodiment, the preset probability may be selected based on practical experience, for example, <NUM>; that is, one half of the retrieval requests may be set to fail, and the other half of the retrieval requests may be set to continue. Or, in order to improve the query efficiency, fewer retrieval requests may be set to fail, and more retrieval requests may be set to be continuously queried. At this point, the preset probability may be set to any probability value less than <NUM> and greater than <NUM>. Or, if a load of the storage node is excessively large, more retrieval requests may be set to fail and fewer retrieval requests may be set to be continuously queried, and at this point, the preset probability may be set to any probability value greater than <NUM> and less than <NUM>.

For example, if the preset probability is <NUM>, a positive integer may be randomly generated using a random number generator, and options of failure and continuing of the retrieval request may be set for odd numbers and even numbers respectively. In practical applications, the specific implementation of the step may also be any other possible implementation, which is not limited herein.

S214: detecting whether a determined result of the retrieval request is failure; if yes, feeding the failure of the retrieval request back to the user, and ending; otherwise, executing step S215.

S215: continuously lowering the concurrency of requesting the queries to all storage nodes; executing step S216.

Since the concurrency of the computing node is less than the first preset threshold, for example, the maximum service capability of a single storage node, the continuous lowering amplitude may be slightly greater at this point; for example, the concurrency may be lowered at a halved speed.

S216: based on the adjusted concurrency, performing a query processing operation on the query request corresponding to the feedback message of a busy service, returning to step S208, and continuing the detection.

In the query processing method according to the present embodiment, by adopting the above-mentioned implementation, flow control may be performed on the query request on the computing node side, such that the retrieval request of the simple query is satisfied as much as possible, and the retrieval request of the complex query is satisfied by lowering the concurrency to strive for most resources; if the retrieval request is not satisfied after the concurrency is lowered, part of the retrieval requests may be determined to fail with the preset probability, so as to save the resources to serve the rest of the retrieval requests. If the feedback message of a busy service is still received when the concurrency is adjusted to the quite-small second preset threshold, the retrieval failure may be directly fed back to the user. With the technical solution of the present embodiment, the query flow of the retrieval request may be effectively controlled on the computing node side, thereby effectively improving the query processing efficiency.

<FIG> is a schematic diagram according to a third embodiment of the present disclosure; the technical solution of a query processing method according to the present embodiment of the present disclosure is further described in more detail based on the technical solution of the above-mentioned embodiments shown in <FIG> and <FIG>. As shown in <FIG>, the query processing method according to the present embodiment may include the following steps of:.

The preset duration in the present embodiment may be selected according to practical experience, for example, <NUM> minutes, one hour or other duration.

S307: increasing the concurrency of requesting the queries to all the storage nodes; executing step S308.

S308: based on the adjusted concurrency, performing the query processing operation on the several query requests included in the retrieval request.

In the present embodiment, the adjusted concurrency becomes larger, and a computing node may detect whether the current concurrency reaches the adjusted concurrency in real time, and if no, a next query request is supplemented in time for querying. Whether the concurrency reaches the adjusted concurrency is further detected, and if no, a next query request is continuously supplemented for querying until the concurrency reaches the adjusted concurrency, thus fully utilizing all query resources of a system to perform a query service.

In the solution of the present embodiment, after the storage node service is filled up and the concurrency of the computing node is lowered, whether the condition that storage of a service node is filled up does not occur within a period of time may be continuously detected, and if yes, the concurrency may be increased, so as to fully utilize all the query resources. In addition, optionally, if the service is filled up again after the concurrency is increased, the concurrency of the computing node may be continuously lowered according to step S304 or the description of the embodiment shown in <FIG>.

The technical solution of the present embodiment may also be used in combination with the technical solution of the embodiment shown in <FIG>, and after the concurrency is lowered each time, the solution of the embodiment shown in <FIG> may be adopted to attempt to increase the concurrency again.

<FIG> is a working principle diagram of a distributed graph database system according to the present embodiment, and as shown in <FIG>, the distributed graph database system may include a plurality of computing nodes and a plurality of storage nodes. Each computing node is configured to receive an external retrieval request. The computing node is also configured to split each retrieval request into several query requests. Then, the storage node of each query request is positioned, as shown in <FIG>, and the query request is sent to the corresponding storage node. To improve the querying efficiency, each computing node may send the query requests to the plural storage nodes with high concurrency. The technical solution of the present embodiment and the technical solution of the embodiment shown in <FIG> may be applied to any computing node shown in <FIG> to realize the query processing operation described in the above-mentioned embodiments.

In the query processing method according to the present embodiment, when the computing node does not receive the feedback message of a busy service within certain preset duration after the concurrency of the computing node is lowered, the concurrency may be increased, so as to more effectively utilize the query resources of the system, and further effectively improve the query processing efficiency.

<FIG> is a schematic diagram according to a fourth embodiment of the present disclosure; as shown in <FIG>, the present embodiment provides a query processing apparatus <NUM>, including:.

The query processing apparatus <NUM> according to the present embodiment has the same implementation as the above-mentioned relevant method embodiment by adopting the above-mentioned modules to implement the implementation principle and the technical effects of the query processing operation, and for details, reference may be made to the description of the above-mentioned relevant method embodiment, and details are not repeated herein.

Further, in one embodiment of the present disclosure, the analyzing module <NUM> is configured to:.

Further optionally, in one embodiment of the present disclosure, the query processing module <NUM> is configured to:
if the retrieval request is a simple query, after receiving a feedback message of a busy service returned by a first storage node based on a first query request in the several query requests, continuously send the first query request to the first storage node.

Further, in one embodiment of the present disclosure, the analyzing module <NUM> is further configured to:
if the number of the several query requests exceeds the preset quantity threshold, determine the retrieval request to be a complex query.

Further, in one embodiment of the present disclosure, the query processing module <NUM> is configured to:.

Further, in one embodiment of the present disclosure, the query processing module <NUM> is further configured to:.

Further, in one embodiment of the present disclosure, the query processing module <NUM> is further configured to:
detect and determine that the current concurrency is not less than a first preset threshold.

Further, in one embodiment of the present disclosure, the query processing module <NUM> is further configured to:
if detecting that the current concurrency is less than the first preset threshold, determine failure of the retrieval request according to a preset probability.

Further optionally, in one embodiment of the present disclosure, the query processing module <NUM> is further configured to:
if detecting that the current concurrency is less than the first preset threshold, and determining that the retrieval request does not fail, continuously lower the concurrency of requesting the queries to all the storage nodes.

Further optionally, in one embodiment of the present disclosure, the query processing module <NUM> is further configured to:.

The query processing apparatus has the same implementation as the above-mentioned relevant method embodiment by adopting the above-mentioned modules to implement the implementation principle and the technical effects of the query processing operation, and for details, reference may be made to the description of the above-mentioned relevant method embodiment, and details are not repeated herein.

In the technical solution of the present disclosure, the acquisition, storage and application of involved user personal information are in compliance with relevant laws and regulations, and do not violate public order and good customs.

According to the embodiment of the present disclosure, there are also provided an electronic device, a readable storage medium and a computer program product.

<FIG> shows a schematic block diagram of an exemplary electronic device <NUM> which may be configured to implement the embodiment of the present disclosure. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other appropriate computers. The electronic device may also represent various forms of mobile apparatuses, such as personal digital assistants, cellular telephones, smart phones, wearable devices, and other similar computing apparatuses. The components shown herein, their connections and relationships, and their functions, are meant to be exemplary only, and are not meant to limit implementation of the present disclosure described and/or claimed herein.

As shown in <FIG>, the device <NUM> includes a computing unit <NUM> which may perform various appropriate actions and processing operations according to a computer program stored in a read only memory (ROM) <NUM> or a computer program loaded from a storage unit <NUM> into a random access memory (RAM) <NUM>. Various programs and data necessary for the operation of the device <NUM> may be also stored in the RAM <NUM>. The computing unit <NUM>, the ROM <NUM>, and the RAM <NUM> are connected with one other through a bus <NUM>. An input/output (I/O) interface <NUM> is also connected to the bus <NUM>.

The plural components in the device <NUM> are connected to the I/O interface <NUM>, and include: an input unit <NUM>, such as a keyboard, a mouse, or the like; an output unit <NUM>, such as various types of displays, speakers, or the like; the storage unit <NUM>, such as a magnetic disk, an optical disk, or the like; and a communication unit <NUM>, such as a network card, a modem, a wireless communication transceiver, or the like. The communication unit <NUM> allows the device <NUM> to exchange information/data with other devices through a computer network, such as the Internet, and/or various telecommunication networks.

The computing unit <NUM> may be a variety of general and/or special purpose processing components with processing and computing capabilities. Some examples of the computing unit <NUM> include, but are not limited to, a central processing unit (CPU), a graphic processing unit (GPU), various dedicated artificial intelligence (AI) computing chips, various computing units running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, or the like. The computing unit <NUM> performs the methods and processing operations described above, such as the method according to the present disclosure. For example, in some embodiments, the method according to the present disclosure may be implemented as a computer software program tangibly contained in a machine readable medium, such as the storage unit <NUM>. In some embodiments, part or all of the computer program may be loaded and/or installed into the device <NUM> via the ROM <NUM> and/or the communication unit <NUM>. When the computer program is loaded into the RAM <NUM> and executed by the computing unit <NUM>, one or more steps of the method according to the present disclosure may be performed. Alternatively, in other embodiments, the computing unit <NUM> may be configured to perform the method according to the present disclosure by any other suitable means (for example, by means of firmware).

Various implementations of the systems and technologies described herein above may be implemented in digital electronic circuitry, integrated circuitry, field programmable gate arrays (FPGA), application specific integrated circuits (ASIC), application specific standard products (ASSP), systems on chips (SOC), complex programmable logic devices (CPLD), computer hardware, firmware, software, and/or combinations thereof. The systems and technologies may be implemented in one or more computer programs which are executable and/or interpretable on a programmable system including at least one programmable processor, and the programmable processor may be special or general, and may receive data and instructions from, and transmit data and instructions to, a storage system, at least one input apparatus, and at least one output apparatus.

Program codes for implementing the method according to the present disclosure may be written in any combination of one or more programming languages. These program codes may be provided to a processor or a controller of a general purpose computer, a special purpose computer, or other programmable data processing apparatuses, such that the program code, when executed by the processor or the controller, causes functions/operations specified in the flowchart and/or the block diagram to be implemented. The program code may be executed entirely on a machine, partly on a machine, partly on a machine as a stand-alone software package and partly on a remote machine, or entirely on a remote machine or a server.

In the context of the present disclosure, the machine readable medium may be a tangible medium which may contain or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine readable medium may be a machine readable signal medium or a machine readable storage medium. The machine readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of the machine readable storage medium may include an electrical connection based on one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read only memory (ROM), an erasable programmable read only memory (EPROM or flash memory), an optical fiber, a portable compact disc read only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

To provide interaction with a user, the systems and technologies described here may be implemented on a computer having: a display apparatus (for example, a cathode ray tube (CRT) or liquid crystal display (LCD) monitor) for displaying information to a user; and a keyboard and a pointing apparatus (for example, a mouse or a trackball) by which a user may provide input for the computer. Other kinds of apparatuses may also be used to provide interaction with a user; for example, feedback provided for a user may be any form of sensory feedback (for example, visual feedback, auditory feedback, or tactile feedback); and input from a user may be received in any form (including acoustic, speech or tactile input).

The systems and technologies described here may be implemented in a computing system (for example, as a data server) which includes a back-end component, or a computing system (for example, an application server) which includes a middleware component, or a computing system (for example, a user computer having a graphical user interface or a web browser through which a user may interact with an implementation of the systems and technologies described here) which includes a front-end component, or a computing system which includes any combination of such back-end, middleware, or front-end components. The components of the system may be interconnected through any form or medium of digital data communication (for example, a communication network). Examples of the communication network include: a local area network (LAN), a wide area network (WAN) and the Internet.

Claim 1:
A query processing method for a distributed graph database system, comprising:
analyzing (S101) a type of a received retrieval request;
further comprising:
splitting a retrieval request into several query requests, detecting whether a number of the several query requests exceeds a preset quantity threshold which is an integer greater than <NUM>;
determining the retrieval request to be a simple query if the number of the several query requests does not exceed the preset quantity threshold, and continuously sending the first query request to the first storage node after receiving a feedback message of a busy service returned by a first storage node based on a first query request in the several query requests,
determining the retrieval request to be a complex query if the number of the several query requests exceeds the preset quantity threshold; and
performing (S102) a query processing operation on the retrieval request based on the type of the retrieval request;
further comprising:
lowering concurrency of requesting queries to all storage nodes after receiving a feedback message of a busy service returned by a second storage node based on a second query request in the several query requests, and performing a query processing operation on the second query request based on the adjusted concurrency;
detecting a feedback message of a busy service returned by any storage node based on any one of the several query requests is received based on the lowered concurrency;
detecting whether a current concurrency is less than a first preset threshold which is the maximum service capability of one storage node, and continuously lowering the concurrency of requesting the queries to all storage nodes if the current concurrency is not less than the first preset threshold, and determining failure of the retrieval request according to a preset probability if the current concurrency is less than the first preset threshold, wherein the preset probability being set as a function of an expected query efficiency or a load of the storage node.