Python: 数据库

磁盘上一个个文件，数据孤立，数据冗余 格式不统一，很难统一管理 无法高效查询，无法灵活查询

以树型结构表示实体及其之间的联系。关系只支持一对多 代表数据库IBM IMS

通用电气最早在1964年开发出网状数据库IDS，只能运行在GE自家的主机上 结点描述数据，结点的联系就是数据的关系 能够直接描述客观世界，可以表示实体间多种复杂关系，而这是层次数据模型无法做到的。比如，一个结点可以有多个父结点，结点之间支持可以多对多关联

使用行、列组成的二维表来组织数据和关系，表中行（记录）即可以描述数据实体，也可以描述实体间关系

关系模型比网状模型、层次模型更简单，不需要关系数存储的物理细节，专心于数据的逻辑构建，而且关系模型有论文的严格的数学理论基础支撑

1970年6月，IBM的研究员E.F.Codd发表了名为“A Relational Model of Data for Large Shared Data Banks”的论文，提出了关系模型的概念，奠定了关系模型的理论基础

1976年，IBM实验室System R项目，通过实现数据结构和操作来证明关系模型实用性，并直接产生了结构化查询语言SQL。1987年，SQL被ISO组织标准化

关系模型，有严格的数学基础，抽象级别较高，简单清晰，便于理解和使用

经过几十年的发展，关系数据库百花齐放，技术日臻成熟和完善

基于关系模型构建的数据库系统称为RDBMS(Relational DataBase System)

BM DB2、Oracle的Oracle和Mysql、微软的MS SQL。以前的Infomix、Sybase等

NoSQL是对非SQL、非传统关系型数据库的统称。 NoSQL一词诞生于1998年，2009年这个词汇被再次提出指非关系型、分布式、不提供ACID的数据库设计模式 随着互联网时代的到来，数据爆发式增长，数据库技术发展日新月异，要适应新的业务需求。 随着移动互联网、物联网的到来，大数据的技术中NoSQL也同样重要 数据库流行度排名 2017.12

数据库流行度排名 2018.6

关系中，能唯一标识一条元组的属性或属性集合，称为候选键

表中一列或者多列组成唯一的key，也就是通过这一个或者多个列能唯一的标识一条记录。即被选择的候选键 主键的列不能包含空值null。主键往往设置为整型、长整型，可以为自增AUTO_INCREMENT字段 表中可以没有主键，但是，一般表设计中，往往都会有主键，以避免记录重复

严格来说，当一个关系中的某个属性或属性集合与另一个关系（也可以是自身）的候选键匹配时，就称作这个属性或属性集合是外键

可以看做是一本字典的目录，为了快速检索用的。空间换时间，显著提高查询效率 可以对一列或者多列字段设定索引

主键索引，主键会自动建立主键索引，主键本身就是为了快速定位唯一记录的 唯一索引，表中的索引列组成的索引必须唯一，但可以为空，非空值必须唯一 普通索引，没有唯一性的要求，就是建了一个字典的目录而已

在MySQL中，InnoDB和MyISAM的索引数据结构可以使用Hash或BTree，默认是BTree

Hash时间复杂度是O(1)，但是只能进行精确匹配，也就是Hash值的匹配，比如范围匹配就没办法了，hash值无序所以无法知道原有记录的顺序。Hash问题较多

BTree索引，以B+树为存储结构

虽然，索引可以提高查询所读，但是却影响增删改的效率，因为需要索引更新或重构。频繁出现在where子句中的列可以考虑使用索引。要避免把性别这种字段设索引

限定了表中字段的取值范围

PRIMARY KEY约束定义了主键，就定义了主键约束。主键不重复且唯一，不能为空

外键定义中，可以不是引用另一张表的主键，但是，往往实际只会关注引用主键 外键：在表B中的列，引用了表A中的主键，表B中的列就是外键 A表称为主表，B表称为从表 插入规则 不需要指定 如果在表B插入一条记录，B的外键列插入了一个值，这个值必须是表A中存在的主键值 更新规则 定义外键约束时指定该规则 删除规则 定义外键约束时指定该规则 外键约束的操作 设定值 说明 CASCADE 级联，从父表删除或更新会自动删除或更新子表中匹配的行 SET NULL 从父表删除或更新行，会设置子表中的外键列为NULL，但必须保证子表列没有指定NOT NULL，也就是说子表的字段可以为NULL才行 RESTRICT 如果从父表删除主键，如果子表引用了，则拒绝对父表的删除或更新操作 NO ACTION 标准SQL的关键字，在MySQL中与RESTRICT相同。拒绝对父表的删除或更新操作 外键约束，是为了保证数据完整性、一致性，杜绝数冗余、数据错误

假设有实体部门，实体员工

类型 描述 解决方案 一对多联系 1:n 一个员工属于一个部门，一个部门有多个员工 员工外键；部门主键 多对多联系 m:n 一个员工属于多个部门，一个部门有多个员工 建立第三表 一对一联系 1:1 假设有实体管理者，一个管理者管理一个部门，一个部门只有一个管理者 字段建在哪张表都行 一对一关系用的较少，往往表示表A的一条记录唯一关联表B的一条记录，反之亦然 它往往是为了将一张表多列分割并产生成了多张表，合起来是完整的信息，或为了方便查询，或为了数据安全隔离一部分字段的数据等等

向表中插入一行数据，自增字段、缺省值字段、可为空字段可以不写 INSERT INTO table_name(col_name,…) VALUES (value1,…); 将select查询的结果插入到表中 INSERT INTO table_name SELECT … ; 如果主键冲突、唯一键冲突就执行update后的设置。这条语句的意思，就是主键不在新增记录，主键在就更新部分字 段 INSERT INTO table_name (col_name1,…) VALUES (value1,…) ON DUPLICATE KEY UPDATE col_name1=value1,…; 如果主键冲突、唯一键冲突就忽略错误，返回一个警告 INSERT IGNORE INTO table_name (col_name,…) VALUES (value1,…); 例： INSERT INTO reg(loginname, `name`, `password`) VALUES('tom', 'tom', 'tom');

INSERT INTO reg(if, loginname, `name`, `password`) VALUES (5, 'tom', 'tom', 'tom');

INSERT INTO reg(id, loginname, `name`, `password`) VALUED (1, 'tom', 'tom', 'tom') ON DUPLICATE KEY UPDATE name = 'jerry'

IFNORE 意义同Insert语句 UPDATA [IGNORE] tal_name SET col_name1=expr1 [, col_name2=expr2 …] [WHERE where_definition] – 例 UPDATE reg SET name='tom· WHERE id=5;

注意这一句非常危险，会更新所有数据 UPDATE reg SET name ='ben';

更新一定要加条件 UPDATE reg SET name = 'ben', password = 'benpwd' WHRER id = 1;

删除符合条件的记录 DELETE FROM tal_name [WHERE where_defintion] 删除一定要有条件 DELETE FROM reg WHERE id =1;

SELECT [DISTINCT] select_expr, … [FROM table_references [WHERE where_definition] [FROUP BY {col_name | expr | position} [ASC | DESC], … [WITH ROLLUP]] [HAVING whrer_definition] [ORDER BY {col_name | expr | position} [ASC | DESC], …] [LIMIT {[offset,} roe_count | row_count OFFSET offset}] [FOR UPDATE | LOCK IN SHARE MODE]]

FOR UPDATE会把行进行写锁定，这是排它锁

查询 查询的结果成为结果集recordset

最简单的查询 SELECT 1; SELECT * FROM employees;

字符串合并 SELECT emp_no, first_name + last_name FROM employees;

执行前

执行后

使用字符串相加函数 CONCAT SELECT emp_no, CONCAT(first_name,' ',last_name) FROM employees;

执行后

AS定义别名，可选。 写AS是一个好习惯 SELECT emp_no as en, CONCAT(first_name,' ',last_name) as name FROM employees; 执行后

隔离性不好，事务的操作就会互相影响，带来不同严重程度的后果 首先看看隔离性不好，带来哪些问题：

更新丢失Lost Update 事务A和B，更新同一个数据，它们都读取了初始值100，A要减10，B要加100，A减去10后更新为90，B加100更新为200，A的更新丢失了，就像从来没有减过10一样 脏读 事务A和B，事务B读取到了事务A未提交的数据（这个数据可能是一个中间值，也可能事务A后来回滚事务）。事务A是否最后提交并不关心。只要读取到了这个被修改的数据就是脏读 不可重复读Unrepeatable read 事务A在事务执行中相同查询语句，得到了不同的结果，不能保证同一条查询语句重复读相同的结果就是不可以重复读 例如，事务A查询了一次后，事务B修改了数据，事务A又查询了一次，发现数据不一致了 注意，脏读讲的是可以读到相同的数据的，但是读取的是一个未提交的数据，而不是提交的最终结果。 幻读Phantom read 事务A中同一个查询要进行多次，事务B插入数据，导致A返回不同的结果集，如同幻觉，就是幻读 数据集有记录增加了，可以看做是增加了记录的不可重复读 有了上述问题，数据库就必须要解决，提出了隔离级别。 隔离级别由低到高，如下表

隔离级别 描述 READ UNCOMMITTED 读取到未提交的数据 READ COMMITTED 读已经提交的数据，ORACLE默认隔离级别 REPEATABLE READ 可以重复读，MySQL的 默认隔离级别 SERIALIZABLE 可串行化。事务间完全隔离，事务不能并发，只能串行执行 隔离级别越高，串行化越高，数据库执行效率低；隔离级别越低，并行度越高，性能越高 隔离级别越高，当前事务处理的中间结果对其它事务不可见程度越高

设置会话级或者全局隔离级别 SET [SESSION | GLOBAL] TRANSACTION ISOLATION LEVEL {READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE}

查询隔离级别 SELECT @@global.tx_isolation; SELECT @@tx_isolation;

SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED; SET SESSION TRANSACTION ISOLATION LEVEL REPEATABLE READ;

禁用自动提交 SET AUTOCOMMIT = 0

SERIALIZABLE，串行了，解决所有问题

REPEATABLE READ，事务A中同一条查询语句返回同样的结果，就是可以重复读数据了。例如语句为(select * from user)。解决的办法有：

对select的数据加锁，不允许其它事务删除、修改的操作 第一次select的时候，对最后一次确切提交的事务的结果做快照 解决了不可以重复读，但是有可能出现幻读。因为另一个事务可以增删数据

READ COMMITTED，在事务中，每次select可以读取到别的事务刚提交成功的新的数据。因为读到的是提交后的数据，解决了脏读，但是不能解决 不可重复读 和 幻读 的问题。因为其他事务前后修改了数据或增删了数据

READ UNCOMMITTED，能读取到别的事务还没有提交的数据，完全没有隔离性可言，出现了脏读，当前其他问题都可能出现

START TRANSACTION或BEGIN开始一个事务，START TRANSACTION是标准SQL的语法 使用COMMIT提交事务后，变更成为永久变更 ROLLBACK可以在提交事务之前，回滚变更，事务中的操作就如同没有发生过一样（原子性） SET AUTOCOMMIT语句可以禁用或启用默认的autocommit模式，用于当前连接。SET AUTOCOMMIT = 0禁用自动提交事务。如果开启自动提交，如果有一个修改表的语句执行后，会立即把更新存储到磁盘

$ pip install pymysql

CREATE DATABASE IF NOT EXISTS school; SHOW DATABASES; USE school;

CREATE TABLE `student` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(30) NOT NULL, `age` int(11) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

import pymysql

IP = '192.168.1.6' USERNAME = 'lqx' PASSWORD = 'lqx' DBNAME ='test' PORT = 3306

conn = None currsor = None # 对结果集的操作 try: conn = pymysql.connect(IP, USERNAME, PASSWORD, DBNAME, PORT) currsor = conn.cursor()

sql = "CREATE TABLE `student` (" \ "`id` int(11) NOT NULL AUTO_INCREMENT," \ "`name` varchar(30) NOT NULL," \ "`age` int(11) DEFAULT NULL," \ "PRIMARY KEY (`id`)" \ ") ENGINE=InnoDB DEFAULT CHARSET=utf8;"

r = currsor.execute(sql) print(r)

conn.commit() except: conn.rollback() print('roll back') finally: if currsor: currsor.close() if conn: conn.close()

首先，必须建立一个传输数据通加粗样式道——连接。

pymysql.connect()方法返回的是Connections模块下的Connection类实例 connect方法传参就是给Connection类的 init 提供参数 Connection初始化常用参数 说明 host 主机 user 用户名 password 密码 database 数据库 port 端口 Connection.ping()方法，测试数据库服务器是否活着。有一个参数reconnect表示断开与服务器连接是否重连。连接关闭抛出异常

import pymysql

IP = '192.168.1.6' USERNAME = 'lqx' PASSWORD = 'lqx' DBNAME ='test' PORT = 3306

conn = None try: conn = pymysql.connect(IP, USERNAME, PASSWORD, DBNAME, PORT) conn.ping(False) # ping不通则抛异常 print(conn) finally: if conn: conn.close()

<pymysql.connections.Connection object at 0x000002370C8996D8>

操作数据库，必须使用游标，需要先获取一个游标对象 Connection.cursor(cursor=None) 方法返回一个新的游标对。 连接没有关闭前，游标对象可以反复使用

cursor参数，可以指定一个Cursor类。如果为None，则使用默认Cursor类

操作数据库 数据库操作需要使用Cursor类的实例，提供execute() 方法，执行SQL语句，成功返回影响的行数

使用insert into语句插入数据

import pymysql

IP = '192.168.1.6' USERNAME = 'lqx' PASSWORD = 'lqx' DBNAME ='test' PORT = 3306

conn = None currsor = None # 对结果集的操作 try: conn = pymysql.connect(IP, USERNAME, PASSWORD, DBNAME, PORT) currsor = conn.cursor()

sql = "insert into student (name,age) values('tom', 20)" r = currsor.execute(sql) print(r)

conn.commit() except: conn.rollback() print('roll back') finally: if currsor: currsor.close() if conn: conn.close()

提交时需提供commit()方法，原因在于，在Connection类的 __init__方法的注释中有这么一句话 autocommit: Autocommit mode. None means use server default. (default: False) 一般不用开启自动提交功能，使用手动管理事务

Connection类有三个方法：

begin 开始事务 commit 将变更提交 rollback 回滚事务 批量增加数据 import pymysql

IP = '192.168.1.6' USERNAME = 'lqx' PASSWORD = 'lqx' DBNAME ='test' PORT = 3306

conn = None currsor = None # 对结果集的操作 try: conn = pymysql.connect(IP, USERNAME, PASSWORD, DBNAME, PORT)

currsor = conn.cursor() for i in range(5): sql = "insert into student (name,age) values('ben{}', {})".format(i,20+i) r = currsor.execute(sql)

conn.commit() # 提交 except: conn.rollback() # 回滚 print('roll back') finally: if currsor: currsor.close() if conn: conn.close()

建立连接 获取游标 执行SQL 提交事务 释放资源

Cursor类的获取查询结果集的方法有fetchone()、fetchmany(size=None)、fetchall() 查询会根据Cursor游标移动 import pymysql

IP = '192.168.1.6' USERNAME = 'lqx' PASSWORD = 'lqx' DBNAME ='test' PORT = 3306

conn = None currsor = None # 对结果集的操作 try: conn = pymysql.connect(IP, USERNAME, PASSWORD, DBNAME, PORT) currsor = conn.cursor()

sql = 'select * from student' rows = currsor.execute(sql) # 返回影响的行数

print(currsor.fetchone()) print(currsor.fetchone()) print(currsor.rownumber, currsor.rowcount) print('1 ~~~~~~~~~~')

print(currsor.fetchmany(2)) print(currsor.rownumber, currsor.rowcount) print('2 ~~~~~~~~~~~')

print(currsor.fetchall()) print(currsor.rownumber, currsor.rowcount)

for x in currsor.fetchall(): print(x, '~') currsor.rownumber = 0 for x in currsor.fetchall(): print(x, '=')

finally: if currsor: currsor.close() if conn: conn.close()

执行结果 (1, 'tom', 20) (2, 'ben0', 20) 2 6 1 ~~~~~~~~~~ ((3, 'ben1', 21), (4, 'ben2', 22)) 4 6 2 ~~~~~~~~~~~ ((5, 'ben3', 23), (6, 'ben4', 24)) 6 6 (1, 'tom', 20) = (2, 'ben0', 20) = (3, 'ben1', 21) = (4, 'ben2', 22) = (5, 'ben3', 23) = (6, 'ben4', 24) =

Process finished with exit code 0

名称 说明 fetchone() 获取结果集的下一行 fetchmany(size=None) size指定返回的行数的行，None则返回空元组 fetchall() 返回剩余所有行，如果走到末尾，就返回空元组，否则返回一个元组，其元素是每一行的记录封装的一个元组 cursor.rownumber 返回当前行号。可以修改，支持负数。 负向超界，拉到起始位置；正向超界，拉到末位位置 cursor.rowcount 返回的总行数 注意：fetch操作的是结果集，结果集是保存在客户端的，也就是说fetch的时候，查询已经结束了

先查后改 import pymysql

IP = '192.168.1.6' USERNAME = 'lqx' PASSWORD = 'lqx' DBNAME ='test' PORT = 3306

conn = None currsor = None # 对结果集的操作 try: conn = pymysql.connect(IP, USERNAME, PASSWORD, DBNAME, PORT) currsor = conn.cursor()

sql = 'select * from student' rows = currsor.execute(sql) # 返回影响的行数 userid = currsor.fetchone()[0] print(userid) sql = "update student set name='jerry' where id='{}'".format(userid) currsor.execute(sql)

conn.commit()

except: conn.rollback() finally: if currsor: currsor.close() if conn: conn.close()

Cursor类有一个Mixin的子类DictCursor 只需要 导入from pymysql.cursors import DictCursor库 cursor = conn.cursor(DictCursor) 就可以了 具体实现 import pymysql from pymysql.cursors import DictCursor

IP = '192.168.1.6' USERNAME = 'lqx' PASSWORD = 'lqx' DBNAME ='test' PORT = 3306

conn = None currsor = None # 对结果集的操作 try: conn = pymysql.connect(IP, USERNAME, PASSWORD, DBNAME, PORT) currsor = conn.cursor(DictCursor)

sql = 'select * from student where id={}'.format('2') currsor.execute(sql) print(currsor.fetchall())

except: conn.rollback() finally: if currsor: currsor.close() if conn: conn.close()

[{'id': 2, 'name': 'ben0', 'age': 20}]

返回一行，是一个字典 返回多行，放在列表中，元素是字典，代表一行

找出用户id为3的用户信息的SQL语句如下 SELECT * from student WHERE id = 3

现在，要求可以找出某个id对应用户的信息，代码如下 userid = 5 # 用户id可以变 sql = 'SELECT * from student WHERE id = {}'.format(userid)

userid可以变，例如从客户端request请求中获取，直接拼接到查询字符串中 如果userid = '5 or 1=1' sql = 'SELECT * from student WHERE id = {}'.format('5 or 1=1')

运行的结果竟然是返回了全部数据

查看连接类和游标类的源码

class Connection(object): def __enter__(self): """Context manager that returns a Cursor""" return self.cursor()

def __exit__(self, exc, value, traceback): """On successful exit, commit. On exception, rollback""" if exc: self.rollback() else: self.commit()

class Cursor(object): def __enter__(self): return self

def __exit__(self, *exc_info): del exc_info self.close()

连接类进入上下文的时候会返回一个游标对象，退出时如果没有异常会提交更改 游标类也使用上下文，在退出时关闭游标对象 import pymysql

IP = '192.168.1.6' USERNAME = 'lqx' PASSWORD = 'lqx' DBNAME ='test' PORT = 3306

conn = pymysql.connect(IP, USERNAME, PASSWORD, DBNAME, PORT) try: with conn.cursor() as cursor: sql = "insert into student (name,age) values('tom'%s, %s)"

r = cursor.executemany(sql, (("{}".format(i), 20+i) for i in range(2))) print(r) # 插入行数 with conn as cursor: cursor.execute('select * from student') print(cursor.fetchall())

except Exception as e: print(e) finally: if conn: conn.close()

执行结果

2 ((1, 'jerry', 20), (2, 'ben0', 20), (3, 'ben1', 21),\ (4, 'ben2', 22), (5, 'ben3', 23), (6, 'ben4', 24),\ (50, "tom'0", 20), (51, "tom'1", 21))

Process finished with exit code 0

换一种写法，使用连接的上下文

import pymysql

IP = '192.168.1.6' USERNAME = 'lqx' PASSWORD = 'lqx' DBNAME ='test' PORT = 3306

conn = pymysql.connect(IP, USERNAME, PASSWORD, DBNAME, PORT)

with conn as cursor: for i in range(2): sql = "insert into student (name,age) values('tom{0}', 20+{0})".format(i) rows = cursor.execute(sql)

cursor.execute('select * from student') print(cursor.fetchall())

cursor.close() conn.close()

conn的with进入是返回一个新的cursor对象，退出时，只是提交或者回滚了事务。并没有关闭cursor和conn。 不关闭cursor就可以接着用，省的反复创建它

如果想关闭cursor对象，这样写 import pymysql

IP = '192.168.1.6' USERNAME = 'lqx' PASSWORD = 'lqx' DBNAME ='test' PORT = 3306

conn = pymysql.connect(IP, USERNAME, PASSWORD, DBNAME, PORT)

with conn as cursor: with cursor: sql = "select * from student" cursor.execute(sql) print(cursor.fetchall())

conn.close()

通过上面的实验，我们应该知道，连接应该不需要反反复复创建销毁，应该是多个cursor共享一个conn

class type(object): def init__(cls, what, bases=None, dict=None): # known special case of type.__init """ type(object_or_name, bases, dict) type(object) -> the object's type type(name, bases, dict) -> a new type

""" pass

type(object) -> the object's type，返回对象的类型，例如type(10) type(name, bases, dict) -> a new type， 返回一个新的类型 XClass = type('myclass', (object,), {'a':100, "b":'string'}) # (objcect,) 可直接为空元组() print(XClass) print('-' * 30) print(XClass.__dict__) print('-' * 30) print(XClass.__name__) print('-' * 30) print(XClass.__bases__) print('-' * 30) print(XClass.mro())

<class 'main.myclass'>

{'a': 100, 'b': 'string', 'module': 'main',\ 'dict': <attribute 'dict' of 'myclass' objects>, \ 'weakref': <attribute 'weakref' of 'myclass' objects>, 'doc': None}

myclass

(<class 'object'>,)

[<class 'main.myclass'>, <class 'object'>]

创建更加复杂的类 def __init__(self): self.x = 1000

def show(self): print(self.__dict__)

XClass = type('myclass', (object,), {'a':100, 'show':show, 'init':__init__}) print(XClass) print('-' * 30) print(XClass.__dict__) print('-' * 30) print(XClass.__name__) print('-' * 30) print(XClass.mro()) print('-' * 30) XClass().show()

<class 'main.myclass'>

{'a': 100, 'show': <function show at 0x0000024D0C7B5158>,\ 'init': <function init at 0x0000024D0C7B51E0>, \ 'module': 'main', 'dict': <attribute 'dict' of 'myclass' objects>,\ 'weakref': <attribute 'weakref' of 'myclass' objects>, 'doc': None}

myclass

[<class 'main.myclass'>, <class 'object'>]

{'x': 1000}

总结 可以借助type构造任何类，用代码来生成代码，这就是元编程

一个类可以继承自type类

注意不是继承自object类 class ModelMeta(type): def __new__(cls, *args, **kwargs): print(cls) print(args) print(kwargs) return super().__new__(cls, *args, **kwargs)

继承自type，ModelMeta就是元类，它可以创建出其它类

class ModelMeta(type): # 继承自type def __new__(cls, *args, **kwargs): print(cls) print(args) print(kwargs) print() return super().__new__(cls, *args, **kwargs)

class A(metaclass=ModelMeta): id = 1000

def __init__(self): print('A.init~~~')

class B(A): def __init__(self): print('B.init~~~')

C = ModelMeta('C', (), {})

class D: pass # D = type('D', (), {}) E = type('E', (), {})

class F(ModelMeta): pass

print('-' * 30) print('A', type(A), A.__bases__) print('B', type(B), B.__bases__) print('C', type(C), C.__bases__) print('~' * 30)

print('D', type(D), D.__bases__) print('E', type(E), E.__bases__) print('F', type(F), C.__bases__)

<class 'main.ModelMeta'> ('A', (), {'module': 'main', 'qualname': 'A',\ 'id': 1000, 'init': <function A.__init__ at 0x0000021CDD5B5268>}) {}

<class 'main.ModelMeta'> ('B', (<class 'main.A'>,), {'module': 'main', \ 'qualname': 'B', 'init': <function B.__init__ at 0x0000021CDD5B5598>}) {}

<class 'main.ModelMeta'> ('C', (), {}) {}

A <class 'main.ModelMeta'> (<class 'object'>,) B <class 'main.ModelMeta'> (<class 'main.A'>,) C <class 'main.ModelMeta'> (<class 'object'>,) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ D <class 'type'> (<class 'object'>,) E <class 'type'> (<class 'object'>,) F <class 'type'> (<class 'object'>,)

从运行结果还可以分析出·__new__(cls, *args, **kwargs)的参数结构：

中间是一个元组('A', (), {'init': <function A.__init__ at 0x0000000000B6E598>, 'module': 'main', 'qualname': 'A', 'id': 100}) 对应 (name, bases, dict) 修改代码如下

class ModelMeta(type): # 继承自type def __new__(cls, name, bases, dict): print('CLS : ', cls) print('NAME : ', name) print('BASES : ', bases) print('DICT : ', dict) return super().__new__(cls, name, bases, dict)

执行结果 CLS : <class 'main.ModelMeta'> NAME : A BASES : ()

DICT : {'module': 'main', 'qualname': 'A', 'id': 1000,\ 'init': <function A.__init__ at 0x000001DB6E6F5268>} CLS : <class 'main.ModelMeta'>

NAME : B BASES : (<class 'main.A'>,)

DICT : {'module': 'main', 'qualname': 'B', \ 'init': <function B.__init__ at 0x000001DB6E6F5598>}

CLS : <class 'main.ModelMeta'> NAME : C BASES : () DICT : {}

A <class 'main.ModelMeta'> (<class 'object'>,) B <class 'main.ModelMeta'> (<class 'main.A'>,) C <class 'main.ModelMeta'> (<class 'object'>,) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ D <class 'type'> (<class 'object'>,) E <class 'type'> (<class 'object'>,) F <class 'type'> (<class 'object'>,)

从运行结果可以看出，只要元类是ModelMeta，创建类对象时，就会调用ModelMeta的__new__方法 上例中，F也是元类， F –继承自–> ModelMeta –继承自–> type type(元类) 返回type。但是type被metaclass修改了的元类的类返回其元类

$ pip install sqlalchemy

官方文档 http://docs.sqlalchemy.org/en/latest/ 查看版本

import sqlalchemy print(sqlalchemy.__version__)# 1.3.5

SQLAlchemy内部使用了连接池

字段类 说明 AutoField 自增的整数字段。 如果不指定，django会为模型类自动增加主键字段 BooleanField 布尔值字段，True和False 对应表单控件CheckboxInput NullBooleanField 比BooleanField多一个null值 CharField 字符串，max_length设定字符长度 对应表单控件TextInput TextField 大文本字段，一般超过4000个字符使用 对应表单控件Textarea IntegerField 整数字段 BigIntegerField 更大整数字段，8字节 DecimalField 使用Python的Decimal实例表示十进制浮点数。max_digits总位数，decimal_places小数点后的位数 FloatField Python的Float实例表示的浮点数 DateField 使用Python的datetime.date实例表示的日期 auto_now=False每次修改对象自动设置为当前时间。 auto_now_add=False对象第一次创建时自动设置为当前时间。 auto_now_add、auto_now、default互斥 对应控件为TextInput，关联了一个Js编写的日历控件 TimeField 使用Python的datetime.time实例表示的时间，参数同上 DateTimeField 使用Python的datetime.datetime实例表示的时间，参数同上 FileField 一个上传文件的字段 ImageField 继承了FileField的所有属性和方法，但是对上传的文件进行校验，确保是一个有效的图片 EmailField 能做Email检验，基于CharField，默认max_length=254 GenericIPAddressField 支持IPv4、IPv6检验，缺省对应文本框输入 URLField 能做URL检验，基于基于CharField，默认max_length=200

缺省情况下，Django的每一个Model都有一个名为id的AutoField字段，如下

id = models.AutoField(primary_key=True)

如果显式定义了主键，这种缺省主键就不会被创建了。

官方文档

值 说明 db_column 表中字段的名称。如果未指定，则使用属性名 primary_key 是否主键 unique 是否是唯一键 default 缺省值。这个缺省值不是数据库字段的缺省值，而是新对象产生的时候被填入的缺省值 null 表的字段是否可为null，默认为False blank Django表单验证中，如果True，则允许该字段为空。默认为False db_index 字段是否有索引 to_field 关联对象的字段。默认情况下，Django 使用相关对象的主键。如果你引用了一个不同的字段，这个字段必须有 unique=True 关系类型字段类

类 说明 ForeignKey 外键，表示一对多 ForeignKey('production.Manufacturer') 自关联ForeignKey('self') ManyToManyField 表示多对多 OneToOneField 表示一对一 一对多时，自动创建会增加_id后缀。

​ 从一访问多，使用对象.小写模型类_set

​ 从一访问一，使用对象.小写模型类

访问id 对象.属性_id

基类 django.db.models.Model

表名不指定默认使用<appname>_<model_name>。使用Meta类修改表名

编辑应用下的models.py文件（这里是employee/models.py）

from django.db import models

""" CREATE TABLE `employees` ( `emp_no` int(11) NOT NULL, `birth_date` date NOT NULL, `first_name` varchar(14) NOT NULL, `last_name` varchar(16) NOT NULL, `gender` smallint(6) NOT NULL DEFAULT 1 COMMENT 'M=1, F=2', `hire_date` date NOT NULL, PRIMARY KEY (`emp_no`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3;

"""

class Employee(models.Model): class Meta: db_table = 'employees'#定义表名

#将列名一一映射出来 emp_no = models.IntegerField(primary_key=True) birth_date = models.DateField(null=False) first_name = models.CharField(null=False, max_length=14) last_name = models.CharField(null=False, max_length=16) gender = models.SmallIntegerField(null=False) hire_date = models.DateField(null=False)

def __repr__(self):#重写可视化效果 return '< Employee {}:{}-{} >'.format(self.emp_no, self.first_name, self.last_name)

str = repr 在项目根目录编写一段测试代码

import os import django

#简单的连接前，需要安装mysqlclient，使用pip install mysqlclient os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'salay.settings') django.setup()

#导入必须在连接setup之后，不然会报应用未注册 from employee.models import Employee emps=Employee.objects.all() for i in emps: print(type(i),i)

#结果 <class 'employee.models.Employee'> < Employee 10001:Georgi-Facello > <class 'employee.models.Employee'> < Employee 10002:Bezalel-Simmel > <class 'employee.models.Employee'> < Employee 10003:Parto-Bamford > <class 'employee.models.Employee'> < Employee 10004:Chirstian-Koblick > <class 'employee.models.Employee'> < Employee 10005:Kyoichi-Maliniak > <class 'employee.models.Employee'> < Employee 10006:Anneke-Preusig > <class 'employee.models.Employee'> < Employee 10007:Tzvetan-Zielinski > <class 'employee.models.Employee'> < Employee 10008:Saniya-Kalloufi > <class 'employee.models.Employee'> < Employee 10009:Sumant-Peac > <class 'employee.models.Employee'> < Employee 10010:Duangkaew-Piveteau > <class 'employee.models.Employee'> < Employee 10011:Mary-Sluis > <class 'employee.models.Employee'> < Employee 10012:Patricio-Bridgland > <class 'employee.models.Employee'> < Employee 10013:Eberhardt-Terkki > <class 'employee.models.Employee'> < Employee 10014:Berni-Genin > <class 'employee.models.Employee'> < Employee 10015:Guoxiang-Nooteboom > <class 'employee.models.Employee'> < Employee 10016:Kazuhito-Cappelletti > <class 'employee.models.Employee'> < Employee 10017:Cristinel-Bouloucos > <class 'employee.models.Employee'> < Employee 10018:Kazuhide-Peha > <class 'employee.models.Employee'> < Employee 10019:Lillian-Haddadi > <class 'employee.models.Employee'> < Employee 10020:Mayuko-Warwick > (0.001) SELECT @@SQL_AUTO_IS_NULL; args=None (0.000) SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED; args=None (0.001) SELECT `employees`.`emp_no`, `employees`.`birth_date`, `employees`.`first_name`, `employees`.`last_name`, `employees`.`gender`, `employees`.`hire_date` FROM `employees`; args=() 查出了所有记录

Django会为模型类提供一个objects对象，它是django.db.models.manager.Manager类型，用于与数据库交互。当定义模型类的时候没有指定管理器，则Django会为模型类提供一个objects的管理器。如果在模型类中手动指定管理器后，Django不再提供默认的objects的管理器了。

管理器是Django的模型进行数据库查询操作的接口，Django应用的每个模型都至少拥有一个管理器。用户也可以自定义管理器类，继承自django.db.models.manager.Manager，实现表级别控制。

查询会返回结果的集，它是django.db.models.query.QuerySet类型。

import os import django

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'salay.settings') django.setup()

from employee.models import Employee emps=Employee.objects.all() print(type(emps))

#结果 <class 'django.db.models.query.QuerySet'> 它是惰性求值，和sqlalchemy一样。结果就是查询的集。

它是可迭代对象。

分页功能实现，使用限制查询集。

查询集对象可以直接使用索引下标的方式（不支持负索引），相当于SQL语句中的limit和offset子句。注意使用索引返回的新的结果集，依然是惰性求值，不会立即查询。

import os import django

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'salay.settings') django.setup()

from employee.models import Employee emps=Employee.objects.all() print(emps[2:5])

#结果 <class 'django.db.models.query.QuerySet'> <QuerySet [< Employee 10003:Parto-Bamford >, < Employee 10004:Chirstian-Koblick >, < Employee 10005:Kyoichi-Maliniak >]> (0.000) SELECT @@SQL_AUTO_IS_NULL; args=None (0.000) SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED; args=None (0.000) SELECT `employees`.`emp_no`, `employees`.`birth_date`, `employees`.`first_name`, `employees`.`last_name`, `employees`.`gender`, `employees`.`hire_date` FROM `employees` LIMIT 3 OFFSET 2; args=()

名称 说明 all() 所有的 filter() 过滤，返回满足条件的数据，如：mgr.filter(emp_no=10010) 如果未查询到，返回空 exlude() 排除，排除满足条件的数据，多条排除条件则为and关系 order_by() 排序，注意参数是字符串，倒序需要在字符串前面加-号，如：mgr.order_by('-emp_no') values() 返回一个对象字典的列表，列表的元素是字典，字典内的字段和值的键值对,将字段以参数的形式带入，可以控制投影的字段 mgr =Employee.objects print(mgr.all()) print(mgr.values()) print(mgr.values('pk','first_name')) print(mgr.filter(pk=10010).values()) print(mgr.exclude(emp_no=10001)) print(mgr.exclude(emp_no=10002).order_by('emp_no')) print(mgr.exclude(emp_no=10002).order_by('-pk')) print(mgr.exclude(emp_no=10002).order_by('-pk').values()) filter(pk=10)这里pk指的就是主键，不用关心主键字段名，当然也可以使用使用主键名filter(emp_no=10)

名称 说明 get() 仅返回单个满足条件的对象 如果未能返回对象则抛出DoesNotExist异常； 如果能返回多条，抛出MultipleObjectsReturned异常 count() 返回当前查询的总条数 first() 返回第一个对象，找不到返回None last() 返回最后一个对象，返回最后一个对象，找不到返回None exists() 判断查询集中是否有数据，如果有则返回True

字段查询表达式可以作为filter()、exclude()、get()的参数，实现where子句。

语法：属性名称__比较运算符=值

注意：属性名和运算符之间使用双下划线

比较运算符如下 名称 例子 说明 exact Entry.objects.get(headline__exact="Cat bites dog") 等价于SQL语句SELECT … WHERE headline = 'Cat bites dog'; 严格等于，可省略不写 contains Entry.objects.get(headline__contains='Lennon')等价于SQL语句 SELECT … WHERE headline LIKE '%Lennon%'; 是否包含，大小写敏感，等价于like '%天%' startswith endswith Entry.objects.filter(headline__startswith='Lennon')等价于SQL语句SELECT … WHERE headline LIKE 'Lennon%'; Entry.objects.filter(headline__endswith='Lennon')等价于SQL语句SELECT … WHERE headline LIKE '%Lennon'; 以什么开头或结尾，大小写敏感 isnull isnotnull Entry.objects.filter(pub_date__isnull=True)等价于SQL语句SELECT … WHERE pub_date IS NULL; 是否为null iexact icontains istartswith iendswith i的意思是忽略大小写 in filter(emp_no__in=[1,2,3,100])等价于SQL语句SELECT … WHERE emp_no IN (1,2,3 100); 是否在指定范围数据中 gt、gte lt、lte filter(id__gt=3)等价于SQL语句SELECT … WHERE id>3; filter(id__lte=6)等价于SQL语句SELECT … WHERE id<=6; filter(pub_date__gt=datetime.date(2000,1,1))等价于SQL语句SELECT … WHERE pub_date > 2000-1-1; 大于，大于等于 小于，小于等于 year、month、dayweek_dayhour、minute、second filter(pub_date__year=2000)等价于SELECT … WHERE pub_date between '2000-01-01' and '2000-12-31' 对日期类型属性处理

虽然Django提供传入条件的方式，但是不方便，它还提供了Q对象来解决。

Q对象是django.db.models.Q

可以使用&、|操作符来组成逻辑表达式。

~表示not。

from django.db.models import Q mgr = Employee.objects print(mgr.filter(Q(pk__lt=10006))) # 不如直接写filter(pk__lt=10006)

print(mgr.filter(pk__gt=10003).filter(pk__lt=10006)) # 与 print(mgr.filter(pk__gt=10003, pk__lt=10006)) # 与 print(mgr.filter(Q(pk__gt=10003), Q(pk__lt=10006))) print(mgr.filter(Q(pk__gt=10003) & Q(pk__lt=10006))) # 与 print(mgr.filter(pk__gt=10003) & mgr.filter(pk__lt=10006))

print(mgr.filter(pk__in=[10003, 10006])) # in print(mgr.filter(Q(pk=10003) | Q(pk=10006))) # 或 print(mgr.filter(pk=10003) | mgr.filter(pk=10006)) print(mgr.filter(~Q(pk__gt=10003))) # 非 可使用&，|和Q对象来构造复杂的逻辑表达式，可以使用一个或多个Q对象。

如果混用关键字参数和Q对象，那么Q对象必须位于关键字参数的前面。

aggregate() 返回字典，方便使用,只能返回一条记录

from employee.models import Employee from django.db.models import Q, Avg, Sum, Max, Min, Count

mgr = Employee.objects print(mgr.filter(pk__gt=10010).count()) # 单值 print(mgr.filter(pk__gt=10010).aggregate(Count('pk'), Max('pk'))) # 字典 print(mgr.filter(pk__lte=10010).aggregate(Avg('pk'))) print(mgr.aggregate(Max('pk'), min=Min('pk'))) # 别名 annotate()方法用来分组聚合，返回查询集。

annotate()中结合统计方法Avg, Sum, Max, Min, Count等等做聚合，返回聚合后的查询集

只有annotate()时，就是以annotate()中的字段为聚合对象，以主键为分组基准，就是先以主键来分组，再对每个分组中annotate()中的字段进行聚合，并且投影所有字段

所得到的结果，以一个个的对象组成的列表，数据并没有显示出来，需要手动去取

emps.filter(pk__lt=10005).annotate(c=Count('gender'),a=Sum('pk')) – 等价SQL语句 SELECT `emp_no`, `birth_date`, `first_name`, `last_name`, `gender`, `hire_date`, COUNT(`gender`) AS `c`, SUM(`emp_no`) AS `a` FROM `employees` WHERE `emp_no` < 10005 GROUP BY `emp_no`; 有annotate()和values()的情况

1、如果values()在annotate()前面，则是以values()中的字段为分组基准，也就是先以values()中的字段来分组，在对各组中的annotate()中的字段进行聚合

​ 如果values()中没有字段，则跟上面那种情况是一样的，只是返回的不再是对象，而是字典组成的查询集，数据都已经显示出来了

emps.filter(pk__lt=10005).values('gender').annotate(c=Count('gender'),a=Sum('pk')) – 等价SQL语句 SELECT `gender`, COUNT(`gender`) AS `c`, SUM(`emp_no`) AS `a` FROM `employees` WHERE `emp_no` < 10005 GROUP BY `gender` 2、如果values()在annotate()后面，则values()中的字段就表名了投影的字段，都是以主键来分组的，当values()中为空，则投影所有字段

​ 返回的结果是字典组成的查询集，数据已经出来了

emps.filter(pk__lt=10005).annotate(c=Count('gender'),a=Sum('pk')).values('gender','c','a','first_name') – 等价SQL语句 SELECT `gender`, `first_name`, COUNT(`gender`) AS `c`, SUM(`emp_no`) AS `a` FROM `employees` WHERE `emp_no` < 10005 GROUP BY `emp_no` 3、如果annotate()前后都有values()，

​ 前面的values()为空，无论后面的values()是否为空，都是以主键来分组，

emps.filter(pk__lt=10005).values().annotate(c=Count('gender'),a=Sum('pk')).values('c','a','first_name') – 等价SQL语句 SELECT `first_name`, COUNT(`gender`) AS `c`, SUM(`emp_no`) AS `a` FROM `employees` WHERE `emp_no` < 10005 GROUP BY `emp_no`; ​ 后面的values()为空，无论前面的values()是否为空，都以主键来分组，并且投影所有字段

emps.filter(pk__lt=10005).values('gender').annotate(c=Count('gender'),a=Sum('pk')).values() – 等价SQL语句 SELECT `emp_no`, `birth_date`, `first_name`, `last_name`, `gender`, `hire_date`, COUNT(`gender`) AS `c`, SUM(`emp_no`) AS `a` FROM `employees` WHERE `emp_no` < 10005 GROUP BY `emp_no`; ​ 后面的values()有主键存在，则无论前面的values()有什么，都是以主键来分组。

emps.filter(pk__lt=10005).values('gender').annotate(c=Count('gender'),a=Sum('pk')).values('c','a','first_name','emp_no') – 等价SQL语句 SELECT `first_name`, `emp_no`, COUNT(`gender`) AS `c`, SUM(`emp_no`) AS `a` FROM `employees` WHERE `emp_no` < 10005 GROUP BY `emp_no`; ​ 后面的values()没有主键存在，也没有除了聚合后结果的字段，哪怕后面的也没有前面values()的字段，都有以 前面values()的字段来分组

emps.filter(pk__lt=10005).values('gender').annotate(c=Count('gender'),a=Sum('pk')).values('c','a') – 等价SQL语句 SELECT COUNT(`gender`) AS `c`, SUM(`emp_no`) AS `a` FROM `employees` WHERE `emp_no` < 10005 GROUP BY `gender`; 后面的values()没有主键存在，但是有其他字段存在，则是以前面values()字段和后面values()中存在的其他字段联合起来分组，也就是联合起来的字段必须完全相同才能被分到同一组

emps.filter(pk__lt=10005).values('gender').annotate(c=Count('gender'),a=Sum('pk')).values('c','a','first_name','last_name') – 等价SQL语句 SELECT `first_name`, `last_name`, COUNT(`gender`) AS `c`, SUM(`emp_no`) AS `a` FROM `employees` WHERE `emp_no` < 10005 GROUP BY `gender`, `first_name`, `last_name`; order_by()—》排序，一般在最后使用

升序就是原字段，例如order_by('c')

降序就是在原字段前面加个-，例如order_by('-c')

注意，如果order_by()中出现了主键，则annotate()前面的values()将无效，

emps.filter(pk__lt=10005).values('gender').annotate(c=Count('gender'),a=Sum('pk')).values('c','a','first_name').order_by('emp_no') – 等价SQL语句 SELECT `first_name`, COUNT(`gender`) AS `c`, SUM(`emp_no`) AS `a` FROM `employees` WHERE `emp_no` < 10005 GROUP BY `emp_no` ORDER BY `emp_no` ASC; ​ 如果order_by()中出现了annotate()后面的values()中没有的字段，则联合起来分组的字段中会添加上这个字段，投影也会添加这个字段

emps.filter(pk__lt=10005).values('gender').annotate(c=Count('gender'),a=Sum('pk')).values('c','a','first_name').order_by('last_name') – 等价SQL语句 SELECT `first_name`, COUNT(`gender`) AS `c`, SUM(`emp_no`) AS `a` FROM `employees` WHERE `emp_no` < 10005 GROUP BY `gender`, `first_name`, `last_name` ORDER BY `last_name` ASC;

员工表和员工工资表

– 员工表 CREATE TABLE `employees` ( `emp_no` int(11) NOT NULL, `birth_date` date NOT NULL, `first_name` varchar(14) NOT NULL, `last_name` varchar(16) NOT NULL, `gender` smallint(6) NOT NULL DEFAULT 1 COMMENT 'M=1, F=2', `hire_date` date NOT NULL, PRIMARY KEY (`emp_no`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3;

– 员工工资表 CREATE TABLE `salaries` ( `id` int(11) NOT NULL AUTO_INCREMENT, `emp_no` int(11) NOT NULL, `salary` int(11) NOT NULL, `from_date` date NOT NULL, `to_date` date NOT NULL, PRIMARY KEY (`id`), KEY `dsad` (`emp_no`), CONSTRAINT `dsad` FOREIGN KEY (`emp_no`) REFERENCES `employees` (`emp_no`) ON DELETE CASCADE ) ENGINE=InnoDB AUTO_INCREMENT=41 DEFAULT CHARSET=utf8mb3; 因为Django不支持多个主键，所以只能给组个主键降级，降为候选键，添加一个id主键，将员工号emp_no作为外键

#在employee/models.py文件下创建工资表的模型 class Salary(models.Model): class Meta: db_table = 'salaries'

id = models.AutoField(primary_key=True, null=False) emp_no = models.ForeignKey('Employee', on_delete=models.CASCADE,db_column='emp_no') #直接将emp_no新建成外键 salary = models.IntegerField(null=False) from_date = models.DateField(null=False) to_date = models.DateField(null=False)

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

#新建属性 @property def name(self): return '{}_{}'.format(self.first_name, self.last_name)

str = repr emp_no = models.ForeignKey('Employee', on_delete=models.CASCADE,db_column='emp_no')

直接将emp_no设置成外键，查询时，如果不设置db_column,则以emp_no_id来搜索，在主表中是搜索不到的，所以需要写上真实的名字，所以写上db_column='emp_no'

import os import django

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'salay.settings') django.setup()

from employee.models import Employee, Salary from django.db.models import Q, Count, Sum

emps = Employee.objects semps = Salary.objects print(semps.all()) 会进入主表employees表中反复搜索

一端对多端

一端Empoyee类中会增加一个特殊属性'salary_set'

​ 特殊属性'salary_set'可以用来查询多端表属性

​ 例如：

from employee.models import Employee, Salary from django.db.models import Q, Count, Sum

emps = Employee.objects semps = Salary.objects

print(emps.get(emp_no=10004).abc.filter(from_date__year=1995)) #转换为SQL语句 """ SELECT `employees`.`emp_no`, `employees`.`birth_date`, `employees`.`first_name`, `employees`.`last_name`, `employees`.`gender`, `employees`.`hire_date` FROM `employees` WHERE `employees`.`emp_no` = 10004;

SELECT `salaries`.`id`, `salaries`.`emp_no`, `salaries`.`salary`, `salaries`.`from_date`, `salaries`.`to_date` FROM `salaries` WHERE ( `salaries`.`emp_no` = 10004 AND `salaries`.`from_date` BETWEEN '1995-01-01' AND '1995-12-31' ); """

print(emps.get(emp_no=10004).abc.filter(from_date__gt=datetime.date(1993,1,1))) #转换为SQL语句 """ SELECT `employees`.`emp_no`, `employees`.`birth_date`, `employees`.`first_name`, `employees`.`last_name`, `employees`.`gender`, `employees`.`hire_date` FROM `employees` WHERE `employees`.`emp_no` = 10004;

SELECT `salaries`.`id`, `salaries`.`emp_no`, `salaries`.`salary`, `salaries`.`from_date`, `salaries`.`to_date` FROM `salaries` WHERE ( `salaries`.`emp_no` = 10004 AND `salaries`.`from_date` > '1993-01-01' ); """

print(emps.get(last_name='Simmel').abc.filter(from_date__gt=datetime.date(2000,1,1))) #转化为SQL语句 """ SELECT `employees`.`emp_no`, `employees`.`birth_date`, `employees`.`first_name`, `employees`.`last_name`, `employees`.`gender`, `employees`.`hire_date` FROM `employees` WHERE `employees`.`last_name` = 'Simmel';

SELECT `salaries`.`id`, `salaries`.`emp_no`, `salaries`.`salary`, `salaries`.`from_date`, `salaries`.`to_date` FROM `salaries` WHERE ( `salaries`.`emp_no` = 10002 AND `salaries`.`from_date` > '2000-01-01' ); """ ​ abc是对特殊属性的改名emp_no = models.ForeignKey('Employee', on_delete=models.CASCADE,db_column='emp_no',related_name='abc')

​ 在创建模型，设置外键的时候，对特殊属性进行命名为abc

多端Salary类中会增加一个特殊属性'emp_no_id'

例子：查询员工10004的所有工资

目标，查询工资salary>60000的所有员工信息

-- 将salaries表和employees表合并，然后查询salary大于55000的员工名
MariaDB [test]> select distinct e.first_name,e.last_name from salaries as s  join employees as e on s.emp_no=e.emp_no where s.salary>55000;
+------------+-----------+
| first_name | last_name |
+------------+-----------+
| Georgi     | Facello   |
| Bezalel    | Simmel    |
| Chirstian  | Koblick   |
+------------+-----------+
3 rows in set (0.000 sec)

使用raw，在django中执行

from employee.models import Employee, Salary

emps = Employee.objects semps = Salary.objects

sql = """ SELECT DISTINCT e.emp_no, e.first_name, e.last_name FROM salaries AS s JOIN employees AS e ON s.emp_no = e.emp_no WHERE s.salary > 55000; """

x=emps.raw(sql) print(type(x)) print(list(x)) for i in x: print(i.first_name,i.gender)

#运行结果 <class 'django.db.models.query.RawQuerySet'> [< Employee 10001:Georgi-Facello >, < Employee 10002:Bezalel-Simmel >, < Employee 10004:Chirstian-Koblick >] Georgi 1 Bezalel 2 Chirstian 1 因为执行的SQL语句必须包含管理器对象的主键，也就是emps = Employee.objects，所以需要加上e.emp_no

而查询的结果，x，属于Raw类型的查询集，而产生的对象则是管理器对象 （emps）类型的对象，而最后可以调用的字段包含了管理器对象（emps）所有的字段和sql语句中投影的其他表的字段，没有加入投影的其他表的字段，是无法查询的

例如

sql = """ SELECT DISTINCT s.emp_no, s.salary, e.first_name, e.last_name FROM salaries AS s JOIN employees AS e ON s.emp_no = e.emp_no WHERE s.salary > 55000; """

x=emps.raw(sql) print(type(x)) for i in x: print(i.first_name,i.gender,i.salary) #这里查询了前面投影的字段，也有没有投影的字段

在employee/models.py文件下

class Employee(models.Model): class Meta: db_table = 'employees'

emp_no = models.IntegerField(primary_key=True) birth_date = models.DateField(null=False) first_name = models.CharField(null=False, max_length=14) last_name = models.CharField(null=False, max_length=16) gender = models.SmallIntegerField(null=False) hire_date = models.DateField(null=False)

def __repr__(self): return '< Employee {}:{}-{} >'.format(self.emp_no, self.first_name, self.last_name)

@property def name(self): return '{}_{}'.format(self.first_name, self.last_name)

str = repr

class Department(models.Model): class Meta: db_table = 'departments'

dept_no = models.CharField(primary_key=True, null=False, max_length=4) dept_name = models.CharField(unique=True, null=False, max_length=40)

def __repr__(self): return '< Dept {} {} >'.format(self.dept_no, self.dept_name)

str = repr

class Dept_emp(models.Model): class Meta: db_table = 'dept_emp'

id = models.AutoField(primary_key=True) emp_no = models.ForeignKey('Employee', on_delete=models.CASCADE,db_column='emp_no',related_name='en') dept_no = models.ForeignKey('Department', on_delete=models.CASCADE,db_column='dept_no',related_name='de') from_date = models.DateField(null=False) to_date = models.DateField(null=False)

def __repr__(self): return '< Dept_emp {} {} {} >'.format(self.id, self.emp_no_id, self.dept_no_id) #这里改成emp_no_id 是为了防止二次查询造成资源浪费

str = repr

查询emp_no=10010的部门编号以及部门名称和员工信息

import os import django

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'salay.settings') django.setup()

from employee.models import Employee,Department,Dept_emp

emgr = Employee.objects dmgr=Department.objects d_e_mgr=Dept_emp.objects print(emgr.filter(emp_no=10010).values().first()) dept_nos=[i.dept_no_id for i in emgr.get(emp_no=10010).en.all()] print(dmgr.filter(dept_no__in=dept_nos).values())

#运行结果 {'emp_no': 10010, 'birth_date': datetime.date(1963, 6, 1), 'first_name': 'Duangkaew', 'last_name': 'Piveteau', 'gender': 2, 'hire_date': datetime.date(1989, 8, 24)} <QuerySet [{'dept_no': 'd004', 'dept_name': 'Production'}, {'dept_no': 'd006', 'dept_name': 'Quality Management'}]>

import os import django

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'blog.settings') django.setup()

from post.models import * from django.contrib.auth.models import User from django.db.transaction import atomic post=Post() content=Content() try: post.title='sadasd' post.author_id=User.objects.get(id=2) with atomic(): post.save() content.id=post raise BufferError content.content='qwer' content.save() except Exception as e: print(e) 当第一个表数据插入完成，抛出异常，事务会回滚

不指定主键，就默认为插入数据

例如，插入一条，作者为admin，标题为abcd 的数据

from post.models import * from django.contrib.auth.models import User from django.db.transaction import atomic

post = Post() content = Content() try: post.title = 'abcd' post.author_id = User.objects.get(username='admin') with atomic(): post.save() content.id = post content.content = 'qwer' content.save() except Exception as e: print(e)

先查出title='aaaaa'的post表中的数据，再把数据组成的对象与content表对应，然后修改content字段

先查再修改

当有外键，且从表有数据

借助模板中从表中定义的related_name='content'，用来删除从表中的数据，再删除主表的数据

通过related_name='content'返回的数据是一个关联管理器对象，需要转换成数据对象，再进行删除

from post.models import * from django.contrib.auth.models import User from django.db.transaction import atomic import datetime content=Content() try: post = Post.objects.filter(title='aaaaa').first() with atomic(): post.content.first().delete() post.delete() except Exception as e: print(e) 手动找到从表中的数据，然后删除 删除单个 from post.models import * from django.contrib.auth.models import User from django.db.transaction import atomic import datetime content=Content() try: post = Post.objects.filter(title='aaaaa').first() with atomic(): content.id=post content.delete() post.delete() except Exception as e: print(e) 删除多个 from post.models import * from django.contrib.auth.models import User from django.db.transaction import atomic import datetime content=Content() try: post = Post.objects.filter(title='sadasd').all() with atomic(): for i in post: content.id=i content.delete() post.delete() except Exception as e: print(e) 以上都是查从表，然后删主表

现在的需求时知道从表内容，要连主表一起删

由从表删主表

import datetime, os, django

print(datetime.date.fromtimestamp(datetime.datetime.now().timestamp())) os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'blog.settings') django.setup(set_prefix=False)

from post.models import Post, Content from django.db.transaction import atomic

cont = Content()

with atomic(): content = Content.objects.filter(content="内容") post = Post() for i in content: post = Post.objects.filter(id=i.id_id).first() i.delete() post.delete()

python manage.py makemigrations

会在app名下的migrations文件夹下生成一个迁移文件

例如上图的0001_initial.py文件

python manage.py migrate 第一次迁移，最好全部迁移

后续再指定app进行迁移

python manage.py migrate employee

$(python_blog) PS D:\python_blog> python manage.py createsuperuser Username (leave blank to use 'hexug'): admin Email address: admin@123.com Password: Password (again): This password is too short. It must contain at least 8 characters. This password is too common. This password is entirely numeric. Bypass password validation and create user anyway? [y/N]: y Superuser created successfully. 创建管理员，实际上是在auth_user表中增加一个特殊用户

settings.py中设置语言、时区 语言名称可以查看 django\contrib\admin\locale 目录

LANGUAGE_CODE = 'zh-Hans' #'en-us' 中文简体 USE_TZ = True TIME_ZONE = 'Asia/Shanghai' #'UTC'

$ python manage.py runserver

Watching for file changes with StatReloader Performing system checks…

System check identified no issues (0 silenced). November 22, 2021 - 18:29:38 Django version 3.2.24, using settings 'blog.settings' Starting development server at http://127.0.0.1:8000/ Quit the server with CTRL-BREAK.

默认启动8000端口

因为在urls.py文件中默认配置了一条，当访问根目录下的admin自动跳准的路由，所以后台登录地址http://127.0.0.1:8000/admin

表明成功登录

登录后如果希望后来能够管理这些表，就需要在admin文件中注册对应的models

举例

models.py

from django.db import models

class Us(models.Model): class meta: db_table="a" pass 在admin.py文件中注册

from .models import Us admin.site.register(Us) 在后台web端查看