A method and system for generating consistent learning progress visualization analysis reports under asynchronous update conditions

By recording source data and configuration change events in the online learning platform, establishing dependencies, and processing component inputs in the order of dependencies, the problem of data inconsistency caused by asynchronous updates of learning visualization analysis reports is solved, ensuring unified display and access consistency of reports, and reducing computational and transmission overhead.

CN123115172APending Publication Date: 2026-11-17SHANDONG SHIJIJINBANG SCI & EDUCATION & CULTURE
View PDF 2 Cites 0 Cited by

Patent Information

Application Number
CN202611627943.6
Authority / Receiving Office
CN · China
Patent Type
Applications(China)
Current Assignee / Owner
Filing Date
2026-10-21
Publication Date
2026-11-17

AI Technical Summary

Technical Problem

In online learning platforms, under asynchronous update conditions, the different calculation times and update frequencies of various components in the learning progress visualization analysis report lead to inconsistencies between charts and explanatory texts. Existing technologies struggle to effectively determine whether downstream results need updating, resulting in inconsistencies between the displayed data and detailed access.

Method used

By recording source data and configuration change events on the server, the dependencies of the reporting components are established. The target event sequence number is fixed and based on the baseline. The actual input is compared in the order of dependencies, the results of unchanged components are reused, necessary components are recalculated, and the report list is atomically published after verifying the results of all components. The teacher's client then switches the display content and report identifier as a whole.

Benefits of technology

It ensures that charts, explanatory text, and detailed access always maintain the same data cutoff position under asynchronous update conditions, solves the data inconsistency problem when multiple components are generated asynchronously, and avoids the computation and transmission overhead caused by full recalculation.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure CN123115172A_ABST
    Figure CN123115172A_ABST
Patent Text Reader

Abstract

This application provides a method and system for generating consistent learning progress visualization analysis reports under asynchronous update conditions, relating to the field of online learning data processing technology. It establishes dependencies between actual input fields of components by recording data and configuration change events on the server; fixes the target event sequence number and restores the target state; compares the baseline and target inputs according to the dependency order; reuses the results of components that meet the conditions; calculates the results of other components according to the target input; after verifying and displaying the necessary components and their upstream results, it atomically publishes the report list; the teacher client switches the displayed content and report identifier according to the list, and the server returns details according to the target state corresponding to the identifier. This application can reduce unnecessary component recalculation and ensure that charts, text, and detail access correspond to the same data cutoff position. It solves the problems of inconsistent data in different areas when multiple components are generated asynchronously and the problem of clicking on an old report returning the latest details.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] This application relates to the field of online learning data processing technology, specifically to a method and system for generating consistent learning progress visualization analysis reports under asynchronous update conditions. Background Technology

[0002] Online learning platforms typically involve students uploading their answers and corrections via their terminals. The server then generates knowledge point statistics, competency profiles, diagnostic texts, and detailed answer summaries, which are then combined and displayed by teachers via their terminals. Different components have different calculation times and update frequencies. If each area reads the latest results independently, issues may arise such as updated charts but outdated text, or clicking on an old report returning the latest details. While recalculating all components with every data change facilitates a unified cutoff point, even if the upstream only changes fields not yet read downstream, it can still trigger unnecessary calculations and transmissions.

[0003] In the prior art, Chinese invention patent CN114254127B discloses a student ability profiling method, a learning resource recommendation method, and a device. This method uses subject knowledge graph encoding to obtain knowledge point representations and combines historical answer information to predict students' knowledge abilities, thereby providing ability profiles and resource recommendations. Chinese invention patent CN117194445B discloses a materialized view updating method and electronic device. This method uses query records to determine the coverage value of the materialized view for query needs and updates the materialized view accordingly to improve query hit rate and query efficiency. The aforementioned patent documents respectively provide processing methods for calculating learning information and updating pre-aggregated results.

[0004] In interactive reports generated asynchronously by multiple components, it is still necessary to solve the problems of how to determine whether different downstream results need to be updated when the upstream results are partially changed, and how to keep the display and detailed access at the same data cutoff position after reusing old results. Summary of the Invention

[0005] In view of this, this application provides a method and system for generating consistent learning situation visualization analysis reports under asynchronous update conditions, so as to solve the above-mentioned problems in the prior art.

[0006] In a first aspect, embodiments of this application provide a method for generating consistent learning progress visualization analysis reports under asynchronous update conditions, including: The server records source data change events and configuration change events that affect report generation, and establishes dependencies on the actual input fields of the report components; Fixed target event sequence number, using it as the baseline if a published report exists, to restore target data and identify components to be inspected; Compare the actual inputs of the target and the baseline in the order of dependencies, reuse the inputs and the results of components with unchanged rules, otherwise recalculate, and then check whether to continue updating by reading the downstream fields respectively; Verify all necessary component results and reuse basis, and after the dependency check is completed, atomically release a report list containing target sequence numbers and result references; The teacher's client switches the displayed content and report identifiers according to the list, and the server returns details according to the target sequence number corresponding to the report identifier.

[0007] In one possible implementation, the server records source data change events and configuration change events that affect report generation, including: Determine the predefined reporting scope based on the student or class set, course, data storage time boundary and data visibility range, and assign a unique scope identifier to each predefined reporting scope; Map temporary filtering conditions that can be fully covered by the predefined report range to the predefined report range, register the corresponding query identifier, and share the snapshot and event sequence of the predefined report range; When the data boundaries of a predefined reporting scope change, a new reporting scope is established and a new scope identifier is assigned. Receive source data change requests or configuration change requests. The configuration change requests are used to change the input configuration, calculation rules or report template of the change report component. Perform duplicate submission checks and version consistency checks on the received change requests. For change requests that pass the inspection, determine the scope of registered reports affected based on the status before and after the change; Within the same transaction, update the corresponding source data or configuration and its version, sequentially assign consecutive event numbers within each affected report range, and save the change events associated with the corresponding range identifier. The change events include event type, change object identifier, values ​​before and after the change, corresponding version, and event number. Within the transaction, the submission deadline number of each affected reporting scope is updated to the event number assigned in this transaction; if the transaction fails, the update and save operations within the transaction are rolled back as a whole.

[0008] In one possible implementation, establishing the dependencies of the actual input fields of the reporting component includes: Register the source object types and value fields directly input by each component, upstream components and their output fields, as well as the conditions and fields that determine the selection, sorting and association of input objects, and register the precision, null value rules and configuration version; Each round of construction obtains actual input from the target source data state and the upstream results applicable to the target source data state, based on the registration configuration corresponding to the target event sequence number. Check for circular dependencies among components; if no circular dependencies exist, determine the topology execution order of the components; if circular dependencies exist, refuse to enable the corresponding component dependency configuration and output the identifier of the component involved in the circular dependency. By providing only the registered input through a unified input interface, the impact of old and new associations is registered simultaneously for association migration, and the impact of all candidate data on the selection result is registered for the component of the selected ranking object.

[0009] In one possible implementation, the fixed target event sequence number, if a published report exists, is used as a baseline to recover target data and determine the components to be inspected, including: Lock the report range record and the status record of the corresponding query, and save the baseline report identifier of the same range identifier and query identifier combination; The current submission deadline number is fixed as the target number and a build task is registered. Only one active build task is retained for the same combination of range identifier and query identifier. Read a complete snapshot no later than the target sequence number, apply subsequent events sequentially to the target sequence number, and restore the data state including the source data and configuration; Query the events and impact information within the range from the baseline to the target, mark the directly affected components, and mark the components to be inspected along the dependencies.

[0010] In one possible implementation, the step of comparing the actual input of the target with the baseline in dependency order, reusing the input and the results of components with unchanged rules, otherwise recalculating, and then checking whether to continue updating by reading downstream fields, includes: After the required upstream results are ready, compare the actual inputs and computation rules of the current component in the target state with those in the baseline state, according to the component dependency order. If the actual input and calculation rules remain unchanged and a valid baseline result exists, reuse the result and save the basis for reuse; otherwise, recalculate after the input is complete and save the result and the corresponding input information. Based on the results, check the changes in the actual content read by each downstream component, and repeat the process in combination with other inputs and calculation rules until all components to be checked obtain results applicable to the target sequence number.

[0011] In one possible implementation, the step of comparing the actual inputs and computation rules of the current component in the target state with those in the baseline state after the required upstream results are ready, according to the component dependency order, includes: Based on the input configuration, determine the source data and upstream results that the current component directly reads, and obtain the actual input corresponding to the target state and the baseline state; The system compares the input configuration, the selected record, and the actual fields read in sequence. If any item is different, the corresponding input is determined to have changed. When record selection or sorting is involved, the system performs the comparison after selection or sorting in the corresponding state. Verify the calculation rules and summarize the comparison results of each input. If the comparison basis is incomplete, keep it pending inspection. If there is a complete range with no relevant changes and the configuration, rules and range have not changed, determine that the input and rules have not changed.

[0012] In one possible implementation, if the actual input and calculation rules remain unchanged and a valid baseline result exists, the result is reused and the basis for reuse is saved; otherwise, the calculation is recalculated after the input is complete, and the result and corresponding input information are saved, including: When the reuse conditions are met, the effective baseline results are associated with the target sequence number of this round, the original calculation information is retained and the basis for reuse is saved; If the reuse conditions are not met, the computation task is bound to the target state and the required upstream results; for statistical components that support incremental computation, incremental computation is performed if the incremental basis is complete and the rules remain unchanged, otherwise the entire computation is recalculated. Verify the validity of the actual input and task corresponding to the calculation results. If the verification is successful, save the results, calculation status and input information in a unified manner. If the verification fails, reject the submission.

[0013] In one possible implementation, based on the obtained results, the changes in the actual content read by each downstream component are checked, and this process is repeated in conjunction with other inputs and calculation rules until all components to be checked obtain results applicable to the target sequence number, including: Based on the input configuration of each downstream component, compare the content actually read from the current component's target result with the baseline result, and record the input change status of each dependency. For dependencies with changing inputs, the corresponding downstream components are included in the set to be checked and deduplicated; for dependencies with unchanged inputs, downstream recalculation is not triggered due to the recalculation of the current component, and the tasks to be checked caused by other inputs or rule changes are retained. Continue to check the downstream dependencies of the components under inspection, and summarize the component results, reuse basis and dependency inspection status.

[0014] In one possible implementation, the verification of all necessary component results and reuse criteria, after the dependency check is completed, atomically publishes a report list containing target sequence numbers and result references, including: List the necessary components for display according to the target template, identify all necessary upstream components, and check the completeness of the results, the actual input of the new results, and all the reuse basis of the reused results in the order of dependency. The number of pending or failed dependencies affecting essential components is confirmed to be zero; In the publishing transaction, confirm that the current report with the same range identifier and query identifier combination is still the baseline report and the activity construction is still the current round task, while saving the immutable report list, updating the current report reference and construction status; continue to provide the previous complete report when the check or transaction fails.

[0015] In one possible implementation, the teacher client switches the displayed content and report identifiers according to the entire list, and the server returns details according to the target sequence number corresponding to the report identifier, including: The teacher client obtains the report list, loads or reuses the component results based on the results, assembles the report to be displayed, and binds the report identifier and query parameters corresponding to the report list to each component. After all necessary components are prepared, switch the entire system to the report to be displayed and set its report identifier to the currently displayed report identifier; The teacher's client responds to a detailed query operation for the currently displayed report by generating a detailed request that includes the identifier of the currently displayed report, query parameters, and request number. The server responds to the detail request, determines the target sequence number based on the report identifier, queries the details under the corresponding target status, and returns the query result in association with the report identifier and the request sequence number; The teacher client verifies the report identifier and request sequence number of the returned result, and only displays the details if they match the currently displayed report identifier and the latest request sequence number of the corresponding query view, otherwise the result is discarded.

[0016] Secondly, embodiments of this application provide a system for generating consistent learning progress visualization analysis reports under asynchronous update conditions, including: The event logging module is used by the server to record source data change events and configuration change events that affect report generation, and to establish the dependencies between the actual input fields of the report components; The baseline recovery module is used to fix the target event number, and if a published report exists, use it as the baseline to restore the target data and identify the components to be inspected. The comparison reuse module is used to compare the actual input of the target with the baseline in the order of dependency, reuse the input and the results of components whose rules have not changed, otherwise recalculate, and then check whether to continue updating by reading the downstream fields respectively. The verification and release module is used to verify the results of all necessary components and the basis for reuse. After the dependency check is completed, it atomically releases a report list containing the target sequence number and result reference. The details return module is used by the teacher client to switch the displayed content and report identifier according to the list as a whole, and the server returns the details according to the target sequence number corresponding to the report identifier.

[0017] Thirdly, embodiments of this application provide a computer-readable storage medium including a stored program, wherein, when the program is executed, it controls the device where the computer-readable storage medium is located to perform the method described in any one of the first aspects.

[0018] In this embodiment, by establishing dependencies between the actual input fields of the report components, when upstream data changes, the target and baseline actual inputs are compared component by component in dependency order. Components with valid baseline results and unchanged necessary inputs and calculation rules reuse existing results; components with changed inputs or calculation rules are calculated; and components lacking valid baseline results are fully calculated, avoiding the computation and transmission overhead caused by full recalculation. Simultaneously, the target event sequence number is fixed using the published report as the baseline and the corresponding data is restored. After verifying all necessary component results and reuse criteria, the report list is atomically published. The teacher's client switches the displayed content and report identifier according to the list, ensuring that charts, explanatory text, and detailed access always correspond to the same data cutoff position. This solves the problems of inconsistent data in different areas when multiple components are generated asynchronously and the issue of clicking on an old report returning the latest details. Attached Figure Description

[0019] To more clearly illustrate the technical solutions of the embodiments of this application, the drawings used in the embodiments 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.

[0020] Figure 1 This is a schematic diagram of hardware device deployment provided in an embodiment of this application; Figure 2 A flowchart illustrating a method for generating a consistent learning progress visualization analysis report under asynchronous update conditions, provided in an embodiment of this application; Figure 3 A schematic diagram illustrating the interaction between the student client, server, and teacher client provided in an embodiment of this application; Figure 4 This is a schematic diagram of a consistency generation system for a visual analysis report of student learning under asynchronous update conditions, provided as an embodiment of this application. Detailed Implementation

[0021] To better understand the technical solution of this application, the embodiments of this application will be described in detail below with reference to the accompanying drawings.

[0022] It should be understood that the described embodiments are merely some, not all, of the embodiments in this application. All other embodiments obtained by those skilled in the art based on the embodiments in this application without inventive effort are within the scope of protection of this application.

[0023] The terminology used in the embodiments of this application is for the purpose of describing particular embodiments only and is not intended to be limiting of this application. The singular forms “a,” “the,” and “the” used in the embodiments of this application and the appended claims are also intended to include the plural forms unless the context clearly indicates otherwise.

[0024] It should be understood that the term "and / or" used in this article is merely a description of the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, or B existing alone. Additionally, the character " / " in this article generally indicates that the preceding and following related objects have an "or" relationship.

[0025] This embodiment first introduces the participating devices in the method for generating consistent learning progress visualization analysis reports under asynchronous update conditions. See also... Figure 1 In this embodiment, the main objects involved include student clients, teacher clients, and a server. Student clients can be teaching tablets with local storage, and teacher clients are computers running a browser. The server communicates with both student and teacher clients via HTTPS, stores transaction records in a database, and executes asynchronous tasks using multiple worker threads. The above configuration is an implementation example, and task constraints are not dependent on a specific processor model. Report notifications can be sent via WebSocket, and clients can query the current list upon disconnection.

[0026] This embodiment sets up knowledge point statistics (K), a proportion chart (G), fixed suggestion text (T), a detailed component (D), and teacher annotations (N). K outputs the number of valid questions, the number of correct questions, the mastery ratio, and the grade; G reads the knowledge point identifier and ratio; T reads the knowledge point identifier and grade, and uses a versioned template; D reads the answer record identifier, question identifier, and score; N reads the annotations. The knowledge point name, layout, and template text are derived from the versioned configuration, and changes to them are included in the direct input check.

[0027] Example 1 based on Figure 1 For device deployment, see [link / reference]. Figure 2 and Figure 3 The method for generating consistent learning progress visualization analysis reports under asynchronous update conditions provided in this embodiment includes: S101, the server records source data change events and configuration change events that affect report generation, and establishes dependencies on the actual input fields of the report components.

[0028] The server distinguishes between predefined reporting scopes for continuous maintenance and temporary filtering performed based on those scopes. Predefined reporting scopes determine the boundaries of continuously saved and updated data. Their scope definitions include the set of students or classes, courses, the time boundary for data storage, and the data visibility range, and are assigned a unique scope identifier (scope_id). Scopes with the same data boundaries and data storage lists, and whose effective configurations are compatible, can share the scope identifier, snapshots, and event sequences. When data boundaries change or the original data storage list cannot support configuration expansion, a new scope is established according to the initialization process described below.

[0029] When a teacher submits temporary screening criteria, the server checks whether the data required to perform the screening and its related statistics, sorting, and correlation calculations is completely contained within recoverable data in a predefined reporting range. If it is completely contained, the temporary screening is mapped to that predefined reporting range without creating a separate event sequence and source data snapshot; if it is not completely contained, information indicating that the data range does not support it is returned, or a new range that can cover the required data is initialized. The mapping only uses data that the requesting subject has access to; the statistical components also adhere to this access boundary.

[0030] The server converts temporary filter conditions into normalized query definitions, specifying the filter fields, operators, condition values, statistical time boundaries, and the execution order of filtering, statistical, and sorting operations. Relative time conditions are converted to specific start and end times upon request. The same query identifier (query_id) is reused only when the normalized query definitions are completely identical; different queries are not merged through unverified semantic inference. When temporary filters change, the query identifier is updated, but the range identifier of the mapped predefined report scope remains unchanged. Regular reports without attached temporary filters also register explicit query definitions and query identifiers.

[0031] For different queries within the same predefined report scope, the server saves the query definition and report construction status separately, sharing the source data snapshot and event sequence for that scope. Each round of construction binds the scope identifier, query identifier, and fixed target event sequence number. It first retrieves the source data from the target status, and then performs object selection, statistics, sorting, and component calculations according to the query definition. If the filtering of statistical objects or calibers is changed, the input of the relevant components should be re-examined; it is not permissible to simply filter already generated charts while using the original text or details under the statistical caliber.

[0032] Only one activity build task is retained for each combination of the same scope identifier and query identifier. Current report references and baseline report references are maintained separately for this combination. An existing report is used as a baseline only when the query definition is the same, the component configuration and rules are compatible, and the reuse basis is valid; otherwise, a complete calculation is performed according to the target state. Component results, task binding information, and reuse basis are associated with query identifiers, and their query definitions are verified to be consistent with the current build before release. The report list stores the scope identifier, query identifier, and standardized query definition. Detailed queries are executed within the query scope defined in the list; additional filtering must not expand this scope or exceed the current data access permissions of the requesting subject. Post-ranking or post-statistical filtering should restore the corresponding selection results according to the query definition, and should not be incorrectly changed to pre-statistical filtering.

[0033] Component calculation rules, component input configurations, and display templates can be updated version-wise within the same report scope without changing the aforementioned scope definitions. These updates are considered configuration events and enter the event sequence for that scope. When accessing a report, the server additionally verifies whether the requesting entity currently has permission to access that scope; the permission configuration stored in the scope does not replace the access permission check performed at the time of the request.

[0034] After receiving a configuration change request, the server first saves the new configuration as a candidate configuration, parses its required source object types, fields, object collections, time ranges, relationships, and upstream dependencies, and checks for circular dependencies. Candidate configurations are not used as valid configurations for report building.

[0035] For candidate configurations where the original reporting scope can fully restore the required inputs and continuously record subsequent changes, the server re-verifies the validity of the configuration object version, data storage list version, and recovery basis during the transaction commit. If verification passes, the server updates the valid configuration within the original scope and registers the configuration change event; if verification fails, the candidate configuration is not committed, and the server either prepares again or returns a failure message.

[0036] For candidate configurations whose required input exceeds the coverage of the original data save list or recovery chain, but whose complete and consistent state can be obtained from authoritative source data, the server establishes a new scope with a new data save list. Following step S102, it obtains an initial complete snapshot, saves the candidate configuration as the initial valid configuration of the new scope, and registers subsequent event receiving relationships. After initialization, the first report is fully constructed according to the new configuration, without directly using component results or incremental intermediate states from the original scope. Historical configurations and recovery chains from the original scope remain available for use in the original report.

[0037] Candidate configurations that cannot obtain necessary input from the original recovery chain or authoritative source data, or that cannot continuously record necessary subsequent changes, will not be set as valid configurations, and will return missing object, field, time range, or relationship information. Circular dependency configurations will not enter the valid configuration state. Authoritative source data refers to the current source records, configurations, and associated data maintained by this system; external data must be fully imported into the controlled data source and included in subsequent change registration before it can be used in this initialization process.

[0038] The acceptance of configuration requests, configuration submission, and report display switching are all recorded separately. The already started build is not changed during candidate configuration preparation. After configuration submission, subsequent builds are started with the corresponding target state; the new report is only switched to display after passing consistency verification and completing client loading. Before a new report is published, the original complete report can continue to be provided, clearly indicating its report identifier and data cutoff position, without marking the original report as having adopted the new configuration.

[0039] When expanding the configuration using a new scope, the replacement relationship between the original and new scopes, as well as the query definitions to be taken over, are preserved. Within the new scope, the data coverage of the queries is verified, the corresponding query identifier is registered, and the first complete build is initiated. Once the new report is ready, the client simultaneously switches the scope identifier, query identifier, report identifier, and displayed content. If preparation or build fails, the original report continues to be provided; if the original scope no longer requires continuous updates, it is handled according to the scope deactivation process.

[0040] Candidate configuration resolution and recovery capability checks can be completed before committing the transaction, and the configuration version, data storage list version, and related overwrite locations are recorded. These bases are re-verified as valid during the final commit; the creation of the new scope of snapshots and the subsequent event reception are coordinated according to the initialization transaction in step S102.

[0041] A change to the same source record may affect multiple reporting scopes. The server determines the potentially affected registered reporting scopes based on student or class associations, course associations, time attributes, and other scope selection fields before and after the source record change. Any scope whose pre-change or post-change state might participate in source data selection, candidate object selection, or association calculations for a particular scope is included in the set of scopes to be registered. For changes to common configurations and associated data, the set of scopes to be registered is determined based on the registration relationship between the configuration or associated data and the reporting scope; if the scope cannot be accurately narrowed, all potentially affected registered scopes within the corresponding business data domain are included, and the inability to determine the affected scope is not used as a basis for ignoring the event.

[0042] Within the same database transaction, the server locks range records in the set of ranges to be registered in a fixed order according to the range identifiers. It then assigns the next consecutive event sequence number to each range, saves the range event, its pre- and post-change values ​​and corresponding versions, direct impact information, and pending notification records, and updates the committed deadline number (head_seq) of each range to the currently assigned event sequence number. This operation is committed along with the source data or configuration and its version updates. If any necessary write fails, the entire transaction is rolled back. Multiple range events arising from changes to the same source data or configuration are associated through a common change identifier, but the event sequence numbers for each range are maintained separately, and cross-range size comparisons are not performed.

[0043] A scope event is uniquely identified by both the scope identifier and the event sequence number within that scope. Report lists, snapshots, build tasks, and detailed queries are all bound to the scope identifier; the target event sequence number corresponding to the report identifier is only interpreted within the scope to which the report belongs. When a new scope is established, an initial snapshot is obtained using the initialization method specified in step S102. After initialization is complete, it participates in the registration of scope events for subsequent source changes.

[0044] The student client generates a unique submission identifier (submission_id) for answering, modifying, or canceling questions, persists it, and sends it. Authentication is obtained from the server session; client-claimed student permissions are not trusted. The database uses the authentication subject and submission_id as unique constraints. When a report is lost and retransmitted, the server returns the original processing result corresponding to the submission identifier. This processing result records the mapping relationship between the range identifiers of each affected report range and the corresponding event sequence numbers. After confirmation, the client is removed from the sending queue.

[0045] This embodiment synchronously maintains the current source record and event record in the database. The current source record includes at least an object identifier, current field value, record version, and validity status; the record version is maintained by the server and increments after each successful modification or reversal. The expected record version submitted by the client is used for concurrency control and is not used to specify the data cutoff position for the report.

[0046] When the server processes a commit, it first queries the saved commit results based on the authenticated subject and the unique commit identifier. Duplicate commits that have already been successfully processed directly return the original processing result without modifying the source record or assigning an event sequence number. The first processed commit occupies the unique commit identifier within the database transaction; concurrent requests processing the same identifier are serialized through unique constraints and transaction locks, and subsequent requests that obtain processing opportunities read the results saved by the previous successful transaction.

[0047] For source record modifications or reversals, the server locks the corresponding source record within the transaction and compares its current record version with the expected version carried in the commit. If they differ, a version conflict is returned, the source record is not modified, and no successful change event is generated; if they match, the pre-change value is retrieved, the post-change value is generated, and the record version is incremented. New records are checked for non-existent object identifiers and then written to the initial version; reversal records save the reversal status with the incremented version, retaining the object identifier and version information required for concurrent verification.

[0048] Within the same transaction, the server completes the following: updating the current source record and version; assigning event sequence numbers to the affected reporting range; saving the values ​​before and after the change and the impact information; advancing the commit deadline sequence numbers for each range; saving the commit results; and writing pending notification records. The transaction is committed only after all operations are successful; if any operation fails, the entire transaction is rolled back. The server only returns a success confirmation to the client after a successful transaction commit; subsequent commits that have lost their confirmation retrieve the saved results using the original unique commit identifier.

[0049] Scope events record the pre-change and post-change versions of the source object and save the data required to apply the event to the scope state. When an object was not previously part of the scope's recoverable data set and is first entered after a change, the event provides the complete post-change values ​​required to create the object; when the object exits, it saves the pre-change information required for exit and deletion or invalidation flags. Scope state recovery checks the object's existence and version continuity according to the event type, without requiring event numbers or source object versions to be identical across different reporting scopes.

[0050] Adding, modifying, or deleting teacher comments involved in report generation is treated as source data changes; changes to the input configuration, calculation rules, or report template of the report component are treated as configuration changes. Both teacher comment change requests and configuration change requests carry a unique commit identifier; for requests to modify or delete existing objects, the expected version of the object to be changed is also carried. The server checks for duplicate commits in the aforementioned manner and verifies the object version within the transaction; when adding an object, it checks if the object identifier does not exist and sets the initial version. Duplicate commits return the saved processing results; version conflicts are not updated; after passing the check, within the same transaction, comments or configurations and their versions are updated, change events in the affected report scope are recorded, the commit deadline sequence numbers for each scope are advanced, and the commit results are saved. Change events are associated with the corresponding report scope through scope identifiers, and the event type, changed object identifier, values ​​before and after the change, corresponding version, and event sequence number within the scope are saved. Report construction only reads the read-only state restored from the fixed target sequence number and does not directly use the current source record or configuration continuously updated by the transaction.

[0051] The component input registration describes the input source and acquisition rules, and does not fix the data value at the time of registration for subsequent rounds of input. For direct source input, it registers the source object type, object identifier, value fields, and the conditions and fields that determine the object's entry, exit, sorting, and association; for upstream input, it registers the upstream component identifier, the output fields read, and object selection rules. Each registration also includes the record order, numerical precision, null value rules, and configuration version.

[0052] Source data and relationships are continuously updated via source data change events; when the input source or acquisition rules change, the registration is updated via configuration change events. The unified input interface obtains the actual input from the target read-only source state and upstream results confirmed to be applicable to the target state in this round, based on the configuration corresponding to the target event sequence number. Changes after the build begins are included in subsequent events, without altering the fixed input for this round. Impact analysis simultaneously covers value fields and fields that determine object selection, order, and relationships, without using whether a field is directly displayed as a registration condition.

[0053] If the target input is complete but the baseline comparison or reuse basis is insufficient, perform the complete calculation under the target state; if the target input itself is incomplete, supplement the data or pause the relevant task. Missing input cannot be replaced by complete recalculation, zero value or empty result.

[0054] The server maintains the dependencies between source data fields and components, as well as between upstream output fields and downstream components. A directed dependency graph is built based on the upstream output fields registered by each component, where nodes represent components, and directed edges from upstream components to downstream components indicate that the downstream component reads the output of that upstream component. The server uses a decreasing in-degree method to check the directed dependency graph: first, nodes with an in-degree of zero are added to a queue; then, nodes are sequentially removed, and the in-degree of their downstream nodes is decreased; downstream nodes whose in-degree is reduced to zero are added to the queue, until the queue is empty.

[0055] When the number of nodes retrieved equals the total number of nodes in the dependency graph, it is determined that there is no circular dependency, and the node retrieval order is used as a usable topology execution order; otherwise, it is determined that a circular dependency exists, the dependency configuration is rejected, and the component identifier that failed to complete the topology sorting is output for configuration correction. When a new configuration fails the check, it is not submitted as a valid configuration event, nor is it used for this round of report building; already published reports are still accessible according to the original report list. When a component is added, deleted, or the upstream input relationship changes, the server re-executes the above checks on the changed dependency graph. Each round of building uses the dependency configuration and its topology execution order that have passed the check corresponding to the target event sequence number, and does not switch to other versions of dependency configuration during the build.

[0056] The input interface returns data according to the registered configuration, and components can only use the objects provided by the interface. When a component reads the top few objects, its selection operation is registered as part of that component, and the fields that the entire candidate set depends on are also registered. Changes in the candidate set also generate inspection tasks. For changes in the selection conditions, output model structure, or calculation rules of components that do not change the report scope definition, a configuration event is registered, and the relevant components and downstream components are conservatively put into an inspection state. When the data boundary of the predefined report scope changes, it is initialized according to the new scope identifier. When the temporary filtering within its data boundary changes, the query identifier is updated. Notifications are not sources of facts; when notifications are out of order or lost, the scheduler scans the database records and continues to work.

[0057] Each scope event stores the event type, scope event number, changed object identifier, changed fields, values ​​before and after the change, and related information. Event types at least include source record addition, modification, revocation, changes in relationships, as well as changes to component input configuration, calculation rules, and templates. The server generates directly impacting information based on the direct source fields registered by the component, the fields used in the selection criteria, the sorting fields, and the related fields.

[0058] For each addition, modification, or revocation of a source record, the server determines whether the state before and after the change might participate in the object selection or calculation of the component. If either state might participate, the component is listed as a potentially affected component. A check task is generated when a record changes from not meeting the filter criteria to meeting them, or vice versa; it is not possible to check only records that remain in the current result set after the change.

[0059] For components ranked or selected from the top few objects, the impact assessment covers all candidate objects and the fields upon which their selection and ranking depend. When a candidate object enters or exits the selection, or when the ranking field changes, the component should be listed as potentially affected, even if it does not appear in the baseline selection results. For changes in relationships, both the old and new relationships should be examined to determine which components might be affected.

[0060] The impact index is derived information from event records. Each event stores a completion flag for impact analysis. Even when analysis is completed but no directly affected components are found, the completion flag and corresponding dependency configuration versions are still stored; missing index entries do not indicate no impact. The server stores the cutoff position for consecutive completed index analyses, advancing to that cutoff position only after all previous events have been analyzed. Each round of event impact judgment considers the filtering, sorting, and association conditions in the current query definition. When changes in source data cause records to enter or exit the query results, or alter their sorting, statistics, and association results, the relevant components are included in the check set. When the impact cannot be reliably determined, data without relevant changes is not directly reused.

[0061] S102, fix the target event sequence number, use it as the baseline when there is a published report, restore the target data and identify the components to be inspected.

[0062] The server generates an initial complete snapshot with a cutoff sequence number of 0 for each newly established reporting scope. The initial snapshot includes the source data, relationships, candidate object data, and initial versions of component input configurations, calculation rules, and templates required for restoring the report for that scope. Existing historical answer data is included in the initial snapshot; it is not required to re-convert all business operations prior to system integration into events. If there is no historical answer data, the initial source data set can be empty, but necessary configurations and their versions should still be fully preserved.

[0063] The objects saved in the initial snapshot should be sufficient to support the selection of source data, ranking candidates, and related calculations registered within that scope, not just those already displayed in the report at that time. Object identifiers, source record versions, and necessary fields are saved with the snapshot to support the application and validation of subsequent scope events.

[0064] This embodiment establishes a data storage list during the initialization of the predefined report scope, specifying the source object type, fields, object coverage conditions, time coverage boundaries, relationships, and the range of ranking candidate objects, and saves the list version. The initial complete snapshot saves data according to the list, and subsequent events cover data changes specified in the list, including changes in objects entering or leaving the coverage scope.

[0065] The data storage list can include data that the current component has not yet read but is allowed to be used later. When determining whether a new component or input configuration is supported, it is also necessary to check whether the required fields, object sets, time ranges, and relationships can be completely restored, rather than using the fact that field names have been registered as the sole basis for data integrity.

[0066] When the input required for a new configuration is completely covered by the current list and corresponding snapshots and events, the configuration event is recorded within the original scope; when it exceeds the coverage of the original list or recovery chain, it is processed according to the new scope initialization method in step S101, and the latest data is not directly added to the historical state of the original scope. For example, if the original scope saves the duration and changes of the required response records, a duration analysis component can be added directly; if the original scope does not save the duration but the authoritative source data is complete, a new scope is created and initialized; if the authoritative source data also lacks the necessary duration, it is not replaced with zero values, null values ​​or data from other time points.

[0067] To avoid omissions or duplications between snapshot generation and concurrent source data changes, this embodiment sets up a common transaction mutual exclusion entry point for the scope initialization and source change registration of the same business data domain. A business data domain refers to a set of source records, configurations, and associated data that jointly participate in scope determination and source change registration. After entering a source change transaction, the server acquires a mutex lock for the business data domain before locking the source object, determining the affected scope, and updating the data; the same mutex lock is acquired during new scope initialization. The mutex lock is held until the transaction is committed or rolled back.

[0068] Business data domains are divided according to the common update boundaries of source records and related data. Mutex locks only cover data domains that may jointly affect the scope of related reports, and do not merge data domains that do not share source data or related updates using the same lock. Atomic related updates across data domains acquire the relevant data domain locks in a fixed order and complete the necessary updates within the same transaction. Holding a mutex lock to complete the initial snapshot is suitable for data sizes that can complete initialization within the allowed write wait time. Initialization sets a transaction timeout; after the timeout, the entire transaction is rolled back and the lock is released, without making incomplete scopes available. Temporary queries do not execute this initialization process and directly use the recoverable state of their mapped scope.

[0069] After acquiring the mutex lock during new range initialization, the necessary source data and configuration are obtained under consistent database read conditions. An initial snapshot, range definition, and initial version are saved, and the range's head_seq is set to 0. Within the same transaction, the range is made available and registered as an event receiving range for subsequent source changes. The mutex lock is released after the transaction is committed. Previously committed source changes are reflected in the initial snapshot; subsequent committed source changes affecting the range are registered starting from event sequence number 1 within the range. A complete rollback occurs if initialization fails, and report construction cannot begin for ranges that have not completed initialization.

[0070] When restoring the state corresponding to the target sequence number s, the server selects the most recent valid complete snapshot with an end sequence number t not greater than s, and applies events within the interval (t, s] sequentially in the independent replicas. If no subsequent snapshots exist, the initial complete snapshot with sequence number 0 is used as the recovery starting point. When t equals s, this snapshot is used directly without applying subsequent events. The initial snapshot itself is not part of the published report and is not used as a valid baseline for component results.

[0071] Subsequent complete snapshots are generated from read-only states with fixed sequence numbers that have been restored and verified, and are not formed by concatenating data from the current source data table and configuration table at different times. If the initial snapshot or other necessary historical data is missing and cannot be recovered from the retained data, the current build round is paused and an unrecoverable status message is returned, without replacing the historical state corresponding to the specified target sequence number with the latest current data.

[0072] Upon receiving a teacher's request, the server verifies the scope, query definition, and permissions. If a complete old report exists for the same scope identifier and query identifier combination, the old list can be returned first. The report scope record and corresponding query status record are locked. If an active construction exists for this combination, the status is returned; otherwise, the current report identifier for this combination is obtained as the baseline report identifier. The baseline cutoff number is denoted as b, the current head_seq is fixed as the target number s, and the construction identifier for this round is registered. When there is no baseline, b=0 is used as the event starting point and the first flag is set. At this time, all components required for building are fully calculated according to the target state. If there is a published and complete empty report, it can be reused according to the general rules.

[0073] Read the most recent complete snapshot whose snapshot expiration number is no greater than s, apply events sequentially to the replicas up to s, and generate a read-only source state. Snapshots include range, configuration, and expiration number. For missing numbers, discrepancies between the pre-event version and the restored version of existing objects, or snapshot verification failures, recovery is initiated from an earlier snapshot. If recovery still fails, the current round is paused. Source status, scoring rules, relationships, input configurations, and templates are all fixed with the version corresponding to 's'.

[0074] The server determines the set of necessary display components based on the target template and traverses the target dependency graph backwards from each necessary display component, adding all components that directly or indirectly provide input to the necessary display components to the set of required components. The set of required components includes the necessary display components and all their upstream dependencies, with duplicate components removed based on their component identifiers. Components used only for intermediate calculations and not directly displayed should also be added to the set of required components. In the following text, the set of necessary components determined by the target template refers to the set of necessary display components.

[0075] When no valid baseline report exists during the initial build, the server creates the current round of tasks for all components in the required component set and executes them in the topological order of the target dependency graph. Components without upstream dependencies obtain input directly from the target read-only source state; components with upstream dependencies obtain input and perform computation after all necessary upstream results are ready. The initial build does not perform baseline input comparison, nor does it omit computation tasks for components that are not included in the required component set for display.

[0076] When a valid baseline report exists, the server first determines the complete set of components required for the build, and then determines the reuse or computation method for each component in the set. A component can only be marked as ready for the current round after all its necessary inputs and upstream results have been confirmed to be applicable to the target state of the current round.

[0077] When a valid baseline exists, query the event impact records for (b, s] to obtain directly changed components. Then, traverse the target dependency graph breadth- or depth-wise to record potentially affected components and dependencies, and deduplicate them using the visited set. Relationship changes are considered in conjunction with both old and new configurations; if configurations are incompatible, conservatively re-examine all components required for building. This stage only determines the scope to be checked, without directly setting all successors to require recalculation. Here, the interval (b, s] represents the range of events greater than the baseline sequence number b and not greater than the target sequence number s.

[0078] For components outside the potential impact range and with consistent definitions, rules, and scope, verify the valid baseline results, interval index integrity, and unchanged basis for all necessary inputs in topological order. Once reuse conditions are met, save the basis and mark them as ready. If the baseline results are invalid or the basis is insufficient, proceed to obtain supplementary basis or complete calculation under the target state. The remaining tasks proceed in topological order, with each task checking all inputs at once after all necessary upstream components are ready. For components without direct source inputs, their direct input checks are considered unchanged; components without upstream components start from the direct source state.

[0079] The server checks each required component for the baseline to ensure the existence of a valid baseline result. A valid baseline result is one whose complete payload can be read and whose applicability to the baseline report status can be confirmed through the original calculation records or reused data. Components appearing for the first time, components not included in the baseline report with no verifiable corresponding results, missing or corrupted payloads, or results whose applicability to the baseline status cannot be confirmed are all treated as having no valid baseline result.

[0080] For components without a valid baseline result, input equality comparisons based on that baseline result are not performed. After the target direct input and all necessary upstream results are complete, a complete calculation is performed according to the target calculation rules, and the input references, rule versions, and calculation results for this round are saved. This process applies to the initial construction of the entire report, as well as to the addition of components to an existing baseline report or when the baseline result becomes invalid.

[0081] When a new component is added to the target template or a new dependency relationship is added to the target dependency graph, the new component, the downstream components corresponding to the new relationship, and the necessary upstream components are included in this round of checks and task scheduling. New dependencies are not directly marked as unchanged inputs; the server confirms that the dependency relationship has been processed by verifying and calculating all inputs of the downstream components in the target state.

[0082] For components originally intended for reuse without relevant changes, if the baseline result is found to be invalid, the current reuse candidate status is cancelled and the process proceeds to full computation; the component is not directly set to ready. For components with missing baseline comparison criteria but complete target input, the target result can be obtained through full computation; if the target input cannot be obtained completely, the component remains not ready and related computations are paused, without replacing the failure result with a zero value or an empty result.

[0083] A unique task key is formed using the build identifier and component identifier. The scheduler scans for pending or expired tasks every 2 seconds, for example; upon claiming a task, the execution generation is increased; the lease example is 30 seconds, renewed every 10 seconds. Upon submission, the generation is updated based on matching conditions. Parameters can be adjusted according to task duration without affecting the fixed target sequence number. If a build is canceled, a new task is created without modifying the original build target and its results are reused.

[0084] S103, compare the actual inputs of the target and the baseline in the order of dependency, reuse the inputs and the results of components with unchanged rules, otherwise recalculate, and then check whether to continue updating by reading the downstream fields.

[0085] The server first waits for all upstream components of the current component to obtain results applicable to the target sequence number, and then prepares the actual inputs for the target and baseline according to the input configuration. This step includes determining the input source and obtaining the actual input, comparing input configurations, records and fields, verifying calculation rules, and summarizing comparison results. Components without upstream components directly check their source inputs. If any component does not have a valid baseline result, comparisons for which baseline values ​​cannot be obtained will not be performed. Complete calculations will be performed after the target input is complete.

[0086] For each input relationship, a valid reference to the baseline is saved. If the baseline component itself is reused, the input comes from the reuse basis of the baseline or a recoverable baseline state, tracing back to the original computational input. An unverified old input cannot be directly used as a baseline input. This round starts from... The scheduler saves explicit task-bound inputs and does not provide the latest status reading for the current round of upstream result reading.

[0087] Records without sequential semantics are arranged according to stable record identifiers. Records with sequential semantics are arranged using the configured business key and unique identifier as the final sorting key. When duplicate business objects exist, the unique record identifier is used to retain the duplicate count; the deduplicated set is not used to replace multiple records. Field sequences are arranged in the same record order. Numerical values ​​are represented using a fixed decimal or integer notation. Null values, missing fields, zero values, and empty strings are encoded differently; the normalization rules are included in the configuration version.

[0088] In this embodiment, the upstream is determined according to formula (1). Downstream Whether the actual input has changed. The equal sign in the formula indicates a deterministic equality comparison as specified in the configuration; strings are compared according to the saved unified encoding; numerical approximation thresholds are not used. The summary is only used to quickly identify differences; identical summaries are still checked against the actual normalized content.

[0089] (1) In equation (1), the upstream component is identified as Downstream components are identified as The baseline event number is The target event number is Input configuration version is The changes include variations in the fields read, selection criteria, or order rules. The actual set or sequence of records read is... Unordered inputs are sorted according to a stable identifier; ordered inputs retain the specified order. The number of fields read when the configuration is consistent is... , is a non-negative integer, and the field index is The value ranges from 1 to The first record after alignment with the record identifier. Field values ​​or value sequences are Subscript Indicates from component To Components Dependency relationships, superscript , These represent the baseline state and the target state, respectively. The indicator function is denoted as... The value is 1 if the condition is true, and 0 otherwise. The input change flag is... A value of 0 indicates no change, and a value of 1 indicates a change. Except for field values ​​compared according to their original type and unit, the above identifiers, serial numbers, and flags are dimensionless. Configuration and input come from component dependency records, actual input records, and ready results for this round.

[0090] The execution order is first comparison. The difference is And stop; then compare. The difference is And stop. Only when the configuration and recording sequence are the same, press the same... Item-by-item comparison This short-circuit execution definition prevents references to undefined fields when there are inconsistencies in the number of fields or missing records after configuration changes. . The spatiotemporal product is conventionally set to 1, but zero-field configuration is only allowed if the algorithm truly depends solely on record membership; if the record identifier itself is meaningless, it should be explicitly configured to form a single scalar input. If necessary comparison inputs are missing, corrupted, or not yet ready, equation (1) is not performed, and the corresponding input is first obtained or restored; if a valid baseline comparison input cannot be obtained but the target input is complete, the full calculation is performed; if the target input is incomplete, it remains pending inspection.

[0091] In this embodiment, the server also verifies the version of the component calculation rules. For sorting and selection inputs, selection is performed on all candidate records in both the target state and the baseline state. The order of values ​​with the same result is determined using a business sorting key and a unique record identifier. If the baseline already has a complete and verifiable selection record, that record can be used directly. If the configuration versions are inconsistent, the input change is directly determined, and the old fields are not forcibly interpreted according to the new configuration. If a complete range with no change is used, it should be confirmed that the event and its impact index cover (b,s] and that the configuration, rules, and range have not changed. Components reading event history must compare the event content and order. If the basis is missing, it is first supplemented or restored. If a valid baseline basis cannot be obtained but the target input is complete, a complete calculation is performed. If the target input is still incomplete, it remains pending inspection.

[0092] Before adopting a complete interval without related changes as a basis, the server verifies that the event records from the baseline sequence number b to the target sequence number s are continuous and complete, that the cutoff position of the index that has been continuously analyzed is not less than s, and verifies that the configuration on which the impact analysis is based is consistent with the configuration required for this round of judgment. If the component definition, calculation rules, or range definition are inconsistent, the unchanged basis will not be directly reused.

[0093] If the above integrity conditions are met, the server checks whether there are any events within the interval that affect the direct input, object selection, sorting, or association relationships of the current component, and confirms that all necessary upstream results have passed this round of verification; for components with upstream dependencies, evidence that the corresponding upstream read content has not changed should also be obtained. Reuse is only allowed when all necessary inputs have evidence of no change and there are valid baseline results.

[0094] When an index is missing, the configuration version is mismatched, or the scope of impact cannot be reliably determined, the server regenerates the impact information from the interval events, or directly obtains the baseline and the actual input under the target state for a complete comparison. If the comparison basis still cannot be completed but the target input is complete, the system proceeds to the complete calculation under the target state; if the target input is also incomplete, the task remains incomplete. The absence of an index entry itself does not constitute sufficient evidence that the input has not changed. The saved evidence of no relevant changes includes at least the range identifier, baseline sequence number, target sequence number, component identifier, input configuration and calculation rule version, interval coverage verification results, relevant event check results, and verification references to necessary upstream inputs for review before report release.

[0095] Direct source data is checked using the same configuration, object set, and field comparison method. For the same component, after all actual inputs are complete: reuse is performed if a valid baseline result exists, all direct and upstream inputs remain unchanged, and the component calculation rule version remains unchanged; calculation is performed only if any input or rule changes. If no valid baseline result exists, complete calculation is performed after the target input is complete. If only the upstream result identifier changes while the field value remains unchanged, it does not constitute a change in downstream input; even if the upstream has been recalculated, the fields read by each downstream component must be determined separately.

[0096] In this embodiment, valid scored answers within the K statistical range are counted only once for each record on the same knowledge point. Multiple answers to the same question are allowed, and each answer is counted separately using its unique identifier. If the product requires only the last answer to be counted, this selection rule must be a versioning rule, and changes to both the old and new selected records must be recorded. In this example, each answer is associated with only one knowledge point; migration of associations updates both the old and new knowledge points. Ability dimensions can be counted separately in the same way, with the same record counted only once for the same dimension.

[0097] For the number of valid and correct questions that can be increased or decreased according to the records, use equation (2a) to form the result to be verified, and then use equation (2b) to determine the final state. The two equations together constitute the statistical update equation (2). If the incremental condition is no longer met before the calculation, then (2a) is not executed, and the complete recalculation branch of (2b) is executed directly.

[0098] (2a) (2b) In equation (2), the baseline statistical state vector is denoted as Its two components are, in turn, the baseline number of valid questions. Baseline correct number of questions All are expressed in units of lines; the target statistical state vector is denoted as... With wavy lines n, c These represent the statistical vector, the number of valid questions, and the number of correct questions that still need to be verified after incremental calculation, respectively. The set of interval events affecting the current component is denoted as... This covers all events from baseline sequence number b to target sequence number s, with event index e. After deduplication using unique event sequence numbers, events are processed sequentially once. The record inclusion flag is denoted as e. a The superscripts - and + indicate the state before and after the event, respectively, and the subscripts... v,e Representation Component v China Event e The contribution of the corresponding record. A value of 1 is assigned if the record belongs to this component, is within the statistical period, is valid, and has been scored; otherwise, a value of 0 is assigned. The scoring flag is denoted as... qCorrect answers are assigned a value of 1, and incorrect answers are assigned a value of 0. Records that do not exist or are not included are uniformly assigned a value of q=0. The scores before and after the event are represented by superscripts - and +, respectively. Both the record inclusion flag and the score flag are dimensionless.

[0099] The record inclusion flag and the target record set for complete recalculation are determined according to the query definition and component statistical rules of this round, and the same statistical caliber is used. For situations where the contribution of affected records cannot be fully determined based on existing events, such as ranking selection, taking only the last answer, or related changes, this embodiment performs a complete recalculation.

[0100] Incremental precondition flag is denoted as Dimensionless, it is set to 1 only when the baseline intermediate state is confirmed as valid at baseline index b, the rules and contribution definitions remain unchanged, the interval events are complete, the old and new contributions are available, and each event is processed only once; otherwise, it is set to 0. The set of all valid scored records that should be included in component v under the target state is denoted as By scanning the target read-only source status The record index is r, and the correct identifier for the corresponding record is... The "other cases" in equation (2b) refer to cases other than the incremental branching condition. This includes cases where there is no baseline or rule change initially. =0, equation (2a) is not executed, and the entire calculation is performed directly without substituting missing values ​​into the formula. When the record set is empty, the summation is a zero vector.

[0101] New record old a =0, cancel new record a =0, when correcting, deduct the old contribution first and then add the new contribution. When transferring knowledge points, the new contribution is added to the old knowledge point. a =0, old knowledge points a =0. The count must be an integer and satisfy 0 ≤ number of correct questions ≤ number of valid questions; if not satisfied, the entire count must be recalculated without truncation. The baseline count can come from earlier calculations, but its complete intermediate state must have evidence to prove that there are no related changes. b It is still valid; the fact that the output ratio is the same is not enough to prove that the intermediate states are the same.

[0102] Complete recalculation in the same The validity and scope of each item are checked one by one, and the contribution is accumulated. If the historical source data itself is incomplete, the complete recalculation cannot be completed. The task should be paused and the failure result should not be used as a zero vector. Equation (2) is only used for the above counting and is not directly used for maximum value, ranking or irreversible model. When the statistical configuration changes, this embodiment directly recalculates the entire data and does not attempt undefined intermediate state transitions.

[0103] When K > 0, the ratio is obtained by dividing c by n and stored as a decimal value with agreed precision. In this example, it is displayed to four decimal places, and the rounding rule is to round to the nearest whole number. The grade is determined using an unrounded integer count: 5c < 2n is "weak", 2n ≤ 5c < 4n is "needs consolidation", and 5c ≥ 4n is "good". When n = 0, the ratio is empty and the grade is "no data available". When reading the ratio chart with four decimal places, only the displayed value is compared. When reading the component with precise counts, the counts must be compared to avoid confusion regarding precision.

[0104] In this embodiment, T generates fixed text based on knowledge point identifiers and levels: "Weak" corresponds to "It is recommended to review basic concepts first," "Needs consolidation" corresponds to "It is recommended to continue completing consolidation exercises," "Good" corresponds to "It is recommended to conduct extended exercises," and "No data available" corresponds to "Please complete the answers first." T does not insert proportions or question numbers into the text. If it is changed to output proportions, the proportions must be added to the input configuration so that changes in the proportions can trigger T calculations. G displays knowledge points on the horizontal axis and proportions on the vertical axis; D sorts and returns question identifiers and scores according to answer record identifiers; N directly reads the comment string.

[0105] Each task uses an independent copy of memory or a temporary table. Results, complete intermediate states, actual input references, and ready states are committed with the transaction. Before committing, bound inputs and execution generations are checked. Failures result in discarded copies, and retries begin from the complete baseline. If batch checkpoints are used, intermediate states and processed sequence numbers must be saved atomically; separate saving is prohibited to avoid duplicate application of events.

[0106] When reusing data, the basis for reuse should be recorded, including the target number s and the baseline report. The old result identifiers, rule versions, and comparison records or complete intervals remain unchanged. Historical component result records retain their original calculation sequence numbers and original inputs. For intermediate counting states, they are only reused if all inputs affecting the contribution remain unchanged; if the displayed results are exactly the same after recalculation, the new intermediate state or its equivalent is preserved, and the erroneous counting is not used based on the displayed summary. Each ready result then triggers an outbound edge check until all correlations are processed.

[0107] After the current component's calculation or reuse results are ready, the following steps are executed. The comparison object is the actual content read by each downstream component, not the upstream result identifier. When the downstream input configuration changes, the input change branch is entered directly; when the upstream baseline result does not exist and a valid comparison basis cannot be obtained, a complete calculation is performed after the target input of the relevant downstream component is complete, and undefined baseline comparisons are not performed. This process is not limited to the initial construction of the entire report.

[0108] The server first compares the input configuration versions of the current component or current input relationship in the baseline state and the target state. If the configuration versions are different, it directly determines that the corresponding input has changed, without comparing fields item by item based on the old and new configurations, and without requiring the old input to be converted to the input under the new configuration; after the input required by the target configuration is complete, the server performs the complete calculation in the target state.

[0109] When the configuration versions are the same, the identifiers of the actually selected records, the order of records with input significance, and the actual field values ​​read are compared according to the configuration. If all comparison items are the same, the input relationship is determined to be unchanged; if any comparison item is different, the input relationship is determined to be changed. If the configuration versions are the same but the necessary comparison basis is missing, damaged, or not yet obtained, the determination that the input has not changed is not made temporarily, and the basis is kept pending inspection and supplementation. If a valid baseline basis cannot be obtained but the target input is complete, the complete calculation is performed according to the baseline unavailable branch; if the target input is not yet complete, the process waits for the target input to be ready. Even if all inputs are the same, the baseline result cannot be directly reused if the calculation rule version is different. This embodiment performs a complete calculation when the input configuration or calculation rule version changes, and does not use the incremental intermediate state formed based on the original configuration or original rules.

[0110] For dependencies with changing inputs, the corresponding downstream components are included in the check set and deduplicated; for dependencies with unchanged inputs, downstream recalculation is not triggered due to the current component recalculation, and the check tasks caused by other inputs or rule changes are retained; when the same downstream component is included in the check set through multiple dependencies, the current build identifier and component identifier are used for deduplication.

[0111] Perform the above steps on the components to be checked, and continue to check their downstream dependencies, summarizing the component results, reuse basis, and dependency check status. Based on their direct source inputs, other upstream inputs, and calculation rules, determine whether to reuse or recalculate; reuse is only performed if all actual inputs and calculation rules remain unchanged and a valid baseline result exists; otherwise, recalculate after all inputs are complete. If there are incomplete dependency checks or necessary components for which valid results have not yet been obtained, the report publishing operation will not proceed.

[0112] Determining that the input for a dependency has not changed only indicates that the downstream does not require recalculation for that dependency; it does not cancel the pending inspection tasks caused by changes in direct source data, other upstream components, or computation rules. Components added to the pending inspection set in step S102 must still complete all input checks. Changes in configuration, record selection, or order rules are handled according to step S103; unchanged results also retain the dependency check status for this round. After all processing is complete, a unified verification will be conducted subsequently; a report cannot be issued solely based on the fact that a single dependency has not changed.

[0113] The dependency check records distinguish between states such as unchanged after comparison, changed after comparison, baseline unavailable but calculation completed according to target input, and incomplete processing. Relationships where the baseline is unavailable but downstream has completed target input verification and calculation are considered completed and are no longer included in the incomplete dependency set; this state is not used as a basis for input unchanged or allowed reuse.

[0114] S104, verify all necessary component results and reuse basis, and after the dependency check is completed, atomically release a report list containing target sequence numbers and result references.

[0115] Get the required set based on the target template Each result is verified to be valid, the payload is complete, and the access permissions are consistent. The applicability of the target is verified in topological order: new results are checked. The inputs for rules and tasks must be consistent with the actual task inputs; input comparison reuse results must check that all inputs remain unchanged and the upstream is valid; interval reuse results must check that the index is complete, there are no related events, and the configuration is consistent. Baseline reuse chains can point to historical evidence, but the chain must start from a complete computation or a complete snapshot, and circular self-verification is not allowed.

[0116] The release verification uses the set of necessary components as the object of the report integrity check, and recursively verifies all its upstream dependencies. If any necessary upstream component is not ready or the target applicability fails the verification, the display-required components that depend on that upstream component must fail the consistency check. The report list may only list the components required for display and access, but the build record should save the result references and verification basis of the necessary upstream components. The consistency check pass flag for the display-required components in Equation (3) includes the verification results of all the above-mentioned necessary upstream dependencies.

[0117] Release is only initiated after all dependencies affecting essential components have been checked. This embodiment includes dependencies pending inspection, those that failed to be checked due to calculation failures, and those based on missing dependencies. Each relationship is counted using deduplicated identifiers based on its construction and upstream / downstream components. Upon successful recovery, the corresponding relationship is removed from the incomplete set, rather than blindly decrementing a counter. While failure due to the absence of an upstream component may not necessarily increase the relationship count, it will cause the consistency check of the required display component or its dependent components to fail; when a display result is directly missing, its result integrity flag is 0.

[0118] (3) In equation (3), the set of necessary components determined by the target template is: Let be a finite non-empty set, and the number of components in the set is | |; The component index is v, and the result is fully readable. The consistency check under target sequence number s passed with the flag set to Both can only take the value 0 or 1; the number of incomplete or failed dependencies is... , is a non-negative integer. The current report identifier is within the range of . The baseline report is identified as The current activity is identified as follows: This round of construction is identified as The subscript 'cur' indicates the current state, 'b' represents the baseline, and 's' represents the target for this round. The publish permission flag is... Publishing is allowed when the value is 1 and not allowed when the value is 0; the indicator function 1(·) is 1 when the condition is true and 0 otherwise. All identifiers and flags are dimensionless. During the initial build, the baseline report identifier and the current report identifier are both empty, and their equality comparison is valid; if the target template does not have the required components, the build is rejected and the empty set condition is not used for publishing.

[0119] In formula (3), the current report, baseline report, and activity build identifier are all verified within the combination of the same scope identifier and query identifier; the results and reuse criteria of each component must also conform to the query definition. The target sequence number in the formula is still the event sequence number corresponding to the predefined report scope.

[0120] The server first completes the result verification, then sets the status of this round of tasks to pending release, prohibiting worker threads from rewriting the verified content. The release transaction locks the report range record, the corresponding query status record, and the report construction record row and verifies their version, and re-verifies the report, activity construction, L, G, and U in formula (3). All results and reuse basis records are immutable records, and changes to the task status must be checked by the report construction record status, so that the conditions do not drift during the check and submission.

[0121] Within the same transaction, the report list is saved, the current report identifier (corresponding to the combination of scope identifier and query identifier) ​​is updated, the report build record is set to published, and the activity pointer is cleared. The report list saves the mapping from scope identifier, query identifier, normalized query definition, s, template version, component identifier to result identifier, and reuse basis record, and saves the original calculation sequence number of each result. If it fails, it rolls back and continues to provide the original report. A notification is sent upon successful submission; if the notification is lost, the client compensates by querying the current identifier every 10 seconds, for example.

[0122] S105, the teacher client switches the displayed content and report identifier according to the list as a whole, and the server returns details according to the target sequence number corresponding to the report identifier.

[0123] After obtaining the list, the teacher client accesses the cache based on the result identifier and summary. If the cache is not found, a specified result is requested, and the server verifies that the result belongs to the report and that the teacher has the access rights. If the summary is different, it is downloaded again. The client does not directly fill the old report with the latest result of a certain service. All necessary components are prepared in an independent memory object and an invisible document container, and the scope identifier, report identifier, and query conditions for this round of reports are set for all components, including reusable components. If a component contains links that change with the report, they should be generated as client query bindings, and the old report identifier should not be fixed in the reusable text. The old report is still displayed when not all components are ready.

[0124] During a single UI state submission, the client replaces the root container and switches the currently displayed report identifier, the current report range identifier, the query identifier, and the report generation. Candidate reports are loaded using independent generations; a delayed download of an older candidate report cannot overwrite a newer one. Therefore, older reports can still be used normally until the entire new report is switched over. This submission makes the identifier for the prepared report the currently displayed report identifier, and subsequent detail requests retrieve the report identifier and bound query parameters from this display state. On the first load when there are no older reports, a waiting state is displayed, and incomplete reports are not shown.

[0125] The teacher client responds to the user's detailed query operation by sending a detailed query request to the server, carrying the identifier of the currently displayed report. The detailed query request includes the report identifier, component identifier, filter criteria, view identifier, request sequence number, and pagination cursor. The server parses the scope identifier, query identifier, normalized query definition, and 's' from the report list to read or reconstruct the data. The query is performed within the defined data range and based on stable record identifiers. Additional filters should not expand the report range. The cursor is bound to the report, filter conditions, and last sort position; the target sequence number remains unchanged on subsequent pages. Different parallel views maintain their own request sequence numbers; these numbers are incremented when a query is replaced within the same view. When the server returns details, it also returns the corresponding report identifier, query view identifier, and request sequence number for the teacher's client to perform matching verification.

[0126] In this embodiment, the returned result must simultaneously match the current range, report, view, and request sequence number; otherwise, it will be discarded. Even if the original calculated sequence number of a reused text is 100, when it is referenced by report 102, its detailed query will also use 102. The original calculation time of a component cannot be used as the cutoff position for the current report details. If historical states cannot be recovered, an expired or unavailable state will be returned, without modifying the latest data.

[0127] After completing the above steps, check the current report, activity builds, retention period reports, and references to valid read leases before cleaning up the history. Clients can request, for example, a 10-minute read lease and renew it. If the retention period expires and there are no references, clean up the lease; expired requests are explicitly returned. Permanent exports need to save the displayed data and detailed snapshots. For continuously updating queries, if head_seq > s after publication, start the next round of tasks from the newly published report; temporary queries only fix the new target sequence number and start the build when a refresh is requested again.

[0128] The server manages the lifecycle of temporary queries and predefined reporting scopes separately. If a temporary query is not accessed within its set validity period and there are no active builds, retention reports, or valid read lease references, its query records, build records, and unreferenced results can be cleaned up without affecting the source data snapshots and event sequences of the predefined reporting scope.

[0129] Once a predefined reporting scope is explicitly deactivated, it will no longer accept new build requests. After all its active builds are completed or canceled, the scope is removed from the subsequent event receiving set through the same transaction mutex entry as the source change registration, and the cutoff sequence number at the time of cessation of receiving is saved. Snapshots, events, and results still referenced by the report are retained until the references are released. When continuous updates are resumed later, a new scope identifier is reinitialized, and the original event sequence that has been interrupted is not directly used.

[0130] As can be seen from the above embodiments, this embodiment establishes dependencies between the actual input fields of the report components. When upstream data changes, it compares the target and baseline actual inputs component by component in dependency order. For components with valid baseline results and all necessary inputs and calculation rules unchanged, it reuses existing results. For components with changed inputs or calculation rules, it performs calculations. For components lacking valid baseline results, it performs complete calculations, avoiding the computation and transmission overhead caused by full recalculation. At the same time, it uses the published report as the baseline to fix the target event sequence number and restore the corresponding data. After verifying all necessary component results and reuse basis, it atomically publishes the report list. The teacher's client switches the displayed content and report identifier according to the list, ensuring that charts, explanatory text, and detailed access always correspond to the same data cutoff position. This solves the problems of inconsistent data in different areas when multiple components are generated asynchronously and the problem of clicking on an old report returning the latest details.

[0131] Example 2 Corresponding to the above embodiments, this application also provides an embodiment of a consistent generation system for student learning visualization analysis reports under asynchronous update conditions.

[0132] See Figure 4 The learning progress visualization analysis report consistency generation system 20 under asynchronous update conditions provided in this embodiment includes: The event logging module 201 is used by the server to record source data change events and configuration change events that affect report generation, and to establish the dependencies of the actual input fields of the report components.

[0133] The baseline recovery module 202 is used to fix the target event number, and when there is a published report, use it as the baseline to restore the target data and identify the components to be inspected.

[0134] The comparison reuse module 203 is used to compare the actual inputs of the target with the baseline in the order of dependencies, reuse the inputs and the results of components whose rules have not changed, otherwise recalculate, and then check whether to continue updating by reading the downstream fields.

[0135] The verification and release module 204 is used to verify the results of all necessary components and the basis for reuse. After the dependency check is completed, it atomically releases a report list containing the target sequence number and result reference.

[0136] The details return module 205 is used by the teacher client to switch the displayed content and report identifier according to the list as a whole, and the server returns the details according to the target sequence number corresponding to the report identifier.

[0137] It should be noted that the specific content involved in the embodiments of this application can be found in the description of the above method embodiments, and will not be repeated here for the sake of brevity.

[0138] Example 3 Corresponding to the above embodiments, this application also provides a computer-readable storage medium, wherein the computer-readable storage medium may store a program, wherein when the program runs, it can control the device where the computer-readable storage medium is located to execute some or all of the steps in the above method embodiments. In specific implementation, the computer-readable storage medium may be a magnetic disk, an optical disk, read-only memory (ROM), or random access memory (RAM), etc.

[0139] Example 4 Corresponding to the above embodiments, this application also provides a computer program product containing executable instructions that, when executed on a computer, cause the computer to perform some or all of the steps in the above method embodiments.

[0140] In this application embodiment, "at least one" refers to one or more, and "more than one" refers to two or more. "And / or" describes the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent the existence of A alone, the simultaneous existence of A and B, or the existence of B alone. A and B can be singular or plural. The character " / " generally indicates that the preceding and following related objects have an "or" relationship. "At least one of the following" and similar expressions refer to any combination of these items, including any combination of single or plural items. For example, at least one of a, b, and c can represent: a, b, c, ab, ac, bc, or abc, where a, b, and c can be single or multiple.

[0141] Those skilled in the art will recognize that the units and algorithm steps described in the embodiments disclosed herein can be implemented using electronic hardware, computer software, or a combination of electronic hardware and software. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this application.

[0142] Those skilled in the art will understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0143] In the several embodiments provided in this application, any function, if implemented as a software functional unit and sold or used as an independent product, can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this application. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0144] The above description is merely a specific embodiment of this application. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the protection scope of this application. The protection scope of this application should be determined by the protection scope of the claims.

Claims

1. A method for generating consistent learning progress visualization analysis reports under asynchronous update conditions, characterized in that, include: The server records source data change events and configuration change events that affect report generation, and establishes dependencies on the actual input fields of the report components; Fixed target event sequence number, using it as the baseline if a published report exists, to restore target data and identify components to be inspected; Compare the actual inputs of the target and the baseline in the order of dependencies, reuse the inputs and the results of components with unchanged rules, otherwise recalculate, and then check whether to continue updating by reading the downstream fields respectively; Verify all necessary component results and reuse basis, and after the dependency check is completed, atomically release a report list containing target sequence numbers and result references; The teacher's client switches the displayed content and report identifiers according to the list, and the server returns details according to the target sequence number corresponding to the report identifier.

2. The method for generating consistent learning progress visualization analysis reports under asynchronous update conditions according to claim 1, characterized in that, The server records source data change events and configuration change events that affect report generation, including: Determine the predefined reporting scope based on the student or class set, course, data storage time boundary and data visibility range, and assign a unique scope identifier to each predefined reporting scope; Map temporary filtering conditions that can be fully covered by the predefined report range to the predefined report range, register the corresponding query identifier, and share the snapshot and event sequence of the predefined report range; When the data boundaries of a predefined reporting scope change, a new reporting scope is established and a new scope identifier is assigned. Receive source data change requests or configuration change requests. The configuration change requests are used to change the input configuration, calculation rules or report template of the change report component. Perform duplicate submission checks and version consistency checks on the received change requests. For change requests that pass the inspection, determine the scope of registered reports affected based on the status before and after the change; Within the same transaction, update the corresponding source data or configuration and its version, sequentially assign consecutive event numbers within each affected report range, and save the change events associated with the corresponding range identifier. The change events include event type, change object identifier, values ​​before and after the change, corresponding version, and event number. Within the transaction, the submission deadline number of each affected reporting scope is updated to the event number assigned in this transaction; if the transaction fails, the update and save operations within the transaction are rolled back as a whole.

3. The method for generating consistent learning progress visualization analysis reports under asynchronous update conditions according to claim 2, characterized in that, The dependency relationships for establishing the actual input fields of the reporting component include: Register the source object types and value fields directly input by each component, upstream components and their output fields, as well as the conditions and fields that determine the selection, sorting and association of input objects, and register the precision, null value rules and configuration version; Each round of construction obtains actual input from the target source data state and the upstream results applicable to the target source data state, based on the registration configuration corresponding to the target event sequence number. Check for circular dependencies among components; if no circular dependencies exist, determine the topology execution order of the components; if circular dependencies exist, refuse to enable the corresponding component dependency configuration and output the identifier of the component involved in the circular dependency. By providing only the registered input through a unified input interface, the impact of old and new associations is registered simultaneously for association migration, and the impact of all candidate data on the selection result is registered for the component of the selected ranking object.

4. The method for generating consistent learning progress visualization analysis reports under asynchronous update conditions according to claim 1, characterized in that, The fixed target event sequence number, if a published report exists, is used as a baseline to restore target data and identify components to be inspected, including: Lock the report range record and the status record of the corresponding query, and save the baseline report identifier of the same range identifier and query identifier combination; The current submission deadline number is fixed as the target number and a build task is registered. Only one active build task is retained for the same combination of range identifier and query identifier. Read a complete snapshot no later than the target sequence number, apply subsequent events sequentially to the target sequence number, and restore the data state including the source data and configuration; Query the events and impact information within the range from the baseline to the target, mark the directly affected components, and mark the components to be inspected along the dependencies.

5. The method for generating consistent learning progress visualization analysis reports under asynchronous update conditions according to claim 3, characterized in that, The process involves comparing the actual inputs of the target and baseline in dependency order, reusing the inputs and results of components with unchanged rules, otherwise recalculating, and then checking whether to continue updating by reading downstream fields, including: After the required upstream results are ready, compare the actual inputs and computation rules of the current component in the target state with those in the baseline state, according to the component dependency order. If the actual input and calculation rules remain unchanged and a valid baseline result exists, reuse the result and save the basis for reuse; otherwise, recalculate after the input is complete and save the result and the corresponding input information. Based on the results, check the changes in the actual content read by each downstream component, and repeat the process in combination with other inputs and calculation rules until all components to be checked obtain results applicable to the target sequence number.

6. The method for generating consistent learning progress visualization analysis reports under asynchronous update conditions according to claim 5, characterized in that, The step of comparing the actual input and computation rules of the current component in the target state with the baseline state after the required upstream results are ready according to the component dependency order includes: Based on the input configuration, determine the source data and upstream results that the current component directly reads, and obtain the actual input corresponding to the target state and the baseline state; The system compares the input configuration, the selected record, and the actual fields read in sequence. If any item is different, the corresponding input is determined to have changed. When record selection or sorting is involved, the system performs the comparison after selection or sorting in the corresponding state. Verify the calculation rules and summarize the comparison results of each input. If the comparison basis is incomplete, keep it pending inspection. If there is a complete range with no relevant changes and the configuration, rules and range have not changed, determine that the input and rules have not changed.

7. The method for generating consistent learning progress visualization analysis reports under asynchronous update conditions according to claim 5 or 6, characterized in that, If the actual input and calculation rules remain unchanged and a valid baseline result exists, the result is reused and the basis for reuse is saved; otherwise, the calculation is recalculated after the input is complete, and the result and corresponding input information are saved, including: When the reuse conditions are met, the effective baseline results are associated with the target sequence number of this round, the original calculation information is retained and the basis for reuse is saved; If the reuse conditions are not met, the computation task is bound to the target state and the required upstream results; for statistical components that support incremental computation, incremental computation is performed if the incremental basis is complete and the rules remain unchanged, otherwise the entire computation is recalculated. Verify the validity of the actual input and task corresponding to the calculation results. If the verification is successful, save the results, calculation status and input information in a unified manner. If the verification fails, reject the submission.

8. The method for generating consistent learning progress visualization analysis reports under asynchronous update conditions according to claim 7, characterized in that, Based on the obtained results, the changes in the actual content read by each downstream component are checked, and this process is repeated in conjunction with other inputs and calculation rules until all components to be checked obtain results applicable to the target sequence number, including: Based on the input configuration of each downstream component, compare the content actually read from the current component's target result with the baseline result, and record the input change status of each dependency. For dependencies with changing inputs, the corresponding downstream components are included in the set to be checked and deduplicated; for dependencies with unchanged inputs, downstream recalculation is not triggered due to the recalculation of the current component, and the tasks to be checked caused by other inputs or rule changes are retained. Continue to check the downstream dependencies of the components under inspection, and summarize the component results, reuse basis and dependency inspection status.

9. The method for generating consistent learning progress visualization analysis reports under asynchronous update conditions according to claim 8, characterized in that, The verification of all necessary component results and reuse basis will be completed after the dependency check is finished, and a report list containing target sequence numbers and result references will be released atomically, including: List the necessary components for display according to the target template, identify all necessary upstream components, and check the completeness of the results, the actual input of the new results, and all the reuse basis of the reused results in the order of dependency. The number of pending or failed dependencies affecting essential components is confirmed to be zero; In the publishing transaction, confirm that the current report with the same range identifier and query identifier combination is still the baseline report and the activity construction is still the current round task, while saving the immutable report list, updating the current report reference and construction status; continue to provide the previous complete report when the check or transaction fails.

10. The method for generating consistent learning progress visualization analysis reports under asynchronous update conditions according to claim 1, characterized in that, The teacher client switches the displayed content and report identifiers according to the overall list, and the server returns details according to the target sequence number corresponding to the report identifier, including: The teacher client obtains the report list, loads or reuses the component results based on the results, assembles the report to be displayed, and binds the report identifier and query parameters corresponding to the report list to each component. After all necessary components are prepared, switch to the report to be displayed and set its report identifier to the currently displayed report identifier; The teacher's client responds to a detailed query operation for the currently displayed report by generating a detailed request that includes the identifier of the currently displayed report, query parameters, and request number. The server responds to the detail request, determines the target sequence number based on the report identifier, queries the details under the corresponding target status, and returns the query result along with the report identifier and the request sequence number; The teacher client verifies the report identifier and request sequence number of the returned result, and only displays the details if they match the currently displayed report identifier and the latest request sequence number of the corresponding query view, otherwise the result is discarded.

Citation Information

Patent Citations

  • Student ability profiling method, learning resource recommendation method and device

    CN114254127B

  • Method for updating materialized view and electronic device

    CN117194445B