Update utils/database.py

utils/database.py

@@ -50,6 +50,7 @@ def create_connection(db_file):
     except Error as e:
         st.error("Failed to connect to database. Please try again or contact support.")
     return None
+    
 def create_connection(db_file: str) -> Optional[sqlite3.Connection]:
     """Create a database connection."""
     try:
@@ -62,37 +63,25 @@ def create_connection(db_file: str) -> Optional[sqlite3.Connection]:
 # utils/database.py
 # Add this version of create_tables (replacing the existing one)
 
+# utils/database.py
+
 def create_tables(conn: sqlite3.Connection) -> None:
-    """
-    Create all necessary tables in the database.
-    
-    Args:
-        conn (sqlite3.Connection): SQLite database connection
-    """
+    """Create all necessary tables in the database."""
     try:
         with conn_lock:
-            # Documents table
-            conn.execute('''
-                CREATE TABLE IF NOT EXISTS documents (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    name TEXT NOT NULL,
-                    content TEXT NOT NULL,
-                    upload_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                );
-            ''')
+            cursor = conn.cursor()
             
-            # Collections table
-            conn.execute('''
+            # Force create collections tables first
+            collections_tables = [
+                '''
                 CREATE TABLE IF NOT EXISTS collections (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     name TEXT NOT NULL UNIQUE,
                     description TEXT,
                     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-                );
-            ''')
-            
-            # Document-Collections relationship table
-            conn.execute('''
+                )
+                ''',
+                '''
                 CREATE TABLE IF NOT EXISTS document_collections (
                     document_id INTEGER,
                     collection_id INTEGER,
@@ -100,11 +89,31 @@ def create_tables(conn: sqlite3.Connection) -> None:
                     PRIMARY KEY (document_id, collection_id),
                     FOREIGN KEY (document_id) REFERENCES documents (id) ON DELETE CASCADE,
                     FOREIGN KEY (collection_id) REFERENCES collections (id) ON DELETE CASCADE
-                );
-            ''')
+                )
+                '''
+            ]
+            
+            # Execute collections tables creation separately
+            for table_sql in collections_tables:
+                try:
+                    cursor.execute(table_sql)
+                    conn.commit()
+                except sqlite3.Error as e:
+                    st.error(f"Error creating collections table: {e}")
+                    st.error(f"SQL that failed: {table_sql}")
+                    raise
             
-            # Queries table
-            conn.execute('''
+            # Create other tables
+            other_tables = [
+                '''
+                CREATE TABLE IF NOT EXISTS documents (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT NOT NULL,
+                    content TEXT NOT NULL,
+                    upload_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+                ''',
+                '''
                 CREATE TABLE IF NOT EXISTS queries (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     query TEXT NOT NULL,
@@ -112,11 +121,9 @@ def create_tables(conn: sqlite3.Connection) -> None:
                     document_id INTEGER,
                     query_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                     FOREIGN KEY (document_id) REFERENCES documents (id) ON DELETE CASCADE
-                );
-            ''')
-            
-            # Annotations table
-            conn.execute('''
+                )
+                ''',
+                '''
                 CREATE TABLE IF NOT EXISTS annotations (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     document_id INTEGER NOT NULL,
@@ -124,19 +131,94 @@ def create_tables(conn: sqlite3.Connection) -> None:
                     page_number INTEGER,
                     annotation_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                     FOREIGN KEY (document_id) REFERENCES documents (id) ON DELETE CASCADE
-                );
-            ''')
+                )
+                '''
+            ]
+            
+            # Execute other tables creation
+            for table_sql in other_tables:
+                try:
+                    cursor.execute(table_sql)
+                    conn.commit()
+                except sqlite3.Error as e:
+                    st.error(f"Error creating table: {e}")
+                    st.error(f"SQL that failed: {table_sql}")
+                    raise
+            
+            # Create indices
+            indices = [
+                'CREATE INDEX IF NOT EXISTS idx_doc_name ON documents(name)',
+                'CREATE INDEX IF NOT EXISTS idx_collection_name ON collections(name)',
+                'CREATE INDEX IF NOT EXISTS idx_doc_collections ON document_collections(collection_id)'
+            ]
+            
+            # Execute indices creation
+            for index_sql in indices:
+                try:
+                    cursor.execute(index_sql)
+                    conn.commit()
+                except sqlite3.Error as e:
+                    st.error(f"Error creating index: {e}")
+                    st.error(f"SQL that failed: {index_sql}")
             
-            # Create indices for better performance
-            conn.execute('CREATE INDEX IF NOT EXISTS idx_doc_name ON documents(name);')
-            conn.execute('CREATE INDEX IF NOT EXISTS idx_collection_name ON collections(name);')
-            conn.execute('CREATE INDEX IF NOT EXISTS idx_doc_collections ON document_collections(collection_id);')
+            # Verify collections table was created
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='collections'")
+            if not cursor.fetchone():
+                st.error("Failed to create collections table despite no errors")
+                raise Exception("Collections table creation failed silently")
             
             conn.commit()
             
     except sqlite3.Error as e:
-        st.error(f"Error creating tables: {e}")
+        st.error(f"Error in create_tables: {e}")
         raise
+    except Exception as e:
+        st.error(f"Unexpected error in create_tables: {e}")
+        raise
+
+def force_recreate_collections_tables(conn: sqlite3.Connection) -> bool:
+    """Force recreate collections tables if they're missing."""
+    try:
+        with conn_lock:
+            cursor = conn.cursor()
+            
+            # Drop existing tables if they exist
+            cursor.execute("DROP TABLE IF EXISTS document_collections")
+            cursor.execute("DROP TABLE IF EXISTS collections")
+            
+            # Create collections table
+            cursor.execute('''
+                CREATE TABLE collections (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT NOT NULL UNIQUE,
+                    description TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            ''')
+            
+            # Create document_collections table
+            cursor.execute('''
+                CREATE TABLE document_collections (
+                    document_id INTEGER,
+                    collection_id INTEGER,
+                    added_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    PRIMARY KEY (document_id, collection_id),
+                    FOREIGN KEY (document_id) REFERENCES documents (id) ON DELETE CASCADE,
+                    FOREIGN KEY (collection_id) REFERENCES collections (id) ON DELETE CASCADE
+                )
+            ''')
+            
+            # Create indices
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_collection_name ON collections(name)')
+            cursor.execute('CREATE INDEX IF NOT EXISTS idx_doc_collections ON document_collections(collection_id)')
+            
+            conn.commit()
+            return True
+            
+    except sqlite3.Error as e:
+        st.error(f"Error recreating collections tables: {e}")
+        return False
+
 
 def get_all_documents(conn: sqlite3.Connection) -> List[Dict]:
     """Get all documents with their metadata and collections."""