R+ tree dynamic publish / subscribe method based on lazy update strategy

Abstract

The application discloses a kind of R+tree dynamic publishing and subscribing method based on lazy update strategy, comprising: constructing subscription condition list and R+tree;Receive subscription condition;The unique identification of subscription condition is generated, and the update field, boundary field and pointer field of subscription condition are determined;Judge whether the unique representation is contained in the initialized subscription condition list, if yes, delete subscription condition, and receive next subscription condition;If not, determine the updated subscription list and the updated R+tree, in response to the publishing request of target event, receive the subscription relationship of target event;Based on subscription relationship, search in the updated subscription list and the updated R+tree, determine final target subscription condition, and publish the final event corresponding to final target subscription condition.The application can improve the efficiency of traffic event matching and node subscription management.

Description

Technical Field

[0001] The present invention relates to the field of intelligent transportation technology, and in particular to an R+ tree dynamic publishing and subscription method based on a lazy update strategy. Background Art

[0002] During the interactive simulations of intelligent transportation systems, thousands of vehicles, traffic lights, sensors, and edge computing nodes interact in real time through a virtual environment, forming a complex, multidimensional, dynamic data flow network. As traffic flow, vehicle routing, and traffic management strategies change dynamically, the interactions (i.e., subscriptions) between nodes are constantly adjusted and updated over time. For example, vehicle routes, traffic congestion conditions, and traffic light scheduling strategies can all have immediate impacts on the relationships between nodes. Therefore, it is necessary to design an efficient dynamic subscription matching mechanism to improve matching efficiency and optimize overall system performance.

[0003] In a content-based publish-subscribe system, the core task of the matching algorithm is to efficiently locate all subscription conditions that match a specific event. The design goals of the matching algorithm primarily encompass multiple dimensions, including space efficiency, time efficiency, and subscription maintenance efficiency. Time efficiency is particularly critical, as the overall system performance depends heavily on the algorithm's responsiveness when handling a large number of dynamic subscriptions and events.

[0004] However, existing matching methods based on linear structures or simple tree structures have many limitations in matching efficiency, such as slow matching speed, high global update costs, and excessive consumption of system resources, which seriously affect the real-time and scalability of the system. In complex dynamic scenarios, how to improve the time efficiency of matching algorithms has become a major research challenge. To address these bottlenecks, researchers need to design matching algorithms that can maintain high efficiency and low latency performance in large-scale, multi-dimensional, and high-frequency interaction scenarios, ensure that the system can quickly respond to event changes, and support the dynamic maintenance and update of large-scale subscription conditions.

[0005] Among existing matching algorithms, the Hanson algorithm and its extended versions improve matching efficiency by indexing and counting predicates across different subscriptions and incorporating a filtering mechanism for matching results. This algorithm employs efficient testing methods to perform preliminary screening of some subscriptions in the early stages, followed by more refined matching operations on the remaining subscriptions, thereby optimizing overall performance. Although this algorithm utilizes predicate indexing technology to improve matching results, it fails to fully consider the interrelationships between different predicates. Furthermore, the Hanson algorithm relies on subscription coverage relationships and employs structures such as KD trees for matching extraction. While this improves matching efficiency to a certain extent, it performs poorly when dynamically updating subscriptions.

[0006] In comparison, the testing network based algorithm further improves matching efficiency by leveraging the correlation between subscriptions and predicates. This algorithm can effectively improve system performance by optimizing the subscription structure and organizing subscription relationships using partially ordered sets. However, due to the need to frequently judge coverage relationships and repeatedly test the same predicates, the algorithm has a high computational cost when processing dynamic subscriptions. For example, the Gryphon system improves matching performance through the structure of a parallel search tree and reduces network bandwidth consumption through message multicast technology. However, the system has certain limitations when processing equivalent predicates, and as the attribute dimension increases, the effectiveness of the coverage relationship gradually weakens, which leads to the emergence of predicate redundancy problems, affecting the efficiency of the overall system. Summary of the Invention

[0007] In view of the above-mentioned deficiencies in the prior art, the present invention provides an R+ tree dynamic publish-subscribe method based on a lazy update strategy, which solves the problem of low efficiency in matching high-frequency dynamic interactions between large-scale nodes in the prior art.

[0008] In order to achieve the above-mentioned object of the invention, the technical solution adopted by the present invention is: an R+ tree dynamic publish-subscribe method based on a lazy update strategy, comprising the following steps:

[0009] S1. Build a subscription condition list and an R+ tree, and initialize the subscription condition list and the R+ tree;

[0010] Among them, the R+ tree is constructed based on the subscription condition list;

[0011] S2. In response to the join request for the subscription condition, receiving the subscription condition according to the request time corresponding to the subscription condition;

[0012] S3. Generate a unique identifier for the subscription condition based on the timestamp, clock sequence, and MAC address of the subscription condition, and determine the update field, boundary field, and pointer field of the subscription condition;

[0013] S4. Determine whether the initialized subscription condition list contains a unique representation. If so, delete the subscription condition, receive the next subscription condition, and execute S2. If not, determine whether the boundary field of the subscription condition intersects with the boundary field in the initialized subscription condition list. If so, execute S5. If not, add the subscription condition to the initialized subscription condition list, update the initialized R+ tree, obtain an updated subscription list and an updated R+ tree, and execute S6.

[0014] S5. Modify the update field and boundary field of the subscription condition, determine the target subscription condition corresponding to the boundary field in the initialized subscription condition list, modify the update field and boundary field of the target subscription condition, add the updated subscription condition to the initialized subscription condition list, and update the initialized R+ tree to obtain an updated subscription list and an updated R+ tree.

[0015] S6. In response to the target event publishing request, receive a subscription relationship of the target event;

[0016] S7. Based on the subscription relationship, a search is performed in the updated subscription list and the updated R+ tree to determine the final target subscription condition, and a final event corresponding to the final target subscription condition is published.

[0017] The beneficial effect of the above scheme is: the present invention can efficiently manage dynamically changing traffic data streams by designing a redundant R+ tree index structure, combining incremental updates with lazy loading mechanisms, thereby solving the system performance bottleneck problem caused by frequent global updates. At the same time, it utilizes the spatial partitioning characteristics of the R+ tree to perform local optimization when the interaction relationship between nodes is complex, effectively improving the efficiency of traffic event matching and node subscription management.

[0018] Furthermore, in S3, a unique identifier of the subscription condition is generated based on the timestamp, clock sequence, and MAC address of the subscription condition, specifically including:

[0019] Using the UUIDv4 standard, the timestamp, clock sequence, and MAC address of the subscription conditions are processed to generate a unique identifier.

[0020] The beneficial effect of the above further solution is that using UUIDv4 to generate a unique identifier can ensure the uniqueness, security and flexibility of the generated unique identifier.

[0021] Furthermore, in S4, it is determined whether the boundary field of the subscription condition intersects with the boundary field in the initialized subscription condition list, specifically including:

[0022] When the boundary field of the subscription condition is a proper subset of the boundary field in the initialized subscription condition list, determining whether the boundary field of the subscription condition intersects the boundary of the boundary field in the initialized subscription condition list;

[0023] When the boundary field of the subscription condition is not a proper subset of the boundary field in the initialized subscription condition list, it is determined that the boundary field of the subscription condition does not intersect with the boundary of the boundary field in the initialized subscription condition list.

[0024] Furthermore, in S4, the initialized R+ tree is updated, specifically including:

[0025] According to the initialized subscription condition list with added subscription conditions, data is inserted according to the R+ tree insertion algorithm to update the initialized R+ tree.

[0026] Furthermore, in S3, the update field of the subscription condition is False;

[0027] In S5, the update fields of the subscription conditions are modified, including:

[0028] Change the Update field of the subscription condition from False to True.

[0029] The beneficial effect of the above further solution is: effectively reducing the number of queries to the R+ tree, and ensuring the robustness and high availability of subscription matching.

[0030] Furthermore, in S7, based on the subscription relationship, a search is performed in the updated subscription list and the updated R+ tree to determine the final target subscription condition, which specifically includes:

[0031] S71. Obtain subscription conditions of the subscription relationship;

[0032] S72. Search the updated R+ tree based on the subscription condition of the subscription relationship to determine the first subscription condition that satisfies the subscription relationship.

[0033] S73. Query the updated field of the first subscription condition from the updated subscription list. If the updated field is False, determine the first subscription condition as the final target subscription condition.

[0034] When the update field is True, the conditions are merged according to the boundary field of the first subscription condition to obtain the second subscription condition, and the updated R+ tree is updated again to obtain the final R+ tree;

[0035] S74. Set the update field of the subscription condition in the condition fusion process to False;

[0036] S75: Determine the second subscription condition as the final target subscription condition.

[0037] The beneficial effect of the above further scheme is: in this way, an on-demand loaded R+ tree update mode is realized, which can not only effectively reduce the number of tree queries, but also ensure efficient matching in the publish-subscribe mode, avoiding the excessive overhead of the traditional R+ tree when dealing with a large number of intersecting boundaries and requiring immediate redivision of the area, while maintaining the organizational rationality and query efficiency of the subscription tree, thereby improving the overall performance of the system. BRIEF DESCRIPTION OF THE DRAWINGS

[0038] Figure 1The figure is a flowchart of a dynamic publish-subscribe method for R+ trees based on a lazy update strategy.

[0039] Figure 2 This is a structural diagram of the subscription condition list.

[0040] Figure 3 A diagram showing how to update a subscription condition list.

[0041] Figure 4 Schematic diagram of updating the subscription condition list under boundary intersection conditions.

[0042] Figure 5 Schematic diagram of the structure and spatial distribution of the updated R+ tree.

[0043] Figure 6 This is a diagram of the monitored subscription conditions.

[0044] Figure 7 Schematic diagram of the structure and spatial distribution example of the R+ tree.

[0045] Figure 8 Schematic diagram of the structure and spatial distribution example of the updated R+ tree.

[0046] Figure 9 This is a schematic diagram of the newly received subscription conditions.

[0047] Figure 10 Schematic diagram of the updated subscription condition list and R+ tree instance.

[0048] Figure 11 The figure shows the updated subscription condition list and R+ tree instance diagram.

[0049] Figure 12 The figure shows the fused subscription condition list and R+ tree instance. DETAILED DESCRIPTION

[0050] The present invention will be further described below with reference to the accompanying drawings and specific embodiments.

[0051] like Figure 1 As shown, a dynamic publish-subscribe method for an R+ tree based on a lazy update strategy includes the following steps:

[0052] S1. Construct a subscription condition list and an R+ tree, and initialize the subscription condition list and the R+ tree; wherein the R+ tree is constructed according to the subscription condition list.

[0053] For example, the constructed subscription condition list (which can be represented as Condition-List) and R+ tree can be either: the subscription condition list is empty, and the R+ tree includes only the root node. Alternatively, the subscription condition list is not empty, and the R+ tree includes nodes other than the root node. The constructed subscription condition list and R+ tree are not specifically limited herein.

[0054] S2. In response to the joining request of the subscription condition, the subscription condition is received according to the request time corresponding to the subscription condition.

[0055] S3. Generate a unique identifier for the subscription condition based on the timestamp, clock sequence, and MAC address of the subscription condition, and determine the update field, boundary field, and pointer field of the subscription condition.

[0056] In this embodiment, in S3, a unique identifier of the subscription condition is generated based on the timestamp, clock sequence, and MAC address of the subscription condition, specifically including:

[0057] Using the UUIDv4 standard, the timestamp, clock sequence, and MAC address of the subscription conditions are processed to generate a unique identifier.

[0058] Optionally, the unique identifier may be represented as UUID, the update field may be represented as ISUPDATE, the boundary field may be represented as COVERD, and the pointer field may be represented as PTR, which is not specifically limited here.

[0059] Optionally, the request time corresponding to the subscription condition may also be understood as being based on a first-in-first-out principle.

[0060] like Figure 2 As shown, Figure 2 This is a structural diagram of the subscription condition list. Figure 2 In the , UUID represents a unique identifier, ISUPDATE indicates whether this subscription condition needs to be updated, SUBSCRIPTION represents the subscription condition description, COVERD is a set representing other subscription conditions that intersect with the boundary of this condition, and PTR represents a bidirectional pointer to the tree structure of this condition.

[0061] S4. Determine whether the initialized subscription condition list contains a unique representation. If so, delete the subscription condition, receive the next subscription condition, and execute S2. If not, determine whether the boundary field of the subscription condition intersects with the boundary field in the initialized subscription condition list. If so, execute S5. If not, add the subscription condition to the initialized subscription condition list, and update the initialized R+ tree to obtain the updated subscription list and the updated R+ tree, and execute S6.

[0062] In this embodiment, in S4, determining whether the boundary field of the subscription condition intersects with the boundary field in the initialized subscription condition list specifically includes:

[0063] When the boundary field of the subscription condition is a proper subset of the boundary field in the initialized subscription condition list, determining whether the boundary field of the subscription condition intersects the boundary of the boundary field in the initialized subscription condition list;

[0064] When the boundary field of the subscription condition is not a proper subset of the boundary field in the initialized subscription condition list, it is determined that the boundary field of the subscription condition does not intersect with the boundary of the boundary field in the initialized subscription condition list.

[0065] In this embodiment, in S4, updating the initialized R+ tree specifically includes:

[0066] According to the initialized subscription condition list with added subscription conditions, data is inserted according to the R+ tree insertion algorithm to update the initialized R+ tree.

[0067] S5. Modify the update field and boundary field of the subscription condition, and at the same time determine the target subscription condition corresponding to the boundary field in the initialized subscription condition list, modify the update field and boundary field of the target subscription condition, and add the updated subscription condition to the initialized subscription condition list, update the initialized R+ tree, and obtain the updated subscription list and the updated R+ tree.

[0068] In this embodiment, in S3, the update field of the subscription condition is False;

[0069] In S5, the update fields of the subscription conditions are modified, including:

[0070] Change the Update field of the subscription condition from False to True.

[0071] For example, when a subscription condition is received and no condition with the same UUID exists, it is necessary to determine whether the subscription condition intersects with any existing subscription condition. If no boundary intersection exists, the condition is directly added to the Condition-List and the R+ tree structure is directly updated, inserting a record. If a boundary intersection exists, the ISUPDATE and COVERD fields of the subscription condition entry where the intersection occurs are modified and added to the Condition-List. In this case, the intersecting area is not isolated and is directly inserted into the tree structure, forming an incomplete R+ tree.

[0072] For example, Figure 3 As shown, Figure 3 This is a diagram for updating the subscription condition list. Figure 3When the system listens to a subscription condition, it saves it to the Condition-Cache (i.e., cache). When the system is initialized, the Condition-List is empty, and the Cache forwards the subscription condition to the Condition-List in a first-in-first-out order. When the Condition-List is not empty, the condition hash value (i.e., unique identifier) ​​is calculated. If the same subscription does not exist in the subscription condition list, it is allowed to be added to the Condition-List. Otherwise, it is rejected and the Cache is requested to delete this subscription condition. Figure 3 Sub-01, Sub-02, Sub-03, Sub-04, and Sub-05 are all subscription conditions. Taking sub-01 as an example, since this subscription condition is detected and not repeated, it is added to the subscription condition list. The processing flow for the remaining subscription conditions is similar.

[0073] Moreover, after agreeing to accept new subscription conditions and adding them to the subscription condition list, data is directly inserted according to the R+ tree insertion algorithm. However, if it is determined that the condition boundaries intersect at this time, only an incomplete R+ tree is updated. This can effectively reduce the number of tree queries and ensure the robustness and high availability of subscription matching.

[0074] like Figure 4 As shown, Figure 4 This is a schematic diagram of updating the subscription condition list under boundary intersection conditions. Figure 4 In the R+Tree, adjustments are made only to the fields in the Condition-List subscription, and a conditional branch is inserted into the tree to identify the intersecting boundaries, without requiring complex, independent processing of the intersecting regions. This reduces the overhead of tree structure adjustments and operations, avoiding the excessive overhead of immediate re-division of regions required when handling a large number of intersecting boundaries in traditional R+Trees.

[0075] In this process, whenever a new subscription condition is accepted and added to the system, the system will first check whether the boundary between the new condition and the existing condition intersects.

[0076] If there is no intersection, the new condition will be directly inserted into the appropriate position according to the R+ tree insertion algorithm, and the tree structure will be updated to maintain the organization rationality and query efficiency of the subscription tree.

[0077] On the contrary, if a boundary intersection is detected, the system will not make excessive interventions on the tree structure, but will only mark and record the boundary intersection information in the Condition-List field and then update an incomplete R+ tree. Figure 5 As shown, Figure 5 Schematic diagram of the structure and spatial distribution of the updated R+ tree.

[0078] This embodiment avoids the performance overhead caused by frequent tree structure changes, while also ensuring system performance when facing complex subscription conditions. This embodiment implements an on-demand R+ tree update mode, which not only effectively reduces the number of tree queries but also ensures efficient matching in the publish-subscribe model, thereby improving the overall performance of the system.

[0079] S6. In response to the publishing request of the target event, receive the subscription relationship of the target event.

[0080] S7. Based on the subscription relationship, a search is performed in the updated subscription list and the updated R+ tree to determine the final target subscription condition, and a final event corresponding to the final target subscription condition is published.

[0081] In this embodiment, in S7, based on the subscription relationship, a search is performed in the updated subscription list and the updated R+ tree to determine the final target subscription condition, which specifically includes:

[0082] S71. Obtain subscription conditions of the subscription relationship;

[0083] S72. Search the updated R+ tree based on the subscription condition of the subscription relationship to determine the first subscription condition that satisfies the subscription relationship.

[0084] S73. Query the updated field of the first subscription condition from the updated subscription list. If the updated field is False, determine the first subscription condition as the final target subscription condition.

[0085] When the update field is True, the conditions are merged according to the boundary field of the first subscription condition to obtain the second subscription condition, and the updated R+ tree is updated again to obtain the final R+ tree;

[0086] S74. Set the update field of the subscription condition in the condition fusion process to False;

[0087] S75: Determine the second subscription condition as the final target subscription condition.

[0088] For example, when the system receives an event request, it searches the tree based on the subscription conditions. If the tree node needs to be updated, the tree is fully developed to achieve on-demand loading. When the subscription condition matches the specific subscription condition, it obtains its instance in the Condition-List and performs a reverse query on the Condition-List. If the ISUPDATE of the node is True, the condition is fused and the tree structure is updated according to COVERD. Figure 6, change the ISUPDATE field of all updated subscription conditions to False; if ISUPDATE is False, publish the event to the matching subscriptions.

[0089] In a specific embodiment, Figure 6 As shown, Figure 6 The following is a diagram of subscription conditions that are monitored. In the initial state of the system, the following conditions can be monitored: Figure 6 Subscription conditions shown.

[0090] In the initial state, the Condition-List is empty. After receiving Sub-01, Sub-01 is added to the subscription condition list and the structure of the R+ tree is updated. The updated R+ tree can be Figure 7 As shown, Figure 7 The diagram below shows an example of the structure and spatial distribution of the R+ tree. Figure 7 In the example, R1 can be used to represent the subscription area formed by Sub-01 (the following subscription conditions are represented as R1).

[0091] When the subscription condition Sub-02 is detected, it is determined that Sub-02 does not appear in the subscription condition list and no boundary intersection occurs, so Sub-02 is added to the subscription condition list and the R+ tree storage structure is updated. Because the condition represented by R2 is completely included in R1, R2 is stored in the R+ tree as a child node of R1. The updated R+ tree can be as follows Figure 8 As shown, Figure 8 Schematic diagram of the structure and spatial distribution example of the updated R+ tree.

[0092] If three new subscription conditions are received at this time, the three new subscription conditions can be Figure 9 As shown, Figure 9 This is a schematic diagram of the newly received subscription conditions.

[0093] At this time, according to the boundary intersection conflict between Sub-03 and Sub-01 in the three newly received subscription conditions, the R+ tree is partially updated and some of the values ​​involved in the subscription condition list are modified. The updated subscription condition list and R+ tree can be as follows: Figure 10 As shown, Figure 10 Schematic diagram of the updated subscription condition list and R+ tree instance.

[0094] After adding Sub-04 and Sub-05 to the subscription condition list, update the subscription condition list and R+ tree again. The updated subscription condition list and R+ tree can be as follows Figure 11 As shown, Figure 11 The figure shows the updated subscription condition list and R+ tree instance diagram.

[0095] When the target event is received as α={a=5,b=17}, the R+ tree storage structure can refer to Figure 10 The search in the R+ tree locates region R1, and the search continues up the subtree to region R2. Region R2 meets the event conditions, the ISUPDATE field is False, and there is no subtree index region. Therefore, the event that meets the conditions is published to the subscriber in region R2.

[0096] When receiving the target event β={a=12,b=20}. Search as Figure 10 The R+ tree shown in the figure first locates the R1 region and no subtree matches the corresponding condition. At this time, the ISUPDATE and COVERED fields of R1 corresponding to the Sub-01 subscription condition are not empty. At this time, the R+ tree begins to develop, and some subtrees develop into a complete R+ tree structure. The intersecting regions are processed independently to form the subscription condition Sub-06. The events published by R1 and R3 are integrated. At this time, the target event meets the R6 subscription condition, and the corresponding event is published to the subscription, and the matching is completed. The fused subscription condition list and R+ tree can be shown as follows Figure 12 As shown, Figure 12 The figure shows the fused subscription condition list and R+ tree instance.

[0097] Those skilled in the art will appreciate that the embodiments described herein are intended to help readers understand the principles of the present invention, and it should be understood that the scope of protection of the present invention is not limited to such specific descriptions and embodiments. Those skilled in the art can make various other specific variations and combinations based on the technical teachings disclosed in the present invention without departing from the essence of the present invention, and such variations and combinations are still within the scope of protection of the invention.

Claims

1. A R+ tree dynamic publish-subscribe method based on lazy update strategy, characterized in that: The method comprises: S1. Construct a subscription condition list and an R+ tree, and initialize the subscription condition list and the R+ tree; Wherein, the R+ tree is constructed according to the subscription condition list; S2. In response to the subscription condition joining request, receive the subscription condition according to the request time corresponding to the subscription condition; S3. Generate a unique identifier for the subscription condition based on the timestamp, clock sequence, and MAC address of the subscription condition, and determine an update field, a boundary field, and a pointer field for the subscription condition; S4. Determine whether the initialized subscription condition list contains the unique identifier. If so, delete the subscription condition, receive the next subscription condition, and execute S2. If not, determine whether the boundary field of the subscription condition intersects with the boundary field in the initialized subscription condition list. If so, execute S5. If not, add the subscription condition to the initialized subscription condition list, update the initialized R+ tree, obtain an updated subscription list and an updated R+ tree, and execute S6. S5. Modify the update field and boundary field of the subscription condition, determine the target subscription condition corresponding to the boundary field in the initialized subscription condition list, modify the update field and boundary field of the target subscription condition, add the updated subscription condition to the initialized subscription condition list, and update the initialized R+ tree to obtain an updated subscription list and an updated R+ tree. S6. In response to the publishing request of the target event, receiving a subscription relationship of the target event; S7. Search the updated subscription list and the updated R+ tree based on the subscription relationship to determine a final target subscription condition, and publish a final event corresponding to the final target subscription condition.

2. The method according to claim 1, characterized in that In S3, generating a unique identifier of the subscription condition based on the timestamp, clock sequence, and MAC address of the subscription condition specifically includes: The UUIDv4 standard is used to process the timestamp, clock sequence and MAC address of the subscription condition to generate the unique identifier.

3. The method according to claim 1, characterized in that In S4, determining whether the boundary field of the subscription condition intersects with the boundary field in the initialized subscription condition list specifically includes: When the boundary field of the subscription condition is a proper subset of the boundary field in the initialized subscription condition list, determining that the boundary field of the subscription condition intersects with a boundary of the boundary field in the initialized subscription condition list; When the boundary field of the subscription condition is not a proper subset of the boundary field in the initialized subscription condition list, it is determined that the boundary field of the subscription condition does not intersect with the boundary of the boundary field in the initialized subscription condition list.

4. The method according to claim 1, wherein In S4, updating the initialized R+ tree specifically includes: According to the initialized subscription condition list with the subscription condition added thereto, data is inserted according to the R+ tree insertion algorithm to update the initialized R+ tree.

5. The method according to claim 1, wherein In S3, the update field of the subscription condition is False; In S5, the updating field of the subscription condition is modified, specifically including: Change the update field of the subscription condition from False to True.

6. The method according to claim 5, characterized in that In S7, searching the updated subscription list and the updated R+ tree based on the subscription relationship to determine the final target subscription condition specifically includes: S71. Obtain subscription conditions of the subscription relationship; S72: Search the updated R+ tree based on the subscription condition of the subscription relationship to determine a first subscription condition that satisfies the subscription relationship. S73. Querying the updated field of the first subscription condition from the updated subscription list; when the updated field is False, determining the first subscription condition as the final target subscription condition; When the update field is True, condition fusion is performed according to the boundary field of the first subscription condition to obtain a second subscription condition, and the updated R+ tree is updated again to obtain a final R+ tree; S74. Set the update field of the subscription condition in the condition fusion process to False; S75: Determine the second subscription condition as the final target subscription condition.

Images