title: Flask SQLAlchemy 資料庫
copyright: true
top: 0
date: 2018-07-24 13:27:03
tags: [Flask 資料庫,sqlalchemy,資料庫對映]
categories: Flask
permalink:
password:
keywords: [Flask 資料庫,sqlalchemy,資料庫對映]
description: Flask使用資料庫模型，處理對映關係，定義基礎的模型類。使用不同的連線資料庫的方式建立與連線資料庫。

看著一雙美麗的眼睛流動著對那個時代的嚮往，不由得讓人也期待啊。

建立資料庫方式

1. Database First # 使用navicat圖形化管理工具一步一步建立
2. Moedl First # 使用navicat的畫圖工具畫出結構，然後自動生成
3. Code First # 用Python寫好資料庫的模型，不用專門寫SQL語句,主要解決建立資料的問題，專注於業務模型的設計。

模型建立與對映

模型概念

關於MVC方式，個人這麼理解：

M --> model模組，主要的核心函式處理模組，負責處理大部分的業務的業務模型
V --> view模組，檢視模組，負責展現出好看的介面
c --> ctrol模組，操作控制模組，負責處理控制部分

ORM:物件關係對映，包括資料建立過程，資料查詢過程，刪除，更新的過程。ORM操作資料庫模型
來間接的操作資料庫。

後期的所有資料庫操作都是通過ORM來操作的。

建立妹子圖專案模型

首先在資料庫中建立好資料庫，資料庫名字為meizi，字符集為utf8mb4 – UTF-8 Unicode,排序規則為utf8mb4_general_ci

還是使用之前的妹子圖的小專案，先建立目錄data，然後新建creata_database.py，準備建立資料庫結構，需要的資料結構大致如下

class data():
    id = None
    # id號
    title = ''
    # 頁面標題
    url = ''
    # 該頁面的主網址
    show_img = ''
    # 頁面的單張展示圖片
    all_img = ''
    # 頁面的所有圖片


    def sample(self):
        pass
 

然後使用sqlalchemy把結構直接對映到資料庫，非常方便。這裡提起一下，sqlalchemy不是flask自帶的，但是falsk對sqlalchemy做了部分的優化，使用pipenv install flask-sqlalchemy即可安裝。

ok，下面的新建的資料庫模型

# -*- coding: utf-8 -*-
# @Time    : 2018/7/24 0024 13:40
# @Author  : Langzi
# @Blog    : www.langzi.fun
# @File    : creata_database.py
# @Software: PyCharm
import sys
from sqlalchemy import Column,Integer,String
# 匯入column（欄位），Integer（數字型別）
reload(sys)
sys.setdefaultencoding('utf-8')

class data():
    id = Column(Integer,primary_key=True,autoincrement=True)
    # 設定id號為資料庫的主鍵，並且自增長
    # 相當於SQL:id int primary key auto_increment
    title = Column(String(100),nullable=True,default='獲取該妹子資訊失敗')
    # 頁面標題長度為100，並且允許為空，如果為空的話就生成上面的default
    url = Column(String(100),nullable=False,unique=True)
    # 該頁面的主網址長度100，不允許為空,不允許重複
    show_img = Column(String(100),nullable=False)
    # 頁面的單張展示圖片
    all_img = Column(String(100),nullable=False)
    # 頁面的所有圖片


    def sample(self):
        pass

妹子圖專案對映到資料庫

然後例項化sql的物件，新增程式碼：

from flask_sqlalchemy import SQLAlchemy
# 例項化sqlalchemy物件，在flask中匯入進來
db = SQLAlchemy()
# db就是sqlalchemy的初始化的核心物件
class data(db.Model):
	id= xxx重複上面的程式碼

把之前的類繼承db即可。然後回到主目錄下的init.py檔案下，該檔案之前是把藍圖註冊到app裡面的，之前的init.py程式碼如下

# -*- coding: utf-8 -*-
# @Time    : 2018/7/19 0019 18:36
# @Author  : Langzi
# @Blog    : www.langzi.fun
# @File    : __init__.py.py
# @Software: PyCharm
import sys
from flask import Flask
from app.web.data.creata_database import db
reload(sys)
sys.setdefaultencoding('utf-8')

def create_app():
    app = Flask(__name__,template_folder=('web/templates'))
    app.config.from_object('config')
    start_Blueprint(app)
    return app

def start_Blueprint(app):
    from app.web.Mmzi import web
    app.register_blueprint(web)

匯入data目錄下create_database.py中的db物件，然後註冊到app當中並且初始化物件，並且呼叫他。

# -*- coding: utf-8 -*-
# @Time    : 2018/7/19 0019 18:36
# @Author  : Langzi
# @Blog    : www.langzi.fun
# @File    : __init__.py.py
# @Software: PyCharm
import sys
from flask import Flask
#from app.web.data.creata_database import db
reload(sys)
sys.setdefaultencoding('utf-8')

def create_app():
    app = Flask(__name__,template_folder=('web/templates'))
    app.config.from_object('config')
    start_Blueprint(app)
    db.init_app(app)
    with app.app_context():
       db.create_all()
    return app

def start_Blueprint(app):
    from app.web import web
    app.register_blueprint(web)

app就像一個插板一樣，藍圖可以註冊到app裡面，路由註冊到app裡面，甚至資料庫也可以註冊到app裡面，後期的登入等模組一樣註冊到裡面，當前已經差不多配置完成了，還有重要的一點沒說，那就是連結到哪個資料庫裡面。

在主目錄下的config.py中可以新增資料庫的配置資訊，之前config之定義了DEBUG的開關，這個時候可以加入資料庫配置。

SQLAlchemy本身無法操作資料庫，其必須以來pymsql，cymysql，mysqldb等第三方外掛，根據配置檔案的不同調用不同的資料庫API，從而實現對資料庫的操作，下面使用過cymysql進行操作

app主目錄下的config.py配置檔案

# -*- coding: utf-8 -*-
# @Time    : 2018/7/17 0017 20:42
# @Author  : Langzi
# @Blog    : www.langzi.fun
# @File    : config.py
# @Software: PyCharm
import sys

reload(sys)
sys.setdefaultencoding('utf-8')

DEBUG = True

SQLALCHEMY_DATABASE_URI = 'mysql+cymysql://root:[email protected]:3306/meizi'
# SQLALCHEMY_DATABASE_URI是flask定義好的配置項，就像DEBUG一樣
# mysql + cymysql ： 使用mysql資料庫，驅動使用cymysql（需要pipenv install cymysql）,你還可以使用pymysql
# 然後資料庫賬號密碼,主機和埠以及資料庫名字

最後允許主程式的時候，會發現資料庫中多了一個名為meizi的資料庫，其中多了一張名為data的表，資料庫的結構和定義的結構一致。

不同連線資料庫外掛使用方法

MySQL-Python
    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>

pymysql
    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]

MySQL-Connector
    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>

cx_Oracle
    oracle+cx_oracle://user:[email protected]:port/dbname[?key=value&key=value...]

方法一：使用Pymysql與SQLAlchemy操作資料庫

# coding=utf-8

from sqlalchemy import create_engine

engine = create_engine("mysql+pymysql://root:[email protected]:3306/school?charset=utf8", max_overflow=5)

# 執行SQL
cur = engine.execute(
    "insert into user (name, password) values('lihy', 'lihy')"
    )

# 新插入行自增ID
cur.lastrowid

# 執行SQL
cur = engine.execute(
    "insert into user(name, password) values(%s, %s)", [('liq', 'liq'), ('liuxj', 'liuxj235')]
    )

# 執行SQL
cur = engine.execute(
    "insert into user(name, password) values(%(name)s, %(password)s)", name='lium', password='lium123'
    )

# 執行SQL
cur = engine.execute('select * from user')

# 獲取第一行資料, 第n行，所有資料
cur.fetchone()
cur.fetchmany(3)
cur.fetchall()

方法二：使用SQLALchemy操作資料庫

初始化物件

# -*-coding:utf-8-*-
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
import datetime

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:[email protected]:3306/movie'
# 用於連線資料的資料庫
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
# 如果設定成 True (預設情況)，Flask-SQLAlchemy 將會追蹤物件的修改並且傳送訊號。

db = SQLAlchemy(app)
# 例項化db物件

建立資料庫模型

class User(db.Model):
    __tablename__ = 'user'
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(35), unique=True)
    pwd = db.Column(db.String(20))
    phone = db.Column(db.String(11), unique=True)

    def __repr__(self):
    # repr返回一個物件的 string 格式,repr的用法是：比如a='admin',repr(a)>>>“‘admin’”
    return '<User %r>'%self.name

資料庫外來鍵關聯

關係使用 relationship() 函式表示。然而外來鍵必須用類 sqlalchemy.schema.ForeignKey 來單獨宣告:

class Person(db.Model):
    __tablename__ = 'persion'
    id = db.Column(db.Integer,primary_key=True,autoincrement=True)
    name = db.Column(db.String(100),index=True)
    pwd = db.Column(db.String(100),index=True)
    info = db.relationship('Address',backref = 'ss')


class Address(db.Model):
    __tablename__ = 'address'
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(50))
    persion_id = db.Column(db.Integer, db.ForeignKey('persion.id'))

上面的例子中，address表中的person_id關聯物件為person表的id的值。隨後在person表中設定關聯屬性,關聯屬性名為info，第一個引數指向Address模型，另一個名叫backref的引數,叫做反向關係,我們將其設定成backref=ss。設定好了後它會向Persion模型中新增一個名為info的屬性，這個屬性可以代替persion_id去直接訪問Persion模型的物件。

>>>r=persion(id=1,name='admin')
>>>u=User(id=10,name='Hyman',persion_id=1)
>>>r.info.append(u)
>>>print u.role
	<Persion admin>

我們將u新增到r的info中,這樣我們同時也在u中添加了一個名叫做persion的屬性,而這屬性就是我們定義的r物件.這就是所謂的可以用info代替persion_id訪問Role模型,但是它獲取的是Persion模型物件而非器對應的id的值…

如果使用MYSQL語句建立資料庫然後使用外來鍵關聯的話，這麼寫：

使用者表
create table user(
id int primary key autoincrement,
username varchar(100) not null
)

文章表
create table article(
id int primary key autoincrement,
title varchar(100) not null,
content text,
authot_id int, //這個是關聯使用者表的id字典，要記住一個表的外來鍵一定是另一個表的主鍵
foreign ket 'author_id' references 'user.id'
)

就這個例子如果使用SQLALchemy的話，建立模型這麼寫

class User(db.Model):
    __tablename__ = 'user'
    id = db.Column(db.Integer,primary_key=True,autoincrement=True)
    username = db.Column(db.String(100),nullable=False)

class Article(db.Model):
    __tablename__ = 'article'
    id = db.Column(db.Integer,primary_key=True,autoincrement=True)
    title = db.Column(db.String(100),nullable=False)
    content = db.Column(db.Text)
    author_id = db.Column(db.Integer,db.ForeignKey('user.id'))# 引用user表的id欄位

執行建立資料庫

db.create_all()

增刪改查

向資料庫插入資料分為三個步驟:

• 建立 Python 物件
• 把它新增到會話
• 提交會話

增

from 你的資料庫模型檔案 import 你建立的資料庫中的表名
me =  你建立的資料庫中的表名('admin','18')
db.session.add(me)
db.session.commit()

刪

db.session.delete(me)
db.session.commit()

查

假設資料庫中有如下條目,並且下面條目的表名為User:

id    username    email
1    admin    [email protected]
2    peter    [email protected]
3    guest    [email protected]

獲取所有資料:

res = User.query(username).all()

獲取返回資料的第一行:

res = User.query(username).first()

過濾資料:

res = User.query(username).filter(id>1).all()

limit:

res = User.query(username).all()[1:3]

and or:

from sqlalchemy import and_
User.query.filter(and_(id==1, username=='admin')).all()
User.query.filter(id==1, username=='admin').all()
User.query.filter(id==1).filter(username=='admin').all()
from sqlalchemy import or_
User.query.filter(or_(id==1, id==2)).all()

多條件查詢:

res = User.query(username).filter(id>0).filter(id<7).all()

通過使用者名稱查詢使用者:

peter = User.query.filter_by(username='peter').first()
peter.id
>>> 1
peter.email
>>>  [email protected]

如果查詢一個不存在的使用者名稱返回 None

使用更復雜的表示式查詢一些使用者:

User.query.filter(User.email.endswith('@example.com')).all()
>>> [<User u'admin'>, <User u'guest'>]

返回物件是列表

按某種規則對使用者排序:

User.query.order_by(User.username)
>>> [<User u'admin'>, <User u'guest'>, <User u'peter'>]

限制返回使用者的數量:

User.query.limit(1).all()
>>> [<User u'admin'>]

filter_by和filter都是過濾條件，只是用法有區別filter_by裡面不能用!=還有> < 等等，所有filter用得更多,filter_by只能用=。

改

res = User.query.filter(User.username='admin').first()
res.username='root'
db.sission.commit()

例項演示一

#coding:utf-8
from flask_sqlalchemy import SQLAlchemy
from flask import Flask,render_template
app = Flask(__name__,template_folder='')
app.config['SQLALCHEMY_DATABASE_URI'] = 'mysql+pymysql://root:[email protected]:3306/test404?charset=utf8'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = True
db = SQLAlchemy(app)


class Article(db.Model):
    __tablename__ = 'article'
    id = db.Column(db.Integer,primary_key=True,autoincrement=True)
    title = db.Column(db.String(50),index=True)
    content = db.Column(db.Text)

db.create_all()

@app.route('/')
def index():
    # # 新增資料
    # # insert article(title,content) values('妹子大粑粑','AAbbCCaaaeeA啊啊')
    # ti = Article(title = '妹子大粑粑',content='AAbbCCaaaeeA啊啊')
    # db.session.add(ti)
    # db.session.commit()

    # # 查詢資料
    # # select * from article where title='妹子大粑粑'
    # result = Article.query.filter(Article.title=='妹子大粑粑').first().content
    # # 第一條的內容
    # res1 = Article.query.filter(Article.title=='妹子大粑粑').all()[0].content
    # # 第一條的內容
    # return render_template('index.html',x=res1)

    # # 修改資料
    # # 先查詢到要修改的資料，然後對需要修改的地方修改，然後提交
    # result = Article.query.filter(Article.title == '妹子大粑粑').first()
    # result.content = '啊啊啊啊啊啊啊啊啊去啊啊啊啊啊啊啊土撥鼠啊'
    # db.session.commit()

    # # 刪除資料
    # # 同上
    # result = Article.query.filter(Article.title == '妹子大粑粑').first()
    # db.session.delete(result)
    # db.session.commit()

app.run(debug=True)

例項演示二

建立一個數據庫物件

class Person(Base):
    __tablename__ = 'person'

    id   = Column(Integer, primary_key=True)
    name = Column(String(32))

    def __repr__(self):
        return "<Person(name='%s')>" % self.name

新增資料

建立一個person物件

person = Person(name='jack')

新增person物件，但是仍然沒有commit到資料庫

session.add(person)

commit操作

session.commit()

如何獲取id的？

>>> person = Person(name='ilis')
>>> person.id #此時還沒有commit到mysql,因此無id
>>> session.add(person)
>>> person.id #同上
>>> session.commit()
2015-08-18 23:08:23,530 INFO sqlalchemy.engine.base.Engine INSERT INTO person (name) VALUES (%s)
2015-08-18 23:08:23,531 INFO sqlalchemy.engine.base.Engine ('ilis',)
2015-08-18 23:08:23,532 INFO sqlalchemy.engine.base.Engine COMMIT
>>> person.id #commit後，可以獲取該物件的id
2015-08-18 23:08:27,556 INFO sqlalchemy.engine.base.Engine BEGIN (implicit)
2015-08-18 23:08:27,557 INFO sqlalchemy.engine.base.Engine SELECT person.id AS person_id, person.name AS person_name
FROM person
WHERE person.id = %s
2015-08-18 23:08:27,557 INFO sqlalchemy.engine.base.Engine (5L,)
5L
>>>

新增多個數據

session.add_all([
    Person(name='jack'),
    Person(name='mike')
])
session.commit()

回滾

>>> person = Person(name='test')
>>> session.add(person)
>>> session.query(person).filter(name=='test')
>>> session.query(Person).filter(Person.name=='test').all()
2015-08-18 23:13:23,265 INFO sqlalchemy.engine.base.Engine INSERT INTO person (name) VALUES (%s)
2015-08-18 23:13:23,265 INFO sqlalchemy.engine.base.Engine ('test',)
2015-08-18 23:13:23,267 INFO sqlalchemy.engine.base.Engine SELECT person.id AS person_id, person.name AS person_name
FROM person
WHERE person.name = %s
2015-08-18 23:13:23,267 INFO sqlalchemy.engine.base.Engine ('test',)
[<demo.Person object at 0x7f4e37730510>]
>>> session.rollback()
2015-08-18 23:13:37,496 INFO sqlalchemy.engine.base.Engine ROLLBACK
>>> session.query(Person).filter(Person.name=='test').all()
2015-08-18 23:13:38,690 INFO sqlalchemy.engine.base.Engine BEGIN (implicit)
2015-08-18 23:13:38,691 INFO sqlalchemy.engine.base.Engine SELECT person.id AS person_id, person.name AS person_name
FROM person
WHERE person.name = %s
2015-08-18 23:13:38,692 INFO sqlalchemy.engine.base.Engine ('test',)
[]
>>>

資料查詢

使用Session的query()方法。

獲取所有資料

session.query(Person).all()

獲取某一列資料,類似於django的get,如果返回資料為多個則報錯

session.query(Person).filter(Person.name==‘jack’).one()

獲取返回資料的第一行

session.query(Person).first()

過濾資料

session.query(Person.name).filter(Person.id>1).all()

limit

session.query(Person).all()[1:3]

order by

session.query(Person).ordre_by(-Person.id)

equal/like/in

query = session.query(Person)
query.filter(Person.id==1).all()
query.filter(Person.id!=1).all()
query.filter(Person.name.like('%ac%')).all()
query.filter(Person.id.in_([1,2,3])).all()
query.filter(~Person.id.in_([1,2,3])).all()
query.filter(Person.name==None).all()

and or

from sqlalchemy import and_
query.filter(and_(Person.id==1, Person.name=='jack')).all()
query.filter(Person.id==1, Person.name=='jack').all()
query.filter(Person.id==1).filter(Person.name=='jack').all()
from sqlalchemy import or_
query.filter(or_(Person.id==1, Person.id==2)).all()

使用text

from sqlalchemy import text
query.filter(text("id>1")).all()
query.filter(Person.id>1).all() #同上
query.filter(text("id>:id")).params(id=1).all() #使用:，params來傳參

query.from_statement(
    text("select * from person where name=:name")).\
    params(name='jack').all()

計數

Query使用count()函式來實現查詢計數。

query.filter(Person.id>1).count()

group by的用法

from sqlalchemy import func
session.query(func.count(Person.name), Person.name),group_by(Person.name).all()

實現count(*)來查詢表內行數

session.query(func.count('*')).select_from(Person).scalar()
session.query(func.count(Person.id)).scalar()

Pymysql with 操作

import contextlib
@contextlib.contextmanager
def mysql(host='127.0.0.1',user='root',passwd='root',db='meizi',port=3306,charset='utf8'):
    conn = pymysql.connect(host='127.0.0.1',user='root',passwd='root',db='meizi',port=3306,charset='utf8')
    cursor = conn.cursor()
    try:
        yield cursor
    finally:
        conn.commit()
        cursor.close()
        conn.close()

# # 執行sql
# with mysql() as cursor:
#    print(cursor)
#    row_count = cursor.execute("select * from tb7")
#    row_1 = cursor.fetchone()
#    print row_count, row_1

官方文件

參考連結

參考連結