Visual data integration method and device, computer equipment and storage medium

Abstract

The invention relates to the technical field of big data and is applied to the fields of finance and medical health. The invention discloses a visual data integration method and device, computer equipment and a storage medium. The method comprises the following steps: determining entities, attributes and relationships based on business requirements, and forming document metadata; on the basis of the document metadata, generating an interface prototype according to user demand research and competitive product analysis results; generating a graphic component for operating the interface prototype and realizing a dragging function to obtain a data model; and storing the data model in a selected storage medium, and recording version information for a terminal to backtrack and compare historical version information. By implementing the method provided by the invention, the development efficiency can be remarkably improved, and meanwhile, the consistency of data and the expansibility of the system are ensured, so that non-professional developers can also efficiently participate in the development and maintenance of the application program, the technical threshold is greatly reduced, and complex business requirements are met.

Description

Technical Field

[0001] This invention relates to the fields of big data, finance and healthcare technologies, and more specifically to methods, apparatuses, computer equipment and storage media for visual data integration. Background Technology

[0002] Financial business process orchestration systems represent an important type of solution technology in the field of information technology. Their primary purpose is to rapidly build applications with minimal coding and manual configuration. These systems are typically based on graphical interfaces, visual modeling, and integration tools, aiming to simplify the application development process and reduce the time and complexity required for traditional coding. While existing service orchestration visual data models and integration solutions can meet market demands to some extent, they still present significant shortcomings and challenges in specific scenarios.

[0003] In the financial sector, financial institutions need to handle complex business logic, such as customer information management, loan approval processes, and transaction monitoring. These operations often involve large amounts of data interaction and stringent compliance requirements. While traditional service orchestration tools can provide some automation, they often fall short when faced with customized business needs. For example, designing a flexible loan approval process may require dynamically adjusting approval steps based on different risk assessment results; this highly personalized business logic is difficult to achieve with existing standardized tools. Furthermore, with the development of fintech, financial institutions face ever-increasing data volumes and higher concurrent access demands, further exposing the performance and scalability limitations of existing systems.

[0004] Similarly, in the healthcare field, electronic health record systems and patient management systems need to process large amounts of sensitive personal health information and must strictly comply with relevant privacy regulations. Healthcare institutions hope to improve efficiency and service quality by designing and optimizing business processes in a more intuitive way. However, current service orchestration solutions perform poorly in handling complex healthcare business logic. For example, when implementing personalized configurations for patient visits, such as appointment booking, examination scheduling, and medication prescriptions, the specific needs of different departments and patients' special circumstances need to be considered, which places higher demands on the system's flexibility. At the same time, with the popularization of digital healthcare services, how to efficiently manage and analyze massive amounts of medical data has become an urgent problem to be solved.

[0005] In summary, while some visual data models and integration solutions for service orchestration exist on the market, they generally lack sufficient customization capabilities and the ability to handle large-scale data processing. This limitation is particularly pronounced in industries like finance and healthcare, which have extremely high requirements for security, reliability, and flexibility.

[0006] Therefore, it is necessary to design a new method to significantly improve development efficiency while ensuring data consistency and system scalability, enabling non-professional developers to participate efficiently in application development and maintenance, greatly reducing the technical threshold and adapting to complex business needs. Summary of the Invention

[0007] The purpose of this invention is to overcome the shortcomings of the prior art and provide a method, apparatus, computer equipment and storage medium for visual data integration.

[0008] To achieve the above objectives, the present invention adopts the following technical solution: a visualization data integration method, comprising:

[0009] Based on business needs, entities, attributes, and relationships are clearly defined, and documented metadata is generated.

[0010] Based on the documented metadata, and according to the results of user needs surveys and competitor analysis, an interface prototype is generated.

[0011] Generate graphical components for manipulating the interface prototype and implement drag-and-drop functionality to obtain the data model;

[0012] The data model is saved to the selected storage medium, and version information is recorded so that the terminal can trace back and compare historical version information.

[0013] The further technical solution is as follows: Based on business needs, entities, attributes, and relationships are clearly defined, and documented metadata is formed, including:

[0014] Generate a business requirements document based on the input business needs and technical constraints;

[0015] Based on the aforementioned business requirements document, identify entities, attributes, and relationships;

[0016] Preset constraints and validation rules are applied to the attributes, and the validity of the attributes is reviewed by an algorithm to obtain documented metadata.

[0017] The further technical solution is as follows: Based on the documented metadata, and according to the results of user needs research and competitor analysis, an interface prototype is generated, including:

[0018] Collect and analyze user needs and competitor analysis results to obtain the analysis results;

[0019] The documented metadata is used in conjunction with the analysis results to generate design specifications, and the entities and relationships are parsed to form parsed information;

[0020] Generate user stories and use cases based on the analysis results and user needs;

[0021] An initial interface layout prototype is generated based on the documented metadata.

[0022] Based on the initial interface layout prototype, adjustments and optimizations were made through a feedback mechanism, and visual design elements were added to obtain the interface prototype.

[0023] The further technical solution is as follows: generating graphical components for operating the interface prototype and implementing drag-and-drop functionality to obtain a data model includes:

[0024] Generate a canvas and toolbar for operating the interface prototype, a standard icon library that is visually easy to distinguish and contains all the necessary attributes, to obtain graphical components;

[0025] Based on the aforementioned graphical components, the front-end framework and its plugins are used to generate drag-and-drop operations and mouse event listeners. Detailed information and connection methods of entities, attributes, and relationships are processed through a sidebar or pop-up window to obtain elements.

[0026] Generate constraint configuration options for each element to obtain the data model.

[0027] The further technical solution is as follows: the generation of a canvas and toolbar for operating the interface prototype, and a standard icon library that is visually easy to distinguish and contains all necessary attributes, to obtain graphical components, including:

[0028] Generate a canvas area, wherein entities, attributes, and relationship icons can be dragged and dropped within the canvas area, and zoom and pan functions are available;

[0029] A toolbar is set in the interface, which provides a variety of graphic elements for the user to choose from;

[0030] Generate a standard icon library, wherein the standard icon library contains all the necessary graphic elements;

[0031] Define a set of basic attributes for each graphic element in the standard icon library, and allow users to modify them through an interactive interface to obtain a graphic component; wherein, the basic attributes include name, type, and constraints.

[0032] The further technical solution is as follows: saving the data model to a selected storage medium and recording version information for the terminal to trace and compare historical version information includes:

[0033] Define the version data structure;

[0034] Configure database tables to store detailed information for each version;

[0035] The data model can be saved to the selected storage medium via API, and save, read, update, and delete operations can be performed.

[0036] When the data model is saving changes, it detects changes to the data model and updates the version data structure and database tables when changes occur, and restores the content corresponding to the historical version information through the rollback function.

[0037] The further technical solution is as follows: when the data model is saved and changes are detected, the version data structure and database tables are updated when changes occur, and the content corresponding to the historical version information is restored through the rollback function, including:

[0038] When the data model is saved, changes to the data model are detected. When changes occur, a version comparison algorithm based on a tree structure is used to identify and display the addition, deletion, and modification of entities, attributes, and relationships between different versions, so as to update the version data structure and database tables. The rollback function is used to restore the content corresponding to the historical version information.

[0039] The present invention also provides a visualization data integration device, comprising:

[0040] Document metadata forming unit, used to define entities, attributes and relationships based on business needs, and to form documented metadata;

[0041] The interface prototype design unit is used to generate interface prototypes based on the documented metadata and the results of user needs research and competitor analysis.

[0042] A data model determination unit is used to generate graphical components for operating the interface prototype and implement drag-and-drop functionality to obtain a data model.

[0043] The record-keeping unit is used to save the data model to a selected storage medium and record version information so that the terminal can trace back and compare historical version information.

[0044] The present invention also provides a computer device, the computer device including a memory and a processor, the memory storing a computer program, and the processor executing the computer program to implement the above-described method.

[0045] The present invention also provides a storage medium storing a computer program that, when executed by a processor, implements the above-described method.

[0046] The advantages of this invention compared to existing technologies are as follows: This invention forms documented metadata by clearly defining entities, their attributes, and relationships based on business needs. Subsequently, it designs an interface prototype based on user needs research and competitive analysis results, and develops drag-and-drop graphical components to create a data model. Finally, it saves the model to a storage medium and records version information for backtracking and comparing historical versions. This series of steps significantly improves development efficiency. This method ensures data consistency and system scalability, allowing non-professional developers to efficiently participate in application development and maintenance without in-depth knowledge of programming languages. It greatly lowers the technical threshold, enabling more people to participate in projects, while also flexibly adapting to complex changes in business needs, thereby achieving rapid iteration and market responsiveness. This low-code / no-code development approach not only accelerates time-to-market but also improves team collaboration efficiency and promotes innovation.

[0047] The present invention will be further described below with reference to the accompanying drawings and specific embodiments. Attached Figure Description

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

[0049] Figure 1 This is a schematic diagram illustrating an application scenario of the visualization data integration method provided in this embodiment of the invention.

[0050] Figure 2 A flowchart illustrating the visualization data integration method provided in an embodiment of the present invention;

[0051] Figure 3 This is a schematic diagram of a sub-process of the visual data integration method provided in an embodiment of the present invention;

[0052] Figure 4 This is a schematic diagram of a sub-process of the visual data integration method provided in an embodiment of the present invention;

[0053] Figure 5 This is a schematic diagram of a sub-process of the visual data integration method provided in an embodiment of the present invention;

[0054] Figure 6 This is a schematic diagram of a sub-process of the visual data integration method provided in an embodiment of the present invention;

[0055] Figure 7 This is a schematic diagram of a sub-process of the visual data integration method provided in an embodiment of the present invention;

[0056] Figure 8 A schematic block diagram of a visualization data integration device provided in an embodiment of the present invention;

[0057] Figure 9 A schematic block diagram of a computer device provided for an embodiment of the present invention. Detailed Implementation

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

[0059] It should be understood that, when used in this specification and the appended claims, the terms "comprising" and "including" indicate the presence of the described features, integrals, steps, operations, elements and / or components, but do not exclude the presence or addition of one or more other features, integrals, steps, operations, elements, components and / or collections thereof.

[0060] It should also be understood that the terminology used in this specification is for the purpose of describing particular embodiments only and is not intended to limit the invention. As used in this specification and the appended claims, the singular forms “a,” “an,” and “the” are intended to include the plural forms unless the context clearly indicates otherwise.

[0061] It should also be further understood that the term "and / or" as used in this specification and the appended claims refers to any combination of one or more of the associated listed items and all possible combinations, and includes such combinations.

[0062] Please see Figure 1 and Figure 2 , Figure 1 This is a schematic diagram illustrating an application scenario of the visualization data integration method provided in this embodiment of the invention. Figure 2This is a schematic flowchart illustrating the visualized data integration method provided in this embodiment of the invention. This visualized data integration method is applied to a server. The server interacts with the terminal, achieving the goals of significantly improving development efficiency, ensuring data consistency, and enhancing system scalability through a series of carefully designed steps. First, entities, their attributes, and relationships are clearly defined based on business requirements, forming documented metadata, laying a solid foundation for subsequent design and development. Next, an interface prototype is designed based on user needs research and competitor analysis results. A drag-and-drop function is implemented using graphical components to build the data model, greatly simplifying the operation for non-professional developers. Furthermore, the data model is saved to a storage medium and version information is recorded, allowing for backtracking and comparison of historical versions, ensuring data consistency and system maintainability. In particular, the tree-structured version comparison algorithm identifies changes between different versions, supporting rollback operations and enhancing system scalability, enabling the application to adapt to complex business needs. The entire process lowers the technical threshold through standardized and visualized tools, allowing non-professional developers to efficiently participate in application development and maintenance.

[0063] Figure 2 This is a flowchart illustrating the visualization data integration method provided in an embodiment of the present invention. Figure 2 As shown, the method includes the following steps S110 to S140.

[0064] S110. Based on business needs, define entities, attributes, and relationships, and form documented metadata.

[0065] In this embodiment, documented metadata refers to the systematic recording and organization of entities, attributes and their relationships determined based on business requirements, along with constraints and validation rules, into formal documents, which serve as the basis and foundation for data model design.

[0066] In one embodiment, please refer to Figure 3 The above-mentioned step S110 may include steps S111 to S113.

[0067] S111. Generate a business requirements document based on the input business requirements and technical constraints.

[0068] In this embodiment, the business requirements document refers to the requirements collected and organized through in-depth communication with stakeholders (including but not limited to customers, users, business analysts, etc.) regarding the system's necessary functions, performance, security, and other aspects. This process involves not only identifying the system's ultimate goals but also understanding the technical environment and constraints in which the system operates, such as hardware requirements, software compatibility, and network architecture. This document details the business processes, expected outcomes, key performance indicators, and any technical constraints that may affect the system design. Its purpose is to provide a clear direction and benchmark for the project's planning, design, and implementation.

[0069] S112. Based on the business requirements document, determine the entities, attributes, and relationships.

[0070] In this embodiment, metadata refers to the specific data structure information derived from further analysis of the business requirements document. This includes the main entities in the system (e.g., merchants, products), the relevant attributes of each entity (e.g., merchant name, account, contact information, etc.), and the relationships between these entities (e.g., an order includes products). Metadata defines the basic framework of the data model; it not only contains information about entities and attributes but also clarifies the logical relationships between them. This step is crucial because it directly determines the application's data structure and interaction patterns, and is of great significance for ensuring data consistency and integrity.

[0071] S113. Apply preset constraints and verification rules to the attribute, and verify the validity of the attribute through an algorithm to obtain documented metadata.

[0072] After completing the initial metadata definition, this information needs to be reviewed and optimized. This step mainly includes:

[0073] Set constraints and validation rules: Define appropriate constraints (such as required, uniqueness, format, etc.) and validation rules for each attribute to ensure the validity and consistency of the data.

[0074] Comprehensive review: Organize a cross-departmental team (including business experts, technical experts, etc.) to conduct a detailed review of the metadata, aiming to identify potential problems or areas for improvement, and ensure that the metadata meets all known business needs and technical standards.

[0075] Documentation: The reviewed and optimized metadata is compiled into a formal document, which will become an important reference for subsequent design, development and testing phases.

[0076] The steps outlined above systematically define and manage the metadata of the data model, laying a solid foundation for building robust, flexible, and easily maintainable applications. This process also emphasizes starting with business needs while considering technological feasibility, ensuring that the final product not only meets users' actual needs but also adapts to future developments.

[0077] In this embodiment, when defining data model metadata, the system first determines the metadata such as data model entities, attributes, and relationships, which constitute the basic building blocks of the data model. The following are the principles followed in determining this metadata:

[0078] Business needs driven: The design of all metadata must be closely centered around actual business needs to ensure that every entity, attribute and relationship can accurately reflect the real business process and data flow.

[0079] Simplicity and clarity: We strive to simplify entities, attributes, and relationships, avoiding any unnecessary complexity and duplication. Each piece of metadata should have unique value, and its naming and description should be as intuitive and easy to understand as possible.

[0080] Scalability: Future expansion options are reserved during the design phase to account for potential changes in requirements. For example, optional fields are provided for entities and attributes to facilitate adding new requirements without altering the existing structure. Furthermore, potential business changes are considered when defining relationships, ensuring the model can flexibly adapt to the introduction of new relationships or entities.

[0081] Consistency: Use unified standards and conventions for naming metadata to prevent confusion. This includes using consistent naming rules (such as camelCase or underscores) and data types to ensure that similar attributes use the same data type, thereby improving data compatibility and comparability.

[0082] Verifiability: Set appropriate constraints for each attribute (such as data type, uniqueness, not null, etc.) to ensure the validity and consistency of the data.

[0083] Maintainability: The ease of subsequent maintenance is fully considered during the design of metadata. Version control is used to track historical changes and ensure that team members can access the history and different versions of metadata.

[0084] By following the above principles, we can ensure that the identified metadata is reasonable and can effectively support the long-term development of the system.

[0085] Specifically, first, the algorithm receives the attribute values ​​to be reviewed, along with their associated constraints and validation rules. In this step, the algorithm needs to be able to correctly parse the input data format and understand the specific requirements of each rule.

[0086] Next, the algorithm checks each attribute according to pre-defined validation rules. For example:

[0087] Required field check: If an attribute is marked as required, the algorithm will verify that the attribute exists and is not empty.

[0088] Format checking: Verifies whether attribute values ​​conform to specified format requirements using regular expressions or other methods.

[0089] Uniqueness check: Queries existing records in a database or storage medium to ensure that the attribute value is unique within this range.

[0090] Data type and range check: Use appropriate logic to determine whether the attribute value matches the expected data type and range.

[0091] Once any violation of the rules is detected, the algorithm should generate specific error messages or warnings. This information helps developers or users understand the problem and take appropriate corrective action. For example:

[0092] Provide a detailed error description: "Attribute X cannot be empty" and "Attribute Y must be a valid email address".

[0093] Suggest possible solutions or correction guidelines.

[0094] To further ensure the validity and consistency of metadata, an automated testing framework can be introduced. This framework can automatically run a set of predefined test cases to check whether the behavior of attributes matches expectations under different scenarios. This is particularly useful for complex data models, as it can help identify potential problems that may not be easily discovered through manual inspection.

[0095] Finally, all verified and confirmed attributes and their associated rules are compiled into a formal document. This document not only includes the final metadata definitions but also records any change history, discussion points, and rationale for decisions made throughout the review process. This allows team members easy access to this crucial information during subsequent design, development, and maintenance phases.

[0096] S120. Based on the documented metadata, and according to the results of user needs survey and competitor analysis, generate an interface prototype.

[0097] In this embodiment, the interface prototype refers to a preliminary user interface model designed through a series of steps, combining collected user requirements with the results of competitive product analysis, and based on documented metadata. This model not only reflects the core functions and characteristics of the system but also considers requirements such as user experience, usability, and aesthetics.

[0098] In one embodiment, please refer to Figure 4 The above-mentioned step S120 may include steps S121 to S127.

[0099] S121. Collect and analyze the results of user needs surveys and competitor analysis to obtain analysis results.

[0100] In this embodiment, the analysis results refer to the needs and preferences of the target user group, their usage habits, and the advantages and disadvantages of similar products on the existing market. Through in-depth analysis of this information, the basic functions the product should possess, its unique selling points, and the problems that need to be avoided can be clearly identified.

[0101] Specifically, collect user needs surveys and competitor analysis results, remove duplicate or irrelevant data to ensure the effectiveness of subsequent analysis. Transform qualitative data into quantifiable forms (e.g., label different opinions) to facilitate further analysis. Use charts and other formats to display data distribution, making it easier to quickly identify trends and patterns.

[0102] Based on the collected information, user needs are categorized according to importance and urgency, such as basic needs, expected needs, and exciting needs. Based on factors such as user feedback frequency and satisfaction ratings, the most pressing needs are identified. Multi-dimensional user data is integrated to create profiles of typical users, helping the team better understand the target audience.

[0103] Assess the market position of competitors through SWOT analysis (Strengths, Weaknesses, Opportunities, Threats). List the core features of each competitor and compare them with your own product plan to identify differences. From a user perspective, evaluate the strengths and weaknesses of competitors in terms of usability, interface design, etc.

[0104] Match user needs with the current state of competitors to identify unmet needs in the market. Based on this analysis, define the product's core value proposition—how it uniquely meets user needs and differentiates itself from competitors. Integrate the identified opportunities and challenges to develop specific product development strategies and marketing plans.

[0105] The system summarizes the entire analysis process and key findings, including an overview of user needs, a summary of competitor performance, and product positioning recommendations. The analysis results are presented to project team members to ensure everyone clearly understands the project's background, objectives, and direction. As the market environment changes and technology advances, the analysis results are updated regularly, and product strategies are flexibly adjusted accordingly.

[0106] S122. Using the documented metadata and the analysis results, design specifications are generated, the entities and their relationships are parsed, and parsed information is formed.

[0107] In this embodiment, the design specifications include design guidelines and objectives.

[0108] Based on the analysis results from the previous step, and combined with existing documented metadata (such as entities, attributes, and their relationships), specific design guidelines and goals are formulated. This includes, but is not limited to, interface style, interaction patterns, and usability standards, ensuring that the final design meets both business needs and provides a good user experience.

[0109] Determine the type of relationship between the entities, such as one-to-one, one-to-many, or many-to-many. This step relies on information about the data structure provided in the metadata.

[0110] Based on an understanding of entities and their relationships, one or more abstraction layers are constructed to simplify complex system structures and make them easier for team members without a technical background to understand.

[0111] The above analysis results will be translated into specific design guidelines to guide subsequent UI / UX design work. This includes, but is not limited to, page layout suggestions, interaction flowcharts, and user experience guidelines.

[0112] These can be accomplished using existing automated data analysis tools or machine learning algorithms.

[0113] S123. Generate user stories and use cases based on the parsing results and user requirements.

[0114] In this embodiment, the parsing results refer to the identification of key data entities, attributes, and relationships within the system by studying documented metadata. For example, it determines which entities are critical components of core business processes, which attributes are essential for describing these entities, and how to define the relationships between these entities. The parsing results provide a solid foundation for subsequent design.

[0115] S124. Generate an initial interface layout prototype based on the documented metadata.

[0116] By combining the analysis results with user needs, specific user stories and use cases are created. This helps the team better understand user behavior patterns and expectations in actual operation, thereby guiding the direction of interface design and ensuring that the design solution meets the actual needs of users.

[0117] S125. Based on the initial interface layout prototype, adjust and optimize through a feedback mechanism, and add visual design elements to obtain the interface prototype.

[0118] Using the information obtained in the previous steps, begin building a prototype of the interface layout. This stage focuses primarily on the layout structure and arrangement of basic elements, without delving into detailed visual design. The goal is to validate the effectiveness and feasibility of the concept, while also providing a foundation for subsequent design iterations.

[0119] Show the initial completed interface layout prototype to potential users or stakeholders, and collect their feedback on data representation methods, operation processes, etc. Based on the feedback and suggestions received, make necessary adjustments and optimizations to the prototype to make it more closely match the actual needs of users.

[0120] Finally, based on the validated and adjusted interface layout prototype, visual design elements (such as color schemes, icons, and fonts) were added to form a complete interface prototype. This version of the prototype not only demonstrated the system's functional structure but also reflected its visual style and interactive experience, providing an intuitive reference for the final product development.

[0121] In this embodiment, designing a visual interface that supports users in intuitively creating, editing, and deleting data models requires comprehensive consideration of users' actual needs, the competitive landscape in the market, and best practices for user experience.

[0122] Conduct face-to-face or online interviews with potential users (such as developers, data analysts, etc.) to understand the specific difficulties and needs they encounter in their existing data modeling process.

[0123] Based on the collected feedback, develop specific user stories and use cases, and clarify the core functions and operational processes that the interface needs to support. For example, users may want to quickly add entities and attributes, or adjust existing relationships.

[0124] Analyze existing visual data modeling tools on the market to identify their strengths and weaknesses in terms of user interface friendliness, functional completeness, and ease of use.

[0125] Extract design elements and interaction patterns from successful cases, avoid repeating known problems, and innovate by combining them with the characteristics of your own product.

[0126] Ensure that the interface design simplifies the user's workflow as much as possible, reducing unnecessary steps and complexity, so that users can focus on the design of the data model rather than the interface operation itself.

[0127] The layout and interaction methods of the various functional modules on the interface are arranged in a reasonable way, so that new users can get started quickly and experienced users can work efficiently.

[0128] Use professional tools like Axure to quickly build low-fidelity prototypes of the interface structure and interaction flow. Low-fidelity prototypes do not require sophisticated visual design, but they must accurately reflect the expected user experience and interaction logic.

[0129] By showcasing a low-fidelity prototype to the target user group, we can gather their firsthand feedback and use it as a basis for iterative optimization of the prototype.

[0130] By combining the results of user needs research, findings from competitor analysis, and the design principles followed, a comprehensive design guide is formed.

[0131] Based on ongoing user feedback and suggestions from the technical team, we continuously optimize the interface design to ensure that the final version meets user needs and provides a good user experience.

[0132] This method allows for the design of a powerful yet easy-to-understand and user-friendly visual data model interface. This will significantly improve user satisfaction and work efficiency, while also laying a solid foundation for product success.

[0133] S130. Generate graphical components for operating the interface prototype and implement drag-and-drop functionality to obtain a data model.

[0134] In this embodiment, the data model refers to the data structure designed through a visual interface, including entities (such as merchants and products), attributes (such as names and accounts), and the relationships between them (such as merchants placing orders). This process not only requires an intuitive user interface to create these elements, but also needs to support detailed configuration and constraint settings to ensure data consistency and integrity.

[0135] In one embodiment, please refer to Figure 5 The above-mentioned step S130 may include steps S131 to S133.

[0136] S131. Generate a canvas and toolbar for operating the interface prototype, and a standard icon library that is visually easy to distinguish and contains all necessary attributes, to obtain a graphical component.

[0137] In this embodiment, a graphical component refers to each interactive graphical unit in a standard icon library that is visually easy to distinguish and contains basic attributes such as name, type, and constraints.

[0138] In one embodiment, please refer to Figure 6 The above step S131 may include steps S1311 to S1314.

[0139] S1311. Generate a canvas area, wherein entities, attributes and relationship icons can be dragged and dropped within the canvas area, and the canvas area has scaling and panning functions.

[0140] In this embodiment, a canvas area is created as the main workspace, allowing users to drag and drop entity, attribute, and relationship icons. This area should support zooming and panning functions so that users can easily manage and view complex data models.

[0141] S1312. Set up a toolbar in the interface, wherein the toolbar provides a variety of graphic elements for the user to select.

[0142] In this embodiment, a toolbar is added to the interface, providing users with a variety of graphical elements to choose from. The toolbar should be easy to use and contain all necessary graphical elements (such as entities, attributes, relationships, etc.) for quick user access.

[0143] S1313. Generate a standard icon library, wherein the standard icon library contains all the necessary graphic elements.

[0144] In this embodiment, a standard icon library is developed, containing all the necessary graphic elements. Each icon should be visually distinctive and able to represent a specific data modeling element.

[0145] S1314. Define a set of basic attributes for each graphic element in the standard icon library, and allow users to modify them through an interactive interface to obtain a graphic component; wherein, the basic attributes include name, type, and constraints.

[0146] Define a set of basic attributes for each graphic element in the standard icon library, such as name, type, and constraints. Provide an interactive interface that allows users to modify these attributes, thereby customizing their data model.

[0147] S132. Based on the aforementioned graphical component, the front-end framework and its plugins are used to generate drag-and-drop operations and mouse event listeners. Detailed information and connection methods of entities, attributes, and relationships are processed through a sidebar or pop-up window to obtain elements.

[0148] In this embodiment, an element refers to an entity, attribute, and relationship created through drag-and-drop operations, and a modeling component that allows for detailed editing and constraint configuration on the interface.

[0149] Utilize front-end frameworks (such as Vue.js) and their related plugins to build drag-and-drop functionality. Listen for user mouse events (such as dragging and placing) to enable real-time manipulation of graphical elements.

[0150] When a user selects an entity or attribute, a sidebar or pop-up window appears, allowing the user to enter or modify detailed information about the element (such as name, data type, constraints, etc.). Connectors are also provided to allow users to establish relationships between entities and set relationship types (such as one-to-one, one-to-many) and related constraints.

[0151] S133. Generate constraint configuration options for each element to obtain a data model.

[0152] Each element provides constraint configuration options, such as uniqueness, NOT NULL, and foreign key constraints. Users can select the desired constraints via drop-down menus or checkboxes, and the system will apply these constraints to the corresponding elements in real time.

[0153] To improve user experience, the interface should be as simple and intuitive as possible to reduce the learning curve. For complex operations, provide guided tutorials or helpful tips.

[0154] The system should provide real-time feedback on any user actions and automatically update the view so that users can see changes in the data model instantly.

[0155] To facilitate subsequent maintenance and expansion, it is recommended to integrate a version control system to record the history of each change and support backtracking and comparing data models of different versions.

[0156] By following the steps above, a powerful and easy-to-use visual data model design tool can be created. It can not only help users quickly build and adjust data models, but also ensure data consistency and integrity, meeting the needs of modern application development.

[0157] In this embodiment, challenges and specific needs encountered during the data modeling process were gathered through in-depth communication with potential users (such as developers and data analysts). Based on this feedback, detailed user stories and use cases were developed to clarify the core functionalities and operations that the interface should support.

[0158] We conducted a detailed analysis of existing visual data modeling tools on the market, evaluating their strengths and weaknesses, with a particular focus on user-friendliness, functionality, and ease of use. This helped us draw inspiration from our designs and avoid common design pitfalls.

[0159] Following a simple and intuitive design philosophy, we ensure that all users can easily understand and use our interface, enabling them to complete tasks efficiently without complicated training or guidance.

[0160] Develop low-fidelity prototypes using tools such as Axure to quickly build the basic structure and interaction flow of the interface, and verify its effectiveness through preliminary testing.

[0161] Create a visual editing canvas that allows users to freely drag and drop entity, attribute, and relationship icons. Simultaneously, design a toolbar on the interface offering a variety of icons to choose from, including entity, attribute, and relationship icons. Users can drag and drop these icons from the toolbar onto the canvas for convenient and intuitive data model building.

[0162] Develop a standard icon library that covers icons for entities, attributes, and relationships, ensuring they are visually easily distinguishable. Furthermore, define basic attributes for each graphical element (entity, attribute, relationship), such as name, type, and constraints, to facilitate subsequent interaction and configuration.

[0163] This implementation uses the Vue front-end framework to enable drag-and-drop functionality, listening for mouse events to support dragging, placing, and resizing graphics. This step ensures that users can intuitively manipulate various elements within the data model.

[0164] When a user selects an entity or attribute, a sidebar or pop-up window appears, allowing the user to enter or modify detailed information about the element (such as name, data type, and constraints). Users can also connect two entities using connectors to establish relationships, and define the type of relationship (one-to-one, one-to-many, etc.) and related constraints (such as cascading delete) in the connector settings.

[0165] It provides constraint setting options for each attribute and relationship, such as uniqueness, NOT NULL, and foreign key constraints. Users can select the desired constraints through drop-down menus or checkboxes, thereby enhancing the integrity and accuracy of the data model.

[0166] When users interact with entities, attributes, and relationships, the system should update the view in real time, allowing users to instantly see the changes in the model. This real-time feedback mechanism helps improve the user experience and efficiency.

[0167] Once the user completes the design of the data model, the system provides a save function to store the model's metadata (including entities, attributes, relationships and their configurations) in the database for easy use and management later.

[0168] To enable real-time viewing and modification of data model changes, the specific steps are as follows:

[0169] Leveraging Vue's two-way data binding feature, we ensure real-time data synchronization between input fields and graphical elements on the interface. Whenever a user enters or modifies an attribute, the relevant graphical elements (such as entity or attribute icons) automatically update. Simultaneously, we set event listeners for the input fields of entities and attributes; when the user modifies a value, the corresponding update function is triggered, applying the changes to the data model and the visualization interface.

[0170] Using graphics libraries (such as SVG), the relevant graphic elements are dynamically re-rendered when the user modifies attributes. This can be achieved by directly modifying the DOM or using a virtual DOM to add, delete, and modify elements. Additionally, an automatic layout algorithm is implemented to ensure that other elements automatically adjust their positions when entities are added or removed, maintaining the readability and neatness of the model.

[0171] When a user inputs or modifies attributes, predefined validation rules (such as data type validation, uniqueness checks, etc.) should be applied immediately. If the user's input does not conform to the rules, the system should provide immediate feedback (such as "This field cannot be empty" or "Value already exists") and suggest modifications to ensure the rationality and correctness of the data model.

[0172] In the entity and attribute settings interface, users can set constraints (such as uniqueness, non-null, etc.). Once set, the system should display the impact of these constraints on the data model in real time, helping users better understand and manage the data model.

[0173] Using a state management library (such as Vuex) to centrally manage the state of the data model ensures that any modifications are reflected on the interface in a timely manner and can handle complex state changes, further improving the user experience and the reliability of the data model.

[0174] Through the above steps, the method of this embodiment not only realizes the visual creation, editing and management of data models, but also provides powerful real-time preview and editing functions, ensuring the rationality and correctness of data models, and greatly improving development efficiency and user experience.

[0175] S140. Save the data model to the selected storage medium and record version information so that the terminal can trace back and compare historical version information.

[0176] In one embodiment, please refer to Figure 7 The above-mentioned step S140 may include steps S141 to S144.

[0177] S141. Define the version data structure.

[0178] In this embodiment, a version data structure needs to be defined first to record information for each version. This structure typically contains the following elements:

[0179] Version number: A unique identifier for each version.

[0180] Creation Time: Records the timestamp of version creation.

[0181] Modifier: Records the user information that made the changes.

[0182] Metadata snapshot: Saves a snapshot of the data model metadata (such as entities, attributes, and relationships) at that time.

[0183] Description information: Users can enter a version description to explain the changes in this version.

[0184] This step ensures that each version has detailed and clear documentation, facilitating subsequent version control and management.

[0185] S142. Set up database tables to store detailed information for each version.

[0186] To persistently store this version information, a dedicated table needs to be created in the database to store this data. This step involves designing and implementing the database schema, including but not limited to fields such as entities, attributes, relationships, and version information. For example, a MySQL database can be used to store this information, with corresponding tables created to track all versions of the data model.

[0187] S143. Save the data model to the selected storage medium via API, and perform save, read, update and delete operations.

[0188] Interact with backend services via API interfaces to perform operations on the data model. These operations include, but are not limited to, saving new data models, reading existing models from storage media, updating existing models, and deleting models that are no longer needed. This ensures that all changes are accurately recorded and tracked, while supporting flexible data management.

[0189] S144. When the data model is saving changes, the changes in the data model are detected, and the version data structure and database tables are updated when there are changes. The content corresponding to the historical version information is restored through the rollback function.

[0190] Specifically, when the data model saves changes, it detects changes in the data model. When changes occur, a version comparison algorithm based on a tree structure identifies and displays the addition, deletion, and modification of entities, attributes, and relationships between different versions to update the version data structure and database tables. The rollback function restores the content corresponding to the historical version information.

[0191] Whenever a user saves a data model, the system automatically checks for any changes. If any are found, it identifies and records the specific changes (additions, deletions, and modifications) to entities, attributes, and relationships between different versions using a tree-structured version comparison algorithm. Based on this information, it updates the version data structure and related entries in the database tables. Furthermore, the system provides a rollback function, allowing users to select a specific historical version and restore the current data model to that state, thus achieving flexible version management and control.

[0192] Through the steps described above, the method in this embodiment not only achieves effective data model preservation and version management, but also provides users with powerful tools to view and compare differences between different versions, greatly enhancing the system's flexibility and usability. This mechanism is crucial for ensuring data consistency and integrity, especially when developing complex enterprise-level applications.

[0193] In this embodiment, to persistently save the metadata of the interface design data model and support the persistence of the data model using databases, files, or other storage methods, and to automatically generate corresponding database scripts or code based on the user-designed data model for creating database table structures and defining entity classes, the specific steps are as follows:

[0194] Define the basic structure of the data model, including metadata formats for entities, attributes, and relationships. The solution uses JSON format to describe the structure and attributes of the data model, ensuring that each attribute contains necessary metadata such as name, data type, constraints (e.g., uniqueness, non-null), and default value.

[0195] Persistence: MySQL database is chosen as the method for storing data model metadata, and dedicated tables are created to store entity, attribute, and relationship information for each data model.

[0196] Implementation of persistent operations: Design a persistent interface to provide methods for saving, reading, updating, and deleting metadata. Persistent operations are handled through an API interface; user modifications can be sent to the backend via API requests, and the backend writes the data to the database or a file. After the user completes the data model design, provide asynchronous saving functionality to avoid blocking the user interface while ensuring that user modifications are saved promptly.

[0197] Automatic data model generation: Based on stored metadata, entities, their attributes, and relationship information are parsed out, and corresponding database creation scripts are generated. Simultaneously, corresponding entity class Java code is automatically generated based on the metadata. This step allows users to easily convert the data model into the actual database table structure and code implementation.

[0198] To support users in version control and tracking of data models, allowing them to backtrack and compare historical versions, a version data structure is defined: recording information for each version, including:

[0199] Version number: A unique identifier for the version.

[0200] Creation time: The version's creation timestamp.

[0201] Modifier: Records the user who made the modification.

[0202] Metadata snapshot: Saves a snapshot of the data model metadata (such as entities, attributes, and relationships) at that time.

[0203] Description information: Users can enter a version description to explain the changes in this version.

[0204] Whenever a user saves a data model, a snapshot of the current model's metadata is stored in the version table and recorded as the new version.

[0205] When a user performs a save operation, the system checks for changes. If changes are found, a new version record is created, and the current metadata is saved as the new version. Additionally, a "rollback" function is provided, allowing users to select a historical version, and the system restores the metadata of that version to the current data model.

[0206] Implement a tree-structured comparison algorithm to identify changes between different versions, such as the addition, modification, and deletion of entities, attributes, and relationships.

[0207] Design a version management panel on the user interface to display a list of all historical versions, including version number, creation time, modifier, and description. Users can click on versions to view and compare them, facilitating understanding of the data model's evolution and making corresponding adjustments.

[0208] Through the above steps, a complete data model version management system has been built. It not only realizes the functions of persistently saving data models and automatically generating database scripts or code, but also enhances users' ability to version control and track data models, supports the retrospection and comparison of historical versions, and improves user experience and data management efficiency.

[0209] To ensure data consistency and integrity, this embodiment provides flexible and powerful data validation and constraint functions. Developers can set validation rules, data types, uniqueness constraints, relationships, etc. in the visual data model to prevent invalid or conflicting data from being entered into the database.

[0210] When designing the metadata structure of a data model, clearly record the type, constraints (such as uniqueness, non-nullability, format, etc.) and relationships (such as foreign keys, primary keys, etc.) of each attribute. For example, the metadata structure can include fields such as isRequired and isUnique to ensure that validation criteria are set when defining the model.

[0211] The visual data model design interface provides a settings panel for each attribute, allowing developers to set validation rules and constraints through a graphical interface. Developers can select data types (such as string, integer, date) via drop-down menus and check options such as "required" and "unique," and the system will automatically generate the corresponding validation logic.

[0212] When a user enters an attribute value, the system applies validation rules in real time. For example, when a user enters an attribute, it immediately checks whether the attribute conforms to the set type, format, and uniqueness constraints.

[0213] When data is submitted to the server, the backend executes validation logic again to ensure that all data validation rules are followed. This is to prevent users from submitting invalid data by bypassing frontend validation. A unified validation framework is implemented on the backend, using middleware to handle the validation of request data, ensuring consistency and maintainability.

[0214] In database design, data validation and constraint logic is transformed into database-level constraints (such as unique indexes and foreign key constraints) to ensure that invalid data is prevented from entering the database during data persistence.

[0215] In the version management function, it is ensured that each historical version follows the same verification rules. When users roll back to a historical version, it is ensured that the model being rolled back also meets the current verification standards.

[0216] Through the above steps, flexible and powerful data validation and constraint functions are achieved, effectively ensuring data consistency and integrity, preventing invalid or conflicting data from being entered into the database, thereby improving the overall reliability of the system.

[0217] It supports tool-based definition and management of application data, enabling developers to create entities, attributes, and relationships using a graphical interface, and set data validation rules and associations. Through a visual data model, users can easily design and modify application data structures via drag-and-drop, connectors, and attribute settings, without manually manipulating data tables. Furthermore, it provides visual modeling tools and database integration capabilities, offering powerful application development capabilities and supporting the rapid building and deployment of enterprise-grade applications.

[0218] The system's customization capabilities have been improved, enabling developers to define and implement complex business logic more flexibly. This can be achieved by adding custom functions, conditional statements, and triggers. More customization options are also provided to meet specific project and business needs, making the service orchestration system more adaptable to different development scenarios. Regarding system scalability and performance, a reasonable data architecture and indexing strategy, as well as technologies such as caching and distributed computing, have been adopted to ensure good performance even when handling large amounts of data and high concurrency access.

[0219] During the design phase, reserve enough interfaces and components for developers to call so that they can implement custom functions according to their own needs.

[0220] During the design phase, the system's scalability and performance requirements were fully considered, the database structure and indexing strategies were rationally planned, and advanced technologies were adopted to improve the system's performance under high load scenarios.

[0221] These measures not only enhance the system's flexibility and customization capabilities but also significantly improve its scalability and performance, enabling it to better adapt to complex and ever-changing application environments.

[0222] The method in this embodiment has been extended to key aspects such as visual data modeling, data validation, data integration, and data synchronization. It supports developers in using a graphical interface to create entities, attributes, and relationships, and to set data validation rules and associations. Users can more easily design and modify the application's data structure without manually writing data tables, greatly simplifying the operation process.

[0223] Furthermore, the method in this embodiment supports seamless integration with other data systems, enabling data storage and retrieval within applications and easy interaction with existing systems and services to achieve data persistence and sharing. This not only provides a better user experience, more powerful features, and easier-to-use and more efficient solution, but also ensures security and reliability, offering users a comprehensive service orchestration visualization data model and integration platform.

[0224] In summary, the method of this embodiment, through a series of innovative measures, not only accelerates the development process and reduces technical difficulty, but also enhances the flexibility and scalability of the system, meets diverse business needs, and promotes the effectiveness of team collaboration.

[0225] This solution significantly improves development efficiency and lowers the technical barrier through visual data models and database integration. Development efficiency can be improved by up to 80%. Developers can create and edit data models graphically without writing tedious code. This visual modeling approach significantly shortens the development cycle, improves development efficiency, and enables projects to be brought to market faster. Non-specialist developers can also participate in the application development process. Visual data models and database integration provide an intuitive and easy-to-understand way of development, reducing reliance on programming skills. This allows more people to participate in the development work and broadens the possibilities for team composition. Through visual data models, business personnel and domain experts can better understand data structures and relationships and express business needs more intuitively. This approach helps developers understand business requirements more accurately, reducing discrepancies in communication and understanding, thereby improving the success rate of projects. The system allows developers to highly customize it according to specific business needs. Developers can customize attributes, validation rules, relationship types, etc., to adapt to different business scenarios. In addition, visual data models and database integration make system maintenance and expansion easier. When business needs change, the model can be quickly modified and expanded through an intuitive interface.

[0226] For example, in the financial industry, banks or financial institutions may need to develop a system to manage customer information, account details, and transaction records. Using the aforementioned visual data integration method, the following operations can be performed:

[0227] First, identify core entities such as "customer," "account," and "transaction" based on business needs, and define corresponding attributes for each entity (e.g., "customer's" name and contact information; "account's" balance and opening date; "transaction's" amount and transaction time). Simultaneously, identify the relationships between these entities (e.g., a customer can have multiple accounts, and an account can have multiple transactions).

[0228] Based on the collected user needs survey and competitor analysis results, an easy-to-use interface prototype was designed. For example, an intuitive customer management system was created that allows users to quickly add new customers, view account details, or perform transaction queries.

[0229] Develop graphical components that allow developers to build data models via drag-and-drop. For example, place icons representing "customers," "accounts," and "transactions" on a canvas and connect them with lines to represent relationships. Additionally, provide a toolbar for selecting different graphical elements and allow users to customize the specific properties of each element.

[0230] Save the final data model to the selected storage medium and record all historical versions of changes. This way, when you need to review any previous changes, you can easily go back to a specific historical version.

[0231] For another example, in the healthcare field, a hospital might want to establish an electronic medical record system to track patient information, diagnostic results, and treatment plans. Using the same visual data integration method, the specific steps are as follows:

[0232] Key entities to identify include "Patient," "Doctor," "Diagnosis," and "Treatment Plan." Assign necessary attributes to each entity (e.g., personal information and allergy history for "Patient"; area of ​​expertise for "Doctor"; symptom description for "Diagnosis"; medication prescriptions for "Treatment Plan"). Simultaneously, clarify the relationships between entities (e.g., a doctor can diagnose multiple patients, and a series of diagnoses and treatment plans will be developed for each patient).

[0233] Based on in-depth user needs analysis and market research, design a user interface prototype that is easy for healthcare professionals to use. This may involve creating an intuitive patient record management system that allows users to quickly access a patient's complete medical history, including all diagnoses and treatments.

[0234] Build a draggable data model using graphical components, which includes icons representing different entities (such as "patient," "doctor," etc.) and connecting lines to show the relationships between them. Provide rich toolbar options to allow users to customize the details of each entity, ensuring the system's flexibility and adaptability.

[0235] The generated data model is stored in a database, and a detailed version control system is enabled to allow for easy restoration to any previous state. This is especially important when handling sensitive medical data, as it ensures data security and integrity, while also facilitating future review or verification.

[0236] The aforementioned visual data integration method forms documented metadata by clearly defining entities, their attributes, and relationships based on business needs. Subsequently, it designs an interface prototype based on user needs research and competitive analysis results, develops drag-and-drop graphical components to create a data model, and finally saves the model to storage media and records version information for backtracking and comparing historical versions. This series of steps significantly improves development efficiency. This method ensures data consistency and system scalability, allowing non-professional developers to efficiently participate in application development and maintenance without in-depth programming language knowledge. It greatly lowers the technical barrier, enabling more people to participate in projects, while also flexibly adapting to complex changes in business needs, thereby achieving rapid iteration and market responsiveness. This low-code / no-code development approach not only accelerates time-to-market but also improves team collaboration efficiency and promotes innovation.

[0237] Figure 8 This is a schematic block diagram of a visual data integration device 300 provided in an embodiment of the present invention. Figure 8 As shown, corresponding to the above-described visualization data integration method, the present invention also provides a visualization data integration apparatus 300. This visualization data integration apparatus 300 includes a unit for executing the above-described visualization data integration method, and the apparatus can be configured in a server. Specifically, please refer to... Figure 8 The visualization data integration device 300 includes a document metadata forming unit 301, an interface prototype design unit 302, a data model determination unit 303, and a record saving unit 304.

[0238] The document metadata forming unit 301 is used to define entities, attributes, and relationships based on business requirements and form documented metadata; the interface prototype design unit 302 is used to generate an interface prototype based on the documented metadata and the results of user needs research and competitor analysis; the data model determination unit 303 is used to generate graphical components for operating the interface prototype and implement drag-and-drop functionality to obtain a data model; and the record saving unit 304 is used to save the data model to a selected storage medium and record version information for the terminal to trace back and compare historical version information.

[0239] In one embodiment, the document metadata forming unit 301 includes:

[0240] The first determining subunit is used to generate a business requirement document based on the input business requirements and technical constraints; the second determining subunit is used to determine entities, attributes, and relationships based on the business requirement document; and the auditing subunit is used to apply preset constraints and verification rules to the attributes and audit the validity of the attributes through an algorithm to obtain documented metadata.

[0241] In one embodiment, the interface prototyping unit 302 includes:

[0242] The system comprises the following sub-units: Analysis Sub-unit, which collects and analyzes user needs and competitor analysis results to obtain analysis results; First Formulation Sub-unit, which uses the documented metadata and analysis results to generate design specifications, parses the entities and their relationships, and forms parsed information; Identification Sub-unit, which generates user stories and use cases based on the parsed results and user needs; Creation Sub-unit, which generates an initial interface layout prototype based on the documented metadata; Building Sub-unit, which adjusts and optimizes the initial interface layout prototype through a feedback mechanism, adds visual design elements, and obtains an interface prototype; Display Sub-unit, which displays the interface layout prototype, collects feedback on data representation methods and operation processes, and adjusts the interface layout prototype; and Adjustment Sub-unit, which adds visual design elements to the adjusted interface layout prototype to obtain an interface prototype.

[0243] In one embodiment, the data model determination unit 303 includes:

[0244] The graphical component creation subunit is used to generate a canvas and toolbar for operating the interface prototype, as well as a standard icon library that is visually easy to distinguish and contains all necessary attributes, to obtain graphical components; the element determination subunit is used to generate drag-and-drop operations and mouse event listeners based on the graphical components using the front-end framework and its plugins, and to process detailed information and connection methods of entities, attributes and relationships through a sidebar or pop-up window to obtain elements; the constraint subunit is used to generate constraint configuration options for each element to obtain a data model.

[0245] In one embodiment, the graphics component creation subunit includes:

[0246] The first creation module generates a canvas area where entities, attributes, and relationship icons can be dragged and dropped, and the canvas has scaling and panning functions. The second module adds a toolbar to the interface, providing various graphic elements for the user to choose from. The third module generates a standard icon library containing all necessary graphic elements. The fourth module defines a set of basic attributes for each graphic element in the standard icon library, allowing the user to modify these attributes through an interactive interface to obtain the graphic component. These basic attributes include name, type, and constraints.

[0247] In one embodiment, the record storage unit 304 includes:

[0248] The structure definition subunit is used to define the version data structure; the table creation subunit is used to set up database tables to store detailed information for each version; the save subunit is used to save the data model to the selected storage medium via API and perform save, read, update and delete operations; the update subunit is used to detect changes in the data model when saving changes, and update the version data structure and database tables when changes occur, and restore the content corresponding to the historical version information through the rollback function.

[0249] In one embodiment, the update subunit is used to detect changes in the data model when the data model saves changes, and when there are changes, to identify and display the addition, deletion and modification of entities, attributes and relationships between different versions based on a version comparison algorithm with a tree structure, so as to update the version data structure and database table, and restore the content corresponding to the historical version information through the rollback function.

[0250] It should be noted that those skilled in the art can clearly understand that the specific implementation process of the above-mentioned visualization data integration device 300 and each unit can be referred to the corresponding description in the foregoing method embodiments. For the sake of convenience and brevity, it will not be repeated here.

[0251] The aforementioned visualization data integration device 300 can be implemented as a computer program, which can, for example... Figure 9 It runs on the computer device shown.

[0252] Please see Figure 9 , Figure 9 This is a schematic block diagram of a computer device provided in an embodiment of this application. The computer device 500 can be a server, wherein the server can be a standalone server or a server cluster composed of multiple servers.

[0253] See Figure 9 The computer device 500 includes a processor 502, a memory, and a network interface 505 connected via a system bus 501. The memory may include a non-volatile storage medium 503 and internal memory 504.

[0254] The non-volatile storage medium 503 may store an operating system 5031 and a computer program 5032. The computer program 5032 includes program instructions that, when executed, cause the processor 502 to perform a visualization data integration method.

[0255] The processor 502 provides computing and control capabilities to support the operation of the entire computer device 500.

[0256] The internal memory 504 provides an environment for the execution of the computer program 5032 in the non-volatile storage medium 503. When the computer program 5032 is executed by the processor 502, the processor 502 can execute a visualization data integration method.

[0257] This network interface 505 is used for network communication with other devices. Those skilled in the art will understand that... Figure 9 The structure shown is merely a block diagram of a portion of the structure related to the present application and does not constitute a limitation on the computer device 500 to which the present application is applied. The specific computer device 500 may include more or fewer components than those shown in the figure, or combine certain components, or have different component arrangements.

[0258] The processor 502 is used to run a computer program 5032 stored in a memory to implement all the steps of the visualization data integration method.

[0259] It should be understood that in the embodiments of this application, the processor 502 may be a central processing unit (CPU), or it may be other general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, etc. The general-purpose processor may be a microprocessor or any conventional processor.

[0260] It will be understood by those skilled in the art that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program includes program instructions and can be stored in a storage medium, which is a computer-readable storage medium. The program instructions are executed by at least one processor in the computer system to implement the process steps of the embodiments of the above methods.

[0261] Therefore, the present invention also provides a storage medium. This storage medium can be a computer-readable storage medium. The storage medium stores a computer program, wherein when executed by a processor, the computer program causes the processor to perform all the steps of the visualization data integration method.

[0262] The storage medium can be any computer-readable storage medium capable of storing program code, such as a USB flash drive, portable hard drive, read-only memory (ROM), magnetic disk, or optical disk.

[0263] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of the various examples have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of this invention.

[0264] In the several embodiments provided by this invention, it should be understood that the disclosed apparatus and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative. For example, the division of each unit is merely a logical functional division, and there may be other division methods in actual implementation. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed.

[0265] The steps in the method of this invention can be adjusted, merged, or reduced in order according to actual needs. The units in the device of this invention can be merged, divided, or reduced according to actual needs. Furthermore, the functional units in the various embodiments of this invention can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0266] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a storage medium. Based on this understanding, the technical solution of the present invention, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, a terminal, or a network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of the present invention.

[0267] The above description is merely a specific embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any person skilled in the art can easily conceive of various equivalent modifications or substitutions within the technical scope disclosed in the present invention, and these modifications or substitutions should all be covered within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.

Claims

1. A visual data integration method, characterized in that, include: Based on business needs, entities, attributes, and relationships are clearly defined, and documented metadata is generated. Based on the documented metadata, and according to the results of user needs surveys and competitor analysis, an interface prototype is generated. Generate graphical components for manipulating the interface prototype and implement drag-and-drop functionality to obtain the data model; The data model is saved to the selected storage medium, and version information is recorded so that the terminal can trace back and compare historical version information.

2. The visualization data integration method according to claim 1, characterized in that, The process of defining entities, attributes, and relationships based on business needs and forming documented metadata includes: Generate a business requirements document based on the input business needs and technical constraints; Based on the aforementioned business requirements document, identify entities, attributes, and relationships; Preset constraints and validation rules are applied to the attributes, and the validity of the attributes is reviewed by an algorithm to obtain documented metadata.

3. The visualization data integration method according to claim 1, characterized in that, Based on the documented metadata, and according to the results of user needs research and competitor analysis, an interface prototype is generated, including: Collect and analyze user needs and competitor analysis results to obtain the analysis results; The documented metadata is used in conjunction with the analysis results to generate design specifications, and the entities and relationships are parsed to form parsed information; Generate user stories and use cases based on the analysis results and user needs; An initial interface layout prototype is generated based on the documented metadata. Based on the initial interface layout prototype, adjustments and optimizations were made through a feedback mechanism, and visual design elements were added to obtain the interface prototype.

4. The visualization data integration method according to claim 1, characterized in that, The process of generating graphical components for manipulating the interface prototype and implementing drag-and-drop functionality to obtain a data model includes: Generate a canvas and toolbar for operating the interface prototype, a standard icon library that is visually easy to distinguish and contains all the necessary attributes, to obtain graphical components; Based on the aforementioned graphical components, the front-end framework and its plugins are used to generate drag-and-drop operations and mouse event listeners. Detailed information and connection methods of entities, attributes, and relationships are processed through a sidebar or pop-up window to obtain elements. Generate constraint configuration options for each element to obtain the data model.

5. The visualization data integration method according to claim 4, characterized in that, The generation of a canvas and toolbar for manipulating the interface prototype, and a standard icon library that is visually easily distinguishable and contains all necessary attributes, to obtain graphical components, including: Generate a canvas area, wherein entities, attributes, and relationship icons can be dragged and dropped within the canvas area, and zoom and pan functions are available; A toolbar is set in the interface, which provides a variety of graphic elements for the user to choose from; Generate a standard icon library, wherein the standard icon library contains all the necessary graphic elements; Define a set of basic attributes for each graphic element in the standard icon library, and allow users to modify them through an interactive interface to obtain a graphic component; wherein, the basic attributes include name, type, and constraints.

6. The visualization data integration method according to claim 1, characterized in that, Saving the data model to a selected storage medium and recording version information for the terminal to trace and compare historical version information includes: Define the version data structure; Configure database tables to store detailed information for each version; The data model can be saved to the selected storage medium via API, and save, read, update, and delete operations can be performed. When the data model is saving changes, it detects changes to the data model and updates the version data structure and database tables when changes occur, and restores the content corresponding to the historical version information through the rollback function.

7. The visualization data integration method according to claim 6, characterized in that, The process of detecting changes to the data model when saving changes, updating the version data structure and database tables when changes occur, and restoring the content corresponding to the historical version information through the rollback function includes: When the data model is saved, changes to the data model are detected. When changes occur, a version comparison algorithm based on a tree structure is used to identify and display the addition, deletion, and modification of entities, attributes, and relationships between different versions, so as to update the version data structure and database tables. The rollback function is used to restore the content corresponding to the historical version information.

8. A visualization data integration device, characterized in that, include: Document metadata forming unit, used to define entities, attributes and relationships based on business needs, and to form documented metadata; The interface prototype design unit is used to generate interface prototypes based on the documented metadata and the results of user needs research and competitor analysis. A data model determination unit is used to generate graphical components for operating the interface prototype and implement drag-and-drop functionality to obtain a data model. The record-keeping unit is used to save the data model to a selected storage medium and record version information so that the terminal can trace back and compare historical version information.

9. A computer device, characterized in that, The computer device includes a memory and a processor, the memory storing a computer program, and the processor executing the computer program to implement the method as described in any one of claims 1 to 7.

10. A storage medium, characterized in that, The storage medium stores a computer program that, when executed by a processor, implements the method as described in any one of claims 1 to 7.

Images