Zero-code operation database system and method based on JavaScript non-compiled language

Abstract

The invention discloses a zero-code operation database system and method based on a JavaScript non-compiled language, and relates to the technical field of software development and database management. The system comprises a configuration input module, a storage module, a scheduling engine module and a database operation controller module. According to the method, a visual configuration interface is provided, complex associated query, view construction, aggregation query and user-defined algorithm operation are supported, and the limitation that an existing zero-code platform only supports simple CRUD is broken through; input and output parameters are described by adopting a JSON Schema standard, and open type decoupling with a third-party platform is realized; the dynamic characteristics of the JavaScript engine are utilized to realize the hot update of the database operation configuration, and the hot update can take effect without restarting the service. The method is suitable for various zero code development scenes, the development cost can be remarkably reduced, and the flexibility and safety of database operation are improved.

Description

Technical Field

[0001] This invention relates to the fields of software development and database management technology, specifically to a zero-code database operation system and method based on the JavaScript uncompiled language. Background Technology

[0002] With the acceleration of enterprise digital transformation, no-code / low-code development platforms are widely used due to their ability to significantly lower the barrier to application development and improve development efficiency. No-code application development includes both front-end and back-end components, with database operations being the core of back-end development. An ideal no-code database operation solution should allow users to perform operations such as adding, deleting, modifying, and querying data, and managing table structures through a visual interface without having to learn complex database query languages ​​(such as SQL).

[0003] Currently, there are some no-code platforms on the market that provide certain database operation functions, but they generally suffer from the following problems: Limited and simplistic functionality: Existing platform database operation modules (such as Nnack's No-Code Database, Airtable's table operations, and JianDaoYun's form design) mainly support basic CRUD (create, read, update, delete) operations. For advanced features such as complex join queries, view construction, aggregation queries, tree-structured data operations, and flexible business constraints, they are either not supported or implemented in a very complex and weak manner, failing to meet the complex needs of real-world business scenarios.

[0004] Deep coupling and lack of openness: These zero-code database operation functions are deeply coupled with their host platform. The data source and operation logic heavily rely on components within the platform, making them unsuitable as independent services for external systems. This closed architecture limits their application scope and hinders the construction of an open development ecosystem.

[0005] High iteration costs and lack of flexibility: When it is necessary to upgrade or modify a database operation logic, the traditional approach requires modifying the code of the entire backend project and recompiling and deploying the entire service. The process is cumbersome, time-consuming, and risky, and it cannot achieve rapid iteration and hot updates of business functions.

[0006] Inefficient configuration parsing: Existing no-code platforms often use simple string concatenation to convert user configurations into executable database statements, lacking optimization strategies. This results in inefficient code and may even introduce security risks.

[0007] Therefore, there is an urgent need for a zero-code database operation solution that can support complex database operations, has an open interface, and supports hot updates. Summary of the Invention

[0008] The purpose of this invention is to solve the above-mentioned problems existing in the prior art and provide a zero-code database operation system based on the JavaScript uncompiled language. This system aims to solve the problems of single function, high coupling and inconvenient maintenance in the prior art, so as to achieve a zero-code database operation solution with comprehensive functions, open decoupling, support for hot updates and efficient configuration parsing.

[0009] To achieve the above objectives, this invention provides a zero-code database operation method based on the JavaScript uncompiled language, comprising the following steps: Configuration generation steps: Receive database operation configuration information entered by the user through a visual interface, convert the configuration information into structured JSON data and persist it, and generate a unique configuration ID for each configuration; the configuration information includes the operation object, operation behavior, and controller parameter information; Request receiving steps: Receive database operation requests initiated by external callers, the requests including target configuration ID and dynamic parameters; Parameter assembly steps: Load the corresponding database operation configuration according to the target configuration ID, parse the controller parameter information in the database operation configuration, and dynamically mix and assemble the fixed values ​​in the controller parameter information with the dynamic parameters to generate a standard parameter structure; Controller scheduling steps: Based on the operation behavior identifier in the database operation configuration, schedule the corresponding database operation controller that is implemented as a smart contract running on the local V8 engine blockchain, and pass the standard parameter structure to the database operation controller; Statement generation and execution steps: In the database operation controller, a database operation statement conforming to the target database syntax is dynamically generated based on the received standard parameter structure. The statement is then executed by calling the database operation HTTP service through a custom HTTP module. Finally, the operation result is returned to the external caller.

[0010] Furthermore, the parameter items in the controller parameter information are configured as one of the following types: fixed value type, dynamic parameter type, or hybrid type; the hybrid type parameter items record their structural blueprint in the database operation configuration, and the structural blueprint is used to indicate how to embed the dynamic parameters into the skeleton composed of fixed values ​​during parameter assembly.

[0011] Furthermore, the parameter assembly step specifically includes: parsing the structural blueprint of the parameter items in the controller parameter information, identifying the fixed values ​​and parameter placeholders contained in the parameter items; when the parameter item is a fixed value, directly extracting the value; when the parameter item contains a parameter placeholder, extracting the corresponding actual parameter value from the dynamic parameters; and recursively mixing and assembling the fixed values ​​and the actual parameter values ​​according to the structure defined by the structural blueprint to generate the standard parameter structure.

[0012] Furthermore, the controller scheduling step specifically includes: the task scheduling engine obtains the corresponding database operation configuration based on the target configuration ID, and extracts the smart contract address corresponding to the operation behavior identifier from it; the task scheduling engine calls the smart contract execution interface of the local V8 engine blockchain, initiates a call to the smart contract address, and transmits the standard parameter structure as transaction data; the local V8 engine blockchain executes the smart contract in the isolated environment of the V8 engine, and dynamically generates database operation statements.

[0013] Furthermore, the method also includes a hot update configuration step: when it is necessary to upgrade the database operation function, the corresponding database operation controller is hot-updated by updating the mapping relationship between the operation behavior identifier and the smart contract address, without having to restart the task scheduling engine or redeploy the external calling platform.

[0014] Furthermore, the visual configuration interface provided in the configuration generation step includes at least one of the following operation categories: operating table structure, including creating a table, deleting a table, querying a table structure, and updating a table structure; operating table row data, including adding table row data, deleting table row data, modifying table row data, querying table row data, querying table row data in relation to other table row data, and automatically updating table row data; operating related table row data; operating view structure and view row data; and operating tree structure tables and their row data.

[0015] Based on the same inventive concept, this invention also provides a zero-code database operation system based on the JavaScript uncompiled language, for implementing the above method, the system comprising: The configuration generation module provides a visual web interface, receives database operation configuration information entered by the user, stores the configuration information as structured JSON data, and generates a unique configuration ID for each configuration. The interface service module is used to receive database operation requests initiated by external callers. The requests include the target configuration ID and dynamic parameters. The parameter assembly middleware is connected to the interface service module. It is used to obtain the corresponding database operation configuration according to the target configuration ID, parse the controller parameter information in the database operation configuration, and dynamically mix and assemble the fixed values ​​in the controller parameter information with the dynamic parameters to generate a standard parameter structure. The task scheduling engine, connected to the parameter assembly middleware, is used to call the corresponding database operation controller according to the operation behavior identifier in the database operation configuration, and to pass the standard parameter structure to the database operation controller. At least one database operation controller, each of which corresponds to a database operation behavior and is implemented as a smart contract running on the local V8 engine blockchain; the database operation controller is used to dynamically generate database operation statements that conform to the target database syntax according to the received standard parameter structure, execute the statements to complete the database operation, and finally return the operation result to the task scheduling engine.

[0016] Furthermore, the parameter assembly middleware is specifically used to: parse the structural blueprint of the parameter items in the controller parameter information, and identify the fixed values ​​and parameter placeholders contained in the parameter items; the structural blueprint is recorded in the mixed-type parameter items, which is used to indicate how to embed dynamic parameters into the skeleton composed of fixed values; when the parameter item is a fixed value, the value is directly extracted; when the parameter item contains parameter placeholders, the corresponding actual parameter value is extracted from the dynamic parameters; according to the structure defined by the structural blueprint, the fixed values ​​and the actual parameter values ​​are recursively mixed and assembled to generate the standard parameter structure.

[0017] Furthermore, the task scheduling engine is a V8 task scheduling engine written in Go, used to call the smart contract execution interface of the local V8 engine blockchain; the system also includes a custom HTTP module, integrated into the local V8 engine, providing the smart contract with the ability to initiate HTTP requests; the database operation controller calls a preset database operation HTTP service through the custom HTTP module to execute the database operation statements.

[0018] Furthermore, the system supports hot updates. When the database operation function needs to be upgraded, the corresponding database operation controller can be hot-updated by updating the mapping relationship between the operation behavior identifier and the smart contract address, without restarting the task scheduling engine or redeploying the external calling platform. The interface service module provides an HTTP interface, and the input parameter structure and output result structure of the interface are described in accordance with the JSON Schema standard.

[0019] Compared with existing technologies, the zero-code database operation system and method based on the JavaScript uncompiled language provided by this invention has the following advantages: Comprehensive functionality covering complex business scenarios: This invention not only supports basic CRUD operations, but also realizes advanced functions such as complex relational queries, view creation and operation, pipeline aggregation queries, tree-structured data operations, and table-level business condition constraints through an original visual configuration method. This greatly expands the backend capabilities of the no-code platform and can meet a wider range of business needs.

[0020] Open and decoupled, building an open ecosystem: This invention, as an independent system, is exposed through standard HTTP and JSON Schema interfaces, allowing easy integration by any third-party application or coding project. This completely breaks the inherent pattern of deep platform binding for existing no-code database operation functions, achieving truly open development.

[0021] The architecture is flexible and supports hot updates: By implementing the database operation controller as a JavaScript smart contract running on the local V8 blockchain, the system supports independent upgrades and deployments of individual operation functions. When an operation function needs to be upgraded, only the mapping between the operation behavior identifier and the smart contract address needs to be updated, without restarting or redeploying the entire system. This greatly improves the efficiency and flexibility of function iteration and reduces maintenance costs and risks.

[0022] Highly efficient configuration with a flexible combination of dynamic and static parameters: The design of the parameter assembly middleware allows a database operation configuration to include both fixed and dynamic parameters. Users can flexibly define the "variable" parts of the configuration according to business needs, improving configuration reusability. Meanwhile, the structured configuration-based parsing method lays the foundation for subsequent statement optimization (such as pre-compilation and condition refactoring), generating efficient and secure target code.

[0023] High security: The smart contract runtime environment based on blockchain technology provides a high degree of security and isolation for the execution of database operation controllers, preventing intrusion and damage by malicious code.

[0024] Excellent user experience and low learning cost: Users configure the entire process through a visual interface without needing to learn any database operation statements, truly achieving WYSIWYG and significantly reducing the technical threshold and the probability of syntax errors. Attached Figure Description

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

[0026] Figure 1 This is a flowchart illustrating the working principle of the zero-code database operation system in this embodiment of the invention.

[0027] Figure 2 This is a schematic diagram illustrating the configuration of query filtering conditions, including fixed values ​​and configuration parameters, in an embodiment of the present invention.

[0028] Figure 3 This is a schematic diagram of the technical architecture of the zero-code database operation system in an embodiment of the present invention.

[0029] Figure 4 This is an architecture diagram of the zero-code database operation system in an embodiment of the present invention.

[0030] Figure 5 This is a functional structure diagram of the zero-code database operation system in an embodiment of the present invention. Detailed Implementation

[0031] The technical solution of the present invention will be clearly and completely described below with reference to the embodiments. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative effort are within the scope of protection of the present invention. It should be noted that relational terms such as "first" and "second" are only used to distinguish one entity or operation from another entity or operation, and do not necessarily require or imply any such actual relationship or order between these entities or operations.

[0032] This invention provides a zero-code system, meaning that the functions provided to users are entirely zero-code; any user operation described below can be considered a zero-code operation. The core of this invention lies in its innovative design, including visual configuration, parameter assembly middleware, and a smart contract-based database operation controller, to achieve a comprehensive, open, decoupled, and hot-update-supporting zero-code database operation solution. The invention will be described in full and detail below with reference to the accompanying drawings.

[0033] Example 1 This embodiment provides a zero-code database operation method based on the JavaScript uncompiled language to solve the problems of insufficient flexibility, incomplete functionality, and excessive coupling with the platform in existing zero-code platforms.

[0034] like Figure 1 As shown, this method can be simplified into two main lines: main line L1 is the configuration generation line, including entering and storing configurations; main line L2 is the configuration invocation line, including invoking configurations, assembling parameters, scheduling the controller, executing statements in the controller, and returning results. The following section, in conjunction with the appendix... Figure 1 Each step of this method is explained in detail.

[0035] I. Main Thread L1: Configure and generate the thread The main L1 layer is primarily completed by system administrators or developers on the web interface. Its purpose is to transform database operation logic into standardized configuration data, laying the foundation for subsequent reuse and invocation. Specifically, it includes the following steps: Step S101: The user enters the configuration on the web page.

[0036] This system provides corresponding web pages for different database operations, allowing users to visually configure database operation information, such as table name, fields, data types, constraints, etc., when creating a table; and table name, query conditions, etc., when querying a table.

[0037] It should be noted that the "configuration" in step S101 is short for "database operation configuration." It is a structured JSON data file that records three core types of information required for database operations: operation object, operation behavior, and controller parameter information. The operation object refers to information such as the database host and table name to be operated on; the operation behavior refers to the method used to operate on the database, such as creating a table, querying table rows, or deleting table rows; the controller parameter information may be an identifier for receiving parameters from the caller, or a set of real data that, after processing, can be used as parameters for database operation statements, such as field information when creating a table or row data information when adding new table rows.

[0038] Step S102: Import the configuration into the database.

[0039] After a user submits their configuration, the system does not execute it immediately. Instead, it stores the configuration in the system database, where it is executed only when called by the user. When storing the configuration in the database, the system generates a unique configuration ID for each configuration, serving as its unique identifier. Subsequent users can then use this ID to instruct the system to execute the corresponding configuration.

[0040] II. Main Line L2: Configuration Call Line The main L2 line is primarily triggered by external applications (such as no-code front-end platforms or third-party business systems) to dynamically execute database operations based on configuration. Specifically, it includes the following steps: Step S201: The external caller performs database operations.

[0041] External callers initiate database operation requests by invoking the system's standard HTTP interface. These requests must include two key parameters: the target configuration ID and the dynamic parameters required for the current execution. When constructing the dynamic parameters, the caller needs to pre-read the configuration parameter structure to ensure that the passed arguments meet the requirements of that structure.

[0042] For example, if the configuration defines "age" as a dynamic parameter, the caller needs to pass in a specific age value (e.g., 25). The caller can be a no-code application development platform or any application in the coding development process, as long as it can initiate an HTTP request.

[0043] Step S202: The parameter assembly middleware assembles the parameters required by the controller based on the configuration and dynamic parameters.

[0044] After receiving the request, the parameter assembly middleware loads the corresponding database operation configuration from the database according to the configuration ID, and then dynamically mixes and assembles the fixed values ​​in the configuration with the dynamic parameters passed by the caller to generate the standard parameter structure required by the database operation controller.

[0045] The parameter assembly middleware is one of the core components of this system, and its assembly process is as follows: First, the middleware reads the JSON configuration stored in the database. It's worth noting that the web page where the user enters configuration information in step S101 is actually customized based on the database operation controller; it can be considered a visual window for entering database operation parameters. Each configuration item corresponds to a parameter in the database operation controller, and different parameters have different data entry UIs.

[0046] Secondly, the middleware executes different assembly strategies based on the parameter types defined in the configuration. There are three ways to enter configuration items: the entire configuration item is a fixed value, the entire configuration item is a configuration parameter, and the configuration item contains both fixed values ​​and configuration parameters.

[0047] If a configuration item is marked as a fixed value (such as "status=1"), the middleware reads the value directly from the database operation configuration JSON without any additional processing.

[0048] If a configuration item is marked as a parameter placeholder, the middleware extracts the corresponding actual parameter value from the dynamic parameters received in step S201, and no additional processing is required.

[0049] For complex nested structures, where configuration items contain both fixed values ​​and configuration parameters, the middleware needs to perform assembly processing. Information on how to assemble the configuration is recorded in the database operation configuration JSON after the configuration item is configured. This includes the configuration item structure UI rendering data, fixed value information, and configuration parameter information. The middleware generates the structure of the actual values ​​for the configuration items based on the configuration item structure UI rendering data. During the generation process, fixed values ​​are directly added to the actual values, and when parameters are encountered, the parameter value is retrieved from the caller's parameter list based on the parameter name and added to the actual values.

[0050] like Figure 2 The image shows an example of query condition configuration items for querying table row data, which includes both fixed values ​​and configuration parameters. "Zhang San" in "Username equals Zhang San" is a fixed value, "age" in "Age greater than parameter age" is a configuration parameter, and "Username equals xxx and age greater than parameter xxx" represents the overall structure of the configuration items.

[0051] Configuration parameters are dynamic parameters required to execute a configuration, set by the user on the web page. A configuration can be understood as a user-defined function; the configured operation objects and behaviors represent the function's execution logic, and the configuration parameters serve as the function's arguments. For example, if a user configures an operation to add a new row of data to a table via the web page and enters a fixed user information entry in the "Add Data" configuration item, then this configuration will write the same data every time it is executed. However, in practical application development, dynamic parameter passing is often required, with the specific data content only known just before the "Add Data" operation is executed. Therefore, this system provides corresponding parameter configuration items on the web page for all parameters that need to be dynamically passed.

[0052] Step S203: The local V8 task scheduling engine calls the specified database operation controller. Specifically, the local V8 task scheduling engine calls the specified database operation controller according to the configuration and passes the parameters obtained in the previous step to it.

[0053] The V8 task scheduling engine is a scheduling service provided by this system. It can invoke different database operation controllers based on database operation configurations. Each database operation configuration specifies which controller should execute it when it is created. For example, if a user configures a table creation operation, the configuration will record that it must be executed by the database operation controller for table creation.

[0054] The V8 task scheduling engine passes the standard parameter structure assembled in step S202 along with the database operation controller when calling it.

[0055] Step S204: After receiving the parameters, the database operation controller generates and executes the database operation statement.

[0056] The database operation controller is a layer of encapsulation for the database API in this system. It is usually written in JavaScript and is used to encapsulate basic database operations such as creating tables, adding table rows, and querying table rows. It serves as the blueprint for the database operation configuration web pages provided to users in step S101. Each database operation web page is built based on the functionality of the corresponding database operation controller.

[0057] The specific implementation includes the following sub-steps: (1) Dynamic parsing: After receiving the parameters, the controller script dynamically parses and generates standard database operation statements (such as SQL statements) based on the preset business rule template and parameter values.

[0058] (2) Execution and communication: To ensure security isolation, the V8 engine runtime environment sends the generated database operation statements to a separate database operation HTTP service through a custom HTTP module.

[0059] (3) Result return: After receiving the statement, the database operation HTTP service calls the underlying database's native API to execute the statement and returns the execution result to the V8 task scheduling engine level by level, and finally returns it to the external caller through the HTTP interface.

[0060] By following the steps above, users can operate the database without learning database operation statements. They only need to configure it on the visual interface, and the statements are automatically generated internally by the system. This not only reduces the learning cost but also significantly reduces the probability of syntax errors, truly achieving WYSIWYG (What You Configure Is What You Get).

[0061] III. Underlying Technical Architecture Based on Smart Contracts To gain a deeper understanding of the advanced nature and specific implementation of steps S203 and S204, the following will combine... Figure 3 This paper elaborates on the implementation method, operating environment, and interaction mechanism between the database operation controller and the underlying database in this invention.

[0062] In a preferred embodiment of the invention, the database operation controller is not a traditional function or class tightly coupled to the system code, but is implemented as a smart contract running in the local blockchain environment. This architecture brings unprecedented flexibility, security, and maintainability to the system.

[0063] like Figure 3 As shown, this underlying implementation process can be broken down into the following steps: Step S301: The external caller initiates a database operation request.

[0064] This step and Figure 1Step S201 remains logically consistent. External systems call the API interface of the V8 task scheduling engine exposed by this system via the HTTP protocol, carrying the target configuration ID and the required dynamic parameters in the request. This HTTP interface is the standard entry point for this invention to provide services externally.

[0065] Step S302: The V8 task scheduling engine calls the database operation controller smart contract.

[0066] Upon receiving a request, the V8 task scheduling engine (preferably written in Go in this embodiment) first retrieves the corresponding database operation configuration from the system database based on the configuration ID. This configuration, in addition to parameter assembly information, explicitly specifies the address of the database operation controller smart contract required to perform this operation. Subsequently, the scheduling engine, acting as a blockchain client, invokes the smart contract execution interface of the local V8 blockchain to call the contract at the specified address, and transmits the standard parameter structure assembled in step S202 as transaction data to that contract.

[0067] Step S303: Local V8 engine blockchain execution database operation controller smart contract.

[0068] The system of this invention deploys a local V8 engine blockchain. This is a lightweight, localized blockchain runtime environment, whose core feature is the use of Google's V8 engine as the virtual machine for smart contracts. The invoked database operation controller is a smart contract written in JavaScript and pre-deployed on this blockchain.

[0069] The V8 engine is renowned for its efficient JavaScript code compilation and execution capabilities, enabling it to compile contract code into high-performance machine code on the fly, providing a secure, isolated, and efficient runtime environment for contract execution. Within this environment, smart contracts receive parameters from the scheduling engine and dynamically parse these parameters based on their internal business logic, ultimately generating complete database operation statements that conform to the target database's syntax.

[0070] Step S304: The V8 engine uses a custom built-in HTTP module to call the database operation HTTP service.

[0071] To decouple and facilitate communication between the smart contract runtime environment and external databases, this invention integrates a custom built-in HTTP module into the V8 engine. This module provides JavaScript smart contracts running on the V8 engine with the ability to initiate HTTP requests.

[0072] After generating valid database operation statements in step S303, the smart contract does not directly manipulate the database. Instead, it invokes this custom built-in HTTP module to send an HTTP request to another independent database operation HTTP service within the system, specifically responsible for interacting with the database. The body of this request contains the database statements to be executed.

[0073] The database operation HTTP service is a service module provided by this invention that directly encapsulates and calls the underlying database's native API. Upon receiving an HTTP request from a smart contract, it parses the database statement within it and executes the statement through a database driver. After execution, the service encapsulates the result into an HTTP response and returns it to the smart contract that called it. Finally, this result is returned to the external caller that initially initiated the request, following the path: smart contract → V8 task scheduling engine → external HTTP interface.

[0074] By introducing the aforementioned underlying smart contract-based technical architecture, this invention achieves significant technological advancements. Taking hot updates as an example: when business requirements change, necessitating the addition of complex pagination and sorting logic to the "query table row data" function, developers only need to modify the corresponding JavaScript code of the "query table row data" smart contract and redeploy the updated contract on the local V8 blockchain. The system only needs to update the mapping relationship between the operation behavior identifier and the new contract address, and the entire upgrade process is complete. During this process, other parts of the system (such as the "create table" controller, parameter assembly middleware, and external interfaces) remain completely unaffected, requiring no stopping, recompilation, or redeployment. This greatly improves the system's iteration efficiency and ease of operation and maintenance.

[0075] Thus, combined Figures 1 to 3 This invention fully describes the entire process from configuration input and storage to being invoked, parameter assembly, smart contract execution, and finally, database operation and result return.

[0076] Example 2 This invention also provides a zero-code database operation system based on the JavaScript non-compiled language. The system encapsulates the complex logic of database operations within visual configuration and intelligent scheduling execution through a series of highly decoupled and collaborative core modules, providing users with a comprehensive, open, integrated, and real-time hot-update-supporting zero-code solution. Figure 4 As shown, it specifically includes: Configuration generation module The configuration generation module is the logical design center of the entire system, and its core is to provide a complete visual web configuration interface. This interface covers all database operations from data structure definition to complex business queries, including but not limited to: table creation, modification, and querying; basic CRUD operations on table rows; support for multi-table joins and complex conditional join queries; view creation and view-based data operations; and specialized operations for tree-structured data (providing various child node processing strategies). Users can complete all configurations through pure interface interaction methods such as clicking and form filling, without writing any database query statements.

[0077] The configuration generation module ultimately transforms all user configuration operations into a structured JSON configuration description file. This JSON configuration description file precisely encapsulates three dimensions of information: the operation object (such as the target database, table name, or view name), the operation behavior identifier (such as `create_table`, `query_table_rows`), and controller parameter information. Parameter information supports flexible definition and can include fixed values, dynamic parameter placeholders, or complex nested structures combining both. Each successfully saved configuration is assigned a globally unique configuration ID and persistently stored. This is equivalent to templated and assetized a piece of database operation logic, with its configuration ID becoming the unique entry point for subsequent calls.

[0078] Interface service module The API service module serves as the system's standardized service gateway, dedicated to achieving open decoupling from third-party systems. It exposes RESTful API interfaces based on the HTTP protocol, with input parameters and output results strictly adhering to the JSON Schema standard for description and definition, ensuring the interface's explicitness, maintainability, and ease of integration.

[0079] External systems (such as other business applications, front-end pages, or no-code platforms) trigger predefined database operations by calling the interface of this module. The call request must contain two key elements: the target configuration ID, which specifies which pre-configured logic to execute; and dynamic parameters, a JSON object that provides the variable values ​​required for this execution. For example, for a product query configuration with a dynamic price cap, the call must pass {"maxPrice":5000}. The interface service module is responsible for receiving, validating, and forwarding these requests to the internal system pipeline, and is key to the system's "configure once, call anywhere" open architecture.

[0080] Parameter assembly middleware The parameter assembly middleware is an intelligent assembly engine that connects static configurations and dynamic requests. It is responsible for combining templated configurations and real-time call parameters into executable instructions. The parameter assembly middleware is activated when the interface service module forwards a request.

[0081] The parameter assembly middleware first loads the corresponding structured JSON configuration based on the target configuration ID in the request. Then, its core task is to parse the controller parameter information in the configuration. Each parameter item in the controller parameter information has a predefined type (fixed value, dynamic parameter, or mixed type) and structure blueprint. For fixed values ​​(such as status="enabled"), the middleware extracts them directly; for dynamic parameter placeholders, it extracts the corresponding actual values ​​from the dynamic parameters in the request; for mixed type parameter items, the structure blueprint defines the nesting relationship between the fixed value skeleton and the dynamic parameter placeholders. The middleware recursively parses this blueprint, precisely embedding the extracted actual values ​​into the fixed value skeleton, ultimately assembling a complete, standard parameter structure object. This process achieves the separation and flexible combination of business logic (fixed part) and runtime data (dynamic part), greatly improving the reusability of the configuration.

[0082] Task scheduling engine The task scheduling engine is the core scheduler of the system, responsible for routing the assembled parameters to the correct execution units. It is a persistent service developed using a high-performance language (such as Go), and its core responsibility is to perform precise scheduling based on the operation behavior identifiers in the configuration.

[0083] After receiving the standard parameter structure produced by the parameter assembly middleware, the task scheduling engine queries the operation behavior identifier recorded in the configuration. Internally, the system maintains a mapping table between operation behavior identifiers and specific execution unit addresses. Crucially, the execution unit is not a traditional library function compiled into the process, but rather implemented as a JavaScript smart contract deployed on the local V8 engine blockchain. Each contract specializes in a single database operation (such as query or insert) and has a unique on-chain address.

[0084] Therefore, after the task scheduling engine finds the corresponding smart contract address based on the identifier, it calls the local V8 blockchain's smart contract execution interface to initiate a contract call transaction, passing in the standard parameter structure as transaction data. This architecture is the cornerstone for enabling hot updates of functionality: when a database operation logic needs to be upgraded, developers only need to deploy the new version of the JavaScript smart contract to the blockchain and update the address mapping relationship in the scheduling engine, and it will take effect immediately without restarting the scheduling engine or the entire system service, achieving agile iteration and seamless upgrades of business functions.

[0085] Database Operation Controller The database operation controller is the secure execution unit that ultimately executes business logic and generates and executes database statements. Specifically, it takes the form of a JavaScript smart contract running on the local V8 engine blockchain. Each controller smart contract encapsulates the complete business logic for a specific database operation, such as parsing query conditions and constructing SQL statements.

[0086] When invoked by the task scheduling engine, the smart contract runs in a sandboxed isolation environment provided by the V8 engine, ensuring execution security. The contract code receives the standard parameter structure and dynamically generates operation statements (such as SQL) that conform to the target database syntax based on its internal logic. After generating the statements, the contract does not directly connect to the database. Instead, it uses a custom HTTP module integrated into the V8 engine to send a request to an independent, high-privilege "database operation HTTP service" within the system, sending the generated statements as the request payload. This HTTP service is responsible for actually connecting to the database and executing the statements, then returning the results to the smart contract. Finally, the operation results are returned to the external caller along the call chain (smart contract → task scheduling engine → interface service module). This design leverages the flexibility of JavaScript and the high performance of the V8 engine, while ensuring the security and controllability of database access through the encapsulation of blockchain smart contracts and HTTP proxy isolation.

[0087] In summary, this system constructs a complete zero-code database operation closed loop through the pipeline collaboration of five major modules. Users perform visual design and generate configuration templates through the configuration generation module; external systems call services through the standardized interface service module; the parameter assembly middleware dynamically integrates the call parameters with the configuration template; the task scheduling engine performs flexible scheduling based on smart contract mapping; and finally, the database operation controller (smart contract) running in a secure sandbox completes statement generation and execution. This architecture not only achieves full functional coverage from complex relational queries and aggregation analysis to transaction operations, but also provides unprecedented openness, flexibility, and maintainability through open APIs, decoupling of configuration and execution, and a smart contract hot update mechanism, truly realizing zero-code development, deployment, and integration of database operations.

[0088] Example 3 This embodiment details how users can configure various database operations in a zero-code manner through the visual web interface provided by the system of this invention. For example... Figure 5As shown, the system's visual operations are divided into seven core parts based on the different operation objects and functions: operation table structure, operation table row data, operation related table row data, operation tree table row data, operation view structure, operation view data, and operation tree related table row data. All operations are completed through pure interface interaction such as point selection and form filling. Users do not need to write any database statements (such as SQL), truly achieving WYSIWYG (What You Configure Is What You Get).

[0089] Operation table structure The table structure manipulation feature provides functionality for defining and modifying database tables, including four methods: creating, deleting, querying, and updating table structures. Each operation is accompanied by a corresponding visual web configuration page.

[0090] When a user performs a "Create Table" operation, they first enter the table creation configuration page from the system's main interface. On this page, the user needs to enter basic information such as the table name and table comments. Then, by clicking the "Add Field" button, the user can define each field in the table, including its name, type, default value, whether it is a primary key, and whether it is required. In addition, the interface provides separate "Index Configuration," "Foreign Key Configuration," "Field Constraint Configuration," and "Global Business Condition Settings" buttons for defining advanced table logic. The global business condition settings allow users to set business rules across fields or tables, such as constraining "Order Table.Product Quantity ≤ Product Table.Inventory." After designing, the user can choose to "Save" the configuration for later use or "Execute Immediately" to have the system generate and execute the table creation statements on the spot.

[0091] The processes for "deleting a table," "querying table structure," and "updating table structure" are more streamlined. After entering the corresponding page, users primarily select the target table through drop-down menus. When updating the table structure, the system displays the existing table structure; the modification interface has the same layout as the table creation interface, allowing users to add, delete, or modify fields. After completing these operations, users can choose to save the configuration or execute immediately.

[0092] Manipulate table row data The table row data manipulation function provides CRUD operations and advanced query functions for data in the table, including 6 operation methods: adding, querying, modifying, deleting, and automatic updating (batch operation).

[0093] Taking "Add Table Row Data" as an example, after the user selects the target table, the interface will list all fields of the table and their corresponding value input boxes. Users can directly enter fixed values ​​or set values ​​as "configuration parameters" to be dynamically passed in during the query. The "Query Table Row Data" function is even more powerful. Users can not only select the returned fields and configure dynamic parameters, but also construct complex query conditions through the intuitive "Add Filter Conditions" interface, supporting pagination and sorting settings. Furthermore, the system supports advanced "pipeline aggregation queries," allowing users to configure grouping, aggregation calculations (such as summation and average), and sorting sequentially through "Add Aggregation Steps," thus enabling complex analyses such as "Sales Amount Ranking" without writing SQL.

[0094] The configuration logic for "Modify Table Row Data" and "Delete Table Row Data" is similar to that of queries. Both require configuring the corresponding conditions to locate the target data row before setting the update value or deletion operation. "Automatically Update Table Row Data" handles batch operations of adding, modifying, and deleting data all at once. Its interface is similar to adding data, but the system internally adds a special field, _writeType, to the operation data to identify the operation type (such as add, modify, delete). The caller controls the operation behavior for each row of data by passing different values ​​to this field.

[0095] Manipulate related table row data The operation on related table rows supports combined operations on parent and child tables with foreign key relationships, including five methods: adding, querying, modifying, deleting, and automatically updating related table rows. Its configuration is highly consistent with the operation on table rows, the core difference being that its operation scope spans multiple related tables.

[0096] For example, when configuring "Querying Rows from Related Tables," users first need to select a "Parent Table." The system interface then displays a list of fields from that parent table and all its related child tables. Users can select any fields they want to query from these related tables and set the query conditions to fields from the parent table or any child table. This makes configuring multi-table join queries as intuitive as configuring single-table queries.

[0097] Operation view structure The view structure provides four methods for creating, querying, modifying, and deleting database views. Creating a view is the core operation among them.

[0098] After entering the view creation configuration page, users first enter the view name, remarks, and other information, and then add one or more base tables using the "Select Table" button. The system will display the fields of all selected tables for users to check to form the columns of the view. When selecting multiple tables, the join conditions between the tables must be configured. Users can flexibly construct table join relationships using the "Add Join Condition" button, for example, setting "Order table.User ID = User table.User ID", and can add additional filter conditions within the same set of join conditions using "AND" and "OR" logic, such as "Product table.Category = 'Electronic Products'".

[0099] Manipulate view data The view manipulation function provides four methods for adding, deleting, modifying, and querying data in created views. Its configuration is exactly the same as that for operating table rows; users only need to select the target view, not the physical table, at the start of the operation.

[0100] Manipulating tree structure tables and tree structure table row data Tree structure tables are built-in template tables used to store tree-shaped data (such as organizational structures), containing three fixed fields: id, pid, and indexID. There are nine methods for operating on this type of table, and their configuration is basically the same as the table structure and row data, but there are key differences.

[0101] When creating a tree structure table, the interface already includes the three fixed fields mentioned above by default. Modifying these three fields is prohibited when creating a tree structure table. The most significant difference lies in the operations for "deleting tree structure table rows" and "automatically updating tree structure table rows." Due to the special nature of tree structures, the system provides three additional deletion strategies for users to choose from: "synchronously delete all child nodes," "disallow deletion of nodes with child nodes," and "delete the node and promote its child nodes to first-level nodes." Users can specify the deletion behavior using radio buttons, and the system will automatically handle complex hierarchical relationships.

[0102] Operation tree related table row data The tree-related table row data manipulation function provides three methods for querying, modifying, and deleting data in other tables associated with the tree structure table. Its configuration is largely the same as that for manipulating the related table row data. Similarly, when performing a deletion operation, the interface provides the same three tree structure deletion strategies as those for manipulating the tree structure table and its row data, allowing the user to choose how to handle the nodes in the related tree table.

[0103] Through the seven categories of visual operation interfaces described above, users can complete the entire process from database structure design to complex business data querying and maintenance without writing any code. All configurations completed in the interface are converted into a structured JSON description file and stored in the system database, while generating a unique configuration ID. Subsequently, any external system only needs to call the standard HTTP interface provided by this invention system, passing in this configuration ID and necessary dynamic parameters, to trigger the execution of the corresponding database operations.

[0104] Example 4: Electronic Equipment The present invention also provides an electronic device, including: a processor, a memory, an input device, and an output device. The processor may be implemented using a general-purpose central processing unit, a microprocessor, an application-specific integrated circuit (ASIC), or one or more integrated circuits, and is used to execute relevant programs to implement the technical solutions provided in the embodiments of this application. The memory may be implemented using a read-only memory, a static storage device, a dynamic storage device, or a random access memory, and is used to store computer program code, the computer program code including computer instructions. When the processor executes the computer instructions, the electronic device executes the zero-code database operation method based on the JavaScript uncompiled language as described in Embodiment 1.

[0105] Example 5: Computer-readable storage medium The present invention also provides a computer-readable storage medium storing a computer program, the computer program including program instructions that, when executed by a processor of an electronic device, cause the processor to perform a zero-code database operation method based on the JavaScript uncompiled language as described in Embodiment 1.

[0106] In the description of this specification, the references to terms such as "an embodiment," "example," "specific example," etc., indicate that a specific feature, structure, material, or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of the present invention. In this specification, the illustrative expressions 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 one or more embodiments or examples.

[0107] The above description is merely a specific embodiment of the present invention, enabling those skilled in the art to understand or implement the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the invention. Therefore, the present invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features claimed herein.

Claims

1. A zero-code database operation method based on the JavaScript uncompiled language, characterized in that, Includes the following steps: Configuration generation steps: Receive database operation configuration information entered by the user through a visual interface, convert the configuration information into structured JSON data and persist it, and generate a unique configuration ID for each configuration; the configuration information includes the operation object, operation behavior, and controller parameter information; Request receiving steps: Receive database operation requests initiated by external callers, the requests including target configuration ID and dynamic parameters; Parameter assembly steps: Load the corresponding database operation configuration according to the target configuration ID, parse the controller parameter information in the database operation configuration, and dynamically mix and assemble the fixed values ​​in the controller parameter information with the dynamic parameters to generate a standard parameter structure; Controller scheduling steps: Based on the operation behavior identifier in the database operation configuration, schedule the corresponding database operation controller that is implemented as a smart contract running on the local V8 engine blockchain, and pass the standard parameter structure to the database operation controller; Statement generation and execution steps: In the database operation controller, a database operation statement conforming to the target database syntax is dynamically generated based on the received standard parameter structure, and the statement is executed by calling the database operation HTTP service through a custom HTTP module. Finally, the operation result is returned to the external caller. The parameter items in the controller parameter information are configured as one of the following types: fixed value type, dynamic parameter type, or hybrid type. The hybrid type parameter items record their structure blueprint in the database operation configuration. The structure blueprint is used to indicate how to embed the dynamic parameters into the skeleton composed of fixed values ​​during parameter assembly.

2. The method according to claim 1, characterized in that, The parameter assembly step specifically includes: The structural blueprint of the parameter items in the controller parameter information is analyzed to identify the fixed values ​​and parameter placeholders contained in the parameter items; When a parameter is a fixed value, the value is extracted directly; when a parameter contains a parameter placeholder, the corresponding actual parameter value is extracted from the dynamic parameters. According to the structure defined in the structural blueprint, the fixed values ​​and the actual parameter values ​​are recursively mixed and assembled to generate the standard parameter structure.

3. The method according to claim 1, characterized in that, The controller scheduling steps specifically include: The task scheduling engine obtains the corresponding database operation configuration based on the target configuration ID, and extracts the smart contract address corresponding to the operation behavior identifier from it. The task scheduling engine calls the smart contract execution interface of the local V8 engine blockchain, initiates a call to the smart contract address, and transmits the standard parameter structure as transaction data. The local V8 engine blockchain executes the smart contract in the isolated environment of the V8 engine, dynamically generating database operation statements.

4. The method according to claim 1, characterized in that, It also includes configuring hot update steps: when it is necessary to upgrade the database operation function, the corresponding database operation controller can be hot-updated by updating the mapping relationship between the operation behavior identifier and the smart contract address, without having to restart the task scheduling engine or redeploy the external calling platform.

5. The method according to claim 1, characterized in that, The visual configuration interface provided in the configuration generation step includes at least one of the following operation categories: Manipulate table structures, including creating tables, deleting tables, querying table structures, and updating table structures; Manipulate table row data, including adding table row data, deleting table row data, modifying table row data, querying table row data, performing join queries on table row data, and automatically updating table row data; Manipulate related table row data; Manipulate view structure and view row data; Operate on the tree structure table and its row data.

6. A zero-code database operation system based on the JavaScript uncompiled language, used to implement the method according to any one of claims 1-5, characterized in that, The system includes: The configuration generation module provides a visual web interface, receives database operation configuration information entered by the user, stores the configuration information as structured JSON data, and generates a unique configuration ID for each configuration. The interface service module is used to receive database operation requests initiated by external callers. The requests include the target configuration ID and dynamic parameters. The parameter assembly middleware is connected to the interface service module. It is used to obtain the corresponding database operation configuration according to the target configuration ID, parse the controller parameter information in the database operation configuration, and dynamically mix and assemble the fixed values ​​in the controller parameter information with the dynamic parameters to generate a standard parameter structure. The task scheduling engine, connected to the parameter assembly middleware, is used to call the corresponding database operation controller according to the operation behavior identifier in the database operation configuration, and to pass the standard parameter structure to the database operation controller. At least one database operation controller, each of which corresponds to a database operation behavior and is implemented as a smart contract running on the local V8 engine blockchain; the database operation controller is used to dynamically generate database operation statements that conform to the target database syntax according to the received standard parameter structure, execute the statements to complete the database operation, and finally return the operation result to the task scheduling engine.

7. The system according to claim 6, characterized in that, The parameter assembly middleware is specifically used for: The structural blueprint of the parameter items in the controller parameter information is parsed to identify the fixed values ​​and parameter placeholders contained in the parameter items; the structural blueprint is recorded in the mixed-type parameter items and is used to indicate how to embed dynamic parameters into the skeleton composed of fixed values; When a parameter is a fixed value, the value is extracted directly; when a parameter contains a parameter placeholder, the corresponding actual parameter value is extracted from the dynamic parameters. According to the structure defined in the structural blueprint, the fixed values ​​and the actual parameter values ​​are recursively mixed and assembled to generate the standard parameter structure.

8. The system according to claim 6, characterized in that, The task scheduling engine is a V8 task scheduling engine written in Go, used to call the smart contract execution interface of the local V8 engine blockchain; the system also includes a custom HTTP module, integrated into the local V8 engine, providing the smart contract with the ability to initiate HTTP requests; the database operation controller calls a preset database operation HTTP service through the custom HTTP module to execute the database operation statements.

9. The system according to claim 6, characterized in that, The system supports hot updates. When it is necessary to upgrade the database operation function, the corresponding database operation controller can be hot-updated by updating the mapping relationship between the operation behavior identifier and the smart contract address, without restarting the task scheduling engine or redeploying the external calling platform. The interface service module provides an HTTP interface to the outside world, and the input parameter structure and output result structure of the interface are described in accordance with the JSON Schema standard.

Images