quick fix!

discover hidden sqlite columns using raw query during sync

Author: sinder38

src/schema/builder.rs

@@ -1,8 +1,8 @@
 use super::{Schema, TopologicalSort};
 use crate::{ConnectionTrait, DbBackend, DbErr, EntityTrait, Statement};
 use sea_query::{
-    ForeignKeyCreateStatement, Index, IndexCreateStatement, IntoIden, TableAlterStatement,
-    TableCreateStatement, TableName, TableRef, extension::postgres::TypeCreateStatement,
+    ForeignKeyCreateStatement, IndexCreateStatement, TableAlterStatement, TableCreateStatement,
+    TableName, TableRef, extension::postgres::TypeCreateStatement,
 };
 
 /// A schema builder that can take a registry of Entities and synchronize it with database.
@@ -322,7 +322,32 @@ impl EntitySchemaInfo {
                         break;
                     }
                 }
+
                 if !column_exists {
+                    #[cfg(feature = "rusqlite")]
+                    {
+                        // TODO: sea_scheme has a bug. this is a quick fix
+                        // On SQLite, PRAGMA table_info does not return generated/virtual columns.
+                        if column_def.get_column_spec().extra.is_some() {
+                            let tbl_str = table_name.1.to_string();
+                            let col_name = column_def.get_column_name();
+                            // hidden IN (2, 3) - filters to only hidden generated columns:
+                            // 2 = Hidden generated column (computed, not stored)
+                            // 3 = Hidden stored generated column (computed and stored)
+                            let xinfo_sql = format!(
+                                "SELECT name FROM pragma_table_xinfo('{}') WHERE name = '{}' AND hidden IN (2, 3)",
+                                tbl_str.replace('\'', "''"),
+                                col_name.replace('\'', "''")
+                            );
+                            let rows = db
+                                .query_all_raw(Statement::from_string(DbBackend::Sqlite, xinfo_sql))
+                                .await?;
+                            if !rows.is_empty() {
+                                continue; // Column exists actually
+                            }
+                        }
+                    }
+
                     let mut renamed_from = "";
                     if let Some(comment) = &column_def.get_column_spec().comment {
                         if let Some((_, suffix)) = comment.rsplit_once("renamed_from \"") {
@@ -351,6 +376,7 @@ impl EntitySchemaInfo {
                     }
                 }
             }
+
             if db.get_database_backend() != DbBackend::Sqlite {
                 for foreign_key in self.table.get_foreign_key_create_stmts().iter() {
                     let mut key_exists = false;
@@ -387,46 +413,6 @@ impl EntitySchemaInfo {
                 db.execute(&stmt).await?;
             }
         }
-        if let Some(existing_table) = existing_table {
-            // For columns with a column-level UNIQUE constraint (#[sea_orm(unique)]) that
-            // already exist in the table but do not yet have a unique index, create one.
-            for column_def in self.table.get_columns() {
-                if column_def.get_column_spec().unique {
-                    let col_name = column_def.get_column_name();
-                    let col_exists = existing_table
-                        .get_columns()
-                        .iter()
-                        .any(|c| c.get_column_name() == col_name);
-                    if !col_exists {
-                        // Column is being added in this sync pass; the ALTER TABLE ADD COLUMN
-                        // will include the UNIQUE inline, so no separate index needed.
-                        continue;
-                    }
-                    let already_unique = existing_table.get_indexes().iter().any(|idx| {
-                        if !idx.is_unique_key() {
-                            return false;
-                        }
-                        let cols = idx.get_index_spec().get_column_names();
-                        cols.len() == 1 && cols[0] == col_name
-                    });
-                    if !already_unique {
-                        let table_name =
-                            self.table.get_table_name().expect("table must have a name");
-                        let tbl_str = table_name.sea_orm_table().to_string();
-                        let table_ref = table_name.clone();
-                        db.execute(
-                            Index::create()
-                                .name(format!("idx-{tbl_str}-{col_name}"))
-                                .table(table_ref)
-                                .col(col_name.into_iden())
-                                .unique()
-                                .if_not_exists(),
-                        )
-                        .await?;
-                    }
-                }
-            }
-        }
         if let Some(existing_table) = existing_table {
             // find all unique keys from existing table
             // if it no longer exist in new schema, drop it
@@ -441,23 +427,6 @@ impl EntitySchemaInfo {
                             break;
                         }
                     }
-                    // Also check if the unique index corresponds to a column-level UNIQUE
-                    // constraint (from #[sea_orm(unique)]). These are embedded in the CREATE
-                    // TABLE column definition and not tracked in self.indexes, so we must not
-                    // try to drop them during sync.
-                    if !has_index {
-                        let index_cols = existing_index.get_index_spec().get_column_names();
-                        if index_cols.len() == 1 {
-                            for column_def in self.table.get_columns() {
-                                if column_def.get_column_name() == index_cols[0]
-                                    && column_def.get_column_spec().unique
-                                {
-                                    has_index = true;
-                                    break;
-                                }
-                            }
-                        }
-                    }
                     if !has_index {
                         if let Some(drop_existing) = existing_index.get_index_spec().get_name() {
                             db.execute(sea_query::Index::drop().name(drop_existing))