使用场景

SQLAlchemy 是一个强大的 Python SQL 工具包和对象关系映射(ORM)系统，适用于以下场景： - 需要与关系型数据库交互的 Python 应用程序 - 需要数据库抽象层以避免直接编写 SQL 的项目 - 需要在不同数据库后端之间切换的应用程序 - 需要复杂查询构建的应用程序 - 需要同时使用 ORM 和原始 SQL 的项目

优势

数据库抽象：支持多种数据库后端(PostgreSQL, MySQL, SQLite, Oracle, MS-SQL等)
ORM 功能：将数据库表映射为 Python 类，行映射为对象
灵活性：既可以使用高级 ORM，也可以直接使用低层 SQL
连接池：内置高效的数据库连接池
事务管理：提供强大的事务控制能力
查询构建：提供 Pythonic 的方式来构建复杂查询
成熟稳定：经过多年发展，社区支持强大

核心功能

Engine：数据库引擎和连接池
Connection Pooling：连接池管理
Dialect：处理不同数据库的差异
SQL Expression Language：SQL 表达式语言
ORM：对象关系映射系统

入门示例

示例1：基本连接和原始 SQL 操作

```python from sqlalchemy import create_engine, text

创建引擎 (这里使用 SQLite 内存数据库)

engine = create_engine('sqlite:///:memory:', echo=True)

执行原始 SQL

with engine.connect() as conn: # 创建表 conn.execute(text(""" CREATE TABLE users ( id INTEGER PRIMARY KEY, name TEXT NOT NULL, age INTEGER ) """))

# 插入数据
conn.execute(text("""
    INSERT INTO users (name, age) VALUES 
    ('Alice', 30),
    ('Bob', 25),
    ('Charlie', 35)
"""))

# 查询数据
result = conn.execute(text("SELECT * FROM users WHERE age > :age"), {"age": 28})
for row in result:
    print(f"ID: {row.id}, Name: {row.name}, Age: {row.age}")

```

示例2：使用 ORM 定义模型

```python from sqlalchemy import createengine, Column, Integer, String from sqlalchemy.ext.declarative import declarativebase from sqlalchemy.orm import sessionmaker

# 定义基类
Base = declarative_base()

# 定义模型
class User(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    name = Column(String)
    age = Column(Integer)

    def __repr__(self):
        return f"<User(name='{self.name}', age={self.age})>"

# 创建引擎和表
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)

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

# 添加数据
user1 = User(name='Alice', age=30)
user2 = User(name='Bob', age=25)
session.add_all([user1, user2])
session.commit()

# 查询数据
users = session.query(User).filter(User.age > 28).all()
print(users)  # 输出: [<User(name='Alice', age=30)>]

```

示例3：更复杂的 ORM 查询

```python from sqlalchemy import createengine, Column, Integer, String, ForeignKey from sqlalchemy.ext.declarative import declarativebase from sqlalchemy.orm import sessionmaker, relationship

Base = declarative_base()

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    name = Column(String)
    books = relationship("Book", back_populates="author")

class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer, primary_key=True)
    title = Column(String)
    author_id = Column(Integer, ForeignKey('authors.id'))
    author = relationship("Author", back_populates="books")

# 设置数据库
engine = create_engine('sqlite:///:memory:')
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

# 添加数据
author = Author(name="J.K. Rowling")
author.books = [
    Book(title="Harry Potter and the Philosopher's Stone"),
    Book(title="Harry Potter and the Chamber of Secrets")
]
session.add(author)
session.commit()

# 复杂查询
result = session.query(Author).join(Book).filter(Book.title.like("%Philosopher%")).first()
print(f"Author: {result.name}")
for book in result.books:
    print(f" - {book.title}")

```

示例4：使用 SQL 表达式语言

```python from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, select

metadata = MetaData()

users = Table('users', metadata, Column('id', Integer, primary_key=True), Column('name', String), Column('age', Integer), )

创建引擎和表

engine = createengine('sqlite:///:memory:') metadata.createall(engine)

插入数据

with engine.connect() as conn: conn.execute(users.insert(), [ {"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}, {"name": "Charlie", "age": 35} ])

# 构建查询
stmt = select([users.c.name, users.c.age]).where(users.c.age > 28)

# 执行查询
result = conn.execute(stmt)
for row in result:
    print(f"Name: {row.name}, Age: {row.age}")

```

这些示例展示了 SQLAlchemy 的不同使用方式，从原始 SQL 操作到高级 ORM 功能。SQLAlchemy 的灵活性允许你根据项目需求选择合适的使用方式。