Python ORM框架 MySQL 安装及操作

安装数据库

下载链接
安装免安装版即可！
下载完后，我们将 zip 包解压到相应的目录，这里我将解压后的文件夹放在 指定安装目录 下。
接下来我们需要配置下 MySQL 的配置文件

打开刚刚解压的文件夹 指定安装目录，在该文件夹下创建 my.ini 配置文件，编辑 my.ini 配置以下基本信息：

[client]
# 设置mysql客户端默认字符集
default-character-set=utf8
 
[mysqld]
# 设置3306端口
port = 3306
# 设置mysql的安装目录
basedir=你的指定安装目录
# 设置 mysql数据库的数据的存放目录，MySQL 8+ 不需要以下配置，系统自己生成即可，否则有可能报错
# datadir=C:\\web\\sqldata
# 允许最大连接数
max_connections=20
# 服务端使用的字符集默认为8比特编码的latin1字符集
character-set-server=utf8
# 创建新表时将使用的默认存储引擎
default-storage-engine=INNODB

接下来我们来启动下 MySQL 数据库：

以管理员身份打开 cmd 命令行工具，切换目录：

cd 指定安装目录

初始化数据库：

mysqld --initialize --console

执行完成后，会输出 root 用户的初始默认密码，如：

2018-04-20T02:35:05.464644Z 5 [Note] [MY-010454] [Server] A temporary password is generated for root@localhost: APWCY5ws&hjQ

APWCY5ws&hjQ 就是MySQL的初始密码（后期可更改）
输入以下安装命令：

mysqld install

启动输入以下命令即可：

net start mysql

注意: 在 5.7 需要初始化 data 目录：
cd 指定安装目录
mysqld --initialize-insecure
初始化后再运行 net start mysql 即可启动 mysql。

登录 MySQL

当 MySQL 服务已经运行时, 我们可以通过 MySQL 自带的客户端工具登录到 MySQL 数据库中, 首先打开命令提示符, 输入以下格式的命名:

mysql -h 主机名 -u 用户名 -p

参数说明：

• -h : 指定客户端所要登录的 MySQL 主机名, 登录本机(localhost 或 127.0.0.1)该参数可以省略;
• -u : 登录的用户名;
• -p : 告诉服务器将会使用一个密码来登录, 如果所要登录的用户名密码为空, 可以忽略此选项。
  如果我们要登录本机的 MySQL 数据库，只需要输入以下命令即可：

mysql -u root -p 密码

若密码存在, 输入密码登录, 不存在则直接按回车登录。登录成功后你将会看到 Welcome to the MySQL monitor... 的提示语。
然后命令提示符会一直以 mysq> 加一个闪烁的光标等待命令的输入, 输入 exit 或 quit 退出登录。

ORM 框架

安装所需环境

$ pip install SQLAlchemy

查看版本

>>> import sqlalchemy
>>> sqlalchemy.__version__
'1.4.15'

登录数据库
创建库

create database test_db;

接下来就可以使用框架对数据库进行操作了
创建表
通过映射创建表的实例

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Author: bo

from sqlalchemy import create_engine
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://root:[email protected]:3306/test_db?charset=utf8mb4'
engine = create_engine(SQLALCHEMY_DATABASE_URI, echo=True)
Base = declarative_base()

class TestMysql(Base):
    __tablename__ = 'table_t'
    id = Column(Integer, primary_key=True)
    sku_code = Column(String(49))  #订单编号
    goods_name = Column(String(100))  #商品名称

    def __str__(self):
        return f"TestMysql[id:{self.id}, name:{self.name}]"

# 执行
Base.metadata.create_all(engine)

如果你执行以上程序成功，你会得到,如：

2021-05-16 12:46:26,470 INFO sqlalchemy.engine.Engine SHOW VARIABLES LIKE 'sql_mode'
2021-05-16 12:46:26,470 INFO sqlalchemy.engine.Engine [raw sql] {}
2021-05-16 12:46:26,472 INFO sqlalchemy.engine.Engine SHOW VARIABLES LIKE 'lower_case_table_names'
2021-05-16 12:46:26,472 INFO sqlalchemy.engine.Engine [generated in 0.00013s] {}
2021-05-16 12:46:26,474 INFO sqlalchemy.engine.Engine SELECT DATABASE()
2021-05-16 12:46:26,474 INFO sqlalchemy.engine.Engine [raw sql] {}
2021-05-16 12:46:26,475 INFO sqlalchemy.engine.Engine BEGIN (implicit)
2021-05-16 12:46:26,475 INFO sqlalchemy.engine.Engine SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = %(table_schema)s AND table_name = %(table_name)s
2021-05-16 12:46:26,475 INFO sqlalchemy.engine.Engine [generated in 0.00013s] {'table_schema': 'test_db', 'table_name': 'table_t'}
2021-05-16 12:46:26,477 INFO sqlalchemy.engine.Engine 
CREATE TABLE table_t (
    id INTEGER NOT NULL AUTO_INCREMENT, 
    sku_code VARCHAR(49), 
    goods_name VARCHAR(100), 
    PRIMARY KEY (id)
)


2021-05-16 12:46:26,477 INFO sqlalchemy.engine.Engine [no key 0.00010s] {}
2021-05-16 12:46:26,671 INFO sqlalchemy.engine.Engine COMMIT

首先需要创建引擎，通过 create_engine 方法完成，echo 参数控制了是否输出相关日志，默认 False

SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://root:[email protected]:3306/test_db?charset=utf8mb4'\
engine = create_engine(SQLALCHEMY_DATABASE_URI, echo=True)

接下来需要创建一个映射用的基类 Base，所有需要映射表的类都要继承这个类，才能完成相关库的操作，比如 Book，在 Book 中设置参数 tablename 代表映射的表名，各个字段需要通过 Column 方法来赋值，并设置相应的字段类型

Base = declarative_base()

class TestMysql(Base):
    __tablename__ = 'table_t'
    id = Column(Integer, primary_key=True)
    sku_code = Column(String(49))  #订单编号
    goods_name = Column(String(100))  #商品名称

    def __str__(self):
        return f"TestMysql[id:{self.id}, name:{self.name}]"

最后通过基类对所给引擎的子类进行映射创建

Base.metadata.create_all(engine)

操作数据库

下面是个增删改查的例子：

from sqlalchemy.orm import sessionmaker
Session = sessionmaker(bind=engine)
session = Session()

book = Book(name="new book")
session.add(book)
session.commit()
print(book)         # > Book[id:1, name:new book]   查询数据

book = session.query(Book).filter_by(id=1).first()
print(book)         # > Book[id:1, name:new book]   通过id查询

book.name = "wxnacy"
session.add(book)
session.commit()

print(book)         # > Book[id:1, name:wxnacy]   修改数据
session.delete(book)
session.commit()    # 删除

SQLAlchemy 在操作数据库时需要用到 Session，通过 sessionmaker 方法获取，操作过程中最关键的一步就是 commit，不然是不会同步到库中的.

查询操作

filter_by(), filter() 两个方法提供了很完成的查询操作，可以满足平常大多数查询操作，后者的功能更强大一些

# 获取满足条件的第一条数据
filter_by(name='wxnacy').first()
filter(Book.name=='wxnacy').first()     # filter 的用法稍有不同

# 获取满足条件的所有数据
filter_by(name='wxnacy').all()

# 获取满足条件的所有数据的数量
filter_by(name='wxnacy').count()

# 后续实例省去 all(), first(), count() 等

# and 操作
# 我们在 Book 中增加一个 price 价格字段
# where id = 1 and name = 'wxnacy'
filter_by(name='wxnacy', price=12)
filter_by(name='wxnacy').filter_by(price=12)
# only filter
from sqlalchemy import and_
filter(and_(Book.name='wxnacy', Book.price=12))

# in (only filter)
# where id in (1, 2)
filter(Book.id.in_([1, 2]))

# like (only filter)
# where name like '%wxn%'
filter(Book.name.like('%wxn%'))

# not equals (only filter)
# where id != 1
filter(Book.id != 1)

# not in (only filter)
# where id not in (1, 2)
filter(~Book.id.in_([1, 2]))

# or (only filter)
# where id = 1 or name = 'wxnacy'
from sqlalchemy import or_
filter(or_(Book.id == 1, Book.name == 'wxnacy'))

# order
# order by id
filter_by().order_by(Book.id)
# order by id desc
from sqlalchemy import desc
filter_by().order_by(desc(Book.id))
filter_by().order_by(Book.id.desc())
filter_by().order_by('id desc')

# limit
# limit 4
filter_by().limit(4)

order by

排序有三种方式，默认为正序排列

# select * from book order by id
session.query(Book).order_by(Book.id).all()

# select * from book order by id desc
from sqlalchemy import desc
session.query(Book).order_by(desc(Book.id)).all()
session.query(Book).order_by(Book.id.desc()).all()
session.query(Book).order_by('id desc').all()

group by

分组

# select name, count(name) as c from book group by name
from sqlalchemy import func
session.query(Book.name, func.count(Book.name).label('c')).group_by(Book.name).all()

批量插入

# insert into book (name) values ('wxnacy');
# insert into book (name) values ('wxnacy');
# 1
session.add(Book(name="wxnacy"))
session.add(Book(name="wxnacy"))
session.commit()

# 2
session.add_all([Book(name="wxnacy"), Book(name="wxnacy")])
session.commit()

# insert into book (name) values ('wxnacy'), ('wxnacy');
# 3
items = [dict(name="wxnacy"), dict(name="wxnacy")]
session.execute(Book.__table__.insert(), items)
session.commit()

从结果上三种方法都可以实现批量插入的效果，但是从他们生成的 SQL 语句看，前两个种就是重复执行了单条 insert 语句，第三种则是将批量添加的数据整合到一条语句中，从效率上讲肯定是推荐第三种方式

末

既然这么菜
那我走？（滑稽）