Method and apparatus for acquiring data by means of graph traversal query, and computer device

Abstract

Disclosed in the present application are a method and apparatus for acquiring data by means of a graph traversal query, a computer device, and a storage medium. Specifically, disclosed in the present application is a method for acquiring data by means of a graph traversal query, the method comprising: receiving a graph traversal query; on the basis of syntax and lexical parsers for graph traversal, generating a syntax tree from the graph traversal query; and traversing the syntax tree to generate an application programming interface query, and on the basis of the application programming interface query, acquiring target data. By means of the method, a graph traversal query can be conveniently converted into an application programming interface query. The method is relatively fast and accurate, and is thus applied to a related application product to acquire data.

Description

Methods, apparatus, and computer equipment for graph traversal query to retrieve data. Technical Field

[0001] This application relates to the field of computers, and more specifically, to a method, apparatus, computer device, and storage medium for obtaining data through graph traversal query. Background Technology

[0002] In the development of Large Language Model (LLM) applications and AI agents, the following problem arose: because API queries are far more complex than graph traversal queries, there is no better way to generate API queries from graph traversal queries, especially when property graphs are used in some products. Therefore, if we want to translate customer requirements into API-acceptable query formats, we first need a tool to convert graph traversal queries into API queries in order to retrieve data from the relevant products.

[0003] Summary of the Invention

[0004] This summary section is provided to introduce some selected concepts in a simplified form, which will be further described in the detailed description section below. This summary section is not intended to identify any key or essential features of the claimed subject matter, nor is it intended to help determine the scope of the claimed subject matter.

[0005] Based on this, this application discloses a method for obtaining data through graph traversal query, comprising:

[0006] Receive graph traversal query;

[0007] Based on the syntax and parser rules, the graph is traversed and queries to generate a syntax tree;

[0008] Traverse the syntax tree to generate an application programming interface query;

[0009] The target data is obtained by querying the application programming interface.

[0010] The above method can easily transform graph traversal queries into application programming interface queries, which can then be applied to relevant application products to obtain data.

[0011] Furthermore, the graph traversal syntax and lexical parser includes provisions for content, nodes, node relationships, relations, numerical graphs, pseudonyms, and filters; the graph traversal-based syntax and lexical parser generates a syntax tree from the graph traversal query by: generating a syntax tree from the graph traversal query according to the provisions for content, nodes, node relationships, relations, numerical graphs, pseudonyms, and filters.

[0012] Using the above method, graph traversal queries can be broken down according to the elements mentioned above, such as nodes, node relationships, and relationships, and then a corresponding syntax tree can be generated. This is beneficial for clearly converting graph traversal queries into application programming interface queries in the future.

[0013] Furthermore, the graph traversal-based syntax and lexical parser generates a syntax tree from the graph traversal query, including: generating a syntax tree from the graph traversal query that includes multiple tree nodes and connections between tree nodes.

[0014] The above method can generate a syntax tree structure with a relatively clear logical structure, which facilitates the subsequent one-to-one conversion of graph traversal queries into application programming interface queries.

[0015] Furthermore, the step of traversing the syntax tree to generate an application programming interface query includes:

[0016] Traverse each tree node and the connection between tree nodes in the syntax tree, and generate an application programming interface query based on the parsing function.

[0017] By using the above method, all tree nodes in the syntax tree can be traversed to generate application programming interface queries more accurately.

[0018] Furthermore, the step of querying and obtaining target data according to the application programming interface includes: calling the application programming interface to query the application and obtain the target data.

[0019] Using the above method, the application programming interface can be invoked into a specific application through a programming interface to realize the function of traversing and querying the original graph and the original question, and obtain the target data.

[0020] Furthermore, the step of calling the application programming interface to query the application and obtain the target data according to the application programming interface includes: calling the application programming interface to query the building temperature detection application and obtain temperature data.

[0021] Using the methods described above, the building temperature program can be accessed through the converted application programming interface (API) to obtain specific target data.

[0022] Furthermore, this application also discloses an apparatus for obtaining data through graph traversal queries, comprising:

[0023] The receiving module is used to receive graph traversal queries;

[0024] A generation module is used by a graph traversal-based syntax and lexical parser to generate a syntax tree from the graph traversal query.

[0025] The traversal module is used to traverse the syntax tree and generate application programming interface queries.

[0026] The acquisition module is used to query and obtain target data based on the application programming interface.

[0027] This application also provides a computer device, including a memory and a processor, wherein the memory stores a computer program, and the processor executes the computer program to implement the above-described method.

[0028] This application also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the above-described method.

[0029] This application also provides a computer program product tangibly stored on a computer-readable medium and comprising computer-executable instructions that, when executed, cause at least one processor to perform the methods described above. Attached Figure Description

[0030] Implementations of this disclosure are illustrated in the accompanying drawings by way of example rather than limitation, and similar reference numerals in the drawings denote the same or similar parts.

[0031] Figure 1 is a schematic flowchart of a method for obtaining data by graph traversal query according to an embodiment of this application.

[0032] Figure 2 is a schematic diagram of a graph traversal query device for obtaining data according to an embodiment of this application.

[0033] Figure 3 is a schematic diagram of a computer device for obtaining data by graph traversal query according to an embodiment of this application.

[0034] The reference numerals in the attached figures are as follows:

[0035] Steps 200 (S101-S104): Apparatus

[0036] 201: Module

[0037] 202: Module

[0038] 203: Module

[0039] 204: Module

[0040] 300: Computer equipment

[0041] 302: Processor

[0042] 304: Memory Detailed Implementation

[0043] In the following description, numerous specific details are set forth for illustrative purposes. However, it will be understood that the invention can be implemented without these specific details. In other instances, well-known circuits, structures, and techniques have not been shown in detail so as not to affect the understanding of the description.

[0044] Throughout the specification, references to "an implementation," "implementation," "exemplary implementation," "some implementations," "various implementations," etc., indicate that the implementation of the invention described may include specific features, structures, or characteristics. However, it is not implied that every implementation must include these specific features, structures, or characteristics. Furthermore, some implementations may have some, all, or none of the features described for other implementations.

[0045] Graph traversal language is a query language for graph databases, also known as Gremlin, primarily used for traversing and managing graph data structures. Application Programming Interface (API) is a query language and runtime for application programming interfaces (APIs), also known as GraphQL, used for executing queries and retrieving data between clients and servers. These two languages ​​differ significantly in functionality and application scenarios, so the issue of statement conversion had not been encountered before.

[0046] The implementation scenario of this application is based on the above situation, but with the rapid development of artificial intelligence technology, end-users have increasingly higher requirements for data usage. These users want to query data not through customized methods, but through artificial intelligence methods. This process requires a large model to first understand the data structure, generate graph traversal statements, and then execute an application programming interface (API) consistent with the graph traversal data structure to query the data. Therefore, this application proposes a method to generate an API query that is as accurate as possible from complex graph traversal queries. Specifically, the graph traversal query is first generated into a syntax tree according to syntax rules and a lexical parser. Then, a parsing function is used to traverse the syntax tree to generate an API query, which can then be used to retrieve the corresponding data.

[0047] Based on this, this application discloses a method for converting graph traversal queries into application programming interface queries, which includes:

[0048] S101, receive graph traversal query.

[0049] Specifically, the graph traversal query is a query statement obtained based on customer needs or current system requirements. As mentioned earlier, human questions can be transformed into graph traversal queries using Langchain programming tools, allowing data to be queried using instance graphs. The generated graph traversal query can then be used for processing on other machines later.

[0050] S102, a graph traversal-based syntax and lexical parser generates a syntax tree from the graph traversal query.

[0051] The graph traversal syntax and lexical parser includes the specifications for content, nodes, node relationships, relations, numerical graphs, pseudonyms, and filters;

[0052] The graph traversal-based syntax and lexical parser generates a syntax tree from the graph traversal query, including:

[0053] Based on the specified content, nodes, node relationships, relationships, numerical graphs, pseudonyms, and filters, the graph is traversed and queried to generate a syntax tree.

[0054] In some embodiments, the rules of the syntax and lexical parser are as follows:

[0055] In some embodiments, content is called content, nodes are called nodes, node relationships are called noderelations, relationships are called relations, the numerical graph is called a valuemap, the alias is called an alias, and the filter is called a filter. Further, the syntax also includes definitions for query, traversal, content, noderelation, node, relation, valuemap, etc.

[0056] For example, traversal: GV content means traversing the contents of a GV.

[0057] For example, `content: (noderelation)*valuemap?` indicates that the noderelation is traversed and analyzed accordingly.

[0058] For example, `noderelation:node(relation)*(noderelation)*` means checking if there are multiple layers of relationships such as `node`, `relation`, and other `noderelation` relationships within a `noderelation`.

[0059] For example, node: ENTITY ALIAS? (FILTER) indicates whether the node has an alternative name and allows for filtering using filters.

[0060] For example, relation:RELATION means that a specific value for relation is defined.

[0061] In some embodiments, the above definition is case-sensitive, meaning that uppercase and lowercase letters convey different meanings.

[0062] In some embodiments, according to the above syntax, a graph traversal query is decomposed into a syntax tree. The syntax tree can be understood as a tree-like structure, that is, the graph traversal query is broken down and parsed into a tree-like syntax analysis object according to the above definition. The tree-like syntax tree corresponds one-to-one with the graph traversal query, and is simply another representation. By constructing such a syntax tree according to the above definition, it is convenient to further analyze and deconstruct the graph traversal query content, and to more accurately and completely convert the graph traversal query into an application programming interface query.

[0063] Furthermore, wherein, the graph traversal-based syntax and lexical parser generates a syntax tree from the graph traversal query, including: generating a syntax tree from the graph traversal query that includes multiple tree nodes and connections between tree nodes.

[0064] In some embodiments, the syntax tree is composed of tree nodes and connections between them. Tree nodes constitute the basic traversal unit of the syntax tree, and connections between tree nodes constitute the direction and path of traversal. In some embodiments, tree nodes of the syntax tree can be content(), noderelation, valuemap, relation, entity(), etc. Connections between tree nodes represent, for example, the subtree nodes to which a certain tree node belongs, as well as the membership and coverage relationships between tree nodes. Through these membership and coverage relationships, the originally complex statements of graph traversal queries can be parsed into simpler semantic units. These semantic units can also be called tree nodes. Through these tree nodes, information such as meaning, attributes, values, and labels in the graph traversal query is reflected, thereby providing a basic and accurate description for subsequent generation of application programming interface queries.

[0065] Using the above method, a syntax tree with a relatively clear logical structure can be generated, and the graph traversal query can then be transformed into an application programming interface query.

[0066] S103, Traverse the syntax tree to generate an application programming interface query.

[0067] Specifically, the traversal process can include entering a tree node, analyzing what is being done at that node, its significance, and its structure; further, it includes entering subtree nodes or accessing the terminal to obtain more specific information, such as leaf node information, etc., ultimately generating an application programming interface (API) query for that tree node containing all leaf nodes and subtree nodes. Then, it exits, returns to the previous node, and continues the traversal to generate API queries for other tree nodes.

[0068] Furthermore, the step of traversing the syntax tree to generate an application programming interface query includes:

[0069] Traverse the tree nodes and connections between them in the syntax tree, and generate an application programming interface query based on the parsing function.

[0070] The parsing functions include enterStat(StatContext), enterAssign(AssignContext), visitTermial(TerminalNode), visitExpr(ExprContext), visitTerminal(TerminalNode), exitExpr(ExprContext), exitAssign(AssignContext), and exitStat(StatContext). These parsing functions have certain parsing capabilities, accessing, interpreting, obtaining, compiling, and integrating information from tree nodes according to their function definitions and order. The calls to these parsing functions have a specific logical relationship and call order. In some embodiments, for example, the system sequentially enters the start context, then the assignment context, accesses the terminal node, then the expression context to further access the terminal node, and after all access is complete, it sequentially exits the corresponding expression context, assignment context, and start context. Through this method, the tree nodes and relationships between them in the syntax tree can be fully understood, and application programming interfaces can be generated more accurately.

[0071] In some embodiments, the large model first generates a graph traversal query from the understanding of the human problem, and then converts it into an application programming interface query. During the conversion process, ANTLR4 is used for syntax and lexical analysis, and a syntax tree is built for the translation of the graph traversal query in order to further accurately convert the graph traversal query into an application programming interface query.

[0072] S104, query according to the application programming interface to obtain the target data.

[0073] Furthermore, the step of querying and obtaining target data according to the application programming interface includes: calling the application programming interface to query the application and obtain the target data.

[0074] In some embodiments, the Application Programming Interface (API) provides a corresponding interface that allows the API query to be invoked in the corresponding application. In this way, the API query can be invoked in a specific application through the programming interface to achieve the function of traversing and querying the original graph and obtaining the target data.

[0075] Furthermore, this includes: calling the application programming interface (API) to query the building temperature detection application and obtain temperature data.

[0076] Using the methods described above, the building temperature program can be accessed through the converted application programming interface (API) to obtain specific target data.

[0077] Specifically, for example, a User Request might include: What is the indoor temperature on the 10th floor of the North Building today?

[0078] The graph traversal query generated by LLM is as follows:

[0079] gV().hasLabel('Temperature_Sensor').as('sensor').out('isLocationOf').hasLabel('Floor').has('name','10th floor').out('isLocationOf').hasLabel('Building').has('name','North Building').select('sensor').out('hasTimeseries').hasLabel('Timeseries').has('captureTime',between('09:00','14:00')).valueMap()

[0080] Subsequently, based on the defined graph traversal syntax and lexical parser, the graph traversal query is used to generate a syntax tree.

[0081] In some embodiments, the syntax tree may first include a structure prog-stat:1-expr. Then, under expr, there are three tree node connections, connecting G, V:.V(), and content. Under content, there are two tree node connections, connecting the first-level noderelation and valuemap. Under valuemap, there are two tree node connections, connecting VALUEMAP:.valueMap and STRINGVALUE:().

[0082] The first-level noderelation has three tree nodes connected by lines, which connect to the second-level node, the second-level relation, and the second-level noderelation, respectively.

[0083] In some embodiments, although the second-level noderelation and the first-level noderelation have the same name, they are subordinate to each other due to the connection between tree nodes. The same name may also appear in the syntax tree, but due to syntactic reasons, it may repeat, and can be further distinguished by the connection between tree nodes and the hierarchical relationship. Furthermore, the connection between tree nodes is also a representation of the relationship between tree nodes.

[0084] The second-level node has two tree nodes connected by lines, which connect ENTITY:.haslable('Tempreture_Sensor') and ALIAS:.as('sensor') respectively.

[0085] The second layer of relation has one connection, which connects to RELATION:.out('isLocationOf').

[0086] The second-level noderelation has three tree nodes connected, which in turn connect to the third-level node, the third-level relation, and the third-level noderelation.

[0087] The third-level node connects ENTITY:.hasLabel('Floor') and FILTER:.has('name','10 th floor')

[0088] The third-level relation connects to RELATIOIN:.out('isLocationOf').

[0089] The third-level node relation connects to the fourth-level node and the fourth-level node relation.

[0090] The fourth-level node connects ENTITY:.hasLabel('Bulding') and FILTER:.has('name','North Building').

[0091] The fourth-level noderelation connects to the fifth-level node, the fifth-level relation, and the fifth-level noderelation.

[0092] The fifth-level node connects to ENTITY:.select('sensor').

[0093] The fifth layer of relation connects to RELATIOIN:.out('has Timeseries').

[0094] The fifth-level node relation connects to the sixth-level node.

[0095] The sixth-level node connects ENTITY:.hasLabel('Timeseries') and FILTER:.has('captureTime', between('9:00', '14:00')).

[0096] As can be seen from the above embodiments, these embodiments, following the aforementioned syntax definitions, perform iterative splitting based on the definitions of nodes, relationships, and node relationships, and utilize specific definitions such as ENTITY, FILTER, RELATION, VALUMAP, and STRINGVALUES to ultimately decompose graph traversal queries into a syntax tree form. Further, this can be understood as splitting the nodes and node relationships in graphs such as attribute graphs and knowledge graphs, thereby converting them into application programming interface queries for querying and retrieving data between the client and server. During this conversion process, the query requirements and meaning are completely and accurately preserved.

[0097] Furthermore, the converted application programming interface query is as follows:

[0098] query{Temperature_Sensor(cond:"",authInfo:"",order:""){sourceId description id ty pe sourceSystem unit userDefinedType name isLocationOf_Floor(cond:"{name:{_eq:\"10thfloor\"}}",authInfo:"",order:""){sourceId description id type sourceSystem areacapacity userDefinedType name isLocationOf_Building(cond:"{name:{_eq:\"North Building\"}}",authInfo:"",order:""){sourceId description id type sourceSystem area capacity userDefinedType name}}hasTimeseries_Timeseries(cond:"{_and:[{captureTime:{_gte:\"09:00\"}},{captureTime:{_lte:\"14:00\"}}]}\",authInfo:"",order:""){id type sourceSy stem pointId captureTime value}}}

[0099] The temperature data obtained by querying using the above application programming interface is as follows:

[0100] Fetched Data:[

[0101] {id:1,value:18.0},

[0102] {id:2,value:20.0},

[0103] {id:3,value:21.0},

[0104] {id:4,value:23.0},

[0105] {id:5,value:25.0},....]

[0106] LLM responded that the indoor temperature on the 10th floor of the north building rose from 18 degrees to 25 degrees between 9 am and 2 pm today.

[0107] In summary, the above methods allow for the control of building temperature through queries via the converted application programming interface, enabling specific applications.

[0108] Furthermore, this application provides a method for converting graph traversal queries into application programming interface queries, which can easily convert graph traversal queries into application programming interface queries. The method is relatively fast and accurate, and can be applied to relevant products to obtain target data.

[0109] Furthermore, as shown in Figure 2, this application also discloses a graph traversal query data acquisition device 200, which includes:

[0110] Receiver module 201 is used to receive graph traversal queries;

[0111] The generation module 202 is used to traverse the graph and generate a syntax tree according to the syntax and parser rules;

[0112] Traversal module 203 is used to traverse the syntax tree and generate application programming interface queries;

[0113] The acquisition module 204 is used to query and acquire target data according to the application programming interface.

[0114] It should be understood that although the steps in the flowchart of Figure 1 are shown sequentially according to the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some of the steps in Figure 1 may include multiple steps or multiple stages, which are not necessarily completed at the same time, but can be executed at different times. The execution order of these steps or stages is not necessarily sequential, but can be performed alternately or in turn with other steps or at least some of the steps or stages in other steps.

[0115] It should be noted that the device may contain more or fewer modules to implement the described functions. For example, at least one module in FIG2 may be further divided into a plurality of different sub-modules, each sub-module being used to perform at least a portion of the operations described herein in conjunction with the corresponding module. Furthermore, in some examples, device 200 may also include additional modules for performing other operations already described in the specification. Moreover, those skilled in the art will understand that the exemplary device 200 may be implemented using software, hardware, firmware, or any combination thereof.

[0116] Figure 3 provides a computer device. According to one embodiment, the computer device 300 may include a processor 302 that executes a computer program stored in a memory 304. When executed by the processor, the computer program implements the method described above.

[0117] Those skilled in the art will understand that the structure shown in Figure 3 is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device to which the present application is applied. Specific computer devices may include more or fewer components than those shown in the figure, or may combine certain components, or may have different component arrangements.

[0118] Those skilled in the art will understand that all or part of the processes in the methods described above can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile computer-readable storage medium, and when executed, it can include the processes of the embodiments described above. Any references to memory, storage, databases, or other media used in the embodiments provided in this application can include at least one of non-volatile and volatile memory. Non-volatile memory can include read-only memory (ROM), magnetic tape, floppy disk, flash memory, or optical storage, etc. Volatile memory can include random access memory (RAM) or external cache memory. By way of illustration and not limitation, RAM can be in various forms, such as static random access memory (SRAM) or dynamic random access memory (DRAM), etc.

[0119] This application also provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, performs the above steps.

[0120] This application also provides a computer program product tangibly stored on a computer-readable medium and including computer-executable instructions that, when executed, cause at least one processor to perform the methods described above.

[0121] Furthermore, the computer program can be stored and run in the cloud to execute the method. Furthermore, the components of the program can be deployed on multiple devices or in the cloud; for example, corresponding steps can be deployed and run on a local computer, or run on different cloud devices, transmitting signals via communication connections, or they can also be deployed and run on a local computer. This application does not limit the described approach or method; corresponding technologies can be flexibly deployed and fully utilized to execute and complete the method using cloud computing, big data, supercomputing capabilities, and other equipment and technologies.

[0122] Some implementations of this disclosure may include an article of writing. The article of writing may include a storage medium for storing logic. Examples of storage media may include one or more types of computer-readable storage media capable of storing electronic data, including volatile or non-volatile memory, removable or non-removable memory, erasable or non-erasable memory, writable or rewritable memory, and so on. Examples of logic may include various software units, such as software components, programs, applications, computer programs, application programs, system programs, machine programs, operating system software, middleware, firmware, software modules, routines, subroutines, functions, methods, procedures, software interfaces, application programming interfaces (APIs), instruction sets, computational code, computer code, code segments, computer code segments, words, values, symbols, or any combination thereof. In some implementations, for example, the article of writing may store executable computer program instructions that, when executed by a processor, cause the processor to perform the methods and / or operations described herein. Executable computer program instructions may include any suitable type of code, such as source code, compiled code, interpreted code, executable code, static code, dynamic code, and so on. Executable computer program instructions can be implemented according to a predefined computer language, method, or syntax used to command the computer to perform specific functions. These instructions can be implemented using any suitable high-level, low-level, object-oriented, visual, compiled, and / or interpreted programming language.

[0123] The examples described above include those of the disclosed architecture. It is certainly impossible to describe every conceivable combination of components and / or methods, but those skilled in the art will understand that many other combinations and arrangements are also possible. Therefore, this novel architecture is intended to cover all such alternatives, modifications, and variations that fall within the spirit and scope of the appended claims.

Claims

1. A method for retrieving data by graph traversal query, wherein, include: Receive graph traversal query; A graph traversal-based syntax and lexical parser generates a syntax tree from the graph traversal query. Traverse the syntax tree to generate an application programming interface query; The target data is obtained by querying the application programming interface.

2. The method according to claim 1, wherein, The graph traversal syntax and lexical parser includes the specifications for content, nodes, node relationships, relations, numerical graphs, pseudonyms, and filters; The graph traversal-based syntax and lexical parser generates a syntax tree from the graph traversal query, including: Based on the specified content, nodes, node relationships, relationships, numerical graphs, pseudonyms, and filters, the graph is traversed and queried to generate a syntax tree.

3. The method according to claim 1, wherein, A graph traversal-based syntax and lexical parser generates a syntax tree from the graph traversal query, including: The graph traversal query generates a syntax tree that includes multiple tree nodes and connections between them.

4. The method according to claim 1, wherein, Traverse the syntax tree to generate application programming interface queries, including: Traverse the tree nodes and connections between them in the syntax tree, and generate an application programming interface query based on the parsing function.

5. The method according to claim 1, wherein, The step of querying and obtaining target data according to the application programming interface includes: According to the application programming interface, the application programming interface is called to query the application and obtain the target data.

6. The method according to claim 1, wherein, The step of calling the application programming interface (API) to query the application and obtain the target data includes: According to the application programming interface (API), the API is called to query the building temperature detection application and obtain temperature data.

7. A device (200) for obtaining data by graph traversal query, wherein, include: The receiving module (201) is used to receive graph traversal queries; The generation module (202) is used to generate a syntax tree by traversing the graph according to the syntax and parser rules; The traversal module (203) is used to traverse the syntax tree and generate application programming interface queries; The acquisition module (204) is used to query and acquire target data according to the application programming interface.

8. A computer device comprising a memory and a processor, wherein the memory stores a computer program, When the processor executes the computer program, it implements the steps of the method according to any one of claims 1 to 6.

9. A computer-readable storage medium having a computer program stored thereon, wherein, When the computer program is executed by a processor, it implements the steps of the method according to any one of claims 1 to 6.

10. A computer program product tangibly stored on a computer-readable medium and comprising computer-executable instructions that, when executed, cause at least one processor to perform the method according to any one of claims 1 to 6.

Images