sqlmeta.comparison.comparator

SQL Object Comparator for Drift Detection.

This module provides the ObjectComparator class which compares SQL Model objects from different sources (parsed scripts vs. database introspection) and generates structured diff results.

Key Features: - Compare tables, views, procedures, triggers, sequences - Detect missing, extra, and modified objects - Type-aware comparison using DataTypeNormalizer - Generate structured diff results - Handle case sensitivity and identifier normalization

Classes

ObjectComparator(type_normalizer)

Compares SQL Model objects and generates diff results.

class sqlmeta.comparison.comparator.ObjectComparator(type_normalizer: DataTypeNormalizer)

Compares SQL Model objects and generates diff results.

This class provides methods to compare SQL objects from different sources (e.g., parsed SQL scripts vs. database metadata) and identify differences.

Example

>>> normalizer = DataTypeNormalizer()
>>> comparator = ObjectComparator(normalizer)
>>> diff = comparator.compare_tables(script_table, db_table, "postgresql")
>>> if diff.has_diffs:
...     print(f"Found differences: {diff}")

__init__(type_normalizer: DataTypeNormalizer)

Initialize the object comparator.

Parameters:

type_normalizer – DataTypeNormalizer for type comparison

compare_tables(expected: Table, actual: Table, dialect: str = 'postgresql') → TableDiff

Compare two table objects.

Parameters:

• expected – Expected table (from scripts)

• actual – Actual table (from database)

• dialect – SQL dialect for type normalization

Returns:

TableDiff object with comparison results

Example

>>> diff = comparator.compare_tables(script_table, db_table, "postgresql")
>>> print(f"Missing columns: {diff.missing_columns}")

compare_schemas(expected_tables: List[Table], actual_tables: List[Table], dialect: str = 'postgresql', schema_name: str = 'public') → SchemaDiff

Compare lists of tables from two schemas.

Parameters:

• expected_tables – Expected tables (from scripts)

• actual_tables – Actual tables (from database)

• dialect – SQL dialect for type normalization

• schema_name – Name of the schema being compared

Returns:

SchemaDiff object with comparison results

compare_views(expected: View, actual: View, dialect: str = 'postgresql') → ViewDiff | None

Compare two view objects.

Parameters:

• expected – Expected view from migrations

• actual – Actual view from database

• dialect – SQL dialect

Returns:

ViewDiff if differences found, None otherwise

compare_indexes(expected: Index, actual: Index, dialect: str = 'postgresql') → IndexDiff | None

Compare two index objects.

Parameters:

• expected – Expected index from migrations

• actual – Actual index from database

• dialect – SQL dialect

Returns:

IndexDiff if differences found, None otherwise

compare_sequences(expected: Sequence, actual: Sequence, dialect: str = 'postgresql') → SequenceDiff | None

Compare two sequence objects.

Parameters:

• expected – Expected sequence from migrations

• actual – Actual sequence from database

• dialect – SQL dialect

Returns:

SequenceDiff if differences found, None otherwise

compare_triggers(expected: Trigger, actual: Trigger, dialect: str = 'postgresql') → TriggerDiff | None

Compare two trigger objects.

Parameters:

• expected – Expected trigger from migrations

• actual – Actual trigger from database

• dialect – SQL dialect

Returns:

TriggerDiff if differences found, None otherwise

compare_procedures(expected: Procedure, actual: Procedure, dialect: str = 'postgresql') → ProcedureDiff | None

Compare two procedure objects.

Parameters:

• expected – Expected procedure from migrations

• actual – Actual procedure from database

• dialect – SQL dialect

Returns:

ProcedureDiff if differences found, None otherwise

compare_functions(expected: Procedure, actual: Procedure, dialect: str = 'postgresql') → FunctionDiff | None

Compare two function objects (Procedure with is_function=True).

Parameters:

• expected – Expected function from migrations (Procedure with is_function=True)

• actual – Actual function from database (Procedure with is_function=True)

• dialect – SQL dialect

Returns:

FunctionDiff if differences found, None otherwise

compare_synonyms(expected: Synonym, actual: Synonym, dialect: str = 'postgresql') → SynonymDiff | None

Compare two synonym objects.

Parameters:

• expected – Expected synonym from migrations

• actual – Actual synonym from database

• dialect – SQL dialect

Returns:

SynonymDiff if differences found, None otherwise

compare_user_defined_types(expected: UserDefinedType, actual: UserDefinedType, dialect: str = 'postgresql') → UserDefinedTypeDiff | None

Compare two user-defined type objects.

Parameters:

• expected – Expected UDT from migrations

• actual – Actual UDT from database

• dialect – SQL dialect

Returns:

UserDefinedTypeDiff if differences found, None otherwise

compare_packages(expected: Package, actual: Package, dialect: str = 'oracle') → PackageDiff | None

Compare two package objects (Oracle).

Parameters:

• expected – Expected package from migrations

• actual – Actual package from database

• dialect – SQL dialect (typically oracle)

Returns:

PackageDiff if differences found, None otherwise

compare_extensions(expected: Extension, actual: Extension, dialect: str = 'postgresql') → ExtensionDiff | None

Compare two extension objects (PostgreSQL).

Parameters:

• expected – Expected extension from migrations

• actual – Actual extension from database

• dialect – SQL dialect (typically postgresql)

Returns:

ExtensionDiff if differences found, None otherwise

compare_events(expected: Event, actual: Event, dialect: str = 'mysql') → EventDiff | None

Compare two event objects (MySQL).

Parameters:

• expected – Expected event from migrations

• actual – Actual event from database

• dialect – SQL dialect (typically mysql)

Returns:

EventDiff if differences found, None otherwise

compare_database_links(expected: DatabaseLink, actual: DatabaseLink, dialect: str = 'oracle') → DatabaseLinkDiff | None

Compare two database link objects (Oracle).

Parameters:

• expected – Expected database link from migrations

• actual – Actual database link from database

• dialect – SQL dialect (typically oracle)

Returns:

DatabaseLinkDiff if differences found, None otherwise

compare_linked_servers(expected: LinkedServer, actual: LinkedServer, dialect: str = 'sqlserver') → LinkedServerDiff | None

Compare two linked server objects (SQL Server).

Parameters:

• expected – Expected linked server from migrations

• actual – Actual linked server from database

• dialect – SQL dialect (typically sqlserver)

Returns:

LinkedServerDiff if differences found, None otherwise

compare_foreign_data_wrappers(expected: ForeignDataWrapper, actual: ForeignDataWrapper, dialect: str = 'postgresql') → ForeignDataWrapperDiff | None

Compare two foreign data wrapper objects (PostgreSQL).

Parameters:

• expected – Expected FDW from migrations

• actual – Actual FDW from database

• dialect – SQL dialect (typically postgresql)

Returns:

ForeignDataWrapperDiff if differences found, None otherwise

compare_foreign_servers(expected: ForeignServer, actual: ForeignServer, dialect: str = 'postgresql') → ForeignServerDiff | None

Compare two foreign server objects (PostgreSQL).

Parameters:

• expected – Expected foreign server from migrations

• actual – Actual foreign server from database

• dialect – SQL dialect (typically postgresql)

Returns:

ForeignServerDiff if differences found, None otherwise

compare_modules(expected: Module, actual: Module, dialect: str = 'db2') → ModuleDiff | None

Compare two DB2 module objects.

Parameters:

• expected – Expected module from migrations

• actual – Actual module from database

• dialect – SQL dialect (typically db2)

Returns:

ModuleDiff if differences found, None otherwise