CN111309989A - Graph database-based shortest path query method and related equipment - Google Patents

Abstract

The present application relates to the field of big data. The present application discloses a graph database-based shortest path query method and related equipment. The method includes: creating a queue, and when a source node and a target node are obtained, storing the source node in a In the queue, query all other nodes adjacent to the source node, store all the adjacent nodes in the queue, traverse all the nodes in the queue in turn, and query the nodes adjacent to the node. All other nodes, and query the adjacent nodes consistent with the target node through loop traversal, thereby obtaining the shortest path. In the present application, adjacent nodes are obtained by cyclic traversal detection of each node in the graph database, and target nodes are obtained by monitoring the adjacent nodes, so as to obtain the shortest path, which can improve the speed and efficiency of path query.

Description

Shortest path query method and related equipment based on graph database

technical field

The present application relates to the field of big data, and in particular, to a shortest path query method and related equipment based on a graph database.

Background technique

A relational network is a network structure composed of nodes with huge data and intricate relationships between nodes. In the real world, there are various similar relationship networks, such as social networks, financial networks, etc. From a mathematical point of view, a relational network is a graph with complex topological features. A graph database is also known as a graph-oriented/graph-based database, and its basic meaning is to store and query data as a graph as a data structure. The main elements in a graph database are nodes and edges. In practical applications, nodes are often used to represent entities or concepts, and edges connected between nodes are used to represent relationships between nodes (entities or concepts). This graph-based abstract structure is easy to represent complex relational data, so graph databases are widely used in relational networks.

In graph databases, a common query is to find the shortest path between two points in an unweighted graph. For the shortest path query, the traditional method is to use the breadth-first traversal (BFS) algorithm to find the shortest path from one point until another point is found. A super node refers to a node whose degree is significantly greater than the average node degree. In the actual network, due to the extremely uneven distribution of node degrees (edges), the breadth-first traversal algorithm often leads to a large number of unnecessary computations, resulting in a very slow query process.

SUMMARY OF THE INVENTION

The purpose of this application is to provide a shortest path query method and related equipment based on a graph database in view of the deficiencies of the prior art. , so as to obtain the shortest path, which can improve the speed and efficiency of path query.

In order to achieve the above purpose, the technical solution of the present application provides a shortest path query method and related equipment based on a graph database.

The present application discloses a shortest path query method based on a graph database, comprising the following steps:

Create a queue, and store the source node in the queue when the source node and the target node are obtained;

Query all adjacent nodes adjacent to the source node, if any adjacent node in all adjacent nodes is consistent with the target node, end this query, and compare the adjacent nodes consistent with the target node with the target node. The path between the source nodes is set as the shortest path, and if any adjacent node in all adjacent nodes is inconsistent with the target node, then all adjacent nodes are stored in the queue;

Traverse all nodes in the queue in turn, query all adjacent nodes adjacent to the currently traversed node, and monitor all adjacent nodes. If any adjacent node is monitored to be consistent with the target node, end In this query, the path between the adjacent node consistent with the target node and the source node is set as the shortest path. If any adjacent node in all adjacent nodes is inconsistent with the target node, the All adjacent nodes are stored in the queue, and this step is repeated until a node consistent with the currently traversed target node is queried in the queue.

Preferably, the query is performed on all other nodes adjacent to the source node, including:

A preset node degree threshold, the node degree threshold is used to determine the maximum number of nodes adjacent to any node;

Monitor the queried node, if the currently queried node is a source node, query all other nodes adjacent to the source node, and if the currently queried node is a non-source node, then The node degree of the currently queried node is compared with the node degree threshold, and if the node degree of the currently queried node is greater than the node degree threshold, the currently queried node is discarded.

Preferably, after storing the source node in the queue, it includes:

setting the state of the source node to unvisited;

Then after querying all other nodes adjacent to the source node, including:

Set the state of the source node to visited.

Preferably, if any adjacent node in all adjacent nodes is inconsistent with the target node, then all adjacent nodes are stored in the queue, including:

Set the status of all neighboring nodes in the queue to unvisited.

Preferably, traversing all nodes in the queue in sequence, and querying all adjacent nodes adjacent to the currently traversed node, including:

Detecting all nodes in the queue in turn, if the status of any node in the queue is visited, then delete the node from the queue;

If the state of the node is not visited, all adjacent nodes adjacent to the node are queried, and when all adjacent nodes of the node are queried, the state of the node is set to visited.

Preferably, the step is repeated until a node consistent with the currently traversed target node is queried in the queue, including:

monitoring the storage status of the queue;

If it is monitored that the node in the queue is empty, the query ends. If it is monitored that the node in the queue is not empty, repeat this step until the adjacent nodes are queried for the same target node. up to the node.

Preferably, the step is repeated until a node consistent with the currently traversed target node is queried in the queue, including:

a preset node hop count threshold, where the node hop count threshold is used to determine the maximum number of nodes in the current queue;

Monitor the total number of nodes in the queue. If the total number of nodes in the queue is greater than the node hop threshold, end the query. If the total number of nodes in the queue is less than or equal to the node hop threshold, repeat this step until the corresponding node hop threshold is reached. The neighbor nodes are queried for nodes that are consistent with the target node.

The present application also discloses a shortest path query device based on a graph database, the device comprising:

Data acquisition module: set to create a queue, when the source node and the target node are acquired, the source node is stored in the queue;

The first query module: set to query all adjacent nodes adjacent to the source node, if any adjacent node in all adjacent nodes is consistent with the target node, end this query, and compare the adjacent nodes with the target node. The path between the adjacent node with the same node and the source node is set as the shortest path. If any adjacent node in all adjacent nodes is inconsistent with the target node, all adjacent nodes are stored in the queue. middle;

Second query module: set to traverse all nodes in the queue in sequence, query all adjacent nodes adjacent to the currently traversed node, and monitor all adjacent nodes. When the target node is consistent, end this query, and set the path between the adjacent node consistent with the target node and the source node as the shortest path, if any adjacent node in all adjacent nodes and the If the target nodes are inconsistent, all adjacent nodes are stored in the queue, and this step is repeated until a node consistent with the currently traversed target node is queried in the queue.

The present application also discloses a computer device, the computer device includes a memory and a processor, the memory stores computer-readable instructions, and when the computer-readable instructions are executed by one or more of the processors, cause One or more of the processors perform the steps of the query method described above.

The present application also discloses a storage medium that can be read and written by a processor, and the storage medium stores computer instructions that, when executed by one or more processors, cause one or more Each processor executes the steps of the query method described above.

The beneficial effects of the present application are: the present application obtains adjacent nodes by performing cyclic traversal detection on each node in the graph database, and monitors the adjacent nodes to obtain the target node, thereby obtaining the shortest path, which can improve the speed and efficiency of path query .

Description of drawings

1 is a schematic flowchart of a graph database-based shortest path query method according to the first embodiment of the application;

2 is a schematic flowchart of a graph database-based shortest path query method according to a second embodiment of the application;

3 is a schematic flowchart of a graph database-based shortest path query method according to a third embodiment of the application;

4 is a schematic flowchart of a graph database-based shortest path query method according to a fourth embodiment of the present application;

5 is a schematic flowchart of a method for querying the shortest path based on a graph database according to the fifth embodiment of the present application;

FIG. 6 is a schematic structural diagram of a shortest path query apparatus based on a graph database according to an embodiment of the present application.

Detailed ways

In order to make the purpose, technical solutions and advantages of the present application more clearly understood, the present application will be described in further detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain the present application, but not to limit the present application.

It will be understood by those skilled in the art that the singular forms "a", "an", "the" and "the" as used herein can include the plural forms as well, unless expressly stated otherwise. It should be further understood that the word "comprising" used in the specification of this application refers to the presence of stated features, integers, steps, operations, elements and/or components, but does not preclude the presence or addition of one or more other features, Integers, steps, operations, elements, components and/or groups thereof.

The flowchart of a graph database-based shortest path query method according to the first embodiment of the present application is shown in FIG. 1 , and this embodiment includes the following steps:

Step s101, creating a queue, and storing the source node in the queue when the source node and the target node are obtained;

Specifically, when querying the shortest distance between two points in a graph database, first obtain the names of the two nodes, such as node A and node B, and arbitrarily set these two nodes as the source node and the target Node, since only the shortest distance between node A and node B is calculated, whether it is node A to node B or node B to node A, the shortest distance should be unique, so the directionality can be ignored, for example, if node A is set as the source node, then node B is the target node, if node B is set as the source node, then node A is the target node.

Specifically, before acquiring the source node and the target node, a queue needs to be set up, and the queue is used to store the nodes, and the stored nodes are used to calculate the adjacent nodes, delete the nodes that have been calculated, and In the adjacent nodes, the adjacent nodes are calculated again, and after cyclic query and calculation, the target node is finally queried in the adjacent nodes. In the initial state, the queue stores the source node for the first time, and through the By querying the source node, nodes adjacent to the source node can be obtained.

Step s102, query all adjacent nodes adjacent to the source node, if any adjacent node in all adjacent nodes is consistent with the target node, end this query, and compare the adjacent nodes consistent with the target node. The path between the adjacent node and the source node is set as the shortest path, if any adjacent node in all adjacent nodes is inconsistent with the target node, then all adjacent nodes are stored in the queue;

Specifically, according to the source node in the queue, all other nodes adjacent to the source node are obtained, and then a comparison can be performed in the adjacent nodes, and the comparison is to compare the The names of adjacent nodes are compared with the names of the target nodes in turn. During the sequential comparison, if the name of any adjacent node is consistent with the name of the target node, the query ends, and the remaining The adjacent node stops the comparison with the target node, and the distance between the adjacent node whose name is consistent with the target node and the source node is the shortest path. If the target nodes are inconsistent, all the adjacent nodes can be stored in the queue to wait for the next round of query.

Step s103, traverse all the nodes in the queue in turn, query all adjacent nodes adjacent to the node currently traversed, and monitor all adjacent nodes, if any adjacent node is monitored to be consistent with the target node When the query ends, the path between the adjacent node that is consistent with the target node and the source node is set as the shortest path. If any adjacent node in all adjacent nodes is inconsistent with the target node , all adjacent nodes are stored in the queue, and this step is repeated until a node consistent with the currently traversed target node is queried in the queue.

Specifically, after the first round of query, the source node and the nodes adjacent to the source node are stored in the queue. At this time, all nodes in the queue can be traversed and queried in turn to obtain Nodes adjacent to all nodes; for example, if there is source node A in the queue, and node C, node D, and node E are adjacent to source node A, then query the adjacent nodes of node A and the adjacent nodes of node C in turn , the adjacent node of node D and the adjacent node of node E, in the process of querying the adjacent node, the adjacent node can be monitored, if any adjacent node and the target node are monitored. is consistent, then the query can be ended, and the path between the adjacent node that is consistent with the target node and the source node is set as the shortest path; for example, in the query process of the adjacent nodes of node C If there is a node consistent with the target node in the query, stop querying node D and node E; if after traversing and querying all nodes in the queue, no node consistent with the target node is found, then you can Store all the adjacent nodes currently queried in the queue, and perform the next round of query, by traversing the nodes in the queue in a loop, until the adjacent nodes are queried to obtain a node consistent with the target node .

In this embodiment, adjacent nodes are obtained by cyclic traversal detection of each node in the graph database, and target nodes are obtained by monitoring adjacent nodes, thereby obtaining the shortest path, which can improve the speed and efficiency of path query.

FIG. 2 is a schematic flowchart of a graph database-based shortest path query method according to the second embodiment of the present application. As shown in the figure, in step s102, query all other nodes adjacent to the source node, including:

Step s201, preset a node degree threshold, and the node degree threshold is used to determine the maximum number of nodes adjacent to any node;

Specifically, before querying the source node, a node degree threshold can be preset in the system, and the node degree threshold is used to determine the maximum number of adjacent nodes to any node, and the node degree refers to any one The number of edges associated with the node; when the node degree of any node is greater than the threshold, the query for the node can be skipped. Since the higher the node degree, the greater the amount of operations, so avoiding a large number of operations and reducing efficiency.

Step s202, monitor the queried node, if the currently queried node is a source node, query all other nodes adjacent to the source node, and if the currently queried node is a non-source node, then The node degree of the currently queried node is compared with the node degree threshold, and if the node degree of the currently queried node is greater than the node degree threshold, the currently queried node is discarded.

Specifically, in the process of querying a node, the node can be monitored. If the node currently queried is the source node, since the source node is the starting node, there is no need to judge the node degree threshold, because no matter what the judgment result is In this case, all other nodes adjacent to the source node can be directly queried; and if the currently queried node is not the source node, then the node degree of the currently queried node must be compared with the node degree of the source node. The degree threshold is compared, and if the node degree of the node currently queried is greater than the node degree threshold, the query of the current node is stopped.

In this embodiment, by setting a node degree threshold and determining the node degree of the node currently queried, it is possible to avoid a large number of operations and reduce efficiency.

In one embodiment, the step s101, after the source node is stored in the queue, includes:

setting the state of the source node to unvisited;

Then after querying all other nodes adjacent to the source node, including:

Set the state of the source node to visited.

Specifically, in the initial state, there is only one source node in the queue, then the state of the source node can be set as unvisited, and after querying the source node, the nodes adjacent to the source node can be obtained. Afterwards, the state of the source node can be set as visited to indicate that the source node has already been queried. Through subsequent determination of the state of the source node, there is no need to query again. For example, in the next round of query, if the source node is found If the state of the node is visited, the source node does not need to be queried again, which reduces operations and improves query efficiency.

In this embodiment, by setting the state of the source node and determining the state of the source node when querying, the operation can be reduced and the query efficiency can be improved.

In one embodiment, in the step s103, if any adjacent node among all adjacent nodes is inconsistent with the target node, after storing all adjacent nodes in the queue, the process includes:

Set the status of all neighboring nodes in the queue to unvisited.

Specifically, after all the adjacent nodes adjacent to the source node are stored in the queue, the state of all adjacent nodes in the queue can also be set to be unvisited, so as to communicate with the visited nodes. Differentiate, so that the visited nodes can be excluded in the next round of query to avoid redundant query, resulting in reduced efficiency.

In this embodiment, by setting the states of adjacent nodes, the adjacent nodes that have not been visited can be distinguished from the source nodes that have been visited, so as to reduce repeated operations and improve query efficiency.

FIG. 3 is a schematic flowchart of a method for querying the shortest path based on a graph database according to the third embodiment of the present application. As shown in the figure, in step s103, all nodes in the queue are traversed in sequence, and the query and the currently traversed node are traversed sequentially. All adjacent nodes, including:

Step s301, sequentially detect all nodes in the queue, if the status of any node in the queue is visited, delete the node from the queue;

Specifically, when a traversal query is performed on a node in the queue, the state of the node is first detected. If the state of any node in the queue is visited, the node can be deleted, and the state of the node can be deleted. Nodes that have been visited are no longer queried.

Step s302, if the state of the node is not visited, query all adjacent nodes adjacent to the node, and after the query of all adjacent nodes of the node is completed, set the state of the node to access.

Specifically, for a node whose status is unvisited, all other nodes adjacent to the node can be queried, and after the unvisited node is queried, all other nodes adjacent to the unvisited node are obtained. Afterwards, the state of the visited node can be set to visited.

In this embodiment, by judging the state of the node in the queue, the node whose state is visited is deleted, which can reduce repeated operations and improve query efficiency.

4 is a schematic flowchart of a graph database-based shortest path query method according to the fourth embodiment of the application. As shown in the figure, in step s103, this step is repeated until a query that is related to the current traversal is found in the queue. Until the node with the same target node, including:

Step s401, monitoring the storage state of the queue;

Specifically, the storage status of the queue can also be monitored. Before querying the nodes in the queue, the current storage status of the queue can be obtained through monitoring. The storage status includes whether there are any nodes in the queue. In the process of querying nodes, the visited nodes will be deleted. If all nodes have been deleted, it means that the source node and the target node are not connected, and there is no path for querying, so the no-path result can be output.

Step s402, if it is monitored that the node in the queue is empty, end this query, if it is monitored that the node in the queue is not empty, then repeat this step until the query is in the adjacent node and the target. until the node matches the node.

Specifically, when it is monitored that there are no nodes in the current queue, the query can be ended at this time, indicating that there is no connection between the source node and the target node, and there is no path to query. If the nodes in the queue are not empty, continue This step is repeated until a node consistent with the target node is queried among adjacent nodes.

In this embodiment, by detecting the storage state in the queue, when the storage state of the queue is empty, the query is ended, which can reduce invalid operations and improve query efficiency.

FIG. 5 is a schematic flowchart of a method for querying the shortest path based on a graph database according to the fifth embodiment of the present application. As shown in the figure, in step s103, this step is repeated until a query related to the current traversal is found in the queue. Until the node with the same target node, including:

Step s501, preset a node hop count threshold, and the node hop count threshold is used to determine the maximum number of nodes in the current queue;

Specifically, a node hop count threshold may also be preset, and the node hop count threshold is used to determine the maximum number of nodes in the current queue.

Step s502, monitor the total number of nodes in the queue, if the total number of nodes in the queue is greater than the node hop count threshold, end this query, if the total number of nodes in the queue is less than or equal to the node hop count threshold, repeat this step, Until a node that is consistent with the target node is queried among the adjacent nodes.

Specifically, before performing a traversal query on the nodes in the queue, the total number of nodes in the queue can also be monitored. When it is found through monitoring that the total number of nodes in the current queue is greater than the node hop threshold, the number of nodes is too large. If the total number of nodes in the queue is less than or equal to the node hop threshold, then you can continue to traverse and query the nodes in the queue. And loop through the query steps until a node consistent with the target node is queried in the adjacent nodes.

In this embodiment, by judging the total number of nodes on the nodes in the queue, excessive computation load caused by too many nodes is avoided, and the query efficiency is improved.

The structure of a graph database-based shortest path query device according to an embodiment of the present application is shown in FIG. 6 , including:

Data acquisition module 601, first query module 602 and second query module 603; wherein, the data acquisition module 601 is connected with the first query module 602, and the first query module 602 is connected with the second query module 603; the data acquisition module 601 is set to Create a queue, and store the source node in the queue when the source node and the target node are obtained; the first query module 602 is set to query all adjacent nodes adjacent to the source node, if all adjacent nodes are adjacent Any adjacent node in the node is consistent with the target node, then end the query, and set the path between the adjacent node consistent with the target node and the source node as the shortest path, if all adjacent nodes If any adjacent node is inconsistent with the target node, all adjacent nodes are stored in the queue; the second query module 603 is set to traverse all the nodes in the queue in turn, and query and the currently traversed node All adjacent nodes are adjacent, and all adjacent nodes are monitored. If any adjacent node is monitored to be consistent with the target node, the query ends, and the adjacent node consistent with the target node is compared with the target node. The path between the source nodes is set as the shortest path, if any adjacent node in all adjacent nodes is inconsistent with the target node, then all adjacent nodes are stored in the queue, and this step is repeated until The queue is queried until a node consistent with the currently traversed target node is found.

An embodiment of the present application further discloses a computer device, the computer device includes a memory and a processor, the memory stores computer-readable instructions, and when the computer-readable instructions are executed by one or more of the processors , causing one or more of the processors to execute the steps in the query methods described in the foregoing embodiments.

The embodiment of the present application further discloses a storage medium, the storage medium can be read and written by a processor, the memory stores computer-readable instructions, and when the computer-readable instructions are executed by one or more processors, causes One or more processors execute the steps in the query methods described in the above embodiments.

Those of ordinary skill in the art can understand that the realization of all or part of the processes in the methods of the above embodiments can be accomplished by instructing relevant hardware through a computer program, and the computer program can be stored in a computer-readable storage medium, and the program is During execution, it may include the processes of the embodiments of the above-mentioned methods. The aforementioned storage medium may be a non-volatile storage medium such as a magnetic disk, an optical disk, a read-only memory (Read-Only Memory, ROM), or a random access memory (Random Access Memory, RAM).

The technical features of the above-described embodiments can be combined arbitrarily. For the sake of brevity, all possible combinations of the technical features in the above-described embodiments are not described. However, as long as there is no contradiction between the combinations of these technical features, All should be regarded as the scope described in this specification.

The above-mentioned embodiments only represent several embodiments of the present application, and the descriptions thereof are relatively specific and detailed, but should not be construed as a limitation on the scope of the patent of the present application. It should be noted that, for those skilled in the art, without departing from the concept of the present application, several modifications and improvements can be made, which all belong to the protection scope of the present application. Therefore, the scope of protection of the patent of the present application shall be subject to the appended claims.

Claims (10)

1. a shortest path query method based on graph database, is characterized in that, comprises the following steps: Create a queue, and store the source node in the queue when the source node and the target node are obtained; Query all adjacent nodes adjacent to the source node, if any adjacent node in all adjacent nodes is consistent with the target node, end this query, and compare the adjacent nodes consistent with the target node with the target node. The path between the source nodes is set as the shortest path, and if any adjacent node in all adjacent nodes is inconsistent with the target node, then all adjacent nodes are stored in the queue; Traverse all nodes in the queue in turn, query all adjacent nodes adjacent to the currently traversed node, and monitor all adjacent nodes. If any adjacent node is monitored to be consistent with the target node, end In this query, the path between the adjacent node consistent with the target node and the source node is set as the shortest path. If any adjacent node in all adjacent nodes is inconsistent with the target node, the All adjacent nodes are stored in the queue, and this step is repeated until a node consistent with the currently traversed target node is queried in the queue. 2. The shortest path query method based on a graph database as claimed in claim 1, wherein the querying all other nodes adjacent to the source node comprises: A preset node degree threshold, the node degree threshold is used to determine the maximum number of nodes adjacent to any node; Monitor the queried node, if the currently queried node is a source node, query all other nodes adjacent to the source node, and if the currently queried node is a non-source node, then The node degree of the currently queried node is compared with the node degree threshold, and if the node degree of the currently queried node is greater than the node degree threshold, the currently queried node is discarded. 3. The shortest path query method based on a graph database according to claim 2, wherein after the source node is stored in the queue, the method comprises: setting the state of the source node to unvisited; After querying all other nodes adjacent to the source node, including: Set the state of the source node to visited. 4. the shortest path query method based on graph database as claimed in claim 3, is characterized in that, described if any adjacent node in all adjacent nodes is inconsistent with described target node, then all adjacent nodes are stored After entering the queue, including: Set the status of all neighboring nodes in the queue to unvisited. 5. The shortest path query method based on a graph database as claimed in claim 4, characterized in that, said traversing all the nodes in the queue successively, and querying all adjacent nodes adjacent to the currently traversed node, comprising: Detecting all nodes in the queue in turn, if the status of any node in the queue is visited, then delete the node from the queue; If the state of the node is not visited, all adjacent nodes adjacent to the node are queried, and when all adjacent nodes of the node are queried, the state of the node is set to visited. 6. The shortest path query method based on a graph database as claimed in claim 5, wherein the step is repeated until a node consistent with the current traversed target node is queried in the queue, comprising: monitoring the storage status of the queue; If it is detected that the node in the queue is empty, the query ends, and if the node in the queue is monitored to be not empty, repeat this step until the adjacent nodes are queried that are consistent with the target node up to the node. 7. The shortest path query method based on a graph database as claimed in claim 5, wherein the step is repeated until a node consistent with the current traversed target node is queried in the queue, comprising: a preset node hop count threshold, where the node hop count threshold is used to determine the maximum number of nodes in the current queue; Monitor the total number of nodes in the queue. If the total number of nodes in the queue is greater than the node hop threshold, end the query. If the total number of nodes in the queue is less than or equal to the node hop threshold, repeat this step until the corresponding node hop threshold is reached. The neighbor nodes are queried until a node consistent with the target node is found. 8. A shortest path query device based on a graph database, wherein the device comprises: Data acquisition module: set to create a queue, when the source node and the target node are acquired, the source node is stored in the queue; The first query module: set to query all adjacent nodes adjacent to the source node, if any adjacent node in all adjacent nodes is consistent with the target node, end this query, and compare the adjacent nodes with the target node. The path between the adjacent node with the same node and the source node is set as the shortest path. If any adjacent node in all adjacent nodes is inconsistent with the target node, all adjacent nodes are stored in the queue. middle; Second query module: set to traverse all nodes in the queue in sequence, query all adjacent nodes adjacent to the currently traversed node, and monitor all adjacent nodes. When the target node is consistent, end this query, and set the path between the adjacent node consistent with the target node and the source node as the shortest path, if any adjacent node in all adjacent nodes and the If the target nodes are inconsistent, all adjacent nodes are stored in the queue, and this step is repeated until a node consistent with the currently traversed target node is queried in the queue. 9. A computer device, characterized in that the computer device comprises a memory and a processor, wherein computer-readable instructions are stored in the memory, and when the computer-readable instructions are executed by one or more of the processors, One or more of the processors are caused to perform the steps of the query method of any one of claims 1 to 7. 10. A storage medium, characterized in that, the storage medium can be read and written by a processor, and the storage medium stores computer instructions that, when executed by one or more processors, cause one or more A plurality of processors execute the steps of the query method according to any one of claims 1 to 7.

Images