A form linkage updating method and device, electronic equipment and storage medium

Abstract

The application relates to the computer technical field and provides a form linkage updating method and device, electronic equipment and a storage medium. The method comprises the following steps: a dependency network for representing linkage influence relations between fields is constructed; in response to updating of a target field in a form, an updating transaction is started, and a set of influence domains corresponding to the target field is determined based on the dependency network; a linkage processing sequence between a plurality of field nodes contained in the set of influence domains is determined, wherein the linkage processing sequence conforms to a dependency relation defined by the dependency network; an updated value of the target field is written in a temporary form state corresponding to the updating transaction, and the field nodes in the set of influence domains are subjected to linkage calculation in the linkage processing sequence; and an updating result obtained through the linkage calculation is written in the temporary form state; and after the linkage calculation is completed, an updated form state corresponding to the temporary form state is submitted at one time.

Description

Technical Field

[0001] This application relates to the field of computer technology, and in particular to a method, apparatus, electronic device and storage medium for form linkage updating. Background Technology

[0002] With the continuous development of enterprise applications and low-code platforms, large business forms are being used more and more widely in various front-end systems. In complex large business forms, there are usually highly dense linkages between fields. For example, a change in the input value of a certain field will dynamically trigger the visibility switching, mandatory field validation, default value derivation, or cascading updates of drop-down option sets of multiple other fields.

[0003] Existing form cascading methods typically employ field listening or event callback mechanisms. When a field is updated, the callback logic associated with that field is immediately triggered, and the calculated cascading result is directly written to the current form state; if the updated field further affects other fields, the callback logic for subsequent fields is triggered.

[0004] However, in forms with multi-level linkage, a single field update may trigger sequential calculations for multiple fields. Since current methods typically write the current form state after each linkage calculation is completed, a single field update may result in multiple update submissions, causing the page to switch between multiple intermediate states. This can easily lead to inconsistencies in the linkage states or page display stuttering. Summary of the Invention

[0005] In view of this, embodiments of this application provide a form linkage update method, apparatus, electronic device, and storage medium to solve the problem in the prior art where, when a single field update triggers multi-level form linkage, the linkage results are immediately written to the current form state, resulting in multiple form updates, inconsistent form linkage states, and page display jitter.

[0006] A first aspect of this application provides a form linkage update method, the method comprising: constructing a dependency network for characterizing the linkage influence relationship between fields, the dependency network including multiple field nodes and directed dependency relationships between field nodes; in response to the update of a target field in the form, initiating an update transaction, and determining an influence domain set corresponding to the target field based on the dependency network, the influence domain set including at least one field node affected by the update of the target field; determining the linkage processing order among the multiple field nodes included in the influence domain set, wherein the linkage processing order conforms to the dependency relationship defined by the dependency network; writing the update value of the target field into a temporary form state corresponding to the update transaction, and performing linkage calculations on the field nodes in the influence domain set according to the linkage processing order, and writing the update result obtained from the linkage calculation into the temporary form state; and submitting the updated form state corresponding to the temporary form state all at once after the linkage calculation is completed.

[0007] A second aspect of this application provides a form linkage update apparatus, comprising: a construction module for constructing a dependency network characterizing the linkage influence relationship between fields, the dependency network including multiple field nodes and directed dependencies between field nodes; a determination module for initiating an update transaction in response to an update of a target field in the form, and determining an influence domain set corresponding to the target field based on the dependency network, the influence domain set including at least one field node affected by the update of the target field; the determination module is further configured to determine the linkage processing order among the multiple field nodes included in the influence domain set, wherein the linkage processing order conforms to the dependency relationship defined by the dependency network; a calculation module for writing the update value of the target field into a temporary form state corresponding to the update transaction, and performing linkage calculations on the field nodes in the influence domain set according to the linkage processing order, and writing the update result obtained from the linkage calculation into the temporary form state; and an update module for submitting the updated form state corresponding to the temporary form state all at once after the linkage calculation is completed.

[0008] A third aspect of this application provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the steps of the above-described method.

[0009] A fourth aspect of this application provides a readable storage medium storing a computer program that, when executed by a processor, implements the steps of the above-described method.

[0010] The beneficial effects of this application embodiment compared with the prior art are as follows: The form linkage update method provided in this application embodiment constructs a dependency network to characterize the linkage influence relationship between fields. The dependency network includes multiple field nodes and directed dependency relationships between field nodes. In response to the update of the target field in the form, an update transaction is initiated, and the set of influence domains corresponding to the target field is determined based on the dependency network. The set of influence domains includes at least one field node affected by the update of the target field. The linkage processing order among the multiple field nodes included in the set of influence domains is determined, wherein the linkage processing order conforms to the dependency relationship defined by the dependency network. The updated value of the target field is written into the temporary form state corresponding to the update transaction, and linkage calculations are performed on the field nodes in the set of influence domains according to the linkage processing order. The update result obtained from the linkage calculation is written into the temporary form state. After the linkage calculation is completed, the updated form state corresponding to the temporary form state is submitted all at once. This application embodiment can determine the range of affected fields and their linkage processing order based on the dependency network when a field update triggers multi-level form linkage, and write the updated value of the target field and the linkage calculation results of each affected field into the same temporary form state first, and then submit the updated form state in a unified manner. Compared to the method where each linkage result is written to the current form state immediately, the embodiments of this application can reduce the number of form update submissions during a single field update process. This avoids the problem in the prior art where, when a single field update triggers multi-level form linkage, each linkage result is written to the current form state immediately, resulting in multiple form updates, inconsistent form linkage states, and page display jitter. Attached Figure Description

[0011] To more clearly illustrate the technical solutions in the embodiments of this application, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0012] Figure 1 This is a schematic diagram illustrating an application scenario of this application embodiment; Figure 2 This is a basic schematic diagram of a form linkage update method provided in an embodiment of this application; Figure 3 This is a basic schematic diagram of a form linkage update device provided in an embodiment of this application; Figure 4 This is a schematic diagram of the electronic device provided in the embodiments of this application. Detailed Implementation

[0013] In the following description, specific details such as particular application structures and techniques are set forth for illustrative purposes and not for limitation, in order to provide a thorough understanding of the embodiments of this application. However, those skilled in the art will understand that this application may also be implemented in other embodiments without these specific details. In other instances, detailed descriptions of well-known applications, devices, circuits, and apparatuses are omitted so as not to obscure the description of this application with unnecessary detail.

[0014] The following will describe in detail, with reference to the accompanying drawings, a form linkage update method and apparatus according to embodiments of this application.

[0015] Figure 1 This is a schematic diagram illustrating an application scenario according to an embodiment of this application. The application scenario may include terminal devices 1, 2, and 3, server 4, and network 5.

[0016] Terminal devices 1, 2, and 3 can be hardware or software. When terminal devices 1, 2, and 3 are hardware, they can be various electronic devices with displays that support communication with server 4, including but not limited to smartphones, tablets, laptops, and desktop computers. When terminal devices 1, 2, and 3 are software, they can be installed on the aforementioned electronic devices. Terminal devices 1, 2, and 3 can be implemented as multiple software programs or software modules, or as a single software program or software module; this embodiment does not impose any limitations on this. Furthermore, various applications can be installed on terminal devices 1, 2, and 3, such as data processing applications, instant messaging tools, social platform software, search applications, shopping applications, etc.

[0017] Server 4 can be a server providing various services, such as constructing a dependency network to characterize the linkage and influence relationships between fields, the dependency network including multiple field nodes and directed dependencies between field nodes; responding to the update of the target field in the form, initiating an update transaction, and determining the set of influence domains corresponding to the target field based on the dependency network, the set of influence domains including at least one field node affected by the update of the target field; determining the linkage processing order among multiple field nodes included in the set of influence domains, wherein the linkage processing order conforms to the dependency relationship defined by the dependency network; writing the updated value of the target field into the temporary form state corresponding to the update transaction, and performing linkage calculations on the field nodes in the set of influence domains according to the linkage processing order, and writing the update result obtained from the linkage calculation into the temporary form state; after the linkage calculation is completed, submitting the updated form state corresponding to the temporary form state all at once. Server 4 can be a single server, a server cluster consisting of several servers, or a cloud computing service center; this embodiment of the application does not limit this.

[0018] It should be noted that server 4 can be either hardware or software. When server 4 is hardware, it can be various electronic devices that provide various services to terminal devices 1, 2, and 3. When server 4 is software, it can be multiple software programs or software modules that provide various services to terminal devices 1, 2, and 3, or it can be a single software program or software module that provides various services to terminal devices 1, 2, and 3. This application embodiment does not impose any limitations on this.

[0019] Network 5 can be a wired network using coaxial cable, twisted pair, and fiber optic connection, or it can be a wireless network that enables interconnection of various communication devices without wiring, such as Bluetooth, Near Field Communication (NFC), and Infrared. This application embodiment does not limit this.

[0020] Users can establish a communication connection with server 4 via network 5 through terminal devices 1, 2 and 3 to receive or send information, etc.

[0021] It should be noted that the specific types, quantities, and combinations of terminal devices 1, 2, and 3, server 4, and network 5 can be adjusted according to the actual needs of the application scenario, and this application embodiment does not impose any restrictions on this.

[0022] Figure 2 This is a flowchart illustrating a form linkage update method provided in an embodiment of this application, as shown below. Figure 2 As shown, the method for updating the form in a linked manner includes: S201. Construct a dependency network to represent the linkage and influence relationship between fields. The dependency network includes multiple field nodes and the directed dependency relationships between field nodes. Specifically, the form linkage update method provided in this application can be executed by a terminal device or a server, or by both a terminal and a server. In this embodiment, the method is described using the server as an example.

[0023] Specifically, the server can pre-obtain the form's field configuration information and field linkage rules. Field configuration information may include field identifiers, field types, initial field values, field attributes, and the order in which fields are declared in the form. Field linkage rules can be used to describe the relationships between fields; for example, a change in the value of one field may affect the visibility, required status, disabled status, candidate options, default value, or validation result of another field.

[0024] Field configuration information and field linkage rules can be obtained based on form templates, form schemas, configuration data generated by low-code configuration platforms, or pre-stored form configuration data on the server; they can also be obtained through configuration interfaces, database queries, configuration file reading, or runtime registration. Therefore, this application embodiment does not limit the specific source of field configuration information and field linkage rules, as long as the linkage and influence relationship between fields can be determined based on the field configuration information and field linkage rules.

[0025] In step S201, the server can abstract each field in the form into a field node and determine the directed dependency relationship between the field nodes according to the field linkage rules. Specifically, if an update of one field will cause a linked change in another field, the server establishes a directed dependency relationship between the field node corresponding to that field and the field node corresponding to the other field, pointing from that field to the other field. From multiple field nodes and the directed dependencies between them, a dependency network representing the linkage effect between fields can be constructed.

[0026] For example, a form includes fields A, B, C, and D. If updating field A affects fields B and C, and updating fields B and C affects field D, then the server can establish directed dependencies A→B, A→C, B→D, and C→D, thus forming a dependency network.

[0027] S202. In response to the update of the target field in the form, initiate an update transaction and determine the set of influence domains corresponding to the target field based on the dependency network. The set of influence domains includes at least one field node affected by the update of the target field. In step S202, when the terminal device detects that the user has performed an update operation such as inputting, modifying, selecting, or clearing any field, it can send the field identifier and the updated value of that field to the server, so that the server can use that field as the target field. Alternatively, when the server background triggers automatic backfilling or data synchronization for any field, the server can use the updated field as the target field.

[0028] In response to an update to the target field, the server initiates an update transaction. This update transaction is used to confine the associated calculations triggered by the update of the target field within the same processing boundary, so that the associated calculations of the affected fields can be completed within that processing boundary.

[0029] The server traverses level by level along the direction indicated by the directed dependency relationship in the dependency network according to the target field node corresponding to the target field in the dependency network (the field node corresponding to the target field is the target field node), determines the field nodes reachable (directly or indirectly reachable) from the target field node, and determines the reachable field nodes as the influence domain set corresponding to the target field. The field nodes in the influence domain set are the field nodes that may be affected by the update of the current target field. Thus, the server does not need to perform linkage calculations for all fields in the form, but only processes the downstream influence scope of the target field.

[0030] For example, the form includes field A, field B, field C, and field D, and field A, field B, field C, and field D respectively correspond to field node A, field node B, field node C, and field node D in the dependency network. If it is known based on the dependency network that field node A points to field node B, field node B points to field node D, and there is no directed dependency relationship from field node A, field node B, or field node D to field node C, then when field A is used as the target field and is updated, the server can determine that the influence domain set corresponding to field A includes field node B and field node D.

[0031] Another example, if it is known based on the dependency network that field node A points to field node B and field node C, and both field node B and field node C point to field node D, then when field A is used as the target field and is updated, the server can determine that the influence domain set corresponding to field A includes field node B, field node C, and field node D. Other field nodes that do not have a downstream dependency relationship with field node A do not enter the scope of the linkage calculation for this update transaction.

[0032] S203. Determine the linkage processing order among the multiple field nodes included in the influence domain set, where the linkage processing order conforms to the dependency relationship defined by the dependency network; In step S203, the server determines the linkage processing order among the multiple field nodes included in the influence domain set. The linkage processing order conforms to the dependency relationship defined by the dependency network. That is to say, when there is a directed dependency relationship from field node A to field node B in the dependency network, if both field node A and field node B belong to the influence domain set, the linkage calculation corresponding to field node A is executed prior to the linkage calculation corresponding to field node B.

[0033] For example, a form includes fields A, B, C, and D, and these fields correspond to field nodes A, B, C, and D respectively in the dependency network. If there are directed dependencies in the dependency network such that field node A points to field node B, field node A points to field node C, field node B points to field node D, and field node C points to field node D, then when field A is updated, the affected domain set includes field nodes B, C, and D. Since the linkage calculation of field node D depends on the linkage results of field nodes B and C, the linkage calculation of field nodes B and C should be executed before the linkage calculation of field node D. The server can determine the linkage processing order as field node B, field node C, and field node D, or field node C, field node B, and field node D, as long as field node D is located after field nodes B and C.

[0034] In some embodiments, to avoid the complex traversal and sorting of the entire dependency network every time the target field is updated, the server can pre-generate a global scheduling sequence based on the dependency network. After the target field is updated, the server selects field nodes belonging to the set of affected domains from the global scheduling sequence to obtain the linkage processing order corresponding to this update transaction. This method avoids re-sorting the entire dependency network every time a field is updated, improving the efficiency of linkage processing. The generation and selection process of the global scheduling sequence will be described in detail later, and will not be repeated here.

[0035] S204. Write the update value of the target field into the temporary form state corresponding to the update transaction, and perform linkage calculation on the field nodes in the affected domain set according to the linkage processing order, and write the update result obtained from the linkage calculation into the temporary form state. In step S204, the server creates or retrieves a temporary form state corresponding to this update transaction. This temporary form state can be a copy, draft state, or cached state generated based on the current form state. The server first writes the updated value of the target field to this temporary form state, instead of directly submitting it to the current form state, to avoid triggering a form state update before the downstream linkage calculation is completed.

[0036] Subsequently, the server performs linkage calculations sequentially on the field nodes in the affected domain set according to the determined linkage processing order. The linkage calculation for each field node can be based on the field value and field attribute in the temporary form state. For example, linkage calculations may include: determining the field attribute of the current field (such as whether it is visible, required, or disabled) based on the value of the upstream field; updating the candidate options of the current field based on the value of the upstream field; deriving the field value of the current field (such as the default value) based on the value of the upstream field; or triggering the validation logic of the current field and generating a validation result.

[0037] After receiving the results of the linked calculations for each field node, the server writes these results to a temporary form state. Since all linked calculation results are written to the same temporary form state, the form state submission will not be triggered immediately upon completion of the linked calculations for each field node during this update transaction, thus avoiding the exposure of multiple intermediate states to the page.

[0038] For example, a form includes fields A, B, C, and D, and these fields correspond to field nodes A, B, C, and D respectively in the dependency network. If there are directed dependencies in the dependency network such that field node A points to field node B, field node A points to field node C, field node B points to field node D, and field node C points to field node D, then when field A is updated, the server can first write the updated value of field A to the temporary form state.

[0039] If the linkage processing order is determined to be field node B, field node C, and field node D, the server can first perform linkage calculation on field B corresponding to field node B based on the updated value of field A in the temporary form state, and write the linkage calculation result of field B to the temporary form state; then, based on the updated value of field A in the temporary form state, perform linkage calculation on field C corresponding to field node C, and write the linkage calculation result of field C to the temporary form state.

[0040] Subsequently, based on the combined calculation results of fields B and C in the temporary form state, the server performs a combined calculation on field D corresponding to field node D, and writes the combined calculation result of field D into the temporary form state. Therefore, the combined calculation of field D can read the latest combined result generated by fields B and C in this update transaction, rather than reading the old result in the current form state.

[0041] In the above process, the results of the linked calculations of fields B, C, and D are all written to the same temporary form state. The server will not submit the form state immediately after the linked calculation of field B or field C is completed. Instead, it will submit the updated form state corresponding to the temporary form state in step S205 after all the field nodes in the affected domain set have completed the linked calculations.

[0042] It is understandable that when performing linkage calculations on field nodes in the affected domain set according to the linkage processing order, if the number of field nodes in the affected domain set exceeds a preset threshold, the server can divide the linkage calculation into multiple execution stages based on the linkage type or priority of the field nodes. For example, the server can prioritize executing linkage calculations that affect the basic state of the interface, such as field values, visibility, required fields, and candidate options, and then execute linkage calculations for validation results; or, some lower-priority linkage calculations can be delayed until the system is idle. This can reduce the impact of executing a large number of linkage calculations at once on the interactive response in large form scenarios.

[0043] S205. After the linkage calculation of the field nodes in the affected domain set is completed, submit the updated form status corresponding to the temporary form status all at once.

[0044] In step S205, after all the field nodes in the affected domain set have completed the linkage calculation, the server submits the updated form state corresponding to the temporary form state all at once.

[0045] The one-time submission may include writing the updated form state to at least one of the form state management module, cache, database, or session state; it may also include sending the updated form state to the terminal device so that the terminal device renders the page based on the updated form state. This application does not limit the specific submission object of the one-time submission, as long as the updated form state formed in this update transaction can be used as a unified result.

[0046] In some embodiments, after the updated form status is submitted all at once, the server can trigger a status delivery or view update for the front-end interface based on the updated form status. Upon receiving the updated form status, the terminal device can update the form page based on this updated form status. Since the results of multiple linked calculations in this update transaction have already been summarized in the temporary form status, the terminal device does not need to perform page updates separately for the linked calculation results of each field node.

[0047] Therefore, in cases where a single target field update triggers multi-level field linkage, this embodiment does not immediately submit the form state after the linkage calculation of each field node is completed. Instead, it first completes the writing of the updated value of the target field and the linkage calculation of the field nodes in the affected domain set within the same temporary form state, and then submits the updated form state uniformly after the linkage calculation is completed. This allows multiple discrete linkage writes to be converged into a single batch submission, reducing the number of form state submissions during a single field update process, avoiding the exposure of multiple intermediate states to the page, reducing the possibility of the page switching between multiple intermediate states, and thus improving the consistency and interactive performance of form linkage updates.

[0048] According to the solution provided in this application, the method constructs a dependency network to characterize the linkage and influence relationships between fields. The dependency network includes multiple field nodes and directed dependencies between field nodes. In response to the update of a target field in the form, an update transaction is initiated, and an influence domain set corresponding to the target field is determined based on the dependency network. The influence domain set includes at least one field node affected by the update of the target field. The linkage processing order among the multiple field nodes included in the influence domain set is determined, wherein the linkage processing order conforms to the dependency relationship defined by the dependency network. The updated value of the target field is written into the temporary form state corresponding to the update transaction, and linkage calculations are performed on the field nodes in the influence domain set according to the linkage processing order. The update result obtained from the linkage calculation is written into the temporary form state. After the linkage calculation is completed, the updated form state corresponding to the temporary form state is submitted all at once. This application embodiment can determine the range of affected fields and their linkage processing order based on the dependency network when a field update triggers multi-level form linkage, and first write the updated value of the target field and the linkage calculation results of each affected field into the same temporary form state, and then submit the updated form state in a unified manner. Compared to the method where each linkage result is written to the current form state immediately, the embodiments of this application can reduce the number of form update submissions during a single field update process. This avoids the problem in the prior art where, when a single field update triggers multi-level form linkage, each linkage result is written to the current form state immediately, resulting in multiple form updates, inconsistent form linkage states, and page display jitter.

[0049] In some examples, a dependency network is constructed to characterize the interrelationships between fields. This includes: mapping multiple fields in the form to field nodes and constructing an initial dependency network based on the field nodes; obtaining the linkage rules corresponding to multiple fields in the form; using each field in the form as a source field and determining the affected field corresponding to each source field based on the linkage rules, wherein the affected field is a field whose value, attribute, candidate option, or validation result changes in response to an update of the source field; and for each source field and each corresponding affected field, establishing a directed dependency relationship in the initial dependency network from the field node corresponding to the source field to the field node corresponding to the affected field, thus obtaining the dependency network.

[0050] In some embodiments, the server can construct a dependency network based on field configuration information and field linkage rules in the form. Field configuration information can be used to determine the multiple fields contained in the form and the field identifiers of each field, while field linkage rules can be used to describe the linkage and influence relationships between fields. For example, an update to one field may affect the field value, visibility, required field status, disabled status, candidate options, or validation results of another field.

[0051] Specifically, the server can determine multiple fields in the form based on the field configuration information, map each field to a field node, and build an initial dependency network based on the field nodes. At this point, the initial dependency network may include multiple field nodes, but directed dependencies have not yet been established between the field nodes, or only some default dependencies have been established.

[0052] Subsequently, the server retrieves the linkage rules corresponding to multiple fields in the form and iterates through the fields. During this iteration, the server can use the currently iterated field as the source field and determine whether an update to the source field will affect other fields based on the linkage rules. If the linkage rules indicate that an update to the source field will affect one or more other fields, the server identifies those one or more other fields as the affected fields corresponding to the source field.

[0053] The affected field can be a field whose value, field attribute, candidate option, or validation result changes in response to an update of the source field. Field attributes can include at least one of the following: visibility, required, disabled, or read-only.

[0054] After identifying the source fields and their corresponding affected fields, the server can establish directed dependencies in the initial dependency network, pointing from the field nodes corresponding to the source fields to the field nodes corresponding to the affected fields. If the same source field corresponds to multiple affected fields, the server can establish directed dependencies from the field nodes corresponding to the source field to the field nodes corresponding to each affected field. If multiple source fields affect the same affected field, the server can establish directed dependencies from the field nodes corresponding to the multiple source fields to the field nodes corresponding to the affected field.

[0055] For example, a form includes fields A, B, C, and D. The server can map fields A, B, C, and D to field nodes A, B, C, and D, respectively. If a linkage rule indicates that an update to field A affects the visibility of field B and the candidate options for field C, and that an update to field B affects the validation result of field D, then the server can establish directed dependencies in the initial dependency network, with field node A pointing to field node B, field node A pointing to field node C, and field node B pointing to field node D. This results in a dependency network used to characterize the linkage and influence relationships between fields.

[0056] By using the above method, the scattered field linkage rules can be transformed into a unified dependency network, allowing the influence relationships between fields to be centrally expressed in the form of field nodes and directed dependencies. Thus, when a target field is updated, the server can determine the scope of fields affected by the target field and the order of linkage processing based on the dependency network, providing a basis for subsequent transactional linkage calculations.

[0057] The dependency network includes at least one of outgoing edge index and incoming edge index; the outgoing edge index is used to determine the downstream field node that the field node points to along the directed dependency relationship; the incoming edge index is used to determine the upstream field node that points to the field node.

[0058] Specifically, during the construction of the dependent network, if the server determines that the field node corresponding to the source field points to the field node corresponding to the affected field, it can record the downstream pointing relationship between the field node corresponding to the source field and the field node corresponding to the affected field in the outgoing edge index; and it can record the upstream source relationship between the field node corresponding to the affected field and the field node corresponding to the source field in the incoming edge index.

[0059] For example, if there are directed dependencies in the network such that node A points to node B, node A points to node C, node B points to node D, and node C points to node D, then the server can record in the outgoing edge index that the downstream nodes corresponding to node A include node B and node C, the downstream nodes corresponding to node B include node D, and the downstream nodes corresponding to node C include node D. The server can also record in the incoming edge index that the upstream nodes corresponding to node B include node A, the upstream nodes corresponding to node C include node A, and the upstream nodes corresponding to node D include node B and node C.

[0060] After a target field is updated, the server can determine the downstream field nodes of the target field node based on the outgoing edge index, and continue traversing the downstream field nodes along the outgoing edge index to determine the set of influence domains corresponding to the target field. For example, when the field corresponding to field node A is updated, the server can determine that field node A points to field nodes B and C based on the outgoing edge index, and further determine field node D based on the outgoing edge indices of field nodes B and C. Thus, the set of influence domains corresponding to field node A includes field nodes B, C, and D.

[0061] When generating a global scheduling sequence, the server can determine the in-degree of each field node based on its incoming edge index. For example, if the incoming edge index of field node D includes field nodes B and C, the server can determine that the in-degree of field node D is 2. Alternatively, after adding a field node to the global scheduling sequence, the server can determine the downstream field node pointed to by that field node based on its outgoing edge index and update the in-degree of the downstream field node accordingly.

[0062] By employing the methods described above, outward edge indexes can improve the server's efficiency in determining the downstream influence range of a target field, while inward edge indexes can improve the server's efficiency in calculating the in-degree of field nodes and generating a global scheduling sequence. Therefore, even in complex forms containing a large number of field nodes and inter-relationships, this reduces the overhead of dependency querying and improves the efficiency of form-related update processing.

[0063] In some examples, after constructing a dependency network to characterize the linkage and influence relationships between fields, the method further includes: performing loop detection on the dependency network; determining that a loop exists in the dependency network if a closed path is detected that starts from a field node, passes through one or more directed dependencies, and returns to that field node; and performing exception handling on the linkage rules corresponding to the loop if a loop is determined to exist in the dependency network. The exception handling includes at least one of preventing the activation of the linkage rule, outputting a loop warning message, or performing degradation processing on the field nodes involved in the loop.

[0064] In some embodiments, after the server constructs a dependency network to represent the linkage and influence relationship between fields, the server can perform loop detection on the dependency network to determine whether there is a closed dependency path in the dependency network.

[0065] Specifically, the server can start from any field node in the dependency network and traverse other field nodes along the directions indicated by the directed dependencies. If, during the traversal, the server detects that it started from a certain field node, passed through one or more directed dependencies, and then returned to that field node, it can determine that a loop exists in the dependency network.

[0066] For example, a form includes fields A, B, and C, and these fields correspond to field nodes A, B, and C, respectively, in a dependency network. If there exists a directed dependency relationship in the dependency network where field node A points to field node B, field node B points to field node C, and field node C points to field node A, then the server can determine that a closed path is formed between field nodes A, B, and C, and thus determine that a loop exists in the dependency network.

[0067] If a loop is determined to exist in the dependent network, the server can perform exception handling on the linkage rules corresponding to the loop. Exception handling may include at least one of the following: preventing the activation of the linkage rules corresponding to the loop, outputting a loop warning message, or performing degradation processing on the field nodes involved in the loop.

[0068] For example, the server can prevent the activation of linkage rules that cause field node C to point to field node A, and output a prompt message to the configuration end. This prompt message can be used to indicate the existence of a closed dependency path consisting of field A, field B, and field C. Alternatively, the server can retain some non-loop linkage rules, while suspending automatic linkage, limiting the linkage propagation level, or switching the relevant fields to a downgraded processing method requiring manual confirmation before updates for loop-related field nodes.

[0069] By using the above methods, we can identify and process the closed dependency path formed by the field linkage rules in a timely manner, so as to avoid the problems of repeated execution of linkage calculations, difficulty in ending update transactions, or instability of form status caused by the cyclical influence between field nodes after the target field is updated.

[0070] It is understood that the embodiments of this application do not limit the specific timing of loop detection. In some embodiments, the server can perform loop detection after the dependency network is built; in other embodiments, the server can perform loop detection on the updated dependency network after the field linkage rules are added, deleted, or modified; in still other embodiments, the server can also perform loop detection on the field nodes or dependency paths involved in the current update transaction during the process of responding to the update of the target field and determining the set of affected domains or the linkage processing order.

[0071] This application does not limit the specific implementation of loop detection. For example, the server can use depth-first traversal, breadth-first traversal, topology sorting detection, recursive methods, or non-recursive methods to detect closed paths in the dependency network. As long as it can be determined whether there is a closed path in the dependency network that starts from a field node and returns to that field node through one or more directed dependencies, it can be applied to the embodiments of this application.

[0072] In some embodiments, the server can perform loop detection on the dependency network using a non-recursive traversal method. Specifically, the server can set an access state for field nodes, including unvisited, being accessed, and completed. The server can use an explicit stack to record the current traversal path and sequentially visit downstream field nodes along the directed dependencies. When the server detects during traversal that a field node points to a field node with an access state of "being accessed," it determines that a loop exists in the dependency network. Because this method maintains the traversal path using an explicit stack rather than a dependency program call stack, it can reduce the risk of recursive call stack overflow in deep dependency networks.

[0073] In some examples, the set of influence domains corresponding to the target field is determined based on the dependency network, including: determining the target field node corresponding to the target field in the dependency network; taking the target field node as the starting node and following the direction indicated by the directed dependency relationship in the dependency network, determining the field nodes associated with the target field node in the dependency network; and combining the determined field nodes into the set of influence domains corresponding to the target field.

[0074] Specifically, the server can first determine the target field node corresponding to the target field in the dependency network. The target field node is the field node mapped when the target field is constructed in the dependency network.

[0075] Subsequently, the server takes the target field node as the starting node and performs downstream traversal along the directions indicated by the directed dependencies in the dependency network to determine the field nodes that can be reached from the target field node. A reachable field node is a field node that can be reached from the target field node through one or more directed dependencies. The reachable field node is the field node associated with the target field node. The server determines the reachable field nodes as the set of influence domains corresponding to the target field. Therefore, the set of influence domains includes downstream field nodes that may be affected by this target field update, while field nodes that are not downstream reachable from the target field node are not included in the scope of the linkage calculation for this update transaction.

[0076] For example, a form includes fields A, B, C, D, and E, and each field corresponds to field node A, field node B, field node C, field node D, and field node E in the dependency network, respectively. If there are directed dependencies in the dependency network such that field node A points to field node B, field node B points to field node D, and field node C points to field node E, then when field A is updated as the target field, the server performs downstream traversal starting from field node A. It can determine that field nodes B and D are reachable from field node A, and therefore, field nodes B and D are determined as the set of influence domains corresponding to field A. Since field nodes C and E are not reachable from field node A, they are not included in the scope of the linkage calculation for this update transaction.

[0077] For example, if there are directed dependencies in the network such that field node A points to field node B, field node A points to field node C, field node B points to field node D, and field node C points to field node D, then when field A is updated as the target field, the server can determine along the directed dependencies that field nodes B, C, and D are all reachable from field node A, and determine field nodes B, C, and D as the set of influence domains corresponding to field A.

[0078] In this way, when the target field is updated, the server can only identify and process the downstream field nodes affected by the target field, without having to perform linkage calculations on all field nodes in the form, thereby reducing the calculation scope in this update transaction and improving the efficiency of form linkage processing.

[0079] In some examples, before determining the linkage processing order among multiple field nodes included in the influence domain set, the method further includes: determining a set of candidate field nodes whose in-degrees meet the preset conditions based on the in-degrees of each field node in the dependency network; sequentially determining the current field node from the set of candidate field nodes, and adding the current field node to the global scheduling sequence; after adding the current field node to the global scheduling sequence, updating the in-degrees of the downstream field nodes pointed to by the current field node; in the case where the in-degrees of the downstream field nodes meet the preset conditions, adding the downstream field nodes to the set of candidate field nodes; repeating the steps of determining the current field node from the set of candidate field nodes, adding the current field node to the global scheduling sequence, and updating the in-degrees of the downstream field nodes until all field nodes in the dependency network are processed, obtaining the global scheduling sequence; wherein, the global scheduling sequence is used to determine the linkage processing order among field nodes in the update transaction.

[0080] In some embodiments, before determining the linkage processing order among field nodes in the influence domain set, the server can pre-generate a global scheduling sequence based on the dependency network. The global scheduling sequence is used to represent the overall linkage calculation sequence relationship among each field node in the dependency network.

[0081] Specifically, the server can first calculate the in-degrees of each field node in the dependency network. The in-degree of a field node can represent the number of directed dependency relationships pointing to the field node, that is, the number of upstream field nodes on which the field node depends. The server can add the field nodes whose in-degrees meet the preset conditions to the set of candidate field nodes. Among them, the preset condition can be that the in-degree is zero, or other conditions used to indicate that the field node currently meets the output conditions.

[0082] The server determines a field node from the set of candidate field nodes as the current field node, and adds the current field node to the global scheduling sequence. When there are multiple field nodes in the set of candidate field nodes, the server can determine the current field node from the multiple field nodes according to a preset stable selection rule. The preset stable selection rule can include at least one of the field declaration order, the field node identifier sorting rule, or the preset priority rule.

[0083] Subsequently, the server removes the current field node from the set of candidate field nodes, and updates the in-degrees of the downstream field nodes pointed to by the current field node. If the in-degree of a certain downstream field node meets the preset conditions after the update, the server adds the downstream field node to the set of candidate field nodes.

[0084] The server repeats the above steps until all field nodes in the dependent network have been processed, thus obtaining a global scheduling sequence. This global scheduling sequence can be used subsequently to determine the order of coordinated processing among field nodes within the affected domain set in this update transaction when the target field is updated.

[0085] For example, a dependency network includes field nodes A, B, C, and D, and there exist directed dependencies such that field node A points to field node B, field node A points to field node C, field node B points to field node D, and field node C points to field node D. In this case, the in-degree of field node A is 0, the in-degrees of field nodes B and C are both 1, and the in-degree of field node D is 2.

[0086] The server can first add field node A to the candidate field node set. Since the in-degree of field node A meets the preset condition, the server adds field node A as the current field node to the global scheduling sequence. At this time, the global scheduling sequence is: field node A. Subsequently, the server updates the in-degree of the downstream field nodes B and C pointed to by field node A, making the in-degree of field node B and field node C both become 0, and adds field node B and field node C to the candidate field node set.

[0087] At this point, the candidate field node set includes both field node B and field node C. If the field declaration order is field A, field B, field C, and field D, the server can determine field node B as the current field node according to the field declaration order and add field node B to the global scheduling sequence. The global scheduling sequence at this point is: field node A, field node B.

[0088] The server updates the in-degree of field node D, which is pointed to by field node B, changing the in-degree of field node D from 2 to 1. Since the in-degree of field node D does not yet meet the preset condition, field node D will not be added to the candidate field node set for the time being.

[0089] Subsequently, the server determines field node C as the current field node from the candidate field node set according to the field declaration order, and adds field node C to the global scheduling sequence. At this time, the global scheduling sequence is: field node A, field node B, field node C.

[0090] The server updates the in-degree of field node D, which is pointed to by field node C, changing the in-degree of field node D from 1 to 0. At this point, the in-degree of field node D meets the preset condition, and the server adds field node D to the candidate field node set. Next, the server adds field node D as the current field node to the global scheduling sequence. At this time, the global scheduling sequence is: field node A, field node B, field node C, field node D.

[0091] Therefore, the server can obtain a global scheduling sequence that satisfies the dependencies defined by the dependency network. In this sequence, field node A precedes field nodes B and C, and both field nodes B and C precede field node D. Thus, this global scheduling sequence ensures that upstream field nodes are processed before their downstream field nodes.

[0092] Furthermore, when field A is updated as the target field, the server can determine the set of influence domains corresponding to field A based on the dependency network, including field nodes B, C, and D. The server can filter field nodes belonging to the set of influence domains from the aforementioned global scheduling sequence, while maintaining the order of the filtered field nodes in the global scheduling sequence. Since the global scheduling sequence is field node A, field node B, field node C, and field node D, the linkage processing order of this update transaction after filtering is: field node B, field node C, and field node D.

[0093] Therefore, after the target field is updated, the server can perform linkage calculations only on the field nodes in the affected domain set, and ensure that the linkage calculations of field node B and field node C are executed before the linkage calculation of field node D, thereby guaranteeing that field node D can be processed based on the latest linkage calculation results of field node B and field node C when performing linkage calculations.

[0094] It is understandable that during the generation of the global scheduling sequence, the candidate field node set may simultaneously include multiple field nodes whose in-degree meets the preset conditions. To avoid inconsistencies in the generated global scheduling sequence caused by different operating environments, different traversal orders, or different data storage orders, the server can determine the current field node from the candidate field node set according to preset stable selection rules.

[0095] In some embodiments, the preset stable selection rule may include at least one of the field declaration order, the field node identifier sorting rule, or the preset priority rule. That is, when there are multiple field nodes in the candidate field node set, the server may determine the current field node from the multiple field nodes according to the declaration order of the fields in the form configuration; or, the server may determine the current field node from the multiple field nodes according to the lexicographical order, numerical order, or other preset sorting rules of the field node identifiers; or, the server may determine the current field node from the multiple field nodes according to the field type, field importance, linkage type, or preset business priority.

[0096] By the above method, even when there are multiple field nodes that can be added to the global scheduling sequence at the same time, the server can determine their order according to fixed rules, making the global scheduling sequence reproducible and stable. In this way, when subsequently screening the field nodes in the influence domain set based on the global scheduling sequence, a stable linkage processing order can be obtained, reducing the debugging difficulties or differences in linkage results caused by inconsistent execution orders.

[0097] In some examples, determining the linkage processing order between multiple field nodes included in the influence domain set includes: traversing the field nodes in the global scheduling sequence according to the arrangement order of the field nodes in the global scheduling sequence; when the currently traversed field node belongs to the influence domain set, retaining the currently traversed field node; and determining the linkage processing order between the field nodes in the influence domain set based on the arrangement order of the retained field nodes in the global scheduling sequence.

[0098] In some embodiments, after determining the influence domain set corresponding to the target field, the server may determine the linkage processing order between the field nodes in the influence domain set based on the pre-generated global scheduling sequence.

[0099] Specifically, the server may traverse the field nodes in the global scheduling sequence according to the arrangement order of the field nodes in the global scheduling sequence. During the traversal process, the server determines whether the currently traversed field node belongs to the influence domain set. If the currently traversed field node belongs to the influence domain set, the server retains the field node; if the currently traversed field node does not belong to the influence domain set, the server skips the field node.

[0100] After the traversal is completed, the server can determine the linkage processing order between the field nodes in the influence domain set based on the arrangement order of the retained field nodes in the global scheduling sequence. That is to say, the server does not need to re-sort the field nodes in the influence domain set every time the target field is updated. Instead, it uses the pre-generated global scheduling sequence to filter out the field nodes that need to perform linkage calculations in the current update transaction and maintains the relative order of these field nodes in the global scheduling sequence.

[0101] For example, a form includes field A, field B, field C, field D, field E, and field F, and the above fields respectively correspond to field node A, field node B, field node C, field node D, field node E, and field node F in the dependency network. Assume that the global scheduling sequence pre-generated by the server based on the dependency network is: field node A, field node E, field node B, field node C, field node F, field node D.

[0102] When field A is updated as the target field, the server determines that the influence domain set corresponding to field A includes field node B, field node C, and field node D based on the dependency network. At this time, the server traverses according to the global scheduling sequence and retains field node B, field node C, and field node D that belong to the influence domain set, so as to determine the linkage processing order in the current update transaction as: field node B, field node C, field node D.

[0103] Since the global scheduling sequence already satisfies the dependency relationship defined by the dependency network, the sequence of field nodes filtered from the global scheduling sequence can also maintain the dependency precedence relationship between the field nodes in the influence domain set. For example, when both field node B and field node C point to field node D, field node D is located after field node B and field node C in the linkage processing order, so that field node D can perform the linkage calculation after its upstream field nodes complete the linkage calculation.

[0104] In some embodiments, when determining the influence domain set or filtering field nodes from the global scheduling sequence, the server can maintain a set of determined field nodes. If a certain field node is determined as an affected field node multiple times via different dependency paths, the server can add it to the set of determined field nodes when it is first determined, and skip this field node when it is determined again later, so that the same field node participates in at most one linkage calculation in one update transaction.

[0105] For example, in a dependency network where field node A points to field node B, field node A points to field node C, field node B points to field node D, and field node C points to field node D, when field A is updated, field node D can be identified as the affected field node via two dependency paths: "field node A → field node B → field node D" and "field node A → field node C → field node D". When determining the set of affected domains or filtering the order of linked processing, the server can retain field node D only once, thus avoiding repeated linked calculations for field node D in the same update transaction.

[0106] Therefore, the server can process only the field nodes affected by the target field update, while avoiding reordering the field nodes in the affected domain set every time the target field is updated, and can also avoid the same field node being processed repeatedly in a single update transaction, thereby improving the efficiency of determining the linkage processing order and the linkage calculation efficiency.

[0107] It is understood that the embodiments of this application do not limit the determination of the linkage processing order between field nodes in the influence domain set to a global scheduling sequence. In some embodiments, the server may also directly determine the linkage processing order between multiple field nodes contained in the influence domain set based on the directed dependency relationship corresponding to the influence domain set in the dependency network.

[0108] For example, the server can extract the directed dependencies between field nodes in the influence domain set from the dependency network, obtaining the sub-dependencies corresponding to the influence domain set; then, based on the sub-dependencies, it determines the order of linkage processing between field nodes in the influence domain set. If there is a directed dependency in the sub-dependencies from any field node to another field node, the server determines that the linkage calculation corresponding to any field node is executed before the linkage calculation corresponding to the other field node.

[0109] Therefore, even without generating a global scheduling sequence, the server can determine the linkage processing order in real time based on the set of influence domains and their internal dependencies after the target field is updated, thereby ensuring that the field nodes in the set of influence domains are still linked for calculation according to their dependency order.

[0110] In some examples, the updated value of the target field is written into the temporary form state corresponding to the update transaction, and the field nodes in the affected domain set are subjected to linkage calculations according to the linkage processing order. The update result obtained from the linkage calculation is then written into the temporary form state. This includes: writing the updated value of the target field into the temporary form state corresponding to the update transaction; determining the current field node in the affected domain set in sequence according to the linkage processing order; performing linkage calculations on the field corresponding to the current field node based on the updated value of the target field already written in the temporary form state and the linkage calculation result of the preceding field node already written in the temporary form state, where the preceding field node is the field node that is located before the current field node in the linkage processing order and has completed the linkage calculation; generating the update result corresponding to the current field node, where the update result includes at least one of field value update, field attribute update, candidate option update, or validation result update; and writing the update result corresponding to the current field node into the temporary form state so that subsequent field nodes can perform linkage calculations based on the written temporary form state.

[0111] In some embodiments, after initiating an update transaction, the server can write the updated value of the target field into the temporary form state corresponding to the update transaction, and sequentially perform linkage calculations on the field nodes in the affected domain set according to the linkage processing order. The temporary form state can be a copy, draft, or cached state generated based on the current form state, used to temporarily store the updated value of the target field and the linkage calculation results of each field node in this update transaction.

[0112] Subsequently, the server determines the current field node from the set of influence domains sequentially according to the linkage processing order. In each round of traversal, the server determines the field node encountered in the current round as the current field node. In other words, the current field node is the field node currently performing linkage calculation when the field nodes in the set of influence domains are processed sequentially according to the linkage processing order.

[0113] For the current field node, the server can perform a linkage calculation on the field corresponding to the current field node based on the updated value of the target field already written in the temporary form state and the linkage calculation result of the preceding field node already written in the temporary form state. The preceding field node can be a field node that precedes the current field node in the linkage processing order and has already completed the linkage calculation.

[0114] For example, a form includes fields A, B, C, and D, which correspond to field nodes A, B, C, and D respectively in the dependency network. If field A is updated as the target field, and the server determines that the affected domain set includes field nodes B, C, and D, and the linkage processing order is field nodes B, C, and D, then the server can first write the updated value of field A to the temporary form state.

[0115] In the first round of processing, the server identifies field node B as the current field node and performs a linked calculation on field B corresponding to field node B based on the updated value of field A in the temporary form state. For example, the server can determine whether field B is visible, required, or has a default value based on the updated value of field A. The server generates the update result for field B and writes it to the temporary form state.

[0116] In the second round of processing, the server identifies field node C as the current field node and performs a linked calculation on field C corresponding to field node C based on the updated value of field A in the temporary form state. For example, the server can determine the candidate options, disabled state, or validation trigger strategy for field C based on the updated value of field A. The server generates the update result corresponding to field C and writes the update result to the temporary form state.

[0117] In the third round of processing, the server identifies field node D as the current field node. Since field nodes B and C both precede field node D in the linkage processing sequence, and the linkage calculation results of fields B and C have already been written to the temporary form state, the server can perform linkage calculations on field D corresponding to field node D based on the latest linkage calculation results of fields B and C in the temporary form state. For example, the server can determine the validation result of field D based on the field value of field B and the candidate options of field C, or determine whether field D is enabled based on the states of fields B and C. The server generates an update result corresponding to field D and writes this update result to the temporary form state.

[0118] In this way, the server can ensure that the linkage calculation of the current field node in each round is based on the same temporary form state, and that subsequent field nodes can read the latest linkage calculation results generated by the previous field node in the current update transaction. Since the update results of each field node are first written to the same temporary form state, and the form state is not immediately committed after each field node's linkage calculation is completed, it is beneficial to commit the updated form state all at once in subsequent updates.

[0119] In some examples, the update result corresponding to the current field node is written to the temporary form state, including: generating the update result corresponding to the current field node as status update information; merging the status update information into the temporary form state according to the field identifier and update type corresponding to the status update information; wherein, the update type includes at least one of field value update, field attribute update, candidate option update or validation result update.

[0120] In some embodiments, after performing a linkage calculation on the field corresponding to the current field node, the server can obtain the update result corresponding to that field. To facilitate unified management of the linkage results of multiple fields in the same update transaction, the server can generate the update result as status update information and merge the status update information into the temporary form status.

[0121] The status update information may include field identifiers, update types, and update content. Field identifiers indicate the field corresponding to the status update information; update types indicate whether the status update information is a field value update, field attribute update, candidate option update, or validation result update; update content represents the specific data that needs to be written to the temporary form status.

[0122] For example, if the linkage calculation result corresponding to field node B is that the visibility of field B changes from "invisible" to "visible", the server can generate status update information with field identifier field B, update type field attribute update, and update content visibility status, and merge this status update information into the temporary form status.

[0123] For example, if the linkage calculation result corresponding to field node C is that the candidate options of field C need to be adjusted according to the updated value of field A, the server can generate status update information with field identifier field C, update type candidate option update, and update content new candidate option set, and merge this status update information into the temporary form status.

[0124] For example, if the validation result of field D changes, the server can generate status update information with the field identifier being field D, the update type being validation result update, and the update content being validation pass status or validation prompt information, and then merge this status update information into the temporary form status.

[0125] In some embodiments, the server can locate the state storage location of the corresponding field in the temporary form state based on the field identifier in the state update information; and write the updated content to the field value area, field attribute area, candidate option area, or validation result area corresponding to the field, depending on the update type. Thus, different types of update results can be written to the corresponding positions in the temporary form state, facilitating subsequent field nodes to continue performing linked calculations based on the updated temporary form state.

[0126] By using the above method, the linked calculation results generated by different field nodes can be uniformly converted into mergeable status update information and accumulated in the same temporary form state. This avoids the linked calculation results from directly affecting the current form state, thus facilitating a one-time submission of the updated form state after the linked calculation is completed.

[0127] In some examples, the method further includes: assigning a batch identifier to the update transaction; associating the batch identifier with the asynchronous linkage calculation if the linkage calculation corresponding to the field node in the affected domain set includes asynchronous linkage calculation; upon receiving the return result of the asynchronous linkage calculation, determining whether the batch identifier corresponding to the return result matches the currently valid batch identifier; if the batch identifier corresponding to the return result matches the currently valid batch identifier, updating the form status based on the return result; and if the batch identifier corresponding to the return result does not match the currently valid batch identifier, discarding the return result.

[0128] In some embodiments, to prevent the historical return results of asynchronous calculations from affecting the current form state, the server may also assign a batch identifier to each update transaction.

[0129] Specifically, when the server responds to an update of the target field and initiates an update transaction, the server can generate a corresponding batch identifier for that update transaction and determine that batch identifier as the currently valid batch identifier for the form. The batch identifier can be an incrementing number, a timestamp, a random identifier, a transaction number, or other identifying information that can distinguish different update transactions.

[0130] During the execution of this update transaction, if the linked calculations corresponding to the field nodes in the affected domain set include asynchronous linked calculations, the server can associate the batch identifier with the asynchronous linked calculation. Asynchronous linked calculations may include remote validation, remote candidate option loading, asynchronous default value derivation, or other linked calculations that require waiting for results from external systems, remote services, or asynchronous tasks.

[0131] For example, after field A is updated, the server starts the first update transaction and assigns a batch identifier (batch-1) to it. If the update of field A triggers the loading of remote candidate options for field B, the server can associate batch-1 with that remote candidate option loading task.

[0132] Before the asynchronous computation returns a result, if the user updates field A or other fields again, the server can initiate a second update transaction and assign a batch identifier (batch-2) to the second update transaction. Simultaneously, the server can determine batch-2 as the currently valid batch identifier for that form. At this point, although the asynchronous computation corresponding to batch-1 may still return a result, batch-1 is no longer the currently valid batch identifier.

[0133] When the server receives the return result of the asynchronous linked calculation, it can determine whether the batch identifier associated with the asynchronous linked calculation matches the currently valid batch identifier of the form. If they match, it means that the update transaction corresponding to the return result is still a currently valid update transaction, and the server can allow the return result to participate in the form state update. For example, the server can update the candidate options, validation results, field values, or field attributes of a field based on the return result.

[0134] If the batch identifier associated with the asynchronous calculation does not match the currently valid batch identifier of the form, it means that a new field update has occurred in the form before the asynchronous calculation returns, and the new update transaction has become the currently valid transaction. In this case, the server does not update the form state based on the returned result. That is, the server can ignore the returned result, discard the returned result, or only record the log information corresponding to the returned result, without making it affect the current form state.

[0135] For example, when field A is updated for the first time, it triggers a remote candidate option loading task for field B, which is associated with batch identifier batch-1. Before this task returns, field A is updated a second time, initiating a second update transaction with batch identifier batch-2. When the remote candidate option loading result corresponding to batch-1 returns later than batch-2, the server determines that batch-1 does not match the currently valid batch identifier batch-2, and therefore does not update the candidate options for field B based on the return result corresponding to batch-1. This avoids the old asynchronous result overwriting the form state generated by the new transaction.

[0136] In the above manner, the embodiments of this application can perform validity checks on asynchronous return results in scenarios with asynchronous linkage calculations, so that only asynchronous return results that match the current valid update transaction participate in the form state update, thereby reducing the possibility of historical asynchronous results polluting the current form state.

[0137] To better understand this application, this embodiment provides a more specific example for illustration: It should be noted that the following code is only an exemplary implementation given to facilitate understanding of the technical solution of this application, and the embodiments of this application do not limit the specific programming language, function name, variable name or data structure form.

[0138] I. Reliance on network construction.

[0139] In this example, field identifiers are used as field nodes. If a change in field X affects the field value, field attribute, candidate options, or validation result of field Y, a directed dependency relationship X→Y is established, pointing from field X to field Y. To support efficient influence domain pruning and in-degree maintenance, this example can maintain both out-edge and in-edge indexes simultaneously. Specifically, `outEdges` records the list of downstream field nodes originating from the field node, and `inEdges` records the list of upstream field nodes pointing to the field node.

[0140] Example as follows: type NodeKey = string;type Graph = {out: Record<NodeKey, NodeKey[]> ;in?: Record<NodeKey, NodeKey[]> ;};function addEdge(g: Graph, from: NodeKey,to: NodeKey) {(g.out[from] ||= []).push(to);if (g.in) (g.in[to] ||= []).push(from);}.

[0141] Using the above method, when it is determined that updating the field from will affect the field to, a directed dependency relationship from from to to can be established in the dependency network, and the outgoing edge index and the incoming edge index can be updated respectively.

[0142] II. Loop detection.

[0143] To avoid closed dependency paths caused by linked rules leading to circular updates, this example performs loop detection after the dependency network is built or changed. This loop detection can be implemented using an explicit stack-based iterative depth-first traversal, thereby reducing the risk of stack overflow in deep dependency scenarios.

[0144] Example as follows: function detectCycle(out: Record<string, string[]> ) {const color:Record<string, 0|1|2> = {}; / / 0 not accessed 1 accessing 2 completed for (const start ofObject.keys(out)) {if (color[start]) continue;const stack: Array<{n: string;i: number}>= [{ n: start, i: 0}];color[start]= 1;while (stack.length) {consttop = stack[stack.length - 1];const nexts = out[top.n]|| [];if (top.i>=nexts.length) {color[top.n] = 2;stack.pop();continue;}const v = nexts[top.i++];if (color[v] === 1) return { hasCycle: true, at: [top.n, v]};if (!color[v]) {color[v]= 1;stack.push({ n: v, i: 0});}}}return { hasCycle: false};}.

[0145] The `color` parameter is used to indicate the access status of a field node. When a field node in the "accessing" state is encountered, it indicates that there is a situation in the current dependency path where the path returns to a field node that is already in the path, which confirms that there is a loop in the dependency network.

[0146] III. Generating a Global Scheduling Sequence If the dependent network satisfies the acyclic condition, or if the server determines that the dependent network is available for scheduling, the in-degree of the field nodes can be calculated and queue-based resolution can be performed to obtain the global scheduling sequence `schedule`. When there are multiple candidate field nodes with an in-degree of 0, they can be stably dequeued according to the field declaration order, field node identifier sorting rules, or other preset priority rules, thereby avoiding jitter in the scheduling sequence generated under different operating environments.

[0147] Example as follows: function buildSchedule(out: Record<string, string[]> , prefer?: (a:string,b:string)=>number) {const index: Record<string, number> = {};for (constu of Object.keys(out)) indeg[u] ||= 0;for (const u of Object.keys(out)) {for(const v of (out[u]|| [])) indeg[v]= (indeg[v] || 0) + 1;}let q =Object.keys(indeg).filter(k =>indeg[k] === 0);if (prefer) q.sort(prefer);const res: string[]= [];while (q.length) {const u = q.shift()!;res.push(u);for (const v of (out[u]|| [])) {indeg[v]-= 1;if (indeg[v] === 0) {q.push(v);if (prefer) q.sort(prefer);}}}return res;}.

[0148] The global scheduling sequence generated in the above manner can satisfy the dependency order relationship defined by the dependency network. That is, if there is a directed dependency relationship in the dependency network where field node u points to field node v, then field node u is located before field node v in the global scheduling sequence.

[0149] IV. Incremental trimming and deduplication.

[0150] When the target field changes, this example does not perform a linked calculation on all field nodes in the entire form; instead, it only updates the influence domain of the target field. The influence domain can be understood as all field nodes reachable downstream along the directed dependency relationship from the target field node.

[0151] Example as follows: function collectAffected(out: Record<string, string[]> , seeds: string[]) {const seen = new Set <string>();const stack = [...seeds];while(stack.length) {const u = stack.pop()!;for (const v of (out[u]|| [])) {if(seen.has(v)) continue;seen.add(v);stack.push(v);}}return seen;}functionsliceSchedule(schedule: string[], affected: Set <string>) {const tasks:string[] = [];for (const k of schedule) if (affected.has(k)) tasks.push(k);return tasks;}.

[0152] `collectAffected` is used to determine the affected domain set starting from the target field node. `seen` is used to mark the already determined field nodes to avoid the same field node being added to the affected domain set repeatedly via different dependency paths. `sliceSchedule` is used to filter field nodes belonging to the affected domain set `affected` from the global scheduling sequence `schedule`, maintaining the order of these field nodes in the global scheduling sequence, thereby forming the batch execution list `tasks` corresponding to this update transaction.

[0153] V. Transactional Updates and One-Time Commits In this example, the concept of an update transaction is introduced. At the start of the transaction, the server creates a draft view (draft) and writes the user's update values ​​for the target field into the draft. Then, it determines the set of affected domains based on the target field and prunes the batch execution list (tasks) from the global scheduling sequence. Next, it executes the linked calculations corresponding to each field node in the order of the tasks and writes the calculated update results back to the draft. Finally, at the end of the transaction, the nextState is committed only once.

[0154] Furthermore, for asynchronous calculations or validations, a batch identifier (batchId) can be introduced. When writing back asynchronous results, the batchId is checked for match to prevent historical asynchronous results from polluting the current form state.

[0155] let batchId = 0;function runTransaction(seedKey: string, newVal: any,state: any, schedule: string[], out: any, compute: any) {const myBatch = ++batchId;const draft = structuredClone(state); / / Or use immer / self-developed draft draft.values[seedKey] = newVal;const affected = collectAffected(out,[seedKey]);const tasks = sliceSchedule(schedule, affected);for (const k oftasks) {const patch = compute[k](draft, { batchId: myBatch});applyPatch(draft, patch);}commitOnce(draft, myBatch);}.

[0156] In the example above, seedKey represents the identifier of the target field that is being updated, newVal represents the updated value of the target field, state represents the current form state, schedule represents the pre-generated global scheduling sequence, out represents the outgoing edge index of the dependent network, and compute represents the linked calculation logic corresponding to the field node.

[0157] The server first creates a draft based on the current form state and writes the updated values ​​of the target fields into the draft. Then, the server determines the set of influence domains corresponding to the target field based on `collectAffected`, and selects the field nodes that need to be processed in this update transaction from the global scheduling sequence based on `sliceSchedule`, obtaining `tasks`. Next, the server executes the linked calculations in the order of `tasks`, and writes the patch obtained from each linked calculation into the draft. After all field nodes in `tasks` have been processed, the server commits the updated form state corresponding to the draft in one go using `commitOnce`.

[0158] Therefore, this example can write the results of multiple linked calculations triggered by a single target field update into the same draft view, and submit them all at once after the linked calculations are completed, thereby reducing the exposure of intermediate states, inconsistencies in form states, or page display jitter caused by multiple real-time writes to the current form state.

[0159] It should be noted that the names Graph, out, in, schedule, draft, patch, batchId, collectAffected, sliceSchedule, compute, applyPatch, and commitOnce in the above examples are only used to describe the implementation logic of the embodiments of this application and do not constitute a limitation on the scope of protection of this application. In other embodiments, other data structures, function names, state management methods, or transaction commit methods can also be used to achieve the same or similar technical effects as the above examples.

[0160] All of the above-mentioned optional technical solutions can be combined in any way to form the optional embodiments of this application, and will not be described in detail here.

[0161] The following are embodiments of the apparatus described in this application, which can be used to execute the embodiments of the method described in this application. For details not disclosed in the apparatus embodiments of this application, please refer to the embodiments of the method described in this application.

[0162] Figure 3 This is a schematic diagram of a form linkage update device provided in an embodiment of this application. Figure 3 As shown, the form-linked update device includes: Module 301 is used to construct a dependency network that represents the linkage and influence relationship between fields. The dependency network includes multiple field nodes and the directed dependency relationships between field nodes. The determination module 302 is used to initiate an update transaction in response to an update of the target field in the form, and determine the set of influence domains corresponding to the target field based on the dependency network. The set of influence domains includes at least one field node affected by the update of the target field. The determination module 302 is also used to determine the linkage processing order among multiple field nodes contained in the influence domain set, wherein the linkage processing order conforms to the dependency relationship defined by the dependency network. The calculation module 303 is used to write the update value of the target field into the temporary form state corresponding to the update transaction, and to perform linkage calculation on the field nodes in the set of affected domains according to the linkage processing order, and write the update result obtained by the linkage calculation into the temporary form state. The update module 304 is used to submit the updated form status corresponding to the temporary form status all at once after the linkage calculation is completed.

[0163] In some examples, a dependency network is constructed to characterize the interrelationships between fields. This includes: mapping multiple fields in the form to field nodes and constructing an initial dependency network based on the field nodes; obtaining the linkage rules corresponding to multiple fields in the form; using each field in the form as a source field and determining the affected field corresponding to each source field based on the linkage rules, wherein the affected field is a field whose value, attribute, candidate option, or validation result changes in response to an update of the source field; and for each source field and each corresponding affected field, establishing a directed dependency relationship in the initial dependency network from the field node corresponding to the source field to the field node corresponding to the affected field, thus obtaining the dependency network.

[0164] In some examples, after constructing a dependency network to characterize the linkage and influence relationships between fields, the method further includes: performing loop detection on the dependency network; determining that a loop exists in the dependency network if a closed path is detected that starts from a field node, passes through one or more directed dependencies, and returns to that field node; and performing exception handling on the linkage rules corresponding to the loop if a loop is determined to exist in the dependency network. The exception handling includes at least one of preventing the activation of the linkage rule, outputting a loop warning message, or performing degradation processing on the field nodes involved in the loop.

[0165] In some examples, the set of influence domains corresponding to the target field is determined based on the dependency network, including: determining the target field node corresponding to the target field in the dependency network; taking the target field node as the starting node and following the direction indicated by the directed dependency relationship in the dependency network, determining the field nodes associated with the target field node in the dependency network; and combining the determined field nodes into the set of influence domains corresponding to the target field.

[0166] In some examples, before determining the order of linked processing among multiple field nodes contained in the influence domain set, the method further includes: determining candidate field nodes whose in-degrees meet preset conditions based on the in-degree of each field node in the dependency network; sequentially determining the current field node from the candidate field nodes and adding the current field node to the global scheduling sequence; after adding the current field node to the global scheduling sequence, updating the in-degree of the downstream field node pointed to by the current field node; if the in-degree of the downstream field node meets the preset conditions, adding the downstream field node to the candidate field node; repeating the steps of determining the current field node from the candidate field nodes, adding the current field node to the global scheduling sequence, and updating the in-degree of the downstream field node until the field nodes in the dependency network are processed, resulting in the global scheduling sequence; wherein, the global scheduling sequence is used to determine the order of linked processing among field nodes in the update transaction.

[0167] In some examples, determining the linkage processing order among multiple field nodes contained in the influence domain set includes: traversing the field nodes in the global scheduling sequence according to their arrangement; retaining the currently traversed field node if it belongs to the influence domain set; and determining the linkage processing order among the field nodes in the influence domain set based on the arrangement order of the retained field nodes in the global scheduling sequence.

[0168] In some examples, the updated value of the target field is written into the temporary form state corresponding to the update transaction, and the field nodes in the affected domain set are subjected to linkage calculations according to the linkage processing order. The update result obtained from the linkage calculation is then written into the temporary form state. This includes: writing the updated value of the target field into the temporary form state corresponding to the update transaction; determining the current field node in the affected domain set in sequence according to the linkage processing order; performing linkage calculations on the field corresponding to the current field node based on the updated value of the target field already written in the temporary form state and the linkage calculation result of the preceding field node already written in the temporary form state, where the preceding field node is the field node that is located before the current field node in the linkage processing order and has completed the linkage calculation; generating the update result corresponding to the current field node, where the update result includes at least one of field value update, field attribute update, candidate option update, or validation result update; and writing the update result corresponding to the current field node into the temporary form state so that subsequent field nodes can perform linkage calculations based on the written temporary form state.

[0169] According to the solution provided in this application embodiment, the form linkage update device constructs a dependency network to characterize the linkage influence relationship between fields. The dependency network includes multiple field nodes and directed dependencies between field nodes. In response to the update of a target field in the form, an update transaction is initiated, and an influence domain set corresponding to the target field is determined based on the dependency network. The influence domain set includes at least one field node affected by the update of the target field. The linkage processing order among the multiple field nodes included in the influence domain set is determined, wherein the linkage processing order conforms to the dependency relationship defined by the dependency network. The updated value of the target field is written into the temporary form state corresponding to the update transaction, and linkage calculations are performed on the field nodes in the influence domain set according to the linkage processing order. The update result obtained from the linkage calculation is written into the temporary form state. After the linkage calculation is completed, the updated form state corresponding to the temporary form state is submitted all at once. This application embodiment can determine the range of affected fields and their linkage processing order based on the dependency network when a field update triggers multi-level form linkage, and first write the updated value of the target field and the linkage calculation results of each affected field into the same temporary form state, and then submit the updated form state in a unified manner. Compared to the method where each linkage result is written to the current form state immediately, the embodiments of this application can reduce the number of form update submissions during a single field update process. This avoids the problem in the prior art where, when a single field update triggers multi-level form linkage, each linkage result is written to the current form state immediately, resulting in multiple form updates, inconsistent form linkage states, and page display jitter.

[0170] Figure 4 This is a schematic diagram of the electronic device 6 provided in an embodiment of this application. Figure 4 As shown, the electronic device 6 of this embodiment includes: a processor 401, a memory 402, and a computer program 403 stored in the memory 402 and executable on the processor 401. When the processor 401 executes the computer program 403, it implements the steps in the various device embodiments described above. Alternatively, when the processor 401 executes the computer program 403, it implements the functions of each module / unit in the various method embodiments and the functions of each device embodiment described above.

[0171] Electronic device 6 can be a desktop computer, laptop, handheld computer, cloud server, or other electronic device. Electronic device 6 may include, but is not limited to, processor 401 and memory 402. Those skilled in the art will understand that... Figure 4 This is merely an example of electronic device 6 and does not constitute a limitation on electronic device 6. It may include more or fewer components than shown, or different components.

[0172] The processor 401 may be a central processing unit (CPU), or other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc.

[0173] The memory 402 can be an internal storage unit of the electronic device 6, such as a hard disk or RAM of the electronic device 6. The memory 402 can also be an external storage device of the electronic device 6, such as a plug-in hard disk, Smart Media Card (SMC), Secure Digital (SD) card, Flash Card, etc., equipped on the electronic device 6. The memory 402 can also include both internal and external storage units of the electronic device 6. The memory 402 is used to store computer programs and other programs and data required by the electronic device.

[0174] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the above-described division of functional units and modules is merely an example. In practical applications, the above functions can be assigned to different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above. The functional units and modules in the embodiments can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0175] If an integrated module / unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, all or part of the processes in the methods of the above embodiments can also be implemented by a computer program instructing related hardware. The computer program can be stored in a computer-readable storage medium, and when executed by a processor, it can implement the steps of the various method embodiments described above. The computer program may include computer program code, which can be in the form of source code, user code, executable files, or certain intermediate forms. A computer-readable medium may include: any entity or device capable of carrying computer program code, recording media, USB flash drives, portable hard drives, magnetic disks, optical disks, computer memory, read-only memory (ROM), random access memory (RAM), electrical carrier signals, telecommunication signals, and software distribution media, etc. It should be noted that the content included in a computer-readable medium can be appropriately added to or subtracted according to the requirements of legislation and patent practice in a jurisdiction. For example, in some jurisdictions, according to legislation and patent practice, computer-readable media do not include electrical carrier signals and telecommunication signals.

[0176] The above embodiments are only used to illustrate the technical solutions of this application, and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features. Such modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of this application, and should all be included within the protection scope of this application.< / string> < / string>

Claims

1. A method for linked form updates, characterized in that, The method includes: Construct a dependency network to characterize the linkage and influence relationships between fields, wherein the dependency network includes multiple field nodes and directed dependency relationships between field nodes; In response to an update of a target field in a form, an update transaction is initiated, and an influence domain set corresponding to the target field is determined based on the dependency network. The influence domain set includes at least one field node affected by the update of the target field. Determine the linkage processing order among multiple field nodes contained in the influence domain set, wherein the linkage processing order conforms to the dependency relationship defined by the dependency network; Write the updated value of the target field into the temporary form state corresponding to the update transaction, and perform linkage calculations on the field nodes in the set of influence domains according to the linkage processing order, and write the update result obtained from the linkage calculation into the temporary form state. After the linkage calculation is completed, the updated form status corresponding to the temporary form status is submitted all at once.

2. The method according to claim 1, characterized in that, Construct a dependency network to characterize the interrelationships and influences between fields, including: Map multiple fields in the form to field nodes, and build an initial dependency network based on the field nodes; Retrieve the linkage rules corresponding to multiple fields in a form; The fields in the form are used as source fields, and the affected fields corresponding to each source field are determined based on the linkage rules. The affected fields are fields whose field values, field attributes, candidate options, or validation results change in response to the update of the source fields. For each source field and its corresponding affected field, a directed dependency relationship is established in the initial dependency network, from the field node corresponding to the source field to the field node corresponding to the affected field, to obtain the dependency network.

3. The method according to claim 2, characterized in that, After constructing a dependency network to characterize the interrelationships between fields, the method further includes: Loop detection is performed on the dependent network; If a closed path is detected in the dependency network that starts from a field node, passes through one or more directed dependencies, and returns to that field node, it is determined that the dependency network contains a loop. If a loop is found in the dependent network, anomaly handling is performed on the linkage rule corresponding to the loop. The anomaly handling includes at least one of preventing the activation of the linkage rule, outputting a loop prompt message, or performing degradation processing on the field nodes involved in the loop.

4. The method according to claim 1, characterized in that, Based on the dependency network, the set of influence domains corresponding to the target field is determined, including: Determine the target field node corresponding to the target field in the dependency network; Starting with the target field node, and following the direction indicated by the directed dependency relationship in the dependency network, determine the field node associated with the target field node in the dependency network; The identified field nodes are combined into a set of influence domains corresponding to the target field.

5. The method according to claim 1, characterized in that, Before determining the order of coordinated processing among multiple field nodes contained in the influence domain set, the method further includes: Based on the in-degree of each field node in the dependency network, candidate field nodes whose in-degree meets the preset conditions are determined; The current field node is determined sequentially from the candidate field nodes, and the current field node is added to the global scheduling sequence; After adding the current field node to the global scheduling sequence, update the in-degree of the downstream field node pointed to by the current field node; If the in-degree of the downstream field node meets the preset condition, the downstream field node is added to the candidate field node; Repeat the steps of determining the current field node from the candidate field nodes, adding the current field node to the global scheduling sequence, and updating the in-degree of the downstream field nodes until all field nodes in the dependent network have been processed, thus obtaining the global scheduling sequence. The global scheduling sequence is used to determine the order of coordinated processing between field nodes in the update transaction.

6. The method according to claim 5, characterized in that, Determining the order of coordinated processing among multiple field nodes contained in the influence domain set includes: The field nodes in the global scheduling sequence are traversed according to their arrangement order. If the currently traversed field node belongs to the set of influence domains, the currently traversed field node is retained; Based on the order of the retained field nodes in the global scheduling sequence, the order of coordinated processing among the field nodes in the set of influence domains is determined.

7. The method according to claim 1, characterized in that, Write the updated value of the target field into the temporary form state corresponding to the update transaction, and perform linkage calculations on the field nodes in the influence domain set according to the linkage processing order. Write the update result obtained from the linkage calculation into the temporary form state, including: Write the updated value of the target field into the temporary form status corresponding to the update transaction; According to the aforementioned linkage processing order, the current field node in the set of influence domains is determined sequentially; Based on the updated value of the target field already written in the temporary form state, and the linkage calculation result of the preceding field node already written in the temporary form state, linkage calculation is performed on the field corresponding to the current field node. The preceding field node is the field node that is located before the current field node in the linkage processing order and has completed the linkage calculation. Generate an update result corresponding to the current field node, wherein the update result includes at least one of field value update, field attribute update, candidate option update, or validation result update; The update result corresponding to the current field node is written to the temporary form state, so that subsequent field nodes can perform linked calculations based on the written temporary form state.

8. A form linkage update device, characterized in that, The device includes: The building module is used to construct a dependency network that represents the linkage and influence relationship between fields. The dependency network includes multiple field nodes and directed dependency relationships between field nodes. The determination module is used to initiate an update transaction in response to an update of a target field in a form, and determine the set of influence domains corresponding to the target field based on the dependency network, wherein the set of influence domains includes at least one field node affected by the update of the target field; The determining module is further configured to determine the linkage processing order among multiple field nodes contained in the influence domain set, wherein the linkage processing order conforms to the dependency relationship defined by the dependency network. The calculation module is used to write the update value of the target field into the temporary form state corresponding to the update transaction, and to perform linkage calculation on the field nodes in the set of influence domains according to the linkage processing order, and write the update result obtained by the linkage calculation into the temporary form state. The update module is used to submit the updated form status corresponding to the temporary form status all at once after the linkage calculation is completed.

9. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the steps of the method as described in any one of claims 1 to 7.

10. A readable storage medium storing a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the method as described in any one of claims 1 to 7.

Images