Scribd
Upload
7 views

CS_Project_Database_UI_with_Tkinter

Uploaded by

tvsaacademy6off
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
7 views

CS_Project_Database_UI_with_Tkinter

Uploaded by

tvsaacademy6off
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
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