SQLAchemy、MYSQL、PYMYSQL

什麼是數據庫?

我的理解：將一些有關係的數據組織在一塊兒，並創建必定規則便於查詢、修改、刪除咱們關係的數據倉庫。

經常使用的數據庫：mysql、oracle、sqlserver等。

接下來咱們主要講mysql.

1)安裝：

linux環境

下載地址：

1  http://dev.mysql.com/downloads/mysql/

或者：

1 yum install -y mysql-server

默認狀況，yum安裝以後數據庫的帳號：root 無密碼。

1 mysql -u root

2）operation

1、基本操做：

一、查看數據庫：

 1 mysql> show databases;
 2 +--------------------+
 3 | Database           |
 4 +--------------------+
 5 | information_schema |
 6 | evil               |
 7 | homework           |
 8 | mysql              |
 9 | test               |
10 +--------------------+
11 5 rows in set (0.01 sec

默認數據庫：

1 　　mysql - 用戶權限相關數據
2 　　test - 用於用戶測試數據
3 　　information_schema - MySQL自己架構相關數據

二、切換或者使用數據庫：use +dbname

1 mysql> use evil;
2 Reading table information for completion of table and column names
3 You can turn off this feature to get a quicker startup with -A
4 
5 Database changed 

三、顯示當前數據庫下全部表：

 

1 mysql> show tables;
2 +----------------+
3 | Tables_in_evil |
4 +----------------+
5 | host           |
6 | service        |
7 | user           |
8 +----------------+
9 3 rows in set (0.00 sec)

四、用戶受權：刷新權限：flush privileges;

 

1 建立用戶
2     create user '用戶名'@'IP地址' identified by '密碼';
3 刪除用戶
4     drop user '用戶名'@'IP地址';
5 修改用戶
6     rename user '用戶名'@'IP地址' to '新用戶名'@'IP地址';
7 修改密碼
8     set password for '用戶名'@'IP地址' = Password('新密碼') 

建立用戶：

 

1 mysql> create user 'test'@'192.168.1.100' identified by '123';
2 Query OK, 0 rows affected (0.00 sec)

 刪除用戶：

 

1 drop user 'test'@'192.168.1.100';
2 Query OK, 0 rows affected (0.00 sec) 

修改用戶：

 

1 mysql> rename user 'test'@'192.168.1.100'  to 'test_1'@'192.168.1.101';
2 Query OK, 0 rows affected (0.00 sec)

修改用戶密碼：

1 mysql> set password for 'test_1'@'192.168.1.101' = Password('321');
2 Query OK, 0 rows affected (0.00 sec

 PS：用戶權限相關數據保存在mysql數據庫的user表中，因此也能夠直接對其進行操做（不建議）

在數據庫mysql裏User表裏有咱們剛纔配置的用戶信息。

 

1 mysql> use mysql;
2 Database changed
3 mysql> select * from user where User="test_1";

 受權管理：

1 show grants for '用戶'@'IP地址'                  -- 查看權限
2 grant  權限 on 數據庫.表 to   '用戶'@'IP地址'      -- 受權
3 revoke 權限 on 數據庫.表 from '用戶'@'IP地址'      -- 取消權限 

權限類型：

 1 all privileges  除grant外的全部權限
 2             select          僅查權限
 3             select,insert   查和插入權限
 4             ...
 5             usage                   無訪問權限
 6             alter                   使用alter table
 7             alter routine           使用alter procedure和drop procedure
 8             create                  使用create table
 9             create routine          使用create procedure
10             create temporary tables 使用create temporary tables
11             create user             使用create user、drop user、rename user和revoke  all privileges
12             create view             使用create view
13             delete                  使用delete
14             drop                    使用drop table
15             execute                 使用call和存儲過程
16             file                    使用select into outfile 和 load data infile
17             grant option            使用grant 和 revoke
18             index                   使用index
19             insert                  使用insert
20             lock tables             使用lock table
21             process                 使用show full processlist
22             select                  使用select
23             show databases          使用show databases
24             show view               使用show view
25             update                  使用update
26             reload                  使用flush
27             shutdown                使用mysqladmin shutdown(關閉MySQL)
28             super                   􏱂􏰈使用change master、kill、logs、purge、master和set global。還容許mysqladmin􏵗􏵘􏲊􏲋調試登錄
29             replication client      服務器位置的訪問
30             replication slave       由複製從屬使用
31 

對於數據庫權限：

1         對於目標數據庫以及內部其餘：
2             數據庫名.*           數據庫中的全部
3             數據庫名.表          指定數據庫中的某張表
4             數據庫名.存儲過程     指定數據庫中的存儲過程
5             *.*                全部數據庫

對於用戶和訪問IP權限：

1             用戶名@IP地址         用戶只能在改IP下才能訪問
2             用戶名@192.168.1.%   用戶只能在改IP段下才能訪問(通配符%表示任意)
3             用戶名@%             用戶能夠再任意IP下訪問(默認IP地址爲%) 

舉例：

1 grant all privileges on db1.tb1 TO '用戶名'@'IP'
2 
3             grant select on db1.* TO '用戶名'@'IP'
4 
5             grant select,insert on *.* TO '用戶名'@'IP'
6 
7             revoke select on db1.tb1 from '用戶名'@'IP'
 

二：操做表

建立表：

1 create table 表名(
2     列名  類型  是否能夠爲空，
3     列名  類型  是否能夠爲空
4 ) 

舉例：

 1 mysql> create table test (id  int not null, name varchar(20));
 2 Query OK, 0 rows affected (0.00 sec)
 3 
 4 mysql> desc test;
 5 +-------+-------------+------+-----+---------+-------+
 6 | Field | Type        | Null | Key | Default | Extra |
 7 +-------+-------------+------+-----+---------+-------+
 8 | id    | int(11)     | NO   |     | NULL    |       |
 9 | name  | varchar(20) | YES  |     | NULL    |       |
10 +-------+-------------+------+-----+---------+-------+
11 2 rows in set (0.00 sec)

1         是否可空，null表示空，非字符串
2             not null    - 不可空
3             null        - 可空

默認值：

1         默認值，建立列時能夠指定默認值，當插入數據時若是未主動設置，則自動添加默認值
2             create table tb1(
3                 nid int not null defalut 2,
4                 num int not null
5             )

自增：

 1 自增，若是爲某列設置自增列，插入數據時無需設置此列，默認將自增（表中只能有一個自增列）
 2             create table tb1(
 3                 nid int not null auto_increment primary key,
 4                 num int null
 5             )
 6             或
 7             create table tb1(
 8                 nid int not null auto_increment,
 9                 num int null,
10                 index(nid)
11             )
12             注意：1、對於自增列，必須是索引（含主鍵）。
13                  2、對於自增能夠設置步長和起始值
14                      show session variables like 'auto_inc%';
15                      set session auto_increment_increment=2;
16                      set session auto_increment_offset=10;
17 
18                      shwo global  variables like 'auto_inc%';
19                      set global auto_increment_increment=2;
20                      set global auto_increment_offset=10;
21 

設置主鍵：

 1 主鍵，一種特殊的惟一索引，不容許有空值，若是主鍵使用單個列，則它的值必須惟一，若是是多列，則其組合必須惟一。
 2             create table tb1(
 3                 nid int not null auto_increment primary key,
 4                 num int null
 5             )
 6             或
 7             create table tb1(
 8                 nid int not null,
 9                 num int not null,
10                 primary key(nid,num)
11             )

設置外鍵：

 1 外鍵，一個特殊的索引，只能是指定內容
 2             creat table color(
 3                 nid int not null primary key,
 4                 name char(16) not null
 5             )
 6 
 7             create table fruit(
 8                 nid int not null primary key,
 9                 smt char(32) null ,
10                 color_id int not null,
11                 constraint fk_cc foreign key (color_id) references color(nid)
12             )

補充：2個表設置外鍵的時候，一表裏的設置外鍵的列值不能出現另外一個表裏的設置外鍵的列不存在的值。不然報錯。這就是約束。

刪除表：

1 mysql> drop table test;
2 Query OK, 0 rows affected (0.00 sec)

 清空表：

1 mysql> truncate  table test;
2 Query OK, 0 rows affected (0.00 sec)
3 
4 mysql> delete from test;
5 Query OK, 0 rows affected (0.00 sec)

修改表：

 1 添加列：alter table 表名 add 列名 類型
 2 刪除列：alter table 表名 drop column 列名
 3 修改列：
 4         alter table 表名 modify column 列名 類型;  -- 類型
 5         alter table 表名 change 原列名 新列名 類型; -- 列名，類型
 6  
 7 添加主鍵：
 8         alter table 表名 add primary key(列名);
 9 刪除主鍵：
10         alter table 表名 drop primary key;
11         alter table 表名  modify  列名 int, drop primary key;
12  
13 添加外鍵：alter table 從表 add constraint 外鍵名稱（形如：FK_從表_主表） foreign key 從表(外鍵字段) references 主表(主鍵字段);
14 刪除外鍵：alter table 表名 drop foreign key 外鍵名稱
15  
16 修改默認值：ALTER TABLE testalter_tbl ALTER i SET DEFAULT 1000;
17 刪除默認值：ALTER TABLE testalter_tbl ALTER i DROP DEFAULT;

基本數據類型：分字符串、時間和數值。http://www.runoob.com/mysql/mysql-data-types.html

三：對錶裏的數據的操做：

一、增：

1         insert into 表 (列名,列名...) values (值,值,值...)
2         insert into 表 (列名,列名...) values (值,值,值...),(值,值,值...)
3         insert into 表 (列名,列名...) select (列名,列名...) from 表

 1 mysql> select * from test;
 2 Empty set (0.00 sec)
 3 
 4 mysql> insert into test (id,name) values(1,"evil");
 5 Query OK, 1 row affected (0.00 sec)
 6 
 7 mysql> select * from test;
 8 +----+------+
 9 | id | name |
10 +----+------+
11 |  1 | evil |
12 +----+------+
13 1 row in set (0.00 sec)

二、刪除表格裏內的數據：

1         delete from 表
2         delete from 表 where id＝1 and name＝'alex'

1 mysql> delete from test where id =1 and name="evil";
2 Query OK, 1 row affected (0.00 sec)

 三、修改

1 update 表 set name ＝ 'alex' where id>1 

 1 mysql> update test set name="jack" where id =1;
 2 Query OK, 1 row affected (0.00 sec)
 3 Rows matched: 1  Changed: 1  Warnings: 0
 4 
 5 mysql> select * from test;
 6 +----+------+
 7 | id | name |
 8 +----+------+
 9 |  1 | jack |
10 +----+------+
11 1 row in set (0.00 sec)

四、查詢：

1         select * from 表
2         select * from 表 where id > 1
3         select nid,name,gender as gg from 表 where id > 1

 

1 mysql> select * from test where id =1;
2 +----+------+
3 | id | name |
4 +----+------+
5 |  1 | jack |
6 +----+------+
7 1 row in set (0.00 sec)

其餘的一些操做：

 1 1、條件
 2         select * from 表 where id > 1 and name != 'alex' and num = 12;
 3 
 4         select * from 表 where id between 5 and 16;
 5 
 6         select * from 表 where id in (11,22,33)
 7         select * from 表 where id not in (11,22,33)
 8         select * from 表 where id in (select nid from 表)
 9 
10     2、通配符
11         select * from 表 where name like 'ale%'  - ale開頭的全部（多個字符串）
12         select * from 表 where name like 'ale_'  - ale開頭的全部（一個字符）
13 
14     3、限制
15         select * from 表 limit 5;            - 前5行
16         select * from 表 limit 4,5;          - 從第4行開始的5行
17         select * from 表 limit 5 offset 4    - 從第4行開始的5行
18 
19     4、排序
20         select * from 表 order by 列 asc              - 根據 「列」 從小到大排列
21         select * from 表 order by 列 desc             - 根據 「列」 從大到小排列
22         select * from 表 order by 列1 desc,列2 asc    - 根據 「列1」 從大到小排列，若是相同則按列2從小到大排序
23 
24     5、分組
25         select num from 表 group by num
26         select num,nid from 表 group by num,nid
27         select num,nid from 表  where nid > 10 group by num,nid order nid desc
28         select num,nid,count(*),sum(score),max(score),min(score) from 表 group by num,nid
29 
30         select num from 表 group by num having max(id) > 10
31 
32         特別的：group by 必須在where以後，order by以前
33 
34     6、連表
35         無對應關係則不顯示
36         select A.num, A.name, B.name
37         from A,B
38         Where A.nid = B.nid
39 
40         無對應關係則不顯示
41         select A.num, A.name, B.name
42         from A inner join B
43         on A.nid = B.nid
44 
45         A表全部顯示，若是B中無對應關係，則值爲null
46         select A.num, A.name, B.name
47         from A left join B
48         on A.nid = B.nid
49 
50         B表全部顯示，若是B中無對應關係，則值爲null
51         select A.num, A.name, B.name
52         from A right join B
53         on A.nid = B.nid
54 
55     7、組合
56         組合，自動處理重合
57         select nickname
58         from A
59         union
60         select name
61         from B
62 
63         組合，不處理重合
64         select nickname
65         from A
66         union all
67         select name
68         from B

補充：

 

mysql中的主鍵必須設置自增屬性嗎？

不是的 。
相反：設置自增屬性的列必須是主鍵 或者加UNIQUE索引
主鍵是有惟一性的 即不能夠重複輸入相同的值
索引就是查找數據的一種特殊結構。好比：書籍的目錄。

 

pymsyql

pymsql是Python中操做MySQL的模塊，其使用方法和MySQLdb幾乎相同。

1）安裝：

pip3 install pymysql

 

2）執行sql

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 import pymysql
 4 
 5 # 建立鏈接
 6 conn = pymysql.connect(host='192.168.1.104', port=3306, user='root', passwd='', db='test')
 7 # 建立遊標
 8 cursor = conn.cursor()
 9 
10 # 執行SQL，並返回收影響行數
11 effect_row = cursor.execute("update test set name = 'ok' where id=1")
12 
13 # 提交，否則沒法保存新建或者修改的數據
14 conn.commit()
15 
16 # 關閉遊標
17 cursor.close()
18 # 關閉鏈接
19 conn.close()
20 
21 #執行結果
22 mysql> select * from test where id =1;
23 +----+------+
24 | id | name |
25 +----+------+
26 |  1 | ok   |
27 +----+------+
28 1 row in set (0.00 sec)

 

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 import pymysql
 4 
 5 # 建立鏈接
 6 conn = pymysql.connect(host='192.168.1.104', port=3306, user='root', passwd='', db='test')
 7 # 建立遊標
 8 cursor = conn.cursor()
 9 
10 # 執行SQL，並返回收影響行數
11 effect_row = cursor.execute("update test set name = 'cc' where id=%s", (1,))
12 # 執行SQL，並返回受影響行數
13 effect_row = cursor.executemany("insert into test(id,name)values(%s,%s)", [(2,"tom"),(3,"co")])
14 
15 # 提交，否則沒法保存新建或者修改的數據
16 conn.commit()
17 
18 # 關閉遊標
19 cursor.close()
20 # 關閉鏈接
21 conn.close()
22 
23 #執行結果：
24 
25 mysql> select * from test;
26 +----+------+
27 | id | name |
28 +----+------+
29 |  1 | cc   |
30 |  2 | tom  |
31 |  3 | co   |
32 +----+------+
33 3 rows in set (0.00 sec)

 

3）獲取新創自增id

 

建立自增表：

1 mysql> create table user (id int auto_increment,name varchar(20),primary key(id));
2 Query OK, 0 rows affected (0.02 sec)

 

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 import pymysql
 4 
 5 conn = pymysql.connect(host='192.168.1.104', port=3306, user='root', passwd='', db='test')
 6 cursor = conn.cursor()
 7 cursor.executemany("insert into user(name)values(%s)", [("tom")])
 8 conn.commit()
 9 cursor.close()
10 conn.close()
11 
12 # 獲取最新自增ID
13 new_id = cursor.lastrowid
14 print(new_id)
15 
16 1

 

1 mysql> select * from user;
2 +----+------+
3 | id | name |
4 +----+------+
5 |  1 | tom  |
6 +----+------+
7 1 row in set (0.00 sec

 

4)獲取查詢數據：

 1 # -*- coding:utf-8 -*-
 2 import pymysql
 3  
 4 conn = pymysql.connect(host='192.168.1.104', port=3306, user='root', passwd='', db='test')
 5 cursor = conn.cursor()
 6 cursor.execute("select * from user")
 7  
 8 # 獲取第一行數據
 9 row_1 = cursor.fetchone()
10  
11 # 獲取前n行數據
12 # row_2 = cursor.fetchmany(3)
13 # 獲取全部數據
14 # row_3 = cursor.fetchall()
15 print(row_1)
16 conn.commit()
17 cursor.close()
18 conn.close()
19 (1, 'tom')

注：在fetch數據時按照順序進行，可使用cursor.scroll(num,mode)來移動遊標位置，如：

• cursor.scroll(1,mode='relative')  # 相對當前位置移動
• cursor.scroll(2,mode='absolute') # 相對絕對位置移動

5）fetch數據類型：（不懂）

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 import pymysql
 4  
 5 conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
 6  
 7 # 遊標設置爲字典類型
 8 cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
 9 r = cursor.execute("call p1()")
10  
11 result = cursor.fetchone()
12  
13 conn.commit()
14 cursor.close()
15 conn.close()

 

SQLALchemy

介紹：

SQLAlchemy是python的一種ORM框架，他將類和對象映射成相應的sql語句，調用DBAPI（pytmysql,mysql 等。一系列的第三方模塊。）來操做數據庫。

Dialect：根據你寫鏈接串挑選那個DBAPI（鏈接mysql仍是oracle）進行鏈接數據庫。

格式：數據庫類型+數據庫鏈接驅動：//用戶名：用戶密碼@數據庫IP【數據庫端口】/數據庫名稱。``dialect[+driver]://user:password@host/dbname[?key=value..]``

 1 MySQL-Python
 2     mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
 3  
 4 pymysql
 5     mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
 6  
 7 MySQL-Connector
 8     mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
 9  
10 cx_Oracle
11     oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
12  
13 更多詳見：http://docs.sqlalchemy.org/en/latest/dialects/index.html

 NOTE：

 1 在python2.7的時候使用：mysqldb.在python3.5中使用pymysql.
 2 在建立鏈接的時候須要注意：
 3 1）訪問的數據庫的IP有權限訪問數據庫服務器。
 4 GRANT ALL PRIVILEGES ON *.* TO 'root'@'192.168.1.100'WITH GRANT OPTION; 
 5 其中192.168.1.100是訪問數據庫的IP。
 6 2）鏈接的數據庫存在。
 7 # mysql -u root -p
 8 Enter password: 
 9 Welcome to the MySQL monitor.  Commands end with ; or \g.
10 Your MySQL connection id is 57
11 Server version: 5.1.73 Source distribution
12 
13 Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
14 
15 Oracle is a registered trademark of Oracle Corporation and/or its
16 affiliates. Other names may be trademarks of their respective
17 owners.
18 
19 Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
20 
21 mysql> show databases;
22 +--------------------+
23 | Database           |
24 +--------------------+
25 | information_schema |
26 | homework           |
27 | mysql              |
28 | test               |
29 +--------------------+
30 4 rows in set (0.00 sec)

 

1）establish db（鏈接數據庫）：

1 engine = create_engine("mysql+pymysql://root:@192.168.1.105:3306/homework", max_overflow=5)

 

解釋：

1 create_engine()建立數據庫鏈接引擎對象。``dialect[+driver]://user:password@host/dbname[?key=value..]``第一個參數是字符串，說明鏈接數據庫的DBAPI,一個是訪問的數據庫的url。
2 dialect：is a database name such as ``mysql``, ``oracle``，``postgresql``。
3 ``driver``：the name of a DBAPI, such as:pymysql,`cx_oracle`` and so on.
4 參數:encoding表示數據庫編碼，默認是UTF-8，能夠指定編碼：encoding="gbk"
5 max_overflow.數據庫鏈接池的大小。默認是5.max_overflow=10.
6 其餘的參數查看create_engine函數的文檔。
7 echo參數若是等於True的時候輸出建立數據庫日誌。默認是關閉False.

 

connection Poolling:鏈接池。

Engine：引擎。（相似rabbitMQ的Chanel，mysql的遊標）

有如上3個部分咱們就能夠鏈接數據庫並進行相關操做。（使用 Engine/ConnectionPooling/Dialect 進行數據庫操做，Engine使用ConnectionPooling鏈接數據庫，而後再經過Dialect執行SQL語句。）

SQLALchemy數據結構：

1)在SQLALchemy.sql包裏有咱們常常操做的sql語句部分：

from .sql import (
insert,
join,
select,
.....
}

 

2)在SQLALchemy.types,包含操做的數據類型：

1 from .types import ( 
2   Enum,
3     FLOAT,
4     Float,
5     INT,
6     INTEGER,
7     Integer,
8    .....
9 }

 

3）在SQLALchemy.schema裏包含數據庫的字段：

 1 from .schema import (
 2     CheckConstraint,
 3     Column,
 4     ColumnDefault,
 5     Constraint,
 6     DefaultClause,
 7     FetchedValue,
 8     ForeignKey,
 9     ForeignKeyConstraint,
10     Index,
11     MetaData,
12 }

 

2)建立表結構

使用 Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 進行數據庫操做。Engine使用Schema Type建立一個特定的結構對象，以後經過SQL Expression Language將該對象轉換成SQL語句，而後經過 ConnectionPooling 鏈接數據庫，再而後經過 Dialect 執行SQL，並獲取結果

 1 from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKey
 2 import pymysql
 3 #建立數據庫鏈接
 4 engine = create_engine("mysql+pymysql://root@192.168.1.105:3306/homework", max_overflow=5,echo=True)
 5 # 建立MetaData對象。
 6 metadata = MetaData()
 7 # 定義表
 8 user = Table('meide', metadata,#建立表。
 9     Column('id', Integer, primary_key=True),#建立列屬性。
10     Column('name', String(20)),
11     )
12 
13 color = Table('color', metadata,
14     Column('id', Integer, primary_key=True),
15     Column('name', String(20)),
16     )
17 # 建立數據表，若是數據表存在，則忽視
18 metadata.create_all(engine)#建立表。
19 
20 
21 mysql> show tables;
22 +--------------------+
23 | Tables_in_homework |
24 +--------------------+
25 | color              |
26 | favor              |
27 | group              |
28 | meide              |
29 | name               |
30 | person             |
31 | server             |
32 | servertogroup      |
33 | ts_test            |
34 | users              |
35 +--------------------+
36 10 rows in set (0.00 sec)

 

 

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 
 4 from sqlalchemy import create_engine
 5 
 6 
 7 engine = create_engine("mysql+pymysql://root:@192.168.1.105:3306/homework", max_overflow=5)
 8 
 9 engine.execute(
10     "INSERT INTO ts_test (name,age) VALUES ('jack2',22)"
11 )
12 
13 result = engine.execute('select * from ts_test')
14 row=result.fetchall()
15 print(row) 

ORM只能建立表、刪除表可是不能幫你修改表結構，須要第三方模塊操做。

經過SQLALchemy建立表結構：

建立單表結構：

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index#導入列數據類型字段。
 5 from sqlalchemy.orm import sessionmaker, relationship#導入會話函數、
 6 from sqlalchemy import create_engine
 7 
 8 engine = create_engine("mysql+pymysql://root:@192.168.1.105:3306/homework", max_overflow=15)#建立數據庫引擎，經過鏈接池獲取數據庫的鏈接。數據庫鏈接池數量爲：15，默認值是5.
 9 #建立sqlorm基類。（爲聲明的類定義基類。）
10 Base = declarative_base()
11 
12 # 建立一個類繼承Base類。
13 class Users(Base):
14     __tablename__ = 'users'#建立表名字。
15     id = Column(Integer, primary_key=True)#建立整型的列並設爲主鍵。
16     name = Column(String(32))#建立字符串類型的數據。
17     extra = Column(String(16))
18 
19     __table_args__ = (
20     UniqueConstraint('id', 'name', name='uix_id_name'),
21         Index('ix_id_name', 'name', 'extra'),
22     )#建立聯合索引。
23 
24     def __repr__(self):
25         return "%s-%s" %(self.id, self.name)
26 
27 Base.metadata.create_all(engine)##執行該函數，他就會執行全部Base全部的子類。調用咱們定義類並建立相應的表結構。

一對多建立表結構：

 1 from sqlalchemy.ext.declarative import declarative_base
 2 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
 3 from sqlalchemy.orm import sessionmaker, relationship
 4 from sqlalchemy import create_engine
 5 
 6 engine = create_engine("mysql+pymysql://root:@192.168.1.105:3306/homework", max_overflow=5)#建立數據庫引擎，經過鏈接池獲取數據庫的鏈接。默認值是5.
 7 
 8 Base = declarative_base() #自定義的類聲明sqlorm基類。
 9 class Favor(Base):
10     __tablename__ = 'favor'#表名字。
11     nid = Column(Integer, primary_key=True)#設置列的屬性：整型，主鍵。
12     caption = Column(String(50), default='red', unique=True)#設置默認值。並設置惟一性約束。此列能夠爲空可是不能不能重複值。主鍵不能夠爲空。
13 
14     def __repr__(self):
15         return "%s-%s" %(self.nid, self.caption)###這個是什麼意思？
16 
17 class Person(Base):
18     __tablename__ = 'person'
19     nid = Column(Integer, primary_key=True)
20     name = Column(String(32), index=True, nullable=True)#該列爲索引列，能夠爲null。
21     favor_id = Column(Integer, ForeignKey("favor.nid"))
22     # 與生成表結構無關，僅用於查詢方便
23     favor = relationship("Favor", backref='pers')
24 Base.metadata.create_all(engine)#執行咱們類中定義的表結構。

 多對多：

 1 from sqlalchemy.ext.declarative import declarative_base
 2 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
 3 from sqlalchemy.orm import sessionmaker, relationship
 4 from sqlalchemy import create_engine
 5 
 6 engine = create_engine("mysql+pymysql://root:@192.168.1.105:3306/homework", max_overflow=5)#建立數據庫引擎，經過鏈接池獲取數據庫的鏈接。默認值是5.
 7 
 8 Base = declarative_base()#爲自定義的類聲明sqlorm基類。
 9 class Group(Base):
10     __tablename__ = 'group'
11     id = Column(Integer, primary_key=True)
12     name = Column(String(64), unique=True, nullable=False)#惟一性約束、不能爲空。惟一性約束的列值能夠爲空，可是這裏設置：nullable=False  不能爲空。
13     port = Column(Integer, default=22)#設置列的默認值以及數據類型。
14 
15 
16 class Server(Base):
17     __tablename__ = 'server'
18 
19     id = Column(Integer, primary_key=True, autoincrement=True)#設置一個整型自增的主鍵。
20     hostname = Column(String(64), unique=True, nullable=False)#設置惟一性約束，不爲null。
21 
22 
23 class ServerToGroup(Base):
24     __tablename__ = 'servertogroup'
25     nid = Column(Integer, primary_key=True, autoincrement=True)
26     server_id = Column(Integer, ForeignKey('server.id'))#和sever的id列設置外鍵。
27     group_id = Column(Integer, ForeignKey('group.id'))#和group的表的id列設置外鍵。
28 Base.metadata.create_all(engine)#執行Base咱們定義的子類。

ORM只能建立全部表和刪除全部表，須要修改表結構，須要藉助第三方模塊。 刪除表：Base.metadata.drop_all(engine)

經過SQLALchemy對錶進行增、刪、改、查操做。

表裏增長數據：使用 add和addall方法進行

增（insert）：

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
 5 from sqlalchemy.orm import sessionmaker, relationship
 6 from sqlalchemy import create_engine
 7 
 8 engine = create_engine("mysql+pymysql://root:@192.168.1.105:3306/homework", max_overflow=5,echo=True)
 9 
10 Base = declarative_base()
11 
12 # 建立單表
13 class Users(Base):
14     __tablename__ = 'users'#建立表名字。
15     id = Column(Integer, primary_key=True)#主鍵。
16     name = Column(String(32))
17     extra = Column(String(16))
18 
19     __table_args__ = (
20     UniqueConstraint('id', 'name', name='uix_id_name'),
21         Index('ix_id_name', 'name', 'extra'),
22     )#建立聯合索引。
23 if __name__ == '__main__':
24     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
25     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話的類。
26     session=Session_cls()#建立會話類的對象,能夠把他當作數據庫當前鏈接。
27     obj=Users(name="ack",extra="beautifiul girl")#插入數據。
28     session.add(obj)#調用會話對象的add方法添咱們項插入的字段。
29     #session.rollback()#回滾，只要沒提交，就能夠回滾。
30     session.commit()#提交。
31 
32 mysql> select * from users;
33 +----+------+-----------------+
34 | id | name | extra           |
35 +----+------+-----------------+
36 |  1 | ack  | beautifiul girl |
37 +----+------+-----------------+
38 1 row in set (0.00 sec)

 

添加多條數據：add_all內部是for循環咱們傳入元組的多個數據，調用add方法插入數據庫的。

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
 5 from sqlalchemy.orm import sessionmaker, relationship
 6 from sqlalchemy import create_engine
 7 
 8 engine = create_engine("mysql+pymysql://root:@192.168.1.105:3306/homework", max_overflow=5,echo=True)
 9 
10 Base = declarative_base()
11 
12 # 建立單表
13 class Users(Base):
14     __tablename__ = 'users'#建立表名字。
15     id = Column(Integer, primary_key=True)#主鍵。
16     name = Column(String(32))
17     extra = Column(String(16))
18 
19     __table_args__ = (
20     UniqueConstraint('id', 'name', name='uix_id_name'),
21         Index('ix_id_name', 'name', 'extra'),
22     )#建立聯合索引。
23 if __name__ == '__main__':
24     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
25     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話類。
26     session=Session_cls()#建立會話類的對象,能夠把他當作數據庫當前鏈接。
27     obj=Users(name="evil",extra="handsome man")#建立咱們構建表的類對象。
28     obj_2=Users(name="tom",extra="brave man")#建立咱們構建表的類對象。
29     obj_3=Users(name="jack",extra="diaosi ")#建立咱們構建表的類對象。
30     session.add_all((obj,
31                     obj_2,
32                     obj_3
33                      ))#調用會話對象的ad_dall方法添咱們項插入的字段。
34     #session.rollback()#回滾，只要沒提交，就能夠回滾。
35     session.commit()#提交。
36 
37 
38 mysql> select * from users;
39 +----+------+-----------------+
40 | id | name | extra           |
41 +----+------+-----------------+
42 |  1 | ack  | beautifiul girl |
43 |  2 | evil | handsome man    |
44 |  3 | tom  | brave man       |
45 |  4 | jack | diaosi          |
46 +----+------+-----------------+
47 4 rows in set (0.00 sec)

 

刪(delete)：形式：query(classname).filer(condition).delete()

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
 5 from sqlalchemy.orm import sessionmaker, relationship
 6 from sqlalchemy import create_engine
 7 
 8 engine = create_engine("mysql+pymysql://root:@192.168.1.105:3306/homework", max_overflow=5,echo=True)
 9 
10 Base = declarative_base()
11 
12 # 建立單表
13 class Users(Base):
14     __tablename__ = 'users'#建立表名字。
15     id = Column(Integer, primary_key=True)#主鍵。
16     name = Column(String(32))
17     extra = Column(String(16))
18 
19     __table_args__ = (
20     UniqueConstraint('id', 'name', name='uix_id_name'),
21         Index('ix_id_name', 'name', 'extra'),
22     )#建立聯合索引。
23 if __name__ == '__main__':
24     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
25     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話類。
26     session=Session_cls()#建立會話類的對象，能夠理解當前數據庫鏈接。
27     session.query(Users).filter(Users.name=="jack").delete()#刪除name=jack的行。
28     #session.rollback()#回滾，只要沒提交，就能夠回滾。
29     session.commit()#提交。
30 mysql> select * from users;
31 +----+------+-----------------+
32 | id | name | extra           |
33 +----+------+-----------------+
34 |  1 | ack  | beautifiul girl |
35 | 21 | tom  | brave man       |
36 | 20 | evil | handsome man    |
37 +----+------+-----------------+
38 3 rows in set (0.00 sec)

 

刪除id>20的列：

 1 if __name__ == '__main__':
 2     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
 3     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話類。
 4     session=Session_cls()#建立會話類的對象。
 5     session.query(Users).filter(Users.id >20).delete()
 6     #session.rollback()#回滾，只要沒提交，就能夠回滾。
 7     session.commit()#提交。
 8 mysql> select * from users;
 9 +----+------+-----------------+
10 | id | name | extra           |
11 +----+------+-----------------+
12 |  1 | ack  | beautifiul girl |
13 | 20 | evil | handsome man    |
14 +----+------+-----------------+
15 2 rows in set (0.00 sec)

 

若是知足多個條件的時候，條件之間用逗號（，）隔開，而不是用and。還須要注意的是：條件判斷的時候（filter）是python語言操做對象仍是直接列的操做。列操做（django）是=而python對象操做相等須要==

錯誤的寫法：

1     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
2     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話類。
3     session=Session_cls()#建立會話類的對象。
4     session.query(Users).filter(Users.name=="tom" and Users.id ==30).delete()
5     #session.rollback()#回滾，只要沒提交，就能夠回滾。
6     session.commit()#提交。

 

這樣SQLALchemy只刪除符合 User.name=="tom" 條件的數據。後面的id=30沒有生效。

正確的寫法：

1     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
2     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話類。
3     session=Session_cls()#建立會話類的對象。
4     session.query(Users).filter(Users.name=="tom" , Users.id ==30).delete()#多個條件刪除用逗號隔開。
5     #session.rollback()#回滾，只要沒提交，就能夠回滾。
6     session.commit()#提交。

 

改(update)：

用：session.query(類名).filter(條件).update({"列名":"值"})注意這個是字典。或者：session.query(類名).filter(條件).update({類名.列名:"值"})

 1 #沒修改以前：
 2 mysql> select * from users;
 3 +----+------+-----------------+
 4 | id | name | extra           |
 5 +----+------+-----------------+
 6 |  1 | ack  | beautifiul girl |
 7 | 24 | test | brave man       |
 8 | 27 | test | brave man       |
 9 +----+------+-----------------+
10 #用：session.query(對象名).filter(條件).update({"列名":"值"})注意這個是字典。
11 
12 #!/usr/bin/env python
13 # -*- coding:utf-8 -*-
14 from sqlalchemy.ext.declarative import declarative_base
15 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
16 from sqlalchemy.orm import sessionmaker, relationship
17 from sqlalchemy import create_engine
18 
19 engine = create_engine("mysql+pymysql://root:@192.168.1.105:3306/homework", max_overflow=5,echo=True)
20 
21 Base = declarative_base()
22 
23 # 建立單表
24 class Users(Base):
25     __tablename__ = 'users'#建立表名字。
26     id = Column(Integer, primary_key=True)#主鍵。
27     name = Column(String(32))
28     extra = Column(String(16))
29 
30     __table_args__ = (
31     UniqueConstraint('id', 'name', name='uix_id_name'),
32         Index('ix_id_name', 'name', 'extra'),
33     )#建立聯合索引。
34 if __name__ == '__main__':
35     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
36     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話類。
37     session=Session_cls()#建立會話類的對象。
38     session.query(Users).filter(Users.id > 24).update({"name":"co"})#更新。
39     #session.rollback()#回滾，只要沒提交，就能夠回滾。
40     session.commit()#提交。
41 
42 mysql> select * from users;
43 +----+------+-----------------+
44 | id | name | extra           |
45 +----+------+-----------------+
46 |  1 | ack  | beautifiul girl |
47 | 24 | test | brave man       |
48 | 27 | co   | brave man       |
49 +----+------+-----------------+
50 3 rows in set (0.00 sec)

 

session.query(類名).filter(條件).update({類名.列名:"值"})我比較喜歡第2種。

 

1 if __name__ == '__main__':
2     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
3     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話類。
4     session=Session_cls()#建立會話類的對象。
5     session.query(Users).filter(Users.id > 24).update({Users.name:"cc"})
6     #session.rollback()#回滾，只要沒提交，就能夠回滾。
7     session.commit()#提交。

 

在數據後面添加數據。query(Users).filter(condition).update({classname.coulmnname:classname.coulmnname+"add data",},synchronize_session=False)

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
 5 from sqlalchemy.orm import sessionmaker, relationship
 6 from sqlalchemy import create_engine
 7 
 8 engine = create_engine("mysql+pymysql://root:@192.168.1.105:3306/homework", max_overflow=5,echo=True)
 9 
10 Base = declarative_base()
11 
12 # 建立單表
13 class Users(Base):
14     __tablename__ = 'users'#建立表名字。
15     id = Column(Integer, primary_key=True)#主鍵。
16     name = Column(String(32))
17     extra = Column(String(16))
18 
19     __table_args__ = (
20     UniqueConstraint('id', 'name', name='uix_id_name'),
21         Index('ix_id_name', 'name', 'extra'),
22     )#建立聯合索引。
23 if __name__ == '__main__':
24     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
25     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話類。
26     session=Session_cls()#建立會話類的對象。
27     session.query(Users).filter(Users.id > 20).update({Users.name:Users.name+"good",},synchronize_session=False)#更改id>20的字段。
28     #session.rollback()#回滾，只要沒提交，就能夠回滾。
29     session.commit()#提交。
30 
31 mysql> select * from users;
32 +----+----------+-----------------+
33 | id | name     | extra           |
34 +----+----------+-----------------+
35 |  1 | ack      | beautifiul girl |
36 | 24 | testgood | brave man       |
37 | 27 | ccgood   | brave man       |
38 +----+----------+-----------------+
39 3 rows in set (0.00 sec)

 

notice：synchronize_session=False：這個不一樣步會話，若是會話過時的時候，數據庫這個字段依然是舊值。防止數據的混亂。

相應的數據進行計算：好比：query(Users).filter(Users.id > 20).update({Users.id:Users.id+100,},synchronize_session="evaluate")

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
 5 from sqlalchemy.orm import sessionmaker, relationship
 6 from sqlalchemy import create_engine
 7 
 8 engine = create_engine("mysql+pymysql://root:@192.168.1.105:3306/homework", max_overflow=5,echo=True)
 9 
10 Base = declarative_base()
11 
12 # 建立單表
13 class Users(Base):
14     __tablename__ = 'users'#建立表名字。
15     id = Column(Integer, primary_key=True)#主鍵。
16     name = Column(String(32))
17     extra = Column(String(16))
18 
19     __table_args__ = (
20     UniqueConstraint('id', 'name', name='uix_id_name'),
21         Index('ix_id_name', 'name', 'extra'),
22     )#建立聯合索引。
23 if __name__ == '__main__':
24     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
25     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話類。
26     session=Session_cls()#建立會話類的對象。
27     session.query(Users).filter(Users.id > 20).update({Users.id:Users.id+100,},synchronize_session="evaluate")#id列進行計算。
28     #session.rollback()#回滾，只要沒提交，就能夠回滾。
29     session.commit()#提交。
30 
31 
32 mysql> select * from users;
33 +-----+----------+-----------------+
34 | id  | name     | extra           |
35 +-----+----------+-----------------+
36 |   1 | ack      | beautifiul girl |
37 | 124 | testgood | brave man       |
38 | 127 | ccgood   | brave man       |
39 +-----+----------+-----------------+
40 3 rows in set (0.00 sec)

 

查（query）：

查詢表全部的數據。

注意res=session.query(Users).all()，res返回時User類的對象列表。想獲取相應的結果能夠用for循環獲取。

 1 #!/usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
 5 from sqlalchemy.orm import sessionmaker, relationship
 6 from sqlalchemy import create_engine
 7 
 8 engine = create_engine("mysql+pymysql://root:@192.168.1.105:3306/homework", max_overflow=5)
 9 
10 Base = declarative_base()
11 
12 # 建立單表
13 class Users(Base):
14     __tablename__ = 'users'#建立表名字。
15     id = Column(Integer, primary_key=True)#主鍵。
16     name = Column(String(32))
17     extra = Column(String(16))
18 
19     __table_args__ = (
20     UniqueConstraint('id', 'name', name='uix_id_name'),
21         Index('ix_id_name', 'name', 'extra'),
22     )#建立聯合索引。
23 if __name__ == '__main__':
24     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
25     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話類。
26     session=Session_cls()#建立會話類的對象。
27     res=session.query(Users).all()#獲取的是User對象的列表，須要for循環相應的字段。
28     for i in res:
29         print(i.name,i.extra)
30     #session.rollback()#回滾，只要沒提交，就能夠回滾。
31     session.commit()#提交。
32 ack beautifiul girl
33 testgood brave man
34 ccgood brave man

 

若是不清楚執行的代碼轉換什麼sql語句。能夠用：

1     res=session.query(Users).all()
2     q=session.query(Users)#不加all()
3     print(q)
4     SELECT users.id AS users_id, users.name AS users_name, users.extra AS users_extra 
5 FROM users

 

查找具體的列：res=session.query(Users.name).all()

 1 if __name__ == '__main__':
 2     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
 3     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話類。
 4     session=Session_cls()#建立會話類的對象。
 5     res=session.query(Users.name).all()
 6     for i in res:
 7         print(i.name)
 8     #session.rollback()#回滾，只要沒提交，就能夠回滾。
 9     session.commit()#提交。
10 ack
11 testgood
12 ccgood

 

查找全部符合的條件的列： res=session.query(Users).filter_by(name="tom").all()

 1 if __name__ == '__main__':
 2     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
 3     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話類。
 4     session=Session_cls()#建立會話類的對象。
 5     res=session.query(Users).filter_by(name="tom").all()
 6     for i in res:
 7         print(i.name,i.extra)
 8     #session.rollback()#回滾，只要沒提交，就能夠回滾。
 9     session.commit()#提交。
10     tom brave man
11     tom brave man

 

查找全部符合條件的數據中的第一列數據：注意返回的不是列表。單個對象。res=session.query(Users).filter_by(name="tom").first()

 1 if __name__ == '__main__':
 2     Base.metadata.create_all(engine)##調用咱們定義類並建立相應的表結構。
 3     Session_cls=sessionmaker(bind=engine)#首先綁定咱們建立的engine與會話（session）關聯。並建立鏈接數據庫會話類。
 4     session=Session_cls()#建立會話類的對象。
 5     res=session.query(Users).filter_by(name="tom").first()
 6     print(res)
 7     # for i in res:
 8     print(res.name,res.extra)
 9     #session.rollback()#回滾，只要沒提交，就能夠回滾。
10     session.commit()#提交。
11    <__main__.Users object at 0x033FB910>
12    tom brave man

其餘的操做：

 1 #　條件
 2 ret = session.query(Users).filter_by(name='alex').all()
 3 ret = session.query(Users).filter(Users.id > 1, Users.name == 'eric').all()
 4 ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'eric').all()
 5 ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
 6 ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
 7 ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='eric'))).all()
 8 from sqlalchemy import and_, or_
 9 ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'eric')).all()
10 ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'eric')).all()
11 ret = session.query(Users).filter(
12     or_(
13         Users.id < 2,
14         and_(Users.name == 'eric', Users.id > 3),
15         Users.extra != ""
16     )).all()
17 
18 
19 # 通配符
20 ret = session.query(Users).filter(Users.name.like('e%')).all()
21 ret = session.query(Users).filter(~Users.name.like('e%')).all()
22 
23 # 限制
24 ret = session.query(Users)[1:2]
25 
26 # 排序
27 ret = session.query(Users).order_by(Users.name.desc()).all()
28 ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()
29 
30 # 分組
31 from sqlalchemy.sql import func
32 
33 ret = session.query(Users).group_by(Users.extra).all()
34 ret = session.query(
35     func.max(Users.id),
36     func.sum(Users.id),
37     func.min(Users.id)).group_by(Users.name).all()
38 
39 ret = session.query(
40     func.max(Users.id),
41     func.sum(Users.id),
42     func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()
43 
44 # 連表
45 
46 ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()
47 
48 ret = session.query(Person).join(Favor).all()
49 
50 ret = session.query(Person).join(Favor, isouter=True).all()
51 
52 
53 # 組合
54 q1 = session.query(Users.name).filter(Users.id > 2)
55 q2 = session.query(Favor.caption).filter(Favor.nid < 2)
56 ret = q1.union(q2).all()
57 
58 q1 = session.query(Users.name).filter(Users.id > 2)
59 q2 = session.query(Favor.caption).filter(Favor.nid < 2)
60 ret = q1.union_all(q2).all()

 更多功能參見文檔，猛擊這裏下載PDF！