8-flask django执行原生sql和sqlalchemy执行原生sql、flask-sqlalchemy使用(filter_by和filter)、flask-migrate使用

林光虚霁晓

已于 2023-11-22 17:44:29 修改

阅读量350

点赞数

分类专栏： flask 文章标签： flask sqlalchemy django sql filter filter_by

于 2023-11-22 15:01:17 首次发布

本文链接：https://blog.csdn.net/weixin_44145338/article/details/134553448

版权

flask 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1 原生sql(django-orm如何执行原生sql)
1.1 django执行原生sql
1.2 sqlalchemy执行原生sql

2 flask-sqlalchemy使用
 2.1 flask-sqlalchemy项目演示(filter_by和filter)
2.2 flask-sqlalchemy集成到flask项目演示
 3 flask-migrate使用

1 原生sql(django-orm如何执行原生sql)

1.1 django执行原生sql

import os

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'djangoProject2.settings')
import django

django.setup()

from app01.models import Book, User

# 原生sql，方式一，跟对象做映射：
# book_list=Book.objects.raw('select id,name,price,publish from app01_book where id =2')
# print(book_list) # RawQuerySet
# for book in book_list:
#     print(book.name)

# 了解的,咱们不这么写
# obj_list = User.objects.raw('select id,name,price,publish from app01_book where id =2')
# print(obj_list)  # RawQuerySet
# for obj in obj_list:
#     print(obj.name)
#     print(obj.price)


## 方式二，纯原生
from django.db import connection
cursor=connection.cursor()
print(type(cursor))
cursor.execute('select distinct id, name from app01_book')

from django.db.backends.utils import CursorDebugWrapper # 这个类上没有fetchall, 要么反射进去的，要么执行 . 拦截 __getattr__
print(cursor.fetchall())
cursor.close()

1.2 sqlalchemy执行原生sql

### 第一种：
# 1  导入
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine
import pymysql

# 2 创建engine对象
engine = create_engine(
    "mysql+pymysql://root:lqz123?@127.0.0.1:3306/cnblogs",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
########  方式一，纯原生
# 3 通过engine获得conn,cursor
# conn = engine.raw_connection()  # 拿到连接对象
# cursor = conn.cursor()
# # 4 具体操作
# cursor.execute('select * from article limit 10')
# print(cursor.fetchall())
# cursor.close()
# conn.close()


### 方式二:通过session
from sqlalchemy.orm import sessionmaker,scoped_session
from sqlalchemy.sql import text
Session = sessionmaker(bind=engine)
session = scoped_session(Session) # 线程安全的session
# cursor=session.execute(text('select * from article'))  # 需要用text包一下
cursor=session.execute(text('select * from article where id = :value'),params={"value":218})  # 需要用text包一下 ,用 :变量名占位
print(cursor.fetchall())
cursor.close()
session.close()


## 方式三：执行原生sql方式三：
# res = session.query(User).from_statement(text("SELECT * FROM boy where name=:name")).params(name='lqz').all()

2 flask-sqlalchemy使用

# sqlalchemy学完了，集成到flask中

## 纯自己集成：详情见项目
	1 在models中建立表---》表手动迁移到数据库
    2 单例的 线程安全session，链接mysql，可以使用配置文件
    3 以后在视图函数中，直接使用session操作即可

## 借助于flask-sqlalchemy
	1 导入 from flask_sqlalchemy import SQLAlchemy
    2 实例化得到对象
    	db = SQLAlchemy()
    3  将db注册到app中
    	db.init_app(app)
    4 视图函数中使用session
    	全局的db.session  # 线程安全的
    5 models.py 中继承Model
    	db.Model
    6 写字段 
    	username = db.Column(db.String(80), unique=True, nullable=False)
    7 配置文件中加入
    SQLALCHEMY_DATABASE_URI = "mysql+pymysql://root@127.0.0.1:3306/ddd?charset=utf8"
    SQLALCHEMY_POOL_SIZE = 5
    SQLALCHEMY_POOL_TIMEOUT = 30
    SQLALCHEMY_POOL_RECYCLE = -1
    # 追踪对象的修改并且发送信号
    SQLALCHEMY_TRACK_MODIFICATIONS = False

2.1 flask-sqlalchemy项目演示(filter_by和filter)

新建一个项目 flask_sqlalchemy
core
    views
    	user.py
    __init__.py
    db_utils.py
    models.py
    settings.py
manage.py

1 __init__.py中：
    from flask import Flask

    app = Flask(__name__)
    app.config.from_pyfile('./settings.py')

    # 也可以自定制命令，引入 flask-session

    # 注册user
    from .views.user import user_bp
    app.register_blueprint(user_bp)

2 manage.py
    from core import app

    if __name__ == '__main__':
        app.run()

3 db_utils.py
    from sqlalchemy import create_engine
    from sqlalchemy.orm import sessionmaker, scoped_session

    from core import app

    engine = create_engine(f"mysql+pymysql://root:root@{app.config.get('HOST')}:{app.config.get('PORT')}/sqlalchemy01",
                           max_overflow=0, pool_size=5)
    Session = sessionmaker(bind=engine)
    session = scoped_session(Session)
    
4 settings.py
    DEBUG = True
    HOST = '127.0.0.1'
    PORT = 3306
    DB_NAME = 'sqlalchemy01'

5 user.py
    from flask import Blueprint, jsonify
    user_bp = Blueprint('user', __name__)

    from core.db_utils import session
    from core.models import Users

    @user_bp.route('/')
    def user_index():
        # 使用session
        # users = session.query(Users).filter_by(name='lqz').all()
        users = session.query(Users).filter(Users.id >= 1).all()
        print(users)  # 这是一个列表
        # 做序列化
        user_list = []
        for user in users:
            user_data = {
                'id': user.id,
                'name': user.name,
                'email': user.email
            }
            user_list.append(user_data)

        # 返回JSON响应
        return jsonify({'code': 100, 'msg': '查询成功', 'result': user_list})

6 models.py	
    # 1 导入一些模块
    import datetime
    from sqlalchemy import create_engine

    # 新的变成sqlalchemy.orm，老的会有  from sqlalchemy.ext.declarative import declarative_base  Warning
    from sqlalchemy.orm import declarative_base, relationship


    from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index

    # django orm，所有类，都要继承一个父类，sqlalchemy中这个父类就是Base，有点特殊，正常导入一个类，继承即可，但是它不是

    # 2 得到所有表模型需要继承 基类
    Base = declarative_base()


    # 3 写表模型
    class Users(Base):
        # 定义表名 数据库表名称，如果不写，默认以类名小写作为表名
        __tablename__ = 'users'
        # 定义字段
        id = Column(Integer, primary_key=True)
        name = Column(String(32), index=True, nullable=False)  # name列，索引，不可为空
        email = Column(String(32), unique=True)
        # datetime.datetime.now不能加括号，加了括号，以后永远是当前时间
        ctime = Column(DateTime, default=datetime.datetime.now)
        extra = Column(Text, nullable=True)  # 可以为空

        def __str__(self):
            return self.name

        def __repr__(self):
            return self.name


    if __name__ == '__main__':
        # 4 创建 engine,需要手动创建数据库
        engine = create_engine(
            "mysql+pymysql://root:lqz123?@127.0.0.1:3306/sqlalchemy01?charset=utf8",
            max_overflow=0,  # 超过连接池大小外最多创建的连接
            pool_size=5,  # 连接池大小
            pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
            pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
        )
        # 5 通过 engine 把上面的表模型，创建到数据库中
        Base.metadata.create_all(engine)

        # 6 删除被Base管理的所有表
        # Base.metadata.drop_all(engine)

2.2 flask-sqlalchemy集成到flask项目演示

flask_flask_sqlalchemy
core
    views
   		user.py
    __init__.py
    models.py
    settings.py
manage.py

1 user.py
    import datetime
    from core import db


    # 3 写表模型
    class Users(db.Model):
        # 定义表名 数据库表名称，如果不写，默认以类名小写作为表名
        __tablename__ = 'users'
        # 定义字段
        id = db.Column(db.Integer, primary_key=True)
        name = db.Column(db.String(32), index=True, nullable=False)  # name列，索引，不可为空
        email = db.Column(db.String(32), unique=True)
        # datetime.datetime.now不能加括号，加了括号，以后永远是当前时间
        ctime = db.Column(db.DateTime, default=datetime.datetime.now)
        extra = db.Column(db.Text, nullable=True)  # 可以为空

        def __str__(self):
            return self.name

        def __repr__(self):
            return self.name
        
2 __init__.py
    from flask import Flask
    from flask_sqlalchemy import SQLAlchemy

    app = Flask(__name__)
    app.config.from_pyfile('./settings.py')

    db = SQLAlchemy()
    db.init_app(app)

    # 也可以自定制命令，引入 flask-session

    # 注册user
    from .views.user import user_bp

    app.register_blueprint(user_bp)


3 models.py
    import datetime
    from core import db

    # 写表模型
    class Users(db.Model):
        # 定义表名 数据库表名称，如果不写，默认以类名小写作为表名
        __tablename__ = 'users'
        # 定义字段
        id = db.Column(db.Integer, primary_key=True)
        name = db.Column(db.String(32), index=True, nullable=False)  # name列，索引，不可为空
        email = db.Column(db.String(32), unique=True)
        # datetime.datetime.now不能加括号，加了括号，以后永远是当前时间
        ctime = db.Column(db.DateTime, default=datetime.datetime.now)
        extra = db.Column(db.Text, nullable=True)  # 可以为空

        def __str__(self):
            return self.name

        def __repr__(self):
            return self.name

4 settings.py
    DEBUG = True

    SQLALCHEMY_DATABASE_URI = "mysql+pymysql://root:root@127.0.0.1:3306/sqlalchemy01?charset=utf8"
    SQLALCHEMY_POOL_SIZE = 5
    SQLALCHEMY_POOL_TIMEOUT = 30
    SQLALCHEMY_POOL_RECYCLE = -1
    # 追踪对象的修改并且发送信号
    SQLALCHEMY_TRACK_MODIFICATIONS = False


5 manage.py
	from core import app
    if __name__ == '__main__':
        app.run()

3 flask-migrate使用

# flask-sqlalchemy  不能对字段进行增改，也不能自动把表同步到数据库，表变更记录
	python manage.py maigrate

# pip3 install flask-migrate
	-老版本需要结合：flask-script
    -新版本不需要了：flask有自己定制命令
    
# https://github.com/miguelgrinberg/Flask-Migrate/
pip3 install Flask-Migrate --upgrade
4.0.5

####### 使用
from flask_migrate import Migrate

app = Flask(__name__)
app.config.from_pyfile('./settings.py')
db = SQLAlchemy(app)
# db.init_app(app)
migrate = Migrate(app, db) # flask 就会多出好几个命令---》

# flask --app manage:app db init  # 初始化，第一次执行，以后再也不执行了，它执行完，会出现一个migrations文件夹
# flask --app manage:app db migrate # django中的makemigrations 是一模一样
# flask --app manage:app db upgrade  # 跟django的migrate一样



# flask上其他第三方插件
	cors
    token
    cache
    restful

林光虚霁晓

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
8-flask django执行原生sql和sqlalchemy执行原生sql、flask-sqlalchemy使用(filter_by和filter)、flask-migrate使用

django执行原生sql和sqlalchemy执行原生sql、flask-sqlalchemy使用、flask-migrate使用
复制链接

扫一扫