Python数据库编程：从DB-API到ORM实战

1. Python数据库编程全景概览

作为一名长期使用Python进行数据处理的老兵，我见证了Python数据库生态从简陋到繁荣的完整演进历程。2005年刚开始接触Python时，我们只能用MySQLdb这样的基础连接器，而如今Python已经形成了完整的数据库技术栈。现代Python数据库支持主要包含三个层级：

最底层是数据库驱动层，比如psycopg2（PostgreSQL）、PyMySQL（MySQL）、cx_Oracle（Oracle）等，它们实现了Python DB-API 2.0规范，负责与数据库服务器建立TCP连接、传输SQL语句和获取结果集。这一层的API比较原始，需要开发者手动管理连接池和事务。

中间层是SQL工具包，典型代表是SQLAlchemy Core和PeeWee。它们提供了SQL表达式语言，允许用Python面向对象的方式构建SQL语句。比如select([users]).where(users.c.name == '张三')这样的链式调用，既避免了SQL注入风险，又提高了代码可读性。

最上层是ORM（对象关系映射），SQLAlchemy ORM和Django ORM是其中的佼佼者。它们将数据库表映射为Python类，行记录映射为对象实例，使开发者可以用纯Python对象的方式操作数据库。ORM会自动处理连接管理、事务边界和SQL生成，大幅提升开发效率。

重要提示：虽然ORM用起来方便，但复杂查询往往需要回退到原生SQL或SQL表达式语言。我建议项目初期使用ORM快速原型开发，性能敏感的核心模块则混合使用ORM和原生SQL。

2. 标准接口：DB-API 2.0规范详解

Python社区在PEP 249中定义了数据库API规范2.0版本，这是所有Python数据库驱动的基础契约。理解这个规范对编写可移植的数据库代码至关重要。让我们通过一个SQLite示例深入解析：

python复制import sqlite3
from contextlib import closing

# 建立连接
conn = sqlite3.connect('example.db', 
                      timeout=10,  # 等待锁的超时时间(秒)
                      isolation_level='IMMEDIATE')  # 事务隔离级别

try:
    with closing(conn.cursor()) as cursor:  # 自动关闭cursor
        # 执行DDL创建表
        cursor.execute('''CREATE TABLE stocks
                        (date text, trans text, symbol text, qty real, price real)''')
        
        # 执行DML插入数据
        cursor.execute("INSERT INTO stocks VALUES ('2023-06-01','BUY','RHAT',100,35.14)")
        
        # 参数化查询防止SQL注入
        t = ('RHAT',)
        cursor.execute('SELECT * FROM stocks WHERE symbol=?', t)
        print(cursor.fetchone())  # 获取单条记录
        
        # 批量插入
        purchases = [('2023-06-02', 'BUY', 'IBM', 1000, 45.00),
                    ('2023-06-03', 'SELL', 'MSFT', 500, 72.50)]
        cursor.executemany('INSERT INTO stocks VALUES (?,?,?,?,?)', purchases)
        
    conn.commit()  # 提交事务
except Exception as e:
    conn.rollback()  # 回滚事务
    raise e
finally:
    conn.close()  # 释放连接

DB-API的核心接口包括：

• connection：代表数据库连接，提供commit()、rollback()等事务方法
• cursor：执行查询和获取结果的游标对象
• execute()：执行单条SQL语句
• executemany()：批量执行相同SQL语句
• fetchone()/fetchall()：逐行或批量获取结果集

实战经验：务必使用contextlib.closing或try-finally确保连接和游标正确关闭。我曾经遇到过因为未关闭游标导致连接池耗尽的线上事故。

3. ORM进阶：SQLAlchemy实战技巧

SQLAlchemy是Python最强大的ORM工具，但它的学习曲线也相当陡峭。下面分享我在电商项目中总结的最佳实践：

3.1 声明式模型定义

python复制from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

Base = declarative_base()

class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    name = Column(String(50), nullable=False, index=True)
    email = Column(String(120), unique=True)
    balance = Column(Float, default=0.0)
    
    def __repr__(self):
        return f"<User(name='{self.name}', email='{self.email}')>"

# 连接配置
engine = create_engine('sqlite:///ecommerce.db', 
                      echo=True,  # 输出SQL日志
                      pool_size=5,  # 连接池大小
                      max_overflow=10,  # 最大溢出连接数
                      pool_timeout=30)  # 获取连接超时时间(秒)

# 创建表
Base.metadata.create_all(engine)

# 创建会话工厂
Session = sessionmaker(bind=engine)

3.2 复杂查询与性能优化

python复制from sqlalchemy import and_, or_, func
from datetime import datetime

def query_users(session):
    # 基础查询
    users = session.query(User).filter(
        User.name.like('张%')
    ).order_by(
        User.balance.desc()
    ).limit(10).all()
    
    # 聚合查询
    result = session.query(
        func.count(User.id),
        func.avg(User.balance)
    ).filter(
        User.created_at >= datetime(2023, 1, 1)
    ).first()
    
    # 联表查询(假设有Order表)
    from sqlalchemy.orm import joinedload
    users_with_orders = session.query(User).options(
        joinedload(User.orders)
    ).filter(
        and_(
            User.balance > 1000,
            or_(
                User.email.endswith('@gmail.com'),
                User.email.endswith('@qq.com')
            )
        )
    ).all()
    
    # 原生SQL回退
    top_users = session.execute(
        "SELECT id, name FROM users WHERE balance > :min_bal ORDER BY balance DESC LIMIT 5",
        {'min_bal': 5000}
    ).fetchall()

性能技巧：使用yield_per()处理大数据集查询，可以避免内存溢出：

python复制for user in session.query(User).yield_per(100):
    process_user(user)

3.3 事务管理最佳实践

python复制from contextlib import contextmanager

@contextmanager
def transactional_session():
    """提供事务性会话的上下文管理器"""
    session = Session()
    try:
        yield session
        session.commit()
    except:
        session.rollback()
        raise
    finally:
        session.close()

# 使用示例
with transactional_session() as session:
    user = User(name='张三', email='zhangsan@example.com')
    session.add(user)
    # 其他数据库操作...

4. 现代数据库扩展支持

4.1 异步IO支持（asyncio）

Python 3.7+的async/await语法为数据库访问带来了新的可能性。以asyncpg为例：

python复制import asyncio
import asyncpg

async def async_query():
    conn = await asyncpg.connect(
        user='user',
        password='pass',
        database='db',
        host='localhost',
        port=5432
    )
    
    try:
        # 简单查询
        result = await conn.fetch(
            'SELECT * FROM users WHERE balance > $1',
            1000
        )
        
        # 事务块
        async with conn.transaction():
            await conn.execute(
                "INSERT INTO users(name, email) VALUES($1, $2)",
                '李四', 'lisi@example.com'
            )
            
    finally:
        await conn.close()

asyncio.run(async_query())

4.2 向量数据库集成

随着AI应用兴起，向量数据库变得重要。以下是使用pgvector扩展PostgreSQL的示例：

python复制from sqlalchemy import Column, Integer, String
from sqlalchemy.dialects.postgresql import ARRAY, FLOAT
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class DocumentEmbedding(Base):
    __tablename__ = 'document_embeddings'
    
    id = Column(Integer, primary_key=True)
    doc_id = Column(String(64), unique=True)
    embedding = Column(ARRAY(FLOAT))  # 768维向量
    
    def similarity(self, other_embedding):
        """计算余弦相似度"""
        import numpy as np
        return np.dot(self.embedding, other_embedding) / (
            np.linalg.norm(self.embedding) * np.linalg.norm(other_embedding)
        )

# 向量相似度查询
nearest_docs = session.query(DocumentEmbedding).order_by(
    DocumentEmbedding.embedding.l2_distance(query_vector)
).limit(5).all()

4.3 分布式数据库支持

对于需要水平扩展的场景，Cassandra和CockroachDB是不错的选择。以下是使用cassandra-driver的示例：

python复制from cassandra.cluster import Cluster
from cassandra.query import SimpleStatement

cluster = Cluster(['node1', 'node2', 'node3'], port=9042)
session = cluster.connect('my_keyspace')

# 分页查询
query = "SELECT * FROM user_actions WHERE user_id = %s"
statement = SimpleStatement(query, fetch_size=100)
rows = session.execute(statement, [user_id])

for row in rows:
    process_row(row)

5. 数据库工具链与测试策略

5.1 数据库迁移工具Alembic

python复制# alembic/env.py配置
from logging.config import fileConfig
from sqlalchemy import engine_from_config
from alembic import context

# 模型导入
from models import Base
target_metadata = Base.metadata

def run_migrations_online():
    connectable = engine_from_config(
        config.get_section(config.config_ini_section),
        prefix="sqlalchemy.",
        poolclass=pool.NullPool,
    )

    with connectable.connect() as connection:
        context.configure(
            connection=connection,
            target_metadata=target_metadata,
            compare_type=True,  # 检测字段类型变化
            compare_server_default=True  # 检测默认值变化
        )

        with context.begin_transaction():
            context.run_migrations()

5.2 单元测试策略

使用pytest进行数据库测试的推荐模式：

python复制import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

@pytest.fixture(scope="module")
def test_db():
    # 使用内存数据库
    engine = create_engine("sqlite:///:memory:")
    Base.metadata.create_all(engine)
    yield engine
    engine.dispose()

@pytest.fixture
def db_session(test_db):
    connection = test_db.connect()
    transaction = connection.begin()
    session = Session(bind=connection)
    
    yield session
    
    session.close()
    transaction.rollback()
    connection.close()

def test_user_creation(db_session):
    user = User(name="测试用户", email="test@example.com")
    db_session.add(user)
    db_session.commit()
    
    assert user.id is not None
    assert db_session.query(User).count() == 1

5.3 性能监控与调优

使用SQLAlchemy事件进行查询监控：

python复制from sqlalchemy import event
from sqlalchemy.engine import Engine
import time

@event.listens_for(Engine, "before_cursor_execute")
def before_cursor_execute(conn, cursor, statement, parameters, context, executemany):
    context._query_start_time = time.time()

@event.listens_for(Engine, "after_cursor_execute")
def after_cursor_execute(conn, cursor, statement, parameters, context, executemany):
    duration = time.time() - context._query_start_time
    if duration > 0.5:  # 慢查询阈值
        print(f"Slow query ({duration:.2f}s): {statement}")

6. 安全最佳实践

6.1 SQL注入防御

python复制# 错误示范 - 字符串拼接
def unsafe_query(user_id):
    cursor.execute(f"SELECT * FROM users WHERE id = {user_id}")  # 高危！

# 正确做法 - 参数化查询
def safe_query(user_id):
    cursor.execute("SELECT * FROM users WHERE id = %s", (user_id,))  # 安全
    
# SQLAlchemy安全示例
session.query(User).filter(User.id == user_input)  # 自动参数化

6.2 连接安全配置

python复制# PostgreSQL安全连接示例
engine = create_engine(
    "postgresql+psycopg2://user:pass@host/db",
    connect_args={
        "sslmode": "verify-full",
        "sslrootcert": "/path/to/root.crt",
        "options": "-c statement_timeout=30000"  # 30秒超时
    },
    pool_pre_ping=True  # 连接池健康检查
)

6.3 敏感数据保护

python复制from sqlalchemy_utils import EncryptedType
from cryptography.fernet import Fernet

key = Fernet.generate_key()  # 保存到安全位置

class PaymentInfo(Base):
    __tablename__ = 'payment_infos'
    
    id = Column(Integer, primary_key=True)
    credit_card = Column(EncryptedType(String, key))
    expiry_date = Column(EncryptedType(String, key))

在多年Python数据库开发中，我最大的体会是：没有放之四海而皆准的最佳实践。小型项目用SQLite+原生SQL可能最高效，大型系统则需要ORM+完善的事务管理。关键是根据团队规模、性能需求和运维能力选择合适的技术栈。对于新项目，我现在的默认选择是PostgreSQL+SQLAlchemy+asyncpg组合，既保证了功能完整性，又能平滑应对规模增长。