Struct Relationship 

pub struct Relationship {

    pub id: Uuid,
    pub source_table_id: Uuid,
    pub target_table_id: Uuid,
    pub cardinality: Option<Cardinality>,
    pub source_optional: Option<bool>,
    pub target_optional: Option<bool>,
    pub source_cardinality: Option<EndpointCardinality>,
    pub target_cardinality: Option<EndpointCardinality>,
    pub flow_direction: Option<FlowDirection>,
    pub foreign_key_details: Option<ForeignKeyDetails>,
    pub etl_job_metadata: Option<ETLJobMetadata>,
    pub relationship_type: Option<RelationshipType>,
    pub notes: Option<String>,
    pub owner: Option<String>,
    pub sla: Option<Vec<SlaProperty>>,
    pub contact_details: Option<ContactDetails>,
    pub infrastructure_type: Option<InfrastructureType>,
    pub visual_metadata: Option<VisualMetadata>,
    pub drawio_edge_id: Option<String>,
    pub color: Option<String>,
    pub source_handle: Option<ConnectionHandle>,
    pub target_handle: Option<ConnectionHandle>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

Relationship model representing a connection between two tables

Relationships can represent foreign keys, data flows, dependencies, or ETL transformations. They connect a source table to a target table with optional metadata about cardinality, foreign key details, and ETL job information.

Example

use data_modelling_core::models::Relationship;

let source_id = uuid::Uuid::new_v4();
let target_id = uuid::Uuid::new_v4();
let relationship = Relationship::new(source_id, target_id);

Example with Metadata (Data Flow Relationship)

use data_modelling_core::models::{Relationship, InfrastructureType, ContactDetails, SlaProperty};
use serde_json::json;
use uuid::Uuid;

let source_id = Uuid::new_v4();
let target_id = Uuid::new_v4();
let mut relationship = Relationship::new(source_id, target_id);
relationship.owner = Some("Data Engineering Team".to_string());
relationship.infrastructure_type = Some(InfrastructureType::Kafka);
relationship.contact_details = Some(ContactDetails {
    email: Some("team@example.com".to_string()),
    phone: None,
    name: Some("Data Team".to_string()),
    role: Some("Data Owner".to_string()),
    other: None,
});
relationship.sla = Some(vec![SlaProperty {
    property: "latency".to_string(),
    value: json!(2),
    unit: "hours".to_string(),
    description: Some("Data flow must complete within 2 hours".to_string()),
    element: None,
    driver: Some("operational".to_string()),
    scheduler: None,
    schedule: None,
}]);
relationship.notes = Some("ETL pipeline from source to target".to_string());

Fields

id: Uuid

Unique identifier for the relationship (UUIDv4)

source_table_id: Uuid

ID of the source table

target_table_id: Uuid

ID of the target table

cardinality: Option<Cardinality>

Legacy cardinality (OneToOne, OneToMany, ManyToMany) - for backward compatibility

source_optional: Option<bool>

Whether the source side is optional (nullable foreign key) - legacy field

target_optional: Option<bool>

Whether the target side is optional - legacy field

source_cardinality: Option<EndpointCardinality>

Crow’s feet cardinality at the source end (zeroOrOne, exactlyOne, zeroOrMany, oneOrMany)

target_cardinality: Option<EndpointCardinality>

Crow’s feet cardinality at the target end (zeroOrOne, exactlyOne, zeroOrMany, oneOrMany)

flow_direction: Option<FlowDirection>

Direction of data flow (sourceToTarget, targetToSource, bidirectional)

foreign_key_details: Option<ForeignKeyDetails>

Foreign key column mapping details

etl_job_metadata: Option<ETLJobMetadata>

ETL job metadata for data flow relationships

relationship_type: Option<RelationshipType>

Type of relationship (ForeignKey, DataFlow, Dependency, ETL)

notes: Option<String>

Optional notes about the relationship

owner: Option<String>

Owner information (person, team, or organization name) for Data Flow relationships

sla: Option<Vec<SlaProperty>>

SLA (Service Level Agreement) information (ODCS-inspired but lightweight format)

contact_details: Option<ContactDetails>

Contact details for responsible parties

infrastructure_type: Option<InfrastructureType>

Infrastructure type (hosting platform, service, or tool) for Data Flow relationships

visual_metadata: Option<VisualMetadata>

Visual metadata for canvas rendering

drawio_edge_id: Option<String>

Draw.io edge ID for diagram integration

color: Option<String>

Color for the relationship line in the UI (hex color code or named color)

source_handle: Option<ConnectionHandle>

Edge attachment point on the source node

target_handle: Option<ConnectionHandle>

Edge attachment point on the target node

created_at: DateTime<Utc>

Creation timestamp

updated_at: DateTime<Utc>

Last update timestamp

Implementations

impl Relationship

pub fn new(source_table_id: Uuid, target_table_id: Uuid) -> Self

Create a new relationship between two tables

Arguments

• source_table_id - UUID of the source table
• target_table_id - UUID of the target table

Returns

A new Relationship instance with a generated UUIDv4 ID and current timestamps.

Example

use data_modelling_core::models::Relationship;

let source_id = uuid::Uuid::new_v4();
let target_id = uuid::Uuid::new_v4();
let rel = Relationship::new(source_id, target_id);

pub fn generate_id(_source_table_id: Uuid, _target_table_id: Uuid) -> Uuid

Generate a UUIDv4 for a new relationship id.

Note: params are retained for backward-compatibility with previous deterministic-v5 API.

Trait Implementations

impl Clone for Relationship

fn clone(&self) -> Relationship

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Relationship

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Relationship

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Relationship

fn eq(&self, other: &Relationship) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Relationship

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Relationship