Low-code database merging method based on incremental meta-model atlas

Abstract

The invention relates to the technical field of low-code databases, and particularly discloses a low-code database merging method based on an incremental meta-model atlas, which comprises the following steps: constructing an entity structure of a development test library meta-model atlas according to system table data of a development test library, constructing an entity structure of the production library meta-model atlas according to the system table data of the production library; generating a development test library meta-model graph according to the entity structure of the development test library meta-model graph, and generating a production library meta-model graph according to the entity structure of the production library meta-model graph; carrying out incremental combination on the development test library meta-model atlas and the production library meta-model atlas; meta-model synchronous merging is carried out on system table data of the production library; and synchronously updating the business table structure in the production library. According to the low-code database merging method based on the incremental meta-model graph, merging of low-code databases under the condition that a development test environment is isolated from a production environment can be efficiently achieved.

Description

Technical Field

[0001] The present invention relates to the field of low-code database technology, and in particular to a low-code database merging method based on an incremental metamodel graph. Background Art

[0002] Due to the particularity of the complex equipment industry, the development and testing environment and the production environment need to be completely physically isolated, and the system cannot be quickly released through DEVOPS R&D and operation integration. In addition, deployment files can generally only be imported from the development and testing environment to the production environment. For example, exporting from the production environment to the development and testing environment requires a long approval cycle, which brings a certain amount of time delay to the implementation and deployment of the low-code system. As a result, the deployment of the low-code system is only considered under the condition of one-way import in an isolated environment. Different from high-code systems that write various models and configurations in code files, low-code systems store business metamodels, interface models, process models, etc. in the database. Therefore, when deploying a low-code system, in addition to compiling and deploying the front-end and back-end codes, it is also necessary to merge the low-code system database.

[0003] The advantage of low-code systems is that they can respond to changes in users' urgent business needs at any time. Low-code system implementers can complete implementation by directly modifying low-code configurations in the background management of the production environment, without having to go through multiple implementation links such as code development and testing in the development and testing environment, and then import them into the production environment for deployment. However, this causes the models and configurations of the development and testing library and the production library to be dynamically updated. When deploying a low-code system, not only must the various models and configuration information in the development and testing library be synchronized to the production library, but the configurations modified on-site in the production library must also be retained, and the models and configurations of the development and testing library and the production library must be merged as a new production library. Due to physical isolation, the models and configurations of the two libraries are dynamically updated, so the models and configurations of the two libraries will have primary key IDs and foreign key IDs that increase separately, and may not match completely. The order of creating business table fields and the order of inserting system table data records are not exactly the same. System data such as users, organizations, and roles are referenced in each model in the form of foreign keys, and may also be created separately in the two libraries, resulting in inconsistencies in primary and foreign keys. Therefore, it is not possible to simply export the business metamodel, interface model, process model and configuration information from the development and testing library to the production library to complete the database deployment merge.

[0004] Although the prior art also proposes a solution for synchronizing the development and testing library of a low-code system with the production library, none of them can achieve a merger. For example, the technical solution for the synchronization method of the low-code multi-environment database structure only generates SQL from the table structure in the test library and executes it in the production library to synchronize the library table structure, without considering the synchronization of the model and configuration information. Since the system tables and business tables of the development and testing library and the production library are associated with each other through the primary key ID, when both have model and configuration modifications, the primary key ID of each table will increase by itself, resulting in the development and testing library and the production library being unable to synchronize the model and configuration data in an intact manner, otherwise there will be primary key ID conflicts, foreign key associations, or data association confusion. For another example, the technical solution of the database synchronization method based on difference detection is applicable to the situation where only the source database is modified and synchronized to the target database. The current production library also has modifications, and it is necessary to consider the problem of merging the models and configurations of the two libraries. Therefore, the technical solutions in the prior art cannot completely solve the problem of low-code database merging when both the development and testing library and the production library are modified under the condition of one-way import in an isolated environment. The merging of low-code databases still adopts the more cumbersome two-database merging method, as follows: One method is to take the production library as the standard, manually record all modifications in the test development library, and manually re-operate in the production library. The low-code system will generate relevant models and configurations according to internal logical rules, and match them with the production library. This method is suitable for the case where there are few modifications in the test development library. When a large number of modifications are made, it is equivalent to re-implementation, which is a large workload. Another method is to take the development and test library as the standard and adopt the manual merging and single import method. Reconfigure and implement the modifications in the production library in the development library, and then export the merged system table structure, system table data (including data model, interface model, process model and system configuration), business table structure in the development library and generate SQL, and execute the SQL in the test library to update the database. When the test passes in the test library, execute the SQL in the production library. In the case of primary key ID conflict, first associate and find all foreign keys related to the primary key ID, and replace all the same data values ​​with the current largest self-increment ID value, and then execute SQL to perform the merge. For the system configuration information such as personnel, organization, and role referenced in the page model and process model, the original production library shall prevail and needs to be reconfigured in the production library. Both methods require too much manual participation and review, and have high requirements for the implementation and deployment personnel. They need to be very meticulous, and the deployment takes a long time. Manual merging of libraries is prone to omissions, which has a certain impact on system stability. In addition, the internal logical relationship between the data in the low-code system tables cannot be fully guaranteed to be correct during synchronization, and errors can only be exposed when the system is running.Common system errors include: part of the form configuration is not synchronized, the form cannot be found due to ID misalignment, the process instance cannot be found in the to-do task, the form is not fully synchronized, the changes in the production library are overwritten and lost due to restoration, the personnel organization roles of the page model and the process model cannot be found, the process model ID is inconsistent and the process cannot be initiated, etc.

[0005] Therefore, how to efficiently realize the merger of low-code databases in the case of isolation of development and testing environment and production environment has become a technical problem that needs to be urgently solved by technical personnel in this field. Summary of the invention

[0006] The present invention provides a low-code database merging method based on an incremental metamodel graph, which solves the problem in the related art that it is impossible to efficiently realize the merging of low-code databases when the development and testing environment is isolated from the production environment.

[0007] As one aspect of the present invention, a low-code database merging method of an incremental metamodel graph is provided, which includes: Constructing the entity structure of the metamodel graph of the development and test library according to the system table data of the development and test library, and constructing the entity structure of the metamodel graph of the production library according to the system table data of the production library; Generate a development and test library metamodel map according to the entity structure of the development and test library metamodel map, and generate a production library metamodel map according to the entity structure of the production library metamodel map; Incrementally merging the development and test library metamodel map with the production library metamodel map to obtain an incremental metamodel map; Performing metamodel synchronization and merging of system table data of the production library according to the incremental metamodel graph; Synchronously updating the business table structure in the production library according to the data model metamodel map in the incremental metamodel map; Perform SQL synchronization on the system table structure and system settings between the development and test library and the production library.

[0008] Further, incrementally merging the development and test library metamodel map with the production library metamodel map to obtain an incremental metamodel map includes: Construct an initial set of incremental triples; Compare the development and test library metamodel graph with the production library metamodel graph in triples to obtain a first triple that exists in the production library metamodel graph and does not exist in the development and test library metamodel graph, and a second triple that exists in the development and test library metamodel graph and does not exist in the production library metamodel graph; Marking the source and the status of the first triplet and the second triplet respectively; The marked first triple and the second triple are added to the initial set of incremental triples to obtain an incremental metamodel graph.

[0009] Further, performing metamodel synchronization and merging on the system table data of the production library according to the incremental metamodel graph includes: Compare the entities of the triples of the incremental metamodel graph with the two-dimensional table of models in the production library to determine the objects to be synchronized in the production library; Map the entities and attributes of the triple to the objects to be synchronized; The foreign key relationship of the object to be synchronized is determined based on the relationship of the triples.

[0010] Further, comparing the entities of the triples of the incremental metamodel graph with the two-dimensional table of models in the production library to determine the objects to be synchronized in the production library, including: Compare the entities of the triples of the incremental metamodel graph with the information of the two-dimensional table of models in the production library; If the model two-dimensional table in the production library has matching record information with the entities of the triples of the incremental metamodel graph, the model two-dimensional table in the production library is determined to be the object to be synchronized; If the model two-dimensional table in the production library contains record information that does not match the entity of the triple of the incremental metamodel graph, it is determined that the model two-dimensional table in the production library does not need to be synchronized.

[0011] Furthermore, the entities and attributes of the triples are mapped to the objects to be synchronized, including: Mapping the entities of the three-member group of the incremental metamodel graph to the table records in the object to be synchronized according to the direct mapping method, and realizing synchronization of entity values; According to the direct mapping method, the attributes of the triples of the incremental metamodel graph are mapped to the columns of the table in the object to be synchronized, and synchronization of the attribute values ​​is achieved.

[0012] Further, determining the foreign key relationship of the object to be synchronized according to the relationship of the triples includes: Match the foreign key relationship with the object to be synchronized according to the relationship of the triples in the incremental metamodel graph; Determine whether the foreign key ID value exists in the production database; If it does not exist, create a new foreign key ID value based on the production database foreign key ID value generator; If it exists, the existing foreign key ID value will be used as the foreign key ID value of the object to be synchronized.

[0013] Furthermore, the business table structure in the production library is synchronously updated according to the data model metamodel map in the incremental metamodel map, including: Acquire an incremental data model metamodel according to the incremental data model metamodel graph in the incremental metamodel graph; The business table structure in the production library is automatically updated according to the business table structure generation function and the incremental data model metamodel.

[0014] Furthermore, the business table structure in the production library is automatically updated according to the business table structure generation function and the incremental data model metamodel, including: Determine the order of creating the business table structure in the production library based on the metamodel generation order of breadth-first search; The business table structure is automatically updated according to the business table structure generation function and the incremental data model metamodel in the order in which the business table structure is created.

[0015] Further, generating a development and test library metamodel map according to the entity structure of the development and test library metamodel map, and generating a production library metamodel map according to the entity structure of the production library metamodel map, includes: Respectively performing knowledge extraction, knowledge cleaning, knowledge disambiguation and knowledge association on the entity structure of the development and test library metamodel map and the entity structure of the production library metamodel map; Respectively extract entities, attributes and relationships of the entity structure of the development and test library metamodel map and the entity structure of the production library metamodel map to form a development and test library metamodel map triple and a production library metamodel map triple; A development and test library metamodel map is generated according to the development and test library metamodel map triples, and a production library metamodel map is generated according to the production library metamodel map triples.

[0016] Further, the entity structure of the metamodel map of the development and test library is constructed according to the system table data of the development and test library, and the entity structure of the metamodel map of the production library is constructed according to the system table data of the production library, including: Determine the entity structure of the development and test library metamodel map according to the system table structure of the development and test library, wherein the system table structure of the development and test library includes the development and test library data model, the development and test library page model and the development and test library process model, and the entity structure of the development and test library metamodel map includes the development and test library data model metamodel map, the development and test library page model metamodel map and the development and test library process model metamodel map; The entity structure of the production library metamodel map is determined according to the system table data structure of the production library, wherein the system table structure of the production library includes the production library data model, the production library page model and the production library process model, and the entity structure of the production library metamodel map includes the production library data model metamodel map, the production library page model metamodel map and the production library process model metamodel map.

[0017] The low-code database merging method of the incremental metamodel map provided by the present invention realizes the merging of the low-code databases in the case of isolation of the development and test environment and the production environment by constructing an incremental metamodel map. Due to the construction of the incremental metamodel map, the foreign key relationship is replaced by the edge relationship of the metamodel map. When the two databases are merged through the metamodel map entity triple, the entity and the entity relationship are synchronized, and the foreign key ID value is not synchronized. After the merger, the consistent foreign key ID value is determined according to the primary key value of each table in the production library and the entity relationship of the triple, which effectively avoids the error of merging the two libraries due to the inconsistent growth of the primary key ID of the development and test library and the production library. In addition, when the development and test library and the production library are merged, the business table structure is not synchronized, but the business metamodel is synchronized first, and then the business metamodel generates the business table structure through the low-code system rules, so that the consistency of the business table structure and the business metamodel can be accurately guaranteed, and the business table structure and the business metamodel can be effectively prevented from being modified arbitrarily in the low-code database by executing SQL statements, resulting in the inconsistency error between the business table structure and the data metamodel, thereby avoiding high-risk problems such as the system being unable to read the business table normally. Therefore, the low-code database merging method of the incremental metamodel graph provided by the present invention can efficiently realize the merging of low-code databases when the development and testing environment is isolated from the production environment. BRIEF DESCRIPTION OF THE DRAWINGS

[0018] The accompanying drawings are used to provide further understanding of the present invention and constitute a part of the specification. Together with the following specific embodiments, they are used to explain the present invention, but do not constitute a limitation of the present invention.

[0019] Figure 1 A flowchart of the low-code database merging method for the incremental metamodel graph provided by the present invention.

[0020] Figure 2 A schematic diagram of the specific implementation process of the low-code database merging of the incremental metamodel graph provided by the present invention.

[0021] Figure 3 A flow chart of the generation process of the development and test library metamodel map and the production library metamodel map provided by the present invention.

[0022] Figure 4 A flow chart for obtaining an incremental metamodel graph provided by the present invention.

[0023] Figure 5 A flowchart of the synchronous merging of metamodels provided by the present invention.

[0024] Figure 6 A flowchart of determining objects to be synchronized in a production library provided by the present invention.

[0025] Figure 7 A flowchart of mapping entities and attributes of a triple to objects to be synchronized is provided by the present invention.

[0026] Figure 8 A flow chart of determining the foreign key relationship of objects to be synchronized provided by the present invention.

[0027] Fig. 9 A schematic diagram of the specific process of synchronous merging of metamodels provided by the present invention.

[0028] Fig.10 A flow chart for synchronously updating the business table structure in the production library provided by the present invention.

[0029] Fig.11 A specific flow chart for automatically updating the business table structure in the production library provided by the present invention. DETAILED DESCRIPTION

[0030] It should be noted that, in the absence of conflict, the embodiments of the present invention and the features in the embodiments may be combined with each other. The present invention will be described in detail below with reference to the accompanying drawings and in combination with the embodiments.

[0031] In order to enable those skilled in the art to better understand the scheme of the present invention, the technical scheme in the embodiment of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiment of the present invention. Obviously, the described embodiment is only a part of the embodiment of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without making creative work should fall within the scope of protection of the present invention.

[0032] It should be noted that the terms "first", "second", etc. in the specification and claims of the present invention and the above-mentioned drawings are used to distinguish similar objects, and are not necessarily used to describe a specific order or sequence. It should be understood that the data used in this way can be interchanged where appropriate, so as to describe the embodiments of the present invention described herein. In addition, the terms "including" and "having" and any variations thereof are intended to cover non-exclusive inclusions, for example, a process, method, system, product or device that includes a series of steps or units is not necessarily limited to those steps or units clearly listed, but may include other steps or units that are not clearly listed or inherent to these processes, methods, products or devices.

[0033] In this embodiment, a low-code database merging method for incremental metamodel graph is provided. Figure 1 is a flowchart of a low-code database merging method according to an incremental metamodel graph provided in an embodiment of the present invention. Figure 1 As shown, including: S100, constructing the entity structure of the metamodel map of the development and test library according to the system table data of the development and test library, and constructing the entity structure of the metamodel map of the production library according to the system table data of the production library; Specifically, the metamodel graph structure of the development and testing library is created based on the data model, page model and process model in the development and testing library system table; and the metamodel graph structure of the production library is created based on the data model, page model and process model in the production library system table.

[0034] S200, generating a development and test library metamodel map according to the entity structure of the development and test library metamodel map, and generating a production library metamodel map according to the entity structure of the production library metamodel map; Specifically, the metamodel map is produced based on the data model, page model and process model in the development and testing library system table. Since the models and configuration information of the low-code system are mostly stored in the database, the development and testing library is subjected to knowledge extraction, knowledge cleaning, knowledge disambiguation and knowledge association for the relevant information of the data model, page model and process model. The entities, attributes and relationships of the three types of models, data model, page model and process model, are extracted visually to form triples, and the data model map, page model map and process model map are constructed.

[0035] It should be understood that since the metamodel graph structure of the production library is consistent with the metamodel graph structure of the development and testing library, only the data is different, the triple extraction steps are the same as those of the development and testing library metamodel graph, and will not be repeated here.

[0036] S300, incrementally merging the development and test library metamodel map with the production library metamodel map to obtain an incremental metamodel map; Specifically, the merging of the development and test library and the production library mainly involves extracting the parts of the metamodels that have changed in the two libraries and performing incremental merging. Since the metamodel graph of the development and test library and the metamodel graph of the production library have the same structure, except for the inconsistent triples, the incremental metamodel graph is obtained by comparing the triples of the two graphs.

[0037] S400, performing metamodel synchronization and merging of system table data of the production library according to the incremental metamodel graph; Specifically, the incremental metamodel graph triples store the metamodel graph information of changes in the development and test library and the production library, including three categories: data model, process model, and interface model. Each type of model constructs an incremental metadata graph, incremental model graph, incremental metadata graph, and incremental data meta graph respectively.

[0038] Perform metamodel synchronization and merging according to the incremental metamodel graph, and update the metamodel and metadata of the data model, process model, and interface model of the production library.

[0039] S500, synchronously updating the business table structure in the production library according to the data model metamodel map in the incremental metamodel map; Specifically, there is a corresponding relationship between the business metamodel and the business table structure, and the business table structure is described in an extended manner. In order to keep the business metamodel consistent with the business table structure, when the development test library and the production library are merged, the business table structure is not synchronized. Instead, the incremental data model metamodel is first obtained based on the incremental data model metamodel graph, and then the incremental data model metamodel executes the business table generation function according to the low-code system data model construction rules to automatically generate or update the business table structure.

[0040] S600: Perform SQL synchronization on the system table structure and system settings between the development and test library and the production library.

[0041] Specifically, since the system table structure is rarely adjusted and changed, the system setting data only synchronizes business data, so the parameter configuration, data dictionary, and system table structure can be directly synchronized using traditional export SQL. When a merge conflict occurs, the selection is made based on the modification timestamp.

[0042] In summary, the low-code database merging method of the incremental metamodel map provided by the present invention realizes the merging of the low-code databases in the case of isolation of the development and test environment and the production environment by constructing an incremental metamodel map. This method constructs an incremental metamodel map, replaces the foreign key relationship with the edge relationship of the metamodel map, and synchronizes the entity and entity relationship when merging the two libraries through the metamodel map entity triple, and does not synchronize the foreign key ID value. After the merger, the consistent foreign key ID value is determined according to the primary key value of each table in the production library and the entity relationship of the triple, effectively avoiding the error of merging the two libraries due to the inconsistent growth of the primary key ID of the development and test library and the production library. In addition, when the development and test library and the production library are merged, the business table structure is not synchronized, but the business metamodel is synchronized first, and then the business metamodel generates the business table structure through the low-code system rules. In this way, the consistency of the business table structure and the business metamodel can be accurately guaranteed, and the business table structure and the business metamodel can be effectively prevented from being arbitrarily modified by executing SQL statements in the low-code database, resulting in an error that the business table structure is inconsistent with the data metamodel, thereby avoiding high-risk problems such as the system being unable to read the business table normally. Therefore, the low-code database merging method of the incremental metamodel graph provided by the present invention can efficiently realize the merging of low-code databases when the development and testing environment is isolated from the production environment, and the low-code database merging method of the incremental metamodel graph can realize the low-code library merging when both the development and testing library and the production library are modified in a physically isolated environment. Compared with the one-way merging of databases in the prior art where only one database is modified and the other is not modified, it effectively improves the database merging efficiency.

[0043] In an embodiment of the present invention, the entity structure of the metamodel map of the development and test library is constructed according to the system table data of the development and test library, and the entity structure of the metamodel map of the production library is constructed according to the system table data of the production library, including: (1) determining the entity structure of the development and test library metamodel map according to the system table structure of the development and test library, wherein the system table structure of the development and test library includes the development and test library data model, the development and test library page model and the development and test library process model, and the entity structure of the development and test library metamodel map includes the development and test library data model metamodel map, the development and test library page model metamodel map and the development and test library process model metamodel map; In the embodiment of the present invention, the metamodel graph structure is created according to the data model, page model and process model in the development and testing library system table. Specifically, Figure 2 As shown in the figure, the various model entities of the development test library include the following: 1) The data model metamodel map includes four types of entities: data metamodel, data model, metadata and data element.

[0044] The data metamodel entity contains the basic information, attributes, parent-child inheritance relationships, combination relationships, dependency relationships and other attributes of the metamodel; the data model entity includes the business table name, definition and other attributes visually constructed through the low-code system; the metadata entity includes the name, definition, value range, type and other attributes of the business table field visually constructed through the low-code system; the data meta entity includes the definition, value range, type and other attributes of the business table field itself visually constructed through the low-code system.

[0045] 2) The interface model metamodel map includes four types of entities: interface metamodel, interface model, interface metadata and interface data element.

[0046] The interface metamodel includes interface metamodel entities such as layout container metamodel, component interaction metamodel, navigation metamodel, dynamic rendering metamodel, etc.; the interface model includes interface model entities such as list page model, detail page model, chart page model, workflow page model, etc.; the interface metadata includes interface metadata entities such as component attribute metadata, page configuration metadata, component binding metadata, user permission metadata, etc.; the interface data element includes interface data element entities such as basic data type element, business entity data element, calculation data element, enumeration data element, etc.

[0047] 3) The process model metamodel map includes four types of entities: process metamodel, process model, process metadata and process data element.

[0048] The process metamodel includes process metamodel entities such as task metamodel, gateway metamodel, event metamodel, process variable metamodel, and swimlane metamodel; the process model includes process model entities such as sequential process model, parallel process model, conditional branch process model, sub-process model, and loop process model; the process metadata includes process metadata entities such as process definition metadata, process node metadata, process authority metadata, and process monitoring metadata; the process data element includes process data element entities such as business basic data element, object data element, process status data element, and association data element.

[0049] According to the actual system data in the development and test library, the entities, attributes, and relationships of the metamodel map are constructed respectively. There are constraint relationships between the four types of entities, such as the abstract and concrete relationship between the metamodel entity and the model entity, and the belonging relationship between the model entity and the metadata entity. There is a definition-implementation relationship between the metadata entity and the data meta entity. There are also constraint relationships within the entities, such as the reference relationship between the data model entities and the data model metadata entities.

[0050] (2) Determine the entity structure of the production library metamodel map based on the system table data structure of the production library, wherein the system table structure of the production library includes the production library data model, the production library page model and the production library process model, and the entity structure of the production library metamodel map includes the production library data model metamodel map, the production library page model metamodel map and the production library process model metamodel map.

[0051] It should be understood that the production library metamodel map is produced and constructed based on the data model, page model and process model in the production library system table. Since the metamodel map structure is consistent, only the data is different, the specific content of the entity structure of the production library metamodel map can refer to the content description of the entity structure of the development and testing library metamodel map in the previous article.

[0052] In an embodiment of the present invention, the model and configuration information of the low-code system are analyzed. The model of the low-code database is composed of metamodel, model, metadata, and data element. The model is further divided into data model, process model, page model and other types.

[0053] Specifically, the metamodel specifically represents the specification of the elements of the model and the relationships between elements. The metamodel includes abstract specifications of the data model and metadata. The metamodel makes the definition and connection of the model more standardized. The low-code system metamodel includes the data model metamodel, the process model metamodel, the page model metamodel, etc. Among them, the data model metamodel defines the structure and rules of the data model, such as the composition of the database table, field types, data constraints, etc. The process model metamodel is used to standardize the modeling and design of business processes, covering elements such as process nodes, flow conditions, execution order, and their relationships. The page model metamodel mainly abstracts and defines the construction of the user interface, including page layout, component type, component properties, data binding rules, etc.

[0054] The model represents the abstraction of data features. The data model is a structure that combines several related data elements in a certain order. The low-code system model includes data models, process models, page models, etc. The data model describes the data structure, data operations, and data constraints. The process model is used to design and execute business processes. The page model is responsible for visual page construction.

[0055] Metadata represents information about the organization of data, data domains, and their relationships. It is data about data. For example, the metadata of "Project Name" is a description of the field "Project Name". Low-code system metadata includes data model metadata, process model metadata, page model metadata, etc. Among them, data model metadata is the specific instance information of the data model created based on the data model metamodel, including detailed information such as the name of the database table, field name, field length, data type, etc. that are actually created. Process model metadata is relevant data about specific business processes that are configured and run based on the process model metamodel, such as the status of the process instance, the current node, the flow history, approval opinions, etc. Page model metadata is the specific configuration data of the user interface built using the page model metamodel, including the actual attribute values ​​of each component on the page, the specific data source and fields for data binding, and the event handling function of the component.

[0056] A data element represents a data unit described by a series of attributes such as definition, identification, representation, and allowed values. Low-code system data elements include data model data elements, process model data elements, page model data elements, etc. The data model data element is a digital abstract representation of a certain feature or attribute of things in the real world, and is also the most basic element that constitutes a data entity. The process model data element is an abstract representation of each link, operation, condition, etc. in the business process, and is the smallest unit that constitutes the business process. The page model data element is the basic element used to describe the user interface in the page model. It is an abstract representation of the page layout, components and their interactive behaviors, and is the smallest unit that constitutes the user interface.

[0057] The data model, process model, and page model are interdependent. The data model is referenced in the process model and page model, and the process model and page model also have a mutual reference relationship. The metamodel, model, metadata, and data element are interdependent. The metamodel and model have an abstract and concrete relationship, the model and metadata have an affiliation relationship, and the metadata and data element have a definition-implementation relationship. Each model object has a complex relationship of dependency, reference, reference, class and implementation, etc. A complex relationship network has been formed internally. The current association between data is mainly represented by foreign key IDs.

[0058] Since a tabular structure (two-dimensional table) is used to organize model data, when representing the relationship between metadata, it is usually necessary to use foreign keys or joint queries, etc., which is relatively cumbersome. Therefore, an embodiment of the present invention uses a knowledge graph to organize the low-code system metamodel. The knowledge graph is a semantic network based on a graph data structure that can represent and store low-code model knowledge in a structured manner.

[0059] Metamodels, models, metadata, and data elements are all represented as entities. The relationship between entities can be represented by edges (relationships), such as the relationship between metamodels and models, the relationship between models and metadata, and the relationship between metadata and data elements. The attributes of an entity are used to describe the detailed characteristics of the entity. For example, the attributes of a metamodel include the rules and structures it defines, the attributes of a model include the specific business logic it describes, the attributes of metadata include the name and type of the data, and the attributes of a data element include the specific value and constraints of the data.

[0060] It should be understood that the metamodel graph, a graph data structure, is very advantageous for processing complex relationships between models and models, and between data and data. It can clearly display the associations and dependencies between metadata, and can easily find the relationships between metadata, thereby improving the discoverability and relevance of metadata.

[0061] Since the metamodel graph does not directly store foreign key ID values ​​but uses edge relationships instead of foreign key relationships, it can effectively avoid the problem of inconsistent growth of primary key IDs in the development and testing library and the production library. In addition, by expanding the entity relationship through edge relationships, more edge relationship information can be stored.

[0062] It should be noted that Figure 2 It only illustrates the situation of synchronizing the production library when the development and test library is modified. Those skilled in the art should understand that the low-code database merging method based on the incremental metamodel graph is also applicable when the development and test library needs to be synchronized for production library modification. Therefore, the low-code database merging method based on the incremental metamodel graph in an embodiment of the present invention can realize the merged generation of low-code libraries when both libraries are modified.

[0063] In an embodiment of the present invention, a development and test library metamodel map is generated according to the entity structure of the development and test library metamodel map, and a production library metamodel map is generated according to the entity structure of the production library metamodel map. Figure 3 As shown, including: S210, performing knowledge extraction, knowledge cleaning, knowledge disambiguation and knowledge association on the entity structure of the development and test library metamodel map and the entity structure of the production library metamodel map respectively; S220, respectively extracting entities, attributes and relationships of the entity structure of the development and test library metamodel map and the entity structure of the production library metamodel map to form a development and test library metamodel map triple and a production library metamodel map triple; S230, generating a development and testing library metamodel graph according to the development and testing library metamodel graph triples, and generating a production library metamodel graph according to the production library metamodel graph triples.

[0064] Specifically, the metamodel map is produced based on the data model, page model and process model in the development and testing library system table. Since the models and configuration information of the low-code system are mostly stored in the database, the development and testing library is subjected to knowledge extraction, knowledge cleaning, knowledge disambiguation and knowledge association for the relevant information of the data model, page model and process model. The entities, attributes and relationships of the three types of models, data model, page model and process model, are extracted visually to form triples, and the data model map, page model map and process model map are constructed.

[0065] When mapping the metamodel data in the test development library to the knowledge graph, a "direct mapping" process is required to map the table to a triple RDF class, the table columns are mapped to triple RDF attributes, and each row of data is mapped to a resource or entity. In the current two-library merge process, the two-library merge errors are often caused by confusion in foreign key IDs. The most effective method is to avoid foreign key IDs during synchronization. Replace the foreign key ID value with the identifier IRI of the entity it points to. When querying the relationship between entities in the knowledge graph, there is no need to rely on the foreign key ID value, and the association between entities can be represented and queried through the relationship path. Even if the foreign key ID value is not stored, it can be achieved by defining and applying various constraints and rules, and using ontology languages ​​such as RDFS or OWL to define the attributes and relationships of entities, as well as the constraints between them, to maintain data consistency and integrity. Among them, the data required for metamodel graph generation is shown in Table 1 below.

[0066] Table 1 Data table required for metamodel graph production

[0067]

[0068] It should be noted that the data model, page model and process model in the production library system table are used to produce and build the production library metamodel map. Since the metamodel map structure is consistent, only the data is different, the triple extraction steps are the same as the development and test library metamodel map generation, and will not be repeated here.

[0069] In an embodiment of the present invention, the development and test library metamodel map and the production library metamodel map are incrementally merged to obtain an incremental metamodel map, such as Figure 4 As shown, including: S310, constructing an initial set of incremental triples; Specifically, a set SET is selected to assist the operation, which is used to store the triples in the two graphs. The two knowledge graphs are traversed respectively, and the triples therein are added to the created set in sequence.

[0070] S320, performing triple comparison between the development and test library metamodel graph and the production library metamodel graph, and obtaining a first triple that exists in the production library metamodel graph and does not exist in the development and test library metamodel graph, and a second triple that exists in the development and test library metamodel graph and does not exist in the production library metamodel graph; Specifically, different triples are obtained by finding the difference between two sets. For example, set A stores the triples of the development and test library graph, and set B stores the triples of the production library graph. Then, by A - B, we can get the different triples that only exist in the development and test library graph, and by B - A, we can get the different triples that only exist in the production library graph.

[0071] S330, performing source marking and status marking on the first triplet and the second triplet respectively; Specifically, the triples are marked with their source (from the development and testing library metamodel map or the production library metamodel map) and status (added, modified, deleted).

[0072] S340, adding the marked first triple and the second triple to the initial set of incremental triples to obtain an incremental metamodel graph.

[0073] Specifically, by adding the labeled triples to the initial set of incremental triples, the incremental metamodel set is (B - A)U(A - B), and then the set is converted into an incremental metamodel graph.

[0074] It should be noted that since both the development and test library and the production library have been modified, when the same triple is modified in both libraries, the triple in the production library will prevail first. When the triple cannot match other triples in the incremental metamodel graph, such as if the corresponding entity cannot be found, the triple in the development and test library will prevail. And the triple in the production library will be marked for subsequent testing and verification after synchronization.

[0075] In the embodiment of the present invention, the system table data of the production library is subjected to metamodel synchronization and merging according to the incremental metamodel graph, such as Figure 5 As shown, including: S410, comparing the entities of the triples of the incremental metamodel graph with the two-dimensional table of models in the production library to determine the objects to be synchronized in the production library; In the embodiment of the present invention, the incremental metamodel map triples store the metamodel map information of the changes in the development and test library and the production library, including three categories: data model, process model, and interface model. Each type of model constructs an incremental metadata map, an incremental model map, an incremental metadata map, and an incremental data metamap. According to the incremental metamodel map, the metamodel synchronization and merging are performed to update the metamodel and metadata of the data model, process model, and interface model of the production library.

[0076] Specifically, the entities of the triples of the incremental metamodel graph are compared with the two-dimensional table of models in the production library to determine the objects to be synchronized in the production library, such as Figure 6 As shown, including: S411, comparing the triple entity of the incremental metamodel graph with the information of the model two-dimensional table in the production library; S412: If the model two-dimensional table in the production library has matching record information with the entities of the triples of the incremental metamodel graph, the model two-dimensional table in the production library is determined to be an object to be synchronized; S413: If the model two-dimensional table in the production library contains record information that does not match the entity of the triple of the incremental metamodel graph, it is determined that the model two-dimensional table in the production library does not need to be synchronized.

[0077] It should be understood that in the embodiment of the present invention, the incremental metamodel graph entity and the model two-dimensional table of the production library are used for comparison. For example, the metadata object to be synchronized is determined by comparing the incremental metadata graph of the data model with the data model metadata system table in the production library. When the model two-dimensional table of the production library contains record information that cannot be matched with the graph entity, it is considered that the model information has not been modified in the test development library and does not need to be synchronized.

[0078] S420, mapping the entities and attributes of the triplet to the object to be synchronized; In the embodiment of the present invention, the entities of the triples are mapped to table records, and the attributes of the triples are mapped to the columns of the table through a direct mapping method.

[0079] Specifically, the entities and attributes of the triples are mapped to the objects to be synchronized, such as Figure 7 As shown, including: S421, mapping the entities of the three-member group of the incremental metamodel graph to the table records in the object to be synchronized according to the direct mapping method, and realizing synchronization of entity values; S422. Map the attributes of the triples of the incremental metamodel graph to the columns of the table in the object to be synchronized according to the direct mapping method, and realize synchronization of the attribute values.

[0080] It should be understood that for entity value synchronization, according to the two-dimensional table name obtained by the entity, the entity value (generally the entity unique identification value) is used to determine whether the table record exists in the production database. If not, it is inserted; if it exists, it is modified. For attribute value synchronization, according to the determined two-dimensional table, the table fields are matched. And the field values ​​corresponding to the table records are modified.

[0081] S430: Determine the foreign key relationship of the object to be synchronized according to the relationship of the triples.

[0082] In the embodiment of the present invention, since the incremental metamodel graph represents the metamodel association through relationships, there is no foreign key ID value comparison when synchronizing the incremental metamodel graph.

[0083] Specifically, the foreign key relationship of the object to be synchronized is determined according to the relationship of the triples, such as Figure 8 As shown, including: S431, matching the foreign key relationship with the object to be synchronized according to the relationship of the triples in the incremental metamodel graph; S432, determine whether the foreign key ID value exists in the production database; S433. If it does not exist, create a new foreign key ID value according to the production library foreign key ID value generator; S434. If it exists, use the existing foreign key ID value as the foreign key ID value of the object to be synchronized.

[0084] It should be understood that the synchronization process for foreign key values ​​is as follows: Fig. 9 As shown, firstly, the foreign key relationship is matched in the two-dimensional table of the model determined in the first step according to the relationship of the triples in the incremental metamodel graph. Then, it is determined whether the foreign key ID value exists in the production library. If not, a new foreign key ID value is created by the production library foreign key ID value generator. If so, the ID value is used as the foreign key ID value. In this way, there is no need to consider the inconsistency between the primary and foreign keys caused by the self-increment of the foreign key ID value, and there will be no foreign key ID misalignment in the development and test library and the production library data.

[0085] In an embodiment of the present invention, the business table structure in the production library is synchronously updated according to the data model metamodel map in the incremental metamodel map, such as Fig.10 As shown, including: S510, acquiring an incremental data model metamodel according to the incremental data model metamodel graph in the incremental metamodel graph; S520: Automatically update the business table structure in the production library according to the business table structure generation function and the incremental data model metamodel.

[0086] In an embodiment of the present invention, the traditional method is to export the business table structure from the development and test library and then synchronize it in the production library. Since the low-code system not only needs to synchronize the table structure when synchronizing the business library structure, but also needs to build a self-incrementing ID generator corresponding to the business table, and at the same time needs to be consistent with the data metamodel, in an embodiment of the present invention, in order to make the business metamodel consistent with the business table structure, when the development and test library and the production library are merged, the business table structure is not synchronized. Instead, the incremental data model metamodel is obtained based on the incremental data model metamodel graph, and then the incremental data model metamodel executes the business table generation function according to the low-code system data model construction rules, automatically generates or updates the business table structure, and automatically sets the self-incrementing primary key ID.

[0087] Therefore, this method of an embodiment of the present invention can effectively prevent the business table structure from being arbitrarily modified by executing SQL statements in a low-code database, causing an error situation in which the business table structure is inconsistent with the data metamodel, thereby avoiding high-risk problems such as the system being unable to read the business table normally.

[0088] More specifically, the business table structure in the production library is automatically updated according to the business table structure generation function and the incremental data model metamodel, such as Fig.11 As shown, including: 1) Determine the order of creating the business table structure in the production library according to the metamodel generation order of breadth-first search; 2) Automatically updating the business table structure according to the business table structure generation function and the incremental data model metamodel in the order in which the business table structure is created.

[0089] Specifically, during the business table generation process, it is necessary to judge the order of business table creation to avoid errors due to the non-existence of foreign key constraints and related references. Therefore, in an embodiment of the present invention, the order of reference relationships can be discovered through the metamodel graph, and the currently existing entities are used as the starting point for sorting out the reference relationships. By using a method of metamodel generation order based on breadth-first search, starting from a given graph entity, along its relationship path with other entities, it is gradually traced up or down to find the bottom-level reference relationship step by step. According to the reverse method, the missing entity is judged first. When an entity is missing, the entity is supplemented first, and then the business table structure of the bottom-level reference relationship is created. Then, according to the parent node, it is checked step by step whether there is a business table that needs to be created, thereby avoiding the failure of business table structure synchronization due to the missing reference entity and the missing foreign key constraint.

[0090] More specifically, the specific implementation steps are as follows: 1) The metamodel graph is G=(V,E), where V is the vertex set (representing business table entities) and E is the edge set (representing foreign key constraint relationships). For any two entities u,v∈V, if table u has a foreign key pointing to table v, then (u,v)∈E.

[0091] 2) Determine the search start node. Based on the currently existing entities and reference relationships, select one or more business table entities from the metamodel graph as the search start node. Let V0⊆V be the set of start nodes. V0 can be those entities that have no foreign key references to other tables, that is, V0={v∈V|∄u∈V,(u,v)∈E}.

[0092] 3) Perform breadth-first search. First, initialize a queue Q and add the nodes in the starting node set V0 to the queue Q. Then traverse the nodes in the queue Q, take out a node v from the queue Q, and process the node. The processing process is as follows: (1) Check whether the entity exists and determine whether the business table entity represented by the current node v already exists. If the entity is missing, you need to add it first.

[0093] (2) If the entity exists or has been supplemented, add it to the list L in the order in which the business table was created.

[0094] (3) Find all adjacent nodes u of the current node v (i.e., other entities connected by foreign key constraints) and add these adjacent nodes u to the queue Q for subsequent processing.

[0095] 4) Repeat the above process of traversing nodes until the queue Q is empty, that is, all nodes have been processed.

[0096] 5) Generate the business table creation order. Arrange the recorded business table creation order list L in reverse order to obtain the final creation order list L'. This ensures that when creating a business table, the underlying entities referenced by other tables are created first, and then the parent node entities are created step by step.

[0097] 6) Create business tables. Create business table structures in reverse order L'. After all tables are created, enable foreign key constraints to ensure that all reference relationships can work properly.

[0098] Therefore, the embodiment of the present invention uses a method of metamodel generation order based on breadth-first search to gradually trace upward or downward through the metamodel graph to find the dependency order relationship of the business table. Reversely create the business table structure according to the dependency order relationship, which can effectively determine the creation order of the business table, avoid the problem of business table structure synchronization failure caused by missing reference entities and missing foreign key constraints during the synchronization of the business table structure, and ensure the integrity and consistency of the database structure.

[0099] The following takes the scientific research contract management function of the scientific research project management system as an example to explain the merger of the development test library and the production library. Through the construction of scientific research contract management, the whole process management of business such as pre-contract preparation, contract signing, contract performance, and contract archiving can be realized, and the record of the contract execution process and the control of the contract execution status can be strengthened. Scientific research contracts have direct or indirect associations with plans, projects, quality, finance, equipment, etc. The scientific research contract management database contains scientific research contract information tables, contract party tables, work node tables, contract funding payment tables, etc.

[0100] In the actual system development and implementation process, the system completes function development in the development and test environment and deploys it to the production environment. Later, according to the changes in user requirements, the functions are modified and adjusted in the development and test environment. At the same time, due to the user's urgent modification requirements, the function is adjusted directly in the production environment by modifying the system low-code configuration.

[0101] In order to realize the normal deployment of scientific research contract management functions, in addition to the front-end and back-end code compilation and deployment, the system database merger is also required.

[0102] First, the contract management data model is sorted out, including the contract management data meta-model, contract management data model, contract management metadata, and contract management data element. For example, the contract management data meta-model includes the name, attributes, primary key and other basic information of the data meta-model, as well as the inheritance, aggregation and other relationships between models.

[0103] The contract management data model includes table structures such as the scientific research contract information table, contract party table, work node table, contract funding payment table, field definitions, indexes and other physical storage structures, including details such as database selection, table creation, field type and length.

[0104] Scientific research contract metadata includes table name, table annotation, field list, field attributes, etc. Such as table structures such as scientific research contract information table and contract party table, such as contract number, contract name, project number, contract confidentiality level, contract amount, funding unit and other table fields.

[0105] The scientific research contract data element includes the definition, value range, type, etc. of the contract information table field itself, such as the type of each field, column name, meaning, data type, whether it is non-empty, etc.

[0106] (1) Creation of the data model metamodel graph structure. The scientific research contract entities are defined according to the scientific research contract business table, mainly including the scientific research contract information entity, the contract party entity, the contract work node entity, the contract funding payment entity, and the qualified supplier entity. The system configuration entities are defined, including the user entity, the organization entity, and the role entity. The scientific research plan entity, scientific research project entity, scientific research quality entity, scientific research financial entity, scientific research equipment entity, etc. that are related to the scientific research contract are also defined.

[0107] The attributes of the scientific research contract entity are defined according to the fields of the scientific research contract business table, and the entity relationship is defined according to the table foreign key relationship. For example, the scientific research contract information entity has a belonging relationship with the contract party entity, contract work node entity, contract funding payment entity, and qualified supplier entity. The user entity, organization entity, role entity, scientific research plan entity, scientific research project entity, scientific research quality entity, scientific research financial entity, scientific research equipment entity, and the scientific research contract information entity have a reference relationship.

[0108] (2) Development and test library data model metamodel map production. Through the steps of knowledge extraction, knowledge cleaning, knowledge disambiguation and knowledge association of the data model related information of the development and test library, the entities, attributes and relationships of the data model are visually extracted to form triples, and the data model map is constructed. Through the "direct mapping" process, the table is mapped to a triple RDF class, the column of the table is mapped to a triple RDF attribute, and the foreign key ID value is replaced with the identifier IRI of the entity it points to. For example, the affiliated projects, qualified suppliers, handling units and handling persons in the scientific research contract information entity are not associated through foreign key IDs, but directly point to the scientific research project entity, qualified supplier entity, organization entity and user entity. The foreign key ID of the affiliated scientific research contract in the scientific research plan entity, scientific research project entity, scientific research quality entity, scientific research financial entity and scientific research equipment and materials entity that reference the scientific research contract information entity is also changed to directly point to the scientific research contract information entity.

[0109] (3) Production of metamodel graph of production database data model. In the production environment, since the metamodel graph structure is the same, only the triple data is different, the production database data model triples are extracted according to the "Development and Testing Database Data Model Metamodel Graph Production" step. Similarly, the foreign key ID value is replaced with the identifier IRI of the entity it points to.

[0110] (4) Incremental data model metamodel map generation. Extract the changed parts of the metamodel in the two databases for incremental merging. Generate incremental changes in scientific research contract information entities, contract party entities, contract work node entities, contract funding payment entities, qualified supplier entities, etc.

[0111] (5) Synchronize the incremental data model metamodel graph. Through the "direct mapping" method, the triple entities, including the scientific research contract information entity, the contract party entity, the contract work node entity, the contract funding payment entity, and the qualified supplier entity, are mapped to the table records, and the triple attributes are mapped to the table columns. For the foreign key ID value, the production library shall prevail. If there is no foreign key ID value, a new foreign key ID value shall be created.

[0112] (6) Automatically generate and synchronize the business table structure based on the data model metamodel map. Obtain the incremental data model metamodel according to the incremental metamodel map, and call the system business table structure generation function to automatically generate the business table structure and related configuration according to the low-code metamodel logic rules. For example, add the "Contract Nature" field to the scientific research contract information table, delete the "Whether to Review" field in the contract work node table, etc.

[0113] (7) Synchronization of system table structure and system settings. During the implementation of the contract management function, the system table structure was not adjusted. The financial account information referenced by the "Reporting Account" field of the "Contract Fund Payment" business table was updated, and the first-level "Material Cost" and its subordinate accounts were added. These system setting adjustments were synchronized through SQL synchronization.

[0114] In summary, the low-code database merging method of the incremental metamodel graph provided by the present invention has the following advantages: 1) In view of the fact that the prior art uses a table structure (two-dimensional table) to organize low-code system model data, when expressing the relationship between metadata, it is usually necessary to implement it through foreign keys or joint queries, etc., which is a relatively cumbersome problem. The embodiment of the present invention uses a metamodel graph to represent and store low-code system data models, page models, and process model knowledge, clearly showing the associations and dependencies between metadata, and can easily find the relationships between metadata, thereby improving the discoverability and relevance of metadata.

[0115] 2) In view of the fact that in the prior art, due to the synchronous modification of the development and test library and the production library, the models and configurations of the two libraries will have the increase of primary key ID and foreign key ID respectively, resulting in primary key ID conflicts, foreign key associations or data association confusion when the two libraries are merged, the embodiment of the present invention adopts an incremental metamodel graph synchronization method to construct three types of metamodel graphs for low-code system data models, page models and process models, including four entities: metamodel, data model, metadata and data element. The foreign key relationship is replaced by the edge relationship of the metamodel graph, and the foreign key ID value is replaced with the identifier IRI of the entity it points to. When the two libraries are merged through the metamodel graph entity triples, the entities and entity relationships are synchronized, but the foreign key ID values ​​are not synchronized. After the merge, a consistent foreign key ID value is determined based on the primary key values ​​of each table in the production library and the entity relationship of the triples. Effectively avoid the error of merging the two libraries due to the inconsistent growth of the primary key IDs of the development and test library and the production library.

[0116] 3) In the embodiment of the present invention, the business metamodel of the low-code system is stored in the system table. When the development and test library and the production library are merged, if the business table is synchronized by executing the business table structure SQL, there may be omissions in the synchronization of the configuration information related to the business table, and there may be modifications to the business table outside the low-code system, resulting in errors such as inconsistency between the business table structure and the data metamodel. When the development and test library and the production library are merged, the embodiment of the present invention does not synchronize the business table structure, but first synchronizes the business metamodel, and then generates the business table structure from the business metamodel through the low-code system rules. In this way, the consistency of the business table structure and the business metamodel can be accurately guaranteed, and the business table configuration, such as the self-increment ID generator, can be automatically constructed. It effectively prevents the business table structure from being arbitrarily modified by executing SQL statements in the low-code database, resulting in errors such as inconsistency between the business table structure and the data metamodel, thereby avoiding high-risk problems such as the system being unable to read the business table normally.

[0117] 4) In view of the fact that foreign key constraints exist in business tables in the prior art, the traditional method for batch creating business table structures is to disable all constraints first, and then enable them after all are imported. Although all have been imported, there may be missing references, resulting in unsuccessful enabling. In the embodiment of the present invention, the method of generating the order of metamodels based on breadth-first search is used to gradually trace upward or downward through the metamodel graph to find the dependency order of the business table. The business table structure is reversely created according to the dependency order, thereby avoiding the failure of business table structure synchronization due to missing reference entities and missing foreign key constraints.

[0118] It is to be understood that the above embodiments are merely exemplary embodiments used to illustrate the principles of the present invention, but the present invention is not limited thereto. For those of ordinary skill in the art, various modifications and improvements can be made without departing from the spirit and essence of the present invention, and these modifications and improvements are also considered to be within the scope of protection of the present invention.

Claims

1. A low-code database merging method for incremental metamodel graphs, characterized in that: include: Constructing the entity structure of the metamodel graph of the development and test library according to the system table data of the development and test library, and constructing the entity structure of the metamodel graph of the production library according to the system table data of the production library; Generate a development and test library metamodel map according to the entity structure of the development and test library metamodel map, and generate a production library metamodel map according to the entity structure of the production library metamodel map; Incrementally merging the development and test library metamodel map with the production library metamodel map to obtain an incremental metamodel map; Performing metamodel synchronization and merging of system table data of the production library according to the incremental metamodel graph; Synchronously updating the business table structure in the production library according to the data model metamodel map in the incremental metamodel map; Perform SQL synchronization on the system table structure and system settings between the development and test library and the production library.

2. The low-code database merging method of the incremental metamodel graph according to claim 1 is characterized in that: Incrementally merging the development and test library metamodel map with the production library metamodel map to obtain an incremental metamodel map, including: Construct an initial set of incremental triples; Compare the development and test library metamodel graph with the production library metamodel graph in triples to obtain a first triple that exists in the production library metamodel graph and does not exist in the development and test library metamodel graph, and a second triple that exists in the development and test library metamodel graph and does not exist in the production library metamodel graph; Marking the source and the status of the first triplet and the second triplet respectively; The marked first triple and the second triple are added to the initial set of incremental triples to obtain an incremental metamodel graph.

3. The low-code database merging method of the incremental metamodel graph according to claim 1 is characterized in that: Performing metamodel synchronization and merging of the system table data of the production library according to the incremental metamodel graph includes: Compare the entities of the triples of the incremental metamodel graph with the two-dimensional table of models in the production library to determine the objects to be synchronized in the production library; Map the entities and attributes of the triple to the objects to be synchronized; The foreign key relationship of the object to be synchronized is determined based on the relationship of the triples.

4. The low-code database merging method of the incremental metamodel graph according to claim 3 is characterized in that: Comparing the entities of the triples of the incremental metamodel graph with the two-dimensional table of models in the production library to determine the objects to be synchronized in the production library, including: Compare the entities of the triples of the incremental metamodel graph with the information of the two-dimensional table of models in the production library; If the model two-dimensional table in the production library has matching record information with the entities of the triples of the incremental metamodel graph, the model two-dimensional table in the production library is determined to be the object to be synchronized; If the model two-dimensional table in the production library contains record information that does not match the entity of the triple of the incremental metamodel graph, it is determined that the model two-dimensional table in the production library does not need to be synchronized.

5. The low-code database merging method of the incremental metamodel graph according to claim 3 is characterized in that: Map the entities and attributes of the triple to the objects to be synchronized, including: Mapping the entities of the three-member group of the incremental metamodel graph to the table records in the object to be synchronized according to the direct mapping method, and realizing synchronization of entity values; According to the direct mapping method, the attributes of the triples of the incremental metamodel graph are mapped to the columns of the table in the object to be synchronized, and synchronization of the attribute values ​​is achieved.

6. The low-code database merging method of the incremental metamodel graph according to claim 3 is characterized in that: Determine the foreign key relationship of the object to be synchronized based on the relationship of the triples, including: Match the foreign key relationship with the object to be synchronized according to the relationship of the triples in the incremental metamodel graph; Determine whether the foreign key ID value exists in the production database; If it does not exist, create a new foreign key ID value based on the production database foreign key ID value generator; If it exists, the existing foreign key ID value will be used as the foreign key ID value of the object to be synchronized.

7. The low-code database merging method of the incremental metamodel graph according to any one of claims 1 to 6, characterized in that: Synchronously updating the business table structure in the production library according to the data model metamodel map in the incremental metamodel map, including: Acquire an incremental data model metamodel according to the incremental data model metamodel graph in the incremental metamodel graph; The business table structure in the production library is automatically updated according to the business table structure generation function and the incremental data model metamodel.

8. The low-code database merging method of the incremental metamodel graph according to claim 7 is characterized in that: Automatically updating the business table structure in the production library according to the business table structure generation function and the incremental data model metamodel includes: Determine the order of creating the business table structure in the production library based on the metamodel generation order of breadth-first search; The business table structure is automatically updated according to the business table structure generation function and the incremental data model metamodel in the order in which the business table structure is created.

9. The low-code database merging method of the incremental metamodel graph according to any one of claims 1 to 6, characterized in that: Generating a development and test library metamodel map according to the entity structure of the development and test library metamodel map, and generating a production library metamodel map according to the entity structure of the production library metamodel map, including: Respectively performing knowledge extraction, knowledge cleaning, knowledge disambiguation and knowledge association on the entity structure of the development and test library metamodel map and the entity structure of the production library metamodel map; Respectively extract entities, attributes and relationships of the entity structure of the development and test library metamodel map and the entity structure of the production library metamodel map to form a development and test library metamodel map triple and a production library metamodel map triple; A development and test library metamodel map is generated according to the development and test library metamodel map triples, and a production library metamodel map is generated according to the production library metamodel map triples.

10. The low-code database merging method of the incremental metamodel graph according to any one of claims 1 to 6, characterized in that: The entity structure of the metamodel graph of the development and test library is constructed according to the system table data of the development and test library, and the entity structure of the metamodel graph of the production library is constructed according to the system table data of the production library, including: Determine the entity structure of the development and test library metamodel map according to the system table structure of the development and test library, wherein the system table structure of the development and test library includes the development and test library data model, the development and test library page model and the development and test library process model, and the entity structure of the development and test library metamodel map includes the development and test library data model metamodel map, the development and test library page model metamodel map and the development and test library process model metamodel map; The entity structure of the production library metamodel map is determined according to the system table data structure of the production library, wherein the system table structure of the production library includes the production library data model, the production library page model and the production library process model, and the entity structure of the production library metamodel map includes the production library data model metamodel map, the production library page model metamodel map and the production library process model metamodel map.

Images