Introduction to Databases

Databases are organized collections of data, designed to store, manage, and retrieve information efficiently. They are fundamental to almost every modern application, from social media platforms and e-commerce sites to banking systems and scientific research. Understanding databases is crucial for any Python developer looking to build robust and scalable applications. Python offers powerful libraries for interacting with various types of databases.

Relational vs. Non-Relational Databases

When working with data storage, a key distinction is between relational and non-relational databases, often referred to as NoSQL. Each type has its strengths and is suited for different kinds of applications and data structures.

Relational Databases

Relational databases store data in tables, which are structured with rows and columns. Each table represents a distinct entity (e.g., "users," "products," "orders"), and relationships between these entities are established using primary and foreign keys. This structured approach ensures data integrity and consistency. Popular relational database management systems (RDBMS) include MySQL, PostgreSQL, SQLite, Oracle, and SQL Server. They are ideal for applications requiring ACID (Atomicity, Consistency, Isolation, Durability) properties, complex queries, and predefined schemas.

Non-Relational Databases (NoSQL)

Non-relational databases, or NoSQL databases, offer more flexible data models than traditional relational databases. They are designed to handle large volumes of unstructured or semi-structured data, making1 them well-suited for big data applications,2 real-time web applications, and scenarios where schema flexibility is important. NoSQL databases come in various types, including:

Document Databases: Store data in flexible, semi-structured documents (e.g., JSON, BSON). Examples: MongoDB, Couchbase.

Key-Value Stores: Simple databases that store data as a collection of key-value pairs. Examples: Redis, DynamoDB.

Column-Family Stores: Store data in columns rather than rows, optimized for analytical queries on large datasets. Examples: Cassandra, HBase.

Graph Databases: Represent data as nodes and edges, ideal for highly interconnected data like social networks. Examples: Neo4j, Amazon Neptune.

Choosing between relational and non-relational databases depends on your project's specific requirements, data structure, scalability needs, and consistency demands. Python provides excellent libraries for interacting with both types, making it a versatile language for database programming.

SQL Basics (SELECT, INSERT, UPDATE, DELETE)

SQL (Structured Query Language) is the standard language for managing and manipulating relational databases. Mastering SQL is essential for anyone working with databases. Python's sqlite3 module (for SQLite databases) and various third-party libraries for other RDBMS (like psycopg2 for PostgreSQL or mysql-connector-python for MySQL) allow you to execute SQL commands directly from your Python scripts.

SELECT Statement

The SELECT statement is used to retrieve data from one or more tables in a database. It's the most frequently used SQL command for querying information.

Example 1: Basic SELECT (Beginner Friendly)

import sqlite3

# Connect to a SQLite database (or create it if it doesn't exist)
conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Create a simple table named 'users' if it doesn't exist
cursor.execute('''
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY,
        name TEXT NOT NULL,
        email TEXT UNIQUE
    )
''')

# Insert some sample data if the table is empty
cursor.execute("INSERT OR IGNORE INTO users (id, name, email) VALUES (1, 'Alice', 'alice@example.com')")
cursor.execute("INSERT OR IGNORE INTO users (id, name, email) VALUES (2, 'Bob', 'bob@example.com')")
cursor.execute("INSERT OR IGNORE INTO users (id, name, email) VALUES (3, 'Charlie', 'charlie@example.com')")
conn.commit() # Save changes to the database

# Select all columns from the 'users' table
print("All users:")
cursor.execute("SELECT * FROM users")
rows = cursor.fetchall() # Fetch all results
for row in rows:
    print(row)

# Close the connection
conn.close()

Explanation

This Python database example demonstrates how to connect to an SQLite database, create a table if it doesn't exist, insert some initial data, and then use the SQL SELECT * FROM users query to retrieve all rows and columns from the users table. The cursor.fetchall() method fetches all the results of the query, which are then printed to the console. This is a fundamental operation for retrieving data in Python with SQL.

Example 2: SELECT with WHERE Clause (Intermediate)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Select users with a specific name
print("\nUsers named Bob:")
cursor.execute("SELECT name, email FROM users WHERE name = 'Bob'")
rows = cursor.fetchall()
for row in rows:
    print(row)

# Select users with an ID greater than 1
print("\nUsers with ID greater than 1:")
cursor.execute("SELECT id, name FROM users WHERE id > 1")
rows = cursor.fetchall()
for row in rows:
    print(row)

conn.close()

Explanation

This example builds upon the basic SELECT by introducing the WHERE clause. The WHERE clause allows you to filter the results based on specified conditions. Here, we demonstrate selecting users with a name equal to 'Bob' and then selecting users where their id is greater than 1. This is crucial for targeted data retrieval in SQL databases.

Example 3: SELECT with ORDER BY and LIMIT (Advanced Beginner)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Select users, ordered by name in descending order, limit to 2
print("\nUsers ordered by name (descending), top 2:")
cursor.execute("SELECT name, email FROM users ORDER BY name DESC LIMIT 2")
rows = cursor.fetchall()
for row in rows:
    print(row)

conn.close()

Explanation

This Python database query example demonstrates ORDER BY and LIMIT clauses. ORDER BY name DESC sorts the results by the name column in descending alphabetical order, while LIMIT 2 restricts the output to only the first two rows after sorting. These clauses are vital for organizing and paginating results when performing data retrieval in SQL.

Example 4: SELECT with JOIN (Intermediate)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Create a 'products' table and insert some data
cursor.execute('''
    CREATE TABLE IF NOT EXISTS products (
        product_id INTEGER PRIMARY KEY,
        product_name TEXT NOT NULL,
        price REAL
    )
''')
cursor.execute("INSERT OR IGNORE INTO products (product_id, product_name, price) VALUES (101, 'Laptop', 1200.00)")
cursor.execute("INSERT OR IGNORE INTO products (product_id, product_name, price) VALUES (102, 'Mouse', 25.00)")
cursor.execute("INSERT OR IGNORE INTO products (product_id, product_name, price) VALUES (103, 'Keyboard', 75.00)")

# Create an 'orders' table to link users and products
cursor.execute('''
    CREATE TABLE IF NOT EXISTS orders (
        order_id INTEGER PRIMARY KEY,
        user_id INTEGER,
        product_id INTEGER,
        quantity INTEGER,
        FOREIGN KEY (user_id) REFERENCES users(id),
        FOREIGN KEY (product_id) REFERENCES products(product_id)
    )
''')
cursor.execute("INSERT OR IGNORE INTO orders (order_id, user_id, product_id, quantity) VALUES (1, 1, 101, 1)")
cursor.execute("INSERT OR IGNORE INTO orders (order_id, user_id, product_id, quantity) VALUES (2, 2, 102, 2)")
cursor.execute("INSERT OR IGNORE INTO orders (order_id, user_id, product_id, quantity) VALUES (3, 1, 103, 1)")
conn.commit()

# Select user names and the products they ordered using a JOIN
print("\nUsers and their ordered products:")
cursor.execute('''
    SELECT users.name, products.product_name
    FROM users
    JOIN orders ON users.id = orders.user_id
    JOIN products ON orders.product_id = products.product_id
''')
rows = cursor.fetchall()
for row in rows:
    print(row)

conn.close()

Explanation

This advanced Python database interaction example demonstrates the power of SQL JOIN statements. We create an orders table that links users and products tables. The JOIN clauses combine rows from multiple tables based on related columns, allowing us to retrieve meaningful insights like which user ordered which product. This is a common and powerful technique for relational database management.

Example 5: SELECT with Aggregate Functions and GROUP BY (Advanced)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Calculate the total quantity ordered per product
print("\nTotal quantity ordered per product:")
cursor.execute('''
    SELECT products.product_name, SUM(orders.quantity) AS total_ordered
    FROM products
    JOIN orders ON products.product_id = orders.product_id
    GROUP BY products.product_name
    ORDER BY total_ordered DESC
''')
rows = cursor.fetchall()
for row in rows:
    print(row)

# Calculate the number of orders per user
print("\nNumber of orders per user:")
cursor.execute('''
    SELECT users.name, COUNT(orders.order_id) AS num_orders
    FROM users
    JOIN orders ON users.id = orders.user_id
    GROUP BY users.name
    ORDER BY num_orders DESC
''')
rows = cursor.fetchall()
for row in rows:
    print(row)

conn.close()

Explanation

This advanced Python SQL example showcases aggregate functions (SUM, COUNT) and the GROUP BY clause. We calculate the total quantity ordered for each product and the number of orders placed by each user. GROUP BY groups rows that have the same values in specified columns into a summary row, enabling calculations across groups. This is essential for generating reports and insights from large datasets in SQL.

INSERT Statement

The INSERT INTO statement is used to add new rows of data into a table.

Example 1: Basic INSERT (Beginner Friendly)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Insert a new user into the 'users' table
try:
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ('David', 'david@example.com'))
    conn.commit() # Commit changes to the database
    print("New user 'David' inserted successfully.")
except sqlite3.IntegrityError as e:
    print(f"Error inserting David: {e}") # Handle potential unique constraint errors

# Verify the insertion
cursor.execute("SELECT * FROM users WHERE name = 'David'")
print("David's record:", cursor.fetchone())

conn.close()

Explanation

This Python database INSERT example demonstrates adding a new row to the users table. The INSERT INTO SQL command specifies the table and columns, and the VALUES clause provides the data. We use parameter placeholders (?) to prevent SQL injection vulnerabilities, a crucial security practice in Python database programming. conn.commit() saves the changes to the database.

Example 2: INSERT with Specific Columns (Intermediate)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Insert a new user, only providing name (email is optional)
try:
    cursor.execute("INSERT INTO users (name) VALUES (?)", ('Eve',))
    conn.commit()
    print("New user 'Eve' inserted successfully (email omitted).")
except sqlite3.Error as e:
    print(f"Error inserting Eve: {e}")

# Verify the insertion
cursor.execute("SELECT * FROM users WHERE name = 'Eve'")
print("Eve's record:", cursor.fetchone())

conn.close()

Explanation

This example shows how to perform an SQL INSERT into specific columns of a table. If a column is nullable or has a default value, you don't need to explicitly include it in the INSERT statement. This provides flexibility when adding new records to your relational database.

Example 3: INSERT Many Rows (Advanced Beginner)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

new_users = [
    ('Frank', 'frank@example.com'),
    ('Grace', 'grace@example.com'),
    ('Heidi', 'heidi@example.com')
]

try:
    cursor.executemany("INSERT INTO users (name, email) VALUES (?, ?)", new_users)
    conn.commit()
    print(f"{len(new_users)} new users inserted successfully using executemany.")
except sqlite3.IntegrityError as e:
    print(f"Error inserting multiple users: {e}")

# Verify the insertions
print("\nAll users after bulk insert:")
cursor.execute("SELECT * FROM users")
for row in cursor.fetchall():
    print(row)

conn.close()

Explanation

This Python database code demonstrates executemany(), a powerful method for inserting multiple rows into a database table in a single operation. This is significantly more efficient than individual INSERT statements when dealing with large datasets, improving the performance of your Python database applications.

Example 4: INSERT and Retrieve Last Inserted ID (Intermediate)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

new_product_name = 'Webcam'
new_product_price = 50.00

try:
    cursor.execute("INSERT INTO products (product_name, price) VALUES (?, ?)", (new_product_name, new_product_price))
    last_id = cursor.lastrowid # Get the ID of the last inserted row
    conn.commit()
    print(f"New product '{new_product_name}' inserted with ID: {last_id}")
except sqlite3.Error as e:
    print(f"Error inserting product: {e}")

# Verify the insertion using the last ID
cursor.execute("SELECT * FROM products WHERE product_id = ?", (last_id,))
print("Inserted product record:", cursor.fetchone())

conn.close()

Explanation

This example shows how to INSERT a new record and then immediately retrieve its auto-generated primary key (ID) using cursor.lastrowid. This is particularly useful when you need to use the newly created ID for subsequent operations, such as creating a related record in another table in your relational database.

Example 5: INSERT with NULL Values (Advanced)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Insert a user with a NULL email (if the column allows NULL)
try:
    cursor.execute("INSERT INTO users (name, email) VALUES (?, ?)", ('Ivan', None))
    conn.commit()
    print("New user 'Ivan' inserted with NULL email.")
except sqlite3.IntegrityError as e:
    print(f"Error inserting Ivan with NULL email: {e}")
except sqlite3.Error as e:
    print(f"General error inserting Ivan: {e}")


# Verify the insertion
cursor.execute("SELECT * FROM users WHERE name = 'Ivan'")
print("Ivan's record:", cursor.fetchone())

conn.close()

Explanation

This Python database example demonstrates inserting a NULL value into a column. This is permissible if the database schema for that column does not specify NOT NULL. Understanding how to handle NULL values is important for data completeness and flexibility in relational database design and Python database interactions.

UPDATE Statement

The UPDATE statement is used to modify existing records in a table.

Example 1: Basic UPDATE (Beginner Friendly)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Update Bob's email address
new_email = 'robert@example.com'
try:
    cursor.execute("UPDATE users SET email = ? WHERE name = ?", (new_email, 'Bob'))
    conn.commit()
    print(f"Bob's email updated to {new_email}.")
except sqlite3.Error as e:
    print(f"Error updating Bob's email: {e}")

# Verify the update
cursor.execute("SELECT * FROM users WHERE name = 'Bob'")
print("Bob's updated record:", cursor.fetchone())

conn.close()

Explanation

This Python database UPDATE example shows how to change data in an existing row. The SET clause specifies which column(s) to modify and their new values, and the WHERE clause identifies which rows to update. Without a WHERE clause, all rows in the table would be updated, which is usually not desired! This is a core operation for data modification in SQL databases.

Example 2: UPDATE Multiple Columns (Intermediate)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Update multiple columns for a product
product_id_to_update = 101
new_price = 1250.00
new_name = 'Gaming Laptop'

try:
    cursor.execute("UPDATE products SET product_name = ?, price = ? WHERE product_id = ?",
                   (new_name, new_price, product_id_to_update))
    conn.commit()
    print(f"Product ID {product_id_to_update} updated with new name '{new_name}' and price {new_price}.")
except sqlite3.Error as e:
    print(f"Error updating product {product_id_to_update}: {e}")

# Verify the update
cursor.execute("SELECT * FROM products WHERE product_id = ?", (product_id_to_update,))
print("Updated product record:", cursor.fetchone())

conn.close()

Explanation

This example demonstrates updating multiple columns in a single SQL UPDATE statement. This is efficient when several fields for a specific record need modification. It's a common scenario in Python database applications where you need to modify existing data.

Example 3: UPDATE with a Subquery or Expression (Advanced Beginner)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Increase the price of all products by 10%
try:
    cursor.execute("UPDATE products SET price = price * 1.10")
    conn.commit()
    print("All product prices increased by 10%.")
except sqlite3.Error as e:
    print(f"Error updating all product prices: {e}")

# Verify the updates
print("\nProducts after 10% price increase:")
cursor.execute("SELECT * FROM products")
for row in cursor.fetchall():
    print(row)

conn.close()

Explanation

This Python database UPDATE example shows how to use an expression in the SET clause. We're increasing the price of all products by 10% directly within the SQL query. This is a powerful feature for performing bulk updates or calculations on data in your relational database.

Example 4: Conditional UPDATE (Intermediate)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Update the quantity of an order, but only if the current quantity is less than 5
order_id_to_update = 2
new_quantity = 5

try:
    cursor.execute("UPDATE orders SET quantity = ? WHERE order_id = ? AND quantity < 5",
                   (new_quantity, order_id_to_update))
    conn.commit()
    if cursor.rowcount > 0:
        print(f"Order ID {order_id_to_update} quantity updated to {new_quantity} (only if original < 5).")
    else:
        print(f"Order ID {order_id_to_update} quantity was not updated (condition not met or order not found).")
except sqlite3.Error as e:
    print(f"Error conditionally updating order {order_id_to_update}: {e}")

# Verify the update
cursor.execute("SELECT * FROM orders WHERE order_id = ?", (order_id_to_update,))
print("Updated order record:", cursor.fetchone())

conn.close()

Explanation

This example demonstrates a conditional UPDATE using a more complex WHERE clause. The quantity for a specific order is only updated if its current quantity is less than 5. This is crucial for implementing business logic and ensuring data integrity in your Python database applications. cursor.rowcount is used to check if any rows were affected.

Example 5: UPDATE with JOIN (Advanced)

Note: SQLite does not directly support UPDATE ... JOIN syntax as in MySQL or PostgreSQL. For SQLite, you typically achieve this with subqueries or by performing a SELECT and then an UPDATE in Python logic if the logic is very complex. However, for illustrative purposes, if you were using a different RDBMS, the concept would be as follows (showing a conceptual example that might need adaptation for SQLite):

# This is a conceptual example for databases that support UPDATE with JOIN
# SQLite typically handles this with subqueries or separate SELECT/UPDATE operations.

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Conceptual: Update user emails based on an external 'new_emails' table.
# In a real SQLite scenario, you'd likely fetch data from 'new_emails'
# and then iterate to update 'users'.

# For demonstration, let's just update a user's email based on product_id purchased.
# This is less common but illustrates cross-table logic.
# More practical: update an order's status based on user's premium status from another table.

# Let's say we want to update the email of users who bought a 'Gaming Laptop'
# For SQLite, this would be a two-step process or a subquery.

# Step 1: Find users who bought 'Gaming Laptop'
cursor.execute('''
    SELECT users.id
    FROM users
    JOIN orders ON users.id = orders.user_id
    JOIN products ON orders.product_id = products.product_id
    WHERE products.product_name = 'Gaming Laptop'
''')
user_ids_to_update = [row[0] for row in cursor.fetchall()]

if user_ids_to_update:
    new_email_suffix = "_VIP@example.com"
    for user_id in user_ids_to_update:
        try:
            # Fetch current user name to construct new email
            cursor.execute("SELECT name FROM users WHERE id = ?", (user_id,))
            user_name = cursor.fetchone()[0]
            new_email = f"{user_name.lower()}{new_email_suffix}"

            cursor.execute("UPDATE users SET email = ? WHERE id = ?", (new_email, user_id))
            print(f"User ID {user_id}'s email updated to {new_email}.")
        except sqlite3.Error as e:
            print(f"Error updating user {user_id}'s email: {e}")
    conn.commit()
else:
    print("No users found who bought 'Gaming Laptop' to update.")

# Verify the updates
print("\nUsers after conditional email update:")
cursor.execute("SELECT * FROM users")
for row in cursor.fetchall():
    print(row)

conn.close()

Explanation

While direct UPDATE ... JOIN syntax is not universally supported by all SQL databases (like SQLite), this example illustrates the concept of updating data in one table based on conditions in another related table. In SQLite, this is typically achieved by first querying the necessary information (e.g., user IDs) using JOIN (Step 1), and then using those results to perform targeted UPDATE statements (Step 2). This is an advanced pattern for managing complex data dependencies and relational database operations in Python.

DELETE Statement

The DELETE FROM statement is used to remove existing rows from a table.

Example 1: Basic DELETE (Beginner Friendly)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Delete a user named 'Charlie'
try:
    cursor.execute("DELETE FROM users WHERE name = ?", ('Charlie',))
    conn.commit()
    print("User 'Charlie' deleted successfully.")
except sqlite3.Error as e:
    print(f"Error deleting Charlie: {e}")

# Verify the deletion
cursor.execute("SELECT * FROM users WHERE name = 'Charlie'")
print("Charlie's record after deletion:", cursor.fetchone())

conn.close()

Explanation

This Python database DELETE example demonstrates removing a specific row from the users table. The WHERE clause is crucial here, as it specifies which rows to delete. Without a WHERE clause, the DELETE statement would remove all rows from the table! This is a fundamental operation for data removal in SQL databases.

Example 2: DELETE by ID (Intermediate)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Delete a product by its ID
product_id_to_delete = 102
try:
    cursor.execute("DELETE FROM products WHERE product_id = ?", (product_id_to_delete,))
    conn.commit()
    if cursor.rowcount > 0:
        print(f"Product ID {product_id_to_delete} deleted successfully.")
    else:
        print(f"Product ID {product_id_to_delete} not found.")
except sqlite3.Error as e:
    print(f"Error deleting product {product_id_to_delete}: {e}")

# Verify the deletion
cursor.execute("SELECT * FROM products WHERE product_id = ?", (product_id_to_delete,))
print("Product record after deletion:", cursor.fetchone())

conn.close()

Explanation

This example illustrates deleting a record using its primary key, product_id. Deleting by ID is a very common and precise way to remove specific data entries, ensuring you only affect the intended record in your relational database. cursor.rowcount is used to confirm if a row was actually deleted.

Example 3: DELETE with Multiple Conditions (Advanced Beginner)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Delete orders with a quantity less than 2 and placed by user ID 2
try:
    cursor.execute("DELETE FROM orders WHERE quantity < ? AND user_id = ?", (2, 2))
    conn.commit()
    if cursor.rowcount > 0:
        print(f"{cursor.rowcount} order(s) deleted based on quantity and user ID conditions.")
    else:
        print("No orders matched the deletion criteria.")
except sqlite3.Error as e:
    print(f"Error deleting orders: {e}")

# Verify deletions
print("\nRemaining orders:")
cursor.execute("SELECT * FROM orders")
for row in cursor.fetchall():
    print(row)

conn.close()

Explanation

This Python database DELETE example demonstrates using multiple conditions in the WHERE clause with AND. This allows for more precise targeting of records to be deleted, ensuring data integrity in complex database scenarios within your Python application.

Example 4: DELETE All Rows (CAUTION!) (Intermediate)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# !!! CAUTION: This will delete ALL rows from the 'orders' table !!!
user_confirmation = input("Are you sure you want to delete ALL orders? (yes/no): ").lower()

if user_confirmation == 'yes':
    try:
        cursor.execute("DELETE FROM orders")
        conn.commit()
        print("ALL orders deleted from the 'orders' table.")
    except sqlite3.Error as e:
        print(f"Error deleting all orders: {e}")
else:
    print("Deletion cancelled.")

# Verify that the table is empty (or not, if cancelled)
print("\nRemaining orders (should be empty if confirmed deletion):")
cursor.execute("SELECT * FROM orders")
for row in cursor.fetchall():
    print(row)

conn.close()

Explanation

This example demonstrates a DELETE FROM table_name statement without a WHERE clause, which removes all rows from the table. This is a powerful but dangerous operation, often requiring user confirmation in real applications. This Python database code highlights the importance of careful SQL query construction and user interaction for critical data operations.

Example 5: DELETE with Subquery (Advanced)

import sqlite3

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

# Delete users who have not placed any orders
try:
    cursor.execute('''
        DELETE FROM users
        WHERE id NOT IN (SELECT DISTINCT user_id FROM orders)
    ''')
    conn.commit()
    if cursor.rowcount > 0:
        print(f"{cursor.rowcount} user(s) deleted who had no orders.")
    else:
        print("No users without orders found to delete.")
except sqlite3.Error as e:
    print(f"Error deleting users with no orders: {e}")

# Verify the deletions
print("\nRemaining users (only those with orders):")
cursor.execute("SELECT * FROM users")
for row in cursor.fetchall():
    print(row)

conn.close()

Explanation

This advanced Python database DELETE example uses a subquery to define the criteria for deletion. It deletes users whose id is not present in the user_id column of the orders table (i.e., users who have not placed any orders). This demonstrates how to perform complex, data-dependent deletions, a key skill for advanced SQL and Python database management.