SQLAlchemy创建，crud，聚合函数，过滤条件，外键约束以及表间的多种关系

最新推荐文章于 2024-05-12 11:10:30 发布
最新推荐文章于 2024-05-12 11:10:30 发布
阅读量8.9k 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42686808/article/details/105338588
版权

SQLAlchemy创建，crud，聚合函数，过滤条件，外键约束，relationship


1.sqlalchemy的创建
先创建引擎create_engine，再创建基类Base：
from sqlalchemy.ext.declarative import declarative_base,Column
from sqlalchemy import create_engine

DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)

class Person(Base):
        __tablename__ = 'person'
        # 2. 在这个ORM模型中创建一些属性，来跟表中的字段进行一一映射。这些属性必须是sqlalchemy给我们提供好的数据类型。
        id = Column(Integer,primary_key=True,autoincrement=True)
        name = Column(String(50))
        age = Column(Integer)

使用Base.metadata.create_all()来将模型映射到数据库中。

**注意:**一旦使用Base.metadata.create_all()将模型映射到数据库中后，即使改变了模型的字段，也不会重新映射了。

2.crud
用session做数据的增删改查操作：

构建session对象：所有和数据库的ORM操作都必须通过一个叫做session的会话对象来实现，通过以下代码来获取会话对象：

*add_data:
```python
from sqlalchemy.orm import sessionmaker
engine = create_engine(DB_URI)
session = sessionmaker(engine)()
添加对象：
* 创建对象，也即创建一条数据：

    p = Person(name='zhiliao',age=18,country='china')
   
* 将这个对象添加到`session`会话对象中：
    
    session.add(p)
   
* 将session中的对象做commit操作（提交）：
 
    session.commit()
   
* 一次性添加多条数据：
    
    p1 = Person(name='zhiliao1',age=19,country='china')
    p2 = Person(name='zhiliao2',age=20,country='china')
    session.add_all([p1,p2])
    session.commit()
  
```
*seach_data:
 	# 查找某个模型对应的那个表中所有的数据：
    all_person = session.query(Person).all()
    # 使用filter_by来做条件查询
    all_person = session.query(Person).filter_by(name='zhiliao').all()
    # 使用filter来做条件查询
    all_person = session.query(Person).filter(Person.name=='zhiliao').all()
    # 使用get方法查找数据，get方法是根据id来查找的，只会返回一条数据或者None
    person = session.query(Person).get(primary_key)
    # 使用first方法获取结果集中的第一条数据
    person = session.query(Person).first()
*update_data:
	#修改对象：首先从数据库中查找对象，然后将这条数据修改为你想要的数据，最后做commit操作就可以修改数据了
    person = session.query(Person).first()
    person.name = 'ketang'
    session.commit()
*delete_data:
     #删除对象：将需要删除的数据从数据库中查找出来，然后使用`session.delete`方法将这条数据从session中删除，最后做commit操作就可以了
    person = session.query(Person).first()
    session.delete(person)
    session.commit()
SQLAlchemy常用数据类型：

  1. Integer：整形，映射到数据库中是int类型。

  2. Float：浮点类型，映射到数据库中是float类型。他占据的32位。

  3. Double：双精度浮点类型，映射到数据库中是double类型，占据64位。

  4. String：可变字符类型，映射到数据库中是varchar类型.

  5. Boolean：布尔类型，映射到数据库中的是tinyint类型。

  6. DECIMAL：定点类型。是专门为了解决浮点类型精度丢失的问题的。在存储钱相关的字段的时候建议大家都使用这个数据类型。并且这个类型使用的时候需要传递两个参数，第一个参数是用来标记这个字段总能能存储多少个数字，第二个参数表示小数点后有多少位。

  7. Enum：枚举类型。指定某个字段只能是枚举中指定的几个值，不能为其他值。在ORM模型中，使用Enum来作为枚举，示例代码如下：

    ```python
class Article(Base):
    __tablename__ = 'article'
    id = Column(Integer,primary_key=True,autoincrement=True)
    tag = Column(Enum("python",'flask','django'))
```

    ​ 在Python3中，已经内置了enum这个枚举的模块，我们也可以使用这个模块去定义相关的字段。示例代码如下：

    ```python
class TagEnum(enum.Enum):
    python = "python"
    flask = "flask"
    django = "django"
```

    class Article(Base):
    __tablename__ = 'article'
    id = Column(Integer,primary_key=True,autoincrement=True)
    tag = Column(Enum(TagEnum))

article = Article(tag=TagEnum.flask)

    1. Date：存储时间，只能存储年月日。映射到数据库中是date类型。在Python代码中，可以使用datetime.date来指定。示例代码如下：

      class Article(Base):
    __tablename__ = 'article'
    id = Column(Integer,primary_key=True,autoincrement=True)
    create_time = Column(Date)

article = Article(create_time=date(2017,10,10))

    2. DateTime：存储时间，可以存储年月日时分秒毫秒等。映射到数据库中也是datetime类型。在Python代码中，可以使用datetime.datetime来指定。示例代码如下：

      class Article(Base):
    __tablename__ = 'article'
    id = Column(Integer,primary_key=True,autoincrement=True)
    create_time = Column(DateTime)

article = Article(create_time=datetime(2011,11,11,11,11,11))

    3. Time：存储时间，可以存储时分秒。映射到数据库中也是time类型。在Python代码中，可以使用datetime.time来至此那个。示例代码如下：

      class Article(Base):
    __tablename__ = 'article'
    id = Column(Integer,primary_key=True,autoincrement=True)
    create_time = Column(Time)

article = Article(create_time=time(hour=11,minute=11,second=11))

    4. Text：存储长字符串。一般可以存储6W多个字符。如果超出了这个范围，可以使用LONGTEXT类型。映射到数据库中就是text类型。

    5. LONGTEXT：长文本类型，映射到数据库中是longtext类型。

Column常用参数：

  1. primary_key：设置某个字段为主键。

  2. autoincrement：设置这个字段为自动增长的。

  3. default：设置某个字段的默认值。在发表时间这些字段上面经常用。

  4. nullable：指定某个字段是否为空。默认值是True，就是可以为空。

  5. unique：指定某个字段的值是否唯一。默认是False。

  6. onupdate：在数据更新的时候会调用这个参数指定的值或者函数。在第一次插入这条数据的时候，不会用onupdate的值，只会使用default的值。常用的就是update_time（每次更新数据的时候都要更新的值）。

  7. name：指定ORM模型中某个属性映射到表中的字段名。如果不指定，那么会使用这个属性的名字来作为字段名。如果指定了，就会使用指定的这个值作为参数。这个参数也可以当作位置参数，在第1个参数来指定。

    title = Column(String(50),name='title',nullable=False)
title = Column('my_title',String(50),nullable=False)
3.聚合函数
query可用参数：
  1. 模型对象。指定查找这个模型中所有的对象。
  2. 模型中的属性。可以指定只查找某个模型的其中几个属性。
  3. 聚合函数。
    • func.count：统计行的数量。
    • func.avg：求平均值。
    • func.max：求最大值。
    • func.min：求最小值。
    • func.sum：求和。
      func上，其实没有任何聚合函数。但是因为他底层做了一些魔术，只要mysql中有的聚合函数，都可以通过func调用。
4.过滤条件
filter过滤条件：

过滤是数据提取的一个很重要的功能，以下对一些常用的过滤条件进行解释，并且这些过滤条件都是只能通过filter方法实现的：

  1. equals：

    article = session.query(Article).filter(Article.title == "title0").first()
print(article)

  2. not equals:

    query.filter(User.name != 'ed')

  3. like：

    query.filter(User.name.like('%ed%'))

  4. in：

    query.filter(User.name.in_(['ed','wendy','jack']))
# 同时，in也可以作用于一个Query
query.filter(User.name.in_(session.query(User.name).filter(User.name.like('%ed%'))))

  5. not in：

    query.filter(~User.name.in_(['ed','wendy','jack']))

  6. is null：

    query.filter(User.name==None)
# 或者是
query.filter(User.name.is_(None))

  7. is not null:

    query.filter(User.name != None)
# 或者是
query.filter(User.name.isnot(None))

  8. and：

    from sqlalchemy import and_
query.filter(and_(User.name=='ed',User.fullname=='Ed Jones'))
# 或者是传递多个参数
query.filter(User.name=='ed',User.fullname=='Ed Jones')
# 或者是通过多次filter操作
query.filter(User.name=='ed').filter(User.fullname=='Ed Jones')

  9. or：

    from sqlalchemy import or_  query.filter(or_(User.name=='ed',User.name=='wendy'))

如果想要查看orm底层转换的sql语句，可以在filter方法后面不要再执行任何方法直接打印就可以看到了。比如：

```python
    articles = session.query(Article).filter(or_(Article.title=='abc',Article.content=='abc'))
    print(articles)
```
5.外键约束
外键：

使用SQLAlchemy创建外键非常简单。在从表中增加一个字段，指定这个字段外键的是哪个表的哪个字段就可以了。从表中外键的字段，必须和父表的主键字段类型保持一致。
示例代码如下：

class User(Base):
    __tablename__ = 'user'
    id = Column(Integer,primary_key=True,autoincrement=True)
    username = Column(String(50),nullable=False)

class Article(Base):
    __tablename__ = 'article'
    id = Column(Integer,primary_key=True,autoincrement=True)
    title = Column(String(50),nullable=False)
    content = Column(Text,nullable=False)

    uid = Column(Integer,ForeignKey("user.id"))

外键约束有以下几项： 
1. RESTRICT：父表数据被删除，会阻止删除。默认就是这一项。 
2. NO ACTION：在MySQL中，同RESTRICT。 
3. CASCADE：级联删除。 
4. SET NULL：父表数据被删除，子表数据会设置为NULL。

第一种：RESTRICT(默认就是这种。当父表数据被删除，从表会拒绝删除)
语法：uid = Column(Integer , ForeignKey("user.id" ,ondelete="RESTRICT")) 

第二种：NO ACTIION（同RESTRICT 一样）
语法: uid = Column(Integer , ForeignKey("user.id" ,ondelete="NO ACTION")) 

第三种：CASCADE (父表数据删除、从表数据也会跟着删除)
语法：uid = Column(Integer , ForeignKey("user.id" ,ondelete="CASCADE"))

第四种： SET NULL (父表数据删除，从表外键字段设为NULL)
语法：uid = Column(Integer , ForeignKey("user.id" ,ondelete="SET NULL"))

注意： 如果uid字段设置了 nullable=False , 再设置 ondelete = "SET NULL",pycharm运行程序则会报错
6.relationship
ORM关系以及一对多：

mysql级别的外键，还不够ORM，必须拿到一个表的外键，然后通过这个外键再去另外一张表中查找，这样太麻烦了。SQLAlchemy提供了一个relationship，这个类可以定义属性，以后在访问相关联的表的时候就直接可以通过属性访问的方式就可以访问得到了。示例代码：

class User(Base):
    __tablename__ = 'user'
    id = Column(Integer,primary_key=True,autoincrement=True)
    username = Column(String(50),nullable=False)

    # articles = relationship("Article")

    def __repr__(self):
        return "<User(username:%s)>" % self.username

class Article(Base):
    __tablename__ = 'article'
    id = Column(Integer,primary_key=True,autoincrement=True)
    title = Column(String(50),nullable=False)
    content = Column(Text,nullable=False)
    uid = Column(Integer,ForeignKey("user.id"))

    author = relationship("User",backref="articles")

另外，可以通过backref来指定反向访问的属性名称。articles是有多个。他们之间的关系是一个一对多的关系

一对一的关系：

在sqlalchemy中，如果想要将两个模型映射成一对一的关系，那么应该在父模型中，指定引用的时候，要传递一个uselist=False这个参数进去。就是告诉父模型，以后引用这个从模型的时候，不再是一个列表了，而是一个对象了。示例代码如下：

class User(Base):
    __tablename__ = 'user'
    id = Column(Integer,primary_key=True,autoincrement=True)
    username = Column(String(50),nullable=False)

    extend = relationship("UserExtend",uselist=False)

    def __repr__(self):
        return "<User(username:%s)>" % self.username

class UserExtend(Base):
    __tablename__ = 'user_extend'
    id = Column(Integer, primary_key=True, autoincrement=True)
    school = Column(String(50))
    uid = Column(Integer,ForeignKey("user.id"))

    user = relationship("User",backref="extend")

当然，也可以借助sqlalchemy.orm.backref来简化代码：

class User(Base):
    __tablename__ = 'user'
    id = Column(Integer,primary_key=True,autoincrement=True)
    username = Column(String(50),nullable=False)

    # extend = relationship("UserExtend",uselist=False)

    def __repr__(self):
        return "<User(username:%s)>" % self.username

class UserExtend(Base):
    __tablename__ = 'user_extend'
    id = Column(Integer, primary_key=True, autoincrement=True)
    school = Column(String(50))
    uid = Column(Integer,ForeignKey("user.id"))

    user = relationship("User",backref=backref("extend",uselist=False))
多对多的关系：
  1. 多对多的关系需要通过一张中间表来绑定他们之间的关系。
  2. 先把两个需要做多对多的模型定义出来
  3. 使用Table定义一个中间表，中间表一般就是包含两个模型的外键字段就可以了，并且让他们两个来作为一个“复合主键”。
  4. 在两个需要做多对多的模型中随便选择一个模型，定义一个relationship属性，来绑定三者之间的关系，在使用relationship的时候，需要传入一个secondary=中间表。
书山压力大&emsp；
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
SQLalchemy-Challenge:使用SQLAlchemy，ORM查询，Pandas和Matplotlib在气候数据库上进行气候分析和数据探索
04-23
通过定义模型类，我们可以将数据库表与Python对象关联起来，然后通过这些对象执行CRUD（创建、读取、更新、删除）操作。ORM查询使得数据库操作变得更加直观，减少了学习和使用不同SQL方言的负担。 **Pandas** 是一...
flask学习之sqlAlchemy_orm之聚合函数
LCY133的博客
11-04 1938
聚合函数共分为： func.count：统计行的数量。 func.avg：求平均值。 func.max：求最大值。 func.min：求最小值。 func.sum：求和。 在程序的最后会进行相关的演示 中间需要的操作还有如下几部分： 1.生成表格 2.批量用随机数填充内容到表格 3.计算聚合函数值 1.生成表格： engine = create_engine(DB_URL) # 都要继承这个函数生成的基类 Base = declarative_base(engine) class User(Base)
SQLAlchemy的CRUD操作
PythonWangbo的博客
04-02 758
SQLAlchemy在 flask中的CRUD操做CreatReadUpdataDeletef Creat 1 创建Python对象（实例化模型类） 2 添加新创建的记录到对数据库对话 3 提交数据库对话 from app import db, Note note1 = Note(body=1) db.session.add(note1) db.session.commit() 首先从app模块...
基于sqlalchemy实现CRUD
最新发布
nnjy_1993的博客
05-12 165
【代码】基于sqlalchemy实现CRUD。
Flask之SQLAlchemy的基本使用
积跬步，至千里。
05-31 2130
SQLAlchemy是一个流行的Python ORM对象关系映射框架。Flask-SQLAlchemy是一个用于在Flask应用程序中使用SQLAlchemy进行数据库访问的扩展库。
sqlalchemy 操作数据库CRUD
matrixdodo
04-30 465
sqlalchemy 连接数据库
93.SQLAlchemy对数据的CRUD
m0_63953077的博客
09-24 190
使用ORM(SQLAlchemy)对数据的增删改查
SqlAlchemy使用教程(六) -- ORM 表间关系的定义与CRUD操作
Python技术探索
01-22 1511
介绍Sqlalchemy ORM 表间关系的定义与CRUD增删改查操作 表间关系主要包括：一对多，一对一，多对多。其中一对多关系中也隐含了多对一关系。 表间关系是数据库操作中的重要技术点，非常有必要理解与掌握。
SQLAlchemy 1.2.8
06-07
7. **高级查询功能**：除了基本的查询，SQLAlchemy还提供了JOIN操作、聚合函数、子查询、窗口函数等多种高级查询特性，满足复杂的数据获取需求。 8. **事件监听**：SQLAlchemy允许注册监听器来响应特定的数据库操作...
sqlalchemy挑战
02-14
8. **高级查询**：SQLAlchemy的表达式语言允许我们构造复杂的查询，包括连接（JOIN）、子查询、聚合函数（如COUNT、SUM等）、排序（ORDER BY）、分组（GROUP BY）等。这些查询可以直接在Python代码中构建，保持代码...
sqlalchemy-challange
03-14
SQLAlchemy 是一个强大的 Python SQL 工具包和 ORM（对象关系映射）系统，它提供了对多种数据库引擎的全面支持，使得在 Python 中操作数据库变得简单。在这个挑战中，我们将探讨如何利用 SQLAlchemy 进行气候数据的...
Python-基于sqlalchemy自动化实现curddemo
08-10
基于sqlalchemy自动化实现curd demo
SQLAlchemy Dialect for SAP HANA.zip
02-04
使用 SQLAlchemy 的表达式语言，可以构建复杂的 SQL 查询，包括联接、子查询、聚合函数等。 10. **性能优化**： SQLAlchemy 提供了缓存和预加载等功能，有助于提高性能。例如，使用 `joinedload` 或 `...
Flask——SQLAlchemy外键以及四种约束，一对多，一对一，多对多关系详解
Oopsl的博客
04-25 1403
外键 ForeignKey使表之间的关系更加紧密 class Grade(Base): #班级表 __tablename__ = 'grade' id = Column(Integer, primary_key=True) gradename = Column(String(50), nullable=False) class Person(Base):# 学生表 ...
SQLAlchemy对数据进行CRUD操作
a272329874a的博客
03-26 759
所有和数据库的ORM操作都必须通过一个叫做session的会话对象 来实现，通过以下代码来获取会话对象。
SQLAlchemy映射表结构和对数据的CRUD
m0_67093160的博客
09-23 291
SQLAlchemy映射表结构和对数据的CRUD
Flask 学习-85.Flask-SQLAlchemy 多个不确定条件查询
qq_27371025的博客
10-03 4605
在后台管理数据的时候，经常会有多个条件查询，查询参数可以是一个也可以是多个，如果没有查询参数就返回全部数据。
Python数据库ORM框架SQLALchemy操作数据库简单封装表关系(一对一、一对多、多对多)增删改查crud工具
J_Sky：编程爱好者,又菜又爱玩.
11-15 1406
SQLALchemy是python下操作数据库的工具包,是一个数据库ORM(对象关系映射)框架,使用SQLALchemy可以极大的简化对数据库和数据的操作,使用ORM管理数据更直观方便.这里我记录一次关于sqlalchemy使用的简单实践,包括了创建数据库连接、定义模型、表关系(一对一、一对多、多对多)增删改查、crud工具,最后使用了pytest进行了一些测试.
SqlAlchemy 使用
高压锅博客
01-24 561
案例代码 from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column,INTEGER,String,DECIMAL from sqlalchemy.orm import sessionmaker username='root' passwd='root' port=3306 ip_dz='127.0.0.1' databa
flask sqlalchemy Multiple joins in one call 无外键
06-01
如果没有外键，你可以使用 `join` 函数来进行多个表的连接。例如，如果你有三个表 `table1`、`table2` 和 `table3`，你可以使用以下代码进行多个表的连接： ```python from flask_sqlalchemy import SQLAlchemy db = SQLAlchemy() class Table1(db.Model): id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(50)) class Table2(db.Model): id = db.Column(db.Integer, primary_key=True) table1_id = db.Column(db.Integer) name = db.Column(db.String(50)) class Table3(db.Model): id = db.Column(db.Integer, primary_key=True) table2_id = db.Column(db.Integer) name = db.Column(db.String(50)) # Join multiple tables query = Table1.query.join(Table2, Table1.id == Table2.table1_id).join(Table3, Table2.id == Table3.table2_id).all() ``` 在上面的代码中，使用 `join` 函数连接了三个表，并使用 `all()` 函数返回了所有记录。请注意，在没有外键的情况下，你需要手动指定连接条件。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值