SQLAlchemy

最新推荐文章于 2025-09-10 20:20:06 发布
转载 最新推荐文章于 2025-09-10 20:20:06 发布 · 43 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/weiwu1578/articles/8982054.html
文章标签：

#数据库 #python

本文详细介绍Python ORM框架SQLAlchemy的使用方法，包括安装配置、数据库连接池设置、原生SQL执行方式及ORM操作等内容，适用于初学者及进阶使用者。

一. 介绍

SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上，使用关系对象映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果

下载

pip3 install sqlalchemy

 

组成部分：

  • Engine，框架的引擎
  • Connection Pooling ，数据库连接池
  • Dialect，选择连接数据库的DB API种类
  • Schema/Types，架构和类型
  • SQL Exprression Language，SQL表达式语言

SQLAlchemy本身无法操作数据库，其必须依赖pymsql等第三方插件，Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：

MySQL-Python
    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
    
pymysql
    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
    
MySQL-Connector
    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
    
cx_Oracle
    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
    
更多：http://docs.sqlalchemy.org/en/latest/dialects/index.html

二. 使用

1. 执行原生SQL语句

import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine
 
engine = create_engine(
    "mysql+pymysql://root:123@127.0.0.1:3306/t1?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
 
 
def task(arg):
    conn = engine.raw_connection()
    cursor = conn.cursor()
    cursor.execute(
        "select * from t1"
    )
    result = cursor.fetchall()
    cursor.close()
    conn.close()
 
 
for i in range(20):
    t = threading.Thread(target=task, args=(i,))
    t.start()
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/t1", max_overflow=0, pool_size=5)


def task(arg):
    conn = engine.contextual_connect()
    with conn:
        cur = conn.execute(
            "select * from t1"
        )
        result = cur.fetchall()
        print(result)


for i in range(20):
    t = threading.Thread(target=task, args=(i,))
    t.start()
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine
from sqlalchemy.engine.result import ResultProxy
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/t1", max_overflow=0, pool_size=5)


def task(arg):
    cur = engine.execute("select * from t1")
    result = cur.fetchall()
    cur.close()
    print(result)


for i in range(20):
    t = threading.Thread(target=task, args=(i,))
    t.start()

注意: 查看连接 show status like 'Threads%';

2. ORM

a. 创建数据库表

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index

Base = declarative_base()


class Users(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=False)
    # email = Column(String(32), unique=True)
    # ctime = Column(DateTime, default=datetime.datetime.now)
    # extra = Column(Text, nullable=True)

    __table_args__ = (
        # UniqueConstraint('id', 'name', name='uix_id_name'),  # 联合唯一
        # Index('ix_id_name', 'name', 'email'),  # 普通索引
    )


def init_db():
    """
    根据类创建数据库表
    :return: 
    """
    engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )

    Base.metadata.create_all(engine)


def drop_db():
    """
    根据类删除数据库表
    :return: 
    """
    engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )

    Base.metadata.drop_all(engine)


if __name__ == '__main__':
    drop_db()
    init_db()

创建包含一对多和多对多的表

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
from sqlalchemy.orm import relationship

Base = declarative_base()


# ##################### 单表示例 #########################
class Users(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True)
    age = Column(Integer, default=18)
    email = Column(String(32), unique=True)
    ctime = Column(DateTime, default=datetime.datetime.now)
    extra = Column(Text, nullable=True)

    __table_args__ = (
        # UniqueConstraint('id', 'name', name='uix_id_name'),
        # Index('ix_id_name', 'name', 'extra'),
    )


class Hosts(Base):
    __tablename__ = 'hosts'

    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True)
    ctime = Column(DateTime, default=datetime.datetime.now)


# ##################### 一对多示例 #########################
class Hobby(Base):
    __tablename__ = 'hobby'
    id = Column(Integer, primary_key=True)
    caption = Column(String(50), default='篮球')


class Person(Base):
    __tablename__ = 'person'
    nid = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=True)
    hobby_id = Column(Integer, ForeignKey("hobby.id"))

    # 与生成表结构无关，仅用于查询方便
    hobby = relationship("Hobby", backref='pers')


# ##################### 多对多示例 #########################

class Server2Group(Base):
    __tablename__ = 'server2group'
    id = Column(Integer, primary_key=True, autoincrement=True)
    server_id = Column(Integer, ForeignKey('server.id'))
    group_id = Column(Integer, ForeignKey('group.id'))


class Group(Base):
    __tablename__ = 'group'
    id = Column(Integer, primary_key=True)
    name = Column(String(64), unique=True, nullable=False)

    # 与生成表结构无关，仅用于查询方便
    servers = relationship('Server', secondary='server2group', backref='groups')


class Server(Base):
    __tablename__ = 'server'

    id = Column(Integer, primary_key=True, autoincrement=True)
    hostname = Column(String(64), unique=True, nullable=False)


def init_db():
    """
    根据类创建数据库表
    :return: 
    """
    engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )

    Base.metadata.create_all(engine)


def drop_db():
    """
    根据类删除数据库表
    :return: 
    """
    engine = create_engine(
        "mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )

    Base.metadata.drop_all(engine)


if __name__ == '__main__':
    drop_db()
    init_db()

一对多可以使用Foreignkey，而多对多需要自己手动创建第三张表

b. 操作数据库表

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import Users
  
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
  
# 每次执行数据库操作时，都需要创建一个session
session = Session()
  
# ############# 执行ORM操作 #############
obj1 = Users(name="alex1")
session.add(obj1)
  
# 提交事务
session.commit()
# 关闭session
session.close()

基本增删改查

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text

from db import Users, Hosts

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)

session = Session()

# ################ 添加 ################
"""
obj1 = Users(name="wupeiqi")
session.add(obj1)

session.add_all([
    Users(name="wupeiqi"),
    Users(name="alex"),
    Hosts(name="c1.com"),
])
session.commit()
"""

# ################ 删除 ################
"""
session.query(Users).filter(Users.id > 2).delete()
session.commit()
"""
# ################ 修改 ################
"""
session.query(Users).filter(Users.id > 0).update({"name" : "099"})
session.query(Users).filter(Users.id > 0).update({Users.name: Users.name + "099"}, synchronize_session=False)  # synchronize_session=False表示为字符串的加
session.query(Users).filter(Users.id > 0).update({"age": Users.age + 1}, synchronize_session="evaluate")  # synchronize_session='evaluate'表示需要计算
session.commit()
"""
# ################ 查询 ################
"""
r1 = session.query(Users).all()
r2 = session.query(Users.name.label('xx'), Users.age).all()  # label为别名，相当于sql中的as
r3 = session.query(Users).filter(Users.name == "alex").all()
r4 = session.query(Users).filter_by(name='alex').all()
r5 = session.query(Users).filter_by(name='alex').first()
r6 = session.query(Users).filter(text("id<:value and name=:name")).params(value=224, name='fred').order_by(Users.id).all()  # 这里写的是查找的条件
r7 = session.query(Users).from_statement(text("SELECT * FROM users where name=:name")).params(name='ed').all()  # 这里写的是整个sql语句
"""


session.close()

常用操作

#　条件
ret = session.query(Users).filter_by(name='alex').all()
ret = session.query(Users).filter(Users.id > 1, Users.name == 'eric').all()
ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'eric').all()
ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='eric'))).all()
from sqlalchemy import and_, or_
ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'eric')).all()
ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'eric')).all()
ret = session.query(Users).filter(
    or_(
        Users.id < 2,
        and_(Users.name == 'eric', Users.id > 3),
        Users.extra != ""
    )).all()


# 通配符
ret = session.query(Users).filter(Users.name.like('e%')).all()
ret = session.query(Users).filter(~Users.name.like('e%')).all()

# 限制
ret = session.query(Users)[1:2]

# 排序
ret = session.query(Users).order_by(Users.name.desc()).all()
ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()

# 分组
from sqlalchemy.sql import func

ret = session.query(Users).group_by(Users.extra).all()
ret = session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id)).group_by(Users.name).all()

ret = session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()

# 连表

ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()

ret = session.query(Person).join(Favor).all()

ret = session.query(Person).join(Favor, isouter=True).all()


# 组合
q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union(q2).all()

q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union_all(q2).all()

基于relationship操作ForeignKey

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text
from sqlalchemy.engine.result import ResultProxy
from db import Users, Hosts, Hobby, Person

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = Session()
# 添加
"""
session.add_all([
    Hobby(caption='乒乓球'),
    Hobby(caption='羽毛球'),
    Person(name='张三', hobby_id=3),
    Person(name='李四', hobby_id=4),
])

person = Person(name='张九', hobby=Hobby(caption='姑娘'))
session.add(person)

hb = Hobby(caption='人妖')
hb.pers = [Person(name='文飞'), Person(name='博雅')]
session.add(hb)

session.commit()
"""

# 使用relationship正向查询
"""
v = session.query(Person).first()
print(v.name)
print(v.hobby.caption)
"""

# 使用relationship反向查询
"""
v = session.query(Hobby).first()
print(v.caption)
print(v.pers)
"""

session.close()

基于relationship操作m2m

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text
from sqlalchemy.engine.result import ResultProxy
from db import Users, Hosts, Hobby, Person, Group, Server, Server2Group

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = Session()
# 添加
"""
session.add_all([
    Server(hostname='c1.com'),
    Server(hostname='c2.com'),
    Group(name='A组'),
    Group(name='B组'),
])
session.commit()

s2g = Server2Group(server_id=1, group_id=1)
session.add(s2g)
session.commit()


gp = Group(name='C组')
gp.servers = [Server(hostname='c3.com'),Server(hostname='c4.com')]
session.add(gp)
session.commit()


ser = Server(hostname='c6.com')
ser.groups = [Group(name='F组'),Group(name='G组')]
session.add(ser)
session.commit()
"""


# 使用relationship正向查询
"""
v = session.query(Group).first()
print(v.name)
print(v.servers)
"""

# 使用relationship反向查询
"""
v = session.query(Server).first()
print(v.hostname)
print(v.groups)
"""


session.close()

其它

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import time
import threading

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text, func
from sqlalchemy.engine.result import ResultProxy
from db import Users, Hosts, Hobby, Person, Group, Server, Server2Group

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = Session()

# 关联子查询
subqry = session.query(func.count(Server.id).label("sid")).filter(Server.id == Group.id).correlate(Group).as_scalar()
result = session.query(Group.name, subqry)
"""
SELECT `group`.name AS group_name, (SELECT count(server.id) AS sid 
FROM server 
WHERE server.id = `group`.id) AS anon_1 
FROM `group`
"""


# 原生SQL
"""
# 查询
cursor = session.execute('select * from users')
result = cursor.fetchall()

# 添加
cursor = session.execute('insert into users(name) values(:value)',params={"value":'wupeiqi'})
session.commit()
print(cursor.lastrowid)
"""

session.close()

简单练习

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# 建 表

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, UniqueConstraint, Index, DateTime, ForeignKey
from sqlalchemy import create_engine
from sqlalchemy.orm import relationship
import datetime

Base = declarative_base()


class Classes(Base):
    __tablename__ = 'classes'
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(32), nullable=False, unique=True)


class Student(Base):
    __tablename__ = 'student'
    id = Column(Integer, primary_key=True, autoincrement=True)
    username = Column(String(32), nullable=False, index=True)
    password = Column(String(64), nullable=False)
    ctime = Column(DateTime, default=datetime.datetime.now)
    class_id = Column(Integer, ForeignKey("classes.id"))

    cls = relationship("Classes", backref='stus')


class Hobby(Base):
    __tablename__ = 'hobby'
    id = Column(Integer, primary_key=True)
    caption = Column(String(50), default='篮球')


class Student2Hobby(Base):
    __tablename__ = 'student2hobby'
    id = Column(Integer, primary_key=True, autoincrement=True)
    student_id = Column(Integer, ForeignKey('student.id'))
    hobby_id = Column(Integer, ForeignKey('hobby.id'))

    __table_args__ = (
        UniqueConstraint('student_id', 'hobby_id', name='uix_student_id_hobby_id'),
        # Index('ix_id_name', 'name', 'extra'),
    )


def init_db():
    # 数据库连接相关
    engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3306/s8day128db?charset=utf8")
    # 创建表
    Base.metadata.create_all(engine)


def drop_db():
    engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3306/s8day128db?charset=utf8")
    # 删除表
    Base.metadata.drop_all(engine)


if __name__ == '__main__':
    # drop_db()
    init_db()

 

import models

from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine

engine =create_engine("mysql+pymysql://root:123456@127.0.0.1:3306/s8day128db?charset=utf8")
XXXXXX = sessionmaker(bind=engine)
session = XXXXXX()

# 1. 在student表中插入数据
# obj = models.Student(username='梅凯',password='123',class_id=2)
# session.add(obj)
# session.commit()

# 2. 在学校表中找到梅凯
# obj = session.query(models.Student).filter(models.Student.username=='梅凯').first()
# print(obj)

# 3. 找到所有学生，打印学生信息(包含班级名称)
# objs = session.query(models.Student).all()
# for obj in objs:
#     cls_obj = session.query(models.Classes).filter(models.Classes.id==obj.class_id).first()
#     print(obj.id,obj.username,obj.class_id,cls_obj.name)

# objs = session.query(models.Student.id,models.Student.username,models.Classes.name).join(models.Classes,isouter=True).all()
# print(objs)

# objs = session.query(models.Student).all()
# for item in objs:
#     print(item.id,item.username,item.class_id,item.cls.name)

# 4. 全栈2期所有的学生
# obj = session.query(models.Classes).filter(models.Classes.name=='全栈2期099').first()
# student_list = obj.stus
# for item in student_list:
#     print(item.id,item.username)


session.close()

 

转载于:https://www.cnblogs.com/weiwu1578/articles/8982054.html

sqlalchemy钩子
fanbin
10-14 1857
基本概念 Sqlalchemy: python Orm框架 Session: sqlalchemy通过session和数据库进行交互, 用法是定义Session类(链接数据库)，实例session对象 Events: Session和数据库交互过程中发生的各种事件, sqlalchemy包含一个事件API，该API发布了很多钩子; e.g.create transaction; f...
Sqlalchemy
2301_77020411的博客
04-19 506
在这个例子中，User.name == 'Alice' 和 User.age > 25 是两个单独的条件，它们分别表示 "用户的名字是 Alice" 和 "用户的年龄大于 25"。and_ 函数将它们组合成一个复合条件，表示 "用户的名字是 Alice 并且年龄大于 25"。一种常见的方法是使用 and_, or_, not_ 等逻辑操作符结合列对象的比较操作来构建条件。同样地，你也可以使用 or_ 来构建 "或者" 条件，使用 not_ 来构建 "非" 条件。# 构建 "或者" 条件。
sqlalchemy
热门推荐
钟健的博客
03-22 6万+
sqlalchemy 简介： SQLAlchemy 是Python 社区最知名的 ORM 工具之一，为高效和高性能的数据库访问设计，实现了完整的企业级持久模型。 **安装 ** pip install sqlalchemy #直接cmd命令行安装 配置文件 一般搭配**flask**框架使用，sqlalchemy的配置一般从flask的config文件中加载 config的配置：flask-sqlalchemy-config 数据类型 类型名 MySQL类型 python类型 描述 Sma
SQLAlchemy 第一篇
silk_java的专栏
12-14 847
在下面的示例中，上下文管理器提供了数据库连接，并且还构建了事务内部的操作。Python DBAPI 的默认行为包括事务始终在进行中；当连接范围被释放时，会发出 ROLLBACK 来结束事务。当我们想要提交数据时，我们通常需要调用Connection.commit()方法，可以隐式开启一个事务。并且执行正常后，会自动提交。如果有异常发送，则会回滚。此处我们以pymysql为mysql的数据库驱动。
SQLAlchemy Async
weixin_41085315的博客
04-03 5800
目录 架构 安装： Engine: Result Session MetaData Table And ORM 反射表 插入数据 查询数据 更新和删除 使用流式 Async ORM 关联对象加载 Event 钩子 SQL 编译缓存 架构 版本要求：Cpython +3.7 安装： pip install SQLAlchemy 安装对应数据库的DBAPI: https://docs.sqlalchemy.org/en/20/dialects/mysq...
Sqlalchemy基本使用
2301_79920669的博客
11-27 2759
SQLAlchemy 是一个功能强大的 Python SQL 工具包和对象关系映射(Object-Relational Mapping ORM)框架，它提供了全功能的数据库抽象层和透明的数据库转换，使得开发者能够以面向对象的方式操作数据库，同时支持多种数据库系统，极大地简化了数据库编程的复杂性。总的来说sqlalchemy提供的这种orm关系映射对不熟悉sql语句的人来说十分的友好。让python操作数据库变的十分的简单。！！
SQLALCHEMY
hellocsz的博客
09-30 8380
写在前面 这篇笔记主要是为了帮助读者更好地理解SQLAlchemy的架构。虽然原文中已经将SQLAlchemy架构的大部分讲得很全面了，但原文主要是介绍SQLAlchemy的架构，很多部分并没有详细解释。这篇笔记到了补充说明的作用。本笔记共10个小节，和原文的10个小节是完全对应的，读者可以在阅读本笔记的过程中随时参照原文。 SQLAlchemy的代码比较难以阅读，这是由它自身的特点决定的。首...
关于 sqlalchemy 批量删除的坑
discsthnew的博客
11-05 1039
定义model。
SQLAlchemy动态表名
Good Luck
01-05 656
【代码】SQLAlchemy动态表名。
python-pandas-2.0.3及其依赖包+sqlalchemy-2.0.30及其依赖包+pymysql-1.1.0
05-11
python安装第三方包失败(使用pip安装失败)的解决方案：在我们使用pip安装软件包的时候，经常会遇到这个错误：ERROR: ...3.0.3-cp38-cp38-win_amd64.whl、SQLAlchemy-2.0.30-cp38-cp38-win_amd64.whl
SQLAlchemy-1.4.50-cp38-cp38-win_amd64.whl.zip
05-19
SQLAlchemy 是一个强大的 Python SQL 工具包和 ORM（对象关系映射）系统，它提供了对多种数据库引擎的全面支持，包括 PostgreSQL、MySQL、SQLite 等。在Python开发中，SQLAlchemy通常用于处理数据库操作，它使得...
基于SpringBoot和uni-app开发的陪诊陪护软件系统源码
程序员创业中
09-06 1450
中国60岁以上人口已突破3.1亿，独居老人超1.3亿，而一线城市三甲医院日均门诊量超万人次。在这组数据背后，是无数家庭面临的困境：子女异地工作无法陪同父母就医，独居老人因不会操作智能设备在挂号机前徘徊，异地患者因不熟悉流程在医院迷路……当“就医”从个人事务演变为社会难题，陪诊陪护系统正以“专业服务+技术赋能”的双重模式，成为破解这一困局的关键。
从Java全栈开发到微服务架构的实战经验分享
CatchLight的博客
09-09 737
应聘者：我认为最重要的是能够理解业务需求，并将其转化为技术方案。同时，持续学习新技术，保持对行业趋势的关注也很关键。毕竟，技术更新很快，只有不断学习才能跟上节奏。通过这次面试，我们可以看到一位资深Java全栈开发者的专业能力和实践经验。他不仅掌握了多种技术栈，还能在实际业务场景中灵活运用，解决实际问题。同时，他也展现了良好的沟通能力和学习能力，这些都是成为一名优秀工程师的关键素质。
Date、BigDecimal类型值转换
2301_81922209的博客
09-06 424
本文展示了前后端数据交互中日期和数值类型的转换处理。前端输入JSON数据包含日期字符串(yyyy-MM-dd和yyyy/MM/dd格式)和数值，后端通过@JsonFormat注解自动转换为Date类型，BigDecimal类型则用于精确计算。数据库中存储datetime和decimal类型数据。后端处理时，使用工具类对价格和利率进行格式化：价格保留两位小数(四舍五入)，利率转换为百分比格式。最终响应数据将日期转为时间戳或格式化字符串，数值转为格式化字符串，并转换支付方式编码为描述文本。完整流程涵盖数据接收、
Redis哨兵
最新发布
2502_92141759的博客
09-10 444
哨兵的结构如图：：Sentinel 会不断检查您的master和slave是否按预期工作：如果master故障，Sentinel会将一个slave提升为master。当故障实例恢复后也以新的master为主：Sentinel充当Redis客户端的服务发现来源，当集群发生故障转移时，会将最新信息推送给Redis的客户端。
SAP HANA Scale-out 03：Performance Guide
SAP攻城狮
09-10 660
HEX EngineThe SAP HANA Execution Engine (HEX)是一个查询执行引擎，从长远来看将取代其他SAP HANA引擎，如连接引擎和OLAP引擎.所有功能都整合在HEX中,从而消除不同引擎之间的物化过程。HEX引擎通过在准备阶段创建适当的SQL计划来连接SQL层和存储层。HEX引擎中的数据是流式处理的，因此可以快速获取第一批结果行，而无需等待所有结果行都被处理。HEX引擎中的操作符是管道化的，改进了并行化并可以减少内存消耗。
SqlAlchemy
07-24
### SQLAlchemy 是什么？ SQLAlchemy 是一个功能强大的 Python SQL 工具包和对象关系映射（Object-Relational Mapping, ORM）框架，它提供了全功能的数据库抽象层和透明的数据库转换，使得开发者能够以面向对象的方式操作数据库，同时支持多种数据库系统，极大地简化了数据库编程的复杂性[^3]。 ### SQLAlchemy 的核心特性 1. **ORM 支持**：SQLAlchemy 提供了灵活的 ORM 系统，允许开发者将数据库表映射到 Python 类，从而以面向对象的方式操作数据库数据。 2. **SQL 表达式语言**：除了 ORM，SQLAlchmey 还提供了强大的 SQL 表达式语言，支持构建复杂的 SQL 查询。 3. **多数据库支持**：SQLAlchemy 支持包括 MySQL、PostgreSQL、SQLite、Oracle 等在内的多种数据库系统。 4. **事务管理**：SQLAlchemy 提供了完整的事务管理功能，确保数据的一致性和完整性。 5. **连接池**：内置的连接池机制可以提高数据库连接的效率和性能。 ### 安装 SQLAlchemy 要安装 SQLAlchemy，可以使用 pip： ```bash pip install sqlalchemy ``` 如果需要连接特定的数据库（如 MySQL），还需要安装相应的驱动程序，例如 `pymysql`： ```bash pip install pymysql ``` ### 连接数据库 以下是一个使用 SQLAlchemy 连接 MySQL 数据库的示例： ```python from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker # 数据库连接字符串 DATABASE_URI = 'mysql+pymysql://root:123456@127.0.0.1:3306/test' # 创建引擎 engine = create_engine(DATABASE_URI, echo=True) # 创建会话 Session = sessionmaker(bind=engine) session = Session() # 声明基类 Base = declarative_base() ``` ### 定义模型 在 SQLAlchemy 中，可以通过定义类来表示数据库表。以下是一个简单的模型定义示例： ```python from sqlalchemy import Column, Integer, String class User(Base): __tablename__ = 'users' id = Column(Integer, primary_key=True) name = Column(String(50)) email = Column(String(50)) # 创建表 Base.metadata.create_all(engine) ``` ### 数据库操作 #### 插入数据 ```python new_user = User(name='Alice', email='alice@example.com') session.add(new_user) session.commit() ``` #### 查询数据 ```python # 查询所有用户 users = session.query(User).all() for user in users: print(user.name, user.email) # 条件查询 user = session.query(User).filter_by(name='Alice').first() print(user.email) ``` #### 更新数据 ```python user = session.query(User).filter_by(name='Alice').first() user.email = 'new_email@example.com' session.commit() ``` #### 删除数据 ```python user = session.query(User).filter_by(name='Alice').first() session.delete(user) session.commit() ``` ### 高级查询 SQLAlchemy 提供了丰富的查询 API，支持复杂的查询操作。例如，可以使用 `filter`、`order_by`、`group_by` 等方法来构建复杂的查询： ```python # 查询并排序 users = session.query(User).order_by(User.name).all() # 聚合查询 from sqlalchemy import func user_count = session.query(func.count(User.id)).scalar() print(f"Total users: {user_count}") ``` ### 在 Flask 中使用 SQLAlchemy 在 Flask 应用中，可以通过 `Flask-SQLAlchemy` 扩展来简化 SQLAlchemy 的使用： ```python from flask import Flask from flask_sqlalchemy import SQLAlchemy app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:123456@127.0.0.1:3306/test' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) class User(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50)) email = db.Column(db.String(50)) @app.route('/') def index(): users = User.query.all() return str(users) if __name__ == '__main__': app.run(debug=True) ``` ### 嵌入使用 SQL 语句 虽然 SQLAlchemy 提供了强大的 ORM 功能，但在某些情况下，直接使用原始 SQL 语句可能更方便。可以通过 `engine.execute()` 方法执行原始 SQL： ```python result = engine.execute("SELECT * FROM users") for row in result: print(row) ``` ### 总结 SQLAlchemy 是一个功能强大且灵活的 Python ORM 工具，适用于各种规模的应用程序开发。通过其丰富的功能，开发者可以更轻松地与数据库进行交互，同时保持代码的可维护性和可扩展性。 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值