Update database.py

database.py

@@ -1,55 +1,87 @@
-from sqlalchemy import create_engine, MetaData, Table, Column, String, Integer, Float, inspect
+from sqlalchemy import (
+    create_engine,
+    MetaData,
+    Table,
+    Column,
+    String,
+    Integer,
+    Float,
+    insert,
+    text,
+)
 
-# Initialize database engine (Persistent SQLite)
+# Use a persistent SQLite database file
 engine = create_engine("sqlite:///database.db")
 metadata_obj = MetaData()
 
-# Function to check existing tables
-def get_existing_tables():
+def create_dynamic_table(df):
     """
-    Returns a list of existing tables in the database.
-
+    Creates a table dynamically based on DataFrame schema.
+    
+    Args:
+        df: pandas DataFrame containing the data
+        
     Returns:
-        list: List of table names.
+        SQLAlchemy Table object
     """
-    inspector = inspect(engine)
-    return inspector.get_table_names()
-
-# Create a default table if no SQL file is uploaded
-def create_placeholder_table():
-    """
-    Creates a default 'users' table with example data if no SQL file has been uploaded.
-    """
-    if "users" not in get_existing_tables():
-        users_table = Table(
-            "users", metadata_obj,
-            Column("id", Integer, primary_key=True),
-            Column("name", String(50)),
-            Column("age", Integer),
-            Column("balance", Float)
-        )
-        metadata_obj.create_all(engine)
+    # Drop existing table if it exists
+    if 'data_table' in metadata_obj.tables:
+        metadata_obj.remove(metadata_obj.tables['data_table'])
+    
+    # Create columns based on DataFrame dtypes
+    columns = []
+    for col_name, dtype in df.dtypes.items():
+        if 'int' in str(dtype):
+            col_type = Integer
+        elif 'float' in str(dtype):
+            col_type = Float
+        else:
+            col_type = String(255)  # Using a generous length for string columns
         
-        with engine.connect() as con:
-            con.execute(users_table.insert(), [
-                {"id": 1, "name": "Alice", "age": 30, "balance": 100.50},
-                {"id": 2, "name": "Bob", "age": 24, "balance": 250.75},
-                {"id": 3, "name": "Charlie", "age": 35, "balance": 80.00}
-            ])
-        print("✅ Created placeholder 'users' table with sample data.")
+        # First column becomes primary key
+        if len(columns) == 0:
+            columns.append(Column(col_name, col_type, primary_key=True))
+        else:
+            columns.append(Column(col_name, col_type))
+    
+    # Create new table
+    table = Table('data_table', metadata_obj, *columns)
+    
+    # Create table in database
+    metadata_obj.create_all(engine, tables=[table])
+    
+    return table
 
-# Function to initialize database (Prevents crashes)
-def initialize_database():
+def clear_database():
     """
-    Ensures the database starts up with a placeholder table if no SQL file is uploaded.
+    Removes all tables from the database.
     """
-    tables = get_existing_tables()
-    
-    if not tables:
-        print("No tables found. Creating a placeholder table...")
-        create_placeholder_table()
-    else:
-        print(f"Database initialized with tables: {tables}")
+    metadata_obj.drop_all(engine)
+    metadata_obj.clear()
 
-initialize_database()
+def insert_rows_into_table(rows, table):
+    """
+    Inserts rows into the specified table.
+    
+    Args:
+        rows: List of dictionaries containing the row data
+        table: SQLAlchemy Table object
+    """
+    with engine.begin() as connection:
+        connection.execute(insert(table), rows)
 
+def get_table_schema():
+    """
+    Returns the current table schema as a string.
+    """
+    if 'data_table' not in metadata_obj.tables:
+        return None
+        
+    table = metadata_obj.tables['data_table']
+    schema = []
+    for column in table.columns:
+        col_type = str(column.type).upper()
+        is_primary = "primary key" if column.primary_key else ""
+        schema.append(f"- {column.name} ({col_type}) {is_primary}".strip())
+    
+    return "\n".join(schema)