Method, system, and medium for upgrading software generated based on low-code development tools

Abstract

The application discloses an upgrading method and system of software based on a low-code development tool and a medium, and the method comprises the following steps: adding an update content field and an update time field to a plurality of data tables storing software function configuration metadata; based on the update time field, exporting configuration records changed after a first time point from the plurality of data tables; acquiring a set of upgrade configuration record files related to version upgrading provided by a software provider; comparing and merging the exported configuration record files with the set of upgrade configuration record files to generate a set of target configuration record files after merging; and batch importing the set of target configuration record files into a database of a target system to complete software upgrading. The application can efficiently and accurately merge a new version released by a software developer with personalized modifications of an old version by a user, realize smooth upgrading, and avoid high cost and error risks caused by manual comparison.

Description

Technical Field

[0001] This invention relates to the field of computer software technology, and in particular to an upgrade method, system, and medium for software generated based on low-code development tools. Background Technology

[0002] The core principles of low-code development tools can be summarized as: visual design + metadata-driven + automated generation + runtime parsing.

[0003] The following section will first introduce low-code development tools:

[0004] 1. Visual modeling: Abstracting development actions into "puzzle pieces".

[0005] Graphical interface: The interface and logic design can be completed by dragging and dropping components (buttons, forms, charts, etc.) and configuring properties (colors, validation rules, etc.), and what you see is what you get.

[0006] Model-driven: The design results are saved as metadata (JSON / XML, etc.) that describes the page structure, data binding, business rules, etc., rather than directly generating code.

[0007] Example: When designing a leave application form, drag and drop the fields → Configure rules → Save as form model metadata.

[0008] 2. Metadata parsing: A "translator" from design to operation.

[0009] Model parsing engine: Reads metadata at runtime and dynamically generates executable logic by combining it with pre-defined algorithms.

[0010] Frontend: Renders metadata into HTML / React / Vue components (e.g., Amis converts JSON into a React component tree).

[0011] Backend: Parse business rules (such as "Leave days > 3 days require supervisor approval") and trigger process engine or database operations.

[0012] 3. Automated code generation: hides complex technical details.

[0013] Code generation engine: For complex scenarios that cannot be covered by metadata (such as custom algorithms), the platform automatically generates partial code (such as JavaScript / Python snippets), which developers can then edit.

[0014] Scaffolding and templates: Pre-set templates for common applications (such as CRM systems) to quickly generate basic code structures.

[0015] 4. Runtime engine: Dynamic execution and extension.

[0016] Event-driven: User actions (such as clicking a button) trigger a predefined event flow, which is executed by the rules engine or workflow engine.

[0017] Domain-Specific Languages ​​(DSLs): Complex logic can be arranged by simplifying syntax (such as `IF(condition).DO(A).ELSE(B)`), and can be configured even by non-programmers.

[0018] 5. The technical layered architecture of low-code development tools is shown in Table 1:

[0019] Table 1

[0020]

[0021] In summary, the essence of low-code development tools is to transform "development" into "configuration." Through the principle of separating algorithms and data, it abstracts many application scenarios into a single algorithm, which is then instantiated using different metadata. The algorithm and metadata are used to implement the presentation of the front-end user interface and the judgment of back-end business logic. Therefore, a very important conclusion can be drawn: software developed with low-code mainly consists of two parts: a runtime engine and metadata.

[0022] Simply put, software developed using low-code development tools mainly consists of two parts: algorithm processing programs and function configuration data.

[0023] The advantages and disadvantages of low-code software development are analyzed below.

[0024] Low-code development platforms (LCDPs) have been widely adopted in enterprise digital transformation in recent years. The main benefits of using low-code development platforms are shown in Table 2 below:

[0025] Table 2

[0026]

[0027] Therefore, it is evident that if software developed using low-code is sold to users, then enterprises can adjust its functions according to their actual business needs during the use of this software, and this adjustment is very easy to complete due to the simple and visual operation interface (building modules).

[0028] However, low-code software development has the following drawbacks:

[0029] Because software developed using low-code can be modified by users through modular building, and the resulting metadata is stored in a conventional database, if a software developer develops software (let's call it Software A) using low-code and sells version V1.0 to user C, and user C modifies the functionality during use, upgrading to version V2.0 becomes very difficult. The developer must clearly understand which functionalities user C modified during version V1.0 and then replicate those modifications in version V2.0 to ensure that user C's customized needs are not lost due to the upgrade. If user C modified only a few functionalities during version V1.0, the process is relatively easy. However, if numerous customizations were made, replicating those modifications after the upgrade becomes extremely difficult and labor-intensive. Summary of the Invention

[0030] The main objective of this invention is to propose a method, system, and medium for upgrading software based on low-code development tools. This method aims to efficiently and accurately merge new versions released by software developers with personalized modifications made by users to older versions, thereby achieving a smooth upgrade and avoiding the high costs and error risks associated with manual comparison.

[0031] To achieve the above objectives, the present invention provides a method for upgrading software generated based on low-code development tools, the method comprising the following steps:

[0032] Step S10: Strengthen the structure of several data tables storing software function configuration metadata by adding an update content field to each data table to uniquely identify a single configuration record and an update time field to record the last modification time of the configuration record.

[0033] Step S20: In response to the export command, based on the update time field, export the configuration records that have changed after the first time point from the plurality of data tables, and each configuration record is exported as an independent configuration record file;

[0034] Step S30: Obtain the set of upgrade configuration record files related to version upgrade provided by the software vendor;

[0035] Step S40: Compare and merge the exported configuration record file with the set of upgrade configuration record files to generate a merged target configuration record file set;

[0036] Step S50: In response to the import command, the target configuration record file set is imported in batches into the database of the target system to complete the software upgrade.

[0037] A further technical solution of the present invention is that the generation rule of the updated content field is: to combine the system timestamp of the addition or first modification of the configuration record with a random number to ensure its global uniqueness; its format is yyyyMMddhhmmssXXXX, where XXXX is a four-digit random code.

[0038] A further technical solution of the present invention is that, in step S20, the naming rule for the filename of the configuration record file is: the name of the data table to which it belongs, the separator, and the update content of the configuration record.

[0039] A further technical solution of the present invention is that the content format of the configuration record file is: plain text format, each line contains a field name and its corresponding field value, and the field name and field value are distinguished by a predefined separator.

[0040] A further technical solution of the present invention is that step S40 specifically includes:

[0041] Step S401: Use a third-party file comparison tool to compare the differences between the exported configuration record file and the set of upgrade configuration record files;

[0042] Step S402: Based on the comparison results, receive the user's manual selection and confirmation operation for the conflicting parts;

[0043] Step S403: Based on the manual selection and confirmation operation, the merged target configuration record file set is automatically generated.

[0044] A further technical solution of the present invention is that step S50 specifically includes:

[0045] Step S501: Traverse each file in the target configuration record file set;

[0046] Step S502: Parse the filename of the current file to obtain the target data table name and the target update content;

[0047] Step S503: Based on the target update content, query the data table corresponding to the target data table name;

[0048] Step S504: If a corresponding record is found, update the record according to the content of the current file;

[0049] Step S505: If no corresponding record is found, insert a new record identified by the target update content into the data table corresponding to the target data table name.

[0050] A further technical solution of the present invention includes, before step S10:

[0051] Step S00: Provide a visual interface in the low-code development platform to receive user instructions on structural enhancement of the several data tables;

[0052] Step S01: After completing the structural enhancement, automatically generate and populate the update content and update time fields for the existing historical configuration records.

[0053] A further technical solution of the present invention is that the updated content field is the first field of each data table.

[0054] To achieve the above objectives, the present invention also proposes an upgrade system for software generated based on low-code development tools. The system includes a memory, a processor, and an upgrade program for the software generated based on low-code development tools stored on the processor. The upgrade program for the software generated based on low-code development tools is executed by the processor to perform the steps of the method described above.

[0055] To achieve the above objectives, the present invention also proposes a computer-readable storage medium storing an upgrade program for software generated based on low-code development tools, wherein the upgrade program for software generated based on low-code development tools is executed by the processor to perform the steps of the method described above.

[0056] The beneficial effects of the upgrade method, system, and medium for software generated based on low-code development tools in this invention are:

[0057] This invention, through the above technical solution, enhances the structure of several data tables storing software function configuration metadata by adding an update content field to each data table to uniquely identify a single configuration record and an update time field to record the last modification time of that configuration record; in response to an export command, based on the update time field, it exports configuration records that have changed after a first time point from the several data tables, with each configuration record being exported as an independent configuration record file; it obtains a set of upgrade configuration record files related to version upgrades provided by the software vendor; it compares and merges the exported configuration record files with the set of upgrade configuration record files to generate a merged target configuration record file set; in response to an import command, it imports the target configuration record file set in batches into the database of the target system to complete the software upgrade. This method can efficiently and accurately merge new versions released by software developers with personalized modifications made by users to old versions, achieving a smooth upgrade and avoiding the high costs and error risks associated with manual comparison. Attached Figure Description

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

[0059] Figure 1 This is a flowchart illustrating a preferred embodiment of the software upgrade method based on low-code development tools of the present invention.

[0060] Figure 2 This is a detailed flowchart of step S40;

[0061] Figure 3 This is a detailed flowchart of step S50;

[0062] Figure 4 This is a schematic diagram of the software function configuration data table;

[0063] Figure 5 This is a schematic diagram of the software function configuration data table after structural enhancement;

[0064] Figure 6 This is a diagram showing how each record exported from a low-code development tool is converted into a corresponding file.

[0065] Figure 7 These are format diagrams for each individual file;

[0066] Figure 8 This is a diagram illustrating the contents of a record in the FlowNewDescription data table;

[0067] Figure 9 This is a schematic diagram of the hardware architecture involved in the software upgrade method generated by the low-code development tools of this invention.

[0068] The realization of the objective, functional features and advantages of the present invention will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0069] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of the present invention.

[0070] To address the problem that after software vendors develop software using low-code and sell it to users, and users subsequently modify the software's functionality using low-code development tools due to customization needs, the software vendors may upgrade the software version. However, when users want to upgrade to the latest version, the metadata defining the software functions has been modified and cannot be directly overwritten, making the upgrade extremely difficult. This invention proposes a solution.

[0071] Specifically, this invention proposes an upgrade method for software generated by low-code development tools. The solution adopted by this invention mainly involves converting the records of the original data table into visible file records, using third-party comparison tools or AI comparison methods to determine the differences, synthesizing new difference record documents, and importing them into the system in batches to complete the upgrade. This upgrade can be a data upgrade for software developed using low-code development tools, or an upgrade for the data set that an AI agent depends on.

[0072] like Figure 1 As shown, a preferred embodiment of the software upgrade method based on low-code development tools of the present invention includes the following steps:

[0073] Step S10: Enhance the structure of several data tables storing software function configuration metadata by adding an update content field to each data table to uniquely identify a single configuration record and an update time field to record the last modification time of the configuration record.

[0074] The updated content field can use ID to define the uniqueness of the record, or it can use other types of primary keys in the data table, such as customer record table, customer ID, and material code information table can use material code number to identify the uniqueness of the record.

[0075] The record ID field is the first field of each data table. The generation rule for the update content field is as follows: the system timestamp of the addition or first modification of the configuration record is combined with a random number to ensure its global uniqueness; its format is yyyyMMddhhmmssXXXX, where XXXX is a four-digit random code. Of course, in other embodiments, the generation format can also be defined as other formats.

[0076] Step S20: In response to the export command, based on the update time field, export the configuration records that have changed after the first time point from several data tables, and each configuration record is exported as an independent configuration record file.

[0077] The naming rules for configuration record files are as follows: the name of the data table to which it belongs, the separator, and the update content of the configuration record.

[0078] The configuration log file is formatted as follows: it uses plain text format, with each line containing a field name and its corresponding field value, and the field name and field value are separated by a predefined delimiter.

[0079] Step S30: Obtain the set of upgrade configuration record files related to version upgrade provided by the software vendor.

[0080] Step S40: Compare and merge the exported configuration record file with the upgrade configuration record file set to generate the merged target configuration record file set.

[0081] like Figure 2 As shown, step S40 specifically includes:

[0082] Step S401: Use a third-party file comparison tool to compare the differences between the exported configuration record file and the set of upgrade configuration record files;

[0083] Step S402: Based on the comparison results, receive the user's manual selection and confirmation operation for the conflicting parts;

[0084] Step S403: Based on the manual selection and confirmation operation, the merged target configuration record file set is automatically generated.

[0085] Step S50: In response to the import command, the target configuration record file set is imported in batches into the database of the target system to complete the software upgrade.

[0086] like Figure 3 As shown, step S50 specifically includes:

[0087] Step S501: Traverse each file in the target configuration record file set;

[0088] Step S502: Parse the filename of the current file to obtain the target data table name and the target update content;

[0089] Step S503: Query the data table corresponding to the target data table name based on the target update content;

[0090] Step S504: If a corresponding record is found, update the record according to the content of the current file;

[0091] Step S505: If no corresponding record is found, insert a new record with the target update content as the identifier into the data table corresponding to the target data table name.

[0092] In this embodiment, the method further includes the following steps before step S10:

[0093] Step S00: Provide a visual interface in the low-code development platform to receive user instructions on structural enhancement of several data tables;

[0094] Step S01: After completing the structural enhancement, automatically generate and populate the update content and update time fields for the existing historical configuration records.

[0095] The following combination Figures 1 to 8 The method for upgrading software generated by low-code development tools according to the present invention will be further described in detail.

[0096] like Figure 4 As shown, software function configuration data typically consists of many data tables. The number of data tables is generally related to the completeness of the low-code functionality provided by the low-code development vendor. Basically, one or more configuration data tables correspond to one functional module. For example, a data table design function might have a configuration table to store and manage the structure data and column configuration data of the user-designed data table; a smart form design function might have a form configuration table to store information such as data items, labels, input methods, validation methods, default values, and layout of form elements; a workflow design function might have a workflow node configuration table and a workflow node routing table to define the operable data items, data validity validation methods, operable action buttons (agree, reject, transfer), and workflow flow configuration data for each workflow node. In short, a fully functional low-code development tool typically has forty to fifty, or even more, data tables used to store user-configured metadata. Furthermore, the data fields in each table are set according to specific functional needs; some configuration tables may have only a few fields, some more than ten, and some dozens or even hundreds.

[0097] Each configuration table stores user-designed or configured data. The amount of data stored in each table is related to the number of functions configured by the user. For example, an ERP software developed using low-code might define more than 1,000 function menus, more than 500 processes, more than 300 reports, and more than 2,000 user form interfaces. In this case, the configuration data of the system would be very large. The menu configuration table would have at least more than 1,000 records, the process node configuration table would have at least thousands of records, and the report configuration table would have at least several hundred records.

[0098] If a software developer sells its software to a user, and after a period of time, the user modifies some processes or other software functions as needed, while the software developer also upgrades the software, adding new functions and adjusting some existing ones, then upgrading the user's system will be extremely difficult. This is because of the numerous configuration tables and records; some have been added, some deleted, and some have been modified by both the software developer and the user. Upgrading will be very challenging.

[0099] Therefore, this invention proposes an upgrade method for software generated based on low-code development tools, which makes the upgrade process simpler, clearer, and more efficient.

[0100] The following example illustrates the workflow of the software upgrade method based on low-code development tools according to the present invention:

[0101] First, such as Figure 5 As shown, add two fields to each configuration table: ID and update time. Ensure that the ID is the first field in each configuration table, is unique, and follows the format yyyyMMddhhmmssxxxx, where xxxx is a four-digit random code. If the original configuration table already has an ID field, no additional field is needed. The update time is used to record the time each data entry is added or edited, and follows the format yyyy / MM / dd hh:mm:ss.

[0102] Next, a configuration data export function was added to the low-code development tool. This function allows exporting all configuration data modified after a specified time, such as all configuration data modified after 17:00 on March 15, 2025. The exported configuration data is presented in text file format, with the filename format: Table Name + Record ID.txt. Each configuration record is a separate file. For example, the FlowNewDescription table has many configuration records; each exported record is converted into a corresponding file. Figure 6 As shown. Each individual file contains data in the format of field name='data content', one field per line, as shown in the example below. Figure 7 As shown, the content of a record in the FlowNewDescription data table is as follows: Figure 8 As shown.

[0103] Then, a configuration data import function was added to the low-code development tool, allowing batch import by folder. The import module iterates through the specified folders, importing files one by one, parsing the table name and record ID in the filename, and querying the corresponding data table. If the record ID already exists in the table, it is updated according to the content of each field in the file. If the record ID does not exist, a new record is generated with the record ID in the filename and the content of each field in the record being the content set in each field of the file.

[0104] In this way, if a version upgrade is needed, the configuration records modified by the user and those modified by the developer after the version release can be exported according to the last update time. These two records are compared using a third-party file comparator, and a new configuration file is created and imported into the user's database to complete the upgrade. For example, if the software developer's V1.0 version was released on March 15, 2025 at 17:00 and sold to users, and then V2.0 was released on July 1, 2025 at 10:00, and the user's environment also needs to be upgraded to V2.0, the user's runtime environment can use the configuration data export function to export the configuration records modified after March 15, 2025 at 17:00, and compare them with the configuration modification records from V1.0 to V2.0 released by the software developer. A third-party file comparison tool is then used to compare these records, and a new configuration record is created and imported in batches using the configuration import function to complete the upgrade.

[0105] The beneficial effects of the software upgrade method based on low-code development tools in this invention are:

[0106] This invention, through the above technical solution, enhances the structure of several data tables storing software function configuration metadata by adding an update content field to each data table to uniquely identify a single configuration record and an update time field to record the last modification time of that configuration record; in response to an export command, based on the update time field, it exports configuration records that have changed after a first time point from the several data tables, with each configuration record being exported as an independent configuration record file; it obtains a set of upgrade configuration record files related to version upgrades provided by the software vendor; it compares and merges the exported configuration record files with the upgrade configuration record file set to generate a merged target configuration record file set; in response to an import command, it batch imports the target configuration record file set into the database of the target system to complete the software upgrade. This method can efficiently and accurately merge the new version released by the software developer with the user's personalized modifications to the old version, achieving a smooth upgrade and avoiding the high cost and error risk of manual comparison.

[0107] To achieve the above objectives, this invention also proposes an upgrade system for software generated using low-code development tools, such as... Figure 9 As shown, the system includes a processor 1001, a CPU, a network interface 1004, a user interface 1003, a memory 1005, a communication bus 1002, and an upgrade program for software generated based on low-code development tools stored on the processor. The communication bus 1002 is used to enable communication between these components. The user interface 1003 may include a display screen or an input unit such as a keyboard. Optionally, the user interface 1003 may also include a standard wired interface or a wireless interface. The network interface 1004 may optionally include a standard wired interface or a wireless interface (such as a Wi-Fi interface). The memory 1005 may be high-speed RAM or non-volatile memory, such as a disk drive. Optionally, the memory 1005 may also be a storage device independent of the aforementioned processor 1001.

[0108] Those skilled in the art will understand that Figure 9 The system structure shown does not constitute a limitation on the system and may include more or fewer components than shown, or combine certain components, or have different component arrangements.

[0109] like Figure 9 As shown, the memory 1005, which serves as a computer storage medium, may include an operating device, a network communication module, a user interface module, and an upgrade program for software generated based on low-code development tools.

[0110] exist Figure 9 In the system shown, network interface 1004 is mainly used to connect to the network server and communicate with the network server; user interface 1003 is mainly used to interact with the user terminal and receive user input instructions; and processor 1001 can be used to call the upgrade program of software generated based on low-code development tools stored in memory 1005.

[0111] To achieve the above objectives, the present invention also proposes a computer-readable storage medium storing an upgrade program for software generated based on low-code development tools. The upgrade program for software generated based on low-code development tools is executed by a processor to perform the steps of the method described above, which will not be repeated here.

[0112] The above description is merely a preferred embodiment of the present invention and does not limit the patent scope of the present invention. Any equivalent structural transformations made under the concept of the present invention using the description and drawings of the present invention, or direct / indirect applications in other related technical fields, are included within the patent protection scope of the present invention.

Claims

1. A method for upgrading software generated using low-code development tools, characterized in that, The method includes the following steps: Step S10: Strengthen the structure of several data tables storing software function configuration metadata by adding an update content field to each data table to uniquely identify a single configuration record and an update time field to record the last modification time of the configuration record. Step S20: In response to the export command, based on the update time field, export the configuration records that have changed after the first time point from the plurality of data tables, and each configuration record is exported as an independent configuration record file; Step S30: Obtain the set of upgrade configuration record files related to version upgrade provided by the software vendor; Step S40: Compare and merge the exported configuration record file with the set of upgrade configuration record files to generate a merged target configuration record file set; Step S50: In response to the import command, the target configuration record file set is imported in batches into the target system's database to complete the software upgrade; The generation rule for the updated content field is as follows: the system timestamp of the configuration record's addition or first modification is combined with a random number to ensure its global uniqueness; its format is yyyyMMddhhmmssXXXX, where XXXX is a four-digit random code; In step S20, the naming rule for the configuration record file is: the name of its data table, the separator, and the update content of the configuration record; The configuration record file is formatted as follows: it uses plain text format, with each line containing a field name and its corresponding field value, and the field name and field value are distinguished by a predefined separator. The aforementioned step S40 specifically includes: Step S401: Use a third-party file comparison tool to compare the differences between the exported configuration record file and the set of upgrade configuration record files; Step S402: Based on the comparison results, receive the user's manual selection and confirmation operation for the conflicting parts; Step S403: Based on the manual selection and confirmation operation, automatically generate the merged target configuration record file set; Step S50 specifically includes: Step S501: Traverse each file in the target configuration record file set; Step S502: Parse the filename of the current file to obtain the target data table name and the target update content; Step S503: Based on the target update content, query the data table corresponding to the target data table name; Step S504: If a corresponding record is found, update the record according to the content of the current file; Step S505: If no corresponding record is found, insert a new record identified by the target update content into the data table corresponding to the target data table name.

2. The method for upgrading software generated based on low-code development tools according to claim 1, characterized in that, The procedure preceding step S10 also includes: Step S00: Provide a visual interface in the low-code development platform to receive user instructions on structural enhancement of the several data tables; Step S01: After completing the structural enhancement, automatically generate and populate the update content and update time fields for the existing historical configuration records.

3. The method for upgrading software generated based on low-code development tools according to claim 1, characterized in that, The updated content field is the first field of each data table.

4. An upgrade system for software generated using low-code development tools, characterized in that, The system includes a memory, a processor, and an upgrade program for software generated using low-code development tools stored on the processor, the upgrade program being executed by the processor to perform the steps of the method as described in any one of claims 1 to 3.

5. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores an upgrade program for software generated based on low-code development tools, which, when run by a processor, performs the steps of the method as described in any one of claims 1 to 3.

Images