Struct DataModel 

pub struct DataModel {

    pub id: Uuid,
    pub name: String,
    pub description: Option<String>,
    pub git_directory_path: String,
    pub tables: Vec<Table>,
    pub relationships: Vec<Relationship>,
    pub domains: Vec<Domain>,
    pub control_file_path: String,
    pub diagram_file_path: Option<String>,
    pub is_subfolder: bool,
    pub parent_git_directory: Option<String>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

Data model representing a complete data model with tables and relationships

A DataModel is a container for a collection of tables and their relationships. It represents a workspace or domain within a larger data modeling system.

Example

use data_modelling_core::models::DataModel;

let model = DataModel::new(
    "MyModel".to_string(),
    "/path/to/git".to_string(),
    "control.yaml".to_string(),
);

Fields

id: Uuid

Unique identifier for the model (UUIDv5 based on name and path)

name: String

Model name

description: Option<String>

Optional description of the model

git_directory_path: String

Path to the Git repository directory

tables: Vec<Table>

Tables in this model

relationships: Vec<Relationship>

Relationships between tables

domains: Vec<Domain>

Business domains in this model

control_file_path: String

Path to the control file (relationships.yaml)

diagram_file_path: Option<String>

Path to diagram file if applicable

is_subfolder: bool

Whether this model is in a subfolder

parent_git_directory: Option<String>

Parent Git directory if this is a subfolder

created_at: DateTime<Utc>

Creation timestamp

updated_at: DateTime<Utc>

Last update timestamp

Implementations

impl DataModel

pub fn new( name: String, git_directory_path: String, control_file_path: String, ) -> Self

Create a new data model with the given name and paths

Arguments

• name - The model name
• git_directory_path - Path to the Git repository directory
• control_file_path - Path to the control file (typically “relationships.yaml”)

Returns

A new DataModel instance with a UUIDv5 ID (deterministic based on name and path) and current timestamps.

Example

use data_modelling_core::models::DataModel;

let model = DataModel::new(
    "MyModel".to_string(),
    "/workspace/models".to_string(),
    "relationships.yaml".to_string(),
);

pub fn get_table_by_id(&self, table_id: Uuid) -> Option<&Table>

Get a table by its ID

Arguments

• table_id - The UUID of the table to find

Returns

A reference to the table if found, None otherwise.

pub fn get_table_by_id_mut(&mut self, table_id: Uuid) -> Option<&mut Table>

Get a mutable reference to a table by its ID

Arguments

• table_id - The UUID of the table to find

Returns

A mutable reference to the table if found, None otherwise.

pub fn get_table_by_name(&self, name: &str) -> Option<&Table>

Get a table by its name

Arguments

• name - The name of the table to find

Returns

A reference to the first table with the given name if found, None otherwise.

Note

If multiple tables have the same name (different database_type/catalog/schema), use get_table_by_unique_key instead.

pub fn get_table_by_unique_key( &self, database_type: Option<&str>, name: &str, catalog_name: Option<&str>, schema_name: Option<&str>, ) -> Option<&Table>

Get a table by its unique key (database_type, name, catalog, schema)

Arguments

• database_type - Optional database type
• name - Table name
• catalog_name - Optional catalog name
• schema_name - Optional schema name

Returns

A reference to the table if found, None otherwise.

Example

// Find table in specific schema
let table = model.get_table_by_unique_key(
    Some("PostgreSQL"),
    "users",
    Some("mydb"),
    Some("public"),
);

pub fn get_relationships_for_table(&self, table_id: Uuid) -> Vec<&Relationship>

Get all relationships involving a specific table

Arguments

• table_id - The UUID of the table

Returns

A vector of references to relationships where the table is either the source or target.

Example

// Get all relationships for a table
let relationships = model.get_relationships_for_table(table_id);

pub fn filter_nodes_by_owner(&self, owner: &str) -> Vec<&Table>

Filter Data Flow nodes (tables) by owner

Arguments

• owner - The owner name to filter by (case-sensitive exact match)

Returns

A vector of references to tables matching the owner.

Example

let owned_nodes = model.filter_nodes_by_owner("Data Engineering Team");

pub fn filter_relationships_by_owner(&self, owner: &str) -> Vec<&Relationship>

Filter Data Flow relationships by owner

Arguments

• owner - The owner name to filter by (case-sensitive exact match)

Returns

A vector of references to relationships matching the owner.

Example

let owned_relationships = model.filter_relationships_by_owner("Data Engineering Team");

pub fn filter_nodes_by_infrastructure_type( &self, infra_type: InfrastructureType, ) -> Vec<&Table>

Filter Data Flow nodes (tables) by infrastructure type

Arguments

• infra_type - The infrastructure type to filter by

Returns

A vector of references to tables matching the infrastructure type.

Example

let kafka_nodes = model.filter_nodes_by_infrastructure_type(InfrastructureType::Kafka);

pub fn filter_relationships_by_infrastructure_type( &self, infra_type: InfrastructureType, ) -> Vec<&Relationship>

Filter Data Flow relationships by infrastructure type

Arguments

• infra_type - The infrastructure type to filter by

Returns

A vector of references to relationships matching the infrastructure type.

Example

let kafka_relationships = model.filter_relationships_by_infrastructure_type(InfrastructureType::Kafka);

pub fn filter_by_tags(&self, tag: &str) -> (Vec<&Table>, Vec<&Relationship>)

Filter Data Flow nodes and relationships by tag

Arguments

• tag - The tag to filter by

Returns

A tuple containing vectors of references to tables and relationships containing the tag.

Example

let (tagged_nodes, tagged_relationships) = model.filter_by_tags("production");

pub fn add_domain(&mut self, domain: Domain)

Add a domain to the model

Arguments

• domain - The domain to add

Example

let domain = Domain::new("customer-service".to_string());
model.add_domain(domain);

pub fn get_domain_by_id(&self, domain_id: Uuid) -> Option<&Domain>

Get a domain by its ID

Arguments

• domain_id - The UUID of the domain to find

Returns

A reference to the domain if found, None otherwise.

pub fn get_domain_by_id_mut(&mut self, domain_id: Uuid) -> Option<&mut Domain>

Get a mutable reference to a domain by its ID

Arguments

• domain_id - The UUID of the domain to find

Returns

A mutable reference to the domain if found, None otherwise.

pub fn get_domain_by_name(&self, name: &str) -> Option<&Domain>

Get a domain by its name

Arguments

• name - The name of the domain to find

Returns

A reference to the first domain with the given name if found, None otherwise.

pub fn add_system_to_domain( &mut self, domain_id: Uuid, system: System, ) -> Result<(), String>

Add a system to a domain

Arguments

• domain_id - The UUID of the domain
• system - The system to add

Returns

Ok(()) if the domain was found and the system was added, Err otherwise.

Example

let system = System::new("kafka-cluster".to_string(), InfrastructureType::Kafka, domain_id);
model.add_system_to_domain(domain_id, system).unwrap();

pub fn add_cads_node_to_domain( &mut self, domain_id: Uuid, node: CADSNode, ) -> Result<(), String>

Add a CADS node to a domain

Arguments

• domain_id - The UUID of the domain
• node - The CADS node to add

Returns

Ok(()) if the domain was found and the node was added, Err otherwise.

pub fn add_odcs_node_to_domain( &mut self, domain_id: Uuid, node: ODCSNode, ) -> Result<(), String>

Add an ODCS node to a domain

Arguments

• domain_id - The UUID of the domain
• node - The ODCS node to add

Returns

Ok(()) if the domain was found and the node was added, Err otherwise.

pub fn add_system_connection_to_domain( &mut self, domain_id: Uuid, connection: SystemConnection, ) -> Result<(), String>

Add a system connection to a domain

Arguments

• domain_id - The UUID of the domain
• connection - The system connection to add

Returns

Ok(()) if the domain was found and the connection was added, Err otherwise.

pub fn add_node_connection_to_domain( &mut self, domain_id: Uuid, connection: NodeConnection, ) -> Result<(), String>

Add a node connection to a domain

Arguments

• domain_id - The UUID of the domain
• connection - The node connection to add

Returns

Ok(()) if the domain was found and the connection was added, Err otherwise.

Trait Implementations

impl Clone for DataModel

fn clone(&self) -> DataModel

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DataModel

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DataModel

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for DataModel

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.