sqlscope 1.0.0__py3-none-any.whl

sqlscope/__init__.py

@@ -0,0 +1,4 @@
+'''Extracts catalog and query metadata from a SQL query'''
+
+from .catalog import Catalog, build_catalog, load_catalog, build_catalog_from_postgres, build_catalog_from_sql
+from .query import Query

sqlscope/catalog/__init__.py

@@ -0,0 +1,12 @@
+'''Represents a catalog of database schemas, tables, and columns.'''
+
+# API exports
+from .constraint import Constraint, ConstraintColumn, ConstraintType
+from .column import Column
+from .table import Table
+from .schema import Schema
+from .catalog import Catalog
+from .builder import CatalogColumnInfo, CatalogUniqueConstraintInfo, build_catalog, build_catalog_from_postgres, load_catalog, build_catalog_from_sql
+
+
+

sqlscope/catalog/builder/__init__.py

@@ -0,0 +1,8 @@
+from ..catalog import Catalog
+from .postgres import build_catalog, build_catalog_from_postgres, CatalogColumnInfo, CatalogUniqueConstraintInfo
+from .sql import build_catalog_from_sql
+
+def load_catalog(path: str) -> Catalog:
+    '''Loads a catalog from a JSON file.'''
+    return Catalog.load_json(path)
+

sqlscope/catalog/builder/postgres.py

@@ -0,0 +1,207 @@
+from ..catalog import Catalog
+from ..constraint import ConstraintType
+
+import psycopg2
+import time
+from dataclasses import dataclass
+
+# region Data Classes
+@dataclass(frozen=True)
+class CatalogColumnInfo:
+    '''Holds information about a database column.'''
+    schema_name: str
+    table_name: str
+    column_name: str
+    column_type: str
+    numeric_precision: int | None
+    numeric_scale: int | None
+    is_nullable: bool
+    foreign_key_schema: str | None
+    foreign_key_table: str | None
+    foreign_key_column: str | None
+
+    def to_dict(self) -> dict:
+        return {
+            'schema_name': self.schema_name,
+            'table_name': self.table_name,
+            'column_name': self.column_name,
+            'column_type': self.column_type,
+            'numeric_precision': self.numeric_precision,
+            'numeric_scale': self.numeric_scale,
+            'is_nullable': self.is_nullable,
+            'foreign_key_schema': self.foreign_key_schema,
+            'foreign_key_table': self.foreign_key_table,
+            'foreign_key_column': self.foreign_key_column,
+        }
+
+@dataclass(frozen=True)
+class CatalogUniqueConstraintInfo:
+    '''Holds information about a unique constraint or primary key.'''
+    schema_name: str
+    table_name: str
+    constraint_type: str
+    columns: str  # Postgres returns this as a string like '{col1,col2,...}'
+
+    def to_dict(self) -> dict:
+        return {
+            'schema_name': self.schema_name,
+            'table_name': self.table_name,
+            'constraint_type': self.constraint_type,
+            'columns': self.columns,
+        }
+# endregion
+    
+# region Catalog Builder
+def build_catalog(columns_info: list[CatalogColumnInfo], unique_constraints_info: list[CatalogUniqueConstraintInfo]) -> Catalog:
+    '''Builds a catalog from the provided column and unique constraint information.'''
+    result = Catalog()
+    
+    for column in columns_info:
+        result.add_column(
+            schema_name=column.schema_name,
+            table_name=column.table_name,
+            column_name=column.column_name,
+            column_type=column.column_type,
+            numeric_precision=column.numeric_precision,
+            numeric_scale=column.numeric_scale,
+            is_nullable=column.is_nullable,
+            fk_schema=column.foreign_key_schema,
+            fk_table=column.foreign_key_table,
+            fk_column=column.foreign_key_column,
+        )
+        
+    for constraint in unique_constraints_info:
+        columns = set(constraint.columns.strip('{}').split(','))  # Postgres returns {col1,col2,...}
+        constraint_type = ConstraintType.PRIMARY_KEY if constraint.constraint_type == 'PRIMARY KEY' else ConstraintType.UNIQUE
+
+        result[constraint.schema_name][constraint.table_name].add_unique_constraint(columns, constraint_type=constraint_type)
+
+    return result
+
+
+def build_catalog_from_postgres(sql_string: str, *, hostname: str, port: int, user: str, password: str, schema: str | None = None, create_temp_schema: bool = False) -> Catalog:
+    '''Builds a catalog by executing the provided SQL string in a temporary PostgreSQL database.'''
+    if sql_string.strip() == '':
+        return Catalog()
+
+    conn = psycopg2.connect(host=hostname, port=port, user=user, password=password)
+    cur = conn.cursor()
+    
+    # Use a temporary schema with a fixed name
+    if create_temp_schema:
+        if schema is None:
+            schema_name = f'sql_error_categorizer_{time.time_ns()}'
+        else:
+            schema_name = schema
+        cur.execute(f'CREATE schema {schema_name};')
+        cur.execute(f'SET search_path TO {schema_name};')
+    else:
+        schema_name = '%' if schema is None else schema
+    
+    # Create the tables
+    cur.execute(sql_string)
+
+    # Fetch the catalog information
+    cur.execute(COLUMNS(schema_name))
+    columns_info = cur.fetchall()
+
+    columns_data = [
+        CatalogColumnInfo(
+            schema_name=row[0],
+            table_name=row[1],
+            column_name=row[2],
+            column_type=row[3],
+            numeric_precision=row[4],
+            numeric_scale=row[5],
+            is_nullable=row[6],
+            foreign_key_schema=row[7],
+            foreign_key_table=row[8],
+            foreign_key_column=row[9],
+        )
+        for row in columns_info
+    ]
+
+    # Fetch unique constraints (including primary keys)
+    cur.execute(UNIQUE_COLUMNS(schema_name))
+    unique_constraints_info = cur.fetchall()
+
+    unique_constraints_data = [
+        CatalogUniqueConstraintInfo(
+            schema_name=row[0],
+            table_name=row[1],
+            constraint_type=row[2],
+            columns=row[3],
+        )
+        for row in unique_constraints_info
+    ]
+
+    # Clean up
+    if create_temp_schema:
+        cur.execute(f'DROP schema {schema_name} CASCADE;')
+    conn.rollback()     # no need to save anything
+
+    return build_catalog(columns_data, unique_constraints_data)
+# endregion
+
+# region SQL Queries
+def UNIQUE_COLUMNS(schema_name: str = '%') -> str:
+    return f'''
+    SELECT
+        kcu.table_schema AS schema_name,
+        kcu.table_name,
+        tc.constraint_type,
+        array_agg(kcu.column_name ORDER BY kcu.ordinal_position) AS columns
+    FROM information_schema.table_constraints tc
+    JOIN information_schema.key_column_usage kcu
+    ON tc.constraint_name = kcu.constraint_name
+    AND tc.constraint_schema = kcu.constraint_schema
+    WHERE tc.constraint_type IN ('UNIQUE', 'PRIMARY KEY')
+    AND kcu.table_schema LIKE '{schema_name}'
+    GROUP BY
+        kcu.table_schema,
+        kcu.table_name,
+        kcu.constraint_name,
+        tc.constraint_type;
+'''
+
+def COLUMNS(schema_name: str = '%') -> str:
+    return f'''
+    SELECT
+        cols.table_schema AS schema_name,
+        cols.table_name,
+        cols.column_name,
+        cols.data_type AS column_type,
+        cols.numeric_precision,
+        cols.numeric_scale,
+        (cols.is_nullable = 'YES') AS is_nullable,
+        fk.foreign_table_schema AS foreign_key_schema,
+        fk.foreign_table_name AS foreign_key_table,
+        fk.foreign_column_name AS foreign_key_column
+    FROM information_schema.columns AS cols
+
+    -- Foreign Key
+    LEFT JOIN (
+        SELECT
+            kcu.table_schema,
+            kcu.table_name,
+            kcu.column_name,
+            ccu.table_schema AS foreign_table_schema,
+            ccu.table_name   AS foreign_table_name,
+            ccu.column_name  AS foreign_column_name
+        FROM information_schema.table_constraints AS tc
+            JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+            AND tc.constraint_schema = kcu.constraint_schema
+            AND tc.table_schema = kcu.table_schema
+            AND tc.table_name = kcu.table_name
+            JOIN information_schema.constraint_column_usage AS ccu
+            ON tc.constraint_name = ccu.constraint_name
+            AND tc.constraint_schema = ccu.constraint_schema
+        WHERE tc.constraint_type = 'FOREIGN KEY'
+    ) fk ON fk.table_schema = cols.table_schema
+        AND fk.table_name = cols.table_name
+        AND fk.column_name = cols.column_name
+
+    WHERE cols.table_schema LIKE '{schema_name}'
+'''
+# endregion

sqlscope/catalog/builder/sql.py

@@ -0,0 +1,219 @@
+import sqlglot
+from sqlglot import exp
+from ..catalog import Catalog
+from ..constraint import ConstraintType
+
+def _get_identifier_name(identifier_exp: exp.Identifier) -> str:
+    '''Returns the normalized name from an Identifier expression.'''
+
+    if identifier_exp.quoted:
+        return identifier_exp.name
+    return identifier_exp.name.lower()
+
+def _get_table_name(table_exp: exp.Table) -> str:
+    '''Returns the normalized table name from a Table expression.'''
+
+    if isinstance(table_exp.this, exp.Identifier):
+        return _get_identifier_name(table_exp.this)
+    return str(table_exp.this).lower()
+
+def _get_schema_name(table_exp: exp.Table, default_schema: str) -> str:
+    '''Returns the normalized schema name from a Table expression, or the default schema if not specified.'''
+
+    if table_exp.db:
+        if isinstance(table_exp.db, exp.Identifier):
+            return _get_identifier_name(table_exp.db)
+        return str(table_exp.db).lower()
+    return default_schema
+
+def _get_column_name(column_exp: exp.ColumnDef) -> str:
+    '''Returns the normalized column name from a ColumnDef expression.'''
+
+    if isinstance(column_exp.this, exp.Identifier):
+        return _get_identifier_name(column_exp.this)
+    return str(column_exp.this).lower()
+
+def _extract_datatype(column_exp: exp.ColumnDef) -> tuple[str, int | None, int | None]:
+    '''Extracts datatype information from a ColumnDef expression.'''
+
+    datatype_exp = column_exp.kind
+    assert isinstance(datatype_exp, exp.DataType), 'Expected DataType expression in ColumnDef'
+
+    datatype = datatype_exp.this.value
+
+    numeric_precision = None
+    numeric_scale = None
+
+    if datatype_exp.expressions:
+        if datatype in {'DECIMAL', 'NUMERIC', 'NUMBER', 'FLOAT'}:
+            if len(datatype_exp.expressions) >= 1:
+                precision_exp = datatype_exp.expressions[0]
+                if isinstance(precision_exp, exp.Literal) and precision_exp.is_int:
+                    numeric_precision = int(precision_exp.name)
+            if len(datatype_exp.expressions) == 2:
+                scale_exp = datatype_exp.expressions[1]
+                if isinstance(scale_exp, exp.Literal) and scale_exp.is_int:
+                    numeric_scale = int(scale_exp.name)
+
+    return datatype, numeric_precision, numeric_scale
+
+def build_catalog_from_sql(sql_string: str, search_path: str = 'public') -> Catalog:
+    '''Builds a catalog from the provided SQL string without executing it in a database.'''
+
+    statements = sqlglot.parse(sql_string)
+
+    # Filter to only CREATE TABLE statements
+    statements = [stmt for stmt in statements if isinstance(stmt, exp.Create) and stmt.kind and stmt.kind.upper() == 'TABLE']
+
+    catalog = Catalog()
+
+    for statement in statements:
+        table_exp = statement.find(exp.Table)
+
+        assert table_exp is not None, 'Expected Table expression in CREATE TABLE statement'
+
+        # "CREATE TABLE <schema_name>.<table_name>" handling
+        table_name = _get_table_name(table_exp)
+        schema_name = _get_schema_name(table_exp, search_path)
+
+        # Extract other relevant information
+        column_exps: list[exp.ColumnDef] = list(statement.find_all(exp.ColumnDef))
+        '''Column definitions'''
+
+        pk_exp: exp.PrimaryKey | None = statement.find(exp.PrimaryKey)
+        '''PRIMARY KEY defined at table level, e.g., PRIMARY KEY (col1, col2)'''
+
+        fk_exps: list[exp.ForeignKey] = list(statement.find_all(exp.ForeignKey))
+        '''FOREIGN KEY defined at table level, e.g., FOREIGN KEY (col1) REFERENCES other_table(other_col)'''
+
+        fks: dict[str, tuple[str, str, str]] = {}
+        '''Mapping of foreign key column names to (schema, table, column) tuples'''
+        # NOTE: this needs to be filled in before adding columns to the catalog
+        
+        unique_exps: list[exp.UniqueColumnConstraint] = list(statement.find_all(exp.UniqueColumnConstraint))
+        '''UNIQUE constraints defined at table level, e.g., UNIQUE (col1, col2)'''
+
+        pk_col_names: set[str] = set()
+        '''Set to keep track of primary key column names'''
+
+        unique_col_names: list[set[str]] = []
+        '''List to keep track of unique constraint column name sets'''
+
+        # Process table-level Foreign Key constraints
+        for fk_exp in fk_exps:
+            fk_id_exps = fk_exp.expressions
+            fk_column_names = [_get_identifier_name(col_exp) for col_exp in fk_id_exps]
+
+            ref_exp = fk_exp.find(exp.Reference)
+            assert ref_exp is not None, 'Expected Reference expression in Foreign Key definition'
+
+            ref_schema_exp = ref_exp.this
+            assert isinstance(ref_schema_exp, exp.Schema), 'Expected Schema expression in Foreign Key reference'
+
+            ref_table_exp = ref_schema_exp.this
+            assert isinstance(ref_table_exp, exp.Table), 'Expected Table expression in Foreign Key reference'
+
+            ref_schema_name = _get_schema_name(ref_table_exp, search_path)
+            ref_table_name = _get_table_name(ref_table_exp)
+
+            ref_id_exps = ref_schema_exp.expressions
+            ref_column_names = [_get_identifier_name(col_exp) for col_exp in ref_id_exps]
+
+            # e.g. "FOREIGN KEY (tenant_id, order_id) REFERENCES orders (tenant_id, order_id)"
+            for fk_col_name, ref_col_name in zip(fk_column_names, ref_column_names):
+                fks[fk_col_name] = (ref_schema_name, ref_table_name, ref_col_name)
+
+        # Process columns
+        for column_exp in column_exps:
+            column_name = _get_column_name(column_exp)
+
+            # Primary Key handling            
+            is_pk = any(isinstance(c.kind, exp.PrimaryKeyColumnConstraint) for c in column_exp.constraints)
+            if is_pk:
+                pk_col_names.add(column_name)
+
+            # Unique handling
+            is_unique = any(isinstance(c.kind, exp.UniqueColumnConstraint) for c in column_exp.constraints)
+            if is_unique:
+                unique_col_names.append({column_name})
+
+            # Not Null handling
+            is_not_null = any(isinstance(c.kind, exp.NotNullColumnConstraint) for c in column_exp.constraints)
+
+            # Foreign Key handling
+            fk_constraint = next((c for c in column_exp.constraints if isinstance(c.kind, exp.Reference)), None)
+
+            if fk_constraint:
+                fk_reference = fk_constraint.kind
+                assert isinstance(fk_reference, exp.Reference), 'Expected Reference expression in Foreign Key constraint'
+
+                fk_schema_exp = fk_reference.this
+                assert isinstance(fk_schema_exp, exp.Schema), 'Expected Schema expression in Foreign Key constraint'
+                
+                fk_table_exp = fk_schema_exp.this
+                assert isinstance(fk_table_exp, exp.Table), 'Expected Table expression in Foreign Key constraint'
+
+                fk_schema_name = _get_schema_name(fk_table_exp, search_path)
+                fk_table_name = _get_table_name(fk_table_exp)
+
+                fk_column_exp = fk_schema_exp.expressions[0]
+                assert isinstance(fk_column_exp, exp.Identifier), 'Expected Identifier expression in Foreign Key column'
+                fk_column_name = _get_identifier_name(fk_column_exp)
+            elif column_name in fks:
+                fk_schema_name, fk_table_name, fk_column_name = fks[column_name]
+            else:
+                fk_schema_name = None
+                fk_table_name = None
+                fk_column_name = None
+
+            # Datatype handling
+            column_type, numeric_precision, numeric_scale = _extract_datatype(column_exp)
+
+            # Add column to catalog
+            catalog[schema_name][table_name].add_column(
+                name=column_name,
+                column_type=column_type,
+                real_name=column_name,
+                numeric_precision=numeric_precision,
+                numeric_scale=numeric_scale,
+                is_nullable=not is_not_null,
+                fk_schema=fk_schema_name,
+                fk_table=fk_table_name,
+                fk_column=fk_column_name)
+        
+        # Process table-level Primary Key constraint
+        if pk_exp:
+            for ordered_exp in pk_exp.expressions:
+                col_exp = ordered_exp.find(exp.Column)
+                assert col_exp is not None, 'Expected Column expression in Primary Key definition'
+                col_name = _get_column_name(col_exp)
+                pk_col_names.add(col_name)
+
+        # Process table-level Unique constraints
+        for unique_exp in unique_exps:
+            unique_schema_exp = unique_exp.this
+            assert isinstance(unique_schema_exp, exp.Schema), 'Expected Schema expression in Unique constraint'
+
+            unique_column_names = set()
+            for col_id_exp in unique_exp.expressions:
+                col_name = _get_identifier_name(col_id_exp)
+                unique_column_names.add(col_name)
+            unique_col_names.append(unique_column_names)
+
+        # Add Primary Key constraint to catalog
+        # NOTE: needs to be perfomed after all columns have been added, since PKs can be defined at both column and table level
+        assert len(pk_col_names) > 0, 'Primary Key columns should have been identified'
+        catalog[schema_name][table_name].add_unique_constraint(
+            columns=pk_col_names,
+            constraint_type=ConstraintType.PRIMARY_KEY
+        )
+
+        # Add Unique constraints to catalog
+        # NOTE: needs to be perfomed after all columns have been added, since Unique constraints can be defined at both column and table level
+        for unique_col_name_set in unique_col_names:
+            catalog[schema_name][table_name].add_unique_constraint(
+                columns=unique_col_name_set,
+                constraint_type=ConstraintType.UNIQUE
+            )
+
+    return catalog

sqlscope/catalog/catalog.py

@@ -0,0 +1,147 @@
+from .table import Table
+from .schema import Schema
+
+from dataclasses import dataclass, field
+import json
+from typing import Self
+from copy import deepcopy
+
+@dataclass
+class Catalog:
+    '''A database catalog, with schemas, tables, and columns.'''
+
+    _schemas: dict[str, Schema] = field(default_factory=dict)
+
+    def __getitem__(self, schema_name: str) -> Schema:
+        '''Gets a schema from the catalog, creating it if it does not exist.'''
+
+        if schema_name not in self._schemas:
+            self._schemas[schema_name] = Schema(schema_name)
+        return self._schemas[schema_name]
+    
+    def __setitem__(self, schema_name: str, schema: Schema) -> Schema:
+        '''Sets a schema in the catalog, replacing any existing schema with the same name.'''
+        
+        self._schemas[schema_name] = schema
+        return schema
+    
+    def has_schema(self, schema_name: str) -> bool:
+        '''Checks if a schema exists in the catalog.'''
+        
+        return schema_name in self._schemas
+    
+    def copy_table(self, schema_name: str, table_name: str, table: Table) -> Table:
+        '''Copies a table into the catalog, creating the schema if it does not exist.'''
+        
+        new_table = deepcopy(table)
+        self[schema_name][table_name] = new_table
+        
+        return new_table
+
+    def has_table(self, schema_name: str, table_name: str) -> bool:
+        '''
+            Checks if a table exists in the specified schema in the catalog.
+
+            Returns False if the schema or table do not exist.
+        '''
+
+        if not self.has_schema(schema_name):
+            return False
+        return self.__getitem__(schema_name).has_table(table_name)
+
+    def add_column(self, schema_name: str, table_name: str, column_name: str,
+                   column_type: str, numeric_precision: int | None = None, numeric_scale: int | None = None,
+                   is_nullable: bool = True,
+                   fk_schema: str | None = None, fk_table: str | None = None, fk_column: str | None = None) -> None:
+        '''Adds a column to the catalog, creating the schema and table if they do not exist.'''
+
+        self[schema_name][table_name].add_column(name=column_name,
+                                                 column_type=column_type, numeric_precision=numeric_precision, numeric_scale=numeric_scale,
+                                                 is_nullable=is_nullable,
+                                                 fk_schema=fk_schema, fk_table=fk_table, fk_column=fk_column)
+        
+    @property
+    def schema_names(self) -> set[str]:
+        '''Returns all schema names in the catalog.'''
+        return set(self._schemas.keys())
+
+    @property
+    def table_names(self) -> set[str]:
+        '''Returns all table names in the catalog, regardless of schema.'''
+
+        result = set()
+        for schema in self._schemas.values():
+            result.update(schema.table_names)
+        return result
+
+    def copy(self) -> Self:
+        '''Creates a deep copy of the catalog.'''
+        return deepcopy(self)
+    
+    def __repr__(self) -> str:
+        schemas = [schema.__repr__(1) for schema in self._schemas.values()]
+
+        result = 'Catalog('
+        for schema in schemas:
+            result += '\n' + schema
+        result += '\n)'
+
+        return result
+
+    
+    def to_dict(self) -> dict:
+        '''Converts the Catalog to a dictionary.'''
+        return {
+            'version': 1,
+            'schemas': {name: sch.to_dict() for name, sch in self._schemas.items()},
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'Catalog':
+        '''Creates a Catalog from a dictionary.'''
+        cat = cls()
+        for _, sch_data in (data.get('schemas') or {}).items():
+            sch = Schema.from_dict(sch_data)
+            cat._schemas[sch.name] = sch
+        return cat
+
+    # String-based JSON (handy for DB/blob storage)
+    def to_json(self, *, indent: int | None = 2) -> str:
+        '''Converts the Catalog to a JSON string.'''
+        return json.dumps(self.to_dict(), indent=indent)
+
+    @classmethod
+    def from_json(cls, s: str) -> 'Catalog':
+        '''Creates a Catalog from a JSON string.'''
+        return cls.from_dict(json.loads(s))
+
+    def to_sqlglot_schema(self) -> dict[str, dict[str, dict[str, str]]]:
+        '''Converts to a sqlglot-compatible catalog format.'''
+
+        result: dict[str, dict[str, dict[str, str]]] = {}
+
+        for sch_name, sch in self._schemas.items():
+            result[sch_name] = {}
+            for tbl_name, tbl in sch._tables.items():
+                if not tbl.columns:
+                    continue
+                result[sch_name][tbl_name] = {}
+                for col in tbl.columns:
+                    result[sch_name][tbl_name][col.name] = col.column_type
+            if not result[sch_name]:
+                del result[sch_name]
+
+        return result
+
+    # Convenience file helpers
+    def save_json(self, path: str, *, indent: int | None = 2) -> None:
+        '''Saves the Catalog to a JSON file.'''
+        with open(path, 'w', encoding='utf-8') as f:
+            json.dump(self.to_dict(), f, indent=indent)
+
+    @classmethod
+    def load_json(cls, path: str) -> 'Catalog':
+        '''Loads a Catalog from a JSON file.'''
+        with open(path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        return cls.from_dict(data)

sqlscope/catalog/column.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass, field
+
+@dataclass
+class Column:
+    '''A database table column, with type and constraints.'''
+
+    name: str
+    real_name: str = field(init=False)
+    table_idx: int | None = None
+    '''Index of the table in `referenced_tables`. If None, the column is not associated with a specific table in `referenced_tables`.'''
+
+    column_type: str = 'UNKNOWN'
+    numeric_precision: int | None = None
+    numeric_scale: int | None = None
+    is_nullable: bool = True
+    is_constant: bool = False
+    fk_schema: str | None = None
+    fk_table: str | None = None
+    fk_column: str | None = None
+
+    def __post_init__(self):
+        self.real_name = self.name
+
+    @property
+    def is_fk(self) -> bool:
+        '''Returns True if the column is a foreign key.'''
+        return all([self.fk_schema, self.fk_table, self.fk_column])
+
+    def __repr__(self, level: int = 0, max_col_len: int = 20) -> str:
+        indent = '  ' * level
+
+        idx_str = f'table_idx={self.table_idx}, ' if self.table_idx is not None else ''
+        return f'{indent}Column(' \
+                    f'name=\'{self.name}\',{" " * (max_col_len - len(self.name))} ' \
+                    f'real_name=\'{self.real_name}\',{" " * (max_col_len - len(self.real_name))} ' \
+                    f'{idx_str}' \
+                    f'is_fk={self.is_fk}, ' \
+                    f'is_nullable={self.is_nullable}, ' \
+                    f'is_constant={self.is_constant}, ' \
+                    f'type=\'{self.column_type}\'' \
+                f')'
+
+    def to_dict(self) -> dict:
+        '''Converts the Column to a dictionary.'''
+        return {
+            'name': self.name,
+            'column_type': self.column_type,
+            'numeric_precision': self.numeric_precision,
+            'numeric_scale': self.numeric_scale,
+            'is_nullable': self.is_nullable,
+            'fk_schema': self.fk_schema,
+            'fk_table': self.fk_table,
+            'fk_column': self.fk_column,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> 'Column':
+        '''Creates a Column from a dictionary.'''
+        return cls(
+            name=data['name'],
+            column_type=data['column_type'],
+            numeric_precision=data.get('numeric_precision'),
+            numeric_scale=data.get('numeric_scale'),
+            is_nullable=data.get('is_nullable', True),
+            fk_schema=(data.get('fk_schema') or None),
+            fk_table=(data.get('fk_table') or None),
+            fk_column=(data.get('fk_column') or None),
+        )