Adds database visualization feature

Implements database visualization using Mermaid diagrams and text summaries.

Provides a visual representation of the database schema, including tables, columns, and relationships. This allows users to better understand the structure of their database.

Automatically generates visualizations after successful merge operations or SQL execution. Includes a button to manually generate the visualization at any time.

Updates the Gradio UI to display the visualization.

schema_sync/app.py

@@ -5,6 +5,7 @@ import os
 from .db_connector import DBConnector
 from .schema_inspector import SchemaInspector
 from .merge_operations import MergeOperations
+from .db_visualizer import DatabaseVisualizer
 from .config import get_config
 
 # Set up logging
@@ -17,10 +18,11 @@ config = get_config()
 db = None
 inspector = None
 merge_ops = None
+visualizer = None
 
 def connect_to_database(db_url):
     """Connect to the database with provided URL"""
-    global db, inspector, merge_ops
+    global db, inspector, merge_ops, visualizer
     
     try:
         # Initialize new connection
@@ -32,6 +34,7 @@ def connect_to_database(db_url):
             
         inspector = SchemaInspector(db)
         merge_ops = MergeOperations(db, inspector)
+        visualizer = DatabaseVisualizer(db, inspector)
         
         # Test connection by fetching tables
         tables = get_db_tables()
@@ -50,10 +53,10 @@ def connect_to_database(db_url):
 def handle_merge(action, table, column, from_values, target_value, preview_only=True):
     """Handler for Gradio interface"""
     if not db:
-        return "Error: Not connected to database. Please connect first."
+        return "Error: Not connected to database. Please connect first.", "", ""
     
     if not table or not column:
-        return "Error: Table and column must be specified"
+        return "Error: Table and column must be specified", "", ""
     
     # Parse from_values as comma-separated list
     from_values_list = [v.strip() for v in from_values.split(',')]
@@ -61,12 +64,21 @@ def handle_merge(action, table, column, from_values, target_value, preview_only=
     if action == "Merge Values":
         if preview_only:
             result = merge_ops.preview_merge(table, column, from_values_list, target_value)
-            return result["preview"]
+            return result["preview"], "", ""
         else:
             result = merge_ops.run_merge(table, column, from_values_list, target_value)
-            return result["log"]
+            # Auto-generate visualization after successful operation
+            if result.get("success", False) and visualizer:
+                try:
+                    text_summary = visualizer.generate_table_summary()
+                    mermaid_diagram = visualizer.generate_mermaid_diagram()
+                    return result["log"], text_summary, mermaid_diagram
+                except Exception as e:
+                    logger.error(f"Error generating visualization after merge: {str(e)}")
+                    return result["log"], "Error generating visualization", ""
+            return result["log"], "", ""
     else:
-        return "Action not implemented yet"
+        return "Action not implemented yet", "", ""
 
 def get_db_tables():
     """Get list of tables from the database for dropdown"""
@@ -116,10 +128,10 @@ def execute_sql_file(sql_file):
     global db
     
     if not db:
-        return "Error: Not connected to database. Please connect first."
+        return "Error: Not connected to database. Please connect first.", "", ""
     
     if sql_file is None:
-        return "Error: No SQL file provided."
+        return "Error: No SQL file provided.", "", ""
     
     try:
         # Read the uploaded file
@@ -127,7 +139,7 @@ def execute_sql_file(sql_file):
             sql_content = f.read()
         
         if not sql_content.strip():
-            return "Error: SQL file is empty."
+            return "Error: SQL file is empty.", "", ""
         
         # Split SQL content by semicolons and execute each statement
         sql_statements = [stmt.strip() for stmt in sql_content.split(';') if stmt.strip()]
@@ -152,19 +164,52 @@ def execute_sql_file(sql_file):
             
             session.commit()
             results.insert(0, f"Successfully executed {len(sql_statements)} SQL statements.")
-            return "\n".join(results)
+            operation_log = "\n".join(results)
+            
+            # Auto-generate visualization after successful SQL execution
+            if visualizer:
+                try:
+                    text_summary = visualizer.generate_table_summary()
+                    mermaid_diagram = visualizer.generate_mermaid_diagram()
+                    return operation_log, text_summary, mermaid_diagram
+                except Exception as e:
+                    logger.error(f"Error generating visualization after SQL execution: {str(e)}")
+                    return operation_log, "Error generating visualization", ""
+            
+            return operation_log, "", ""
             
         except Exception as e:
             session.rollback()
             error_msg = f"Error executing SQL: {str(e)}"
             logger.error(error_msg)
-            return error_msg
+            return error_msg, "", ""
         finally:
             session.close()
             
     except Exception as e:
         logger.error(f"Error reading SQL file: {str(e)}")
-        return f"Error reading SQL file: {str(e)}"
+        return f"Error reading SQL file: {str(e)}", "", ""
+
+def generate_database_visualization():
+    """Generate database visualization"""
+    if not visualizer:
+        return "Error: Not connected to database. Please connect first.", ""
+    
+    try:
+        # Generate both Mermaid diagram and text summary
+        mermaid_diagram = visualizer.generate_mermaid_diagram()
+        text_summary = visualizer.generate_table_summary()
+        
+        return text_summary, mermaid_diagram
+        
+    except Exception as e:
+        error_msg = f"Error generating visualization: {str(e)}"
+        logger.error(error_msg)
+        return error_msg, ""
+
+def refresh_visualization():
+    """Refresh the database visualization"""
+    return generate_database_visualization()
 
 def create_ui():
     """Create and configure the Gradio UI"""
@@ -172,7 +217,7 @@ def create_ui():
         gr.Markdown("# SchemaSync - Database Schema Manipulation Tool")
         
         with gr.Row():
-            with gr.Column():
+            with gr.Column(scale=1):
                 # Database Connection Section
                 gr.Markdown("## Database Connection")
                 
@@ -246,13 +291,40 @@ def create_ui():
                 with gr.Row():
                     preview_btn = gr.Button("Preview Changes")
                     run_btn = gr.Button("Run Operation", variant="primary")
+                
+                # Database Visualization Section
+                gr.Markdown("## Database Visualization")
+                
+                visualize_btn = gr.Button("Generate Visualization", variant="secondary")
             
-            with gr.Column():
+            with gr.Column(scale=2):
+                # Operation Results
+                gr.Markdown("## Operation Results")
+                
                 output = gr.TextArea(
                     label="Operation Log",
                     placeholder="Operation results will appear here",
-                    lines=20
+                    lines=15
                 )
+                
+                # Visualization Results
+                gr.Markdown("## Database Schema")
+                
+                with gr.Tabs():
+                    with gr.TabItem("Schema Summary"):
+                        schema_summary = gr.Markdown(
+                            value="Connect to a database and run operations or click 'Generate Visualization' to see the schema structure."
+                        )
+                    
+                    with gr.TabItem("ER Diagram"):
+                        gr.Markdown("Copy the code below and paste it into [Mermaid Live Editor](https://mermaid.live) to view the interactive diagram.")
+                        
+                        mermaid_code = gr.Code(
+                            label="Mermaid Diagram Code",
+                            language="markdown",
+                            lines=15,
+                            value="Connect to database and run operations to see diagram code here."
+                        )
         
         # Connect buttons to handlers
         connect_btn.click(
@@ -270,19 +342,26 @@ def create_ui():
         execute_sql_btn.click(
             fn=execute_sql_file,
             inputs=sql_file,
-            outputs=output
+            outputs=[output, schema_summary, mermaid_code]
         )
         
         preview_btn.click(
             fn=handle_merge,
             inputs=[action, table, column, from_values, target_value, preview_checkbox],
-            outputs=output
+            outputs=[output, schema_summary, mermaid_code]
         )
         
         run_btn.click(
             fn=handle_merge,
             inputs=[action, table, column, from_values, target_value, gr.Checkbox(value=False, visible=False)],
-            outputs=output
+            outputs=[output, schema_summary, mermaid_code]
+        )
+        
+        # Manual visualization generation
+        visualize_btn.click(
+            fn=generate_database_visualization,
+            inputs=None,
+            outputs=[schema_summary, mermaid_code]
         )
         
     return app

schema_sync/db_visualizer.py

@@ -0,0 +1,153 @@
+import logging
+import json
+from sqlalchemy import text
+
+logger = logging.getLogger(__name__)
+
+class DatabaseVisualizer:
+    def __init__(self, db_connector, schema_inspector):
+        self.db = db_connector
+        self.inspector = schema_inspector
+        
+    def get_database_schema(self):
+        """Get complete database schema with tables, columns, and relationships"""
+        try:
+            # Get all tables
+            tables_query = """
+                SELECT table_name 
+                FROM information_schema.tables 
+                WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
+                ORDER BY table_name
+            """
+            tables_result = self.db.execute_query(tables_query)
+            tables = [row[0] for row in tables_result]
+            
+            schema_data = {
+                "tables": {},
+                "relationships": []
+            }
+            
+            # Get detailed info for each table
+            for table in tables:
+                # Get columns
+                columns = self.inspector.get_column_info(table)
+                
+                # Get foreign keys
+                foreign_keys = self.inspector.get_foreign_keys(table)
+                
+                # Get primary key
+                pk_query = f"""
+                    SELECT column_name
+                    FROM information_schema.key_column_usage
+                    WHERE table_name = '{table}'
+                    AND constraint_name IN (
+                        SELECT constraint_name
+                        FROM information_schema.table_constraints
+                        WHERE table_name = '{table}'
+                        AND constraint_type = 'PRIMARY KEY'
+                    )
+                """
+                pk_result = self.db.execute_query(pk_query)
+                primary_keys = [row[0] for row in pk_result]
+                
+                # Store table info
+                schema_data["tables"][table] = {
+                    "columns": columns,
+                    "primary_keys": primary_keys,
+                    "foreign_keys": foreign_keys
+                }
+                
+                # Add relationships
+                for fk in foreign_keys:
+                    relationship = {
+                        "from_table": table,
+                        "from_column": fk["column_name"],
+                        "to_table": fk["foreign_table_name"],
+                        "to_column": fk["foreign_column_name"]
+                    }
+                    schema_data["relationships"].append(relationship)
+            
+            return schema_data
+            
+        except Exception as e:
+            logger.error(f"Error getting database schema: {str(e)}")
+            return {"tables": {}, "relationships": []}
+    
+    def generate_mermaid_diagram(self):
+        """Generate a Mermaid ER diagram of the database"""
+        schema = self.get_database_schema()
+        
+        if not schema["tables"]:
+            return "No tables found in database"
+        
+        mermaid_lines = ["erDiagram"]
+        
+        # Add tables and columns
+        for table_name, table_info in schema["tables"].items():
+            mermaid_lines.append(f"    {table_name} {{")
+            
+            for col in table_info["columns"]:
+                col_name = col["column_name"]
+                data_type = col["data_type"]
+                is_pk = col_name in table_info["primary_keys"]
+                is_fk = any(fk["column_name"] == col_name for fk in table_info["foreign_keys"])
+                
+                # Add type indicators
+                type_indicator = ""
+                if is_pk:
+                    type_indicator = " PK"
+                elif is_fk:
+                    type_indicator = " FK"
+                
+                mermaid_lines.append(f"        {data_type} {col_name}{type_indicator}")
+            
+            mermaid_lines.append("    }")
+        
+        # Add relationships
+        for rel in schema["relationships"]:
+            # Mermaid relationship syntax: TableA ||--o{ TableB : relationship
+            mermaid_lines.append(
+                f"    {rel['to_table']} ||--o{{ {rel['from_table']} : \"{rel['from_column']} -> {rel['to_column']}\""
+            )
+        
+        return "\n".join(mermaid_lines)
+    
+    def generate_table_summary(self):
+        """Generate a text summary of database structure"""
+        schema = self.get_database_schema()
+        
+        if not schema["tables"]:
+            return "No tables found in database"
+        
+        summary_lines = ["# Database Schema Summary\n"]
+        
+        # Table overview
+        summary_lines.append(f"**Total Tables:** {len(schema['tables'])}")
+        summary_lines.append(f"**Total Relationships:** {len(schema['relationships'])}\n")
+        
+        # Detailed table info
+        summary_lines.append("## Tables\n")
+        
+        for table_name, table_info in schema["tables"].items():
+            summary_lines.append(f"### {table_name}")
+            summary_lines.append(f"- **Columns:** {len(table_info['columns'])}")
+            summary_lines.append(f"- **Primary Keys:** {', '.join(table_info['primary_keys']) if table_info['primary_keys'] else 'None'}")
+            summary_lines.append(f"- **Foreign Keys:** {len(table_info['foreign_keys'])}")
+            
+            # Column details
+            summary_lines.append("\n**Columns:**")
+            for col in table_info["columns"]:
+                nullable = "NULL" if col["is_nullable"] == "YES" else "NOT NULL"
+                summary_lines.append(f"- `{col['column_name']}` ({col['data_type']}) {nullable}")
+            
+            summary_lines.append("")
+        
+        # Relationships summary
+        if schema["relationships"]:
+            summary_lines.append("## Relationships\n")
+            for rel in schema["relationships"]:
+                summary_lines.append(
+                    f"- `{rel['from_table']}.{rel['from_column']}` → `{rel['to_table']}.{rel['to_column']}`"
+                )
+        
+        return "\n".join(summary_lines)