Business unit intelligent content version management method and control system

Abstract

The invention discloses a business unit intelligent content version management method and a control system, and belongs to the technical field of Internet. The method comprises the following steps: constructing a template execution unit; generating a template execution unit mirror image of the template execution unit; compressing the template execution unit mirror image to obtain a mirror image compressed file; decompressing the mirror image compressed file to obtain an execution unit; and updating the execution unit. According to the method, storage occupation can be reduced, timeliness can be improved, optimization and innovation are made in combination with services in the aspects of mirror image generation and initialization updating algorithms, and compared with a traditional method, the overall timeliness is improved by 30%. The generation of the mirror image of the execution unit technically uses a json character string in combination with a zip compression algorithm, and a special data structure is generated in combination with business data characteristics when json data is generated, so that the process of restoring the mirror image data into original data is greatly simplified.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to a business unit intelligent content version management method and control system. Background Art

[0002] As the company's business grows, more and more execution units need to be developed. The existing execution unit development process is troublesome and cumbersome, and it is impossible to carry out secondary development on the already developed execution units. It is necessary to manually copy the repeated parts and upgrade and optimize them. The previous complex process needs to be repeated. A large amount of such repetitive work leads to a great waste of manpower and material resources. In addition, the technical ability of developers is required to be high. They need to understand all relevant development technologies to fully develop a usable execution unit, which also leads to high employment costs.

[0003] Previously, when the system generated a new execution unit (differentiated by work area), it was necessary to first create the execution unit shell, create a digital human, bind the digital human to the device, execute the unit data, dashboard, job organization structure, execution unit parameters, worksheets, modules, worksheet parameters, bind worksheets, etc. Among them, the device is the lowest-level working device, the digital human is a logical concept, the module is a script running on the device, the worksheet is the manager of the module, responsible for assigning the module to each device for execution, the position is a logical concept, and the execution unit is a large unit that manages all positions. The system is composed of execution units one by one. With the growth of the company's business, more and more execution units need to be developed. The development efficiency of execution units on the existing system has become a bottleneck restricting the company's development. Summary of the invention

[0004] The purpose of the present invention is to provide a business unit intelligent content version management method and control system. As an execution unit development platform, developers can first create execution unit templates and publish different versions of the templates. Low-level developers can reference these templates to quickly generate available execution units according to the versions. This reduces the development of complex processes, reduces repetitive work, saves manpower and material resources, lowers the technical threshold of developers, and reduces employment costs.

[0005] In order to solve the above technical problems, the present invention provides a business unit intelligent content version management method, comprising the following steps:

[0006] Build template execution unit;

[0007] Generate a template execution unit image of the template execution unit;

[0008] Compressing the template execution unit image to obtain an image compression file;

[0009] Decompress the image compressed file to obtain an execution unit;

[0010] Update the execution unit.

[0011] Preferably, compressing the template execution unit image to obtain an image compression file specifically includes the following steps:

[0012] Compress the template execution unit image into a json string;

[0013] Compress the json string into a zip package using the zip compression algorithm;

[0014] Save the zip file in a mongodb database in binary form.

[0015] Preferably, the template execution unit includes a working module, a statistical module and a setting module;

[0016] The work module includes position information, work table information, module information, configuration information, and input and output table data;

[0017] The statistics module includes dashboard, global data and shared data permissions;

[0018] The setting module includes setting information.

[0019] Preferably, the template execution unit image includes a position image, a work table image, a module image, a configuration information image, an input and output table data image, a shared data authority image, a global data image, a dashboard image and a setting information image.

[0020] Preferably, the method further comprises the following steps:

[0021] For job mirroring, the self-associative tree structure data in the mongodb database is converted into parent-child tree structure data in json format;

[0022] For worksheet images and module images, generate a json string with description information and associated information, compress the script code into a txt document through the zip algorithm and save it in the file server, and associate the file index information through the filename_zip field in the json string;

[0023] For input and output table data, table metadata and table data are separated to generate mirror information, and table metadata and table data are associated through tableId;

[0024] For global data, data sets, and dashboard data, the uniqueness of the data is determined by gradually decoupling the associated ID and data and adding two additional fields: data ID + execution unit ID.

[0025] Preferably, decompressing the image compressed file to obtain the execution unit specifically includes the following steps:

[0026] Decompress the zip package to get a json string;

[0027] Deserialize the json string to get the execution unit.

[0028] Preferably, updating the execution unit specifically includes the following steps:

[0029] Each execution unit's update thread starts a separate transaction;

[0030] Update the execution unit in the transaction;

[0031] When all update threads of all execution units have run successfully, all transactions are committed.

[0032] Preferably, updating the execution unit in a transaction specifically includes the following steps:

[0033] The originId field in the data is used to link the data in the image of the template execution unit of different versions. The position data is updated to replace the position and the position-bound worksheet with the data in the image, and the position configuration information is retained.

[0034] Preferably, the operation of the mongodb database adopts the mongoTemplate framework.

[0035] The present invention also provides a business unit intelligent content version management and control system, comprising:

[0036] Create a module to build a template execution unit;

[0037] An image generation module, used to generate a template execution unit image of the template execution unit;

[0038] A compression module is used to compress the template execution unit image to obtain an image compression file;

[0039] A decompression module is used to decompress the image compressed file to obtain an execution unit;

[0040] The update module is used to update the execution unit.

[0041] Compared with the prior art, the present invention has the following beneficial effects:

[0042] 1. Lower the technical threshold: With the growth of business, the development volume of execution units is getting larger and larger. In the previous development method, each execution unit needs to be fully developed from beginning to end, and each developer needs to understand the complete development process and full-stack technology, which has high technical requirements. Through the present invention, a new execution unit can be created based on the execution unit template image, so that only a small number of high-tech developers are needed to develop the execution unit template image, and the technical requirements for developers who create execution units through template images are greatly reduced, which greatly reduces the company's operating costs.

[0043] 2. Simplify the development method to improve efficiency: The previous development method is to develop and use, and develop an execution unit process. Although a certain code reuse (worksheet module script) is achieved, the peripheral structural framework still needs to be redeveloped for the execution unit. Each newly added execution unit needs to do such an operation. With the large-scale growth of business, more and more execution units are developed. Such a development method has become complicated. The present invention further extracts and generates images from duplicate codes, allowing developers to directly generate an execution unit through the image, and only needs to adjust the parameters appropriately to develop a complete execution unit. For developers, this greatly simplifies the development method. For an identical execution unit, it takes about a day or even longer to develop a similar execution unit. Through the same operation of the present invention, you only need to click the generate button through the execution unit template created in advance, and generate the execution unit with one click. After adjusting the personalized parameters, the entire development process is completed, and the time is only within an hour, which is reduced by dozens of times.

[0044] 3. Reduce storage occupancy and improve timeliness: The present invention has made optimization and innovation in the generation of images and the initialization update algorithm in combination with the business, which has a 30% improvement in overall timeliness compared to traditional practices. The execution unit image is generated technically using a json string combined with a zip compression algorithm. First, when generating a json string, the first data compression is performed by combining the business characteristics. The json string after the first compression is further compressed by the zip compression algorithm, so that the final generated image data is only 50% of the original data size. In order to quickly restore the image data, a special data structure is generated in combination with the business data characteristics when generating json data, which greatly simplifies the process of restoring the image data to the original data.

[0045] 4. Improve Data Security:

[0046] (1) Transaction control of massive data modification: Although there is no direct hard limit on the amount of data in a mongodb transaction, the excessive amount of data involved in the transaction may cause the transaction execution time to be too long, thereby affecting performance. If the transaction involves a large number of write operations, it may affect the cache usage of WiredTiger, and thus affect the performance of the transaction. There may be hundreds of thousands of data modifications and insertions in the input and output tables. At this time, the pressure on the database may cause the database to crash. Therefore, the present invention adopts the method of final data consistency. The massive data to be modified is first pushed to the message queue. The transaction control of the message queue ensures that the data update instructions are accurately issued. By testing rabbitMq, it can easily support the push of hundreds of thousands of data. Then, the real data update operation is slowly executed through the message consumer. Through the retry mechanism, the abnormal log is recorded, and finally the manual backup is performed to ensure the final consistency of the data, and the timeliness is also improved to a certain extent.

[0047] (2) Transaction control under multi-threading in spring environment: In order to improve the efficiency of batch update execution unit under the execution framework, multi-thread execution update operation is designed. When the development environment is in spring environment, database transactions are restricted to the same thread, which becomes a problem when controlling multi-threaded transactions. The present invention uses heap memory as a medium for communication between threads. When multiple threads all meet the transaction submission conditions, a unified transaction submission operation will be performed. The specific implementation process is as follows: Before the multi-threaded transaction starts, a counter is added to the heap memory to record the number of threads and the error mark. Whenever a thread meets the transaction submission conditions, the counter will be subtracted by 1, and then the counter will be continuously monitored to see if it is 0 and if the error mark is true. Only when the counter is 0 will the transaction submission operation be performed, otherwise the transaction will be rolled back if it times out or the error mark is true.

[0048] The (1) solution ensures the data security of the execution unit when it is updated, and also improves the timeliness of the update to a certain extent; (2) the multi-threading ensures the timeliness of the batch execution unit update and improves the data security. BRIEF DESCRIPTION OF THE DRAWINGS

[0049] The specific implementation modes of the present invention are further described in detail below with reference to the accompanying drawings.

[0050] Figure 1 It is a flow chart of a method for intelligent content version management of a business unit according to the present invention. DETAILED DESCRIPTION

[0051] Many specific details are set forth in the following description to facilitate a full understanding of the present invention. However, the present invention can be implemented in many other ways than those described herein, and those skilled in the art can make similar generalizations without violating the connotation of the present invention, so the present invention is not limited to the specific implementation disclosed below.

[0052] The terms used in one or more embodiments of this specification are only for the purpose of describing specific embodiments, and are not intended to limit one or more embodiments of this specification. The singular forms of "a", "said" and "the" used in one or more embodiments of this specification and the appended claims are also intended to include plural forms, unless the context clearly indicates other meanings. It should also be understood that the term "and / or" used in one or more embodiments of this specification refers to and includes any or all possible combinations of one or more associated listed items.

[0053] It should be understood that although the terms first, second, etc. may be used to describe various information in one or more embodiments of this specification, this information should not be limited to these terms. These terms are only used to distinguish the same type of information from each other. For example, without departing from the scope of one or more embodiments of this specification, the first may also be referred to as the second, and similarly, the second may also be referred to as the first. Depending on the context, the word "if" as used herein may be interpreted as "at the time of" or "when" or "in response to determining".

[0054] The present invention is further described in detail below in conjunction with the accompanying drawings:

[0055] The present invention provides a business unit intelligent content version management method, comprising the following steps:

[0056] Build template execution unit;

[0057] Generate a template execution unit image of the template execution unit;

[0058] Compressing the template execution unit image to obtain an image compression file;

[0059] Decompress the image compressed file to obtain an execution unit;

[0060] Update the execution unit.

[0061] Preferably, compressing the template execution unit image to obtain an image compression file specifically includes the following steps:

[0062] Compress the template execution unit image into a json string;

[0063] Compress the json string into a zip package using the zip compression algorithm;

[0064] Save the zip file in a mongodb database in binary form.

[0065] Preferably, the template execution unit includes a working module, a statistical module and a setting module;

[0066] The work module includes position information, work table information, module information, configuration information, and input and output table data;

[0067] The statistics module includes dashboard, global data and shared data permissions;

[0068] The setting module includes setting information.

[0069] Preferably, the template execution unit image includes a position image, a work table image, a module image, a configuration information image, an input and output table data image, a shared data authority image, a global data image, a dashboard image and a setting information image.

[0070] Preferably, the method further comprises the following steps:

[0071] For job mirroring, the self-associative tree structure data in the mongodb database is converted into parent-child tree structure data in json format;

[0072] For worksheet images and module images, generate a json string with description information and associated information, compress the script code into a txt document through the zip algorithm and save it in the file server, and associate the file index information through the filename_zip field in the json string;

[0073] For input and output table data, table metadata and table data are separated to generate mirror information, and table metadata and table data are associated through tableId;

[0074] For global data, data sets, and dashboard data, the uniqueness of the data is determined by gradually decoupling the associated ID and data and adding two additional fields: data ID + execution unit ID.

[0075] Preferably, decompressing the image compressed file to obtain the execution unit specifically includes the following steps:

[0076] Decompress the zip package to get a json string;

[0077] Deserialize the json string to get the execution unit.

[0078] Preferably, updating the execution unit specifically includes the following steps:

[0079] Each execution unit's update thread starts a separate transaction;

[0080] Update the execution unit in the transaction;

[0081] When all update threads of all execution units have run successfully, all transactions are committed.

[0082] Preferably, updating the execution unit in a transaction specifically includes the following steps:

[0083] The originId field in the data is used to link the data in the image of the template execution unit of different versions. The position data is updated to replace the position and the position-bound worksheet with the data in the image, and the position configuration information is retained.

[0084] Preferably, the operation of the mongodb database adopts the mongoTemplate framework.

[0085] The present invention also provides a business unit intelligent content version management and control system, comprising:

[0086] Create a module to build a template execution unit;

[0087] An image generation module, used to generate a template execution unit image of the template execution unit;

[0088] A compression module is used to compress the template execution unit image to obtain an image compression file;

[0089] A decompression module is used to decompress the image compressed file to obtain an execution unit;

[0090] The update module is used to update the execution unit.

[0091] In order to better illustrate the technical effect of the present invention, the present invention provides the following specific embodiments to illustrate the above technical process:

[0092] Embodiment 1: A business unit intelligent content version management system, comprising:

[0093] 1. Create an execution unit: Create a template execution unit. The execution unit data includes work modules: position information, worksheet information, module information, digital human information, configuration information, input and output table data, single task information, and periodic task information. Statistics module: dashboard, theme, component, data set, global data, and shared data permissions. Setting information: execution unit setting information, etc. The dependency relationship of data information is: single task (periodic task) -> position -> worksheet -> configuration information -> input and output table data -> shared data -> global data. Dashboard -> Theme -> Component -> Dataset -> Global Data.

[0094] 2. Generate an execution unit image: Generate sub-images of each data module and combine them into an execution unit image.

[0095] 2.1. Module image.

[0096] 2.2. Worksheet mirroring.

[0097] 2.3. Position mirror: The position mirror contains position data, position-bound worksheet (associated with the worksheet mirror id), worksheet-bound module mirror id, position-bound digital human, position configuration information, etc.

[0098] 2.4.Configure information mirroring.

[0099] 2.5. Input data table metadata and table data image.

[0100] 2.6. Shared data permission mirror.

[0101] 2.7. Global data metadata and data mirroring.

[0102] 2.8. Dashboard image (including associated dataset id and component information).

[0103] 2.9. Set up information mirroring.

[0104] The image information is compressed into a JSON string through an algorithm, and then compressed into a zip package through the zip compression algorithm and saved in the mongodb database in binary form, with the execution unit id and the execution unit image being associated.

[0105] The algorithms for compressing the original data of each module into a json string are different. The job data is generated by calculating the self-associative tree structure data in the mongodb collection into parent-child tree structure data in json format. The module and worksheet mirror will generate a json string with description information and associated information. The script code will generate a txt document compressed into a zip package through the zip algorithm and saved in the file server. The file index information is associated with the filename_zip field in json. Input and output, table data separate the table metadata and table data to generate mirror information, and associate the table metadata and table data through tableId. Global data, data sets, and dashboard data involve associated information. Special processing is done on the data structure when generating the mirror. The uniqueness of the data is determined by gradually decoupling the associated id and data and adding two other fields, data id + execution unit id. The data id generated by the mirror data remains unchanged and only the execution unit id is changed to simplify the complex calculation during data mapping, which greatly reduces the time.

[0106] The process of compressing table data metadata into JSON strings is to remove homogeneous data and retain only necessary data. Data types and other type description fields are saved as the simplest decimal numbers through a unified mapping table. Table data is a complete data image that is not compressed into a JSON string.

[0107] 3. Update execution unit: Update execution unit includes initialization execution unit when the execution unit is generated for the first time through mirroring, update execution unit when an updated version of the execution unit has been generated, and deletion execution unit when the execution unit is no longer needed.

[0108] Initializing the execution unit means parsing the image information of each module after getting the execution unit template image, and deserializing the compressed json string format image into the original data through reverse calculation. The compression algorithms of each module are different. The position data compression algorithm is to calculate the self-associated position data in the database into a position tree structure, and then compress the tree structure into a json string using the zip compression algorithm to compress it into binary information and save it in the database. When performing reverse calculation, it is necessary to first parse the image zip package into a json string, deserialize the json string into the object information in the program, and then parse the object information to regenerate the self-associated data structure in the position data table. This reflects the practice of exchanging time for space. The original data that is much larger than the image is generated through calculation. The dashboard, data set, and global data are simplified through the innovation of the image data structure, which reduces the time complexity from the previous O(n) to O(1).

[0109] The update execution unit associates the data in different versions of the image through the originId field in the data. The position data update replaces the position and the position-bound worksheet (module information) with the data in the image, and the position configuration information is retained. The position-bound digital person can choose to update or unchanged update strategy. The input and output table data comparison data implements different update logics through the set update strategy, including unchanged strategy, overwrite strategy, and fusion strategy. The difficulty lies in the control of large amounts of data during updates, and the problem of restoring the original data when an error occurs in the update. The traditional database transactions (mongodb) that come with the transaction are no longer suitable for the current scenario. We ensure data security through data eventual consistency.

[0110] 4. Batch update execution unit: The execution framework supports batch execution update. In order to save time, multi-threading is used to run the update logic of each execution unit. However, the update of the execution framework is regarded as an atomic operation, and each thread updates the execution unit as a whole (succeed together and fail together). When selecting the technology, the mongoTemplate framework is used for the operation of the mongodb database. In this environment, multi-threaded transaction control becomes a challenge. Since spring's transaction control is thread-isolated, the overall transaction is invalid under multi-threading. The processing method of the present invention is that each thread starts an independent transaction separately, and uses the heap memory as a communication medium for multiple threads. When a thread is executed, it will not submit the transaction immediately, but will be blocked in the current state until all the execution unit update threads in this update successfully run to the current blocked state, and the counter in the heap memory will be added to the trigger state. At this time, when all threads monitor this state, they will not submit transactions uniformly until all other update threads run successfully. When one of the threads fails and reports an error, it notifies other threads that failfalg is true, then all threads will execute the transaction rollback operation after the operation is completed. This mechanism ensures the timeliness of batch updates under the execution framework and the security of data.

[0111] The key technical points of the present invention are:

[0112] 1. The data structure generated by the execution unit mirror image ensures the complexity of the calculation during initialization. For example, the global data mirror image: the global data data is a three-dimensional data composed of a data group group, a data key key, and a key data data, wherein the data group group and the data key key form a tree structure. The traditional way of generating a mirror image through the primary key self-association data requires replacing the primary key when the mirror image generates the original data, and then generating the self-association relationship through the primary key. This requires first generating a mirror data tree structure and then recursively replacing the primary key id one by one to generate the self-association relationship. The time complexity of such an algorithm is O(n). In this regard, the present invention optimizes the data structure, cancels the self-association method of the tree structure through the primary key, adds the mdid field to cooperate with the execution unit id to form a unique key, and when the mirror image generates a new execution unit, the mdid does not need to be changed, only the execution unit id needs to be modified. In this way, when generating the original data, it is only necessary to uniformly replace the execution unit ids of all tree structure data to achieve the same purpose. Through this optimization, the algorithm time complexity of generating metadata is improved from O(n) to O(1). This optimization improves the timeliness of the overall generation of execution units by 30%.

[0113] 2. When updating data, the transaction guarantee of massive data is adopted. The present invention adopts the method of final consistency of data. The massive data to be modified is first pushed to the message queue. The transaction control of the message queue ensures that the data update instruction is accurately issued. Through testing, rabbitMq can easily support the push of hundreds of thousands of data, and then slowly executes the real data update operation through the message consumer. Through the retry mechanism, recording the exception log and finally by manual backup, the final consistency of the data is guaranteed, and the timeliness is also improved to a certain extent.

[0114] 3. Ensure timeliness during batch updates and control of multi-threaded transactions in a spring environment. The present invention uses heap memory as a medium for communication between threads. When multiple threads all meet the conditions for transaction submission, a unified transaction submission operation will be performed. The specific implementation process is as follows: Before the multi-threaded transaction starts, a counter is added to the heap memory to record the number of threads and the error mark. Whenever a thread meets the conditions for transaction submission, the counter will be subtracted by 1, and then the counter will continue to monitor whether it is 0 and whether the error mark is true. Only when the counter is 0 will the transaction be submitted, otherwise the transaction will be rolled back if it times out or the error mark is true.

[0115] In the several embodiments provided by the present invention, it should be understood that the disclosed devices and methods can be implemented in other ways. For example, the device embodiments described above are only schematic, for example, the division of the modules, modules or units is only a logical function division, and there may be other division methods in actual implementation, for example, multiple units, modules or components can be combined or integrated into another device, or some features can be ignored or not executed.

[0116] The units may or may not be physically separated, and the components displayed as units may be one physical unit or multiple physical units, that is, they may be located in one place or distributed in multiple different places. Some or all of the units may be selected according to actual needs to achieve the purpose of the present embodiment.

[0117] In addition, each functional unit in each embodiment of the present invention may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above-mentioned integrated unit may be implemented in the form of hardware or in the form of software functional units.

[0118] In particular, according to the embodiments disclosed in the present invention, the process described above with reference to the flowchart can be implemented as a computer software program. For example, the embodiments disclosed in the present invention include a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program includes a program code for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from the network through the communication part, and / or installed from a removable medium. When the computer program is executed by the central processing unit (CPU), the above-mentioned functions defined in the method of the present invention are executed. It should be noted that the above-mentioned computer-readable medium of the present invention can be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. The computer-readable storage medium can be, for example, but not limited to, a system, device or device of an electrical, magnetic, optical, electromagnetic, infrared segment, or semiconductor, or any combination of the above.

[0119] The flow chart and block diagram in the accompanying drawings illustrate the possible architecture, function and operation of the system, method and computer program product according to various embodiments of the present invention. In this regard, each square box in the flow chart or block diagram can represent a module, a program segment or a part of a code, and the module, the program segment or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the square box can also occur in a sequence different from that marked in the accompanying drawings. For example, two square boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each square box in the block diagram and / or flow chart, and the combination of the square boxes in the block diagram and / or flow chart can be implemented with a dedicated hardware-based system that performs the specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.

[0120] The above is only a specific embodiment of the present invention, but the protection scope of the present invention is not limited thereto. Any changes or substitutions within the technical scope disclosed by the present invention should be included in the protection scope of the present invention. Therefore, the protection scope of the present invention should be based on the protection scope of the claims.

Claims

1. A business unit intelligent content version management method, characterized in that: The following steps are involved: Build template execution unit; Generate a template execution unit image of the template execution unit; Compressing the template execution unit image to obtain an image compression file; Decompress the image compressed file to obtain an execution unit; Updates the execution unit.

2. The business unit intelligent content version management method according to claim 1, characterized in that: The template execution unit image is compressed to obtain an image compression file, which specifically includes the following steps: Compress the template execution unit image into a json string; Compress the json string into a zip package using the zip compression algorithm; Save the zip file in a mongodb database in binary form.

3. The business unit intelligent content version management method according to claim 2, characterized in that: The template execution unit includes a working module, a statistical module and a setting module; The work module includes position information, work table information, module information, configuration information, and input and output table data; The statistics module includes dashboard, global data and shared data permissions; The setting module includes setting information.

4. The business unit intelligent content version management method according to claim 3, characterized in that: The template execution unit image includes a position image, a work table image, a module image, a configuration information image, an input and output table data image, a shared data authority image, a global data image, a dashboard image and a setting information image.

5. The business unit intelligent content version management method according to claim 4, characterized in that: The following steps are also included: For job mirroring, the self-associative tree structure data in the mongodb database is converted into parent-child tree structure data in json format; For worksheet images and module images, generate a json string with description information and associated information, compress the script code into a txt document through the zip algorithm and save it in the file server, and associate the file index information through the filename_zip field in the json string; For input and output table data, table metadata and table data are separated to generate mirror information, and table metadata and table data are associated through tableId; For global data, data sets, and dashboard data, the uniqueness of the data is determined by gradually decoupling the associated ID and data and adding two additional fields: data ID + execution unit ID.

6. The business unit intelligent content version management method according to claim 5, characterized in that: Decompressing the image compressed file to obtain an execution unit specifically includes the following steps: Decompress the zip package to get a json string; Deserialize the json string to get the execution unit.

7. The business unit intelligent content version management method according to claim 6, characterized in that: Updating the execution unit specifically includes the following steps: Each execution unit's update thread starts a separate transaction; Update the execution unit in the transaction; When all update threads of all execution units have run successfully, all transactions are committed.

8. The business unit intelligent content version management method according to claim 7, characterized in that: The execution unit is updated in the transaction, which includes the following steps: The originId field in the data is used to link the data in the image of the template execution unit of different versions. The position data is updated to replace the position and the position-bound worksheet with the data in the image, and the position configuration information is retained.

9. The business unit intelligent content version management method according to claim 8, characterized in that: The operation of the mongodb database adopts the mongoTemplate framework.

10. A business unit intelligent content version management control system, used to implement the business unit intelligent content version management method according to any one of claims 1 to 9, characterized in that: include: Create modules for building template execution units; An image generation module, used to generate a template execution unit image of the template execution unit; A compression module is used to compress the template execution unit image to obtain an image compression file; A decompression module is used to decompress the image compressed file to obtain an execution unit; The update module is used to update the execution unit.

Images