CN113486092A

CN113486092A - Time graph approximate query method and device based on time constraint

Info

Publication number: CN113486092A
Application number: CN202110872412.4A
Authority: CN
Inventors: 黄金晶
Original assignee: Suzhou Vocational Institute of Industrial Technology
Current assignee: Suzhou Vocational Institute of Industrial Technology
Priority date: 2021-07-30
Filing date: 2021-07-30
Publication date: 2021-10-08
Anticipated expiration: 2041-07-30
Also published as: CN113486092B

Abstract

The invention discloses a time graph approximate query method based on time constraint, which comprises the following steps: s1: and receiving a plurality of query graphs, and putting the query graphs into a query waiting queue according to the time sequence. S2: and sequentially taking out a plurality of query graphs from the query waiting queue, and receiving the corresponding limited hop count h. S3: and performing approximate matching on the query graph in a pre-stored time graph within the range of the limited hop count h to obtain an approximate query result set. S4: and screening according to the time constraint relation of the approximate query result set and the query graph to obtain a final query result set. S5: and outputting a final query result set, and finishing the approximate query of the time chart. The invention can carry out approximate query of the time-constrained time chart, the query chart is provided with the time-constrained relation, the subgraph simulation technology is utilized to carry out subgraph matching in the specified hop number range, the approximate query result of the query chart is found in the data chart, and the query result meets the preset time-constrained relation in the query chart.

Description

Time graph approximate query method and device based on time constraint

Technical Field

The invention belongs to the field of data analysis, and particularly relates to a time graph approximate query method and device based on time constraint.

Background

Graph pattern matching is to find all matching results according to a given query graph in a data graph, and plays an important role in many aspects, such as matching of chemical molecular structures, analysis of social relationships in social networks, and the like. In recent years, how to perform effective graph matching in large-scale data graphs is a hot issue of academic and industrial research. In the past, most of research is focused on static graphs, but data in the fields of social networks, biochemistry and the like in life are dynamically changed, and some documents begin to focus on query of dynamic time graphs. In the time chart, the edges of the connecting nodes have time information, and a time constraint relationship can be added according to a semantic relationship in the process of inquiry, for example, a traveler who flies from Beijing to Guangzhou wants to stay in Shanghai for one day, needs to check the flight from Beijing to Shanghai and the flight from Shanghai to Guangzhou in the process of flight inquiry, and the two flights need to have a time interval of one day. Graph pattern matching on a dynamic time graph can reflect the relationship between query results and time.

At present, the time-constrained query is carried out in a time chart, and the main problem exists in the prior art that the time-constrained query is carried out on the time chart, and the query result completely consistent with the query chart is obtained mainly by using an accurate matching mode, so that the practical application is difficult to form.

Disclosure of Invention

The invention aims to provide a time graph approximate query method and device based on time constraint so as to provide the technical effect of practical application.

In order to solve the problems, the technical scheme of the invention is as follows:

a time graph approximate query method based on time constraint comprises the following steps:

s1: and receiving a plurality of query graphs, and putting the query graphs into a query waiting queue according to the time sequence.

S2: and sequentially taking out a plurality of query graphs from the query waiting queue, and receiving the corresponding limited hop count h.

S3: and performing approximate matching on the query graph in a pre-stored time graph within the range of the limited hop count h to obtain an approximate query result set.

S4: and screening according to the time constraint relation of the approximate query result set and the query graph to obtain a final query result set.

S5: and outputting a final query result set, and finishing the approximate query of the time chart.

The time constraint relationship is the relationship between the two time intervals, and the time constraint relationship comprises the steps of prior, partial overlapping and inclusion.

Further preferably, the time constraint relationship further comprises a time constraint value Δ T, { Δ T α T | α ∈ { < ≦, > ≧ } }, where T is a time threshold.

The preceding time interval between two time intervals in the preceding relationship is coherent with the time constraint value Δ t.

The overlap time region in the partial overlap relationship between two time intervals is coherent with the time constraint value Δ t.

Wherein step S3 specifically includes the following steps

S31: reading the first table item Q of the query graph₀To obtain the table entry Q₀And matching the node value and the in-out value with the time chart to obtain a point matching result set ResultV and an edge matching result set ResultE.

S32: merging according to the edge matching result set ResultE in step S31, putting the merged result into the result set ResultQ, updating the point matching result set ResultV, and then emptying the edge matching result set ResultE after merging.

S33: reading next table item Q of query graph₁To obtain the table entry Q₁And the node value and the in-out value are matched with the time chart to update a point matching result set ResultV and an edge matching result set ResultE.

S34: merging according to the edge matching result set ResultE in the step S33, putting the merged result into a result set ResultQ, updating a point matching result set ResultV, and clearing the edge matching result set ResultE.

S35: and repeating the step S33 and the step S34 until all the entries in the query graph are read, and obtaining an approximate query result set.

Specifically, step S31 specifically includes the following steps

S311: reading the first table item Q of the query graph₀To obtain the table entry Q₀Node value and in-out value of (a).

S312: find and table item Q from time chart₀Relative to each otherA corresponding data block, each data item of the data block is read,

if the entry and exit value recorded in the data item is greater than or equal to the entry Q₀The point matching result set ResultV is updated according to the data item.

If each data item of the data block is read completely and the point matching result set ResultV is not updated, go to step S5, output NULL and end the query.

S313: read table entry Q₀To obtain a table entry Q₀Point to another table entry Q_x。

S314: reading point matching result set ResultV inner table item Q₀The corresponding data items are sequentially matched in the time chart within the range of limited hop number h, and the table item Q is found₀To table entry Q_xReachable path acquisition Q₀Q_xThe edge matches the result and will match the table entry Q_xUpdating the corresponding matching result to the point matching result set ResultV, Q₀Q_xAnd updating the edge matching result to an edge matching result set ResultE.

S315: repeating the step S314, updating the point matching result set ResultV and the edge matching result set ResultE until the point matching result set ResultV and the edge matching result set ResultE are matched with the table item Q₀And then the process goes to step S32 after all the link entries are matched.

Specifically, step S33 specifically includes the following steps

S331: reading next table item Q of query graph₁To obtain the table entry Q₁Searching whether the table item Q exists in the point matching result set ResultV or not₁If the matching result of (1) is present, the process proceeds to step S332, and if not, the table entry Q is checked in step S31₁And matching is carried out, and the point matching result set ResultV is updated.

S332: read table entry Q₁To obtain a table entry Q₁Point to another table entry Q_ySearching whether the point matching result set ResultV has an item Q_yIf the matching result of (3) is present, the process proceeds to step S333, and if not, the process proceeds to step S334.

S333: read point match result set ResultVTable item Q₁And Q_yAnd sequentially matching the table entries Q₁The matching result is matched in the time chart within the range of limited hop number h, and the table item Q is found₁To table entry Q_yReachable path acquisition Q₁Q_yEdge-matching the result, and matching Q₁Q_yAnd updating the edge matching result into an edge matching result set ResultE, and jumping to the step S335.

S334: reading point matching result set ResultV inner table item Q₁And sequentially matching the table entries Q₁The matching result is matched in the time chart within the range of limited hop number h, and the table item Q is found₁To table entry Q_yReachable path acquisition Q₁Q_yThe edge matches the result and will match the table entry Q_yUpdating the corresponding matching result to the point matching result set ResultV, Q₁Q_yAnd updating the edge matching result into an edge matching result set ResultE, and jumping to the step S335.

S335: repeating the steps S332 to S334, and updating the point matching result set ResultV and the edge matching result set ResultE until the point matching result set ResultV and the edge matching result set ResultE are matched with the table item Q₁And then the process goes to step S34 after all the link entries are matched.

Specifically, step S4 specifically includes the following steps

S41: and reading the time constraint relation of the query graph.

S42: and reading the matching results of the result set ResultQ in sequence, and removing the matching results which do not accord with the time constraint based on the time constraint relation of the query graph to obtain a final query result set.

A time-graph approximate query device based on time constraint comprises a query graph receiver, a first memory, a query graph analyzer, a query graph matching processor, a time constraint processor and a second memory,

the query graph receiver is used for receiving a plurality of query graphs and putting the query graphs into the first memory according to the time sequence.

The query graph analyzer sequentially fetches a plurality of query graphs from the first memory and receives the corresponding limited hop count h.

And the query graph matching processor is used for receiving the query graph and the limited hop count h, and carrying out approximate matching on the query graph in a range of the limited hop count h in a pre-stored time graph to obtain an approximate query result set.

The time constraint processor is used for receiving the time constraint relation of the approximate query result set and the query graph, and screening to obtain a final query result set.

The second memory is used for receiving and storing the final query result set and outputting the final query result set.

Specifically, the query graph matching processor is configured to read a plurality of entries of the query graph, obtain node values and entry and exit values of the plurality of entries, and sequentially match the plurality of entries with the time graph to obtain a point matching result set ResultV and an edge matching result set ResultE. And merging the edge matching result sets ResultE, putting the merged result into a result set ResultQ, updating the point matching result set ResultV, and clearing the edge matching result set ResultE after merging is executed to obtain an approximate query result set.

Specifically, the time constraint processor is configured to receive the time constraint relationship of the query graph from the query graph matching processor, sequentially read matching results of the result set ResultQ, and remove matching results that do not meet the time constraint based on the time constraint relationship of the query graph, thereby obtaining a final query result set.

Due to the adoption of the technical scheme, compared with the prior art, the invention has the following advantages and positive effects: the invention can carry out approximate query of the time-constrained time chart, the query chart is provided with the time-constrained relation, the subgraph simulation technology is utilized to carry out subgraph matching in the specified hop number range, the approximate query result of the query chart is found in the data chart, and the query result meets the preset time-constrained relation in the query chart. The graph pattern matching on the dynamic time graph can reflect the relation between the query result and the time, and the optimal time arrangement is realized.

Drawings

Various other advantages and benefits will become apparent to those of ordinary skill in the art upon reading the following detailed description of the preferred embodiments. The drawings are only for purposes of illustrating the preferred embodiments and are not to be construed as limiting the invention.

FIG. 1 is a flow chart of a time graph approximate query method based on time constraint according to the present invention;

FIG. 2 is a schematic diagram of a timing diagram of the present invention;

FIG. 3 is a schematic diagram of reachable paths based on the time diagram of FIG. 2;

FIG. 4 is a schematic diagram of a time constraint relationship according to the present invention;

FIG. 5 is a schematic diagram of a logic structure of a timing diagram according to the present invention;

FIG. 6 is a schematic diagram of a time chart according to the present invention;

FIG. 7 is a schematic diagram of a logical structure of a query graph of a time graph according to the present invention;

FIG. 8 is a schematic diagram of a storage structure of a query graph according to the present invention;

FIG. 9 is a block diagram of an apparatus for approximate query of a time chart based on time constraint according to the present invention;

FIG. 10 is a query graph example of the present invention;

FIG. 11 is another query example of the present invention;

FIG. 12 is a diagram illustrating a prior relationship screening rule according to the present invention;

FIG. 13 is a diagram illustrating a relationship screening rule according to the present invention;

FIG. 14 is a diagram illustrating a partial overlap relationship filtering rule according to the present invention

FIG. 15 is a diagram of an edge matching result set ResultE according to the present invention;

FIG. 16 is a diagram of a final query result set in accordance with the present invention.

Detailed Description

In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the following description will be made with reference to the accompanying drawings. It is obvious that the drawings in the following description are only some examples of the invention, and that for a person skilled in the art, other drawings and embodiments can be derived from them without inventive effort.

For the sake of simplicity, the drawings only schematically show the parts relevant to the present invention, and they do not represent the actual structure as a product. In addition, in order to make the drawings concise and understandable, components having the same structure or function in some of the drawings are only schematically illustrated or only labeled. In this document, "one" means not only "only one" but also a case of "more than one".

The time graph approximate query method and device based on time constraint proposed by the present invention will be further described in detail with reference to the accompanying drawings and specific embodiments. Advantages and features of the present invention will become apparent from the following description and from the claims.

Example 1

Referring to fig. 1, the present embodiment provides a time graph approximate query method based on time constraints, which includes the following steps. S1: and receiving a plurality of query graphs, and putting the query graphs into a query waiting queue according to the time sequence. S2: and sequentially taking out a plurality of query graphs from the query waiting queue, and receiving the corresponding limited hop count h. S3: and performing approximate matching on the query graph in a pre-stored time graph within the range of the limited hop count h to obtain an approximate query result set. S4: and screening according to the time constraint relation of the approximate query result set and the query graph to obtain a final query result set. S5: and outputting a final query result set, and finishing the approximate query of the time chart.

First, a description is given of what is referred to as a time chart, and particularly, referring to fig. 2, fig. 2 is only an illustrative example of a time chart, and is not limited thereto. In fig. 1, there are 4 nodes, and the nodes are connected to form edges, and the edges have time information, and the time information is composed of a series of time intervals(s)₁,e₁)、(s₂,e₂)、……、(s_i,e_i) Composition of wherein s_iRepresents the starting time, e_iRepresenting the termination time. If it is necessary to start from a node and reach another node, the time on the edge of the passing node is ordered, and the path is the timeTo the path. In FIG. 1, A₁B₂The time interval of the edge is (1,5), B₂C₁The edge time interval has two segments (3,7) and (6, 10). Wherein the starting time 3 of (3,7) is less than A₁B₂End time of edge (1,5) 5, thus from A₁To C₁There is only one time reachable path, as shown in fig. 3.

Next, referring to fig. 4, as described above, there are time intervals between two adjacent nodes in the time chart, and there are time constraint relations between two adjacent nodes, and there are 13 time constraint relations, and in this embodiment, the 13 relations are integrated and summarized into 3 kinds, which are, respectively, prior to (before), partially overlapping (overlaps), and containing (contacts). When the time constraint relationship is prior to or partially overlapping, the time constraint relationship also sets a time constraint value Δ T, { Δ T α | α ∈ { < ≦, >, > ≧ } }, where T is a time threshold.

Illustrating time constraint relationships

1) Suppose two time intervals (t)₁,t₂) And (t)₃,t₄) Both satisfy ″ (t)₁,t₂)before(t₃,t₄) And Δ t ≧ 2 "indicates a time interval (t)₁,t₂) Is to precede (t)₃,t₄) And the preceding time interval is at least 2.

2) Suppose two time intervals (t)₁,t₂) And (t)₃,t₄) Both satisfy ″ (t)₁,t₂)overlaps(t₃,t₄) And Δ t<2' represents the time interval (t)₁,t₂) Some time intervals are coincided with (t)₃,t₄) And the overlapping time regions are less than 2.

3) Suppose two time intervals (t)₁,t₂) And (t)₃,t₄) Both satisfy ″ (t)₁,t₂)contains(t₃,t₄) "then represents the time interval (t)₁,t₂) Comprises (t)₃,t₄)。

Referring to fig. 5 and 6, in the present embodiment, the nodes having the same tag value in the time mapDifferentiation by subscripts is possible, see in particular FIG. 5, A₁、A₂、A₃Distinguished by subscripts. Referring specifically to fig. 5, in the storage of the time chart, a multi-level index structure is adopted, and the out-degree and in-degree of each node and other nodes pointed to by the node are recorded for each node. With A₁Node is taken as an example, in FIG. 4, from A₁The node starts to have two edges respectively pointing to B₁And D₁Node, thus recording A₁Node out degree of 2, in degree of 0, A₁The Next pointer of a node points to B₁And D₁In the node respectively records A₁B₁Edge and A₁D₁Time intervals on the edges.

Referring to fig. 7 and 8, the query graph is next described. FIG. 7 shows three query graphs. FIG. 7(1) is a query graph expressing the relationship of "before", where the time interval on the AB edge is prior to the time interval on the AC edge, and the prior time interval is greater than 2. Fig. 7(2) expresses the "overlaps" relationship that the time interval on AB overlaps with the time interval on CA by a partial overlap time of 3. FIG. 7(3) shows that the time interval on the AB side includes the time interval on the AC side, and the time interval on the BC side is prior to the time interval on the AB side and is less than or equal to 1. Fig. 8 is a adjacency list storage lookup table adopted in this embodiment, and an array C is used to record a time constraint relationship, and fig. 8 is a storage structure of a lookup table shown in (1) of fig. 7. Each entry of the adjacency list records a node value, an access value, and a node pointed to by each node in the query graph. The time constraint array records the time constraint relation between edges in the query graph, and each unit in the time constraint array is a time constraint relation.

With reference to fig. 1, the implementation of the present embodiment will now be described step by step.

In step S1, a plurality of query graphs are received and put into a query waiting queue in the time order of receiving the query graphs.

Next, in step S2, the query graph is sequentially fetched from the query waiting queue, and the corresponding limited hop count h is received to enter step S3 for matching.

In step S3, the query graph and the preset time graph are approximately matched within the range of the limited hop count h to obtain an approximate query result set, specifically, step S3 specifically includes the following steps.

First, in step S31, the first entry of the read query graph is marked as Q₀To obtain the table entry Q₀And matching the node value and the in-out value with the time chart to obtain a point matching result set ResultV and an edge matching result set ResultE.

Can be subdivided into the following steps

First, in step S311, the first table entry Q of the query graph is read₀To obtain the table entry Q₀For convenience of description of the subsequent steps, assume that the table entry Q is a table entry Q₀The node value of (a) is a, which may also be referred to as node a.

Next, in step S312, find the data block corresponding to the node value a from the storage structure of the time chart, sequentially read each data item of the data block, and if the node in-out value recorded in the data item is greater than or equal to the entry Q in the query graph obtained in step S311₀The node recorded in the data item is a matching result of the node a, and is put into the point matching result set ResultV ═ a (a)_a,A_b,…)}，A_a、A_bIs an entry Q in the time chart₀Corresponding to the node value in the data block. If the query of the entire data block is completed, result v is NULL, which indicates that no corresponding node is matched, and the process directly proceeds to step S5, and the query is ended.

Then, in step S313, the table entry Q is read₀The Next pointer of (A) points to a link table entry L₀Link table item L₀The node pointed to by the node A is stored, and the node value of the pointed node is marked as B for convenience of description.

Next, in step S314, a matching result A (A) of the A node in ResultV is found_a,A_b…), the first matching result A of the A node is taken_aFinding the data block where A is located in the storage structure of the time chart, and finding A_aCorresponding data item from A_aStarting from the node, finding out the B which can be matched with the B node of the query graph in all h-hop ranges in the time graph_m、B_n… node, i.e. from A_aNode starts to B_m、B_n… node has time reachable path, and records the matching result of node B into the point matching result set ResultV, and records the edge matching result into the edge matching result set ResultE ═ AB: (a: (B)<A_aB_m,T>；<A_aC_i,T；C_iD_k,T；…；F_mB_n,T>)}，<A_aB_m,T>Express edge A_aB_mCan match edge AB, and edge A_aB_mThe time interval of (a) is T;<A_aC_i,T；C_iD_k,T；…；F_mB_n,T>expression from A_aNode departure and approach node C_i、D_k…F_mAnd finally to B_nNode, the whole process is in h hop range and is from A_aTo B_nThere is a time reachable path in between. The same method is used for the remaining matching result { A ] of the node A_b… finding reachable B within h-hop range in time diagram_m、B_n…, the point matching result set ResultV and the edge matching result set ResultE also need to be updated continuously.

In step S315, the table entries Q are read in sequence₀The remaining chain table items pointed by the Next pointer are matched in the h-hop range according to the step S314, and the point matching result set ResultV and the edge matching result set ResultE are updated until the point matching result set ResultV and the edge matching result set ResultE are matched with the table item Q₀And after all the link entries are matched, the link entry is NULL, and the step S32 is skipped.

Subsequently, the process proceeds to step S32, where the entry Q is checked₀The node a in (b) and the matching results of the node B, C … and the like pointed to by the node a are merged, the merged result is put into a result set ResultQ, and the matching results in a point matching result set ResultV are updated. In addition, the matching result of the edge matching result set ResultE needs to be cleared in order to match the next entry of the adjacency list of the query graph.

Referring to fig. 10, step S32 is illustrated. According to the stepsFirstly, matching the node A, and setting the matching result of the node A as A₁And A₂Then ResultV ═ a (a)₁,A₂) Are followed by A₁And A₂And matching the node B within the starting h hop range, and setting the matching result of the AB edge in the time chart as ResultE { { AB: (a { [ AB ])<A₁B₁,T>、<A₂B₁,T>) } and then adds the node B match result to ResultV, which is { a (a) (B) }₁,A₂)、B(B₁) }; then matching the AC edge, and setting the matching result of the AC edge as<A₁C₁,T>Then ResultE { { AB: (a) { (B) } at this time<A₁B₁，T>、<A₂B₁，T>)}、{AC:(<A₁C₁,T>)}}，ResultV＝{A(A₁,A₂)、B(B₁)、C(C₁) }; the matching results of the AB edge and the AC edge are combined next, because the matching result of the AC edge is not from A₂Matching results of point origin, thus removing one matching result of AB edge<A₂B₁,T>And updating the matching result of ResultV, wherein ResultV is { A (A)₁，)、B(B₁)、C(C₁) Put the merged result into result set ResultQ ═ AB: (a: (b))<A₁B₁,T>)、{AC:(<A₁C₁,T>)}。

Next, step S33 specifically includes the following steps,

first, in step S331, the next table entry Q of the query graph is read₁To obtain the table entry Q₁For convenience of description of the subsequent steps, assume that the table entry Q is a table entry Q₁The node value of (a) is D, which may also be referred to as D node. Searching whether the table item Q exists in the point matching result set ResultV or not₁If the matching result of (1) is present, the process proceeds to step S332, and if not, the table entry Q is checked in step S31₁And matching is carried out, and the point matching result set ResultV is updated.

Then, the process proceeds to step S332, where the table entry Q is read₁The Next pointer of (A) points to the first link entry L of the link entry₀For convenience of description, let the link table entry L₀And searching whether a matching result with the node value V exists in the point matching result set ResultV, if so, entering a step S333, and if not, entering a step S334.

If the process goes to step S333, the matching result D (D) of the D node in the point matching result set ResultV is read₁,D₂…), for each matching result of D, it is found whether there is a time reachable path from the node within h hops to reach V_iNode (V)_iIs the matching result V (V) of V in step S332₁,V₂…) and records the DV edge matching result into ResultE, and then jumps to step S335.

If step S334 is entered, since the V node has not been matched in the foregoing step, the matching result of the D node in ResultV is directly read, for each matching result of D, a node that can be matched with the V node in the query graph within the h-hop range is found in the time graph according to the method in step S314, the matching result of the V node is recorded into the result set ResultV, and the matching result of the DV edge is recorded into the result set ResultE, and then step S335 is entered.

Finally, in step S335, steps S332 to S334 are repeated, and the point matching result set ResultV and the edge matching result set ResultE are updated until the table entry Q is reached₁And then the process goes to step S34 after all the link entries are matched.

Similar to the step S32, the step S34 is specific to the entry Q₁Merging the D node and the node matching result pointed by the D node according to the step S32, adding the merged result into a result set ResultQ, and removing the matching result which does not meet the requirement in the merging process; the ResultE edge match result set is then cleared in preparation for the next match.

Referring to fig. 11, another merging case is specifically explained. The query graph shown in fig. 11 has more BC edges than fig. 10, and after the AB edges and the AC edges are matched according to the foregoing steps, the matching results are merged and placed into the result set ResultQ. The edge BC is then matched, since the node B and the node C have been matched previously, so that the result B (B) from the matching of the node B is obtained_i…) start to findReachable C within h-hop range_kNode, and C_kThe node is a matching result of the C node in the previous step, and finally the matching result of the BC edge is merged into ResultQ.

And subsequently, repeating the step S33 and the step S34 until all the entries in the query graph are read, and obtaining an approximate query result set.

And then, in S4, screening according to the time constraint relation of the approximate query result set and the query graph to obtain a final query result set. In particular to

First, in step S41, the time constraint relationship of the query graph is read, see FIG. 8, and the first element C in the time constraint relationship array is read₀Taking out two edges e with time constraint relation₁And e₂Time constraint relationship type R_cAnd a time constraint value T_c。

Next, in step S42, the matching results in the result set ResultQ are sequentially read, and if there is a sum edge e₁、e₂Matched side e'₁And e'₂(e’₁And e'₂Within h hop range and e are also possible₁、e₂Matching path) of e'₁The time intervals within the upper h-jump range are (t)_a1,t_b1),(t_a2,t_b2)…，e’₂The time intervals within the upper h-jump range are (t)_c1,t_d1),(t_c2,t_d2) …, further screening out the results meeting the time constraint relationship, and removing the results not meeting the time constraint relationship to obtain the final query result set.

The specific rule is

1) before relationship

Referring to FIG. 12, (t)_a1,t_b1)…(t_an,t_bn) To be able to sum with e₁Matching h-hop in-range path e'₁Time interval (t) of_c1,t_d1)…(t_cn,t_dn) To be able to sum with e₂Matching h-hop in-range path e'₂In the above time zone, the before rule requires route e'₁The last time intervalTo precede e'₂The first time interval of (1), i.e. t_bn<t_c1And t is_c1-t_bnSatisfying a time constraint value T_c。

2) contacts relationships

Referring to FIG. 13, the continains relationship requires e'₂Each time interval on the path is contained in e'₁Within a certain time interval; i.e. to e'₂Each time interval (t) on the path_ci,t_di) Sequentially inquire e'₁Each time interval (t)_a1,t_b1)…(t_an,t_bn) See if there is a time interval (t)_ak,t_bk) Is in accordance with t_ci≥t_akAnd t is_di≤t_bk。

3) overlap relationships

Referring to FIG. 14, the overlap relationship requires e'₁The starting time of the first time interval on the path is earlier than e'₂Starting time of the first time interval on the route, e'₁The end time of the last time interval on the route is earlier than e'₂End time of last time interval on route, and e'₁And e'₂The overlapped interval values are required to satisfy the time constraint value T_c。

Finally, in step S5, the final query result set is output, and we get the desired result and end the time-graph approximation query.

Example 2

Referring to fig. 2, the present embodiment provides a time-constraint-based time chart approximate query apparatus according to embodiment 1, which employs a time chart approximate query method according to any one of the requirements of embodiment 1.

Referring to fig. 9, the present embodiment includes a query graph receiver, a first memory, a query graph analyzer, a query graph matching processor, a time constraint processor, and a second memory,

Fig. 5 is a time chart, and fig. 7(1) is a query chart, which is used to describe the whole query process in conjunction with the present embodiment.

The query graph receiver is used for receiving a query graph submitted by a user and putting the query graph into the first memory according to the time sequence.

The query graph analyzer fetches the query graph from the first memory, receives the restricted hop count h, in this example, let h be 2, and sends the query graph and the corresponding restricted hop count h to the query graph matching processor.

The query graph matching processor performs approximate matching within a 2-hop range in the data graph according to the structure of the query graph, and the matching process is as follows:

1) reading first table item Q of adjacent table of query graph₀And obtaining the node value A, the out-degree value 2 and the in-degree value 0 of the table entry.

2) In the storage structure of the time graph, finding a data block corresponding to the node A, firstly reading a first item set in the data block to obtain the node A₁Out-degree value 2 and in-degree value 0 corresponding to the node, because A₁The access values of the nodes are all equal to the access value of the node in the query graph A, and the matching result ResultV is recorded as { A (A)₁)}. Continuing to read the second item set in the data block to obtain A₂Out-degree value 4, in-degree value 0, and A corresponding to the node₁When the node entry and exit values are compared, the matching result is recorded as result { A (A) }₁,A₂)}. Continuing to read the third set of items in the data block, obtainingTo obtain A₃Out-degree value 1 and in-degree value 2 corresponding to the node, because A₃The out-degree value of the node is smaller than the out-degree value of the node A in the query graph, so that A₃The node cannot be matched with the a node.

3) Reading the first table item Q in the query graph₀The Next pointer of (A) points to a link table entry L₀If the node value is B, entering the step (4) to match the AB side within the 2-hop range;

4) find the matching result A (A) of the A node in ResultV₁,A₂) Finding out the data block of A in the storage structure of the time chart and matching the data block to A₁Corresponding data item from A₁Starting from the data item of the node, the Next pointer points to the linked list, and the first node value is B₁Satisfy the match of AB edge in 2 jump range, and match B₁Node records the result set ResultV ═ A (A) of the point matching₁,A₂)，B(B₁) And simultaneously recording the matching result into an edge matching result set result (AB: (<A₁B₁,(1,2)>) Due to A }₁To B₁Only 1 jump between them, so continue to find B data block, find B₁In the item set, discovery B₁Edge not pointed out, pair B₁The matching of the nodes is terminated. In A₁Continuously reading the Next node of the linked list pointed by Next in the data block, the node value is D₁Finding out the data block where D is located and matching D₁Data item of interest, discovery D₁The pointed node is C₁Cannot match B in the 2-hop range, and thus is from A₁From node, only the node in 2-hop range is matched with the node B<A₁B₁,(1,2)>. Next, another matching result A to the A node₂The matching of the AB edge within the 2-hop range is carried out, and the matching result with time for reaching the path is recorded, in this case, only<A₂B₁,(3,4)(8,19)>Can match the AB edge, Path A₂→E₁→B₂The time reachable path is not met. Thus, in this step, the final AB edge match result formed is ResultE ═ AB: (<A₁B₁,(1,2)>、<A₂B₁,(3,4)>、<A₂B₁,(8,19)>}；

5) Reading table item Q in query graph₀The Next pointer of (a) points to the Next table entry L of the linked list₁Matching the AC edges in the 2-hop range by the method in the above step 4), and recording the matching result of the C node into result (v) { a (a) }₁,A₂),B(B₁),C(C₁) And recording the edge matching result into result ═ AC: (<A₁D₁,(5,6)；D₁C₁,(9,11)>、<A₁D₁,(7,8)；D₁C₁,(9,11)>、<A₂C₁,(6,8)>、<A₂E₂,(7,9)；E₂C₁,(11,15)>}。

6) Repeating the step 5) to read the table item Q₀The Next pointer of (L) points to the Next entry of the linked list since L₁The next entry in the table is NULL, so for Q₀The matching of the relevant nodes of the table entry is finished.

7) Referring to FIG. 15, for item Q₀The node A in the system and the matching results of the node B and the node C pointed to by the node A are merged, and the merged result is put into ResultQ. ResultQ { { (AB:<A₁B₁,(1,2)>),(AC：<A₁D₁,(5,6)；D₁C₁,(9,11)>)}、{(AB：<A₁B₁,(1,2)>),(AC：<A₁D₁,(7,8)；D₁C₁,(9,11)>)}、{(AB：<A₂B₁,(3,4)>),(AC：<A₂C₁,(6,8)>)}、{(AB：<A₂B₁,(8,19)>),(AC：<A₂C₁,(6,8)>)}、{(AB：<A₂B₁,(3,4)>),(AC：<A₂E₂,(7,9)；E₂C₁,(11,15)>)}、{(AB：<A₂B₁,(8,19)>),(AC：<A₂E₂,(7,9)；E₂C₁,(11,15)>)}}。

8) reading next table item Q of adjacent table of query graph₁Table entry Q₁The node value of (2) is B, and the node matching result ResultV already has B nodeAnd entering step 9) according to the point matching result.

9) Due to Q₁Item Next pointer is NULL, for item Q₁The matching of the relevant nodes is ended.

10) Continuously reading next table item Q of adjacent table of query graph₂Table entry Q₂The node value of (1) is C, the matching result of the C node is already in the node matching result ResultV, and the step 11) is entered.

11) Due to Q₂The item's Next pointer is NULL, for Q₂And finishing the matching of the table entry related nodes.

12) Because the last table entry Q of the adjacent table of the query graph₂After matching is completed, the approximate query result of the query matching the 2-hop range and the time constraint array of the query graph are sent to the time constraint processor.

The time constraint processor further screens the query results according to the time constraint relationship, selects the results conforming to the time constraint relationship, and obtains a final query result set, wherein the process is as follows:

a) reading the first element C in the time constraint relation array₀Taking out two edges AB, AC and R of time constraint relation_cBefore and time constraint value T_c>2。

b) Read the first match result, R, in ResultE₁＝{(AB：<A₁B₁,(1,2)>),(AC：<A₁D₁,(5,6)；D₁C₁,(9,11)>) Due to R_c＝before、T_c>2, the time interval of the AB edge in the matching result is required to be prior to the time interval of the AC edge, and the time interval is at least greater than 2. At R₁In (A)₁B₁The time interval on the side is (1,2), the matching result of the AC side is a time path of 2 hops, the time interval on the first hop is taken out according to the before relation and is compared, and the first hop A₁D₁The temporal interval on the sides is (5,6), A₁D₁The starting time of the temporal interval on the sides is 5, A₁B₁The edge has an end time of 2, it is clear that the time interval between 5 and 2 is greater than 2, and thus R₁Are query results that satisfy the temporal constraint relationship.

c) Continue reading the second match result, R, in ResultE₂＝{(AB：<A₁B₁,(1,2)>),(AC：<A₁D₁,(7,8)；D₁C₁,(9,11)>) The matching method of (c) }, same as b), R₂Is a match result.

d) Continue reading the third matching result, R, in ResultE₃＝{(AB：<A₂B₁,(3,4)>),(AC：<A₂C₁,(6,8)>) Due to A }₂B₁End time of the on-edge time interval and A₂C₁The start time on the edge does not satisfy the time relationship prior to 2, thus R₃Is not a match result.

e) Continue reading the fourth match result in ResultE as described in d), R₄Nor is it a matching result.

f) Continue reading the fifth match result, R, in ResultE₅＝{(AB：<A₂B₁,(3,4)>),(AC：<A₂E₂,(7,9)；E₂C₁,(11,15)>) According to the method described above, A₂B₁The temporal interval (3,4) and A on the sides₂E₂The temporal interval (7,9) on the sides satisfies the temporal relation preceding 2, so R₅Is a match result.

g) Continue reading the last match result, R, in ResultE₆＝{(AB：<A₂B₁,(8,19)>),(AC：<A₂E₂,(7,9)；E₂C₁,(11,15)>) That result is not a match result.

Referring to fig. 16, a final time constraint matching result R { { (AB:<A₁B₁,(1,2)>),(AC：<A₁D₁,(5,6)；D₁C₁,(9,11)>)}、{(AB：<A₁B₁,(1,2)>),(AC：<A₁D₁,(7,8)；D₁C₁,(9,11)>)}、{(AB：<A₂B₁,(3,4)>),(AC：<A₂E₂,(7,9)；E₂C₁,(11,15)>)}}。

the embodiments of the present invention have been described in detail with reference to the accompanying drawings, but the present invention is not limited to the above embodiments. Even if various changes are made to the present invention, it is still within the scope of the present invention if they fall within the scope of the claims of the present invention and their equivalents.

Claims

1. A time graph approximate query method based on time constraint is characterized by comprising the following steps:

s1: receiving a plurality of query graphs, and putting the query graphs into a query waiting queue according to a time sequence;

s2: sequentially taking out a plurality of query graphs from the query waiting queue, and receiving corresponding limited hop count h;

s3: carrying out approximate matching on the query graph in a pre-stored time graph within the range of the limited hop count h to obtain an approximate query result set;

s4: screening according to the time constraint relation of the approximate query result set and the query graph to obtain a final query result set;

2. The method according to claim 1, wherein a time interval is provided between two adjacent nodes in the time graph, and the time constraint relationship is a relationship between two time intervals, and the time constraint relationship includes prior, partial overlap, and containment.

3. The time constraint-based time map approximation query method of claim 2, wherein the time constraint relationship further comprises a time constraint value Δ T, { Δ T α T | α ∈ { ≦ >, > ≧ } }, where T is a time threshold;

the prior time interval under the prior relation between the two time intervals is coherent with the time constraint value delta t;

the overlap time zone in the partial overlap relationship between two of the time intervals is coherent with the time constraint value Δ t.

4. The time-constraint-based time graph approximate query method of claim 1, wherein the step S3 specifically comprises the following steps

S31: reading the first table item Q of the query graph₀Obtaining the table entry Q₀The node value and the in-out value are matched with the time chart to obtain a point matching result set ResultV and an edge matching result set ResultE;

s32: merging according to the edge matching result set ResultE in the step S31, putting a merging result into a result set ResultQ, updating the point matching result set ResultV, and then emptying the edge matching result set ResultE after merging;

s33: reading the next table item Q of the query graph₁Obtaining the table entry Q₁And the node value and the in-out value are matched with the time chart to update the point matching result set ResultV and the edge matching result set ResultE;

s34: merging according to the edge matching result set ResultE in the step S33, putting a merging result into the result set ResultQ, updating the point matching result set ResultV, and clearing the edge matching result set ResultE;

s35: repeating the step S33 and the step S34 until all the entries in the query graph are read, and obtaining the approximate query result set.

5. The time-constraint-based time graph approximate query method of claim 4, wherein the step S31 specifically comprises the following steps

S311: reading the first table item Q of the query graph₀Obtaining the table entry Q₀Node value and in-out value of (a);

s312: finding the time map from the time mapTable item Q₀A corresponding data block, reading each data item of the data block,

if the entry and exit value recorded in the data item is greater than or equal to the entry Q₀If the value of the point matching result set ResultV is less than the threshold value, updating the point matching result set ResultV according to the data item;

if each data item of the data block is read and the point matching result set ResultV is not updated, jumping to the step S5, outputting NULL and ending the query;

s313: reading the table item Q₀Obtaining the table entry Q₀Point to another table entry Q_x；

S314: reading the table item Q in the point matching result set ResultV₀The corresponding data items are sequentially matched in the time chart within the range of the limited hop number h, and the table item Q is found₀To the table entry Q_xReachable path acquisition Q₀Q_xThe edge matches the result and will match the table entry Q_xUpdating the corresponding matching result to the point matching result set ResultV, wherein Q is₀Q_xUpdating the edge matching result to the edge matching result set ResultE;

s315: repeating the step S314, updating the point matching result set ResultV and the edge matching result set ResultE until the point matching result set ResultV and the edge matching result set ResultE are matched with the table item Q₀After all the link table entries are matched, the process goes to step S32.

6. The time-constraint-based time graph approximate query method of claim 4, wherein the step S33 specifically comprises the following steps

S331: reading the next table item Q of the query graph₁Obtaining the table entry Q₁Searching whether the table item Q exists in the point matching result set ResultV or not₁If the matching result is present, the process proceeds to step S332, and if not, the step S31 is performed to the table entry Q₁Matching and updating to the point matching resultSet ResultV;

s332: reading the table item Q₁Obtaining the table entry Q₁Point to another table entry Q_ySearching whether the table item Q exists in the point matching result set ResultV or not_yIf the matching result is present, the process proceeds to step S333, and if not, the process proceeds to step S334;

s333: reading the table item Q in the point matching result set ResultV₁And Q_yAnd sequentially matching the table entries Q₁The matching result is matched in the time chart within the range of the limited hop number h, and the table item Q is found₁To the table entry Q_yReachable path acquisition Q₁Q_yEdge matching results, and matching said Q₁Q_yUpdating the edge matching result to the edge matching result set ResultE, and jumping to step S335;

s334: reading the table item Q in the point matching result set ResultV₁And sequentially matching the table entries Q₁The matching result is matched in the time chart within the range of the limited hop number h, and the table item Q is found₁To the table entry Q_yReachable path acquisition Q₁Q_yThe edge matches the result and will match the table entry Q_yUpdating the corresponding matching result to the point matching result set ResultV, wherein Q is₁Q_yUpdating the edge matching result to the edge matching result set ResultE, and jumping to step S335;

s335: repeating the steps S332 to S334, and updating the point matching result set ResultV and the edge matching result set ResultE until the point matching result set ResultV and the edge matching result set ResultE are matched with the table entry Q₁After all the link table entries are matched, the process goes to step S34.

7. The time-constraint-based time graph approximate query method of claim 1, wherein the step S4 specifically comprises the following steps

S41: reading the time constraint relation of the query graph;

s42: and sequentially reading the matching results of the result set ResultQ, and removing the matching results which do not accord with the time constraint based on the time constraint relation of the query graph to obtain the final query result set.

8. A time-constraint-based time-graph approximate query device is characterized by comprising a query graph receiver, a first memory, a query graph analyzer, a query graph matching processor, a time constraint processor and a second memory,

the query graph receiver is used for receiving a plurality of query graphs and putting the query graphs into the first memory according to a time sequence;

the query graph analyzer sequentially takes out a plurality of query graphs from the first memory and receives corresponding limited hop count h;

the query graph matching processor is used for receiving the query graph and the limited hop count h, and performing approximate matching on the query graph in a pre-stored time graph within the range of the limited hop count h to obtain an approximate query result set;

the time constraint processor is used for receiving the approximate query result set and the time constraint relation of the query graph so as to carry out screening to obtain a final query result set;

the second memory is configured to receive and store the final query result set, and is capable of outputting the final query result set.

9. The time-constraint-based time-graph approximation query device of claim 8,

the query graph matching processor is used for reading a plurality of table entries of the query graph, obtaining node values and access values of the table entries, and sequentially matching the table entries with the time graph to obtain a point matching result set ResultV and an edge matching result set ResultE; merging the edge matching result sets ResultE, putting the merged result into a result set ResultQ, updating the point matching result set ResultV, and clearing the edge matching result sets ResultE after merging to obtain the approximate query result set.

10. The apparatus as claimed in claim 8, wherein the time constraint processor is configured to receive the time constraint relationship of the query graph from the query graph matching processor, sequentially read the matching results of the result set ResultQ, and remove the matching results that do not meet the time constraint relationship based on the time constraint relationship of the query graph to obtain the final query result set.