Flask--SQLAlchemy_flask-sqlalchemy 语句 返回指定列

通过使用with_entities()方法来获取要在结果中返回的列

# 查询制定的id列
result = RiskDataModel.query.with_entities(RiskDataModel.id)  # 返回BaseQuery

# 返回指定的两列
result = RiskDataModel.query.with_entities(RiskDataModel.id, RiskDataModel.name)  

# 并且去重
result  = RiskDataModel.query.with_entities(RiskDataModel.store_st_id).distinct().all()
1
2
3
4
5
6
7
8

from flask import Flask,render_template
from flask_sqlalchemy import SQLAlchemy
import pymysql
import json
import jieba
import re
from collections import Counter

# 将pymysql视为mysqldb,即pymysql伪装成mysqldb
pymysql.install_as_MySQLdb() 

# 将当前运行的主程序构建成Flaks的应用，以便接受用户请求，并给出响应
app=Flask(__name__)

app.config['SQLALCHEMY_DATABASE_URI']='mysql://root:123456@localhost:3306/db1'
# sqlalchemy_database_uri

# 设置每次请求结束后会自动提交数据库中的改动，但官方不建议使用
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True
# sqlalchemy_commit_on_teardown

# 追踪数据库改变后模型类也会改变，与上面那个同步使用
app.config['SQLALCHENY_TRACK_MODIFICATIONS'] = True
# sqlalchemy_track_modifications

# 创建SQLALchemy的实例
db=SQLAlchemy(app)


class Bei_sai_3(db.Model):
    __tablename__="Bei_sai_3"
    id = db.Column(db.Integer,primary_key=True)  # Integer 普通整数，32位
    gongzuo_name = db.Column(db.String(255))
    city_qu = db.Column(db.String(255))
    gongsi_name= db.Column(db.String(255))
    gong_zi=db.Column(db.String(255))
    gong_zi_max=db.Column(db.Float)
    gong_zi_min=db.Column(db.Float)
    gongzuo_yaoqiu=db.Column(db.String(2555))
    xue_li=db.Column(db.String(255))
    gongzuo_jing_yan=db.Column(db.String(255))
    gongsi_xingzhi=db.Column(db.String(255))
    gui_mo=db.Column(db.String(255))
    gui_mo_num=db.Column(db.Integer)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

from flask import Flask, request, render_template
from flask_sqlalchemy import SQLAlchemy

import pymysql
pymysql.install_as_MySQLdb()

app = Flask(__name__)
#指定连接字符串
app.config['SQLALCHEMY_DATABASE_URI']='mysql://root:123456@localhost:3306/flask'
#指定让SQLAlchemy自动追踪程序的修改
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
#指定执行完操作之后自动提交
app.config['SQLALCHEMY_COMMIT_ON_TEARDOWN'] = True

#为当前的项目创建一个SQLAlchemy的实例
db = SQLAlchemy(app)


# 创建模型类 - Models
# 创建 Users 类,映射到表中叫 users 表
# 创建字段 : id , 主键,自增
# 创建字段 : username , 长度为80的字符串,不允许为空,必须唯一
# 创建字段 : age , 整数,允许为空
# 创建字段 : email,长度为120的字符串,必须唯一
class Users(db.Model):
    __tablename__ = 'users'
    id = db.Column(db.Integer,primary_key=True)
    username = db.Column(db.String(80),nullable=False,unique=True)
    age = db.Column(db.Integer)
    email = db.Column(db.String(120),unique=True)

    def __init__(self,username,age,email):
        self.username = username
        self.age = age
        self.email = email

    def __repr__(self):
        return '<Users:%r>' % self.username


class Student(db.Model):
    __tablename__ = "student"
    id = db.Column(db.Integer,primary_key=True)
    sname = db.Column(db.String(30),nullable=False)
    sage = db.Column(db.Integer)

    def __init__(self,sname,sage):
        self.sname = sname
        self.sage = sage

    def __repr__(self):
        return '<Student %r>' % self.sname

class Teacher(db.Model):
    __tablename__ = "teacher"
    id = db.Column(db.Integer,primary_key=True)
    tname = db.Column(db.String(30),nullable=False)
    tage = db.Column(db.Integer)

    def __init__(self,tname,tage):
        self.tname = tname
        self.tage = tage

    def __repr__(self):
        return "<Teacher %r>" % self.tname

class Course(db.Model):
    __tablename__ = "course"
    id = db.Column(db.Integer,primary_key=True)
    cname = db.Column(db.String(30))

    def __init__(self,cname):
        self.cname = cname

    def __repr__(self):
        return "<Course %r>" % self.cname



# 将创建好的实体类映射回数据库
# db.drop_all()
db.create_all()


@app.route('/insert')
def insert_views():
    # 创建 Users 对象
    users = Users('王伟超',38,'wangwc@163.com')
    # 将对象通过db.session.add()插入到数据库
    db.session.add(users)
    # 提交插入操作
    db.session.commit()
    return "Insert Success"

@app.route('/register',methods=['GET','POST'])
def register():
    if request.method == 'GET':
        return render_template('02-register.html')
    else:
        # 接收前端传递过来的数据
        username = request.form.get('username')
        age = int(request.form.get('age'))
        email = request.form.get('email')
        # 将数据构建成 Users 对象
        users = Users(username,age,email)
        # 通过 db.session.add 将对象保存进数据库
        db.session.add(users)
        # 提交
        # db.session.commit()
        return "Register OK"


if __name__ == "__main__":
    app.run(debug=True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

app=Flask（name,static_folder=“static”,static_url_path="/aaa",template_folder=“templates”）

__name__实际上是有值的，name=main，指的是该模块所在的目录

static_folder = “static”，设置静态资源夹的名字是static

static_url_path，设置访问静态资源的url前缀，若不存在该项，默认为static

template_folder，存放html模板的模板夹名字

app.run(host=127.0.0.1,port=5008,debug=True)

host=127.0.0.1 设置访问flask_web应用的ip是127.0.0.1

port=5008设置访问flask_web应用的端口是5008

debug=True设置调试模式打开

补充：print(app.url_map) 打印路由和视图函数的对应关系

查询
1.FLASK-SQLALCHEMY - 查询
1.基于 db.session 进行查询
1.db.session.query()
该函数会返回一个Query对象，类型为 BaseQuery，包含了指定实体类对应的表中所有的数据

		该函数也可以接受多个参数，参数表示的是要查询哪个实体


	2.查询执行函数
		目的：在查询的基础上得到最终想要的结果
		语法：db.session.query(...).查询执行函数()
1
2
3
4
5
6

也可以直接使用定义的类来查询：
例：Users.query.all()
Users.query.first()
。。。。。

		函数         说明
all()        以列表的方式返回查询的所有结果
first()      返回查询中的第一个结果，如果没有结果，则返回None
first_or_404()  返回查询中的第一个结果，如果没有结果，则终止并返回404
count()      返回查询结果的数量
1
2
3
4
5

get() 根据主键获取到对象，

	3.查询过滤器函数
		作用：在查询的基础上，筛选部分列出来
		语法：db.session.query(..).过滤器函数().查询执行函数()
		过滤器函数：
		函数                说明
filter()            按指定条件进行过滤(多表，单表，定值，不定值..)
filter_by()         按等值条件进行过滤
limit()             按限制行数获取
order_by()          根据指定条件进行排序
group_by()          根据指定条件进行分组
1
2
3
4
5
6
7
8
9
10

offset() 跳过几条开始查，例：db.session.query.offset(2).all() #跳过前两条，开始查

db.session.query.offset(1).limit(2).all()  # 跳过一条，取出两条数据

User.query.order_by(User.id.desc()).all()  # 按照id进行降序的方式，查出，默认升序，函数asc()

1
2
3
4

详解：
1.filter()
1. 查询年龄 大于 30 的Users 的信息
db.session.query(Users).filter(Users.age>30).all()
注意：条件必须由 模型类.属性 来组成
2.查询年龄 大于 30 且 id 大于5 的Users的信息
db.session.query(Users).filter(Users.age>30,Users.id > 5).all()
3.查询年龄大于30 或者 id大于5 的Users的信息
注意：查询 或 的操作，要借助 or_(),
or_() 函数需要导入 from sqlalchemy import or_
db.session.query(Users).filter(or_(条件1,条件2)).all()

			4.查询id等于5的Users的信息
				注意：等值判断必须使用 ==
				db.session.query(Users).filter(Users.id==5).first()

			5.查询 email 中包含 'w' 的users的信息 - 模糊查询 like
				db.session.query(Users).filter(Users.email.like('%w%')).all()

			6.查询 id 在 [1,2,3] 之间的 Users 的信息
				db.session.query(Users).filter(Users.id.in_([1,2,3])).all()

		2.filter_by()
			1.查询 id=5的Users的信息
				db.session.query(Users).filter_by(id=5).first()
1
2
3
4
5
6
7
8
9
10
11
12
13

2. 写入多个条件：
   db.session.query(Users).filter_by(id=5，name=“wht”).first()

    	3.limit()
    		1.在整个查询结果中获取前5条数据	
    			db.session.query(Users).limit(5).all()
   1
   2
   3

db.session.query(Users).limit(5).all()
db.session.query(Users).limit(3).offset(1).all()
offset() 表示行数偏移量，这里就是从多少开始查询

		4.order_by()
			1.对Users表中所有的数据按id倒序排序
				db.session.query(Users).order_by('id desc').all()
1
2
3

desc 表示倒序，默认为升序
若指定的字段中有重复的，还可以指定二级排序
db.session.query(Users).order_by(‘id desc,age asc’).all()
按照id倒序排列，年龄升序排列

db.session.query(Users).order_by(Users.id.desc()).all()
注意：新版本

		5.group_by()
1

按照年龄进行分组
db.session.query(Users.age).group_by(‘age’).all()

from sqlalchemy import func
db.session.query(Users.age,func.count(Users.age)).group_by(Users.age).all()

按照年龄进行分组，得出每个年龄的人数

func中有很多数学上的函数

2.基于 Models 进行查询
	Models.query.查询过滤器(条件参数).查询执行函数()
1
2

基于Models实现的查询：查询id>3的所有用户的信息

user = Users.query.filter(Users.id>3).all()
print(users)

删除

2.FLASK-SQLALCHEMY - 删除 和 修改
1.删除
步骤1.查询出要删除的实体
user=db.session.query(Users).filter_by(id=5).first()
步骤2.根据所提供的删除方法将信息删除
db.session.delete(user)
@app.route(’/delete_user’)
def delete_user():
user = Users.query.filter_by(id=5).first()
db.session.delete(user)
db.session.commit()
return ‘Delete OK’

2.修改
	将 id 为1 的用户的 username 改为 Wang WC ，年龄改为 40
	步骤1.查
	user = Users.query.filter_by(id=1).first()
	步骤2.改
	user.username = "Wang WC"
	user.age = 40
	步骤3.保存
	db.session.add(user)  
1
2
3
4
5
6
7
8
9

这一步因为有id值，所以保证了是更新回去，而不是增加一条

修改

@app.route(’/update_user’)
def update_user():
user = Users.query.filter_by(id=1).first()
user.username = “Wang WC”
user.age = 40
db.session.add(user)
return “Update OK”

先指定条件，然后以键值对的方式，指定要修改哪些信息，然后提交

User.query.filter_by(name=“zhou”).update({“name”:“python”,“email”:“python@163.com”})
db.session.commit()