drizzle_migrations/

generate.rs

//! Programmatic migration generation API.
//!
//! Diff two schema snapshots and get SQL statements — no file I/O, no CLI needed.
//!
//! # Snapshot-to-snapshot example
//!
//! ```rust
//! use drizzle_migrations::{Snapshot, diff};
//!
//! let prev = Snapshot::empty(drizzle_types::Dialect::SQLite);
//! let current = Snapshot::empty(drizzle_types::Dialect::SQLite);
//! let migration = diff(&prev, &current).unwrap();
//! assert!(migration.is_empty());
//! ```
//!
//! # Schema-to-schema example (recommended for runtime generation)
//!
//! ```rust,no_run
//! use drizzle_migrations::{DiffOptions, diff_schemas_with};
//! use drizzle_migrations::{Schema, Snapshot};
//! use drizzle_types::Dialect;
//!
//! # #[derive(Default)]
//! # struct V1;
//! # #[derive(Default)]
//! # struct V2;
//! # impl Schema for V1 {
//! #     fn to_snapshot(&self) -> Snapshot { Snapshot::empty(Dialect::SQLite) }
//! #     fn dialect(&self) -> Dialect { Dialect::SQLite }
//! # }
//! # impl Schema for V2 {
//! #     fn to_snapshot(&self) -> Snapshot { Snapshot::empty(Dialect::SQLite) }
//! #     fn dialect(&self) -> Dialect { Dialect::SQLite }
//! # }
//!
//! let generated = diff_schemas_with(
//!     &V1,
//!     &V2,
//!     &DiffOptions::new()
//!         .rename_table("users_old", "users")
//!         .rename_column("users", "full_name", "name")
//!         .strict_renames(true),
//! )?;
//!
//! if !generated.is_empty() {
//!     let _sql = generated.to_sql();
//! }
//! # Ok::<(), drizzle_migrations::MigrationError>(())
//! ```

use crate::postgres::collection::PostgresDDL;
use crate::schema::{Schema, Snapshot};
use crate::sqlite::collection::SQLiteDDL;
use crate::version::ORIGIN_UUID;
use crate::writer::MigrationError;
use std::borrow::Cow;
use std::io::{self, Write};

/// Generated migration payload.
#[derive(Clone, Debug)]
pub struct Plan {
    /// SQL statements for the migration.
    pub statements: Vec<String>,
    /// Warning messages emitted while planning the migration.
    pub warnings: Vec<String>,
    /// Schema snapshot after this migration is applied.
    pub snapshot: Snapshot,
}

impl Plan {
    /// Returns true when there are no executable SQL statements.
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.statements.is_empty()
            || self
                .statements
                .iter()
                .all(|statement| statement.trim().is_empty())
    }

    /// Format statements with `--> statement-breakpoint` markers.
    #[must_use]
    pub fn to_sql(&self) -> String {
        self.statements.join("\n--> statement-breakpoint\n")
    }

    /// Write formatted migration SQL to a writer.
    ///
    /// # Errors
    ///
    /// Returns the underlying [`io::Error`] if writing to `writer` fails.
    pub fn write(&self, writer: impl Write) -> io::Result<()> {
        let mut writer = writer;
        writer.write_all(self.to_sql().as_bytes())
    }
}

/// Explicit rename hints used during migration generation.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct RenameHints {
    /// PostgreSQL schema rename hints.
    pub schema_renames: Vec<SchemaRenameHint>,
    /// Table rename hints.
    pub table_renames: Vec<TableRenameHint>,
    /// Column rename hints.
    pub column_renames: Vec<ColumnRenameHint>,
}

impl RenameHints {
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    #[must_use]
    pub fn rename_schema(mut self, from: impl Into<String>, to: impl Into<String>) -> Self {
        self.schema_renames.push(SchemaRenameHint {
            from: from.into(),
            to: to.into(),
        });
        self
    }

    #[must_use]
    pub fn rename_table(mut self, from: impl Into<String>, to: impl Into<String>) -> Self {
        self.table_renames.push(TableRenameHint {
            schema: None,
            from: from.into(),
            to: to.into(),
        });
        self
    }

    #[must_use]
    pub fn rename_table_in(
        mut self,
        schema: impl Into<String>,
        from: impl Into<String>,
        to: impl Into<String>,
    ) -> Self {
        self.table_renames.push(TableRenameHint {
            schema: Some(schema.into()),
            from: from.into(),
            to: to.into(),
        });
        self
    }

    #[must_use]
    pub fn rename_column(
        mut self,
        table: impl Into<String>,
        from: impl Into<String>,
        to: impl Into<String>,
    ) -> Self {
        self.column_renames.push(ColumnRenameHint {
            schema: None,
            table: table.into(),
            from: from.into(),
            to: to.into(),
        });
        self
    }

    #[must_use]
    pub fn rename_column_in(
        mut self,
        schema: impl Into<String>,
        table: impl Into<String>,
        from: impl Into<String>,
        to: impl Into<String>,
    ) -> Self {
        self.column_renames.push(ColumnRenameHint {
            schema: Some(schema.into()),
            table: table.into(),
            from: from.into(),
            to: to.into(),
        });
        self
    }
}

/// PostgreSQL schema rename hint.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SchemaRenameHint {
    /// Current schema name.
    pub from: String,
    /// New schema name.
    pub to: String,
}

/// Table rename hint.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TableRenameHint {
    /// Optional schema (`PostgreSQL` only). If omitted, defaults to `public`.
    pub schema: Option<String>,
    /// Current table name.
    pub from: String,
    /// New table name.
    pub to: String,
}

/// Column rename hint.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ColumnRenameHint {
    /// Optional schema (`PostgreSQL` only). If omitted, defaults to `public`.
    pub schema: Option<String>,
    /// Table containing the column.
    pub table: String,
    /// Current column name.
    pub from: String,
    /// New column name.
    pub to: String,
}

/// Generation options for [`diff_with`] and [`diff_schemas_with`].
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct DiffOptions {
    /// Explicit rename hints applied before heuristic diffing.
    pub renames: RenameHints,
    /// If true, every hint must apply; otherwise generation fails.
    pub strict_renames: bool,
    /// Typed data movement for SQLite table rebuilds, bound to the exact
    /// predecessor snapshot.
    pub sqlite_rebuild_data: Option<crate::sqlite::SqliteRebuildDataPlanRegistry>,
}

impl DiffOptions {
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    #[must_use]
    pub fn with_renames(mut self, renames: RenameHints) -> Self {
        self.renames = renames;
        self
    }

    #[must_use]
    pub const fn strict_renames(mut self, strict: bool) -> Self {
        self.strict_renames = strict;
        self
    }

    #[must_use]
    pub fn sqlite_rebuild_data(mut self, plan: crate::sqlite::SqliteRebuildDataPlan) -> Self {
        self.sqlite_rebuild_data = Some(crate::sqlite::SqliteRebuildDataPlanRegistry::single(plan));
        self
    }

    #[must_use]
    pub fn sqlite_rebuild_data_registry(
        mut self,
        registry: crate::sqlite::SqliteRebuildDataPlanRegistry,
    ) -> Self {
        self.sqlite_rebuild_data = Some(registry);
        self
    }

    #[must_use]
    pub fn rename_schema(mut self, from: impl Into<String>, to: impl Into<String>) -> Self {
        self.renames = self.renames.rename_schema(from, to);
        self
    }

    #[must_use]
    pub fn rename_table(mut self, from: impl Into<String>, to: impl Into<String>) -> Self {
        self.renames = self.renames.rename_table(from, to);
        self
    }

    #[must_use]
    pub fn rename_table_in(
        mut self,
        schema: impl Into<String>,
        from: impl Into<String>,
        to: impl Into<String>,
    ) -> Self {
        self.renames = self.renames.rename_table_in(schema, from, to);
        self
    }

    #[must_use]
    pub fn rename_column(
        mut self,
        table: impl Into<String>,
        from: impl Into<String>,
        to: impl Into<String>,
    ) -> Self {
        self.renames = self.renames.rename_column(table, from, to);
        self
    }

    #[must_use]
    pub fn rename_column_in(
        mut self,
        schema: impl Into<String>,
        table: impl Into<String>,
        from: impl Into<String>,
        to: impl Into<String>,
    ) -> Self {
        self.renames = self.renames.rename_column_in(schema, table, from, to);
        self
    }
}

/// Diff two snapshots and return the migration SQL statements.
///
/// Both snapshots must be for the same dialect (e.g., both `SQLite` or both `PostgreSQL`).
/// Returns `Ok(vec![])` if no changes are detected.
///
/// This is a pure function — no file I/O, no side effects.
///
/// For writing tagged migration directories (`./drizzle/<tag>/...`), prefer
/// [`crate::build::run`].
///
/// # Errors
///
/// Returns [`MigrationError::DialectMismatch`] if the two snapshots use
/// different dialects, or a [`MigrationError::ConfigError`] if applying
/// rename hints fails under strict mode.
pub fn diff(prev: &Snapshot, current: &Snapshot) -> Result<Plan, MigrationError> {
    diff_with(prev, current, &DiffOptions::default())
}

/// Diff two snapshots with explicit generation options.
///
/// Use this when you need rename hints (table/column renames) to avoid
/// drop-and-recreate diffs.
///
/// # Errors
///
/// Returns [`MigrationError::DialectMismatch`] if the two snapshots use
/// different dialects, or a [`MigrationError::ConfigError`] if applying
/// rename hints fails under strict mode.
pub fn diff_with(
    prev: &Snapshot,
    current: &Snapshot,
    options: &DiffOptions,
) -> Result<Plan, MigrationError> {
    let (statements, warnings) = match (prev, current) {
        (Snapshot::Sqlite(p), Snapshot::Sqlite(c)) => {
            let mut prev_ddl = SQLiteDDL::from_entities(p.ddl.clone());
            let cur_ddl = crate::sqlite::collection::SQLiteDDL::from_entities(c.ddl.clone());
            let mut statements = apply_sqlite_rename_hints(&mut prev_ddl, &cur_ddl, options)?;
            let mut diff = crate::sqlite::diff::compute_migration(&prev_ddl, &cur_ddl);
            crate::sqlite::rebuild_data::apply_rebuild_data_plan(
                prev.id(),
                &prev_ddl,
                &cur_ddl,
                &mut diff.statements,
                options.sqlite_rebuild_data.as_ref(),
            )
            .map_err(MigrationError::ConfigError)?;
            diff.sql_statements =
                crate::sqlite::statements::from_json(diff.statements.clone()).sql_statements;
            statements.extend(diff.sql_statements);
            (statements, diff.warnings)
        }
        (Snapshot::Postgres(p), Snapshot::Postgres(c)) => {
            if options.sqlite_rebuild_data.is_some() {
                return Err(MigrationError::ConfigError(
                    "SQLite rebuild-data plan cannot be used for a PostgreSQL migration"
                        .to_string(),
                ));
            }
            let mut prev_ddl = PostgresDDL::from_entities(p.ddl.clone());
            let cur_ddl = PostgresDDL::from_entities(c.ddl.clone());
            let mut statements = apply_postgres_rename_hints(&mut prev_ddl, &cur_ddl, options)?;
            let diff = crate::postgres::diff::compute_migration(&prev_ddl, &cur_ddl);
            statements.extend(diff.sql_statements);
            (statements, diff.warnings)
        }
        _ => return Err(MigrationError::DialectMismatch),
    };

    // Link the produced snapshot into the chain: it succeeds `prev`. A fresh
    // empty baseline (no entities, still pointing at the origin) keeps the
    // origin marker instead of adopting the baseline's throwaway id.
    let mut snapshot = current.clone();
    let prev_is_origin_baseline =
        prev.is_empty() && matches!(prev.prev_ids(), [only] if only == ORIGIN_UUID);
    if prev_is_origin_baseline {
        snapshot.set_prev_ids(vec![ORIGIN_UUID.to_string()]);
    } else {
        snapshot.set_prev_ids(vec![prev.id().to_string()]);
    }

    Ok(Plan {
        statements,
        warnings,
        snapshot,
    })
}

/// Generate migration SQL from two schema values implementing [`Schema`].
///
/// This is usually the best runtime API when you already have two schema types.
///
/// # Errors
///
/// Returns [`MigrationError::DialectMismatch`] if the two schemas use
/// different dialects.
pub fn diff_schemas<From: Schema, To: Schema>(
    prev: &From,
    current: &To,
) -> Result<Plan, MigrationError> {
    let prev = prev.to_snapshot();
    let current = current.to_snapshot();
    diff(&prev, &current)
}

/// Generate migration SQL from two schemas with generation options.
///
/// # Example
///
/// ```rust,no_run
/// use drizzle_migrations::{DiffOptions, Schema, Snapshot, diff_schemas_with};
/// use drizzle_types::Dialect;
///
/// # #[derive(Default)]
/// # struct FromSchema;
/// # #[derive(Default)]
/// # struct ToSchema;
/// # impl Schema for FromSchema {
/// #     fn to_snapshot(&self) -> Snapshot { Snapshot::empty(Dialect::SQLite) }
/// #     fn dialect(&self) -> Dialect { Dialect::SQLite }
/// # }
/// # impl Schema for ToSchema {
/// #     fn to_snapshot(&self) -> Snapshot { Snapshot::empty(Dialect::SQLite) }
/// #     fn dialect(&self) -> Dialect { Dialect::SQLite }
/// # }
/// let migration = diff_schemas_with(
///     &FromSchema,
///     &ToSchema,
///     &DiffOptions::new().rename_column("users", "displayName", "display_name"),
/// )?;
/// # let _ = migration;
/// # Ok::<(), drizzle_migrations::MigrationError>(())
/// ```
///
/// # Errors
///
/// Returns [`MigrationError::DialectMismatch`] if the two schemas use
/// different dialects, or a [`MigrationError::ConfigError`] if applying
/// rename hints fails under strict mode.
pub fn diff_schemas_with<From: Schema, To: Schema>(
    prev: &From,
    current: &To,
    options: &DiffOptions,
) -> Result<Plan, MigrationError> {
    let prev = prev.to_snapshot();
    let current = current.to_snapshot();
    diff_with(&prev, &current, options)
}

fn apply_sqlite_rename_hints(
    prev: &mut SQLiteDDL,
    cur: &SQLiteDDL,
    options: &DiffOptions,
) -> Result<Vec<String>, MigrationError> {
    let mut statements = Vec::new();

    if !options.renames.schema_renames.is_empty() && options.strict_renames {
        return Err(MigrationError::ConfigError(
            "sqlite rename_schema hint is not supported".to_string(),
        ));
    }

    for hint in &options.renames.table_renames {
        if hint.schema.is_some() {
            if options.strict_renames {
                return Err(MigrationError::ConfigError(
                    "sqlite rename_table hint does not support schema".to_string(),
                ));
            }
            continue;
        }

        if !valid_rename_name(&hint.from) || !valid_rename_name(&hint.to) || hint.from == hint.to {
            if options.strict_renames {
                return Err(MigrationError::ConfigError(format!(
                    "invalid sqlite table rename hint: {} -> {}",
                    hint.from, hint.to
                )));
            }
            continue;
        }

        let can_apply = prev.tables.one(&hint.from).is_some()
            && cur.tables.one(&hint.to).is_some()
            && prev.tables.one(&hint.to).is_none();

        if !can_apply {
            if options.strict_renames {
                return Err(MigrationError::ConfigError(format!(
                    "sqlite table rename hint did not match snapshots: {} -> {}",
                    hint.from, hint.to
                )));
            }
            continue;
        }

        statements.push(format!(
            "ALTER TABLE `{}` RENAME TO `{}`;",
            hint.from, hint.to
        ));
        apply_sqlite_table_rename(prev, &hint.from, &hint.to);
    }

    for hint in &options.renames.column_renames {
        if hint.schema.is_some() {
            if options.strict_renames {
                return Err(MigrationError::ConfigError(
                    "sqlite rename_column hint does not support schema".to_string(),
                ));
            }
            continue;
        }

        if !valid_rename_name(&hint.table)
            || !valid_rename_name(&hint.from)
            || !valid_rename_name(&hint.to)
            || hint.from == hint.to
        {
            if options.strict_renames {
                return Err(MigrationError::ConfigError(format!(
                    "invalid sqlite column rename hint: {}.{} -> {}",
                    hint.table, hint.from, hint.to
                )));
            }
            continue;
        }

        let can_apply = prev.columns.one(&hint.table, &hint.from).is_some()
            && cur.columns.one(&hint.table, &hint.to).is_some()
            && prev.columns.one(&hint.table, &hint.to).is_none();

        if !can_apply {
            if options.strict_renames {
                return Err(MigrationError::ConfigError(format!(
                    "sqlite column rename hint did not match snapshots: {}.{} -> {}",
                    hint.table, hint.from, hint.to
                )));
            }
            continue;
        }

        statements.push(format!(
            "ALTER TABLE `{}` RENAME COLUMN `{}` TO `{}`;",
            hint.table, hint.from, hint.to
        ));
        apply_sqlite_column_rename(prev, &hint.table, &hint.from, &hint.to);
    }

    Ok(statements)
}

fn apply_postgres_rename_hints(
    prev: &mut PostgresDDL,
    cur: &PostgresDDL,
    options: &DiffOptions,
) -> Result<Vec<String>, MigrationError> {
    let mut statements = Vec::new();

    for hint in &options.renames.schema_renames {
        if !valid_rename_name(&hint.from) || !valid_rename_name(&hint.to) || hint.from == hint.to {
            if options.strict_renames {
                return Err(MigrationError::ConfigError(format!(
                    "invalid postgres schema rename hint: {} -> {}",
                    hint.from, hint.to
                )));
            }
            continue;
        }

        let can_apply = prev.schemas.one(&hint.from).is_some()
            && cur.schemas.one(&hint.to).is_some()
            && prev.schemas.one(&hint.to).is_none();

        if !can_apply {
            if options.strict_renames {
                return Err(MigrationError::ConfigError(format!(
                    "postgres schema rename hint did not match snapshots: {} -> {}",
                    hint.from, hint.to
                )));
            }
            continue;
        }

        statements.push(format!(
            "ALTER SCHEMA \"{}\" RENAME TO \"{}\";",
            hint.from, hint.to
        ));
        apply_postgres_schema_rename(prev, &hint.from, &hint.to);
    }

    for hint in &options.renames.table_renames {
        let schema = hint.schema.as_deref().unwrap_or("public");
        if !valid_rename_name(schema)
            || !valid_rename_name(&hint.from)
            || !valid_rename_name(&hint.to)
            || hint.from == hint.to
        {
            if options.strict_renames {
                return Err(MigrationError::ConfigError(format!(
                    "invalid postgres table rename hint: {}.{} -> {}",
                    schema, hint.from, hint.to
                )));
            }
            continue;
        }

        let can_apply = prev.tables.one(schema, &hint.from).is_some()
            && cur.tables.one(schema, &hint.to).is_some()
            && prev.tables.one(schema, &hint.to).is_none();

        if !can_apply {
            if options.strict_renames {
                return Err(MigrationError::ConfigError(format!(
                    "postgres table rename hint did not match snapshots: {}.{} -> {}",
                    schema, hint.from, hint.to
                )));
            }
            continue;
        }

        statements.push(format!(
            "ALTER TABLE \"{}\".\"{}\" RENAME TO \"{}\";",
            schema, hint.from, hint.to
        ));
        apply_postgres_table_rename(prev, schema, &hint.from, &hint.to);
    }

    for hint in &options.renames.column_renames {
        let schema = hint.schema.as_deref().unwrap_or("public");
        if !valid_rename_name(schema)
            || !valid_rename_name(&hint.table)
            || !valid_rename_name(&hint.from)
            || !valid_rename_name(&hint.to)
            || hint.from == hint.to
        {
            if options.strict_renames {
                return Err(MigrationError::ConfigError(format!(
                    "invalid postgres column rename hint: {}.{}.{} -> {}",
                    schema, hint.table, hint.from, hint.to
                )));
            }
            continue;
        }

        let can_apply = prev.columns.one(schema, &hint.table, &hint.from).is_some()
            && cur.columns.one(schema, &hint.table, &hint.to).is_some()
            && prev.columns.one(schema, &hint.table, &hint.to).is_none();

        if !can_apply {
            if options.strict_renames {
                return Err(MigrationError::ConfigError(format!(
                    "postgres column rename hint did not match snapshots: {}.{}.{} -> {}",
                    schema, hint.table, hint.from, hint.to
                )));
            }
            continue;
        }

        statements.push(format!(
            "ALTER TABLE \"{}\".\"{}\" RENAME COLUMN \"{}\" TO \"{}\";",
            schema, hint.table, hint.from, hint.to
        ));
        apply_postgres_column_rename(prev, schema, &hint.table, &hint.from, &hint.to);
    }

    Ok(statements)
}

fn apply_sqlite_table_rename(ddl: &mut SQLiteDDL, from: &str, to: &str) {
    let to = to.to_string();

    if let Some(t) = ddl
        .tables
        .list_mut()
        .iter_mut()
        .find(|t| t.name.as_ref() == from)
    {
        t.name = to.clone().into();
    }

    for c in ddl
        .columns
        .list_mut()
        .iter_mut()
        .filter(|c| c.table.as_ref() == from)
    {
        c.table = to.clone().into();
    }

    for pk in ddl
        .pks
        .list_mut()
        .iter_mut()
        .filter(|pk| pk.table.as_ref() == from)
    {
        pk.table = to.clone().into();
    }

    for u in ddl
        .uniques
        .list_mut()
        .iter_mut()
        .filter(|u| u.table.as_ref() == from)
    {
        u.table = to.clone().into();
    }

    for fk in ddl.fks.list_mut().iter_mut() {
        if fk.table.as_ref() == from {
            fk.table = to.clone().into();
        }
        if fk.table_to.as_ref() == from {
            fk.table_to = to.clone().into();
        }
    }

    for idx in ddl
        .indexes
        .list_mut()
        .iter_mut()
        .filter(|i| i.table.as_ref() == from)
    {
        idx.table = to.clone().into();
    }

    for chk in ddl
        .checks
        .list_mut()
        .iter_mut()
        .filter(|c| c.table.as_ref() == from)
    {
        chk.table = to.clone().into();
    }
}

fn apply_sqlite_column_rename(ddl: &mut SQLiteDDL, table: &str, from: &str, to: &str) {
    let to = to.to_string();

    if let Some(c) = ddl
        .columns
        .list_mut()
        .iter_mut()
        .find(|c| c.table.as_ref() == table && c.name.as_ref() == from)
    {
        c.name = to.clone().into();
    }

    for pk in ddl
        .pks
        .list_mut()
        .iter_mut()
        .filter(|pk| pk.table.as_ref() == table)
    {
        for col in pk.columns.to_mut().iter_mut() {
            if col.as_ref() == from {
                *col = to.clone().into();
            }
        }
    }

    for u in ddl
        .uniques
        .list_mut()
        .iter_mut()
        .filter(|u| u.table.as_ref() == table)
    {
        for col in u.columns.to_mut().iter_mut() {
            if col.as_ref() == from {
                *col = to.clone().into();
            }
        }
    }

    for fk in ddl.fks.list_mut().iter_mut() {
        if fk.table.as_ref() == table {
            for col in fk.columns.to_mut().iter_mut() {
                if col.as_ref() == from {
                    *col = to.clone().into();
                }
            }
        }
        if fk.table_to.as_ref() == table {
            for col in fk.columns_to.to_mut().iter_mut() {
                if col.as_ref() == from {
                    *col = to.clone().into();
                }
            }
        }
    }

    for idx in ddl
        .indexes
        .list_mut()
        .iter_mut()
        .filter(|i| i.table.as_ref() == table)
    {
        for col in &mut idx.columns {
            if !col.is_expression && col.value.as_ref() == from {
                col.value = to.clone().into();
            }
        }
    }
}

fn rewrite_cow(value: &mut Cow<'static, str>, from: &str, to: &str) {
    if value.as_ref() == from {
        *value = to.to_string().into();
    }
}

fn rewrite_optional_cow(value: &mut Option<Cow<'static, str>>, from: &str, to: &str) {
    if value.as_deref() == Some(from) {
        *value = Some(to.to_string().into());
    }
}

fn rewrite_schema_qualified_value(value: &mut Option<Cow<'static, str>>, from: &str, to: &str) {
    let Some(current) = value.as_deref() else {
        return;
    };
    let Some(rest) = current
        .strip_prefix(from)
        .and_then(|rest| rest.strip_prefix('.'))
    else {
        return;
    };
    *value = Some(format!("{to}.{rest}").into());
}

fn apply_postgres_schema_rename(ddl: &mut PostgresDDL, from: &str, to: &str) {
    for schema in ddl.schemas.list_mut() {
        rewrite_cow(&mut schema.name, from, to);
    }

    for table in ddl.tables.list_mut() {
        rewrite_cow(&mut table.schema, from, to);
        rewrite_schema_qualified_value(&mut table.inherits, from, to);
    }

    for column in ddl.columns.list_mut() {
        rewrite_cow(&mut column.schema, from, to);
        rewrite_optional_cow(&mut column.type_schema, from, to);
        if let Some(identity) = &mut column.identity {
            rewrite_optional_cow(&mut identity.schema, from, to);
        }
    }

    for index in ddl.indexes.list_mut() {
        rewrite_cow(&mut index.schema, from, to);
    }

    for fk in ddl.fks.list_mut() {
        rewrite_cow(&mut fk.schema, from, to);
        rewrite_cow(&mut fk.schema_to, from, to);
    }

    for pk in ddl.pks.list_mut() {
        rewrite_cow(&mut pk.schema, from, to);
    }

    for unique in ddl.uniques.list_mut() {
        rewrite_cow(&mut unique.schema, from, to);
    }

    for check in ddl.checks.list_mut() {
        rewrite_cow(&mut check.schema, from, to);
    }

    for policy in ddl.policies.list_mut() {
        rewrite_cow(&mut policy.schema, from, to);
    }

    for enum_ in ddl.enums.list_mut() {
        rewrite_cow(&mut enum_.schema, from, to);
    }

    for sequence in ddl.sequences.list_mut() {
        rewrite_cow(&mut sequence.schema, from, to);
    }

    for view in ddl.views.list_mut() {
        rewrite_cow(&mut view.schema, from, to);
    }
}

fn apply_postgres_table_rename(ddl: &mut PostgresDDL, schema: &str, from: &str, to: &str) {
    let to = to.to_string();

    for table in ddl.tables.list_mut() {
        if table.schema.as_ref() == schema && table.name.as_ref() == from {
            table.name = to.clone().into();
        }

        if table.schema.as_ref() == schema
            && let Some(inherits) = &mut table.inherits
        {
            if inherits.as_ref() == from {
                *inherits = to.clone().into();
            } else if inherits.as_ref() == format!("{schema}.{from}") {
                *inherits = format!("{schema}.{to}").into();
            }
        }
    }

    for c in ddl
        .columns
        .list_mut()
        .iter_mut()
        .filter(|c| c.schema.as_ref() == schema && c.table.as_ref() == from)
    {
        c.table = to.clone().into();
    }

    for pk in ddl
        .pks
        .list_mut()
        .iter_mut()
        .filter(|pk| pk.schema.as_ref() == schema && pk.table.as_ref() == from)
    {
        pk.table = to.clone().into();
    }

    for u in ddl
        .uniques
        .list_mut()
        .iter_mut()
        .filter(|u| u.schema.as_ref() == schema && u.table.as_ref() == from)
    {
        u.table = to.clone().into();
    }

    for fk in ddl.fks.list_mut().iter_mut() {
        if fk.schema.as_ref() == schema && fk.table.as_ref() == from {
            fk.table = to.clone().into();
        }
        if fk.schema_to.as_ref() == schema && fk.table_to.as_ref() == from {
            fk.table_to = to.clone().into();
        }
    }

    for idx in ddl
        .indexes
        .list_mut()
        .iter_mut()
        .filter(|i| i.schema.as_ref() == schema && i.table.as_ref() == from)
    {
        idx.table = to.clone().into();
    }

    for chk in ddl
        .checks
        .list_mut()
        .iter_mut()
        .filter(|c| c.schema.as_ref() == schema && c.table.as_ref() == from)
    {
        chk.table = to.clone().into();
    }

    for policy in ddl
        .policies
        .list_mut()
        .iter_mut()
        .filter(|p| p.schema.as_ref() == schema && p.table.as_ref() == from)
    {
        policy.table = to.clone().into();
    }
}

fn apply_postgres_column_rename(
    ddl: &mut PostgresDDL,
    schema: &str,
    table: &str,
    from: &str,
    to: &str,
) {
    let to = to.to_string();

    for c in ddl.columns.list_mut().iter_mut() {
        if c.schema.as_ref() == schema && c.table.as_ref() == table && c.name.as_ref() == from {
            c.name = to.clone().into();
        }
    }

    for pk in ddl
        .pks
        .list_mut()
        .iter_mut()
        .filter(|p| p.schema.as_ref() == schema && p.table.as_ref() == table)
    {
        for col in pk.columns.to_mut().iter_mut() {
            if col.as_ref() == from {
                *col = to.clone().into();
            }
        }
    }

    for u in ddl
        .uniques
        .list_mut()
        .iter_mut()
        .filter(|u| u.schema.as_ref() == schema && u.table.as_ref() == table)
    {
        for col in u.columns.to_mut().iter_mut() {
            if col.as_ref() == from {
                *col = to.clone().into();
            }
        }
    }

    for fk in ddl.fks.list_mut().iter_mut() {
        if fk.schema.as_ref() == schema && fk.table.as_ref() == table {
            for col in fk.columns.to_mut().iter_mut() {
                if col.as_ref() == from {
                    *col = to.clone().into();
                }
            }
        }
        if fk.schema_to.as_ref() == schema && fk.table_to.as_ref() == table {
            for col in fk.columns_to.to_mut().iter_mut() {
                if col.as_ref() == from {
                    *col = to.clone().into();
                }
            }
        }
    }

    for idx in ddl
        .indexes
        .list_mut()
        .iter_mut()
        .filter(|i| i.schema.as_ref() == schema && i.table.as_ref() == table)
    {
        for col in &mut idx.columns {
            if !col.is_expression && col.value.as_ref() == from {
                col.value = to.clone().into();
            }
        }
    }
}

fn valid_rename_name(name: &str) -> bool {
    !name.trim().is_empty()
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::postgres::PostgresSnapshot;
    use crate::postgres::ddl::{
        Column as PgColumn, PostgresEntity, Schema as PgSchema, Table as PgTable,
    };
    use crate::schema::Schema as MigrationSchema;
    use crate::sqlite::SQLiteSnapshot;
    use crate::sqlite::ddl::{Column, SqliteEntity, Table};

    #[derive(Default)]
    struct EmptySqliteSchema;

    impl MigrationSchema for EmptySqliteSchema {
        fn dialect(&self) -> drizzle_types::Dialect {
            drizzle_types::Dialect::SQLite
        }

        fn to_snapshot(&self) -> Snapshot {
            Snapshot::empty(drizzle_types::Dialect::SQLite)
        }
    }

    #[test]
    fn test_generate_empty_to_empty() {
        let prev = Snapshot::empty(drizzle_types::Dialect::SQLite);
        let cur = Snapshot::empty(drizzle_types::Dialect::SQLite);
        let migration = diff(&prev, &cur).unwrap();
        assert!(migration.statements.is_empty());
    }

    #[test]
    fn test_generate_create_table() {
        let prev = Snapshot::empty(drizzle_types::Dialect::SQLite);

        let mut cur_snap = SQLiteSnapshot::new();
        cur_snap.add_entity(SqliteEntity::Table(Table::new("users")));
        cur_snap.add_entity(SqliteEntity::Column(
            Column::new("users", "id", "integer").not_null(),
        ));
        cur_snap.add_entity(SqliteEntity::Column(
            Column::new("users", "name", "text").not_null(),
        ));
        let cur = Snapshot::Sqlite(cur_snap);

        let migration = diff(&prev, &cur).unwrap();
        assert!(!migration.statements.is_empty());
        assert!(migration.statements[0].contains("CREATE TABLE"));
        assert!(migration.statements[0].contains("users"));
    }

    #[test]
    fn test_generate_dialect_mismatch() {
        let prev = Snapshot::empty(drizzle_types::Dialect::SQLite);
        let cur = Snapshot::empty(drizzle_types::Dialect::PostgreSQL);
        let result = diff(&prev, &cur);
        assert!(matches!(result, Err(MigrationError::DialectMismatch)));
    }

    #[test]
    fn test_generate_postgres_empty() {
        let prev = Snapshot::empty(drizzle_types::Dialect::PostgreSQL);
        let cur = Snapshot::empty(drizzle_types::Dialect::PostgreSQL);
        let migration = diff(&prev, &cur).unwrap();
        assert!(migration.statements.is_empty());
    }

    #[test]
    fn test_diff_schemas_empty() {
        let prev = EmptySqliteSchema;
        let cur = EmptySqliteSchema;
        let migration = diff_schemas(&prev, &cur).unwrap();
        assert!(migration.statements.is_empty());
    }

    #[test]
    fn test_diff_with_sqlite_rename_hints() {
        let mut prev_snap = SQLiteSnapshot::new();
        prev_snap.add_entity(SqliteEntity::Table(Table::new("users")));
        prev_snap.add_entity(SqliteEntity::Column(
            Column::new("users", "full_name", "text").not_null(),
        ));

        let mut cur_snap = SQLiteSnapshot::new();
        cur_snap.add_entity(SqliteEntity::Table(Table::new("accounts")));
        cur_snap.add_entity(SqliteEntity::Column(
            Column::new("accounts", "display_name", "text").not_null(),
        ));

        let prev = Snapshot::Sqlite(prev_snap);
        let cur = Snapshot::Sqlite(cur_snap);

        let options = DiffOptions::new()
            .rename_table("users", "accounts")
            .rename_column("accounts", "full_name", "display_name");

        let migration = diff_with(&prev, &cur, &options).unwrap();
        assert_eq!(
            migration.statements,
            vec![
                "ALTER TABLE `users` RENAME TO `accounts`;".to_string(),
                "ALTER TABLE `accounts` RENAME COLUMN `full_name` TO `display_name`;".to_string(),
            ]
        );
    }

    #[test]
    fn test_diff_with_sqlite_table_rename_hint_and_add_column() {
        let mut prev_snap = SQLiteSnapshot::new();
        prev_snap.add_entity(SqliteEntity::Table(Table::new("users")));
        prev_snap.add_entity(SqliteEntity::Column(
            Column::new("users", "id", "integer").not_null(),
        ));

        let mut cur_snap = SQLiteSnapshot::new();
        cur_snap.add_entity(SqliteEntity::Table(Table::new("accounts")));
        cur_snap.add_entity(SqliteEntity::Column(
            Column::new("accounts", "id", "integer").not_null(),
        ));
        cur_snap.add_entity(SqliteEntity::Column(Column::new(
            "accounts", "email", "text",
        )));

        let migration = diff_with(
            &Snapshot::Sqlite(prev_snap),
            &Snapshot::Sqlite(cur_snap),
            &DiffOptions::new().rename_table("users", "accounts"),
        )
        .unwrap();

        assert_eq!(
            migration.statements,
            vec![
                "ALTER TABLE `users` RENAME TO `accounts`;".to_string(),
                "ALTER TABLE `accounts` ADD `email` TEXT;".to_string(),
            ]
        );
    }

    #[test]
    fn test_diff_with_postgres_table_rename_hint_and_add_column() {
        let mut prev_snap = PostgresSnapshot::new();
        prev_snap.add_entity(PostgresEntity::Schema(PgSchema::new("public")));
        prev_snap.add_entity(PostgresEntity::Table(PgTable::new("public", "users")));
        prev_snap.add_entity(PostgresEntity::Column(
            PgColumn::new("public", "users", "id", "integer").not_null(),
        ));

        let mut cur_snap = PostgresSnapshot::new();
        cur_snap.add_entity(PostgresEntity::Schema(PgSchema::new("public")));
        cur_snap.add_entity(PostgresEntity::Table(PgTable::new("public", "accounts")));
        cur_snap.add_entity(PostgresEntity::Column(
            PgColumn::new("public", "accounts", "id", "integer").not_null(),
        ));
        cur_snap.add_entity(PostgresEntity::Column(PgColumn::new(
            "public", "accounts", "email", "text",
        )));

        let migration = diff_with(
            &Snapshot::Postgres(prev_snap),
            &Snapshot::Postgres(cur_snap),
            &DiffOptions::new().rename_table("users", "accounts"),
        )
        .unwrap();

        assert_eq!(
            migration.statements,
            vec![
                "ALTER TABLE \"public\".\"users\" RENAME TO \"accounts\";".to_string(),
                "ALTER TABLE \"accounts\" ADD COLUMN \"email\" text;".to_string(),
            ]
        );
    }

    #[test]
    fn test_diff_with_strict_rename_hints_errors() {
        let prev = Snapshot::empty(drizzle_types::Dialect::SQLite);
        let cur = Snapshot::empty(drizzle_types::Dialect::SQLite);
        let options = DiffOptions::new()
            .strict_renames(true)
            .rename_table("missing_table", "users");

        let result = diff_with(&prev, &cur, &options);
        assert!(matches!(result, Err(MigrationError::ConfigError(_))));

        let prev = Snapshot::empty(drizzle_types::Dialect::PostgreSQL);
        let cur = Snapshot::empty(drizzle_types::Dialect::PostgreSQL);
        let options = DiffOptions::new()
            .strict_renames(true)
            .rename_schema("missing_schema", "app");

        let result = diff_with(&prev, &cur, &options);
        assert!(matches!(result, Err(MigrationError::ConfigError(_))));
    }
}