Scribd
Upload
3 views

CS_Project_Database_UI_with_Tkinter

Uploaded by

tvsaacademy6off
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
3 views

CS_Project_Database_UI_with_Tkinter

Uploaded by

tvsaacademy6off
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

CS Project: Database Management UI

with Tkinter
Overview

This project involves creating a graphical user interface (GUI) to interact with a MySQL
database using Python’s Tkinter and mysql.connector.
The application provides functionalities to:
- View and interact with data from different tables in the database.
- Add new records to the selected table.
- Fetch and display data dynamically based on the table selection.

Features:
1. Table Selection: Users can select a table from a dropdown menu.
2. Display Table Data: A treeview displays the data from the selected table.
3. Add New Record: Users can fill out a form to add new records to the selected table.
4. Validation and Error Handling: Ensures that all fields are filled before submission and
handles database errors gracefully.

Detailed Explanation of the Code

1. Database Connection

The create_connection() function establishes a connection to the MySQL database.

def create_connection() -> MySQLConnection:


"""Create a connection to the MySQL database."""
try:
connection = connect(
host="localhost",
user="root",
passwd="1977",
database="usdms"
)
return connection
except Exception as e:
messagebox.showerror("Database Error", f"Error connecting to database: {e}")
raise

2. Fetching Data from the Database

The fetch_data() function retrieves data from the database based on a provided query.

def fetch_data(connection: MySQLConnection, query: str, params: Optional[tuple] = None) -


> List[Dict]:
"""Fetch data from the database."""
cursor = None
try:
cursor = connection.cursor(dictionary=True)
if params:
cursor.execute(query, params)
else:
cursor.execute(query)
return cursor.fetchall()
except Exception as e:
messagebox.showerror("Error", f"Error fetching data: {e}")
return []
finally:
if cursor:
cursor.close()

3. Displaying Data in the UI

The fetch_and_display_table_data() function retrieves and displays the data in the


Treeview widget.

def fetch_and_display_table_data(self, table_name: str):


"""Fetch and display table data."""
self.current_table = table_name

# Get columns
columns = get_table_columns(self.connection, table_name)
self.tree["columns"] = columns
self.tree["show"] = "headings"
# Add columns to treeview
for col in columns:
self.tree.heading(col, text=col)
self.tree.column(col, width=100)

# Fetch data and populate treeview


query = f"SELECT * FROM {table_name}"
data = fetch_data(self.connection, query)

# Clear existing rows


for row in self.tree.get_children():
self.tree.delete(row)

# Insert new rows


for record in data:
self.tree.insert("", tk.END, values=list(record.values()))

4. Adding a New Record

The add_record() function allows users to add a new record to the selected table. It checks
for form validation and executes an INSERT query.

def add_record(self):
"""Add a new record to the selected table."""
try:
if not self.current_table:
messagebox.showwarning("Warning", "Please select a table first!")
return

columns = get_table_columns(self.connection, self.current_table)


values = [self.entry_widgets[col].get() for col in columns]

if not all(values):
messagebox.showwarning("Validation Error", "Please fill all fields!")
return

query = f"INSERT INTO {self.current_table} ({', '.join(columns)}) VALUES ({',


'.join(['%s'] * len(columns))})"
if execute_query(self.connection, query, tuple(values)):
self.fetch_and_display_table_data(self.current_table)
messagebox.showinfo("Success", "Record added successfully!")

# Clear entry fields after successful addition


for entry in self.entry_widgets.values():
entry.delete(0, tk.END)

except Exception as e:
messagebox.showerror("Error", f"Failed to add record: {e}")

5. Creating the UI Elements

The create_entry_form() function dynamically generates a form based on the columns of


the selected table.

def create_entry_form(self):
"""Create entry form for adding records."""
if not self.current_table:
return

# Remove existing form if any


for widget in self.root.grid_slaves():
if int(widget.grid_info()["row"]) == 2:
widget.destroy()

form_frame = ttk.LabelFrame(self.root, text="Add New Record")


form_frame.grid(row=2, column=0, padx=10, pady=10, sticky="ew")

self.entry_widgets = {}
columns = get_table_columns(self.connection, self.current_table)

for idx, col in enumerate(columns):


label = ttk.Label(form_frame, text=col)
label.grid(row=idx, column=0, padx=5, pady=5)
entry = ttk.Entry(form_frame)
entry.grid(row=idx, column=1, padx=5, pady=5)
self.entry_widgets[col] = entry

submit_button = ttk.Button(form_frame, text="Add Record", command=self.add_record)


submit_button.grid(row=len(columns), column=0, columnspan=2, pady=10)
6. Running the Application

Finally, the run() method initializes and runs the Tkinter event loop.

def run(self):
"""Start the application."""
try:
self.root.mainloop()
finally:
if self.connection:
self.connection.close()

Conclusion

This project demonstrates how to use Python's Tkinter library to build a simple yet
functional database management interface.
It provides the ability to select tables, view data, and add records, all while handling
common database operations and errors.

You might also like