Flask framework query advanced & Flask-SQLAlchemy plugin

Flask

Relationship between tables

First create two tables, user1 and article4, and define the field uid of the table article4 as a foreign key to the id of the user1 field

from sqlalchemy import create_engine  # 用于创建引擎
from content import DB_URL  # 用于创建引擎
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from sqlalchemy.orm import sessionmaker, relationship  # 用于提交事务和关联表格
from sqlalchemy import Column, Integer, String, Float, ForeignKey  # 用于创建表格内数据及外键

engine = create_engine(DB_URL)  # 创建引擎
Base = declarative_base(engine)  # # 所有的类都要继承自 declarative_base 这个函数生成的基类


class User(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'user1'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string, 空
    name = Column(String(50), nullable=True)
    # 创建表格关联
    article = relationship('Article')

	def __repr__(self):
        return '<id:{},name:{}>'.format(self.id,self.name)

class Article(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'article4'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 title, 数据类型约束 string, 空
    title = Column(String(50), nullable=True)
    # 创建字段 content, 数据类型约束 string, 空
    content = Column(String(50), nullable=True)
    # 创建字段 uid, 数据类型约束 int, 并且指定为表格 user1 的字段 id 的外键
    uid = Column(Integer, ForeignKey('user1.id'))
    # 创建表格关联
    author = relationship('User')
    
    def __repr__(self):
        return '<Article:id:{},title:{},content:{},uid:{}>'.format(self.id,self.title,self.content,self.uid)


# 模型映射到数据库中
Base.metadata.create_all()
Insert picture description here


Insert picture description here


Then, insert the data, note that the main table data must be inserted first

from sqlalchemy import create_engine  # 用于创建引擎
from content import DB_URL  # 用于创建引擎
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from sqlalchemy.orm import sessionmaker, relationship  # 用于提交事务和关联表格
from sqlalchemy import Column, Integer, String, Float, ForeignKey  # 用于创建表格内数据及外键

engine = create_engine(DB_URL)  # 创建引擎
Base = declarative_base(engine)  # # 所有的类都要继承自 declarative_base 这个函数生成的基类


class User(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'user1'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string, 空
    name = Column(String(50), nullable=True)
    # 创建表格关联
    article = relationship('Article')
	
	def __repr__(self):
        return '<id:{},name:{}>'.format(self.id,self.name)

class Article(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'article4'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 title, 数据类型约束 string, 空
    title = Column(String(50), nullable=True)
    # 创建字段 content, 数据类型约束 string, 空
    content = Column(String(50), nullable=True)
    # 创建字段 uid, 数据类型约束 int, 并且指定为表格 user1 的字段 id 的外键
    uid = Column(Integer, ForeignKey('user1.id'))
	# 创建表格关联
    author = relationship('User')
    
    def __repr__(self):
        return '<Article:id:{},title:{},content:{},uid:{}>'.format(self.id,self.title,self.content,self.uid)


# 绑定事务
Session = sessionmaker(bind=engine)
session = Session()

# 提交主表事务
user = User(name='xiao su')
session.add(user)
session.commit()

# 提交外键表事务
article1 = Article(title='Python', content='521', uid=1)
article2 = Article(title='Java', content='520', uid=1)
session.add(article1)
session.add(article2)
session.commit()
Insert picture description here


Insert picture description here

Finally, according to the table relationship query, a multi-sentence query is used here and two tables are associated

from sqlalchemy import create_engine  # 用于创建引擎
from content import DB_URL  # 用于创建引擎
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from sqlalchemy.orm import sessionmaker, relationship  # 用于提交事务和关联表格
from sqlalchemy import Column, Integer, String, Float, ForeignKey  # 用于创建表格内数据及外键

engine = create_engine(DB_URL)  # 创建引擎
Base = declarative_base(engine)  # # 所有的类都要继承自 declarative_base 这个函数生成的基类


class User(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'user1'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string, 空
    name = Column(String(50), nullable=True)
    # 创建表格关联
    article = relationship('Article')

	def __repr__(self):
        return '<id:{},name:{}>'.format(self.id,self.name)

class Article(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'article4'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 title, 数据类型约束 string, 空
    title = Column(String(50), nullable=True)
    # 创建字段 content, 数据类型约束 string, 空
    content = Column(String(50), nullable=True)
    # 创建字段 uid, 数据类型约束 int, 并且指定为表格 user1 的字段 id 的外键
    uid = Column(Integer, ForeignKey('user1.id'))	
	# 创建表格关联
    author = relationship('User')
    
    def __repr__(self):
        return '<Article:id:{},title:{},content:{},uid:{}>'.format(self.id,self.title,self.content,self.uid)


# 绑定事务
Session = sessionmaker(bind=engine)
session = Session()

data = session.query(User).first()  # 先获取 user1 表的第一条数据的 id(1)
print(data.id)  # 输出为 1
articles = session.query(Article).filter(Article.uid == data.id).all()  # 根据 id 号对应的外键 uid 号查询对应的 article 书籍
for i in articles:
    print(i)  # 魔法方法查询
    # output:<Article:id:1,title:Python,content:521,uid:1>
    # output:<Article:id:2,title:Java,content:520,uid:1>

The relationship statement relationship is used here to query two tables

from sqlalchemy import create_engine  # 用于创建引擎
from content import DB_URL  # 用于创建引擎
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from sqlalchemy.orm import sessionmaker, relationship  # 用于提交事务和关联表格
from sqlalchemy import Column, Integer, String, Float, ForeignKey  # 用于创建表格内数据及外键

engine = create_engine(DB_URL)  # 创建引擎
Base = declarative_base(engine)  # # 所有的类都要继承自 declarative_base 这个函数生成的基类


class User(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'user1'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string, 空
    name = Column(String(50), nullable=True)
    # 创建表格关联
    article = relationship('Article')

    def __repr__(self):
        return '<id:{},name:{}>'.format(self.id,self.name)


class Article(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'article4'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 title, 数据类型约束 string, 空
    title = Column(String(50), nullable=True)
    # 创建字段 content, 数据类型约束 string, 空
    content = Column(String(50), nullable=True)
    # 创建字段 uid, 数据类型约束 int, 并且指定为表格 user1 的字段 id 的外键
    uid = Column(Integer, ForeignKey('user1.id'))
    # 创建表格关联
    author = relationship('User')

    def __repr__(self):
        return '<Article:id:{},title:{},content:{},uid:{}>'.format(self.id,self.title,self.content,self.uid)


# 绑定事务
Session = sessionmaker(bind=engine)
session = Session()

# data = session.query(User).first()  # 先获取 user1 表的第一条数据的 id(1)
# print(data.id)  # 输出为 1
# articles = session.query(Article).filter(Article.uid == data.id).all()  # 根据 id 号对应的外键 uid 号查询对应的 article 书籍
# for i in articles:
#     print(i)  # 魔法方法查询
#     # output:<Article:id:1,title:Python,content:521,uid:1>
#     # output:<Article:id:2,title:Java,content:520,uid:1>

# 通过文章来查询所有作者
user = session.query(Article).first()
print(user.author)  # 魔法方法查询
# output:<id:1,name:xiao su>

# 根据作者来查询所有文章
data = session.query(User).first()
for i in data.article:
    print(i)  # 魔法方法查询
    # output:<Article:id:1,title:Python,content:521,uid:1>
    # output:<Article:id:2,title:Java,content:520,uid:1>

Query advanced & sort

order_by : You can specify to sort according to a field in this table, if you add a (-) in front, it means descending order

Specify the default sort when the model is defined : Sometimes, you don’t want to specify the sorting method every time you query, you can specify the sorting method when you define the model

Library table file

Insert picture description here


First modify the query database name (change mysql_2 to mysql_1)

url configuration item file

HOSTNAME = '127.0.0.1'  # 主机地址
DATABASE = 'mysql_1'  # 数据库名字
PORT = 3306  # 数据库端口
USERNAME = 'root'  # 用户名
PASSWORD = 'root'  # 密码

# 创建 url 固定模板
DB_URL = 'mysql+pymysql://{}:{}@{}:{}/{}'.format(USERNAME, PASSWORD, HOSTNAME, PORT, DATABASE)

Create tables and add data at the same time

Python main file

from sqlalchemy import create_engine  # 用于创建引擎
from content import DB_URL  # 用于创建引擎
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from sqlalchemy.orm import sessionmaker, relationship  # 用于提交事务和关联表格
from sqlalchemy import Column, Integer, String, Float, ForeignKey  # 用于创建表格内数据及外键

engine = create_engine(DB_URL)  # 创建引擎
Base = declarative_base(engine)  # # 所有的类都要继承自 declarative_base 这个函数生成的基类


class Article(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'article'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 title, 数据类型约束 string
    title = Column(String(50))
    # 创建字段 price, 数据类型约束 float, 空
    price = Column(Float, nullable=True)

    def __repr__(self):
        return '<Article:title:{},price:{}>'.format(self.title,self.price)


# 模型映射到数据库中
Base.metadata.create_all()

# 绑定事务
Session = sessionmaker(bind=engine)
session = Session()

# 增添数据
for i in range(10):
    import random
    article = Article(title='title%s' % i, price=random.randint(50, 100))
    # 上传数据到事务
    session.add(article)

# 提交事务
session.commit()

Python main file

from sqlalchemy import create_engine  # 用于创建引擎
from content import DB_URL  # 用于创建引擎
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from sqlalchemy.orm import sessionmaker, relationship  # 用于提交事务和关联表格
from sqlalchemy import Column, Integer, String, Float, ForeignKey  # 用于创建表格内数据及外键

engine = create_engine(DB_URL)  # 创建引擎
Base = declarative_base(engine)  # # 所有的类都要继承自 declarative_base 这个函数生成的基类


class Article(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'article'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 title, 数据类型约束 string
    title = Column(String(50))
    # 创建字段 price, 数据类型约束 float, 空
    price = Column(Float, nullable=True)

    def __repr__(self):
        return '<Article:title:{},price:{}>'.format(self.title,self.price)


# 绑定事务
Session = sessionmaker(bind=engine)
session = Session()

# 排序查询
article1 = session.query(Article).order_by(Article.price).all()  # price 升序查询
# article2 = session.query(Article).order_by(Article.price.desc()).all()  # price 降序查询
article2 = session.query(Article).order_by(-Article.price).all()  # price 降序查询

for article in article1:
    print(article)  # 魔法查询

for article in article2:
    print(article)  # 魔法查询

Simplify the main Python file: __mapper_args _ parameters

Here you have to delete the previously created table and create it again to take effect


Query Advanced & Restrictions

from sqlalchemy import create_engine  # 用于创建引擎
from content import DB_URL  # 用于创建引擎
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from sqlalchemy.orm import sessionmaker, relationship  # 用于提交事务和关联表格
from sqlalchemy import Column, Integer, String, Float, ForeignKey  # 用于创建表格内数据及外键

engine = create_engine(DB_URL)  # 创建引擎
Base = declarative_base(engine)  # # 所有的类都要继承自 declarative_base 这个函数生成的基类


class Article(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'article'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 title, 数据类型约束 string
    title = Column(String(50))
    # 创建字段 price, 数据类型约束 float, 空
    price = Column(Float, nullable=True)

    def __repr__(self):
        return '<Article:title:{},price:{}>'.format(self.title, self.price)


# 绑定事务
Session = sessionmaker(bind=engine)
session = Session()

# 查询前三条的数据
# limit() 限制查询结果的条数
articles1 = session.query(Article).limit(3).all()
for article in articles1:
    print(article)  # 魔法方法查询

# 查询中间三条的数据
# offset() 忽视查询的条数
articles2 = session.query(Article).order_by(Article.id).offset(3).limit(3).all()
for article in articles2:
    print(article)  # 魔法方法查询

Query Advanced & Slice

from sqlalchemy import create_engine  # 用于创建引擎
from content import DB_URL  # 用于创建引擎
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from sqlalchemy.orm import sessionmaker, relationship  # 用于提交事务和关联表格
from sqlalchemy import Column, Integer, String, Float, ForeignKey  # 用于创建表格内数据及外键

engine = create_engine(DB_URL)  # 创建引擎
Base = declarative_base(engine)  # # 所有的类都要继承自 declarative_base 这个函数生成的基类


class Article(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'article'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 title, 数据类型约束 string
    title = Column(String(50))
    # 创建字段 price, 数据类型约束 float, 空
    price = Column(Float, nullable=True)

    def __repr__(self):
        return '<Article:title:{},price:{}>'.format(self.title, self.price)


# 绑定事务
Session = sessionmaker(bind=engine)
session = Session()

# 切片 
# 按照 price 的升序查询前 5 条数据, 左闭右开
articles3 = session.query(Article).order_by(Article.price).all()[0:5]
for article in articles3:
    print(article)  # 魔法方法查询

Query Advanced & Group

First create the table and add data

from sqlalchemy import create_engine  # 用于创建引擎
from content import DB_URL  # 用于创建引擎
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from sqlalchemy.orm import sessionmaker  # 用于提交事务
from sqlalchemy import Column, Integer, String, Enum  # 用于创建表格内数据及外键
from sqlalchemy import func  # 用于聚合函数

engine = create_engine(DB_URL)  # 创建引擎
Base = declarative_base(engine)  # # 所有的类都要继承自 declarative_base 这个函数生成的基类


class User(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'user1'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string
    name = Column(String(50))
    # 创建字段 gender, 数据类型约束 Enum(枚举)
    gender = Column(Enum('男', '女'))
    # 创建字段 age, 数据类型约束 int
    age = Column(Integer)
    

# 模型映射到数据库中
Base.metadata.create_all()

# 绑定事务
Session = sessionmaker(bind=engine)
session = Session()

# 增添数据
for i in range(10):
    import random
    list1 = ['男', '女']
    user = User(name='user%s' % i, gender=list1[random.randint(0, 1)], age=random.randint(12, 30))
    # 将数据提交到事务中
    session.add(user)

# 提交事务
session.commit()
Insert picture description here


Then, group by data

from sqlalchemy import create_engine  # 用于创建引擎
from content import DB_URL  # 用于创建引擎
from sqlalchemy.ext.declarative import declarative_base  # 用于生成基类
from sqlalchemy.orm import sessionmaker  # 用于提交事务
from sqlalchemy import Column, Integer, String, Enum  # 用于创建表格内数据及外键
from sqlalchemy import func  # 用于聚合函数

engine = create_engine(DB_URL)  # 创建引擎
Base = declarative_base(engine)  # # 所有的类都要继承自 declarative_base 这个函数生成的基类


class User(Base):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'user1'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = Column(Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string
    name = Column(String(50))
    # 创建字段 gender, 数据类型约束 Enum(枚举)
    gender = Column(Enum('男', '女'))
    # 创建字段 age, 数据类型约束 int
    age = Column(Integer)
    

# 绑定事务
Session = sessionmaker(bind=engine)
session = Session()

# group_by 分组, 根据 gender 字段分组
res1 = session.query(User.gender, func.count(User.id)).group_by(User.gender).all()
print(res1)
# output:[('男', 7), ('女', 3)]

# having 进一步进行过滤, 查询年龄在 18 岁以下的各年龄段的人数
res2 = session.query(User.age, func.count(User.id)).group_by(User.age).having(User.age < 18).all()
print(res2)
# output:[(19, 2), (21, 1), (23, 2), (25, 2), (28, 1), (29, 1)]

Flask-SQLAlchemy plugin

First need to install this module pip install flask-sqlalchemy

Create two tables, user2 and article2

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from content import DB_URL  # 用于创建引擎

web = Flask(__name__)  # 创建 Flask 实例

# 连接数据库
web.config['SQLALCHEMY_DATABASE_URI'] = DB_URL
web.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(web)


@web.route('/')
def index():
    return '首页'


class User(db.Model):
    __tablename__ = 'user2'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string
    name = db.Column(db.String(50))

    def __repr__(self):
        return '<User:name:{}>'.format(self.name)


class Article(db.Model):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'article2'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    # 创建字段 title, 数据类型约束 String
    title = db.Column(db.String(50))
    # 创建字段 uid, 数据类型约束 int, 设置为 user2 表字段 id 的外键
    uid = db.Column(db.Integer, db.ForeignKey('user2.id'))
    # 创建表关联
    author = db.relationship('User', backref='articles')


# 映射数据库
db.create_all()

Add data

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from content import DB_URL  # 用于创建引擎

web = Flask(__name__)  # 创建 Flask 实例

# 映射数据库
web.config['SQLALCHEMY_DATABASE_URI'] = DB_URL
web.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(web)


@web.route('/')
def index():
    return '首页'


class User(db.Model):
    __tablename__ = 'user2'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string
    name = db.Column(db.String(50))

    # def __str__(self):
    #     return 'User(name:{})'.format(self.name)

    def __repr__(self):
        return '<User:name:{}>'.format(self.name)


class Article(db.Model):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'article2'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    # 创建字段 title, 数据类型约束 String
    title = db.Column(db.String(50))
    # 创建字段 uid, 数据类型约束 int, 设置为 user2 表字段 id 的外键
    uid = db.Column(db.Integer, db.ForeignKey('user2.id'))
    # 创建表关联
    author = db.relationship('User', backref='articles')

# 添加数据
user = User(name='xiao su')  # 给表 user2 创建 name 为 xiao su 的一项
article = Article(title='python')  # 给表 article2 创建 title 为 python 的一项
article.author = user  # 创建表关联
db.session.add(article)  # 提交数据到事务
db.session.commit()  # 提交事务

Query data

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from content import DB_URL  # 用于创建引擎

web = Flask(__name__)  # 创建 Flask 实例

# 映射数据库
web.config['SQLALCHEMY_DATABASE_URI'] = DB_URL
web.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(web)


@web.route('/')
def index():
    return '首页'


class User(db.Model):
    __tablename__ = 'user2'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string
    name = db.Column(db.String(50))

    # def __str__(self):
    #     return 'User(name:{})'.format(self.name)

    def __repr__(self):
        return '<User:name:{}>'.format(self.name)


class Article(db.Model):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'article2'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    # 创建字段 title, 数据类型约束 String
    title = db.Column(db.String(50))
    # 创建字段 uid, 数据类型约束 int, 设置为 user2 表字段 id 的外键
    uid = db.Column(db.Integer, db.ForeignKey('user2.id'))
    # 创建表关联
    author = db.relationship('User', backref='articles')

    def __repr__(self):
        return '<Article:id:{},title:{},uid:{}>'.format(self.id,self.title,self.uid)


# 映射数据库
# db.create_all()

# 添加数据
# user = User(name='xiao su')  # 给表 user2 创建 name 为 xiao su 的一项
# article = Article(title='python')  # 给表 article2 创建 title 为 python 的一项
# article.author = user  # 创建表关联
# db.session.add(article)  # 提交数据到事务
# db.session.commit()  # 提交事务

# 查询数据方法 1
user = User.query.all()
for i in user:
    print(i)  # 魔法方法查询
    # output:<User:name:cheney>

# 查询数据方法 2
article = db.session.query(Article).all()
for i in article:
    print(i)  # 魔法方法查询
    # output:<Article:id:1,title:python,uid:1>

Python main file: the purpose is to use the database in the browser

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from content import DB_URL  # 用于创建引擎

web = Flask(__name__)  # 创建 Flask 实例

# 映射数据库
web.config['SQLALCHEMY_DATABASE_URI'] = DB_URL
web.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(web)


@web.route('/')
def index():
    return '首页'


class User(db.Model):
    __tablename__ = 'user2'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    # 创建字段 name, 数据类型约束 string
    name = db.Column(db.String(50))

    # def __str__(self):
    #     return 'User(name:{})'.format(self.name)

    def __repr__(self):
        return '<User:name:{}>'.format(self.name)


class Article(db.Model):
    # 给表格取名字, 若缺失此参数, 那么表格的名字将以类的名字代替
    __tablename__ = 'article2'
    # 创建字段 id, 数据类型约束 int, 主键, 自增长
    id = db.Column(db.Integer, primary_key=True, autoincrement=True)
    # 创建字段 title, 数据类型约束 String
    title = db.Column(db.String(50))
    # 创建字段 uid, 数据类型约束 int, 设置为 user2 表字段 id 的外键
    uid = db.Column(db.Integer, db.ForeignKey('user2.id'))
    # 创建表关联
    author = db.relationship('User', backref='articles')

    def __repr__(self):
        return '<Article:id:{},title:{},uid:{}>'.format(self.id,self.title,self.uid)


# 映射数据库
# db.create_all()

# 添加数据
# user = User(name='xiao su')  # 给表 user2 创建 name 为 xiao su 的一项
# article = Article(title='python')  # 给表 article2 创建 title 为 python 的一项
# article.author = user  # 创建表关联
# db.session.add(article)  # 提交数据到事务
# db.session.commit()  # 提交事务

# 查询数据方法 1
user = User.query.all()
for i in user:
    print(i)  # 魔法方法查询
    # output:<User:name:cheney>

# 查询数据方法 2
article = db.session.query(Article).all()
for i in article:
    print(i)  # 魔法方法查询
    # output:<Article:id:1,title:python,uid:1>


if __name__ == '__main__':
    web.run(debug=True)