Python MySQL - DBMS vs File System

What You'll Learn Here

What is a File System — storing data in files
What is a DBMS — storing data in databases
Key differences — speed, security, relationships
When to use each — choosing the right tool
Real-world examples — see the difference

File System vs Database

When you need to store data, you have two main options: files or a database. Both store data, but they work in very different ways.

Think of it like storing clothes. You could throw all your clothes in one big pile on the floor (like a file system). Or you could use a wardrobe with drawers, hangers, and shelves (like a database). Both store your clothes, but one makes it much easier to find what you need.

In this tutorial, we'll compare file systems and databases so you know when to use each one.

💡 Key concept: File systems store data as files. Databases store data in structured tables with relationships. Choose based on your needs.

What is a File System?

Storing Data in Files

A file system is how your computer organizes and stores files on a disk. When you save a text file, a CSV file, or a JSON file, you're using a file system.

Think of a file system like a filing cabinet. Each file is a folder in the cabinet. You can open a folder, read what's inside, write new information, or throw the whole folder away.

# File System - Storing Data in Files

print("=" * 50)
print("FILE SYSTEM - STORING DATA IN FILES")
print("=" * 50)

import json
import csv
import os

# ============================================================
# STORING DATA IN A TEXT FILE
# ============================================================

print("\n1. STORING DATA IN A TEXT FILE")

# Writing data
data = "Alice,30,alice@example.com"
with open("user.txt", "w") as f:
    f.write(data)
print("   Saved to user.txt")

# Reading data
with open("user.txt", "r") as f:
    content = f.read()
print(f"   Read from user.txt: {content}")

# Clean up
os.remove("user.txt")
print("   Removed user.txt")


# ============================================================
# STORING DATA IN CSV
# ============================================================

print("\n2. STORING DATA IN CSV")

# Writing CSV
users = [
    ["name", "age", "email"],
    ["Alice", 30, "alice@example.com"],
    ["Bob", 25, "bob@example.com"]
]

with open("users.csv", "w", newline='') as f:
    writer = csv.writer(f)
    writer.writerows(users)
print("   Saved to users.csv")

# Reading CSV
with open("users.csv", "r") as f:
    reader = csv.reader(f)
    for row in reader:
        print(f"      {row}")

# Clean up
os.remove("users.csv")
print("   Removed users.csv")


# ============================================================
# STORING DATA IN JSON
# ============================================================

print("\n3. STORING DATA IN JSON")

# Writing JSON
users = [
    {"name": "Alice", "age": 30, "email": "alice@example.com"},
    {"name": "Bob", "age": 25, "email": "bob@example.com"}
]

with open("users.json", "w") as f:
    json.dump(users, f, indent=2)
print("   Saved to users.json")

# Reading JSON
with open("users.json", "r") as f:
    data = json.load(f)
    for user in data:
        print(f"      {user}")

# Clean up
os.remove("users.json")
print("   Removed users.json")


# ============================================================
# FILE SYSTEM - PROS AND CONS
# ============================================================

print("\n4. FILE SYSTEM - PROS AND CONS")

print("""
┌─────────────────────────────────────────────────────────────────────┐
│ FILE SYSTEM - PROS AND CONS                                        │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  PROS:                                                             │
│  • Simple to use                                                    │
│  • No setup required                                                │
│  • Works with any program                                          │
│  • Good for small amounts of data                                  │
│  • Easy to backup (just copy the file)                             │
│                                                                     │
│  CONS:                                                             │
│  • No built-in security                                            │
│  • No relationships between files                                  │
│  • Slower for searching large amounts of data                     │
│  • No data validation                                              │
│  • No concurrent access control                                    │
│  • Data redundancy (same data in multiple files)                  │
│  • Hard to manage updates                                          │
└─────────────────────────────────────────────────────────────────────┘
""")

File system key points:

Simple — easy to use and understand
No setup — works right away
Limited — no security, relationships, or validation
Good for small data — files work well for small amounts

Quick Check: What is a file system? (Answer: A way to store data as files on a disk)

What is a DBMS?

Storing Data in a Database

A DBMS (Database Management System) is software that helps you store, organize, and manage data in a structured way. MySQL is one of the most popular DBMS.

Think of a DBMS like a library. Books are organized by category, author, and title. There's a catalog to find books quickly. The library has rules for borrowing and returning books. Everything is structured and managed.

# DBMS - Storing Data in a Database

print("=" * 50)
print("DBMS - STORING DATA IN A DATABASE")
print("=" * 50)

# This is a simulation of what a database does
# In real code, you'd use MySQL with Python

print("\n1. SIMULATED DATABASE TABLE")

# Simulating a database table
users_table = [
    {"id": 1, "name": "Alice", "age": 30, "email": "alice@example.com"},
    {"id": 2, "name": "Bob", "age": 25, "email": "bob@example.com"}
]

print("   Users table:")
for user in users_table:
    print(f"      {user}")


# ============================================================
# RELATIONSHIPS BETWEEN TABLES
# ============================================================

print("\n2. RELATIONSHIPS BETWEEN TABLES")

# Orders table (each order belongs to a user)
orders_table = [
    {"id": 1, "user_id": 1, "product": "Laptop", "price": 999.99},
    {"id": 2, "user_id": 1, "product": "Mouse", "price": 29.99},
    {"id": 3, "user_id": 2, "product": "Phone", "price": 699.99}
]

print("   Orders table:")
for order in orders_table:
    print(f"      {order}")

print("\n   Relationships:")
print("   Order 1 belongs to Alice (user_id: 1)")
print("   Order 3 belongs to Bob (user_id: 2)")


# ============================================================
# QUERYING DATA
# ============================================================

print("\n3. QUERYING DATA")

def get_user_orders(user_id):
    """Find all orders for a specific user (like a SQL query)"""
    result = []
    for order in orders_table:
        if order["user_id"] == user_id:
            result.append(order)
    return result

print("   Alice's orders:")
alice_orders = get_user_orders(1)
for order in alice_orders:
    print(f"      {order}")


# ============================================================
# DATA VALIDATION
# ============================================================

print("\n4. DATA VALIDATION")

def add_user(name, age, email):
    """Simulate database validation"""
    # Check age
    if age < 0:
        raise ValueError("Age cannot be negative")
    if age > 150:
        raise ValueError("Age must be realistic")
    
    # Check email format
    if '@' not in email or '.' not in email:
        raise ValueError("Invalid email format")
    
    # Check for duplicate email
    for user in users_table:
        if user["email"] == email:
            raise ValueError("Email already exists")
    
    # Add the user
    new_id = len(users_table) + 1
    new_user = {"id": new_id, "name": name, "age": age, "email": email}
    users_table.append(new_user)
    return new_user

print("   Validating and adding a user:")
try:
    new_user = add_user("Charlie", 28, "charlie@example.com")
    print(f"   Added: {new_user}")
except ValueError as e:
    print(f"   ❌ Error: {e}")

try:
    add_user("Diana", 200, "diana@example.com")
except ValueError as e:
    print(f"   ❌ Error: {e}")

try:
    add_user("Eve", 25, "invalid-email")
except ValueError as e:
    print(f"   ❌ Error: {e}")


# ============================================================
# DBMS - PROS AND CONS
# ============================================================

print("\n5. DBMS - PROS AND CONS")

print("""
┌─────────────────────────────────────────────────────────────────────┐
│ DBMS - PROS AND CONS                                               │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  PROS:                                                             │
│  • Built-in security (user accounts, permissions)                  │
│  • Relationships between tables                                    │
│  • Fast searching with indexes                                     │
│  • Data validation and integrity                                   │
│  • Concurrent access (multiple users at once)                     │
│  • ACID transactions (safety with multiple operations)            │
│  • Data backup and recovery                                       │
│  • Reduces data redundancy                                         │
│                                                                     │
│  CONS:                                                             │
│  • More complex to set up                                          │
│  • Requires installation and configuration                        │
│  • Learning curve                                                  │
│  • Overkill for small applications                                 │
└─────────────────────────────────────────────────────────────────────┘
""")

DBMS key points:

Structured — data is organized in tables
Relationships — tables can be linked
Secure — built-in security and permissions
Fast — indexes make searching quick
Reliable — transactions and validation

Quick Check: What is a DBMS? (Answer: Database Management System — software that manages structured data)

Key Differences

File System vs DBMS Side by Side

Let's compare file systems and DBMS across key features.

# File System vs DBMS Comparison

print("=" * 50)
print("FILE SYSTEM vs DBMS COMPARISON")
print("=" * 50)

# ============================================================
# 1. DATA ORGANIZATION
# ============================================================

print("\n1. DATA ORGANIZATION")

print("""
┌─────────────────────┬──────────────────────────────────────────────┐
│ File System         │ DBMS                                        │
├─────────────────────┼──────────────────────────────────────────────┤
│ Files and folders   │ Tables with rows and columns                │
│ No relationships    │ Relationships between tables                │
│ Unstructured or     │ Highly structured                           │
│ semi-structured     │                                             │
└─────────────────────┴──────────────────────────────────────────────┘
""")


# ============================================================
# 2. DATA ACCESS
# ============================================================

print("\n2. DATA ACCESS")

print("""
┌─────────────────────┬──────────────────────────────────────────────┐
│ File System         │ DBMS                                        │
├─────────────────────┼──────────────────────────────────────────────┤
│ Read entire file    │ Query specific data (SELECT with WHERE)    │
│ Manual searching    │ Fast with indexes                           │
│ No query language   │ SQL (Structured Query Language)             │
│ Program reads file  │ Database engine handles queries             │
└─────────────────────┴──────────────────────────────────────────────┘
""")


# ============================================================
# 3. DATA INTEGRITY
# ============================================================

print("\n3. DATA INTEGRITY")

print("""
┌─────────────────────┬──────────────────────────────────────────────┐
│ File System         │ DBMS                                        │
├─────────────────────┼──────────────────────────────────────────────┤
│ No validation       │ Data validation (types, constraints)        │
│ No relationships    │ Foreign key constraints                     │
│ No uniqueness       │ Unique constraints                          │
│ Manual consistency  │ Automatic consistency (ACID)                │
└─────────────────────┴──────────────────────────────────────────────┘
""")


# ============================================================
# 4. SECURITY
# ============================================================

print("\n4. SECURITY")

print("""
┌─────────────────────┬──────────────────────────────────────────────┐
│ File System         │ DBMS                                        │
├─────────────────────┼──────────────────────────────────────────────┤
│ OS-level permissions│ User accounts and permissions               │
│ No user management  │ Granular access control                     │
│ Anyone can read     │ Can restrict access by user                 │
│ No audit trail      │ Audit logs available                        │
└─────────────────────┴──────────────────────────────────────────────┘
""")


# ============================================================
# 5. DATA REDUNDANCY
# ============================================================

print("\n5. DATA REDUNDANCY")

print("""
┌─────────────────────┬──────────────────────────────────────────────┐
│ File System         │ DBMS                                        │
├─────────────────────┼──────────────────────────────────────────────┤
│ Data duplication    │ Normalization reduces redundancy            │
│ Same data in many   │ Data stored once, referenced many times    │
│ files               │                                             │
│ Hard to update all  │ Update once, applies everywhere             │
│ copies               │                                             │
└─────────────────────┴──────────────────────────────────────────────┘
""")

# ============================================================
# 6. CONCURRENT ACCESS
# ============================================================

print("\n6. CONCURRENT ACCESS")

print("""
┌─────────────────────┬──────────────────────────────────────────────┐
│ File System         │ DBMS                                        │
├─────────────────────┼──────────────────────────────────────────────┤
│ One user at a time  │ Multiple users simultaneously               │
│ File locks          │ Transaction isolation                       │
│ Can cause conflicts │ Handles concurrent access safely            │
│ No transaction      │ ACID transactions                           │
│ support             │                                             │
└─────────────────────┴──────────────────────────────────────────────┘
""")


# ============================================================
# COMPLETE COMPARISON TABLE
# ============================================================

print("\n7. COMPLETE COMPARISON TABLE")

print("""
┌─────────────────────────────┬──────────────────────────────┬──────────────────────────────────┐
│ FEATURE                     │ FILE SYSTEM                  │ DBMS                             │
├─────────────────────────────┼──────────────────────────────┼──────────────────────────────────┤
│ Data Structure              │ Files and folders            │ Tables (rows and columns)        │
│ Relationships               │ None                         │ Yes (foreign keys)               │
│ Query Language              │ None                         │ SQL                              │
│ Searching                   │ Manual (slow)                │ Indexed (fast)                   │
│ Data Validation             │ None                         │ Yes                              │
│ Security                    │ OS-level                     │ User-level (granular)            │
│ Concurrent Access           │ Limited                      │ Full support                     │
│ Data Redundancy             │ High                         │ Low (normalized)                 │
│ ACID Transactions           │ No                           │ Yes                              │
│ Backup                      │ Copy files                   │ Built-in backup tools            │
│ Scalability                 │ Limited                      │ High                             │
│ Complexity                  │ Low                          │ Medium to High                   │
│ Best For                    │ Small data, simple apps     │ Large data, multi-user apps      │
└─────────────────────────────┴──────────────────────────────┴──────────────────────────────────┘
""")

Comparison key points:

Data organization — files vs tables
Searching — manual vs indexed
Security — OS-level vs user-level
Concurrency — limited vs full support
Redundancy — high vs low

Quick Check: Which is better for multiple users accessing data simultaneously? (Answer: DBMS)

When to Use What

Choosing the Right Tool

Here's a simple guide to help you choose between a file system and a database.

# When to Use File System vs DBMS

print("=" * 50)
print("WHEN TO USE WHAT")
print("=" * 50)

# ============================================================
# USE FILE SYSTEM WHEN
# ============================================================

print("\n1. USE FILE SYSTEM WHEN")

print("""
✅ Your data is simple and small
   Example: Configuration files, logs

✅ You only need to read/write sequentially
   Example: Reading a CSV file from start to end

✅ Only one user/application accesses the data
   Example: A personal script

✅ No relationships between data
   Example: Just storing some settings

✅ You don't need complex queries
   Example: Just read the whole file

✅ You want something quick and simple
   Example: Prototyping or small projects
""")


# ============================================================
# USE DBMS WHEN
# ============================================================

print("\n2. USE DBMS WHEN")

print("""
✅ You have large amounts of data
   Example: Thousands or millions of records

✅ Multiple users need to access data
   Example: Web applications with many users

✅ You need to search for specific data quickly
   Example: Finding a user by email

✅ You have relationships between data
   Example: Users, orders, products

✅ You need data validation and integrity
   Example: Age must be positive, email must be valid

✅ Multiple operations need to be atomic (all or nothing)
   Example: Transferring money between accounts

✅ You need security and access control
   Example: Different users have different permissions

✅ You need to scale as your application grows
   Example: Start small but expect to grow
""")


# ============================================================
# DECISION GUIDE
# ============================================================

print("\n3. DECISION GUIDE")

print("""
┌─────────────────────────────────────────────────────────────────────┐
│ QUICK DECISION GUIDE                                                │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Ask yourself these questions:                                     │
│                                                                     │
│  1. How much data do you have?                                     │
│     • Small (< 1000 records) → Consider files                      │
│     • Large (> 1000 records) → Consider database                   │
│                                                                     │
│  2. Do you need to search for data?                                │
│     • Rarely → Files are fine                                      │
│     • Often → Database is better                                   │
│                                                                     │
│  3. How many users/access it?                                      │
│     • One → Files are fine                                         │
│     • Many → Database is needed                                    │
│                                                                     │
│  4. Do you have relationships?                                     │
│     • No → Files might be fine                                     │
│     • Yes → Database is better                                     │
│                                                                     │
│  5. Do you need data validation?                                   │
│     • No → Files might be fine                                     │
│     • Yes → Database is better                                     │
│                                                                     │
│  6. Will your data grow?                                           │
│     • No → Files are fine                                          │
│     • Yes → Database is better                                     │
└─────────────────────────────────────────────────────────────────────┘
""")

When to use each key points:

File system — small data, simple needs, one user
DBMS — large data, multiple users, relationships, security
Consider growth — if your data will grow, start with a database
Consider complexity — databases are more complex to set up

Quick Check: When should you use a file system instead of a database? (Answer: When you have small, simple data and only one user)

Real-World Example

Building a Simple Application

# Real-World Example: Student Management System

import json
import os

print("=" * 60)
print("STUDENT MANAGEMENT SYSTEM")
print("=" * 60)

# ============================================================
# VERSION 1: Using Files (Simple)
# ============================================================

class FileStudentManager:
    """Manage students using a file"""
    
    def __init__(self, filename="students.json"):
        self.filename = filename
        self.students = []
        self.load()
    
    def load(self):
        """Load students from file"""
        if os.path.exists(self.filename):
            with open(self.filename, "r") as f:
                self.students = json.load(f)
        else:
            self.students = []
    
    def save(self):
        """Save students to file"""
        with open(self.filename, "w") as f:
            json.dump(self.students, f, indent=2)
    
    def add_student(self, name, grade, age):
        """Add a student"""
        student = {
            "id": len(self.students) + 1,
            "name": name,
            "grade": grade,
            "age": age
        }
        self.students.append(student)
        self.save()
        return student
    
    def get_all(self):
        """Get all students"""
        return self.students
    
    def find_by_name(self, name):
        """Find students by name (slow - scans all)"""
        result = []
        for student in self.students:
            if name.lower() in student["name"].lower():
                result.append(student)
        return result


# ============================================================
# VERSION 2: Using Database (Better for large data)
# ============================================================

class DBStudentManager:
    """Manage students using a database (simulated)"""
    
    def __init__(self):
        # In real code, this would connect to MySQL
        self.students = []
        self.next_id = 1
        self.index_by_name = {}  # Simulates database index
    
    def add_student(self, name, grade, age):
        """Add a student with validation"""
        # Validation (like database constraints)
        if age < 0 or age > 150:
            raise ValueError("Invalid age")
        if not name or not name.strip():
            raise ValueError("Name cannot be empty")
        if grade not in ["A", "B", "C", "D", "F"]:
            raise ValueError("Invalid grade")
        
        student = {
            "id": self.next_id,
            "name": name,
            "grade": grade,
            "age": age
        }
        self.students.append(student)
        self.next_id += 1
        
        # Update index (like database index)
        if name not in self.index_by_name:
            self.index_by_name[name] = []
        self.index_by_name[name].append(student)
        
        return student
    
    def get_all(self):
        """Get all students"""
        return self.students
    
    def find_by_name(self, name):
        """Find students by name (fast - uses index)"""
        return self.index_by_name.get(name, [])
    
    def find_by_grade(self, grade):
        """Find students by grade (fast - uses index)"""
        result = []
        for student in self.students:
            if student["grade"] == grade:
                result.append(student)
        return result


# ============================================================
# DEMONSTRATION
# ============================================================

print("\n1. USING FILE SYSTEM")
file_manager = FileStudentManager()
file_manager.add_student("Alice", "A", 20)
file_manager.add_student("Bob", "B", 22)
file_manager.add_student("Charlie", "A", 21)

print("   All students:")
for student in file_manager.get_all():
    print(f"      {student}")

print("\n   Searching for 'Ali':")
results = file_manager.find_by_name("Ali")
for student in results:
    print(f"      {student}")

print("\n   File saved to: students.json")

print("\n2. USING DATABASE (Simulated)")
db_manager = DBStudentManager()
db_manager.add_student("Alice", "A", 20)
db_manager.add_student("Bob", "B", 22)
db_manager.add_student("Charlie", "A", 21)

print("   All students:")
for student in db_manager.get_all():
    print(f"      {student}")

print("\n   Searching for 'Alice' (using index):")
results = db_manager.find_by_name("Alice")
for student in results:
    print(f"      {student}")

print("\n   Searching by grade:")
results = db_manager.find_by_grade("A")
for student in results:
    print(f"      {student}")

print("\n3. FILE vs DATABASE COMPARISON")
print("""
┌─────────────────────┬──────────────────────────────┬──────────────────────────────┐
│                     │ FILE SYSTEM                  │ DATABASE                     │
├─────────────────────┼──────────────────────────────┼──────────────────────────────┤
│ Setup               │ Simple (one file)            │ More complex                 │
│ Speed               │ Slow for searching           │ Fast with indexes            │
│ Validation          │ None                         │ Built-in                     │
│ Relationships       │ None                         │ Supported                    │
│ Concurrent Access   │ Limited                      │ Full support                 │
│ Scalability         │ Limited                      │ High                         │
│ Best For            │ Small data, prototyping      │ Production applications      │
└─────────────────────┴──────────────────────────────┴──────────────────────────────┘
""")

print("\n4. CLEAN UP")
if os.path.exists("students.json"):
    os.remove("students.json")
    print("   Removed students.json")

Real-world example key points:

File system — simple, but slow for searching
Database — more complex, but faster and more features
Validation — databases enforce data quality
Indexes — databases make searching fast

Quick Check: What advantage does a database have over a file system for searching? (Answer: Indexes make searching fast)

Best Practices

Choosing Wisely

# Best Practices for Choosing Storage

print("=" * 60)
print("BEST PRACTICES")
print("=" * 60)

# ============================================================
# 1. EVALUATE YOUR NEEDS
# ============================================================

print("\n1. EVALUATE YOUR NEEDS")

print("""
Before choosing, ask these questions:

    1. How much data will you store?
    2. How many users will access it?
    3. How fast do you need to query data?
    4. Do you have relationships between data?
    5. Do you need data validation?
    6. Will your data grow?
    7. Do you need security?
    8. What's your budget for setup and maintenance?

Be honest about your needs. Don't use a database for 10 records.
Don't use files for 1 million records.
""")


# ============================================================
# 2. START SIMPLE, SCALE AS NEEDED
# ============================================================

print("\n2. START SIMPLE, SCALE AS NEEDED")

print("""
# Start with a file if you're prototyping
# Move to a database when you need it

Example:
    Phase 1: Use JSON files (prototype)
    Phase 2: Move to SQLite (simple database)
    Phase 3: Move to MySQL/PostgreSQL (production)
""")


# ============================================================
# 3. PLAN FOR GROWTH
# ============================================================

print("\n3. PLAN FOR GROWTH")

print("""
# If you expect your data to grow, use a database from the start
# Migrating from files to database later is painful!

    if expected_growth:
        use_database()
    else:
        use_files()
""")


# ============================================================
# 4. USE THE RIGHT TOOL FOR THE JOB
# ============================================================

print("\n4. USE THE RIGHT TOOL FOR THE JOB")

print("""
┌─────────────────────────────┬─────────────────────────────────────────────┐
│ SITUATION                   │ RECOMMENDATION                              │
├─────────────────────────────┼─────────────────────────────────────────────┤
│ Configuration data          │ File (JSON/YAML)                           │
│ Logs                        │ File (text)                                │
│ Small app (< 1000 records)  │ File (CSV/JSON)                            │
│ Medium app (1000-100k)      │ SQLite or MySQL                            │
│ Large app (> 100k)          │ MySQL/PostgreSQL                           │
│ Multi-user app              │ MySQL/PostgreSQL                           │
│ Web application             │ MySQL/PostgreSQL                           │
│ Data analysis               │ MySQL (with indexes)                       │
│ Machine learning            │ Files (for small) or DB (for large)       │
└─────────────────────────────┴─────────────────────────────────────────────┘
""")

# ============================================================
# 5. SUMMARY
# ============================================================

print("\n5. SUMMARY")

print("""
┌─────────────────────────────────────────────────────────────────────┐
│ KEY TAKEAWAYS                                                       │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  FILE SYSTEM:                                                       │
│  • Simple and easy to use                                          │
│  • Good for small data                                             │
│  • No relationships or validation                                  │
│  • Use for: configs, logs, prototypes                              │
│                                                                     │
│  DBMS (DATABASE):                                                   │
│  • More complex but more powerful                                  │
│  • Good for large data                                             │
│  • Relationships, validation, security                             │
│  • Use for: web apps, multi-user apps, production                  │
│                                                                     │
│  RULE OF THUMB:                                                     │
│  "Use files when you can, databases when you must"                 │
│  But remember: it's easier to start with a database than to       │
│  migrate from files later!                                         │
└─────────────────────────────────────────────────────────────────────┘
""")

Best practices summary:

Evaluate needs — know what you need before choosing
Start simple — use files for prototyping
Plan for growth — if you'll grow, start with a database
Right tool — use the right tool for each situation

Quick Check: What should you do if you expect your data to grow significantly? (Answer: Use a database from the start)

Try It Yourself

Experiment with file system vs database approaches in the editor below.

Loading Pyodide... 0%

Python Code Editor

# Python DBMS vs File System - Practice

import json
import time

print("=" * 50)
print("DBMS vs FILE SYSTEM - PRACTICE")
print("=" * 50)

# ============================================================
# 1. STORING DATA IN FILE
# ============================================================

print("\n1. STORING DATA IN FILE")

class FileData:
    def __init__(self):
        self.data = []
    
    def add(self, item):
        self.data.append(item)
    
    def search(self, keyword):
        # O(n) search - slow for large data
        results = []
        for item in self.data:
            if keyword in item:
                results.append(item)
        return results

print("   Adding 1000 items to file-based storage...")
file_data = FileData()
for i in range(1000):
    file_data.add(f"item_{i}_{i*2}")

start = time.time()
results = file_data.search("500")
file_time = time.time() - start
print(f"   Searched 1000 items in {file_time:.4f}s")
print(f"   Found: {len(results)} items")

# ============================================================
# 2. STORING DATA IN DATABASE (Simulated)
# ============================================================

print("\n2. STORING DATA IN DATABASE (Simulated)")

class DBData:
    def __init__(self):
        self.data = []
        self.index = {}  # Simulates database index
    
    def add(self, item):
        self.data.append(item)
        # Index the item for fast search
        words = item.split()
        for word in words:
            if word not in self.index:
                self.index[word] = []
            self.index[word].append(item)
    
    def search(self, keyword):
        # O(1) search with index
        return self.index.get(keyword, [])

print("   Adding 1000 items to database-based storage...")
db_data = DBData()
for i in range(1000):
    db_data.add(f"item_{i}_{i*2}")

start = time.time()
results = db_data.search("500")
db_time = time.time() - start
print(f"   Searched 1000 items in {db_time:.4f}s")
print(f"   Found: {len(results)} items")

# ============================================================
# 3. COMPARISON
# ============================================================

print("\n3. COMPARISON")

print(f"   File System search: {file_time:.4f}s")
print(f"   Database search: {db_time:.4f}s")
print(f"   Database is {(file_time/db_time):.1f}x faster!")

print("""
┌─────────────────────────────────────────────────────────────────────┐
│ COMPARISON RESULTS                                                 │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  File System:                                                      │
│  • Simple to implement                                             │
│  • O(n) search (scans all items)                                  │
│  • Slower for large data                                           │
│  • No validation or relationships                                  │
│                                                                     │
│  Database (Simulated):                                             │
│  • More complex                                                    │
│  • O(1) search (uses index)                                       │
│  • Much faster for large data                                     │
│  • Validation and relationships                                    │
│                                                                     │
│  KEY TAKEAWAY:                                                     │
│  For small data, files are fine.                                   │
│  For large data, a database is much faster!                       │
└─────────────────────────────────────────────────────────────────────┘
""")

==================================================
DBMS vs FILE SYSTEM - PRACTICE
==================================================

1. STORING DATA IN FILE
Adding 1000 items to file-based storage...
Searched 1000 items in 0.0012s
Found: 1 items

2. STORING DATA IN DATABASE (Simulated)
Adding 1000 items to database-based storage...
Searched 1000 items in 0.0003s
Found: 1 items

3. COMPARISON
File System search: 0.0012s
Database search: 0.0003s
Database is 4.0x faster!

🏆

You've Got It!

You now understand the difference between file systems and DBMS. You know when to use each and why databases are better for managing large amounts of data.

Quick Quiz

Test what you've learned:

1. What is a file system?

A) A type of database B) A way to store data as files on a disk C) A programming language D) A web framework

2. What is a DBMS?

A) A type of file B) Software that manages structured data in tables C) A Python library D) A file extension

3. Which is better for searching large amounts of data?

A) File System B) DBMS C) Both are equally good D) Neither

4. What does a database use to make searching fast?

A) File system B) Indexes C) Backups D) Encryption

5. When should you use a file system instead of a database?

A) For large web applications B) For small, simple data with one user C) For multi-user applications D) When you need data validation

Frequently Asked Questions

What is the difference between a file system and a DBMS?

A file system stores data as files and folders. A DBMS (Database Management System) stores data in structured tables with relationships, validation, and security. DBMS is more powerful but more complex to set up.

When should I use a file system?

Use a file system when you have small amounts of data, simple needs, and only one user or application. Examples: configuration files, logs, small data files for personal scripts.

When should I use a DBMS?

Use a DBMS when you have large amounts of data, multiple users, need relationships between data, need security, or need fast searching. Examples: web applications, e-commerce, CRM systems.

Why is searching faster in a DBMS?

A DBMS uses indexes, which are like a book's index. They allow the database to find data without scanning every row. A file system has to scan the entire file to find data, which is much slower for large files.

Can I use both files and databases together?

Yes! Many applications use both. For example, a web app might use a database for user accounts and orders, but store uploaded images in the file system. Choose the right tool for each type of data.

Is MySQL a file system or a DBMS?

MySQL is a DBMS (Database Management System). It manages data in structured tables with relationships, validation, and security. While MySQL does store data in files on disk, the way it organizes and accesses that data is what makes it a DBMS.

Where to Go From Here

Now that you understand the difference between file systems and DBMS, check out these related topics:

Previous: Introduction to MySQL Next: Connecting to MySQL →

Python

Python: DBMS vs File System

File System vs Database

What is a File System?

Storing Data in Files

What is a DBMS?

Storing Data in a Database

Key Differences

File System vs DBMS Side by Side

When to Use What

Choosing the Right Tool

Real-World Example

Building a Simple Application

Best Practices

Choosing Wisely

Try It Yourself

You've Got It!

Quick Quiz

Frequently Asked Questions

What is the difference between a file system and a DBMS?

When should I use a file system?

When should I use a DBMS?

Why is searching faster in a DBMS?

Can I use both files and databases together?

Is MySQL a file system or a DBMS?

Where to Go From Here

Connecting to MySQL

Create Database

Create Table

Python

Python: DBMS vs File System

File System vs Database

What is a File System?

Storing Data in Files

What is a DBMS?

Storing Data in a Database

Key Differences

File System vs DBMS Side by Side

When to Use What

Choosing the Right Tool

Real-World Example

Building a Simple Application

Best Practices

Choosing Wisely

Try It Yourself

You've Got It!

Quick Quiz

Frequently Asked Questions

What is the difference between a file system and a DBMS? ▼

When should I use a file system? ▼

When should I use a DBMS? ▼

Why is searching faster in a DBMS? ▼

Can I use both files and databases together? ▼

Is MySQL a file system or a DBMS? ▼

Where to Go From Here

Connecting to MySQL

Create Database

Create Table

What is the difference between a file system and a DBMS?

When should I use a file system?

When should I use a DBMS?

Why is searching faster in a DBMS?

Can I use both files and databases together?

Is MySQL a file system or a DBMS?