如何在生产与测试环境中用Peewee动态设置SQLite数据库路径？

Hey there! Let's tackle this dynamic database setup problem with Peewee—this is a common scenario when switching between test and production environments, especially when you need to support multiple databases. Here's a clean, maintainable approach based on Peewee's built-in tools:

The key here is to replace your hardcoded database connections with Peewee's Proxy class. This lets you dynamically swap out the database instance at runtime without modifying your model definitions.

First, update your models file (e.g., models.py):

from peewee import SqliteDatabase, Model, Proxy

# Create a database proxy to handle dynamic connections
db_proxy = Proxy()

# Define a base model that uses the proxy
class BaseModel(Model):
    class Meta:
        database = db_proxy

# Now all your actual models inherit from BaseModel instead of directly setting a database
class User(BaseModel):
    username = CharField(unique=True)
    email = CharField()

class Product(BaseModel):
    name = CharField()
    price = DecimalField()

In your test script, you can initialize the fixed test database and bind it to the proxy:

from peewee import SqliteDatabase
from models import db_proxy, User, Product

# Initialize the test database
test_db = SqliteDatabase('test_db.sqlite')
db_proxy.initialize(test_db)

# Create tables (safe=True avoids errors if tables already exist)
test_db.create_tables([User, Product], safe=True)

# Your test logic goes here
def test_user_creation():
    user = User.create(username='test_user', email='test@example.com')
    assert User.get_by_id(user.id).username == 'test_user'

test_user_creation()

For production, you can accept the database path via command-line arguments, config files, or user input. Here's how to implement command-line-based dynamic setup:

import argparse
from peewee import SqliteDatabase
from models import db_proxy, User, Product

def init_database(db_path):
    """Initialize and bind a SQLite database to the proxy."""
    prod_db = SqliteDatabase(db_path)
    db_proxy.initialize(prod_db)
    # Optional: Create tables if they don't exist (use migrations in production!)
    prod_db.create_tables([User, Product], safe=True)
    return prod_db

if __name__ == '__main__':
    # Parse command-line arguments for database path
    parser = argparse.ArgumentParser(description='Run the app with a specified SQLite database.')
    parser.add_argument('--db', required=True, help='Path to your production SQLite database file (e.g., ./prod_db.sqlite)')
    args = parser.parse_args()

    # Initialize the production database
    current_db = init_database(args.db)

    # Example application logic: Fetch and print all users
    print("Current users in the database:")
    for user in User.select():
        print(f"- {user.username} ({user.email})")

    # To switch to another database later (e.g., for multi-db support):
    # another_db = init_database('./another_prod_db.sqlite')
    # db_proxy.initialize(another_db)
    # Now all model operations will use another_db

• Use Migrations: Avoid using create_tables in production for schema changes. Instead, use Peewee's playhouse.migrate module to manage database migrations safely.
• Manage Multiple Databases: If you need to work with multiple databases simultaneously, store database instances in a dictionary (e.g., db_instances = {'db1': db1, 'db2': db2}) and switch them via db_proxy.initialize(db_instances['db2']).
• File Permissions: Ensure the application has read/write permissions for the SQLite database file and its parent directory in production.

内容的提问来源于stack exchange，提问作者Declan