SysML model storage method fusing key-value pair database and graph database

Abstract

The invention discloses a SysML model storage method fusing a key-value pair database and a graph database. The method comprises the following steps: S1, preprocessing and extracting model elements; s2, designing and storing a key value pair database; s3, designing and storing a graph database; s4, designing a graph-key value pair database association mechanism; and S5, verifying data integrity and boundary limitation. According to the method, the content information of the model elements is stored in the key value pair database in the JSON format, and the multi-dimensional semantic relationship among the model elements is structurally expressed in the graph database, so that a dual-mode database architecture with efficient read-write performance and rich semantic expression capability is constructed; a unified ID mapping mechanism and a semantic boundary verification rule are further introduced, decoupling storage and unified management of the model content and structure are achieved, and the technical blank of the SysML model in the aspects of extensible storage and relation modeling is filled up.

Description

Technical Field

[0001] This invention belongs to the field of computer software technology and relates to a method for storing SysML models, specifically a method for storing SysML models that integrates key-value databases and graph databases. Background Technology

[0002] In modern engineering, systems typically consist of a set of interacting components designed to achieve specific goals or solve complex problems. Engineering systems, as complex aggregates fulfilling human needs, encompass physical entities, information, human resources, procedures, facilities, and their relationships with the natural and social environment. Their lifecycle includes creation, operation, maintenance, and optimization, driven by multiple demands and the external environment. With the increasing complexity of systems, Model-Based Systems Engineering (MBSE) has gradually become a core methodology in modern engineering development. SysML (Systems Modeling Language), as the primary modeling language for MBSE, is widely used in aerospace, rail transportation, industrial control, automotive electronics, and other fields. Through SysML models, developers can perform requirement modeling, structural modeling, behavioral modeling, and parametric modeling throughout the system lifecycle, thereby effectively improving the standardization and traceability of system design.

[0003] In existing technologies, SysML models are typically stored in standardized formats such as XMI (XML Metadata Interchange) and rely on graphical modeling tools for editing and management. However, traditional file-based storage methods have the following problems:

[0004] 1. Mixed structure and relationships: The content of model elements and the dependencies between elements are usually mixed and stored in a unified document, lacking structured and scalable database support;

[0005] 2. Low query efficiency: Document-based parsing has low retrieval efficiency in large-scale model scenarios and does not support fast query, reasoning, and traversal based on relationships;

[0006] 3. Lack of semantic hierarchy: The semantic relationships between model elements, such as dependency, verification, and allocation, are not managed hierarchically, making it difficult to meet the multidimensional modeling needs of complex systems.

[0007] In recent years, some studies have attempted to use database technology to store and manage models. For example, key-value databases offer high-performance data read and write capabilities, making them suitable for storing the raw content of model elements; while graph databases can naturally express the relationship structure between model elements, making them suitable for modeling structured dependencies. However, there is currently a lack of a unified model storage method that integrates both approaches, supporting both content storage and semantic relationship management, especially in applications that satisfy SysML-specific semantic constraints.

[0008] Therefore, there is an urgent need to propose a model storage method that integrates key-value databases and graph databases to meet the needs of SysML semantic modeling, so as to improve the model's structured management capabilities, query efficiency and semantic expression capabilities, and provide basic support for MBSE engineering practice. Summary of the Invention

[0009] To address the problems of complex structures, difficulty in expressing relational semantics, and low query efficiency in the current SysML model storage process, especially in large-scale system modeling where traditional file-based storage methods cannot support efficient model management and semantic reasoning, this invention provides a SysML model storage method that integrates key-value pair databases and graph databases. This method stores the content information of model elements in JSON format in a key-value pair database and structurally represents the multidimensional semantic relationships between model elements in a graph database, constructing a dual-model database architecture that simultaneously possesses high read / write performance and rich semantic expression capabilities. Furthermore, it introduces a unified ID mapping mechanism and semantic boundary verification rules to achieve decoupled storage and unified management of model content and structure, filling the technical gap in scalable storage and relational modeling of SysML models, and promoting the evolution of MBSE models for complex systems in terms of persistence and scalability. This invention improves the storage efficiency and relational traceability of SysML models in the process of complex system modeling, and is suitable for large-scale system engineering modeling platforms in fields such as aviation, aerospace, and automotive, with broad application prospects.

[0010] The objective of this invention is achieved through the following technical solution:

[0011] A method for storing SysML models that integrates key-value databases and graph databases includes the following steps:

[0012] Step S1: Model element preprocessing and extraction:

[0013] Step S101: Export the SysML model to be stored as a standardized format file;

[0014] Step S102: Parse the model file and extract the following fields for each model element: unique identifier id, element name name, element description description, whether it is a subsystem that can be further subdivided isSubsystem, and original model content content.

[0015] Step S103: Extract the relationship pairs between model elements and record them initially for subsequent relational modeling processing in the graph database;

[0016] Step S2: Key-value database design and storage:

[0017] Each model element extracted in step S1 is written into a key-value pair database with its id as the key and stored in JSON format;

[0018] Step S3: Graph Database Design and Storage:

[0019] Step S301: Write the id, name, and type of each model element as node information into the graph database to construct a node set for the model element;

[0020] Step S302: Based on the relationships between model elements extracted in step S1, construct the edge set in the graph database. Each edge contains the fields: source_id, target_id, and relation_type.

[0021] Step S4: Design of Graph-Key-Value Database Relationship Mechanism:

[0022] Record the binding mapping relationship between graph database nodes and key-value pair database records. When querying a graph database node, access the corresponding key-value pair database by ID to obtain detailed static information of the node. When performing add, delete, or update operations, it is necessary to maintain the corresponding records in both the graph database and the key-value pair database to ensure data consistency and integrity.

[0023] Step S5: Data integrity and boundary constraint verification:

[0024] Data integrity and boundary constraints are verified using the following constraint rules:

[0025] Limitation 1: Uniqueness constraint: Before writing model elements into the database, the system must deduplicate the elements based on name matching and semantic similarity analysis to avoid duplicate entry of semantically equivalent or similar model elements into the database.

[0026] Restriction 2, Model Boundary Constraints: The model structure path must end with an element that isSubsystem=true; if an element isSubsystem=false, it must not have any child nodes.

[0027] Restriction 3: Relationship structure constraint: The parent-child relationship between model elements should support a many-to-many structure.

[0028] Compared with the prior art, the present invention has the following advantages:

[0029] 1. Supports complex relationship expression and efficient query: By introducing a relationship type system with a clear semantic hierarchy and implementing the structured organization of nodes and edges in the graph database, complex model relationships can be expressed and queried efficiently, making up for the technical shortcomings of traditional storage methods that cannot support complex structured models.

[0030] 2. Supports scalable and service-oriented deployment of models: By adopting a key-value pair and graph database coupling approach, it provides a technical foundation for distributed storage and on-demand loading of models, which is conducive to the expansion of subsequent model service-oriented deployment, online collaborative modeling and model version management functions.

[0031] 3. Excellent versatility and compatibility: This invention supports multiple mainstream model expression formats, including XMI, XML, JSON, and SysML v2, and has good toolchain compatibility, making it suitable for importing and converting models generated by mainstream SysML modeling tools. Attached Figure Description

[0032] Figure 1 A flowchart illustrating the SysML model storage method for integrating key-value databases and graph databases;

[0033] Figure 2 The process for preprocessing and extracting model element data in step S1;

[0034] Figure 3 An example of a key-value database design;

[0035] Figure 4 A class diagram for edge structure categories in a graph database;

[0036] Figure 5 An example of graph database design. Detailed Implementation

[0037] The technical solution of the present invention will be further described below with reference to the accompanying drawings, but it is not limited thereto. Any modifications or equivalent substitutions to the technical solution of the present invention that do not depart from the spirit and scope of the technical solution of the present invention should be covered within the protection scope of the present invention.

[0038] This invention provides a SysML model storage method that integrates key-value databases and graph databases, such as... Figure 1 As shown, the method includes the following steps:

[0039] Step S1: Model element preprocessing and extraction. For example... Figure 2 As shown, the specific steps include:

[0040] Step S101: Export the SysML model to be stored as a standardized format file, including but not limited to XMI, JSON or XML formats.

[0041] Step S102: Parse the model file and extract the following fields for each model element: unique identifier id, element name name, element description description, isSubsystem flag (boolean type) indicating whether it is a subdivisible subsystem, and the original model content content. The content is a structured representation fragment of the SysML model, including but not limited to XML, XMI, JSON, or SysML v2.

[0042] Step S103: Extract the relationship pairs between model elements and record them initially for subsequent relational modeling processing in the graph database. The relationship type is not distinguished in this step.

[0043] Step S2: Key-value database design and storage.

[0044] Each model element extracted in step S1 is written to a key-value database using its id as the key and stored in JSON format. The key-value database can be a database that supports JSON data structures, such as Redis, RocksDB, LevelDB, or other compatible databases.

[0045] Figure 3 This is an example of key-value database design in this invention, where the SysML model element has the id "element-123" and the name "FlightControl". This element represents a system used to control the aircraft's attitude. The isSubsystem field has a value of true, indicating that this element is a subsystem that can be further subdivided. Its content field contains the XMI representation fragment of this model element.

[0046] Step S3: Graph Database Design and Storage. This includes the following steps:

[0047] Step S301: Write the id, name, and type of each model element as node information into the graph database to construct a node set for the model element.

[0048] Step S302: Based on the relationships between model elements extracted in step S1, construct an edge set in the graph database. Each edge contains the following fields: source_id (source node identifier), target_id (target node identifier), and relation_type (edge ​​type).

[0049] like Figure 4 As shown, the relation types supported by relation_type and their semantic hierarchy structure are defined as follows:

[0050] The Dependency class is the parent class for dependency relationships, indicating that a target element has a certain dependency constraint on a source element. It contains the subclass Violates, which represents a target element violating a certain constraint of the source element. For example, a module might violate the functional behavior described by an activity.

[0051] The `Abstract` class is the parent class for abstract modeling relationships, containing subclasses: `Allocate`, `Satisfy`, `Refine`, and `Verify`. Here, `Allocate` represents the allocation relationship from behavior to modules and from attributes to constraints; `Satisfy` represents the satisfaction of requirements by model elements (such as operations or attributes); `Refine` represents the refinement relationship between elements (such as modules, use cases, behaviors, and requirements); and `Verify` represents the verification relationship between behaviors and requirements.

[0052] The Composition class represents the composition relationship between a source node and a target node, where the target node is a subsystem of the source node.

[0053] In this step, the graph database can be Neo4j, TigerGraph, JanusGraph, or other databases that support multiple relational graph structures.

[0054] Figure 5 As an instance in the graph database, the module FlightControl establishes a Violates relationship with the activity StabilizeAttitude, reflecting a certain violation of the function of the activity by the module, and realizing the traceable expression of the model relationship.

[0055] Step S4: Design of graph-key-value pair database association mechanism.

[0056] The association mechanism in this step is implemented through a unified `id` field, which records the binding mapping relationship between graph database nodes and key-value pair database records. When querying a graph database node, the corresponding key-value pair database can be accessed through the `id` to obtain detailed static information about the node. When performing add, delete, or update operations, the corresponding records in both the graph database and the key-value pair database must be maintained simultaneously to ensure data consistency and integrity.

[0057] Step S5: Data integrity and boundary constraint verification.

[0058] This step includes the following constraints:

[0059] Limitation 1: Uniqueness constraint. Before writing model elements into the database, the system must deduplicate the elements based on name matching and semantic similarity analysis to avoid duplicate entry of semantically equivalent or similar model elements.

[0060] Restriction 2: Model Boundary Constraints. The model structure path must end with an element that has isSubsystem=true; if an element has isSubsystem=false, it must not have any child nodes.

[0061] Restriction 3: Relationship structure constraints. The parent-child relationship between model elements should support a many-to-many structure. The same model element can be a child node of multiple parent nodes, and can also have multiple child nodes.

Claims

1. A SysML model storage method that integrates key-value databases and graph databases, characterized in that... The method includes the following steps: Step S1: Model element preprocessing and extraction: Step S101: Export the SysML model to be stored as a standardized format file; Step S102: Parse the model file and extract the following fields for each model element: unique identifier id, element name name, element description description, whether it is a subsystem that can be further subdivided isSubsystem, and original model content content. Step S103: Extract the relationship pairs between model elements and record them initially for subsequent relational modeling processing in the graph database; Step S2: Key-value database design and storage: Each model element extracted in step S1 is written into a key-value pair database with its id as the key and stored in JSON format; Step S3: Graph Database Design and Storage: Step S301: Write the id, name, and type of each model element as node information into the graph database to construct a node set for the model element; Step S302: Based on the relationships between model elements extracted in step S1, construct the edge set in the graph database. Each edge contains the fields: source_id, target_id, and relation_type. Step S4: Design of Graph-Key-Value Database Relationship Mechanism: Record the binding mapping relationship between graph database nodes and key-value pair database records. When querying a graph database node, access the corresponding key-value pair database by ID to obtain detailed static information of the node. When performing add, delete, or update operations, it is necessary to maintain the corresponding records in both the graph database and the key-value pair database to ensure data consistency and integrity. Step S5: Data integrity and boundary constraint verification: Data integrity and boundary constraints are verified using the following constraint rules: Limitation 1: Uniqueness constraint: Before writing model elements into the database, the system must deduplicate the elements based on name matching and semantic similarity analysis to avoid duplicate entry of semantically equivalent or similar model elements into the database. Restriction 2, Model Boundary Constraints: The model structure path must end with an element that isSubsystem=true; if an element isSubsystem=false, it must not have any child nodes. Restriction 3: Relationship structure constraint: The parent-child relationship between model elements should support a many-to-many structure.

2. The SysML model storage method for integrating key-value databases and graph databases according to claim 1, characterized in that... In S101, the standardized format includes XMI, JSON, or XML formats.

3. The SysML model storage method for integrating key-value databases and graph databases according to claim 1, characterized in that... In S102, content is a structured representation fragment of the SysML model, including XML, XMI, JSON, or SysML v2.

4. The SysML model storage method for integrating key-value databases and graph databases according to claim 1, characterized in that... In step S2, the key-value pair database is selected from databases that support JSON data structures.

5. The SysML model storage method for integrating key-value databases and graph databases according to claim 1, characterized in that... In S302, the relation types supported by relation_type and their semantic hierarchy structure are defined as follows: The Dependency class is the parent class for dependency relationships, indicating that the target element has a certain dependency constraint relationship with the source element. It contains the subclass Violates, which indicates that the target element violates a certain constraint of the source element. The Abstract class is the parent class for abstracting modeling relationships. It contains the subclasses Allocate, Satisfy, Refine, and Verify. Allocate represents the allocation relationship between behavior and modules, and between attributes and constraints. Satisfy represents the fulfillment of requirements by model elements. Refine represents the refinement relationship between elements. Verify represents the verification relationship between behavior and requirements. The Composition class represents the composition relationship between a source node and a target node, where the target node is a subsystem of the source node.

6. The SysML model storage method for integrating key-value databases and graph databases according to claim 1, characterized in that... The graph database used is Neo4j, TigerGraph, or JanusGraph, which supports multiple relational graph structures.

Images