CN117971225A - Method for automatically generating java development codes based on various database tables - Google Patents
Method for automatically generating java development codes based on various database tables Download PDFInfo
- Publication number
- CN117971225A CN117971225A CN202311580216.5A CN202311580216A CN117971225A CN 117971225 A CN117971225 A CN 117971225A CN 202311580216 A CN202311580216 A CN 202311580216A CN 117971225 A CN117971225 A CN 117971225A
- Authority
- CN
- China
- Prior art keywords
- database
- code
- data
- generated
- codes
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000011161 development Methods 0.000 title claims abstract description 50
- 238000000034 method Methods 0.000 title claims abstract description 50
- 238000012423 maintenance Methods 0.000 claims description 12
- 238000012545 processing Methods 0.000 claims description 12
- 230000008569 process Effects 0.000 claims description 10
- 238000013461 design Methods 0.000 claims description 7
- 238000003339 best practice Methods 0.000 claims description 4
- 230000008878 coupling Effects 0.000 claims description 4
- 238000010168 coupling process Methods 0.000 claims description 4
- 238000005859 coupling reaction Methods 0.000 claims description 4
- 238000012217 deletion Methods 0.000 claims description 4
- 230000037430 deletion Effects 0.000 claims description 4
- 230000003252 repetitive effect Effects 0.000 claims description 4
- 230000006870 function Effects 0.000 claims description 3
- 230000002776 aggregation Effects 0.000 claims description 2
- 238000004220 aggregation Methods 0.000 claims description 2
- 230000003416 augmentation Effects 0.000 claims description 2
- 238000004891 communication Methods 0.000 claims description 2
- 239000012141 concentrate Substances 0.000 claims description 2
- 238000004519 manufacturing process Methods 0.000 claims description 2
- 238000013508 migration Methods 0.000 claims description 2
- 230000005012 migration Effects 0.000 claims description 2
- 238000003860 storage Methods 0.000 claims 1
- 230000009897 systematic effect Effects 0.000 claims 1
- 230000008859 change Effects 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000008901 benefit Effects 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000007774 longterm Effects 0.000 description 1
- 238000013507 mapping Methods 0.000 description 1
- 230000002035 prolonged effect Effects 0.000 description 1
Abstract
The invention discloses a method for automatically generating java development codes based on various database tables, which relates to the field of software development, in particular to a method for automatically generating java development codes based on various database (mysql, postgres, orcle) tables according to set templates.
Description
Technical Field
The invention relates to the field of software development, in particular to a method for automatically generating java development codes based on various database tables.
Background
In the software development process, a developer needs to define a database table according to requirements and manually write corresponding development codes to realize the operation on the database, and the method is low in efficiency, and aims at the problems that code writing specifications are often nonuniform and necessary code factors are lacking, so that a method for automatically generating the development codes based on various database tables is needed to improve development efficiency and accuracy.
The existing method for generating java development codes still has the following defects:
1. Low development efficiency: in the conventional manual code writing manner, a developer needs to spend a great deal of time and effort to write and debug the code, which results in prolonged development period and low efficiency.
2. The code quality is unstable: manually writing codes is prone to errors and vulnerabilities, and particularly in complex business scenarios, developers may ignore some details or use non-canonical coding styles, resulting in unstable code quality.
3. The technical threshold is high: traditional manual code writing requires developers to be familiar with the knowledge of various aspects such as database table structures, programming languages, related frameworks and the like, and has high technical requirements for the developers.
4. Lack of flexibility: the traditional manual code writing mode is difficult to adapt to the change of the demands of different business scenes, and once the demands change, a large amount of codes are required to be modified, so that the workload is large.
5. Poor maintainability: traditional manually written code may vary in structure and style, making code maintenance and upgrades difficult, resulting in difficult long-term maintenance of the system.
Disclosure of Invention
A method for automatically generating java development codes based on various database tables comprises the following specific steps:
step S1: is connected to a database: connecting to the database by providing the location, user name and password of the database using a suitable library;
step S2: reading a database table structure: obtaining structural information of a database table by using a query statement or a system table, wherein the structural information comprises information such as table names, field types, field notes and the like;
Step S3: template selection: performing configuration work of templates by selecting different code templates (mybatis, jpa, mybatis-plus);
Step S4: generating codes: generating corresponding development codes according to the acquired table structure information, wherein the generated codes can comprise entity classes, DAO classes, service classes and the like;
Step S5: processing relation: if there are relationships in the table, such as foreign key relationships, these relationships need to be processed in the generated code;
Step S6: CRUD generation method: for each table, create, read, update, delete (CRUD) and batch (add, modify, delete) methods are generated to create, read, update, or delete records in the database.
Further, in step S1, after connecting to the database, the application program may communicate with the database by sending a database query statement or executing a database operation command, may query, insert, update or delete data in the database, execute operations such as transactions, etc., after connecting to the database, the application program may interact with the database through a database connection object, execute various database operations, may create, modify, delete database objects such as a database table, view, store a procedure, etc., manage the structure of the database, after connecting to the database, the application program may open transactions, perform atomic execution of multiple database operations, ensure consistency and integrity of data, and after connecting to the database, the application program may put the connection object into a connection pool for management, so as to obtain available connections from the connection pool when needed, and improve efficiency and performance of database access.
Further, in step S2, by reading the table structure of the database, the information of the table name, the field type, etc. can be known, so as to help the database administrator perform database design and maintenance work, for example, suitable indexes, constraints and association relationships can be determined according to the table structure, so as to optimize database performance, the program developer can know the table and field definitions in the database by reading the table structure of the database, so as to correctly use and process data in an application program, for example, when writing SQL query sentences, the table name and the field name need to be known to correctly retrieve and operate data, when performing data migration or database synchronization operation, reading the table structure of the database can help to ensure that the target database is consistent with the table structure of the source database, which is very important for migrating data from one environment (such as development environment) to another environment (such as production environment), reading the table structure can be used for automatically generating database documents or reports, including detailed descriptions of the table and the field, data type, length limitations, default values, etc. can help users to correctly use the database structure, for writing SQL query sentences, reading the table name and field names, accurately retrieving and analyzing the table name, and field names, and checking the data types can further accurately analyze the data, and checking the quality of the data, and checking the data types and fields, and checking quality problems, etc. can be guaranteed.
Further, in step S3, the code template may automatically generate a commonly used code structure, reduce repetitive labor, through selecting a suitable code template, the developer may quickly generate codes such as basic augmentation and deletion operations, entity classes, data access objects, etc., saving time and effort for manually writing the codes, the code template may generally follow a certain coding specification and style, through selecting a suitable code template, it may be ensured that the developers in the team keep consistent in code style, this helps to improve the readability and maintainability of the code, reduce problems caused by style differences, the automatically generated code template is tested and verified, and is generally more reliable than the manually written code, selecting a mature and verified code template may reduce errors and BUG, improve the quality and stability of the code, different code templates may generally be applied to different frames and technical stacks, through selecting a code template suitable for the frame and technical stack used in the current project, may quickly conform to the best practice of the frame, the code template may generally be configured and customized, the personnel may support the development and custom requirements may be adjusted according to the specific project, and the custom requirements may be satisfied, and the custom requirements may be generated according to the custom requirements.
Further, in step S4, by automatically generating the code, the developer can save time and effort for writing repeated and templated codes, the generated code provides an infrastructure required by projects, the developer can concentrate on realization of business logic, development speed is increased, the generated code is based on table structure information, consistency of the code and a database model is ensured, thus problems such as misspelling and field type mismatch which may occur in the handwritten code can be avoided, accuracy and stability of the code are improved, the generated code generally conforms to best practices and design principles, good readability and maintainability are achieved, the subsequent code maintenance work is simpler and more efficient, maintenance cost is reduced, the generated code generally conforms to a certain coding specification and style, team cooperation efficiency is improved, unification of the codes enables the developer to understand and maintain each other codes more easily, communication and cooperation cost is reduced, the generated code comprises components such as a Data Access Object (DAO) and a business logic layer (Service), the like, the database operation interface can be provided, the database can be conveniently and quickly searched by calling the database can be simplified, and the development operation is realized.
Further, in step S5, by correctly processing the association relationships between tables, the integrity of data can be ensured, for example, when external key association is used in the database, the generated code should be able to correctly process cascade update and deletion, avoiding the occurrence of orphan data or inconsistency, the generated code should be able to conveniently perform cross-table query and operation, by processing the association relationships between tables, the developer should be able to more easily perform complex data query, connection and aggregation operations, improving development efficiency, for business logic involving multiple tables, processing the association relationships may simplify writing of codes, the generated code should be able to provide a convenient way to process business logic between multiple tables, reducing workload of the developer, when the ORM framework is used, the association relationships between processing tables may help the framework to correctly map the association relationships between objects, so that the developer can more naturally operate objects, without paying much attention to the association relationships at the bottom layer of the database, the generated code should contain complete association relationship definitions, so that other developers can quickly understand and use the association relationships, and access and maintain the complete interface by using the generated code, thereby providing complete access and maintenance of the interface can be reduced.
Further, in step S6, the CRUD method is generated to help the developer standardize the database operation, so that the operations of adding, deleting and checking the database are more standard and unified, thus ensuring that all database operations follow the same interface and standard, reducing the problems caused by different implementation modes of different developers, reducing repetitive and mechanical code writing work, improving the development efficiency, reducing the coupling degree between different modules, improving the flexibility and the scalability of the system, and ensuring that the generated CRUD method is automatically generated based on the table structure information, reducing the risk of human coding errors, improving the accuracy and the stability of the code, avoiding potential bug introduced by human negligence, providing a unified data access interface by the generated CRUD method, enabling other parts of the application program to conveniently call the methods to perform the database operations, reducing the coupling degree between different modules, improving the flexibility and the scalability of the system, ensuring that the generated method is better in the best design and the best in the practical applicability and the better in the practical applicability, and the better maintenance of the system.
Based on various database tables, the invention aims to improve the efficiency and accuracy of software development, reduce the workload of manual code writing, reduce the technical threshold of developers, avoid errors and vulnerabilities occurring when the codes are written manually by automatically generating the development codes, automatically generate corresponding entity class, DAO class, service class and other codes according to the structure of the database tables, greatly simplify the development flow, improve the development efficiency, and in addition, the automatically generated development codes can also be subjected to customized development according to the needs of different Service scenes, thereby ensuring that the development is more flexible and extensible.
1. Development efficiency is improved: by automatically generating the development codes, the workload of manually writing the codes can be greatly reduced, the development period is shortened, and the development efficiency is improved;
2. improving the code quality: the automatically generated development codes can be automatically generated according to the structure of the database table, so that errors and loopholes generated when the codes are manually written are avoided, and the quality of the codes is improved;
3. the development threshold is reduced: the technical requirements on developers can be reduced by automatically generating the development codes, so that the developers can be more focused on the realization of business logic, and the complex codes are not written;
4. the flexibility is high: the customized development can be carried out according to the needs, so that the requirements of different service scenes are met, and the development is more flexible and extensible;
5. The maintainability is strong: the development code automatically generated can be modified and optimized according to the needs, so that the maintenance and the upgrading are convenient;
Therefore, the invention has higher practicability and innovation, higher practical value and economic benefit, and has wide application prospect in the technical field of computers.
Detailed Description
The subject matter described herein will now be discussed with reference to example embodiments, it being understood that these embodiments are discussed only to enable a person skilled in the art to better understand and thereby achieve the subject matter described herein, and are not limiting of the scope, applicability, or examples set forth in the claims, that changes may be made in the function and arrangement of the elements discussed without departing from the scope of the disclosure, that various processes or components may be omitted, substituted, or added as needed, that various processes or components may be omitted, or added, that the methods described may be performed in a different order than described, and that various steps may be added, omitted, or combined, that features described with respect to some examples may be combined in other examples,
As used herein, the terms "comprises," "comprising," and variants thereof mean "including but not limited to," the terms "based on," which mean "based at least in part on," the terms "one embodiment" and "an embodiment" mean "at least one embodiment," the terms "another embodiment" mean "at least one other embodiment," the terms "first," "second," etc. may refer to different or the same objects, and may include other definitions below, whether explicit or implicit, the definition of a term being consistent throughout the specification unless the context clearly dictates otherwise,
Examples
A method for automatically generating java development codes based on various database tables comprises the following specific steps:
step S1: is connected to a database: connecting to the database by providing the location, user name and password of the database using a suitable library;
step S2: reading a database table structure: obtaining structural information of a database table by using a query statement or a system table, wherein the structural information comprises information such as table names, field types, field notes and the like;
Step S3: template selection: performing configuration work of templates by selecting different code templates (mybatis, jpa, mybatis-plus);
Step S4: generating codes: generating corresponding development codes according to the acquired table structure information, wherein the generated codes can comprise entity classes, DAO classes, service classes and the like;
Step S5: processing relation: if there are relationships in the table, such as foreign key relationships, these relationships need to be processed in the generated code;
Step S6: CRUD generation method: for each table, create, read, update, delete (CRUD) and batch (add, modify, delete) methods are generated to create, read, update, or delete records in the database.
In step S1 of the algorithm, connecting to the database in this step we can use JDBC (Java Database Connectivity) in Java to connect to the database. First, the appropriate database driver needs to be loaded, and then a database connection is established by providing the location, user name and password of the database.
In step S2, the structure information of the database table is generally obtained by executing an SQL query statement or reading a system table. For example, the information such as TABLE NAME, field type, etc. may be obtained by executing SQL statements such as SHOW TABLES and DESCRIBE table_name.
In step S3, the template selection is performed, and different code templates, such as MyBatis, JPA, myBatis-Plus, etc., may be selected according to actual requirements. Corresponding configuration work such as configuration entity class annotation, configuration DAO interface XML mapping file and the like is required to be carried out aiming at different templates.
In step S4, the generating code may use a template engine (such as FREEMARKER or Velocity) to generate corresponding development codes including entity class, DAO class, service class, etc. according to the acquired table structure information and the selected template. Corresponding code files may be generated in the template by traversing the table structure information.
Processing relationships if there are relationships in the database table, such as foreign key relationships, the generated code needs to process the relationships appropriately, such as adding association notes (e.g., @ OneToMany, @ ManyToOne) in the entity class or writing an association query in the DAO interface, in step S5.
In step S6, the CRUD generation method generates, for each table, a corresponding CRUD method including Create, read, update, delete and a batch operation method according to the structure information and the template of the table. The methods can directly operate database records to complete corresponding data operation functions.
It will be appreciated by persons skilled in the art that various changes and modifications may be made to the above-disclosed embodiments without departing from the spirit of the invention, and therefore the scope of the invention is to be defined by the appended claims,
It should be noted that, not all the steps and units in the above flowcharts and the system configuration diagrams are necessary, some steps or units may be omitted according to actual needs, the execution sequence of each step is not fixed, and may be determined according to needs, the apparatus structures described in the above embodiments may be physical structures or logical structures, that is, some units may be implemented by the same physical entity, some units may be implemented by multiple physical entities, or some components in multiple independent devices may be implemented together,
The detailed description set forth above describes example embodiments, but does not represent all embodiments that may be practiced or that fall within the scope of the claims, and the use of the term "exemplary" throughout this specification is meant to be "serving as an example, instance, or illustration," preferred "or" advantageous "over other embodiments, for the purpose of providing an understanding of the described technology, including specific details, however, such technology may be practiced without these specific details, and in some instances, well-known structures and devices are shown in block diagram form in order to avoid obscuring the concepts of the described embodiments,
The foregoing description of the disclosure is provided to enable any person of ordinary skill in the art to make or use the disclosure, and various modifications to the disclosure will be readily apparent to those of ordinary skill in the art and the general principles defined herein may be applied to other variations without departing from the scope of the disclosure, and thus the disclosure is not limited to the examples and designs described herein but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.
Claims (7)
1. A method for automatically generating java development codes based on various database tables is characterized in that: the method comprises the following specific steps:
step S1: is connected to a database: connecting to the database by providing the location, user name and password of the database using a suitable library;
step S2: reading a database table structure: obtaining structural information of a database table by using a query statement or a system table, wherein the structural information comprises information such as table names, field types, field notes and the like;
Step S3: template selection: performing configuration work of templates by selecting different code templates (mybatis, jpa, mybatis-plus);
Step S4: generating codes: generating corresponding development codes according to the acquired table structure information, wherein the generated codes can comprise entity classes, DAO classes, service classes and the like;
Step S5: processing relation: if there are relationships in the table, such as foreign key relationships, these relationships need to be processed in the generated code;
Step S6: CRUD generation method: for each table, create, read, update, delete (CRUD) and batch (add, modify, delete) methods are generated to create, read, update, or delete records in the database.
2. The method for automatically generating java development code based on various database tables according to claim 1, wherein: in step S1, after connecting to the database, the application program may communicate with the database by sending a database query statement or executing a database operation command, may query, insert, update or delete data in the database, execute operations such as transactions, etc., after connecting to the database, the application program may interact with the database through a database connection object, execute various database operations, may create, modify, delete database objects such as database tables, views, storage processes, etc., manage structures of the database, after connecting to the database, the application program may open transactions, perform atomic execution of multiple database operations, ensure consistency and integrity of data, after connecting to the database, the application program may place the connection object in a connection pool for management, so as to obtain available connections from the connection pool when needed, and improve efficiency and performance of database access.
3. The method for automatically generating java development code based on various database tables according to claim 1, wherein: in step S2, by reading the table structure of the database, the name of the table, the field name, the field type, etc. can be known, so as to help the database administrator perform database design and maintenance work, for example, suitable indexes, constraints and association relationships can be determined according to the table structure, so that the program developer can know the table and field definitions in the database by reading the table structure of the database, so that the data can be used and processed correctly in the application program, for example, when writing SQL query sentences, the table name and the field name need to be known to search and operate the data correctly, when performing data migration or database synchronization operation, reading the table structure of the database can help to ensure that the target database is consistent with the table structure of the source database, which is very important for migrating the data from one environment (such as development environment) to another environment (such as production environment), reading the table structure can be used for automatically generating database documents or reports, including details of the table and the fields, data type, length limitations, default values, etc., which can help the user to analyze the database structure, perform systematic analysis and document, obtain the data types, check the data types and check the data, and check the quality of the data, and check the data types and confirm that the quality of the data is inconsistent, and the data quality is not required to be matched with the data types.
4. The method for automatically generating java development code based on various database tables according to claim 1, wherein: in step S3, the code templates can automatically generate commonly used code structures, reduce repetitive labor, through selecting a suitable code template, a developer can quickly generate codes of basic augmentation and deletion operations, entity classes, data access objects and the like, time and effort for manually writing the codes are saved, the code templates generally follow a certain coding specification and style, through selecting a suitable code template, the developer in a team can be ensured to keep consistent in code style, which is helpful for improving the readability and maintainability of the codes, problems caused by style differences are reduced, the automatically generated code templates are tested and verified, and are generally more reliable than manually written codes, mature and verified code templates are selected to reduce errors and the generation of BUG, the quality and stability of the codes are improved, different code templates are generally applicable to different frames and technical stacks, the code templates suitable for the current project are selected, the basic skeleton of the project can be quickly used, and the best practice of the frame is met, the code templates are generally configurable and customizable according to the specific requirements of the project, the developer can be customized according to the specific project, the customization requirements are met, and the customization requirements are met.
5. The method for automatically generating java development code based on various database tables according to claim 1, wherein: in step S4, by automatically generating the code, the developer can save the time and effort of writing repeated and templated codes, the generated code provides the infrastructure required by the project, the developer can concentrate on the realization of business logic, the development speed is accelerated, the consistency of the generated code and a database model is ensured based on table structure information, thus the problems of misspelling, field type mismatch and the like possibly occurring in the handwritten code can be avoided, the accuracy and stability of the code are improved, the generated code generally conforms to the best practice and design principle, the readability and maintainability are good, the subsequent code maintenance work is simpler and more efficient, the maintenance cost is reduced, the generated code generally conforms to a certain coding specification and style, the team cooperation efficiency is improved, the unification of the code style enables the developer to understand and maintain the codes of each other more easily, the communication and cooperation cost is reduced, the generated code comprises components such as a data access object (o) and a business logic layer (Service), the database operation interface can be provided, the database operation can be simplified, the database can be conveniently and quickly deleted by calling the DAoperator to realize the complex operation of generating the generated code, and the database is improved.
6. The method for automatically generating java development code based on various database tables according to claim 1, wherein: in step S5, by correctly processing the association relationships between tables, the integrity of data can be ensured, for example, when external key association is used in a database, the generated code should be able to correctly process cascade update and deletion, avoiding the occurrence of orphan data or inconsistency, the generated code should be able to conveniently perform cross-table query and operation, by processing the association relationships between tables, the developer should be able to easily perform complex data query, connection and aggregation operations, improving development efficiency, for business logic involving multiple tables, processing the association relationships may simplify the writing of code, the generated code should be able to provide a convenient way to process business logic between multiple tables, reducing the workload of developer, when an ORM framework is used, the association relationships between processing tables may help the framework to correctly map the association relationships between objects, so that the developer can more naturally operate objects without paying much attention to the association relationships at the bottom layer of the database, the generated code should contain complete association relationship definitions, so that other developer can quickly understand and use the association relationships, and the difficulty of accessing the subsequent data can be more completely and consistently maintained by generating the generated code.
7. The method for automatically generating java development code based on various database tables according to claim 1, wherein: in step S6, the CRUD method is generated to help the developer standardize the database operation, so that the operations of adding, deleting and checking the database are more standard and unified, thus ensuring that all database operations follow the same interface and standard, reducing the problems caused by different implementation modes of different developers, reducing repetitive and mechanical code writing work, improving development efficiency, reducing the coupling degree between different modules, improving the flexibility and the feasibility of the system, and ensuring that the generated CRUD method is automatically generated based on the table structure information, reducing the risk of human coding errors, improving the accuracy and the stability of the code, avoiding potential bug introduced by human negligence, providing a unified data access interface by the generated CRUD method, enabling other parts of the application program to conveniently call the methods to perform database operations, reducing the coupling degree between different modules, improving the flexibility and the feasibility of the system, and ensuring that the generated method has better design and better expandability and better practical and maintenance functions.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311580216.5A CN117971225A (en) | 2023-11-24 | 2023-11-24 | Method for automatically generating java development codes based on various database tables |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311580216.5A CN117971225A (en) | 2023-11-24 | 2023-11-24 | Method for automatically generating java development codes based on various database tables |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN117971225A true CN117971225A (en) | 2024-05-03 |
Family
ID=90850623
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311580216.5A Pending CN117971225A (en) | 2023-11-24 | 2023-11-24 | Method for automatically generating java development codes based on various database tables |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117971225A (en) |
-
2023
- 2023-11-24 CN CN202311580216.5A patent/CN117971225A/en active Pending
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10289396B2 (en) | Source code translation | |
| US8903762B2 (en) | Modeling data exchange in a data flow of an extract, transform, and load (ETL) process | |
| WO2020233330A1 (en) | Batch testing method, apparatus, and computer-readable storage medium | |
| US7689582B2 (en) | Data flow system and method for heterogeneous data integration environments | |
| US8392880B2 (en) | Rapid application development for database-aware applications | |
| US7490098B2 (en) | Apparatus, system, and method for processing hierarchical data in disparate data repositories | |
| US20070214111A1 (en) | System and method for generating code for an integrated data system | |
| Luković et al. | An approach to developing complex database schemas using form types | |
| CN101996131A (en) | Automatic test method and automatic test platform for graphic user interface (GUI) based on x extensive makeup language (XML) packaging key word | |
| US20120324432A1 (en) | Systems and methods to automatically generate classes from api source code | |
| CN113204571B (en) | SQL execution method and device related to write-in operation and storage medium | |
| Ferreira et al. | Patterns for data and metadata evolution in adaptive object-models | |
| CN116821098A (en) | Data warehouse management method, service system and storage medium | |
| CN116360766A (en) | Low-code system and device based on DDD visual designer | |
| US20220075796A1 (en) | Architecture for data map converters | |
| CN117971225A (en) | Method for automatically generating java development codes based on various database tables | |
| CN114860689A (en) | Method and system for migrating data objects between heterogeneous databases | |
| CN113885970A (en) | Method, system and medium for generating report data based on script | |
| CN111427902B (en) | Metadata management method, device, equipment and medium based on lightweight database | |
| CN113297181A (en) | Configuration item management database, data processing method and device | |
| CN112051987B (en) | Service data processing method, device and equipment, program generating method and device | |
| Aboulsamh et al. | Towards a model-driven approach to information system evolution | |
| US11888937B2 (en) | Domain specific provider contracts for core data services | |
| Tok et al. | Microsoft SQL Server 2012 Integration Services | |
| US20240143487A1 (en) | Secure testing of attachment functionality of objects |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication |