SQLAlchemy ORM 框架详解

最新推荐文章于 2024-01-19 21:07:21 发布
最新推荐文章于 2024-01-19 21:07:21 发布
阅读量1.1k 收藏 4
点赞数 1
分类专栏： Python 文章标签： python mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/roninyang/article/details/121131617
版权

SQLAlchemy ORM 框架详解

一、安装

pip install sqlalchemy==1.4.7
pip install pymysql # 连接mysql数据库所需库

二、连接数据库

from sqlalchemy import create_engine

engine = create_engine(f"mysql+pymysql://{数据库账号}:{密码}@{数据库地址}:3306/{数据库}", echo=True)
print(engine)

------打印结果------
Engine(mysql+pymysql://root:***@127.0.0.1:3306/scrapy)

三、创建会话通道

from sqlalchemy.orm import sessionmaker

maker = sessionmaker(bind=engine)
session = maker()
print(session)

------打印结果----------------
<sqlalchemy.orm.session.Session object at 0x03BB4400>

四、关闭会话通道

session.close_all()

五、创建数据表模型

  • 创建models模块，存放模型对象
  • 创建表的模型对象，要继承declarative_base对象
  • __tablename__：数据库中表的名称
  • 字段要与数据库中字段对应
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):

    __tablename__ = 'users'
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(20))
    fullname = Column(String(32))
    password = Column(String(32))

    def __repr__(self): # 当查询的时候，返回模型结果数据时调用
        return f"<User(name='{self.name}', fullname='{self.fullname}', password='{self.password}')>"

六、自动生成数据表（在没有表的情况下）

Base.metadata.create_all(engine, checkfirst=True)

七、数据库操作

1、添加

1）add: 单条添加
# 实例化模型类
ed_user = User(name="desire", fullname="asdfasdf", password="123123")
# 添加
session.add(ed_user)
# 提交
session.commit()

====> sql

INSERT INTO users (name, fullname, password) VALUES (%(name)s, %(fullname)s, %(password)s)
[generated in 0.00054s] {'name': 'desire', 'fullname': 'asdfasdf', 'password': '123123'}
2）add_all: 批量添加（内部还是使用的add）
# 列表每个元素为模型类实例
session.add_all([
        User(name='wendy', fullname='Wendy Williams', password='windy'),
        User(name='mary', fullname='Mary Contrary', password='mary'),
        User(name='fred', fullname='Fred Flintstone', password='freddy')])
    session.commit()

==> sql

INSERT INTO users (name, fullname, password) VALUES (%(name)s, %(fullname)s, %(password)s)
[cached since 0.005862s ago] {'name': 'wendy', 'fullname': 'Wendy Williams', 'password': 'windy'}

INSERT INTO users (name, fullname, password) VALUES (%(name)s, %(fullname)s, %(password)s)
[cached since 0.01483s ago] {'name': 'mary', 'fullname': 'Mary Contrary', 'password': 'mary'}

INSERT INTO users (name, fullname, password) VALUES (%(name)s, %(fullname)s, %(password)s)
[cached since 0.01808s ago] {'name': 'fred', 'fullname': 'Fred Flintstone', 'password': 'freddy'}

2、修改

1）方式一
  • 根据ID查询出来数据实体类
  • 然后直接修改数据实体类中的数据
  • 进行commit提交，
user = session.get(User, 8)
user.password = "123456"
session.commit()

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE users.id = %(pk_1)s
-- [generated in 0.00105s] {'pk_1': 8}
UPDATE users SET password=%(password)s WHERE users.id = %(users_id)s
-- [generated in 0.00042s] {'password': '123456', 'users_id': 8}
2）方式二
  • 通过链式调用进行更新操作
  • update参数为字典形式，字典的key要跟列名对应
  • 更新成功返回1，更新失败返回0
session.query(User).filter(User.id==8).update({"password":"654321"})
session.commit()

==> sql

UPDATE users SET password=%(password)s WHERE users.id = %(id_1)s
-- [generated in 0.00195s] {'password': '654321', 'id_1': 8}

3、查询

1）查询所有数据
  • 通过query进行查询，使用all()查询所有数据，返回数据为列表嵌套模型类
  • 可以通过循环遍历获取
  • 可以通过【类名.属性名】获取指定的数据
users = session.query(User).all()
for user in users:
    print(user, user.name)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users

==> 打印结果

<User(name='desire', fullname='asdfasdf', password='123123')> desire
<User(name='wendy', fullname='Wendy Williams', password='windy')> wendy
<User(name='mary', fullname='Mary Contrary', password='mary')> mary
<User(name='fred', fullname='Fred Flintstone', password='freddy')> fred
2）查询第一条数据
  • 使用first查询第一条数据
  • 返回的是模型类，可以通过【类名.属性名】获取指定的数据
user = session.query(User).first()
print(user, user.name)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
 LIMIT %(param_1)s
-- [generated in 0.00076s] {'param_1': 1}

==> 打印结果

<User(name='desire', fullname='asdfasdf', password='123123')> desire
3）查询指定列数据
  • 在query中添加多个参数，参数可以为模型类，也可以为列名，返回的数据为列表嵌套元组
  • 通过循环遍历获取
  • 同样可以使用【类名.属性名】获取指定的数据
users = session.query(User.name, User.fullname).all()
for user in users:
    print(user, user.name,user.fullname)

==> sql

SELECT users.name AS users_name, users.fullname AS users_fullname
FROM users

==> 打印结果

('desire', 'asdfasdf') desire asdfasdf
('wendy', 'Wendy Williams') wendy Wendy Williams
('mary', 'Mary Contrary') mary Mary Contrary
('fred', 'Fred Flintstone') fred Fred Flintstone
4）条件查询
1. filter条件查询
  • 使用filter进行条件查询，查询条件为【User.fullname==Wendy Williams】
  • 使用filter指定列为条件时，需要使用【类名.属性名】当做条件
users = session.query(User).filter(User.fullname == "Wendy Williams").all()
    for user in users:
        print(user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE users.fullname = %(fullname_1)s
-- [generated in 0.00043s] {'fullname_1': 'Wendy Williams'}

==> 打印结果

<User(name='wendy', fullname='Wendy Williams', password='windy')>
2. filter_by条件查询
  • 使用filter_by进行条件查询，可以把模型类属性当做filter_by参数进行条件查询【fullname=“Wendy Williams”】
  • 可以简化代码复杂度
users = session.query(User).filter_by(fullname="Wendy Williams").all()
for user in users:
    print(user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE users.fullname = %(fullname_1)s
-- [generated in 0.00053s] {'fullname_1': 'Wendy Williams'}

==> 打印结果

<User(name='wendy', fullname='Wendy Williams', password='windy')>
3.多条件查询
  • 可以使用链式调用，添加多个filter/filter_by
  • 也可以在filter/filter_by添加多个参数进行多条件查询
users = session.query(User).filter_by(fullname="Wendy Williams", name="wendy").all()
# users = session.query(User).filter_by(fullname="Wendy Williams").filter_by(name="wendy").all()
# users = session.query(User).filter(User.fullname=="Wendy Williams", User.name=="wendy").all()
for user in users:
    print(user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE users.fullname = %(fullname_1)s AND users.name = %(name_1)s
-- [generated in 0.00053s] {'fullname_1': 'Wendy Williams', 'name_1': 'wendy'}

==> 打印结果

<User(name='wendy', fullname='Wendy Williams', password='windy')>
5）模糊查询
  • like模糊查询，不区分大小写，但是在其他后端区分大小写（暂时没遇到过）
  • ilike模糊查询，对于保证不区分大小写的比较，推荐使用这个
users = session.query(User).filter(User.fullname.like('%F%')).all()
# users = session.query(User).filter(User.fullname.ilike('%F%')).all()
for user in users:
    print(user)

==> sql

-- like>>
SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE users.fullname LIKE %(fullname_1)s
-- [generated in 0.00051s] {'fullname_1': '%F%'}

-- ilike>>
SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE lower(users.fullname) LIKE lower(%(fullname_1)s)
-- [generated in 0.00061s] {'fullname_1': '%F%'}

==> 打印结果

<User(name='desire', fullname='asdfasdf', password='123123')>
<User(name='fred', fullname='Fred Flintstone', password='freddy')>
6）IN查询
1. IN查询
  • 查询多个id的数据时，可以使用IN查询
  • 可以使用【类名.属性名.in_()】进行IN查询
  • IN查询参数为列表
  • 返回值为列表
users = session.query(User).filter(User.id.in_([1,2,3])).all()
for user in users:
    print(user)

sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE users.id IN (%(id_1_1)s, %(id_1_2)s, %(id_1_3)s)
-- [generated in 0.00055s] {'id_1_1': 1, 'id_1_2': 2, 'id_1_3': 3}

==> 打印结果

<User(name='desire', fullname='asdfasdf', password='123123')>
<User(name='wendy', fullname='Wendy Williams', password='windy')>
<User(name='mary', fullname='Mary Contrary', password='mary')>
2. not IN查询
  • 只需在IN查询的基础上添加~
  • 【~类名.属性名.in_()】进行not IN查询
users = session.query(User).filter(~User.id.in_([1,2,3])).all()
for user in users:
    print(user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE users.id NOT IN (%(id_1_1)s, %(id_1_2)s, %(id_1_3)s)
-- [generated in 0.00086s] {'id_1_1': 1, 'id_1_2': 2, 'id_1_3': 3}

==> 打印结果

<User(name='fred', fullname='Fred Flintstone', password='freddy')>
7）and查询
  • 可以直接使用filter进行and多条件查询
  • 也可以使用and_进行多条件查询
from sqlalchemy import and_

users = session.query(User).filter(and_(User.name == "wendy",User.fullname == "Wendy Williams")).all()
# users = session.query(User).filter(User.name == "wendy",User.fullname == "Wendy Williams").all()
for user in users:
    print(user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE users.name = %(name_1)s AND users.fullname = %(fullname_1)s
-- [generated in 0.00065s] {'name_1': 'wendy', 'fullname_1': 'Wendy Williams'}

==> 打印结果

<User(name='wendy', fullname='Wendy Williams', password='windy')>
8）or查询
  • 再进行过滤的时候，可以通过or_进行多个条件满足其一即可查询出来
from sqlalchemy import or_

users = session.query(User).filter(or_(User.name == "wendy1",User.fullname == "Wendy Williams")).all()
for user in users:
    print(user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE users.name = %(name_1)s OR users.fullname = %(fullname_1)s
-- [generated in 0.00045s] {'name_1': 'wendy1', 'fullname_1': 'Wendy Williams'}

==> 打印结果

<User(name='wendy', fullname='Wendy Williams', password='windy')>
9）主键查询
  • 可以使用get进行主键查询
  • 直接使用session.get
    • 第一个参数为模型类
    • 第二个参数为id值
  • 使用链式调用session.query(User).get(1)
user = session.get(User, 1)
# user = session.query(User).get(1)
print(user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE users.id = %(pk_1)s
-- [generated in 0.00083s] {'pk_1': 1}

==> 打印结果

<User(name='desire', fullname='asdfasdf', password='123123')>
10）范围查询
1. BETWEEN ... AND ...
  • between 范围查询
  • 查询确定范围的值，这些值可以是数字，文本或日期
  • 范围包含开始和结束值
q = session.query(User).filter(User.id.between(2,4)).all()
for user in q:
    print(user.id, user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE users.id BETWEEN %(id_1)s AND %(id_2)s
-- [generated in 0.00053s] {'id_1': 2, 'id_2': 4}

==> 打印结果

2 <User(name='wendy', fullname='Wendy Williams', password='windy')>
3 <User(name='mary', fullname='Mary Contrary', password='mary')>
4 <User(name='fred', fullname='Fred Flintstone', password='freddy')>
2. NOT BETWEEN ... AND ...
  • 只需在between查询的基础上添加~
q = session.query(User).filter(~User.id.between(2,4)).all()
for user in q:
    print(user.id,user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE users.id NOT BETWEEN %(id_1)s AND %(id_2)s
-- [generated in 0.00042s] {'id_1': 2, 'id_2': 4}

==> 打印结果

1 <User(name='desire', fullname='asdfasdf', password='123123')>
7 <User(name='mary', fullname='Mary Contrary', password='mary')>
8 <User(name='fred', fullname='Fred Flintstone', password='654321')>
11）分组查询
group_by 分组查询
q = session.query(User).group_by(User.name).all()
for user in q:
    print(user.id,user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users GROUP BY users.name
-- [generated in 0.00048s] {}

==> 打印结果

1 <User(name='desire', fullname='asdfasdf', password='123123')>
2 <User(name='wendy', fullname='Wendy Williams', password='windy')>
3 <User(name='mary', fullname='Mary Contrary', password='mary')>
4 <User(name='fred', fullname='Fred Flintstone', password='freddy')>
having 聚合操作（使用聚合操作 需要导入 func 库）
from sqlalchemy.sql import func
q = session.query(User).group_by(User.name).having(func.min(User.id)>3).all()
for user in q:
    print(user.id,user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users GROUP BY users.name
HAVING min(users.id) > %(min_1)s
-- [generated in 0.00083s] {'min_1': 3}

==> 打印结果

4 <User(name='fred', fullname='Fred Flintstone', password='freddy')>
统计分组后的数据量
from sqlalchemy.sql import func
q = session.query(User.name, func.count(User.name)) \
    .group_by(User.name).all()
print(q)

==> sql

SELECT users.name AS users_name, count(users.name) AS count_1
FROM users GROUP BY users.name
-- [generated in 0.00184s] {}

==> 打印结果

[('desire', 1), ('wendy', 1), ('mary', 2), ('fred', 2)]

4、删除

  • delete 删除操作
  • 删除操作后，要进行提交commit
  • 返回：删除成功 1，删除失败 0
result = session.query(User).filter_by(id=5).delete()
print(result)
session.commit()

==> sql

DELETE FROM users WHERE users.id = %(id_1)s
-- [generated in 0.00052s] {'id_1': 5}

==> 打印结果

1

5、使用文本SQL

  • 可以使用text()进行文本SQL执行
from sqlalchemy import text

users = session.query(User).filter(text("id < 3")).all()
for user in users:
    print(user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users
WHERE id < 3

==> 打印结果

<User(name='desire', fullname='asdfasdf', password='123123')>
<User(name='wendy', fullname='Wendy Williams', password='windy')>

6、统计

  • count 统计结果数
num = session.query(User).count()
print(num)

==> sql

SELECT count(*) AS count_1
FROM (SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users) AS anon_1

==> 打印结果

4

7、去重

  • distinct 去重
users = session.query(User).distinct().all()
print(users)

==> sql

SELECT DISTINCT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users

==> 打印结果

[
    <User(name='desire', fullname='asdfasdf', password='123123')>, 
    <User(name='wendy', fullname='Wendy Williams', password='windy')>, 
    <User(name='mary', fullname='Mary Contrary', password='mary')>, 
    <User(name='fred', fullname='Fred Flintstone', password='freddy')>
]

8、排序

  • order_by 排序
1. 默认排序，升序
users = session.query(User).order_by(User.id).all()
for user in users:
    print(user.id, user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users ORDER BY users.id

==> 打印结果

1 <User(name='desire', fullname='asdfasdf', password='123123')>
2 <User(name='wendy', fullname='Wendy Williams', password='windy')>
3 <User(name='mary', fullname='Mary Contrary', password='mary')>
4 <User(name='fred', fullname='Fred Flintstone', password='freddy')>
2. 降序
users = session.query(User).order_by(User.id.desc())
for user in users:
    print(user.id, user)

==> sql

SELECT users.id AS users_id, users.name AS users_name, users.fullname AS users_fullname, users.password AS users_password
FROM users ORDER BY users.id DESC

==> 打印结果

4 <User(name='fred', fullname='Fred Flintstone', password='freddy')>
3 <User(name='mary', fullname='Mary Contrary', password='mary')>
2 <User(name='wendy', fullname='Wendy Williams', password='windy')>
1 <User(name='desire', fullname='asdfasdf', password='123123')>

9、别名

1. 为实体类指定别名
  • 使用aliased对实体类指定别名
    • 第一个参数为：实体类名
    • 第二个参数为：别名
  • 添加列时，要使用【别名.属性】
user_alias = aliased(User, name='user_alias')
users = session.query(user_alias, user_alias.name).all()
for instance in users:
    print(instance.user_alias, instance.name)

==> sql

SELECT user_alias.id AS user_alias_id, user_alias.name AS user_alias_name, user_alias.fullname AS user_alias_fullname, user_alias.password AS user_alias_password
FROM users AS user_alias

==> 打印结果

<User(name='desire', fullname='asdfasdf', password='123123')> desire
<User(name='wendy', fullname='Wendy Williams', password='windy')> wendy
<User(name='mary', fullname='Mary Contrary', password='mary')> mary
<User(name='fred', fullname='Fred Flintstone', password='freddy')> fred
2. 为列指定别名
  • label 为列指定别名
  • 获取值得时候，要使用别名进行获取，否则会报错
users = session.query(User.name.label('name_label')).all()
for user in users:
    print(user.name_label)

==> sql

SELECT users.name AS name_label
FROM users

==> 打印结果

desire
wendy
mary
fred
DesireYang
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SQLAlchemy教程（二）基本增删改查
qq_38949193的博客
09-26 729
增删改查 增： from sqlalchemy.orm import sessionmaker from sqlalchemy import create_engine from s1 import models #导入创建表的模块 engine = create_engine('sqlite:///test.db') #连接数据库 Session = sessionmaker(bin...
SQLAlchemy ORM 模版
a490128788的专栏
07-09 120
ORM 是软件开发目前常用的框架。它使得研发人员无需过多关注SQL及数据库层面，将更多精力放在业务逻辑设计上，省了一个数据库工程师。鉴于其优秀的XXX（省钱），所以得到了广泛的应用。 ORM带来的另一个好处，就是由于ORM实现了SQL和程序语言的互译，使得利用软件设计思想优化数据库操作变为可能。通俗说是实现了SQL语句的复用。 软件设计的核心，是灵活和复用。复用意味着省钱：开发成本低！维护成本低！但复用会在一定程度上降低灵活性。 找灵活和复用的平衡是软件设计的重点，故而诞生了23种“设计模式”。 本
SQLAlchemy 中的 Session,sessionmaker,scoped_session详解
没有撤退可言.
03-25 7418
一、关于SQLAlchemy 什么是SQLAlchemy？ 答：SQLAlchemy是一个关系型数据库框架，它提供了高层的 ORM 和底层的原生数据库的操作，让开发者不用直接和 SQL 语句打交道，而是通过 Python 对象来操作数据库，在舍弃一些性能开销的同时，换来的是开发效率的较大提升。 一句话：就是对数据库的抽象！ Session 其实 就是一个会话, 可以和数据库打交道的一个会...
python sqlalchemy session_关于ORM，以及Python中SQLAlchemy的sessionmaker，scoped_session
weixin_39639622的博客
12-03 293
orm(object relational mapping)：对象关系映射。python面向对象，而数据库是关系型。orm是将数据库关系映射为Python中的对象，不用直接写SQL。缺点是性能略差。通过sessionmaker，我们得到一个类，一个能产生session的工厂。我们可以用这个类的对象来操作数据库。example：from sqlalchemy import create_engine...
sqlalchemy.orm.sessionmaker（一）笔记记录
ben1122334的博客
01-10 1868
1. bulk_save_objects：批量插入/批量更新 说明： 大容量保存功能允许将映射的对象用作简单插入和更新操作的源，这些操作可以更容易地组合到更高性能的“executemany”操作中； 从对象中提取数据也使用较低的延迟过程来执行，该过程忽略在更新时是否实际修改了属性，还忽略了SQL表达式。 给定的对象不会添加到会话中，也不会在其上建立其他状态，除非还设置了“return_defau...
【SQLAlchemy】python最常用ORM （三）
kardel的博客
12-10 368
http://www.kardel.xyz/blog/sqlalchemypython%E6%9C%80%E5%B8%B8%E7%94%A8orm-%E4%B8%89/ 基于之前两篇文章，我们可以实现使用SQLAlchemy对单表的简单增删改查操作，本文将整合之前的逻辑，实现一个简单的工具类，封装出增删改查的接口，方便使用。 对于复杂查询，级联查询的适配，则需在query中实现更为详细的逻辑，此处...
ORM-SQLAlchemy
haihaihai2232的博客
06-27 121
ORM ORM, 对象映射关系 , 对象和关系之间的映射, 使用面向对象的方式操作数据库. 关系模型和Python对象之间的映射 tabel => class , 表映射为类 row => object , 行映射为实例 column =>property , 字段映射为属性 SQLAlchemy SQLAlchemy是一个ORM框架 安装 ...
python orm 框架中sqlalchemy用法实例详解
09-18
SQLAlchemy 是 Python 中最成熟的 ORM 框架之一，拥有丰富的资源和文档，以及广泛的支持。许多 Python Web 框架如 Flask 和 Django 都对 SQLAlchemy 提供了良好的支持。它被认为是 Python ORM 的事实标准，能够胜任...
Python-sqlakeyset该库实现了SQLAlchemy的基于键集分页包括ORM和核心
08-10
SQLAlchemy作为Python中最流行的SQL ORM（对象关系映射）框架，提供了强大的数据库操作能力，但默认并不包含键集分页的直接支持。`sqlakeyset`库弥补了这一空白，为SQLAlchemy的ORM和核心模式都提供了键集分页解决...
orm的详细解释概念
12-03
目前市场上的ORM框架有很多，例如Java的Hibernate、MyBatis，.NET的Entity Framework，Python的SQLAlchemy等。这些框架各有特点，可以根据项目需求选择合适的工具。 总结来说，ORM是一种强大的工具，它使开发者能够...
SQLAlchemy —— ORM
白菜执笔人的博客
04-22 1181
Flask 学习笔记 一、ORM 介绍         随着项目越来越大，采用原生 SQL 的方式在代码中会出现大量的 SQL 语句，对项目的进展非常不利。 1. SQL 语句重复利用率不高。越复杂的 SQL 语句条件越多，代码越长。会出现大量相近似的 SQL 语句。 2. 很多 SQL 语句是在业务逻辑中拼出来的。如果有数据库需要更改，就要去修改...
SQLAlchemy ORM框架
个人学习笔记库，一篇一篇记录成长的足迹
12-10 2064
ORM简介 ORM 全称 Object Relational Mapping, 叫对象关系映射。简单的说，ORM 将数据库中的表与面向对象语言中的类建立了一种对应关系。这样，我们要操作数据库，数据库中的表或者表中的一条记录就可以直接通过操作类或者类实例来完成。 对于数据的操作增、删、查、改（主要是查）得到的只是一个字符串没办法显示在前端界面。但用面向对象语言与类建立映射（mapping）后将得到的字符存储在内存中，在声明周期类显示在界面上。 我们知道操作数据库都是用SQL语句执行的： 建数据库 crea
SQLAlchemy中filter函数的使用
m0_67093160的博客
09-26 1999
SQLAlchemy中filter函数的使用
Python库学习(十四):ORM框架-SQLAlchemy
weixin_39001207的博客
01-07 1619
相反，它仅是为了创建一个数据库引擎对象，该对象封装了连接到数据库的配置和行为，但直到实际执行数据库操作时才会尝试建立连接。会话允许你在应用程序中创建、更新、删除数据库中的数据，并提供了一系列方法来管理事务的提交和回滚。模型类相关代码，不用我们挨个去写模型，它的实现原理：通过连接到数据库，然后分析数据库结构，最后生成对应的。返回查询结果的第一列的第一个值，通常用于获取单个聚合函数的结果，如。执行外连接操作，返回左表中的所有记录以及右表中匹配的记录。在插入新记录时，如果没有提供该列的值，则将使用默认值。
SQLAlchemy ORM查询常见筛选条件的表示方法
王敏的专栏
03-07 7456
使用 SQLAlchemy ORM 查询数据的时候，如果需要的获取的记录按选条件进行筛选，可以参考本文介绍的相关方法。不存在什么技巧，需要的是熟悉而已。使用我经常用的数据源 Sample Data。推荐使用 jupyter notebook 进行交互测试。 使用 SQLAlchemy ORM，涉及到 engine, session 等对象。在查询前，先准备好如下代码： from sqlalchem...
python SQLALchemy ORM模型映射
weixin_39771914的博客
08-14 1528
The ``declarative_base()`` function is now available as sqlalchemy.orm.declarative_base(). (deprecated since: 2.0) (Background on SQLAlchemy 2.0 at: https://sqlalche.me/e/b8d9) base = declarative_base(engine) TypeError: declarative_base() takes 0 position
SQLAlchemy ORM指南：简化数据库操作的最佳实践
最新发布
ak_bingbing的博客
01-19 1599
​ 在这篇博客中，你详细介绍了 SQLAlchemy 的相关使用，包括增删改查操作以及创建表等内容。这些知识对于学习 Flask 和 Django 构建 Web 应用程序提供了坚实的基础。​ 通过掌握 SQLAlchemy，你可以更加灵活地操作数据库，轻松实现数据的持久化和查询。这为你开发功能丰富、可靠的 Web 应用程序提供了强大的工具和技术支持。​ 同时，理解 SQLAlchemy 的工作原理和核心概念，例如 ORM（对象关系映射）模式，可以帮助你更好地组织和管理应用程序的数据层。
【SQLAlchemy】官方文档教程学习2：模型类的定义与创建数据表
Maestro_T的博客
11-26 1130
Declare a Mapping 当使用ORM时，配置过程首先是描述我们要处理的数据库表，然后是定义我们自己的类，这些类将被映射到这些表。在现代SQLAlchemy中，这两个任务通常是一起执行的，使用一个称为声明式扩展Declarative Extensions的系统，它允许我们创建包含指令的类，以描述它们将被映射到的实际数据库表。 使用声明式系统映射的类是用一个基类来定义的，这个基类维护着一个相对于这个基类的类和表的目录–这被称为声明式基类declarative base class。我们的应用程序通常
sqlalchemy orm框架的应用
06-01
SQLAlchemy ORM框架是一个Python编程语言下的ORM框架，它提供了一个高度抽象的SQL表达式语言，可以让我们用Python对象的方式操作数据库，而不需要直接使用SQL语句。 应用方面，SQLAlchemy ORM框架可以用于快速开发基于数据库的应用程序，例如Web应用，数据分析应用等。通过SQLAlchemy ORM框架，我们可以使用Python对象来代替数据库中的表格，实现面向对象的数据访问。同时，SQLAlchemy ORM框架还提供了一些高级的特性，例如数据类型映射、数据关联、事务处理等，可以方便地实现复杂的数据操作逻辑。 总的来说，SQLAlchemy ORM框架的应用可以大大提高开发效率，同时也可以让数据库操作变得更加简单、安全、可靠。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值