Struct Column 

pub struct Column {

    pub id: Option<String>,
    pub name: String,
    pub business_name: Option<String>,
    pub description: String,
    pub data_type: String,
    pub physical_type: Option<String>,
    pub physical_name: Option<String>,
    pub logical_type_options: Option<LogicalTypeOptions>,
    pub primary_key: bool,
    pub primary_key_position: Option<i32>,
    pub unique: bool,
    pub nullable: bool,
    pub partitioned: bool,
    pub partition_key_position: Option<i32>,
    pub clustered: bool,
    pub classification: Option<String>,
    pub critical_data_element: bool,
    pub encrypted_name: Option<String>,
    pub transform_source_objects: Vec<String>,
    pub transform_logic: Option<String>,
    pub transform_description: Option<String>,
    pub examples: Vec<Value>,
    pub default_value: Option<Value>,
    pub relationships: Vec<PropertyRelationship>,
    pub authoritative_definitions: Vec<AuthoritativeDefinition>,
    pub quality: Vec<HashMap<String, Value>>,
    pub enum_values: Vec<String>,
    pub tags: Vec<String>,
    pub custom_properties: HashMap<String, Value>,
    pub secondary_key: bool,
    pub composite_key: Option<String>,
    pub foreign_key: Option<ForeignKey>,
    pub constraints: Vec<String>,
    pub errors: Vec<HashMap<String, Value>>,
    pub column_order: i32,
    pub nested_data: Option<String>,
}

Column model representing a field in a table

A column defines a single field with a data type, constraints, and optional metadata. This model supports all ODCS v3.1.0 property fields to ensure no data loss during import/export.

Example

use data_modelling_core::models::Column;

let column = Column::new("id".to_string(), "INT".to_string());

Fields

id: Option<String>

Stable technical identifier (ODCS: id)

name: String

Column name (ODCS: name)

business_name: Option<String>

Business name for the column (ODCS: businessName)

description: String

Column description/documentation (ODCS: description)

data_type: String

Logical data type (ODCS: logicalType - e.g., “string”, “integer”, “number”)

physical_type: Option<String>

Physical database type (ODCS: physicalType - e.g., “VARCHAR(100)”, “BIGINT”)

physical_name: Option<String>

Physical name in the data source (ODCS: physicalName)

logical_type_options: Option<LogicalTypeOptions>

Additional type options (ODCS: logicalTypeOptions)

primary_key: bool

Whether this column is part of the primary key (ODCS: primaryKey)

primary_key_position: Option<i32>

Position in composite primary key, 1-based (ODCS: primaryKeyPosition)

unique: bool

Whether the column contains unique values (ODCS: unique)

nullable: bool

Whether the column allows NULL values (inverse of ODCS: required)

partitioned: bool

Whether the column is used for partitioning (ODCS: partitioned)

partition_key_position: Option<i32>

Position in partition key, 1-based (ODCS: partitionKeyPosition)

clustered: bool

Whether the column is used for clustering

classification: Option<String>

Data classification level (ODCS: classification - e.g., “confidential”, “public”)

critical_data_element: bool

Whether this is a critical data element (ODCS: criticalDataElement)

encrypted_name: Option<String>

Name of the encrypted version of this column (ODCS: encryptedName)

transform_source_objects: Vec<String>

Source objects used in transformation (ODCS: transformSourceObjects)

transform_logic: Option<String>

Transformation logic/expression (ODCS: transformLogic)

transform_description: Option<String>

Human-readable transformation description (ODCS: transformDescription)

examples: Vec<Value>

Example values for this column (ODCS: examples)

default_value: Option<Value>

Default value for the column

relationships: Vec<PropertyRelationship>

ODCS v3.1.0 relationships (property-level references)

authoritative_definitions: Vec<AuthoritativeDefinition>

Authoritative definitions (ODCS: authoritativeDefinitions)

quality: Vec<HashMap<String, Value>>

Quality rules and checks (ODCS: quality)

enum_values: Vec<String>

Enum values if this column is an enumeration type

tags: Vec<String>

Property-level tags (ODCS: tags)

custom_properties: HashMap<String, Value>

Custom properties for format-specific metadata not covered by ODCS

secondary_key: bool

Whether this column is a secondary/business key

composite_key: Option<String>

Composite key name if this column is part of a composite key

foreign_key: Option<ForeignKey>

Foreign key reference (legacy - prefer relationships)

constraints: Vec<String>

Additional constraints (e.g., “CHECK”, “UNIQUE”)

errors: Vec<HashMap<String, Value>>

Validation errors and warnings

column_order: i32

Display order for UI rendering

nested_data: Option<String>

Nested data type for ARRAY or MAP types

Implementations

impl Column

pub fn new(name: String, data_type: String) -> Column

Create a new column with the given name and data type

Arguments

• name - The column name (must be valid according to naming conventions)
• data_type - The data type string (e.g., “INT”, “VARCHAR(100)”)

Returns

A new Column instance with default values (nullable=true, primary_key=false).

Example

use data_modelling_core::models::Column;

let col = Column::new("user_id".to_string(), "BIGINT".to_string());

Trait Implementations

impl Clone for Column

fn clone(&self) -> Column

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Column

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

Formats the value using the given formatter.

impl Default for Column

fn default() -> Column

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Column

fn deserialize<__D>( __deserializer: __D, ) -> Result<Column, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Column

fn eq(&self, other: &Column) -> 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 Column

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Column