R + tree dynamic publishing and subscribing method based on lazy updating strategy

Abstract

The invention discloses an R + tree dynamic publishing and subscribing method based on a lazy updating strategy. The method comprises the following steps: constructing a subscribing condition list and an R + tree; receiving a subscription condition; generating a unique identifier of the subscription condition, and determining an update field, a boundary field and a pointer field of the subscription condition; judging whether the initialized subscription condition list contains unique representation or not, if yes, deleting the subscription condition, and receiving the next subscription condition; if not, determining an updated subscription list and an updated R + tree, responding to the publishing request of the target event, and receiving a subscription relationship of the target event; and searching in the updated subscription list and the updated R + tree based on the subscription relationship, determining a final target subscription condition, and publishing a final event corresponding to the final target subscription condition. According to the invention, the efficiency of traffic event matching and node subscription management can be improved.

Description

Technical Field

[0001] The 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] In the simulation interaction process of the intelligent transportation system, thousands of vehicles, traffic lights, sensors and edge computing nodes interact in real time through a virtual environment, forming a complex multi-dimensional dynamic data flow network. With the dynamic changes in traffic flow, vehicle path planning and traffic management strategies, the interaction (i.e. subscription) relationship between nodes will be continuously adjusted and updated over time. For example, vehicle driving paths, traffic congestion conditions, traffic light scheduling strategies, etc. can all have an immediate impact on the relationship 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 mainly cover multiple dimensions such as space efficiency, time efficiency, and subscription maintenance efficiency. Among them, time efficiency is particularly critical because the overall performance of the system depends to a large extent on the response speed of the algorithm when processing a large number of dynamic subscriptions and events.

[0004] However, the matching methods based on linear structures or simple tree structures in the existing technology have many limitations in matching efficiency, such as slow matching speed, high global update cost, excessive system resource consumption, etc., 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 an important challenge in research. To address these bottleneck problems, researchers need to design matching algorithms that can still 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 dynamic maintenance and updates of large-scale subscription conditions.

[0005] Among the existing matching algorithms, the Hanson algorithm and its extended version improve matching efficiency by indexing and counting the predicates of different subscriptions and combining a filtering mechanism for matching results. The algorithm uses an efficient testing method to preliminarily screen some subscriptions in the early stages and then perform more sophisticated matching operations on the remaining subscriptions to optimize the overall performance. Although the algorithm uses predicate indexing technology to improve matching results, it fails to fully consider the interrelationships between different predicates. In addition, the Hanson algorithm relies on subscription coverage relationships and uses structures such as KD trees for matching extraction. Although it improves matching efficiency to a certain extent, it performs insufficiently when dynamically updating subscriptions.

[0006] In contrast, the Testing network based algorithm further improves the matching efficiency by utilizing the correlation between subscriptions and predicates. The algorithm can effectively improve the performance of the system by optimizing the subscription structure and organizing subscription relationships using partially ordered sets. However, due to the need to frequently judge the coverage relationship and repeatedly test the same predicate, 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 and affects 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 publishing and subscription 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 invention object, the technical solution adopted by the present invention is: an R+ tree dynamic publish-subscribe method based on 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 joining request of the subscription condition, receiving the subscription condition according to the request time corresponding to the subscription condition;

[0012] S3. Generate a unique identifier of the subscription condition according to 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, and update the initialized R+ tree to 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, update the initialized R+ tree, and obtain an updated subscription list and an updated R+ tree;

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

[0016] S7. Search in the updated subscription list and the updated R+ tree based on the subscription relationship, determine the final target subscription condition, and publish the final event corresponding to the final target subscription condition.

[0017] The beneficial effect of the above scheme is: the present invention can efficiently manage dynamically changing traffic data flows by designing a redundant R+ tree index structure, combined with incremental updates and lazy loading mechanisms, thereby solving the system performance bottleneck problem caused by frequent global updates. At the same time, the spatial partitioning characteristics of the R+ tree are utilized 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 according to 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 condition are processed to generate a unique identifier.

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

[0021] Further, in S4, determining whether the boundary field of the subscription condition intersects with the boundary field in the initialized subscription condition list includes:

[0022] When the boundary field of the subscription condition is a proper subset of the boundary field in the subscription condition list after the initialization, determining that the boundary field of the subscription condition intersects with the boundary of the boundary field in the subscription condition list after the initialization;

[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 to which the subscription condition is added, data is inserted according to the R+ tree insertion algorithm to update the initialized R+ tree.

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

[0027] In S5, the update field of the subscription condition is 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, searching in 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, querying the update field of the first subscription condition from the updated subscription list, and when the update field is False, determining the first subscription condition as the final target subscription condition;

[0034] When the update field is True, the condition is 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, setting 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 immediately redividing 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 R+ tree dynamic publish-subscribe method based on a lazy update strategy.

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

[0040] Figure 3 A schematic diagram of updating 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 schematic diagram of the subscription conditions monitored.

[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] Fig. 9 This is a schematic diagram of the newly received subscription conditions.

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

[0048] Fig.11 The figure is a schematic diagram of the updated subscription condition list and R+ tree instance.

[0049] Fig.12 The figure is a schematic diagram of the merged subscription condition list and R+ tree instance. DETAILED DESCRIPTION

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

[0051] like Figure 1 As shown, a R+ tree dynamic publishing and subscription method based on 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] Exemplarily, the constructed subscription condition list (which can be expressed as Condition-List) and R+ tree can be respectively that the subscription condition list is empty and the R+ tree only includes the root node. Alternatively, the subscription condition list is not empty and the R+ tree includes other nodes except the root node. No specific limitation is made to the constructed subscription condition list and R+ tree.

[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 of the subscription condition according to 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 according to 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 condition 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, and no specific limitation is made 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 diagram of the structure of the subscription condition list. Figure 2 In the table, UUID indicates a unique identifier, ISUPDATE indicates whether the subscription condition needs to be updated, SUBSCRIPTION indicates a description of the subscription condition, COVERD is a set indicating other subscription conditions that intersect with the boundary of this condition, and PTR indicates 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, update the initialized R+ tree, 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 subscription condition list after the initialization, determining that the boundary field of the subscription condition intersects with the boundary of the boundary field in the subscription condition list after the initialization;

[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 to which the subscription condition is added, 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 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 field of the subscription condition is modified, including:

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

[0071] For example, when a subscription condition is received, if there is no condition with the same UUID, it is necessary to determine whether the subscription condition has a boundary intersection with the existing subscription condition. If there is no boundary intersection, directly add it to the Condition-List and directly update the R+ tree structure to insert a record; if there is a boundary intersection, modify the ISUPDATE, COVERD fields of the subscription condition entry where the intersection occurs, and add it to the Condition-List. At this time, the intersection area is not independent, and it is directly inserted into the tree structure to form 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 will save 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, the subscription condition is detected and is not repeated, so it is added to the subscription condition list. The processing flow of other subscription conditions is similar.

[0073] Moreover, when 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 boundary intersection occurs 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 Schematic diagram of updating the subscription condition list under boundary intersection conditions. Figure 4 In the above, only the fields of the subscription condition list Condition-List are adjusted, and a conditional branch with intersecting boundaries is inserted into the tree without complex independent processing of the intersecting regions. This reduces the overhead of tree structure adjustment and operation, and avoids the excessive overhead of the traditional R+ tree that needs to immediately re-divide the region when processing a large number of intersecting boundaries.

[0075] During this process, whenever a new subscription condition is accepted and added to the system, the system first checks 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 intervene in the tree structure excessively, but 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 can avoid the performance overhead caused by frequent tree structure changes, and also ensure the performance of the system when facing complex subscription conditions. This embodiment implements an on-demand loading R+ tree update mode, which can not only effectively reduce the number of tree queries, but also ensure efficient matching in the publish-subscribe mode, 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. Search in the updated subscription list and the updated R+ tree based on the subscription relationship, determine the final target subscription condition, and publish the final event corresponding to the final target subscription condition.

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

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

[0083] S72, searching in 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, querying the update field of the first subscription condition from the updated subscription list, and when the update field is False, determining the first subscription condition as the final target subscription condition;

[0085] When the update field is True, the condition is 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, setting 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 according to 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, its instance in the Condition-List is obtained and a reverse query is performed 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 the 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, 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 following is a schematic diagram 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 monitored, 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 and updated 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 Fig. 9 As shown, Fig. 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 incompletely updated, and some values ​​involved in the subscription condition list are modified. The updated subscription condition list and R+ tree can be as follows: Fig.10 As shown, Fig.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: Fig.11 As shown, Fig.11 The figure is a schematic diagram of the updated subscription condition list and R+ tree instance.

[0095] When the target event received is α={a=5,b=17}, the R+ tree storage structure can refer to Fig.10 By searching the R+ tree, we locate the R1 region, and continue searching the subtree to locate the R2 region. The R2 region meets the event conditions, the ISUPDATE field is False, and there is no subtree index region, so the qualified events are published to the subscribers in the R2 region.

[0096] When receiving the target event β={a=12,b=20}. Search as Fig.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 intersection area is processed independently to form the subscription condition Sub-06, and 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 ends. The fused subscription condition list and R+ tree can be shown as follows Fig.12 As shown, Fig.12 The figure is a schematic diagram of the merged 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 should be understood that the protection scope of the present invention is not limited to such specific statements and embodiments. Those skilled in the art can make various other specific variations and combinations that do not deviate from the essence of the present invention based on the technical revelations disclosed by the present invention, and these variations and combinations are still within the protection scope 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 joining request of the subscription condition, receiving the subscription condition according to the request time corresponding to the subscription condition; S3. Generate a unique identifier of the subscription condition according to the timestamp, clock sequence and MAC address of the subscription condition, and determine an update field, a boundary field and a pointer field of the subscription condition; S4, determine whether the initialized subscription condition list contains the 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; 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, update the initialized R+ tree, and 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 the final target subscription condition, and publish the 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 according to 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 the 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, characterized in that: In S4, updating the initialized R+ tree specifically includes: According to the initialized subscription condition list added with the subscription condition, data is inserted according to the R+ tree insertion algorithm to update the initialized R+ tree.

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

6. The method according to claim 5, characterized in that In S7, searching in the updated subscription list and the updated R+ tree based on the subscription relationship to determine the final target subscription condition specifically includes: S71, obtaining the subscription condition of the subscription relationship; S72, searching in 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 update field of the first subscription condition from the updated subscription list, and when the update 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, setting 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