Software application generation method, device and equipment and readable storage medium

Abstract

The invention discloses a software application generation method, device and equipment and a readable storage medium, and the method comprises the steps: responding to an operation of dragging a database table to a visual canvas by a user and an operation of selecting a field from the database table, and obtaining a table name of the database table, a target field and a constraint condition of a target parameter; the target field, the target parameter and the constraint condition of the target parameter all come from the database table; and generating an execution script according to the table name of the database table, the target field and the constraint condition of the target parameter, and generating a back-end interface and a front-end page according to the execution script. According to the technical scheme disclosed by the invention, a user only needs to drag the database table to the visual canvas and perform the field selection operation on the database table dragged to the visual canvas, and the server can automatically generate the back-end interface and the front-end page based on the operation of the user, so that the complexity of configuration in a software application generation process is reduced, and the user experience is improved. The generation efficiency and the generation effect of the software application are improved, and the generation cost of the software application is reduced.

Description

Technical Field

[0001] The present application relates to the technical field of software application development, and in particular to a software application generation method, apparatus, device and readable storage medium. Background Art

[0002] A low-code platform is a development tool that builds software applications through a visual interface and drag-and-drop components, which can reduce the amount of manual coding and quickly develop software applications.

[0003] Traditional low-code platforms use drag-and-drop components to build front-end page prototypes, and then bind data to each component in the front-end page prototype to complete page generation and data mapping. This method of generating software applications requires users to define the correspondence between front-end interface elements, back-end interfaces and database fields one by one through a visual interface. Users need to have knowledge reserves such as database design, business logic abstraction and component interaction, resulting in low software application development efficiency and high development costs.

[0004] In summary, how to improve the efficiency of software application generation and reduce the cost of software application generation is a technical problem that needs to be urgently solved by those skilled in the art. Summary of the Invention

[0005] In view of this, the purpose of this application is to provide a software application generation method, apparatus, device and readable storage medium for improving the efficiency of software application generation and reducing the cost of software application generation.

[0006] In order to achieve the above objectives, this application provides the following technical solutions:

[0007] A software application generation method includes: in response to a user's operation of dragging a database table to a visualization canvas and selecting a field from the database table, obtaining the table name, target field, and target parameter constraints of the database table; the target field, the target parameter, and the target parameter constraints are all derived from the database table; generating an execution script based on the table name, the target field, and the target parameter constraints, and generating a back-end interface and a front-end page based on the execution script.

[0008] Optionally, generating an execution script based on the table name of the database table, the target field and the constraints of the target parameters includes: generating a query script based on the table name of the database table, the target field and the constraints of the target parameters, and encapsulating the query script into the execution script.

[0009] Optionally, if there are multiple database tables, the method further includes: in response to a valid connection between the database tables made by the user, obtaining the table name, connection field, and connection direction of the validly connected database table, and determining the connection type according to the connection direction;

[0010] Generate a query script according to the table name of the database table, the target field and the constraint conditions of the target parameter, including: generating a query script according to the table name of the effectively connected database table, the connection field, the connection type, the target field and the constraint conditions of the target parameter.

[0011] Optionally, if the number of levels of effective connections is greater than 1, a query script is generated based on the table name, the connection field, the connection type, the target field, and the constraint conditions of the target parameter of the effectively connected database table, including: determining the database table of the first-level effective connection based on the number of levels of effective connections between the database tables; generating a query statement based on the table name, the connection field, the connection type, the corresponding target field, and the constraint conditions of the corresponding target parameter of the database table of the first-level effective connection; using the query statement as a temporary table, determining the database table that does not participate in the generation of the query statement in another level of effective connection based on the number of levels of effective connections between the database tables, determining the temporary table and the database table that does not participate in the generation of the query statement in the another level of effective connection as the database table of the first-level effective connection, and returning to execute the step of generating the query statement based on the table name, the connection field, the connection type, the corresponding target field, and the constraint conditions of the corresponding target parameter of the database table of the first-level effective connection, until a query statement is generated for the database table of the last level of effective connection to obtain the query script.

[0012] Optionally, before responding to the effective connection made by the user between the database tables, the method further includes: in response to the connection made by the user between the database tables, obtaining the selected fields in the head-end database table and the selected fields in the terminal database table to which the user connects; judging whether the head-end database table and the terminal database table can form an effective connection based on the selected fields in the head-end database table and the selected fields in the terminal database table; if so, displaying a connecting line segment with a connection direction between the selected fields in the head-end database table and the selected fields in the terminal database table; the selected fields in the head-end database table and the selected fields in the terminal database table are the connection fields; if not, refusing to display a connecting line segment with a connection direction between the selected fields in the head-end database table and the selected fields in the terminal database table.

[0013] Optionally, when it is determined that the head-end database table and the end-end database table fail to form a valid connection, the method further includes: displaying a pop-up box indicating connection failure on the visualization canvas.

[0014] Optionally, after obtaining the table name, target field, and target parameter constraints of the database table, the method further includes: converting the table name, target field, and target parameter constraints of the database table on the visualization canvas into data in a preset format;

[0015] Before generating a query script based on the table name of the database table, the target field and the constraint conditions of the target parameter, it also includes: using an association analysis engine to obtain the table name of the database table from the data in the preset format, extracting the target field from the data in the preset format through a projection operation, and identifying the constraint conditions of the target parameter from the data in the preset format through a selection operation.

[0016] Optionally, it also includes: in response to the user's modification operation on the table structure of the database table, obtaining the table name, target fields and target parameter constraints of the database table after the modification operation; generating a new execution script according to the table name, target fields and target parameter constraints of the database table after the modification operation; generating a new back-end interface and a new front-end page according to the new execution script, and using the new back-end interface and the new front-end page to replace the back-end interface and the front-end page generated by the previous execution script; or, comparing the new execution script with the previous execution script to determine an incremental script, and updating the back-end interface and the front-end page generated by the previous execution script according to the incremental script.

[0017] Optionally, if there are multiple database tables, when obtaining the table name, target field, and target parameter constraints of the database table after the modification operation, the method further includes: obtaining the table name, connection field, and connection direction of the database table effectively connected after the modification operation, and determining the connection type after the modification operation according to the connection direction of the database table effectively connected after the modification operation;

[0018] Generate a new execution script according to the table name, target field and target parameter constraints of the database table after the modification operation, including: generate a new execution script according to the table name, connection field, connection type, target field and target parameter constraints of the database table that is effectively connected after the modification operation.

[0019] Optionally, before generating the back-end interface and the front-end page according to the execution script, it also includes: displaying the attribute information of the target field and the attribute information of the target parameter respectively, so that the user can configure the target field and / or the target parameter; or, after generating the back-end interface and the front-end page according to the execution script, it also includes: receiving a first configuration instruction sent by the user, and displaying the attribute information of the target field and / or the attribute information of the target parameter according to the first configuration instruction, so that the user can configure the target field and / or the target parameter.

[0020] Optionally, before generating the front-end page according to the execution script, it also includes: displaying the configuration page so that the user can configure the front-end page on the configuration page; or, after generating the front-end page according to the execution script, it also includes: receiving a second configuration instruction sent by the user, and displaying the configuration page so that the user can configure the front-end page on the configuration page.

[0021] Optionally, after displaying the configuration page, it also includes: obtaining the custom logic slot inserted by the user on the configuration page and the target interface associated with the custom logic slot, so that the front-end page includes the custom logic slot; wherein the custom logic slot is associated with the target interface; and / or, obtaining the trigger inserted by the user on the configuration page and the attributes configured for the trigger, so that the front-end page includes the trigger with the attributes.

[0022] Optionally, generating a front-end page according to the execution script includes: matching a first front-end component of the target field in the front-end page according to business rules and the type of the target field, and matching a second front-end component of the target parameter in the front-end page according to the business rules and the type of the target parameter; generating the front-end page according to the execution script, the target field, the first front-end component, the target parameter and the second front-end component.

[0023] Optionally, before generating the front-end page according to the execution script, the first front-end component, and the second front-end component, the method further includes: determining a layout of the target fields and the first front-end component according to the number of the target fields, and determining a layout of the target parameters and the second front-end component according to the number of the target parameters;

[0024] The front-end page is generated according to the execution script, the target field, the first front-end component, the target parameter and the second front-end component, including: generating the front-end page according to the execution script, the target field, the first front-end component, the target field and the layout of the first front-end component, the target parameter, the second front-end component, the target parameter and the layout of the second front-end component.

[0025] Optionally, it also includes: if the number of target fields is greater than a first preset value and the query result items corresponding to the target fields are greater than a second preset value, then generating a table grouping label corresponding to the target field on the front-end page; wherein, the table grouping label is associated with a sub-page, and the sub-page is used to display the query result items corresponding to the target field.

[0026] Optionally, the database table includes the table name, fields and descriptions of the fields of the database table.

[0027] Optionally, the visualization canvas is included in a graphical interface, which also includes a first information display area; before responding to the user's operation of dragging a database table to the visualization canvas and selecting a field from the database table, it also includes: obtaining at least one database table, and displaying the obtained database table in the first information display area on the graphical interface, so that the user can select the database table from the first information display area and drag it to the visualization canvas.

[0028] Optionally, the graphical interface further includes a second information display area for displaying the target field and the target parameter.

[0029] A software application generation device includes: a first acquisition module, which is used to obtain the table name, target field and target parameter constraints of the database table in response to the user's operation of dragging the database table to a visualization canvas and selecting a field from the database table; the target field, the target parameter and the target parameter constraints are all derived from the database table; and a first generation module, which is used to generate an execution script based on the table name of the database table, the target field and the target parameter constraints, and generate a back-end interface and a front-end page based on the execution script.

[0030] A software application generating device comprises: a memory for storing a computer program; and a processor for implementing the steps of any one of the above-mentioned software application generating methods when executing the computer program.

[0031] A readable storage medium stores a computer program, wherein the computer program, when executed by a processor, implements the steps of any one of the above-mentioned software application generation methods.

[0032] The present application provides a software application generation method, apparatus, device and readable storage medium, wherein the method includes: in response to a user's operation of dragging a database table to a visualization canvas and selecting a field from the database table, obtaining the table name, target field and target parameter constraints of the database table; the target field, target parameter and target parameter constraints are all derived from the database table; generating an execution script based on the table name, target field and target parameter constraints of the database table, and generating a back-end interface and a front-end page based on the execution script.

[0033] With the above-mentioned technical solution disclosed in the present application, the user only needs to drag the database table to the visual canvas and perform field selection operations on the database table dragged to the visual canvas. The server can automatically generate an execution script based on the user's operation, and can automatically generate a back-end interface and a front-end page based on the execution script to complete the generation of the software application. In this way, during the generation process of the software application, the user only needs to understand the database table structure to complete the full-stack development, without the need to learn front-end and back-end technologies, without the need to switch between multiple modules or manually maintain cross-level rules. The table-driven one-stop configuration can eliminate the multi-module separation problems such as data models, interfaces, and interfaces in the low-code platform as much as possible, thereby achieving extreme simplicity of operation, reducing the complexity of configuration during the software application generation process, improving the generation efficiency and generation effect of the software application, and reducing the generation cost of the software application.

[0034] Additional aspects and advantages of the present application will be given in part in the description below, and in part will become apparent from the description below, or will be learned through practice of the present application. BRIEF DESCRIPTION OF THE DRAWINGS

[0035] Figure 1 A flowchart of a software application generation method provided in an embodiment of the present application;

[0036] Figure 2 A flowchart of another software application generation method provided in an embodiment of the present application;

[0037] Figure 3 A schematic diagram of a user dragging a database table to a visualization canvas provided in an embodiment of the present application;

[0038] Figure 4 A schematic diagram of a generated front-end page provided in an embodiment of the present application;

[0039] Figure 5 A schematic diagram of the configuration page provided in an embodiment of the present application. DETAILED DESCRIPTION

[0040] In the field of enterprise information system development, traditional software development involves product managers determining business requirements through research, communication meetings, and business department discussions, then drawing interface prototypes. Front-end and back-end developers then independently develop based on the interface prototypes, and after verification, the products are launched. Business personnel and product managers lack coding skills, front-end developers lack back-end coding skills, and back-end development differs from front-end coding. This results in low overall development efficiency and an inability to keep up with the explosive growth of business needs. This is why low-code platforms have emerged. Low-code platforms are development tools that use a visual interface and drag-and-drop components to build software applications, reducing manual coding and enabling rapid software application development. Traditional low-code platforms use drag-and-drop components to build front-end page prototypes, then bind data to each component in the front-end page prototype to complete page generation and data mapping, leading to configuration difficulties.

[0041] Specifically, traditional low-code development faces the following technical challenges in the process of rapidly developing software applications:

[0042] 1. Configuration complexity and learning cost are too high

[0043] Traditional low-code platforms generally employ configuration models based on form design, process orchestration, or drag-and-drop interfaces, requiring users to possess knowledge of database design, business logic abstraction, and component interaction. For example, when creating a business system, users must separately configure multiple independent modules, including data models, form layouts, permission rules, and interface logic, and must understand the relationships between these modules. This decentralized configuration approach leads to redundant steps and poorly coupled configuration items. Non-technical personnel require professional training to master the platform, severely limiting the universal applicability of low-code platforms.

[0044] 2. High mapping cost between business entities and implementation layer

[0045] Traditional low-code platforms require users to define the relationships between front-end interface elements, back-end interfaces, and database fields through a visual interface, creating a layer-by-layer mapping from "business requirements → interface layer → logic layer → persistence layer." This process requires manual maintenance of cross-layer association rules, which is not only inefficient but also prone to system errors caused by inconsistent configurations. For example, when a business entity attribute changes, form controls, interface parameters, and database table structures must also be modified simultaneously.

[0046] To this end, the present application provides a software application generation method, apparatus, device and readable storage medium. The user only needs to drag the database table to the visual canvas and perform field selection operations on the database table on the visual canvas. Then, the server can generate a back-end interface and a front-end page according to the user's dragging operation, thereby realizing a simple and clear way to generate the back-end interface and the front-end page by dragging the database table, solving the problem of simultaneous development, joint debugging and deployment of the front and back ends, reducing the complexity of configuration in the software application generation process, improving the generation efficiency and generation effect of the software application, and reducing the generation cost of the software application.

[0047] The following describes in detail embodiments of the present application, examples of which are shown in the accompanying drawings, wherein the same or similar reference numerals throughout represent the same or similar elements or elements having the same or similar functions. The embodiments described below with reference to the accompanying drawings are exemplary and are intended to be used to explain the present application, and should not be construed as limiting the present application.

[0048] See also Figure 1 , which is a flowchart of a software application generation method provided in an embodiment of the present application. The software application generation method provided in an embodiment of the present application may include:

[0049] S11: In response to the user's operation of dragging a database table to the visualization canvas and selecting a field from the database table, the table name, target field, and target parameter constraints of the database table are obtained; the target field, target parameter, and target parameter constraints are all derived from the database table.

[0050] It should be noted that the execution entity of the software application generation method provided in the embodiment of the present application can be a low-code platform, and the low-code platform is deployed in the server. Therefore, the execution entity of the software application generation method provided in the embodiment of the present application can also be the server where the low-code platform is located.

[0051] Before the software application is generated, the server can perform data source maintenance. For details, see Figure 2, which is a flowchart of another software application generation method provided by an embodiment of the present application. Exemplarily, the URL (Uniform Resource Locator) of the data source (specifically, the URL of the data source required by the user to generate the software application) can be obtained, and the original database table can be imported into the server based on the URL. For example: at least one original database table in the database (for example, all original database tables in the database) is imported into the server based on the URL. Considering that the original database table may contain not only fields but also data, in order to facilitate users to operate the database table clearly and intuitively, the table name, field, field description, field constraints (wherein, the field constraints can be hidden in the database table) and other information can be extracted from each original database table when the original database table is imported into the server to form a database table, and the database table can be displayed on a graphical interface. The graphical interface may include a visualization canvas and an information display area. For example, it may include at least two information display areas (one information display area (referred to as a first information display area) may be used to display database tables, and the other information display area (referred to as a second information display area) may be used to display target fields and target parameters, etc.). It should be noted that, in order to facilitate the presentation of more database tables on the graphical interface, the database tables may only display the table names.

[0052] When the user needs to generate a software application, the database table can be selected from the database tables displayed in the graphical interface, and the selected database table can be dragged and dropped into the visual canvas. It should be noted that if the database table only displays the table name of the database table in the information display area, the table name, fields and field descriptions of the database table can be presented when the user drags the database table onto the visual canvas, so that the user can operate the database table dragged onto the visual canvas. Among them, the visual canvas can be rendered using Canvas technology. In addition, the user's dragging operation and other operations on the visual canvas can be captured by the event monitoring module in the server, that is, when the user drags the database table to the visual canvas, the event monitoring module in the server can monitor the user's operation of dragging the database table to the visual canvas, and the table name of the database table dragged by the user can be obtained, that is, in response to the user dragging the database table to the visual canvas, the server (specifically, the event monitoring module in the server) can obtain the table name of the database table.

[0053] After the user drags the database table onto the visual canvas, he can select a field from the database table. During this process, the event listening module in the server can listen to the field selected by the user, obtain the target field and target parameter, and determine the constraint conditions of the target parameter based on the obtained target parameter. That is, in response to the user's operation of selecting a field from the database table, the server (specifically, the event listening module in the server) can obtain the target field, target parameter, and the constraint conditions of the target parameter. Among them, the target field and target parameter can both be derived from the database table dragged by the user onto the visual canvas, and the constraint conditions of the target parameter can be included in the database table dragged by the user onto the visual canvas or can be obtained based on the database table. It should be noted that the target field can be directly derived from the database table or indirectly derived from the database table, for example, it can be a target field generated by calculating, converting, or combining fields in the database table. In addition, the target parameter can be directly derived from the database table or indirectly derived from the database table (in this case, the constraint conditions of the target parameter can be determined in an indirect manner). The target field is used to control the content and structure of the query results (that is, it is used to determine the query results); the target parameter is used as a filter field for users to filter the query results based on the target parameter. The target parameter's constraints are used to filter the data rows that meet the conditions.

[0054] Specifically, the server can obtain the target field and target parameters according to the way the user selects the field from the database table. Figure 3 , which is a schematic diagram of a user dragging a database table to a visualization canvas provided in an embodiment of the present application.

[0055] For the target field, for example, when the user selects a field according to the first selection method, the selected field can be determined as the target field (that is, the field selected according to the first selection method is determined as the target field). For example, a field in the database table that is not determined as a target field can have an add button (such as Figure 3 ), when the user clicks the Add button, the corresponding field can be determined as the target field; when the user selects a field according to the second selection method, the selected field can be deleted from the target field (that is, the field selected according to the second selection method is deleted from the target field). For example, a field in the database table that is determined as a target field can have a Delete button next to it (such as Figure 3 ), the user clicks the Delete button to delete the corresponding field from the target field. It should be noted that to reduce user operations, the server can default to all fields contained in the first database table (i.e., the main table) dragged by the user as the target field. Of course, the server can also default to the target field being empty.

[0056] For the target parameter, illustratively, when the user selects a field according to the third selection method, the selected field can be determined as the target parameter (i.e., the field selected according to the third selection method is determined as the target parameter). For example, a field in the database table that has not been determined as a target parameter can be clicked by the user. When the user clicks on a field that has not been selected as a target parameter, the corresponding field can be determined as the target field. After the user selects a field according to the third selection method, the field in the database table that is determined as the target parameter can be marked with a first identifier (e.g., Figure 3 ) to indicate that the corresponding field has been selected as the target parameter; when the user selects a field according to the fourth selection method, the selected field can be deleted from the target parameter (that is, the field selected according to the fourth selection method is deleted from the target parameter), for example: the target parameter can be displayed in the information display area on the visual canvas, and the user can use the delete button on the keyboard or other methods to choose to delete the corresponding target parameter from the target parameters displayed in the information display area, wherein, on the basis that the field determined as the target parameter in the database table has a first identifier, when the target parameter is deleted based on the user's fourth selection method, the first identifier of the corresponding field in the database table can be deleted.

[0057] In addition, the visualization canvas can also include a name editing component (i.e., corresponding table-level attribute configuration) for users to define business logic labels (for example, the order table requires an audit log) to generate the names of the execution script, back-end interface, and front-end page (where the names of the execution script, back-end interface, and front-end page can be the same).

[0058] S12: Generate an execution script according to the table name, target field, and target parameter constraints of the database table, and generate a backend interface and a frontend page according to the execution script.

[0059] Based on step S11, the server may generate an execution script based on the obtained table name, target field, and target parameter constraints of the database table. For example, the server may first generate a query script (including the table name, target field, and target parameter constraints) based on the obtained table name, target field, and target parameter constraints of the database table, and then package the query script into an execution script that can be executed by the program (the execution script is an execution unit within the software application, and the query results can be obtained by executing the execution script).

[0060] After generating the execution script, the server can generate a back-end interface and a front-end page according to the generated execution script to realize the generation of the software application. Among them, the generated back-end interface can be used as a calling unit for external calls, and the generated back-end interface can be specifically a RESful API (Representational State Transfer Application Programming Interface) interface, and the generated front-end page can be bound to the generated back-end interface, and the front-end page can include the target field (or can also include the query results corresponding to the target field obtained by executing the generated execution script), and the target parameter (used as a filter field for the user to filter the query results on the front-end page). In addition, when the database table dragged by the user to the visual canvas is a single table, the generated back-end interface can be a single-table operation interface (add, delete, modify, and query), and the parameter verification logic can be automatically generated according to the field constraints.

[0061] From the above, it can be seen that the embodiment of the present application breaks the original low-code design idea, and thinks of having data first and then pages, so as to confirm the parameters and field information of the page according to the data, and accordingly designs a method of dragging the database table into the visual canvas instead of the traditional method of dragging components into the visual canvas as the starting point for software application generation. That is, the embodiment of the present application reshapes the starting point of low-code development and no longer relies on components to build pages. The final effect is that the user drags the database table directly into the visual canvas, the system automatically parses the table structure, and presents it in the form of standardized entity units such as the database table name, field, and field description, so that the user can operate the database table on the visual canvas and automatically generate software applications based on the user's operation, which greatly reduces the complexity of the operation, improves the efficiency of software application generation, and reduces the cost of software application generation.

[0062] In the software application generation process provided by the embodiment of the present application, users only need to understand the structure of the business table to complete full-stack development, without having to learn the technical details of the front-end and back-end, thus achieving extreme simplicity of operation. Moreover, through table-driven one-stop configuration, the problem of multi-module separation such as data models, interfaces, and interfaces in traditional low-code platforms is eliminated as much as possible. That is, the embodiment of the present application successfully solves the problems of high configuration complexity and high mapping cost in traditional low-code platforms through a database table-driven visual mapping solution, and achieves significant technical effect improvement, which is specifically reflected as follows:

[0063] 1. Improved configuration efficiency and ease of use

[0064] Through the visual configuration mode of the database mapping canvas, users can complete full-stack configuration by simply dragging and dropping database tables. There is no need to switch between multiple modes or manually maintain cross-level rules. This solves the configuration complexity and high learning cost problems of traditional software application generation methods:

[0065] Streamlined operation steps: Compared with traditional low-code platforms that require independent configuration of data models, interfaces, interfaces and other modules, the embodiments of this application can reduce the complexity of full-stack development and compress the full-stack development steps.

[0066] Reduced learning costs: Non-technical personnel can master core operations through a short training period. Users only need to understand the table structure and do not need to know technical details such as front-end components and interface protocols.

[0067] 2. Business entity mapping costs are significantly reduced

[0068] Based on the full-stack automated generation mechanism of table structures, the server system completes the full-link mapping from "database → backend interface → front-end page", solving the high mapping cost problem between business entities and implementation layers in traditional software application generation methods:

[0069] Improved cross-level mapping efficiency: Traditional platforms require defining field mapping rules layer by layer, which takes about 30 minutes per table. However, the embodiments of the present application can achieve zero manual mapping (efficiency can be improved by 100%).

[0070] Improved configuration effect: By automatically generating execution scripts, back-end interfaces, and front-end pages, configuration consistency can be ensured.

[0071] In summary, the embodiments of the present application can shorten the development cycle (the time taken for the entire process from need to upper limit is shortened from 5-10 days on traditional low-code platforms to less than 1 day (simple scenarios) or 3 days (complex scenarios)), reduce maintenance costs (system error troubleshooting time is reduced by 90%, and the failure rate due to inconsistent configuration is close to zero), and expand applicability (through minimalist operation and highly scalable design, non-technical personnel (such as business analysts) can directly participate in system construction, and user group coverage can be increased by more than 40%). In other words, the embodiments of the present application achieve a comprehensive improvement in low-code development efficiency, quality, and universality through table-driven one-stop configuration and full-stack automated generation, providing efficient tool support for rapidly iterating digital transformation scenarios.

[0072] From the above, it can be seen that in the above-mentioned solution disclosed in the embodiment of the present application, the user only needs to drag the database table to the visual canvas and perform field operations on the database table on the visual canvas. The server can automatically generate an execution script based on the user's operation, and can automatically generate a back-end interface and a front-end page based on the execution script to complete the generation of the software application. In this way, during the generation process of the software application, the user only needs to understand the database table structure to complete the full-stack development, without the need to learn front-end and back-end technologies, without the need to switch between multiple modules or manually maintain cross-level rules. The table-driven one-stop configuration can eliminate the multi-module separation problems such as data models, interfaces, and interfaces in the low-code platform as much as possible, achieve extreme simplicity of operation, reduce the complexity of configuration during the software application generation process, improve the generation efficiency and generation effect of the software application, and reduce the generation cost of the software application.

[0073] An embodiment of the present application provides a method for generating a software application, which generates an execution script based on the table name, target field, and target parameter constraints of a database table, and may include:

[0074] Generate a query script based on the table name, target field, and target parameter constraints of the database table, and encapsulate the query script into an execution script.

[0075] In an embodiment of the present application, when the server generates an execution script based on the table name, target field, and target parameter constraints of a database table, it can first generate a query script based on the table name, target field, and target parameter constraints of the database table. For example, the query script can be a SQL (Structured Query Language) script, where the table name of the database table can correspond to the "from" clause in the SQL script, the target field can correspond to the "select" clause in the SQL script, and the target parameter constraints can correspond to the "where" clause in the SQL script. Of course, other query scripts can also be used, such as NoSQL query scripts, search engine query scripts, etc.

[0076] After the query script is generated, the generated query script can be encapsulated into an execution script, so that the program can directly execute the generated execution script to obtain the execution result.

[0077] The software application generation method provided in the embodiment of the present application may further include:

[0078] In response to a valid connection between database tables by a user, obtaining the table name, connection field, and connection direction of the validly connected database table, and determining the connection type according to the connection direction;

[0079] Generate a query script based on the database table name, target fields, and target parameter constraints, which can include:

[0080] Generate a query script based on the table name, connection field, connection type, target field and target parameter constraints of the effectively connected database table.

[0081] In an embodiment of the present application, when a user drags a database table to a visualization canvas, the user can drag a database table to the visualization canvas and select fields from the database table, so that the system generates a corresponding execution script, back-end interface, and front-end page according to the user's dragging operation on a database table.

[0082] Alternatively, the user can also drag multiple database tables to the visual canvas. In this case, the user can not only select fields from the database tables, but also connect between database tables. Among them, the event monitoring module can monitor the user's operations on the visual canvas in real time and can capture the Cartesian coordinate trajectory of the user's dragging operation in real time. When the user connects between database tables, it can determine whether a valid connection can be formed between the database tables. For example, when the user connects to the primary key of the target table through the foreign key field, a valid connection is formed between the corresponding database tables. It should be noted that the type of valid connection between database tables (that is, the association type between database tables, the server can automatically determine the association type between database tables based on the user's operation) can be: 1:1, 1:N, N:M, and multiple levels of valid connections can be formed between database tables. The relationship between the valid connections between database tables can be stored using a graph database. In addition, when the user drags multiple database tables to the visualization canvas, the event listening module in the server can not only obtain the constraints of the target fields and target parameters, but also obtain the table name or other identifier of the database table corresponding to the target field to indicate the database table from which the target field originates, and can obtain the table name or other identifier of the database table corresponding to the target parameter to indicate the database table from which the target parameter originates.

[0083] When a user establishes a valid connection between database tables, the server (specifically, the event listening module in the server) may obtain the table name of the validly connected database table, the connection field of the validly connected database table, and the connection direction of the validly connected database table in response to the valid connection between the database tables by the user, and may determine the connection type of the validly connected database table according to the connection direction of the validly connected database table. The relationship between the connection direction and the connection type may be preset. Based on the above, the connection type of the validly connected database table may be determined according to the relationship between the preset connection direction and the connection type and the connection direction of the validly connected database table (for example, inner join). Left Outer Join For example, the connection type corresponding to the connection direction to the right (i.e., the connection arrow points to the right) may be a left connection, the connection type corresponding to the connection direction to the left (i.e., the connection arrow points to the left) may be a right connection, and the connection type corresponding to the connection direction to both sides (i.e., there are connection arrows at both ends) may be an inner connection. It should be noted that the connection type can be a natural connection. or theta connection.

[0084] On the basis of the above, the server can generate a query script according to the table name, target field and target parameter constraints of the database table, specifically as follows: generate a query script according to the table name, connection field, connection type, target field and target parameter constraints of the effectively connected database table. Exemplarily, the query script can be a SQL script, the table name of the effectively connected database table can correspond to from in the SQL script, the connection field can correspond to on in the SQL script (and the connection field can correspond to select in the SQL script), the connection type can correspond to join in the SQL script, the target field can correspond to select in the SQL script, and the target parameter constraints can correspond to where in the SQL script. After generating the query script according to the table name, connection field, connection type, target field and target parameter constraints of the effectively connected database table, the back-end interface and front-end page can be generated according to the generated query script. Among them, when the user drags multiple database tables onto the visualization canvas and a valid connection is formed between the database tables, the generated back-end interface can be a multi-table cascading query interface (supporting complex query parameter mapping of cross-table JOIN): parsing table association paths, generating JOIN query statements (such as "order table → customer table → address table" generates a nested query); automatically mapping query parameters.

[0085] It should be noted that if the number of levels of effective connections between database tables is 1, a query script can be directly generated based on the table name, connection field, connection type, target field, and target parameter constraints of the effectively connected database tables. If the number of levels of effective connections between database tables is greater than 1, a query statement can be first generated based on the table name, connection field, connection type, target field, and target parameter constraints of the first-level effectively connected database tables (when the query script is an SQL script, the query statement here is the SQL statement), and the query statement is used as a temporary table. A query statement is generated based on the temporary table and the table name, connection field, connection type, target field, and target parameter constraints of the database tables in the adjacent levels that are not involved in the query statement generation, and the above step of using the query statement as a temporary table is returned to execute until a query statement is generated for the database tables of the last level of effective connection to obtain a query script.

[0086] The final effect is that the relationship between tables is realized through connection interaction: the user drags the foreign key field to connect the value to the primary key field of the target table. The server automatically identifies the association type and generates the corresponding database cascade constraints (such as JOIN query logic and transaction consistency rules). The final query script contains field information, table relationships (including table join conditions), and query conditions.

[0087] In the aforementioned software application generation, through the visual configuration mode of the database mapping canvas, users can complete full-stack configuration by simply dragging and dropping database tables and connecting lines to define relationships. There is no need to switch between multiple modes or manually maintain cross-level rules. This solves the configuration complexity and high learning cost problems of traditional software application generation methods:

[0088] Streamlined Operational Steps: Compared to traditional low-code platforms that require independent configuration of data models, interfaces, and user interfaces, this embodiment of the application can reduce the complexity of full-stack development, compressing the full-stack development steps by over 60%. For example, when creating a business system with three related tables, the traditional method requires configuring 12 independent modules, while this solution can be completed by simply dragging the data tables and drawing the connection lines.

[0089] Lower learning costs: Non-technical personnel can master core operations in 2 hours of training (traditional platforms require more than 5 days). Users only need to understand the table structure and do not need to know technical details such as front-end components and interface protocols.

[0090] Furthermore, based on the full-stack automated generation mechanism of table structures, the server system completes the full-link mapping from "database → backend interface → front-end page", solving the high mapping cost problem between business entities and implementation layers in traditional software application generation methods:

[0091] Improved cross-level mapping efficiency: Traditional platforms require defining field mapping rules layer by layer, which takes about 30 minutes per table. However, the embodiments of the present application can achieve zero manual mapping (efficiency can be improved by 100%).

[0092] Automated relationship processing: The generation time of multi-table cascade query interfaces is reduced from 2 hours in traditional ORM (Object Relational Mapping) frameworks to within 10 seconds (supporting N:M complex relationship scenarios). Join table query SQL and transaction consistency rules are automatically generated to avoid manual coding errors.

[0093] As can be seen from the above, the embodiment of the present application simplifies the complex business system configuration into intuitive operations of table structures and relationships through a database table-driven visual mapping mechanism.

[0094] A software application generation method provided in an embodiment of the present application may include generating a query script based on the table name, connection field, connection type, target field, and target parameter constraints of the effectively connected database table if the number of valid connection levels is greater than 1, and may include:

[0095] According to the number of levels of effective connections between database tables, determine the first-level database tables of effective connections;

[0096] Generate a query statement based on the table name, connection field, connection type, corresponding target field and corresponding target parameter constraints of the first-level effectively connected database table;

[0097] The query statement is used as a temporary table, and the database table corresponding to the other level of effective connection is determined according to the number of levels of effective connection between database tables. The temporary table and the database table corresponding to the other level of effective connection are determined as the database table of the first level of effective connection. Return to execute the step of generating a query statement according to the table name, connection field, connection type, corresponding target field and corresponding target parameter constraint conditions of the first level of effective connection, until a query statement is generated for the database table of the last level of effective connection to obtain a query script.

[0098] In an embodiment of the present application, if the number of database tables is greater than 2 and the number of levels of effective connections between database tables is greater than 1, the process of generating a query script based on the table name, connection field, connection type, target field, and target parameter constraints of the effectively connected database tables may specifically be:

[0099] Step 1: Determine the first-level effectively connected database tables based on the number of levels of effective connections between database tables. Specifically, the last-level effectively connected database tables can be determined based on the number of levels of effective connections between database tables. That is, the last-level effectively connected database tables can be determined first in ascending order of the effective connections, so that the first-level effectively connected database tables can be determined last. This facilitates positioning the target field in the first data table (i.e., the main table) dragged by the user within the outer query statement. When the query script is an SQL script, the query statement here is an SQL statement.

[0100] Step 2: Generate a query statement based on the table name of the aforementioned first-level effectively connected database table, the connection field of the first-level effectively connected database table, the connection type of the first-level effectively connected database table, the target field corresponding to the first-level effectively connected database table, and the constraint conditions of the target parameter corresponding to the first-level effectively connected database table. In this process, the database table at the first end of the determined first-level effectively connected database table (specifically, the database table that is first dragged to the visualization canvas, and can also be called the left table in the first-level effectively connected database table when the user arranges the database tables from left to right) can be determined as a temporary main table, and the database table at the second end of the determined first-level effectively connected database table (specifically, the database table that is later dragged to the visualization canvas, and can also be called the right table in the first-level effectively connected database table when the user arranges the database tables from left to right) can be determined as a child table.

[0101] Step 3: Use the query statement generated in Step 2 as a temporary table, that is, the table generated by the query statement generated in Step 2 as a temporary table. This means that the temporary table can be renamed using the p rename operation. Furthermore, the database tables in the other level (i.e., the previous level) of the valid connection that are not involved in the query statement generation can be determined based on the number of levels of valid connections between database tables. Subsequently, the temporary table and the database tables in the other level of valid connections that are not involved in the query statement generation can be determined as database tables in a first-level valid connection. The process then returns to the step of generating a query statement based on the table name, connection fields, connection type, corresponding target fields, and corresponding target parameter constraints of the first-level valid connection database tables, i.e., returning to Step 2. Steps 2 and 3 are repeated until a query statement is generated for the database tables in the last level of valid connections (i.e., until a query statement is generated for the database tables in the first level of valid connections), thereby obtaining a query script. Upon returning to Step 2, the database tables in the other level of valid connections that are not involved in the query statement generation can be determined as temporary primary tables, and the temporary tables can be determined as child tables.

[0102] For example, the user drags database table 1, database table 2, database table 3, and database table 4 to the visualization canvas in sequence, and first forms a first-level valid connection between database table 1 and database table 2, then forms a second-level valid connection between database table 2 and database table 3, and then forms a third-level valid connection between database table 3 and database table 4. Based on this, the process of generating a query script can be:

[0103] Step 10: First determine the database table 3 and database table 4 that are effectively connected at the third level;

[0104] Step 20: Generate an innermost query statement based on the table names, connection fields, connection types, corresponding target fields, and corresponding target parameter constraints of the third-level effectively connected database tables 3 and 4; wherein, database table 3 is determined as a temporary master table, and database table 4 is determined as a subtable;

[0105] Step 30: The innermost query statement generated in step 20 is used as temporary table 1, and according to the number of levels of effective database table connections, database table 2 corresponding to the second-level effective connection that does not participate in the generation of the query statement is determined, database table 2 (determined as the temporary main table) and temporary table 1 (determined as the subtable) are determined as database tables of the first-level effective connection, and an outer query statement is generated according to the table names, connection fields, connection types, corresponding target fields, and corresponding target parameter constraints of database table 2 and temporary table 1;

[0106] Step 40: Use the outer query statement generated in step 30 as temporary table 2, and determine the database table 1 that does not participate in the generation of the query statement and corresponds to the first-level effective connection according to the number of levels of effective connections of the database tables, determine database table 1 (determine database table 1 as the main table) and temporary table 2 (determine temporary table 2 as the sub-table) as the database tables of the first-level effective connection, and generate the outermost query statement according to the table name, connection field, connection type, corresponding target field and corresponding target parameter constraints of database table 1 and temporary table 2 to obtain a query script.

[0107] The above method can realize the orderly generation of query statements in the query script, improve the reliability and accuracy of query script generation, and make the target field corresponding to the first data table (i.e., the main table) dragged by the user be located in the outermost query statement.

[0108] A software application generation method provided in an embodiment of the present application may further include, before responding to a user's valid connection between database tables:

[0109] In response to a user connection between database tables, obtaining a selected field in a head-end database table and a selected field in a terminal database table of the user connection;

[0110] According to the selected fields in the head-end database table and the selected fields in the end-end database table, it is determined whether the head-end database table and the end-end database table can form a valid connection;

[0111] If so, a connecting line segment with a connecting direction is displayed between the selected field in the head-end database table and the selected field in the end-end database table; the selected field in the head-end database table and the selected field in the end-end database table are connecting fields;

[0112] If not, the connection line segment with the connection direction between the selected field in the head-end database table and the selected field in the end-end database table is rejected.

[0113] In an embodiment of the present application, before responding to a valid connection between databases by a user, the user can also respond to a connection between database tables by obtaining selected fields in the head-end database table (i.e., the head-end database table to which the user connects when connecting between database tables) and selected fields in the end-end database table (i.e., the end-end database table to which the user connects when connecting between database tables). Then, based on the selected fields in the head-end database table and the selected fields in the end-end database table, it is determined whether a valid connection can be formed between the head-end database table and the end-end database table. Specifically, it can be determined whether the field type of the selected field in the head-end database table is the same as the field type of the selected field in the end-end database table, and whether the selected field in the head-end database table and the selected field in the end-end database table cross levels or form a loop. If the field type of the selected field in the head-end database table is the same as the field type of the selected field in the end-end database table, and the selected field in the head-end database table and the selected field in the end-end database table do not cross levels and do not form a loop, then it is determined that a valid connection can be formed between the head-end database table and the end-end database table. If the field type of the selected field in the head-end database table is different from the field type of the selected field in the terminal database table, or the selected field in the head-end database table and the selected field in the terminal database table cross levels or form a loop, it is determined that no effective connection is formed between the head-end library table and the terminal database table.

[0114] If it is determined that the head-end database table and the terminal database table can form a valid connection, a connecting line segment with a connection direction (i.e., a connecting line segment with a connection direction) can be displayed between the selected fields in the head-end database table and the selected fields in the terminal database table. That is, a connecting line segment with a connection direction can be displayed between the selected fields in the head-end database table and the selected fields in the terminal database table on the visualization canvas. Figure 3 As shown in the figure, a connecting line is displayed between the selected field x2 in the main table and the selected field y3 in the sub-table. In addition, the selected fields in the first database table and the selected fields in the last database table are both connected fields.

[0115] If it is determined that no valid connection can be formed between the first-end database table and the terminal database table, the connection line segment with the connection direction displayed between the selected fields in the first-end database table and the selected fields in the terminal database table can be rejected. At this time, the selected fields in the first-end database table and the selected fields in the terminal database table are not connection fields.

[0116] The above method can accurately and efficiently determine whether a valid connection is formed between database tables.

[0117] A software application generation method provided in an embodiment of the present application may further include, when it is determined that the head-end database table and the end-end database table fail to form a valid connection:

[0118] Displays a connection failure pop-up on the visualization canvas.

[0119] In an embodiment of the present application, when it is determined that a valid connection cannot be formed between the database tables at the head end and the database tables at the end end, not only can the display of a connecting line segment with a connection direction between the selected field in the database table at the head end and the selected field in the database table at the end end be rejected, but a pop-up box indicating a connection failure can also be displayed on the visual canvas, wherein the pop-up box can include prompt information of the connection failure. For example, if a valid connection cannot be formed due to different bullet types, the pop-up box can include prompt information such as "field types must be the same" or "field types are different and a valid connection cannot be formed", so that the user can determine the cause of the connection failure based on the prompt information of the connection failure, and reselect the database table or selected field for connection based on the cause of the connection failure.

[0120] By displaying a connection failure pop-up box on the visual canvas, users can intuitively and quickly determine that a valid connection cannot be formed between the selected fields of the head-end database table and the selected fields of the end-end database table, so as to reselect the head-end database table, the end-end database table, or reselect the selected fields in the database table.

[0121] A software application generation method provided in an embodiment of the present application may further include, after obtaining the table name, target field, and target parameter constraints of a database table:

[0122] Convert the table name, target field, and target parameter constraints of the database table on the visualization canvas into data in a preset format;

[0123] Before generating a query script based on the table name, target field, and target parameter constraints of the database table, you can also include:

[0124] The association analysis engine is used to obtain the table name of the database table from the data in the preset format, the target field is extracted from the data in the preset format through projection operation, and the constraint conditions of the target parameter are identified from the data in the preset format through selection operation.

[0125] In an embodiment of the present application, the event listening module in the server can monitor the table name, target field, and target parameter constraints of the database table on the visual canvas to obtain the table name, target field, and target parameter constraints of the database table, and then, the information obtained can be converted into data in a preset format. For example, the data in the preset format can specifically be data in JSON (JavaScript Object Notation, JS object notation) format. That is, the event listening module can monitor the table name, target field, and target parameter constraints of the database table on the visual canvas, and convert the monitored information into data in a preset format. Among them, the data in the preset format contains the table name, target field, and target parameter constraints of the database table. By converting the relevant information of the database table on the visual canvas into data in a preset format, it is convenient for the association analysis engine (association analysis engine based on relational algebra) in the server to perform analysis and identification, and generate a query script based on the analysis and identification results.

[0126] On the basis of the above, before generating a query script based on the table name, target field and target parameter constraints in the database table, the server can also use the association analysis engine to obtain the table name of the database table from the data in the preset format, and the association analysis engine can extract the target field from the data in the preset format through the π projection operation, and the association analysis engine can identify the target parameter constraints from the data in the preset format through the σ selection operation. Then, the association analysis engine can generate a query script based on this information obtained from the data in the preset format.

[0127] It should be noted that when there are multiple database tables and the user forms an effective connection between the database tables, the event monitoring module in the server can also convert the table name, connection field and connection direction of the effectively connected database table on the monitored visual canvas into the above-mentioned preset format data. That is, when there are multiple database tables and the user forms an effective connection between the database tables, the above-mentioned preset format data can also include the table name, connection field and connection type of the effectively connected database table, so that the association analysis engine can generate a corresponding query script based on this information. Of course, in the aforementioned process, the event monitoring module can also first determine the connection type based on the connection direction, and then convert the table name, connection field and connection type of the effectively connected database table into the above-mentioned preset format data, so that the association analysis engine can generate a corresponding query script based on this information.

[0128] Among them, when there are multiple database tables and the user forms a valid connection between the database tables, the association analysis engine can eventually generate a natural connection or theta join algebraic expression, and the server can automatically deduce the join type (inner join Left Outer Join etc.), and can build complex mapping relationships between multiple tables through the ρ renaming operation, completing the construction of the association model based on the closure characteristics of relational algebra.

[0129] For example, the data in the preset format inputted by the event monitoring module to the correlation analysis engine may be in the following form:

[0130]

[0131] The query script output by the association analysis engine can be:

[0132] select R1.2,R1.3,t3.6

[0133] from(select t1.1,t1.2,t2.4,t2.5 from t1,t2 on t1.1=t2.4)R1

[0134] on t3.3=R1.1

[0135] The relational algebra corresponding to the above query script is:

[0136] R1=π 1,2,4,5 (σ 1＝4 (t1×t2))

[0137]

[0138] The above can achieve the following: 1) Replace manually defined association rules with relational algebra operations, reducing operational complexity; 2) Automatically match foreign key-primary key pairs using the attribute intersection characteristics of natural joins; 3) Support automatic generation of conditional expressions for theta joins, covering multiple scenarios such as equijoins and range joins; 4) Optimize join paths through relational algebra equivalent transformations, improving the execution efficiency of association operations.

[0139] The software application generation method provided in the embodiment of the present application may further include:

[0140] In response to a user's modification operation on a table structure of a database table, obtaining the table name, target fields, and target parameter constraints of the database table after the modification operation;

[0141] Generate a new execution script based on the table name, target field, and target parameter constraints of the database table after the modification operation;

[0142] Generate a new back-end interface and a new front-end page according to the new execution script, and use the new back-end interface and the new front-end page to replace the back-end interface and the front-end page generated by the previous execution script; or, compare the new execution script with the previous execution script to determine the incremental script, and update the back-end interface and the front-end page generated by the previous execution script according to the incremental script.

[0143] In the process of generating a software application according to the aforementioned embodiment, a user can modify the table structure of a database table dragged onto the visual canvas (e.g., adding a new field, modifying a field in the database table, or deleting a field, etc.). At this time, the event monitoring module in the server can respond to the user's modification operation on the table structure of the database table, obtain the table name, target field, and target parameter constraints of the database table after the modification operation, and can generate a new execution script based on the table name, target field, and target parameter constraints of the database table after the modification operation. In order to facilitate the distinction between the generated execution scripts, each time an execution script is generated, the version information of the generated execution script can also be recorded. For example, the time when the execution script was generated can be used as the version information of the execution script.

[0144] Then, the software application can be updated based on the new execution script. Specifically, after generating a new execution script, a new back-end interface and a new front-end page can be generated according to the new execution script, and the new back-end interface can be used to replace the back-end interface generated by the previous execution script, and the new front-end page can be used to replace the front-end page generated by the previous execution script, so as to achieve full reconstruction of the back-end interface and the front-end page. Alternatively, after generating a new execution script, the new execution script can be compared with the previous execution script to determine the incremental script, and then the back-end interface and front-end page generated by the previous execution script can be updated according to the incremental script, so as to achieve incremental update of only the affected parts and avoid full reconstruction.

[0145] The above method can achieve real-time synchronization of dynamic scripts and configurations, and versioned binding of configurations and codes. When the table structure of the database table changes, the server automatically updates the associated interfaces and interface logic through difference comparison, ensuring strong consistency between the front-end and back-end codes and the database structure, and avoiding the risk of logical faults caused by manual maintenance. That is, when the table structure changes, the server automatically updates the interfaces and interface logic through real-time synchronization technology of dynamic scripts and configurations, avoiding logical errors caused by manual synchronization omissions in traditional platforms (the measured error rate has dropped from 15% to below 0.5%), and improving the software application generation effect. In other words, table structure changes can be synchronized to the application layer in real time, meeting the needs of rapid iteration and achieving dynamic scalability.

[0146] It should be noted that when a user performs a modification operation on a table structure, in response to the user's modification operation on the table structure of a database table, the table name, target fields, and target parameter constraints of the database table after the modification operation are obtained. Before generating a new execution script based on the table name, target fields, and target parameter constraints of the database table after the modification operation, it can also be determined whether at least one of the table name, target parameters, and target parameter constraints of the database table has been modified (specifically, the determination can be made based on the table name, target fields, and target parameter constraints after the modification operation and the table name, target fields, and target parameter constraints before the modification operation). If so, the step of generating a new execution script based on the table name, target fields, and target parameter constraints of the database table after the modification operation can be executed. Otherwise, the step of generating a new execution script based on the table name, target fields, and target parameter constraints of the database table after the modification operation can be rejected. The above steps can avoid the generation of unnecessary new execution scripts, new back-end interfaces, and new front-end pages.

[0147] A software application generation method provided in an embodiment of the present application may further include: if there are multiple database tables, obtaining the table name, target field, and target parameter constraints of the database table after the modification operation;

[0148] Obtain the connection field and connection direction of the database table that is effectively connected after the modification operation, and determine the connection type after the modification operation according to the connection direction of the database table that is effectively connected after the modification operation;

[0149] Generate a new execution script based on the table name, target fields, and target parameter constraints of the modified database table, which can include:

[0150] Generate a new execution script based on the table name, connection field, connection type, target field, and target parameter constraints of the database table that is effectively connected after the modification operation.

[0151] In an embodiment of the present application, if there are multiple database tables, the user can also modify at least one of the table name, connection field, and connection direction of the effectively connected database table. In order to ensure strong consistency between the front-end and back-end codes and the database structure, and improve the accuracy and generation effect of software application updates, the event monitoring module in the server can also obtain the table name, connection field, and connection direction of the effectively connected database table after the modification operation when obtaining the table name, target parameters, and constraints of the target parameters of the database table after the modification operation, and determine the connection type after the modification operation based on the connection direction of the effectively connected database table after the modification operation. On this basis, generating a new execution script based on the table name, target field, and target parameter constraints of the database table after the modification operation can specifically be: generating a new execution script based on the table name, connection field, connection type, target field, and target parameter constraints of the effectively connected database table after the modification operation. Afterwards, the software application can be updated based on the new execution script.

[0152] If the aforementioned embodiment includes determining whether at least one of the table name, target parameter, and target parameter constraint of the database table has been modified, then the aforementioned determination operation may specifically be: determining whether at least one of the table name, connection field, connection type, target parameter, and target parameter constraint of the database table has been modified. If so, then executing the step of generating a new execution script based on the table name, connection field, connection type, target field, and target parameter constraint of the database table that is effectively connected after the modification operation. If not, then refusing to execute the step of generating a new execution script based on the table name, connection field, connection type, target field, and target parameter constraint of the database table that is effectively connected after the modification operation.

[0153] A software application generation method provided in an embodiment of the present application may further include, before generating a backend interface and a frontend page according to an execution script: displaying attribute information of a target field and attribute information of a target parameter so that a user can configure the target field and / or target parameter;

[0154] or,

[0155] After generating the backend interface and the frontend page according to the execution script, the method may further include: receiving a first configuration instruction sent by a user, and displaying the attribute information of the target field and / or the attribute information of the target parameter according to the first configuration instruction.

[0156] In an embodiment of the present application, before generating the back-end interface and the front-end page according to the execution script (for example, after generating the execution script and before generating the back-end interface and the front-end page according to the execution script), the server can display the attribute information of the target field and the attribute information of the target parameter respectively, so that the user can configure the target field and / or the target parameter. In this case, if it is determined that the user configures the target field and / or the target parameter, the back-end interface and the front-end page can be generated according to the execution script and the configured target field and / or the configured target parameter.

[0157] Alternatively, after the back-end interface and the front-end page are generated according to the execution script, if the user has a need to configure the target parameters and / or target parameters, a first configuration instruction (i.e., an instruction to configure the target field and / or target parameter) can be sent to the server. After receiving the first configuration instruction, the server can display the attribute information of the target field and / or the attribute information of the target parameter for the user to configure the target field and / or target parameter. Wherein, if the first configuration instruction is an instruction to configure the target field, the server can display the attribute information of the target field; if the first configuration instruction is an instruction to configure the target parameter, the server can display the attribute information of the target parameter; if the first configuration instruction is an instruction to configure the attribute information of the target field and the attribute information of the target parameter, the server can display the attribute information of the target field and the attribute information of the target parameter. Alternatively, regardless of whether the first configuration instruction is an instruction to configure the target parameter and / or target parameter, the server can display the attribute information of the target field and the attribute information of the target parameter. In this case, if the user configures the target field and / or target parameter, the backend interface and the frontend page may be updated according to the configured target field and / or configured target parameter.

[0158] It should be noted that the attribute information of the target field may be, for example, the order of the target field, the name of the target field, the field description of the target field, the type of the target field, whether the target field is displayed, etc.; the attribute information of the target parameter may be, for example, the name of the target parameter, the type of the target parameter, the order of the target parameter, the field description of the target parameter, etc. Moreover, when displaying the attribute information of the target field and the attribute information of the target parameter, the attribute information of the target field and the attribute information of the target parameter may be displayed on separate interfaces respectively (i.e., the attribute information of the target field is displayed separately on one interface, and the attribute information of the target parameter is displayed separately on another interface); or, at least two display boxes may be included on the same interface, one display box is used to display the attribute information of the target field, and the other display box is used to display the attribute information of the target parameter.

[0159] By displaying the attribute information of the target field and / or the attribute information of the target parameter, the user can configure the target field and / or the target parameter according to needs, so as to improve the flexibility of software application generation and enable the generated software application to better meet the needs of the user.

[0160] A software application generation method provided by an embodiment of the present application may further include, before generating a front-end page according to executing a script: displaying a configuration page so that a user can configure the front-end page on the configuration page;

[0161] or,

[0162] After the front-end page is generated according to the execution script, the method may further include: receiving a second configuration instruction sent by the user, and displaying the configuration page so that the user can configure the front-end page on the configuration page.

[0163] In an embodiment of the present application, before the front-end page is generated according to the execution script (for example, after the execution script is generated and before the front-end page is generated according to the execution script), the server can display the configuration page for the user to configure the front-end page on the configuration page. In this case, if it is determined that the user configures the configuration page, the front-end page can be generated according to the execution script and the configuration on the configuration page.

[0164] Alternatively, before the front-end page is generated according to the execution script, if the user has a need to configure the front-end page, the second configuration instruction (i.e., the instruction to configure the page) can be sent to the server. After receiving the second configuration instruction sent by the user, the server can display the configuration page for the user to configure the front-end page on the configuration page. In this case, if it is determined that the user has configured the configuration page, the front-end page can be updated according to the configuration on the configuration page. For example, see Figure 4 and Figure 5 ,in, Figure 4 A schematic diagram of the front-end page generated by the embodiment of the present application is provided. Figure 4 x1-1, x1-2, x1-3, etc. are the query results corresponding to field x1. Figure 4 The x2-1, x2-2, x2-3, etc. in the figure are the query results corresponding to the field x2, and the x3-1, x3-2, x3-3, etc. in the figure are the query results corresponding to the field x3. Figure 5 A schematic diagram of the configuration page provided in the embodiment of the present application. After the front-end page is generated, if the user has a need to configure the front-end page, the second configuration instruction can be sent to the server, and the server can display the following information: Figure 5It should be noted that after generating the front-end page, the server can enter the field configuration, parameter configuration and page configuration according to the user's configuration requirements.

[0165] The configuration page can contain a preview page corresponding to the front-end page. For details, see Figure 5 The preview page allows users to preview and obtain the generated front-end page, and allows users to configure the target fields, target parameter layout, etc. on the preview page. Of course, the configuration page can also include other configuration items, so that users can configure the front-end page based on other configuration items.

[0166] The above method allows users to configure the front-end page, thereby improving the flexibility of front-end page generation and enabling the generated software application to better meet user needs.

[0167] The software application generation method provided in an embodiment of the present application may further include, after displaying the configuration page, the following steps:

[0168] Obtain the custom logic slot inserted by the user on the configuration page and the target interface associated with the custom logic slot, so that the front-end page contains the custom logic slot and associates the custom logic slot with the target interface;

[0169] and / or,

[0170] Get the trigger inserted by the user on the configuration page and the properties configured for the trigger, so that the front-end page contains the trigger with the properties.

[0171] In an embodiment of the present application, after the configuration page is displayed, the custom logic slot inserted by the user on the configuration page and the target interface associated with the custom logic slot can be obtained, so that the generated front-end page can include the custom logic slot inserted by the user on the configuration page, and the custom logic slot contained in the front-end page is associated with the target interface associated with it by the user, so that when the custom logic slot is run, the result can be obtained by calling the associated target interface. Exemplarily, the configuration page can include: themes, add buttons, save buttons, delete buttons, export buttons, import buttons, custom buttons (such as data processing slots, inserting custom functions in the configuration page (such as order total price calculation, etc.)), multi-page, summary, header form, table configuration and other custom logic slots, so that users can insert custom logic slots on the configuration page according to their needs.

[0172] And / or, after displaying the configuration page, the trigger inserted by the user on the configuration page and the properties configured for the trigger (such as trigger conditions, trigger effects, etc.) can be obtained. For example: when the user wants to use a target field to perform a trigger operation, the user can select the trigger object in the trigger, and configure the trigger conditions and trigger effects (such as font color change, cell color change, pop-up window, etc.) for the trigger object, so that the generated front-end page can contain a trigger with the properties configured by the user; or, the user can insert an event trigger: bind table operation event (such as "verify inventory before saving").

[0173] That is, after displaying the configuration page, users can insert custom logic slots and associate target interfaces with them, and / or insert triggers and configure trigger properties. This allows users to insert custom logic slots or triggers into automatically generated front-end pages for complex business scenarios. These actions are isolated from standardized code, ensuring the stability of core logic.

[0174] By using dynamic logic slot technology (including user-configured custom logic slots and / or triggers), the embodiments of the present application can not only ensure the stability of core logic but also support highly customized requirements:

[0175] Flexible injection of custom logic slots or triggers: Users can insert data processing functions or triggers (such as order amount verification rules) into the automatically generated front-end page. Slot behavior and trigger behavior are isolated from standardized code to ensure that custom logic is not affected during system upgrades.

[0176] Compatibility verification: In complex business systems such as e-commerce and ERP (Enterprise Resource Planning), actual tests show that more than 80% of functions can be implemented through standard configurations, and the remaining 20% ​​of customized requirements are completed through slots and trigger extensions. The development cycle is shortened by 75% compared to traditional low-code platforms.

[0177] An embodiment of the present application provides a method for generating a software application, which generates a front-end page based on executing a script, and may include:

[0178] Match the first front-end component of the target field in the front-end page according to the business rules and the type of the target field, and match the second front-end component of the target parameter in the front-end page according to the business rules and the type of the target parameter;

[0179] A front-end page is generated according to the execution script, the target field, the first front-end component, the target parameter and the second front-end component.

[0180] In an embodiment of the present application, when a front-end page is generated according to the execution script, the first front-end component of the target field in the front-end page can be matched according to the business rules and the type of the target field, and the second front-end component of the target parameter in the front-end page can be matched according to the business rules and the type of the target parameter. For the first front-end component that matches the target field and the second front-end component that matches the target parameter, for example, basic fields (such as text, numbers) can be matched as standard controls such as input boxes and drop-down boxes, and associated fields (such as foreign keys) can automatically generate query forms with cascading selectors, and field constraints (such as non-empty, uniqueness) can be converted into front-end verification rules in real time.

[0181] Then, a front-end page can be generated based on the execution script, the target field and its matching first front-end component, the target parameter and its matching second front-end component. In other words, the front-end page can not only be associated with the execution script, but also include the target field and its matching first front-end component, the target parameter and its matching second front-end component.

[0182] The above method can realize dynamic rendering of the front-end page, that is, the front-end components of the fields in the front-end page can be automatically matched based on the field type and business rules.

[0183] A software application generation method provided in an embodiment of the present application may further include, before generating a front-end page according to the execution script, the first front-end component, and the second front-end component:

[0184] Determine the layout of the target fields and the first front-end component according to the number of target fields, and determine the layout of the target parameters and the second front-end component according to the number of target parameters;

[0185] Generating a front-end page based on the execution script, target field, first front-end component, target parameter, and second front-end component may include:

[0186] A front-end page is generated according to the execution script, the target field, the first front-end component, the target field and the layout of the first front-end component, the target parameter, the second front-end component, the target parameter and the layout of the second front-end component.

[0187] In an embodiment of the present application, before generating a front-end page according to the execution script, the first front-end component, and the second front-end component, the layout of the target field and the first front-end component it matches can also be determined according to the number of target fields, and the layout of the target parameter and the second front-end component it matches can be determined according to the number of target parameters, so as to automatically generate a responsive layout (such as a single-column arrangement or a multi-column arrangement) according to the number of fields. Of course, the layout of the target field and the first front-end component it matches can also be determined according to the number and type of target fields, and the layout of the target parameter and the second front-end component it matches can be determined according to the number and type of target parameters, so as to automatically generate a responsive layout according to the number and type of fields.

[0188] Based on the above, a front-end page can be generated based on the execution script, target parameter, first front-end component, target parameter and the layout of the first front-end component that matches it, target parameter, second front-end component, target parameter and the layout of the second front-end component that matches it. That is, the front-end page can not only be associated with the execution script, but can also include the target field and its matching first front-end component, the target parameter and its matching second front-end component. At the same time, the target field and the first front-end component can be arranged according to the determined corresponding layout, and the target parameter and the second front-end component can also be arranged according to the determined corresponding layout.

[0189] The software application generation method provided in the embodiment of the present application may further include:

[0190] If the number of target fields is greater than the first preset value and the query result items corresponding to the target fields are greater than the second preset value, a table grouping label corresponding to the target fields is generated on the front-end page;

[0191] Among them, the table grouping label is associated with a sub-page, which is used to display the query result items corresponding to the target field.

[0192] In an embodiment of the present application, if the number of target fields is greater than a first preset value (the specific size can be set according to needs or experiments, etc.) and the query result item corresponding to the target field is greater than a second preset value (the specific size can be set according to needs or experiments, etc.), it indicates that the front-end page has too much information to display. At this time, in order to reduce the amount of information intuitively displayed on the front-end page and reduce the pressure on users to view, a table grouping label corresponding to the target field can be generated on the front-end page. For example, the table grouping label can be "click to view" or "view more", etc. Among them, the table grouping label can be associated with a sub-page. When the user clicks the table grouping label, the sub-page associated with the table grouping label can be displayed. The sub-page is used to display the query result item corresponding to the target field.

[0193] Of course, users can also manually configure sub-pages, etc. on the configuration page.

[0194] An embodiment of the present application provides a method for generating a software application, wherein a database table may include a table name, fields, and field descriptions of the database table.

[0195] In an embodiment of the present application, the database table dragged by the user onto the visualization canvas may include the table name, fields, and field descriptions of the database table, thereby facilitating the user to operate the fields in the database table based on this information.

[0196] In a software application generation method provided by an embodiment of the present application, a visualization canvas is included in a graphical interface, and the graphical interface may further include a first information display area;

[0197] Before responding to the user's operation of dragging the database table to the visualization canvas and selecting a field from the database table, the following steps may also be included:

[0198] At least one database table is obtained, and the obtained database table is displayed in a first information display area on a graphical interface, so that a user can select a database table from the first information display area and drag it to a visualization canvas.

[0199] In an embodiment of the present application, the visualization canvas may be included in a graphical interface, and the graphical interface may further include a first information display area. Before responding to the user's operation of dragging a database table to the visualization canvas and selecting a field from the database table, the server may perform data source maintenance to extract information such as the table name, field, field description, and field constraints from at least one original database table to obtain the corresponding database table, and may display at least one obtained database table in the first information display area on the graphical interface, so that the user can select the required database table from the database table displayed in the first information display area and drag the required database table to the visualization canvas. In order to enable the first information display area to display more database tables, the first information display area may only display the table name of the database table. When the user drags the database table to the visualization canvas, the table name of the database table, the fields contained in the database table, and the description of the fields may be displayed on the visualization canvas so that the user can operate on the database table dragged to the visualization canvas.

[0200] In a software application generation method provided by an embodiment of the present application, the graphical interface may further include a second information display area for displaying target fields and target parameters.

[0201] In an embodiment of the present application, the graphical interface may also include a second information display area, which can be used to display target fields and target parameters, so that users can clearly and intuitively obtain the target parameters and target fields corresponding to operations on the fields in the database table on the visual interface.

[0202] The second information display area may include a first information display sub-area and a second information display sub-area. The first information display sub-area is used to display the target field, and the second information display sub-area is used to display the target parameters.

[0203] The software application generation solution provided in this application is described as follows:

[0204] This application provides a low-code, full-stack development system based on database table drive, which uses visual table mapping and automated code generation technology to achieve efficient construction and dynamic expansion of business systems:

[0205] 1. Technical Solution Architecture

[0206] 1. The core modules in the server are:

[0207] Visual canvas (or database mapping canvas): a visual configuration interface that supports dragging and dropping table entities, connecting relationships, and editing properties (i.e., editing the name of the execution script, selecting and determining the target fields and target parameters).

[0208] Metadata parsing engine: parses table structures and relationships, and generates standardized configuration metadata (i.e., generates query scripts, target fields, and target parameters).

[0209] Full-stack code generator: Generates execution scripts, back-end interfaces, and front-end pages based on standardized configuration data.

[0210] Dynamic synchronization controller: monitors table structure changes, triggers code updates and version synchronization.

[0211] Extension Slot Manager: Provides a custom logic injection interface to isolate standard code from extension logic.

[0212] 2. Data flow logic:

[0213] User operation table entity configuration → Metadata parsing engine parsing → Full-stack code generator outputs full-stack code → Dynamic synchronization controller maintains consistency.

[0214] 2. Implementation of Key Technologies

[0215] 1. Visualization canvas, please refer to Figure 3 , which is a schematic diagram of the visualization canvas provided in an embodiment of the present application.

[0216] Functional design:

[0217] a. Table entity import: supports importing table structures from existing databases, or creating new tables (including field names, types, constraints, etc.) through the graphical interface.

[0218] b. Relationship definition: Users connect to the primary key of the target table through the foreign key field. The server automatically determines the association type (1:1, 1:N, N:M) and generates cascading rules.

[0219] c. Property configuration:

[0220] 1) Field level (i.e., target field, target parameter); set the front-end component mapping rules. For example, the "Gender" field is mapped to a radio button, and the data source is bound to a dictionary table.

[0221] 2) Table level (i.e., the name of the execution script, back-end interface, and front-end page): Define business logic tags, such as "Order table requires audit log."

[0222] Technical implementation:

[0223] 1) Use Canvas technology to render the canvas, and capture user drag and connection operations through the event monitoring module.

[0224] 2) Use graph databases (such as Neo4j) to store relationships between tables and support complex topology analysis.

[0225] 2. Automatically generate full-stack code. For example, the execution script can be as follows:

[0226] SELECT target field, join field in database table 1, join field in database table 2

[0227] FROM database table name 1

[0228] LEFT JOIN database table name 2

[0229] ON The connection field in database table 1 = the connection field in database table 2

[0230] <where>Constraints on target parameters

[0231] var result = ds.page(sql);

[0232] return result;

[0233] Backend interface generation logic:

[0234] a. Single table operation interface:

[0235] Automatically generate parameter validation logic based on field constraints.

[0236] b. Multi-table cascade query interface:

[0237] 1) Parse the table association path and generate a JOIN query statement. For example, "order table → customer table → address table" generates a nested query.

[0238] 2) Automatically map query parameters.

[0239] Front-end page generation logic:

[0240] a. Component matching rules:

[0241] 1) Base field (i.e. target field): table field mapping.

[0242] 2) Parameter field (i.e. target parameter): SQL condition field mapping.

[0243] b. Layout adaptation:

[0244] 1) Automatically generate responsive layouts (such as single-column / multi-column arrangements) based on the number and type of fields.

[0245] 2) Complex forms are guided step by step (implemented through table grouping tags).

[0246] 3. Dynamic synchronization and expansion mechanism

[0247] a. Implement synchronization process:

[0248] 1) When a user modifies the table structure (such as adding a new field), the metadata parsing engine compares the new and old versions.

[0249] 2) The difference analysis module identifies interfaces and pages that need to be updated. For example, newly added fields need to be synchronized to the form and query interfaces.

[0250] 3) The code generator only incrementally updates the affected parts, avoiding full rebuild.

[0251] b. Expansion slot design:

[0252] 1) Slot type:

[0253] Data processing slot: insert custom functions in the configuration page, for example: order total price calculation.

[0254] Event trigger slot: bind table operation events, for example: verify inventory before saving.

[0255] 2) Isolation mechanism: The extension logic exists as an independent module and interacts with the standard code through an API.

[0256] This achieves: 1) End-to-end automation: Full automation from database design to application execution eliminates manual coding and configuration fragmentation. 2) Dynamic adaptability: Table structure changes are synchronized to the application layer in real time, supporting rapid business iteration. 3) Open scalability: A slot mechanism balances standardization and customization requirements to cover complex business scenarios.

[0257] For example, Figures 3 to 5 The software application shown is generated. Figure 3 To query the business data source, drag the database table to the visualization canvas; Figure 4 Corresponding to the back-end interface and front-end page display generation; Figure 5 The corresponding generated page can be adjusted online, and fields and parameters can be edited.

[0258] An embodiment of the present application also provides a software application generation device, which may include: a first acquisition module, used to obtain the table name, target field and target parameter constraints of the database table in response to the user's operation of dragging the database table to the visual canvas and selecting a field from the database table; the target field, target parameter and target parameter constraints are all derived from the database table; a first generation module, used to generate an execution script based on the table name, target field and target parameter constraints of the database table, and generate a back-end interface and a front-end page based on the execution script.

[0259] An embodiment of the present application provides a software application generation device, wherein the first generation module may include: a first generation sub-module, configured to generate a query script based on the table name, target fields, and target parameter constraints of a database table, and encapsulate the query script into an execution script.

[0260] A software application generation device provided by an embodiment of the present application, if there are multiple database tables, may further include: a second acquisition module for acquiring, in response to a valid connection made by a user between database tables, the table name, connection field, and connection direction of the validly connected database table, and determining the connection type according to the connection direction;

[0261] The first generating submodule may include: a first generating unit, configured to generate a query script according to the table name, connection field, connection type, target field and target parameter constraints of the effectively connected database table.

[0262] An embodiment of the present application provides a software application generation device. If the number of levels of effective connections is greater than 1, the first generation unit may include: a first determination subunit, used to determine the first-level database table of the effective connection based on the number of levels of effective connections between database tables; a generation subunit, used to generate a query statement based on the table name, connection field, connection type, corresponding target field and corresponding target parameter constraints of the first-level effective connection database table; a second determination subunit, used to use the query statement as a temporary table, determine the database table corresponding to another level of effective connection based on the number of levels of effective connections between database tables, determine the temporary table and the database table corresponding to the other level of effective connection as the database table of the first-level effective connection, and return to execute the step of generating the query statement based on the table name, connection field, connection type, corresponding target field and corresponding target parameter constraints of the first-level effective connection database table, until a query statement is generated for the last level of effective connection database table to obtain a query script.

[0263] A software application generation device provided by an embodiment of the present application may further include: a third acquisition module, used to obtain the selected fields in the head-end database table and the selected fields in the terminal database table connected by the user in response to the user's effective connection between the database tables before responding to the user's effective connection between the database tables; a judgment module, used to judge whether the head-end database table and the terminal database table can form an effective connection based on the selected fields in the head-end database table and the selected fields in the terminal database table; a first display module, used to display a connection line segment with a connection direction between the selected fields in the head-end database table and the selected fields in the terminal database table if the head-end database table and the terminal database table can form an effective connection; the selected fields in the head-end database table and the selected fields in the terminal database table are connection fields; and a rejection module, used to refuse to display a connection line segment with a connection direction between the selected fields in the head-end database table and the selected fields in the terminal database table if the head-end database table and the terminal database table fail to form an effective connection.

[0264] An embodiment of the present application provides a software application generation device, which may further include: a second display module, configured to display a connection failure pop-up box on a visual canvas when it is determined that the head-end database table and the end-end database table fail to form an effective connection.

[0265] The software application generation device provided in an embodiment of the present application may further include: a conversion module configured to, after obtaining the table name, target field, and target parameter constraints of the database table, convert the table name, target field, and target parameter constraints of the database table on the visualization canvas into data in a preset format;

[0266] The first generation module may further include: an acquisition submodule, which is used to obtain the table name of the database table from the data in a preset format using the association analysis engine before generating a query script based on the table name, target field and target parameter constraints of the database table, extract the target field from the data in the preset format through a projection operation, and identify the target parameter constraints from the data in the preset format through a selection operation.

[0267] An embodiment of the present application provides a software application generation device, which may also include: a fourth acquisition module, used to respond to a user's modification operation on the table structure of a database table, and obtain the table name, target fields and target parameter constraints of the database table after the modification operation; a second generation module, used to generate a new execution script based on the table name, target fields and target parameter constraints of the database table after the modification operation; an update module, used to generate a new back-end interface and a new front-end page based on the new execution script, and use the new back-end interface and the new front-end page to replace the back-end interface and the front-end page generated by the previous execution script; or, compare the new execution script with the previous execution script to determine an incremental script, and update the back-end interface and the front-end page generated by the previous execution script according to the incremental script.

[0268] A software application generation device provided by an embodiment of the present application, if there are multiple database tables, may further include: a fifth acquisition module configured to, when acquiring the table name, target field, and target parameter constraints of the database table after the modification operation, acquire the connection fields and connection directions of the database tables that are effectively connected after the modification operation, and determine the connection type after the modification operation based on the connection directions of the database tables that are effectively connected after the modification operation;

[0269] The second generating module may include: a second generating submodule, configured to generate a new execution script according to the table name, connection field, connection type, target field and target parameter constraints of the effectively connected database table after the modification operation.

[0270] An embodiment of the present application provides a software application generation device, which may further include: a third display module, used to display the attribute information of the target field and the attribute information of the target parameter before generating the back-end interface and the front-end page according to the execution script, so that the user can configure the target field and / or target parameter; or, after generating the back-end interface and the front-end page according to the execution script, it may also include: receiving a first configuration instruction sent by the user, and displaying the attribute information of the target field and / or the attribute information of the target parameter according to the first configuration instruction.

[0271] An embodiment of the present application provides a software application generation device, which may further include: a fourth display module, which is used to, before generating a front-end page according to an execution script, further include: displaying a configuration page so that the user can configure the front-end page on the configuration page; or, after generating the front-end page according to the execution script, further include: receiving a second configuration instruction sent by the user, and displaying the configuration page so that the user can configure the front-end page on the configuration page.

[0272] An embodiment of the present application provides a software application generation device, which may also include: a sixth acquisition module, used to obtain the custom logic slot inserted by the user on the configuration page and the target interface associated with the custom logic slot after displaying the configuration page, so that the front-end page includes the custom logic slot and associates the custom logic slot with the target interface; and / or, obtain the trigger inserted by the user on the configuration page and the attributes configured for the trigger, so that the front-end page includes the trigger with attributes.

[0273] An embodiment of the present application provides a software application generation device, and the first generation module may include: a matching sub-module, which is used to match the first front-end component of the target field in the front-end page according to the business rules and the type of the target field, and match the second front-end component of the target parameter in the front-end page according to the business rules and the type of the target parameter; a third generation sub-module, which is used to generate the front-end page according to the execution script, the target field, the first front-end component, the target parameter and the second front-end component.

[0274] In a software application generation device provided by an embodiment of the present application, the first generation module may further include: a determination submodule configured to determine, before generating a front-end page according to the execution script, the first front-end component, and the second front-end component, a layout of target fields and the first front-end component based on the number of target fields, and a layout of target parameters and the second front-end component based on the number of target parameters;

[0275] The third generation submodule may include: a second generation unit, used to generate a front-end page based on the execution script, target field, first front-end component, target field and layout of the first front-end component, target parameters, second front-end component, target parameters and layout of the second front-end component.

[0276] An embodiment of the present application provides a software application generation device, which may also include: a third generation module, which is used to generate a table grouping label corresponding to the target field on the front-end page if the number of target fields is greater than a first preset value and the query result item corresponding to the target field is greater than a second preset value; wherein the table grouping label is associated with a sub-page, and the sub-page is used to display the query result item corresponding to the target field.

[0277] In a software application generation device provided by an embodiment of the present application, a visualization canvas is included in a graphical interface, and the graphical interface may further include a first information display area;

[0278] The software application generation device may also include: a seventh acquisition module, which is used to acquire at least one database table before responding to the user's operation of dragging the database table to the visualization canvas and selecting a field from the database table, and display the acquired database table in the first information display area on the graphical interface, so that the user can select the database table from the first information display area and drag it to the visualization canvas.

[0279] An embodiment of the present application provides a software application generation device, wherein the graphical interface may further include a second information display area for displaying target fields and target parameters.

[0280] The present application also provides a software application generation device, which may include: a memory for storing a computer program; and a processor for executing the computer program stored in the memory to implement the following steps:

[0281] In response to the user's operation of dragging a database table to the visualization canvas and selecting a field from the database table, the table name, target field, and target parameter constraints of the database table are obtained; the target field, target parameter, and target parameter constraints are all derived from the database table; an execution script is generated based on the table name, target field, and target parameter constraints of the database table, and a back-end interface and front-end page are generated based on the execution script.

[0282] The present application also provides a readable storage medium, which stores a computer program. When the computer program is executed by a processor, the following steps can be implemented:

[0283] In response to the user's operation of dragging a database table to the visualization canvas and selecting a field from the database table, the table name, target field, and target parameter constraints of the database table are obtained; the target field, target parameter, and target parameter constraints are all derived from the database table; an execution script is generated based on the table name, target field, and target parameter constraints of the database table, and a back-end interface and front-end page are generated based on the execution script.

[0284] The description of the relevant parts of the software application generation device, equipment and readable storage medium provided in this application can be found in the detailed description of the corresponding parts of the software application generation method provided in this application, and will not be repeated here.

[0285] It should be noted that the logic and / or steps represented in the flowcharts or otherwise described herein, for example, can be considered as a sequenced list of executable instructions for implementing the logical functions, and can be embodied in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus, or device (e.g., a computer-based system, a system including a processor, or other system that can fetch and execute instructions from an instruction execution system, apparatus, or device). For purposes of this specification, a "computer-readable medium" can be any device that can contain, store, communicate, propagate, or transport a program for use by, or in conjunction with, an instruction execution system, apparatus, or device. More specific examples (non-exhaustive list) of computer-readable media include the following: an electrical connection with one or more wires (electronic device), a portable computer disk cartridge (magnetic device), random access memory (RAM), read-only memory (ROM), erasable and programmable read-only memory (EPROM or flash memory), fiber optic devices, and portable compact disc read-only memory (CDROM). Furthermore, the computer-readable medium may even be paper or other suitable medium on which the program is printed, since the program may be obtained electronically, for example, by optically scanning the paper or other medium and then editing, interpreting or processing it in another suitable manner if necessary, and then storing it in a computer memory.

[0286] It should be understood that various parts of the present application can be implemented using hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented using software or firmware stored in a memory and executed by a suitable instruction execution system. For example, if implemented using hardware, as in another embodiment, any one of the following technologies known in the art or a combination thereof can be used to implement: a discrete logic circuit having a logic gate circuit for implementing a logic function on a data signal, an application-specific integrated circuit having a suitable combination of logic gate circuits, a programmable gate array (PGA), a field programmable gate array (FPGA), etc.

[0287] Throughout this specification, references to terms such as "one embodiment," "some embodiments," "example," "specific example," or "some examples" indicate that a specific feature, structure, material, or characteristic described in conjunction with that embodiment or example is included in at least one embodiment or example of the present application. In this specification, schematic representations of the above terms do not necessarily refer to the same embodiment or example. Furthermore, the specific features, structures, materials, or characteristics described may be combined in any suitable manner in any one or more embodiments or examples.

[0288] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of technical features being referred to. Thus, a feature specified as "first" or "second" may explicitly or implicitly include at least one such feature. Throughout the description of this application, "plurality" means at least two, for example, two, three, etc., unless otherwise specifically defined.

[0289] In this application, unless otherwise specified or limited, the terms "mounted," "connected," "connect," "fixed," and the like should be understood broadly. For example, these terms may refer to fixed or removable connections, or integration; mechanical or electrical connections; direct or indirect connections through an intermediary; and internal communication between two components or interaction between two components, unless otherwise specified. Those skilled in the art will understand the specific meanings of these terms in this application based on the specific circumstances.

[0290] Although the embodiments of the present application have been shown and described above, it can be understood that the above embodiments are exemplary and cannot be understood as limitations on the present application. Ordinary technicians in this field can change, modify, replace and modify the above embodiments within the scope of the present application.< / where>

Claims

1. A software application generation method, characterized in that: include: In response to a user dragging a database table to a visualization canvas and selecting a field from the database table, obtaining a table name, a target field, and constraints of a target parameter of the database table; the target field, the target parameter, and the constraints of the target parameter are all derived from the database table; An execution script is generated according to the table name of the database table, the target field and the constraint conditions of the target parameters, and a back-end interface and a front-end page are generated according to the execution script.

2. The software application generation method according to claim 1, characterized in that: Generate an execution script according to the table name of the database table, the target field, and the constraint conditions of the target parameter, including: A query script is generated according to the table name of the database table, the target field and the constraint conditions of the target parameters, and the query script is encapsulated into the execution script.

3. The software application generation method according to claim 2, characterized in that: If there are multiple database tables, the following is also included: In response to a valid connection between the database tables made by the user, obtaining the table name, connection field, and connection direction of the validly connected database table, and determining a connection type according to the connection direction; Generate a query script according to the table name of the database table, the target field and the constraint conditions of the target parameter, including: A query script is generated according to the table name of the effectively connected database table, the connection field, the connection type, the target field and the constraint conditions of the target parameter.

4. The software application generation method according to claim 3, characterized in that: If the number of valid connection levels is greater than 1, a query script is generated according to the table name of the validly connected database table, the connection field, the connection type, the target field, and the constraint conditions of the target parameter, including: Determine the database tables of the first-level effective connection according to the number of levels of effective connections between the database tables; Generate a query statement according to the table name of the first-level effectively connected database table, the connection field, the connection type, the corresponding target field and the corresponding constraint condition of the target parameter; The query statement is used as a temporary table, and the database tables that do not participate in the generation of the query statement in another level of effective connection are determined according to the number of levels of effective connections between the database tables. The temporary table and the database tables that do not participate in the generation of the query statement in the other level of effective connection are determined as database tables of a first-level effective connection. The process returns to the step of generating the query statement according to the table name of the first-level effective connected database table, the connection field, the connection type, the corresponding target field, and the corresponding target parameter constraint conditions, until a query statement is generated for the database table of the last level of effective connection, so as to obtain the query script.

5. The software application generation method according to claim 3, characterized in that: Before responding to the valid connection between the database tables by the user, the method further includes: In response to the user connecting between the database tables, obtaining a selected field in the head-end database table and a selected field in the end-end database table of the user connection; According to the selected fields in the head-end database table and the selected fields in the terminal database table, determining whether the head-end database table and the terminal database table can form a valid connection; If so, a connecting line segment with a connecting direction is displayed between the selected field in the head-end database table and the selected field in the terminal database table; the selected field in the head-end database table and the selected field in the terminal database table are the connecting fields; If not, the connection line segment with a connection direction displayed between the selected field in the head-end database table and the selected field in the end-end database table is rejected.

6. The software application generation method according to claim 5, characterized in that: When it is determined that the head-end database table and the end-end database table fail to form an effective connection, the method further includes: A pop-up box indicating connection failure is displayed on the visualization canvas.

7. The software application generation method according to any one of claims 2 to 6, characterized in that: After obtaining the table name, target field, and target parameter constraints of the database table, the following steps are also included: Converting the table name, target field, and target parameter constraints of the database table on the visualization canvas into data in a preset format; Before generating a query script according to the table name of the database table, the target field and the constraint conditions of the target parameter, the method further includes: The table name of the database table is obtained from the data in the preset format using an association analysis engine, the target field is extracted from the data in the preset format through a projection operation, and the constraint conditions of the target parameter are identified from the data in the preset format through a selection operation.

8. The software application generation method according to any one of claims 1 to 6, characterized in that: Also includes: In response to the user's modification operation on the table structure of the database table, obtaining the table name, target field, and target parameter constraint conditions of the database table after the modification operation; Generate a new execution script according to the table name, target field and target parameter constraints of the database table after the modification operation; A new back-end interface and a new front-end page are generated according to the new execution script, and the new back-end interface and the new front-end page are used to replace the back-end interface and the front-end page generated by the previous execution script; or, the new execution script is compared with the previous execution script to determine an incremental script, and the back-end interface and the front-end page generated by the previous execution script are updated according to the incremental script.

9. The software application generation method according to claim 8, characterized in that: If there are multiple database tables, when obtaining the table name, target field, and target parameter constraints of the database table after the modification operation, the following is also included: Obtaining the table name, connection field, and connection direction of the database table that is effectively connected after the modification operation, and determining the connection type after the modification operation according to the connection direction of the database table that is effectively connected after the modification operation; Generate a new execution script based on the table name, target field, and target parameter constraints of the database table after the modification operation, including: A new execution script is generated according to the table name, connection field, connection type, target field and target parameter constraints of the database table that is effectively connected after the modification operation.

10. The software application generation method according to claim 1, characterized in that: Before generating the back-end interface and the front-end page according to the execution script, the method further includes: displaying the attribute information of the target field and the attribute information of the target parameter respectively, so that the user can configure the target field and / or the target parameter; or, After generating the back-end interface and front-end page according to the execution script, it also includes: receiving a first configuration instruction sent by the user, and displaying the attribute information of the target field and / or the attribute information of the target parameter according to the first configuration instruction, so that the user can configure the target field and / or the target parameter.

11. The software application generation method according to claim 1 or 10, characterized in that: Before generating the front-end page according to the execution script, the method further includes: displaying a configuration page so that the user can configure the front-end page on the configuration page; or, After generating the front-end page according to the execution script, the method further includes: receiving a second configuration instruction sent by the user, and displaying the configuration page so that the user can configure the front-end page on the configuration page.

12. The software application generation method according to claim 11, characterized in that: After displaying the configuration page, it also includes: Obtaining a custom logic slot inserted by the user on the configuration page and a target interface associated with the custom logic slot, so that the front-end page includes the custom logic slot; wherein the custom logic slot is associated with the target interface; and / or, The trigger inserted by the user on the configuration page and the attributes configured for the trigger are obtained, so that the front-end page includes the trigger with the attributes.

13. The software application generation method according to claim 1, wherein: Generate a front-end page according to the execution script, including: A first front-end component that matches the target field in the front-end page according to the business rules and the type of the target field, and a second front-end component that matches the target parameter in the front-end page according to the business rules and the type of the target parameter; The front-end page is generated according to the execution script, the target field, the first front-end component, the target parameter and the second front-end component.

14. The software application generation method according to claim 13, characterized in that: Before generating the front-end page according to the execution script, the first front-end component and the second front-end component, the method further includes: Determining a layout of the target fields and the first front-end component according to the number of the target fields, and determining a layout of the target parameters and the second front-end component according to the number of the target parameters; Generating the front-end page according to the execution script, the target field, the first front-end component, the target parameter, and the second front-end component includes: The front-end page is generated according to the execution script, the target field, the first front-end component, the target field and the layout of the first front-end component, the target parameter, the second front-end component, the target parameter and the layout of the second front-end component.

15. The software application generation method according to claim 13, wherein: Also includes: If the number of the target fields is greater than a first preset value and the query result items corresponding to the target fields are greater than a second preset value, generating a table grouping label corresponding to the target fields on the front-end page; The table grouping tag is associated with a sub-page, and the sub-page is used to display the query result item corresponding to the target field.

16. The software application generation method according to claim 1, characterized in that: The database table includes the table name, fields and descriptions of the fields of the database table.

17. The software application generation method according to claim 16, characterized in that: The visualization canvas is included in a graphical interface, and the graphical interface also includes a first information display area; Before responding to the user's operation of dragging a database table to the visualization canvas and selecting a field from the database table, the method further includes: At least one database table is obtained, and the obtained database table is displayed in a first information display area on the graphical interface, so that the user can select the database table from the first information display area and drag it to the visualization canvas.

18. The software application generation method according to claim 17, characterized in that: The graphical interface further includes a second information display area for displaying the target field and the target parameters.

19. A software application generating device, characterized in that: include: A first acquisition module is configured to acquire, in response to a user dragging a database table to a visualization canvas and selecting a field from the database table, a table name, a target field, and constraints of a target parameter of the database table; the target field, the target parameter, and the constraints of the target parameter are all derived from the database table; The first generating module is used to generate an execution script according to the table name of the database table, the target field and the constraint conditions of the target parameters, and generate a back-end interface and a front-end page according to the execution script.

20. A software application generating device, characterized in that: include: memory for storing computer programs; A processor, configured to implement the steps of the software application generation method according to any one of claims 1 to 18 when executing the computer program.

21. A readable storage medium, characterized in that The readable storage medium stores a computer program, which, when executed by a processor, implements the steps of the software application generation method according to any one of claims 1 to 18.

Images