SQLAlchemy（一）

最新推荐文章于 2024-03-11 14:58:45 发布
最新推荐文章于 2024-03-11 14:58:45 发布
阅读量610 收藏 4
点赞数 3
分类专栏： Python Road flask 文章标签： Flask 数据库 SQLAlchemy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/T_I_A_N_/article/details/100007144
版权

1、flask-sqlalchemy安装

pip install flask_sqlalchemy

2、SQLAlchemy连接数据库

from sqlalchemy import create_engine

HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'flask_study'
USERNAME = 'root'
PASSWORD = 'tian'

# dialect+driver://username:password@host:port/database
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) #使用create_engine创建一个引擎，然后再调用这个引擎的connect（）方法
conn = engine.connect()

3、定义ORM模型并映射到数据库

ORM：对象关系映射

创建一个ORM模型，这个ORM模型必须继承自sqlalchemy给我们提供好的基类
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

engine = create_engine(DB_URI) #连接数据库

Base = declarative_base(engine) #继承flask提供的基类

#  必须继承自sqlalchemy给我们提供好的基类
class User(Base):
    __tablename__ = 'User'
    name = Column(String(50), nullable=True)
    age = Column(Integer)
    id = Column(Integer, primary_key=True, nullable=False)



#  将创建好的ORM模型，映射到数据库中。
Base.metadata.create_all()

4、SQLAlchemy对数据的增删改查

①用session做数据的增删改查操作

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

    from sqlalchemy.orm import sessionmaker

    engine = create_engine(DB_URI)
    session = sessionmaker(engine)()

②增：

obj = User(name='tian', age=18)
session.add(obj)
session.commit()

③删：

obj = session.query(User).first()
session.delete(obj)
session.commit()

④改：

obj = session.query(User).first()
obj.name='mingbo'
session.commit()

⑤查：

obj = session.query(User).first()
print(obj)

5、SQLAlchemy常见数据类型

1. Integer：整形，映射到数据库中是int类型。
2. Float：浮点类型，映射到数据库中是float类型。他占据的32位。
3. Double：双精度浮点类型，映射到数据库中是double类型，占据64位。
4. String：可变字符类型，映射到数据库中是varchar类型.
5. Boolean：布尔类型，映射到数据库中的是tinyint类型。
6. DECIMAL：定点类型。是专门为了解决浮点类型精度丢失的问题的。这个类型使用的时候需要传递两个参
数，第一个参数是用来标记这个字段总能能存储多少个数字，第二个参数表示小数点后有多少位。
7. Enum：枚举类型。指定某个字段只能是枚举中指定的几个值，不能为其他值。在ORM模型中，使用Enum来作为枚举
8. Date：存储时间，只能存储年月日。映射到数据库中是date类型。在Python代码中，可以使用`datetime.date`来指定。
9. DateTime：存储时间，可以存储年月日时分秒毫秒等。映射到数据库中也是datetime类型。
在Python代码中，可以使用`datetime.datetime`来指定。
10. Time：存储时间，可以存储时分秒。映射到数据库中也是time类型。在Python代码中，可以使用`datetime.time`来至此那个。
11. Text：存储长字符串。一般可以存储6W多个字符。如果超出了这个范围，可以使用LONGTEXT类型。映射到数据库中就是text类型。
12. LONGTEXT：长文本类型，映射到数据库中是longtext类型。

6、Column常用参数

  1.  primary_key：设置某个字段为主键。
  2.  autoincrement：设置这个字段为自动增长的。
  3.  default：设置某个字段的默认值。在发表时间这些字段上面经常用。
  4.  nullable：指定某个字段是否为空。默认值是True，就是可以为空。
  5.  unique：指定某个字段的值是否唯一。默认是False。
  6.  onupdate：在数据更新的时候会调用这个参数指定的值或者函数。在第一次插入这条数据的时候，不会用onupdate的值，只会使用default的值。常用的就是`update_time`（每次更新数据的时候都要更新的值）。
  7. name：指定ORM模型中某个属性映射到表中的字段名。如果不指定，那么会使用这个属性的名字来作为字段名。如果指定       了，就会使用指定的这个值作为参数。这个参数也可以当作位置参数，在第1个参数来指定。

7、query可用参数：

  1.  func.count：统计行的数量。
  2.  func.avg：求平均值。
  3. func.max：求最大值。
  4. func.min：求最小值。
  5. func.sum：求和。

只要mysql中有的聚合函数，都可以通过func调用。

示例：

from sqlalchemy import func
result = session.query(func.max(Article.price)).first()

8、filter过滤：

1. equals：

obj = session.query(User).filter(User.name=='mingbo').first()
print(obj)

2. not equals:

obj = session.query(User).filter(User.name!='mingbo').all()

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方法后面不要再执行任何方法直接打印就可以看到了。比如：
        articles = session.query(Article).filter(or_(Article.title=='abc',Article.content=='abc'))
        print(articles)

9、外键及其四种约束讲解：

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

10、外键关系

个人觉得，比Django的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", uselist=False)  # backref只需在一个表里写就行，反向引用，

    def __repr__(self):
        return "<Article(title:%s,content:%s)>" % (self.title, self.content)

查询某个作者的文章题目：
 

use_obj=session.query(User).first()
for article in use_obj.articles:   
    #articles是backref的值
    print(article.title)

查询某篇文章的作者：

article_obj=session.query(Article).first()
print(article_obj.author.username)

②一对一

把一张表中不常用的字段放到另一张表。是一对一的关系。

在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=backref("extend",uselist=False))

③多对多

1. 先把两个需要做多对多的模型定义出来
2. 使用Table定义一个中间表，中间表一般就是包含两个模型的外键字段就可以了，并且让他们两个来作为一个“复合主键”。
3. 在两个需要做多对多的模型中随便选择一个模型，定义一个relationship属性，来绑定三者之间的关系，在使用relationship的时候，需要传入一个secondary=中间表。

文章和标签是多对多的关系：
 

from sqlalchemy import Table
from sqlalchemy.orm import sessionmaker.relationship,backref

article_tag = Table(
    "article_tag",  # 表名
    Base.metadata,  #
    Column("article_id", Integer, ForeignKey("article.id"), primary_key=True),  # 列名，类型，外键映射，作为主键（唯一）
    Column("tag_id", Integer, ForeignKey("tag.id"), primary_key=True)
)


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

    # tags = relationship("Tag",backref="articles",secondary=article_tag)

    def __repr__(self):
        return "<Article(title:%s)>" % self.title


class Tag(Base):
    __tablename__ = 'tag'
    id = Column(Integer, primary_key=True, autoincrement=True)
    name = Column(String(50), nullable=False)

    articles = relationship("Article", backref="tags", secondary=article_tag)  # secondary指向第三张表。
#Article是关联表，，backref是Article表用来查Tag表时用到的。

    def __repr__(self):
        return "<Tag(name:%s)>" % self.name

①查询一篇文章的标签

article_obj = session.query(Article).first()
for i in article_obj.tags:
    print(i.id,i.name)

②查询某个标签有哪些文章

tag_obj = session.query(Tag).first()
for i in tag_obj.articles:
    print(i.id,i.title)

总得来说，SQLAlchemy的数据库查询比Django的数据库查询方便了许多，对正向和反向的查询很容易实现。

__tian__
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SQLAlchemy使用方法
全儿的博客
09-21 334
SQLAlchemy学习记录 一、关系定义 （一）一对多关系 onetomany 表示一对多的关系时，在子表类中通过 foreign key (外键)引用父表类。 然后，在父表类中通过 relationship() 方法来引用子表的类： class User(Base): __tablename__ = 'users' id = Column(Integer, primary_k...
SQLAlchemy使用教程
m0_67401499的博客
08-02 1600
ORM(ObjectRelationalMapping，对象关系映射)可以绕过SQL语句，把数据库的table（表）映射为编程语言的class（类），可以直接使用编程语言的对象模型操作数据库，而不使用SQL语句。ORM把表映射成类，把行作为实例，把字段作为属性，在执行对象操作时最终会把对象的操作专函为数据库原生语句。...
常用的SQLalchemy 字段类型
热门推荐
ajiong314
06-22 1万+
常用的SQLAlchemy字段类型类型名python中类型说明Integerint普通整数，一般是32位SmallIntegerint取值范围小的整数，一般是16位BigIntegerint或long不限制精度的整数Floatfloat浮点数Numericdecimal.Decimal普通整数，一般是32位Stringstr变长字符串Textstr变长字符串，对较长或不限长度的字符串做了优化Uni...
SQLAlchemy笔记
weixin_46469970的博客
04-19 277
SQLAlchemy工具(ORM工具) 什么是ORM！？ 答：object relation mapping；对象关系映射； 大白话解释：通过模型类对象，操作数据库增删改查！！而不是直接使用sql语句！ ORM语法操作的本质就是一种翻译，把基于orm语法编写的代码(如BookInfo.objects.all())翻译成真正用于和数据库通信的sql语句(select * from tb_books)...
SQLAlchemy 字段、要点
Could_tzw的博客
05-18 2161
SQLAlchemy 一 、字段 类型名 Python类型 说明 Integer int 普通整数 一般是32位 SmallInteger int 取值范围小的整数 一般是 16 位 BigInteger int 或 long 不限制精度的整数 Float float 浮点数 Numeric decimal.Decimal 定点数 String str 变长字符串 Text str 变长字符串，对较长或不限长度的字符串做了优化 Unicode unicode 变长
【sqlalchemy框架】中的bool布尔类型，在mysql中实际存储为【tinyint字段类型-一个字节的int类型】
weixin_43343144的博客
06-26 1233
基于sqlalchemy框架框架的Bool类型，在mysql中实际存储为【tinyint字段类型-一个字节的int类型】 比如：基于mysql中的tinyint字段值为0，在sqlalchemy返回False,其他值为True
Flask SQLAlchemy一对一,一对多的使用方法实践
12-23
Flask-SQLAlchemy安装和建表操作请参考这里。 复制代码 代码如下:# Role表class Role(db.Model): id=db.Column(db.Integer,primary_key=True) name=db.Column(db.String(80))# RoleType表class Role_type(db....
sqlalchemy
04-09
sqlalchemy 是python对数据库操作一个库。里面集成了各种方法。有兴趣的可以看看
FlaskSQLAlchemy下载及安装
02-28
**Flask-SQLAlchemy**是Python微框架Flask的一个扩展，它使得在Flask应用中集成和使用SQLAlchemy变得更加方便。SQLAlchemy是Python的一个强大的ORM（对象关系映射）库，能够将数据库操作转化为面向对象的编程方式。...
解决pandas使用sqlalchemy保存到Mysql数据库时，bool布尔类型数据转为tinyint数据的读取
最新发布
呆萌的代Ma
03-11 482
pandas在使用to_sql()保存数据到数据表中，Mysql会将bool类型的数据转为tinyint类型，比如：此时数据表字段的类型为：这样就可以在读取出数据之后，将指定的这两列bool_true与bool_false转为bool布尔类型的数据。
Python-SQLAlchemy正确生成浮点型的方法，解决sqlachemy Float浮点型的坑，生成float类型时，长度和精度均为0，导致查询不到结果！
weixin_43343144的博客
06-07 5583
问题：在使用mysql数据库的时候【Float类型生成的长度和精度均为0】,不管是直接操作mysql还是使用SQLAlchemy的filter条件查询浮点数都是如此！ # 查询price字段【定义为Float类型】导致查询==条件的时候失败 orders = db.session.query(cls.create_time, cls.price, cls.amount).filter( ...
SQLALchemy笔记
dream_0870的博客
05-25 308
SQLALchemy笔记 使用SQLAlchemy去连接数据库： 使用SQLALchemy去连接数据库，需要使用一些配置信息，然后将他们组合成满足条件的字符串： HOSTNAME = '127.0.0.1' PORT = '3306' DATABASE = 'first_sqlalchemy' USERNAME = 'root' PASSWORD = 'root' # dialect+driver://username:password@host:port/database DB_URI = "mysql
sqlalchemy常用的数据类型
liweiweili126的博客
03-20 875
# SQLALchemy笔记 ### 使用SQLAlchemy去连接数据库： 使用SQLALchemy去连接数据库，需要使用一些配置信息，然后将他们组合成满足条件的字符串： ```python HOSTNAME = '127.0.0.1' PORT = '3306' DATABASE = 'first_sqlalchemy' USERNAME = 'root' PASSWORD = 'root...
Flask之sqlalchemy过滤、外键和表单关系
qq_26008885的博客
11-10 648
一、过滤条件 过滤是数据提取的一个很重要的功能，以下对一些常用的过滤条件进行解释，并且这些过滤条件都是只能通过filter方法实现的 equals query.filter(User.name == 'ed')或query.filter_by(name = 'ed') not equals query.filter(User.name != 'ed') like query.filter(User.name.like('%ed%')) in query.filter(User.name.in_(['e
Sqlalchemy 常用数据类型
高压锅博客
01-24 2721
1. SQLAlchemy常用数据类型 Integer：整形，映射到数据库中是int类型。 Float：浮点类型，映射到数据库中是float类型。他占据的32位。 Double：双精度浮点类型，映射到数据库中是double类型，占据64位。 String：可变字符类型，映射到数据库中是varchar类型. Boolean：布尔类型，映射到数据库中的是tinyint类型。 DECIMAL：定点类型。是专门为了解决浮点类型精度丢失的问题的。在存储钱相关的字段的时候建议大家都使用这个数据类
SQLAlchemy之常用数据类型
why404
01-21 1067
SQLAlchemy常用数据类型 Integer：整形，映射到数据库中是int类型。 Float：浮点类型，映射到数据库中是float类型。它占据的32位。 Double：双精度浮点类型，映射到数据库中是double类型，占据64位 (SQLALCHEMY中没有)。 String：可变字符类型，映射到数据库中是varchar类型. Boolean：布尔类型，映射到数据库中的是tinyint类型。...
Flask-SQLAlchemy查询方法汇总 - 表间查询 一对一、一对多、多对多
steventian72的博客
10-27 2158
1. 一对一 参考一对多的例子，下添加uselist=False就变成了一对一。 # 添加一对一的反向引用，在一对多的情况下添加uselist=False就变成了一对一 rank_related_score = db.relationship('tbl_2018_data', backref = 'score_related_rank', uselist=False) ...
sqlachemy连接mysql配置
06-09
在使用 SQLAlchemy 连接 MySQL 数据库时，您需要提供以下配置参数： 1. `user`：MySQL 数据库的用户名。 2. `password`：MySQL 数据库的密码。 3. `host`：MySQL 数据库的主机名或 IP 地址。 4. `port`：MySQL 数据库的端口号，默认为 3306。 5. `database`：MySQL 数据库的名称。 6. `charset`：MySQL 数据库的字符集，建议使用 `utf8mb4`。 您可以使用以下代码连接 MySQL 数据库： ```python from sqlalchemy import create_engine engine = create_engine('mysql+pymysql://user:password@host:port/database?charset=utf8mb4', encoding='utf-8', pool_size=10, pool_recycle=3600, echo=True) ``` 其中，`pymysql` 是 Python 中用于连接 MySQL 数据库的一个驱动程序。您需要在 Python 中安装 `pymysql` 模块，才能使用它连接 MySQL 数据库。 在上述代码中，`pool_size` 和 `pool_recycle` 分别指定了连接池的大小和回收时间。`echo=True` 表示开启 SQLAlchemy 的调试输出功能，方便调试和排错。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值