【Python之路Day13】網絡篇之MySQL、ORM框架

MySQL

一. 概述

什麼是數據庫？

數據庫能夠理解成保存有組織數據的容器（一般是一個文件或一組文件），不少時候咱們所說的數據庫就是咱們使用的數據庫軟件（專業點就是數據庫管理系統DBMS），咱們並非直接訪問數據庫而是使用數據庫軟件，它爲咱們訪問數據庫。

什麼是數據表?

數據表就是咱們要存放數據的東西，就像一個圖書館裏的書架同樣，並非隨便堆到裏面就完事了，有人要借書，你須要根據目錄(數據庫裏爲索引)很快的找到書在哪排那層哪一個位置，從而快速的取出要借的書。

什麼是RDBMS？

RDBMS即關係數據庫管理系統(Relational Database Management System)，是將數據組織爲相關的行和列的系統，而管理關係數據庫的計算機軟件就是關係數據庫管理系統.

有哪些RDBMS？

1. DB2， IBM公司的產品，起源於世界上第一個關係型數據庫System R和System R*。站點：http://www.ibm.com/analytics/us/en/technology/db2/
2. Oracle，米國甲骨文公司生產商用產品，它是在數據庫領域一直處於領先地位的產品。站點：http://www.oracle.com/cn/database/overview/index.html
3. PostgreSQL，Berkeley開發，徹底由社區驅動的開源項目，由全世界超過1000名貢獻者所維護。PostgreSQL標榜本身是世界上最早進的開源數據庫。不過也確實很牛逼，選擇什麼主要看怎麼取捨了。InfoQ這裏有一片文章是MySQL和PostgreSQL的一個對比和分析，點我.  PostgreSQL官方站點：https://www.postgresql.org/。
4. MySQL，開源的一款RDBMS，如今米國甲骨文公司旗下，分社區版和企業版，通常咱們使用的都是社區版。官方站點：http://www.mysql.com/
5. SQL Server，Microsoft的一款商用RDBMS，官方站點：https://www.microsoft.com/zh-cn/server-cloud/products/sql-server/
6. Percona：MySQL優化版，性能更強。官方站點：https://www.percona.com
7. Sybase，Infomix，MariaDB等等...

RDBMS的相關術語？

• 數據庫（Database）：數據庫是帶有相關數據的表的集合。
• 表（Table）：表是帶有數據的矩陣。數據庫中的表就像一種簡單的電子表格。
• 列（Column）：每一列（數據元素）都包含着同種類型的數據，好比郵編。
• 行（Row）：行（又被稱爲元組、項或記錄）是一組相關數據，好比有關訂閱量的數據。
• 冗餘（Redundancy）：存儲兩次數據，以便使系統更快速。
• 主鍵（Primary Key）：主鍵是惟一的。同一張表中不容許出現一樣兩個鍵值。一個鍵值只對應着一行。
• 外鍵（Foreign Key）：用於鏈接兩張表。
• 複合鍵（Compound Key）：複合鍵（又稱組合鍵）是一種由多列組成的鍵，由於一列並不足以肯定惟一性。
• 索引（Index）：它在數據庫中的做用就像書後的索引同樣。
• 引用完整性（Referential Integrity）：用來確保外鍵一直指向已存在的一行。

什麼是SQL?

SQL：Structure Query Language，結構化查詢語言，是一種專門用來與數據庫通訊的語言。遵循的標準主要有：

• SQL-86
• SQL-89
• SQL-92
• SQL-03
• SQL-08

SQL語句分類

Data defination language（DDL）：

• CREATE --在數據庫中建立對象
• ALTER ---修改數據庫結構
• DROP ---刪除對象
• RENAME --- 重命名對象

Data Manipulation language（DML）

• SELECT --- 獲取數據
• INSERT --- 向表中插入數據
• UPDATE --- 更新表中已有數據
• DELETE --- 刪除表中的數據

Data Control Language(DCL)

• GRANT --- 賦予一個用戶對數據庫或者數據表格等制定權限
• REVOKE --- 刪除一個用戶對數據庫或者表哥的制定權限

Transaction Control Language（TCL）

• COMMIT --- 保存數據操做
• SAVEPOINT --- 爲方便Roolback標記一個事務點
• ROOLBACK --- 從最後一次COMMIT中恢復到提交前的狀態

二. 安裝MySQL

安裝MySQL有好多種方式：

• 使用平臺包管理器安裝， 如apt-get ，yum等
• 下載源碼編譯安裝
• 下載通用二進制包安裝
• ...

包管理器安裝：

#debian/Ubuntu
apt-get install mysql-server -y

#RHEL
yum install mysql-server -y

...

源碼安裝(RHEL平臺，其餘平臺大同小異)，此處版本是5.5.28，能夠下載最新的，大同小異。

cmake的重要特性之一是其獨立於源碼（out-of-source）的編譯功能，即編譯工做能夠在另外一個指定的目錄中而非源碼目錄中進行，這能夠保證源碼目錄不受任何一次編譯的影響，所以在同一個源碼樹上能夠進行屢次不一樣的編譯，如針對不一樣平臺編譯。

1.安裝跨平臺編譯器,cmake：
  tar xv cmake-3.2.1.tar.gz
  cd cmake-3.2.1
  ./bootstrap
  make
  make install

2.編譯安裝mysql-5.5.28
  1.使用cmake編譯mysql-5.5
  cmake指定編譯選項的方式不一樣於make，其實現方式對好比下：
  ./configure   至關於  cmake .
  ./configura --help   至關於    cmake . -LH or   ccmake .

  指定安裝文件的安裝路徑時經常使用的選項：
  -DCMAKE_INSTALL_PREFIX=/usr/local/mysql
  -DMYSQL_DATADIR=/data/mysql
  -DSYSCONFDIR=/etc

  默認編譯的存儲引擎包括：csv、myisam、myisammrg和heap。如要安裝其餘存儲引擎，可使用相似以下的選項：
  -DWITH_INNOBASE_STORAGE_ENGINE=1
  -DWITH_ARCHIVE_STORAGE_ENGINE=1
  -DWITH_BLACKHOLE_STORAGE_ENGINE=1
  -DWITH_FEDERATED_STORAGE_ENGINE=1

  若要明確指定不編譯某存儲引擎，但是使用相似以下的選項:
  -DWITHOUT_<ENGINE>_STORAGE_ENGINE=1
  如：
  -DWITHOUT_EXAMPLE_STORAGE_ENGINE=1
  -DWITHOUT_FEDERATED_STORAGE_ENGINE=1

  如要編譯其餘功能，如SSL等，則可使用以下選項來實現編譯時使用某庫或不使用某庫：
  -DWITH_READLINE=1
  -DWITH_SSL=system
  -DWITH_ZLIB=system
  -DWITH_LIBWRAP=0

  其餘經常使用的選項：
  -DMYSQL_TCP_PORT=3306
  -DMYSQL_UNIX_ADDR=/tmp/mysql.sock
  -DENABLED_LOCAL_INFILE=1
  -DEXTRA_CHARSETS=all
  -DDEFAULT_CHARSET=utf8
  -DDEFAULT_COLLATION=utf8_general_ci
  -DWITH_DEBUG=0
  -DENABLE_PROFILING=1

安裝Mysql：
  建立用戶：
    groupadd -r mysql
    useradd -r -g mysql -M -s /sbin/nologin mysql
  編譯：
    cmake . -DCMAKE_INSTALL_PREFIX=/usr/local/mysql \
    -DMYSQL_DATADIR=/mydata/data -DSYSCONFDIR=/etc \
    -DWITH_INNOBASE_STORAGE_ENGINE=1  \
    -DWITH_ARCHIVE_STORAGE_ENGINE=1 \
    -DWITH_BLACKHOLE_STORAGE_ENGINE=1 \
    -DWITH_READLINE=1 \
    -DWITH_SSL=system \
    -DWITH_ZLIB=system \
    -DWITH_LIBWRAP=0 \
    -DMYSQL_UNIX_ADDR=/tmp/mysql.sock \
    -DDEFAULT_CHARSET=utf8 \
    -DDEFAULT_COLLATION=utf8_general_ci
    make 
    make install
  建立數據目錄:
    mkdir -pv /mydata/data && chown mysql /mydata/data
  初始化數據庫:
    cd /usr/local/mysql
    chown mysql:mysql -R /usr/local/mysql
    scripts/mysql_install_db  --user=mysql --datadir=/mydata/data
  拷貝文件:
     cp support-files/my-huge.cnf /etc/my.cnf 
     cp support-files/mysql.server /etc/init.d/mysqld
  添加環境變量：
    vi /etc/profile.d/mysql.sh 
      export PATH=$PATH:/usr/local/mysql/bin
    source /etc/profile.d/mysql.sh
  添加man手冊：
    vi /etc/man.config 
     添加：
      MANPATH /usr/local/mysql/man
  添加庫文件到系統：
    vi /etc/ld.so.conf.d/mysql.conf
      添加：
        /usr/local/mysql/lib
      執行：
        ldconfig -v /etc/ld.so.conf.d/mysql.conf
  添加到自啓動：
    chkconfig --add mysqld

cmake編譯安裝5.5.28

通用二進制包安裝：

===一、準備數據存放的文件系統===
這裏假設其數據盤的目錄爲/data/mysql，然後須要建立/data/mysql目錄作爲mysql數據的存放目錄。

===二、新建用戶以安全方式運行進程：===

# groupadd -r mysql
# useradd -g mysql -r -s /sbin/nologin -M  mysql
# mkdir /data/mysql
# chown -R mysql:mysql /data/mysql

===三、安裝並初始化mysql-5.6.26===
# cd /usr/local/src && tar xf mysql-5.6.26-linux-glibc2.5-x86_64.tar.gz -C /usr/local && cd /usr/local/
# mv mysql-5.6.26-linux-glibc2.5-x86_64  mysql && cd mysql 


# chown -R mysql:mysql  .
# yum install libaio-devel -y      #安裝依賴包
# scripts/mysql_install_db --user=mysql --basedir=/usr/local/mysql --datadir=/data/mysql
# chown -R root  .  

===四、爲mysql提供主配置文件：===

# vi  /etc/my.cnf    #貼入下面內容：

# For advice on how to change settings please see
# http://dev.mysql.com/doc/refman/5.6/en/server-configuration-defaults.html
# *** DO NOT EDIT THIS FILE. It's a template which will be copied to the
# *** default location during install, and will be replaced if you
# *** upgrade to a newer version of MySQL.

[mysqld]

# Remove leading # and set to the amount of RAM for the most important data
# cache in MySQL. Start at 70% of total RAM for dedicated server, else 10%.
# innodb_buffer_pool_size = 128M

# Remove leading # to turn on a very important data integrity option: logging
# changes to the binary log between backups.
# log_bin

# These are commonly set, remove the # and set as required.
# basedir = .....
# datadir = .....
# port = .....
# server_id = .....
# socket = .....

# Remove leading # to set options mainly useful for reporting servers.
# The server defaults are faster for transactions and fast SELECTs.
# Adjust sizes as needed, experiment to find the optimal values.
# join_buffer_size = 128M
# sort_buffer_size = 2M
# read_rnd_buffer_size = 2M 

#sql_mode=NO_ENGINE_SUBSTITUTION,STRICT_TRANS_TABLES 
basedir = /usr/local/mysql
datadir = /data/mysql
socket = /data/mysql/mysql.sock

character-set-server=utf8mb4
collation-server=utf8mb4_general_ci

back_log = 600   
max_connections = 3000   
max_connect_errors = 500   
#table_cache = 614  
#
#
#external-locking = FALSE  
max_allowed_packet = 32M  
#
sort_buffer_size = 2M  
join_buffer_size = 2M   
#
thread_cache_size = 300   
thread_concurrency = 8   
query_cache_size = 64M   
query_cache_limit = 4M    
#query_cache_min_res_unit = 2k    
default-storage-engine = InnoDB
#
thread_stack = 192K  
#
transaction_isolation = READ-COMMITTED   
#
tmp_table_size = 256M   
max_heap_table_size = 256M
long_query_time = 1
slow_query_log = 1
slow_query_log_file=/data/mysql/slow-log.log
#log-slow-queries=/data/mysql/slow-log.log
binlog_cache_size = 4M
max_binlog_cache_size = 8M
max_binlog_size = 100M
expire_logs_days = 10
key_buffer_size = 2048M 
read_buffer_size = 1M  
read_rnd_buffer_size = 16M   
bulk_insert_buffer_size = 64M   
#myisam_sort_buffer_size = 128M   
#myisam_max_sort_file_size = 10G   
#myisam_max_extra_sort_file_size = 10G
#myisam_repair_threads = 1   
#myisam_recover   
skip-name-resolve
lower_case_table_names = 1
server-id = 1

innodb_additional_mem_pool_size = 16M   
innodb_buffer_pool_size = 2G    
innodb_file_io_threads = 4   
innodb_thread_concurrency = 8   
innodb_flush_log_at_trx_commit = 2   
innodb_log_buffer_size = 16M  
innodb_log_file_size = 128M   
innodb_log_files_in_group = 3   
innodb_max_dirty_pages_pct = 90   
innodb_lock_wait_timeout = 120   
innodb_file_per_table = 1  

[mysql]
default-character-set = utf8mb4

[client]
default-character-set = utf8mb4
socket = /data/mysql/mysql.sock



===五、爲mysql提供sysv服務腳本：===

# cd /usr/local/mysql
# cp support-files/mysql.server  /etc/rc.d/init.d/mysqld 

===6. 添加至服務列表：===
# chkconfig --add mysqld && chkconfig mysqld on

然後就能夠啓動服務測試使用了。
爲了使用mysql的安裝符合系統使用規範，並將其開發組件導出給系統使用，這裏還須要進行以下步驟：

===七、輸出mysql的man手冊至man命令的查找路徑：===
# yum install man -y 
# sed -i '48 s@^@MANPATH /usr/local/mysql/man @'  /etc/man.config

===八、輸出mysql的頭文件至系統頭文件路徑/usr/include：===

這能夠經過簡單的建立連接實現：
# ln -sv /usr/local/mysql/include  /usr/include/mysql

===九、輸出mysql的庫文件給系統庫查找路徑：===

# echo '/usr/local/mysql/lib' > /etc/ld.so.conf.d/mysql.conf

然後讓系統從新載入系統庫：
# ldconfig -v

===十、修改PATH環境變量，讓系統能夠直接使用mysql的相關命令。具體實現過程這裏再也不給出。===
# vim /etc/profile.d/mysql.sh
export PATH=/usr/local/mysql/bin:$PATH
# . /etc/profile.d/mysql.sh

===11. 啓動MySQL服務：===
# service mysqld start

通用二進制包安裝5.6.26

想要使用MySQL來存儲並操做數據，則須要作幾件事情：
　　a. 安裝MySQL服務端
　　b. 安裝MySQL客戶端 (安裝完服務器端，默認都帶有客戶端工具，安裝過程略...)
　　b. 【客戶端】鏈接【服務端】
　　c. 【客戶端】發送命令給【服務端MySQL】服務的接受命令並執行相應操做(增刪改查等)

三. 數據庫操做：

1. 顯示全部數據庫：

SHOW DATABASES;


#默認數據庫：
#　　mysql - 用戶權限相關數據
#　　test - 用於用戶測試數據
#　　information_schema - MySQL自己架構相關數據

2. 使用/進入數據庫

USE db_name;

3. 顯示庫的的全部表

SHOW TABLES;

4. 受權管理

用戶管理：

建立用戶
    create user '用戶名'@'IP地址' identified by '密碼';
刪除用戶
    drop user '用戶名'@'IP地址';
修改用戶
    rename user '用戶名'@'IP地址'; to '新用戶名'@'IP地址';;
修改密碼
    set password for '用戶名'@'IP地址' = Password('新密碼')
 
PS：用戶權限相關數據保存在mysql數據庫的user表中，因此也能夠直接對其進行操做（不建議）

受權管理：

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

all privileges  除grant外的全部權限
            select          僅查權限
            select,insert   查和插入權限
            ...
            usage                   無訪問權限
            alter                   使用alter table
            alter routine           使用alter procedure和drop procedure
            create                  使用create table
            create routine          使用create procedure
            create temporary tables 使用create temporary tables
            create user             使用create user、drop user、rename user和revoke  all privileges
            create view             使用create view
            delete                  使用delete
            drop                    使用drop table
            execute                 使用call和存儲過程
            file                    使用select into outfile 和 load data infile
            grant option            使用grant 和 revoke
            index                   使用index
            insert                  使用insert
            lock tables             使用lock table
            process                 使用show full processlist
            select                  使用select
            show databases          使用show databases
            show view               使用show view
            update                  使用update
            reload                  使用flush
            shutdown                使用mysqladmin shutdown(關閉MySQL)
            super                   􏱂􏰈使用change master、kill、logs、purge、master和set global。還容許mysqladmin􏵗􏵘􏲊􏲋調試登錄
            replication client      服務器位置的訪問
            replication slave       由複製從屬使用

對於權限

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

對於數據庫

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

對於用戶和IP

grant all privileges on db1.tb1 TO '用戶名'@'IP'

            grant select on db1.* TO '用戶名'@'IP'

            grant select,insert on *.* TO '用戶名'@'IP'

            revoke select on db1.tb1 from '用戶名'@'IP'

示例

四. 表操做

一、建立表

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

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

是否能夠爲空？

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

默認值

自增，若是爲某列設置自增列，插入數據時無需設置此列，默認將自增（表中只能有一個自增列）
            create table tb1(
                nid int not null auto_increment primary key,
                num int null
            )
            或
            create table tb1(
                nid int not null auto_increment,
                num int null,
                index(nid)
            )
            #注意：一、對於自增列，必須是索引（含主鍵）。
                 2、對於自增能夠設置步長和起始值
                     show session variables like 'auto_inc%';
                     set session auto_increment_increment=2;
                     set session auto_increment_offset=10;

                     shwo global  variables like 'auto_inc%';
                     set global auto_increment_increment=2;
                     set global auto_increment_offset=10;

自增

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

主鍵

外鍵，一個特殊的索引，只能是指定內容
            creat table color(
                nid int not null primary key,
                name char(16) not null
            )

            create table fruit(
                nid int not null primary key,
                smt char(32) null ,
                color_id int not null,
                constraint fk_cc foreign key (color_id) references color(nid)
            )

外鍵

二、刪除表

drop table tb_name;

三、清空表

delete from tb_name;
truncate table tb_name;


#清空表推薦使用truncate

四、修改表

#添加列：
        ALTER TABLE  表名 ADD 列名 類型;
#刪除列：
        ALTER TABLE  表名 DROP COLUMN 列名;
#修改列：
        ALTER TABLE 表名 MODIFY COLUMN 列名 類型;  -- 類型
        ALTER TABLE 表名 CHANGE 原列名 新列名 類型; -- 列名，類型
 
#添加主鍵：
        ALTER TABLE 表名 ADD PRIMARY KEY(列名);
#刪除主鍵：
        ALTER TABLE 表名 DROP PRIMARY KEY;
        ALTER TABLE 表名  MODIFY  列名 INT, DRIP PRIMARY KEY; 
 
#添加外鍵：
        ALTER TABLE 從表 ADD CONSTRAINT 外鍵名稱（形如：FK_從表_主表） FOREIGN KEY 從表(外鍵字段) REFERENCES 主表(主鍵字段);
#刪除外鍵：
        ALTER TABLE 表名 DROP FOREIGN KEY 外鍵名稱;
 
#修改默認值：
        ALTER TABLE testalter_tbl ALTER i SET DEFAULT 1000;
#刪除默認值：
        ALTER TABLE testalter_tbl ALTER i DROP DEFAULT; 

五、基本數據類型

數值型；
      精確數值：
        tinyint   a very small integer   1byte
        smallint  a small integer        2byte
        mediumint a medium-sized integer 3byte
        int       a standard integer     4byte
        bigint    a large integer        8byte
        decimal   a fixed-point number

      近似數值：
        float     a single-precision floating-point number  4byte
        double    a double-precision floating-point number  8byte
        bit       a bit field
        real
      auto_increment：自增，設定以後必須知足如下條件:
        非空
        無符號
        必定要建立索引
        經過查看LAST_INSERT_ID內置函數查看上一次自增的值；mysql> SELECT LAST_INSERT_ID();
        前提：
          無符號整型
          必須是primary key或者 Unique key
          必須是Not Null
          unsigned：無符號
    
    字符型；
      定長字符
        char(#) 最大255個字符
        binary(#)（區分大小寫的定長字符）
      變長字符
        varchar(#)，如varchar(3)：最多隻能存儲3個字符，可是佔位4個字符，由於多一個字符串的結束符；
          每個2**8須要一個結束符，也就是若是在255個之內須要1個結束符，若是超過須要2個；最大能夠存儲65535個字符
        tinytext  255
        text  65535，上面索引不能索引整個字段，不區分大小寫
        mediumtext  16777215
        longtext 4294967295個
        以上五種都不區分大小寫；

        varbinary(#)（區分大小寫的可變長字符）
        
        blob（binary large object ）文本大對象，區分大小寫

        Mysql內置數值類型: enum（枚舉型）, set(集合)
        修飾符：
          NOT NULL
          NULL
          DEFAULT
          CHARACTER SET  字符集
          COLLATION 

    日期型；
      date, time, datetime, timestamp（從linux元年開始通過的秒數）, year

基本數據類型

更多>>>

五. 基本操做

這裏主要就是一些DML語句

一、增(INSERT)

insert into 表 (列名,列名...) values (值,值,值...);
insert into 表 (列名,列名...) values (值,值,值...),(值,值,值...);
insert into 表 (列名,列名...) select (列名,列名...) from 表;

2. 刪(DELETE)

        delete from 表
        delete from 表 where id＝1 and name＝'sam'

View Code

3. 改(UPDATE)

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

View Code

4. 查(SELECT)

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

View Code

五、其餘

1、條件
        select * from 表 where id > 1 and name != 'jerry' and num = 12;

        select * from 表 where id between 5 and 16;

        select * from 表 where id in (11,22,33)
        select * from 表 where id not in (11,22,33)
        select * from 表 where id in (select nid from 表)

    2、通配符
        select * from 表 where name like 'jerry%'  - jerry開頭的全部（多個字符串）
        select * from 表 where name like 'jerr_'  - jerr開頭的全部（一個字符）

    3、限制
        select * from 表 limit 5;            - 前5行
        select * from 表 limit 4,5;          - 從第4行開始的5行
        select * from 表 limit 5 offset 4    - 從第4行開始的5行

    4、排序
        select * from 表 order by 列 asc              - 根據 「列」 從小到大排列
        select * from 表 order by 列 desc             - 根據 「列」 從大到小排列
        select * from 表 order by 列1 desc,列2 asc    - 根據 「列1」 從大到小排列，若是相同則按列2從小到大排序

    5、分組
        select num from 表 group by num
        select num,nid from 表 group by num,nid
        select num,nid from 表  where nid > 10 group by num,nid order nid desc
        select num,nid,count(*),sum(score),max(score),min(score) from 表 group by num,nid

        select num from 表 group by num having max(id) > 10

        特別的：group by 必須在where以後，order by以前

    6、連表
        無對應關係則不顯示
        select A.num, A.name, B.name
        from A,B
        Where A.nid = B.nid

        無對應關係則不顯示
        select A.num, A.name, B.name
        from A inner join B
        on A.nid = B.nid

        A表全部顯示，若是B中無對應關係，則值爲null
        select A.num, A.name, B.name
        from A left join B
        on A.nid = B.nid

        B表全部顯示，若是B中無對應關係，則值爲null
        select A.num, A.name, B.name
        from A right join B
        on A.nid = B.nid

    7、組合
        組合，自動處理重合
        select nickname
        from A
        union
        select name
        from B

        組合，不處理重合
        select nickname
        from A
        union all
        select name
        from B

View Code

FROM子句：表示要查詢的關係   表、多個表、其餘SELECT語句；
WHERE子句：布爾關係表達式    
  = 、> 、< 、>= 、<=
  邏輯關係：
    AND
    OR
    NOT
  BETWEEN ... AND ... 
    指定一個運算符要搜索的閉區間
  LIKE ''
    %:任意長度任意字符
    _：任意單個字符
    #: 0~9之間的單一數字
    . [字符列表]  在字符列表中的任一值
    . [! 字符列表] 不在字符列表中的任一值
    . - ：指定字符範圍，兩邊的值分別爲其上限；
  RLIKE或者REGXP 
    支持正則表達式匹配
  IN
    離散取值的時候指定一個IN，在其中選值；
    用於匹配列表中的任何一個值，IN子句能夠代替用OR子句鏈接的一連串的條件。
    IN ()
  IS NULL
  IS NOT NULL

ORDER BY field_name {ASC|DESC}
  查詢結果排序  
  可是數據量太大的話，很是消耗系統資源，所以應該將數據存入磁盤的時候就排好序存放；

AS 
  取個別名能夠給字段起個別名，也能夠對錶起個別名：
  SELECT name AS New_name FROM tb;

LIMIT子句：
  LIMIT [offset,]Count
    Offset：偏移幾個
    count：取幾個
    若是不指定count，取值offset個數
    若是指定count，偏移offset，取值count個

View Code

 

pymysql

pymysql是Python中操做MySQL的模塊，使用方法和MySQLDB幾乎同樣。

一. 安裝

pip3 install pymysql   


#源碼安裝
https://github.com/PyMySQL/PyMySQL

python3 setup.py install

二. 使用

1. 執行SQL語句

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Author: DBQ(Du Baoqiang)

import pymysql   #導入模塊

#建立鏈接
conn = pymysql.connect(
    host='172.16.30.162',   #主機IP
    port=3306,              #端口
    user='tom',             #鏈接數據庫用戶
    password='tom123',      #鏈接密碼
    db='db1'                #鏈接的數據庫名稱
)

#建立遊標
cursor = conn.cursor()

#執行SQL,並返回受影響的行數
effect_row = cursor.execute("UPDATE tb1 SET host='1.1.1.1'")


# 執行SQL，並返回受影響行數
#effect_row = cursor.execute("UPDATE tb1 SET host='1.1.1.2' WHERE id > %s",(1,))

# 執行SQL，並返回受影響行數
#effect_row = cursor.executemany("INSERT INTO tb1(host) VALUES(%s),(%s)", [("1.1.1.11",1),("1.1.1.11",1)])

print(effect_row)
# 提交，否則沒法保存新建或者修改的數據
conn.commit()

# 關閉遊標
cursor.close()

# 關閉鏈接
conn.close()

二、獲取新建立數據自增ID

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Author: DBQ(Du Baoqiang)

import pymysql   #導入模塊

#建立鏈接
conn = pymysql.connect(
    host='172.16.30.162',   #主機IP
    port=3306,              #端口
    user='tom',             #鏈接數據庫用戶
    password='tom123',      #鏈接密碼
    db='db1'                #鏈接的數據庫名稱
)

# #建立遊標
cursor = conn.cursor()

cursor.executemany("INSERT INTO tb1(host,id) VALUES(%s,%s)", [("1.1.1.30",12),("1.1.1.30",13)])
conn.commit()
cursor.close()
conn.close()

new_id = cursor.lastrowid
print(new_id)

三、獲取查詢數據

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Author: DBQ(Du Baoqiang)

import pymysql   #導入模塊

#建立鏈接
conn = pymysql.connect(
    host='172.16.30.162',   #主機IP
    port=3306,              #端口
    user='tom',             #鏈接數據庫用戶
    password='tom123',      #鏈接密碼
    db='db1'                #鏈接的數據庫名稱
)

# #建立遊標
cursor = conn.cursor()

cursor.execute("SELECT * FROM tb1")

#獲取第一行數據
row_1 = cursor.fetchone()

#獲取前N行數據
row_2 = cursor.fetchmany(3)

#獲取全部數據
row_3 = cursor.fetchall()

conn.commit()
cursor.close()
conn.close()

print(row_1)    #遊標的位置會變的，獲取了第一行以後，遊標就到第二行位置了
print(row_2)   #所以打印前三行的時候，是打印的2，3，4
print(row_3)   #同理，打印全部的，其實是當前遊標到最後的位置


#代碼執行結果：
(1, '1.1.1.1')
((2, '1.1.1.2'), (3, '1.1.1.2'), (4, '1.1.1.11'))
((5, '3'), (6, '1.1.1.11'), (7, '3'), (8, '1.1.1.11'), (9, '1'), (10, '1.1.1.11'), (11, '1'), (12, '1.1.1.30'), (13, '1.1.1.30'))

PS:  在fetch數據時按照順序進行，可使用cursor.scoll(num,mode) 來移動遊標位置，以下：

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

#獲取第一行數據
row_1 = cursor.fetchone()

#獲取前N行數據
row_2 = cursor.fetchmany(3)

#獲取全部數據
#先移動遊標
cursor.scroll(0,mode='absolute')   #絕對位置移動
row_3 = cursor.fetchall()

print(row_1)
print(row_2)
print(row_3)

#再次執行的結果：
(1, '1.1.1.1')
((2, '1.1.1.2'), (3, '1.1.1.2'), (4, '1.1.1.11'))
((1, '1.1.1.1'), (2, '1.1.1.2'), (3, '1.1.1.2'), (4, '1.1.1.11'), (5, '3'), (6, '1.1.1.11'), (7, '3'), (8, '1.1.1.11'), (9, '1'), (10, '1.1.1.11'), (11, '1'), (12, '1.1.1.30'), (13, '1.1.1.30'))

四、fetch數據類型

關於默認獲取的數據是元祖類型，若是想要或者字典類型的數據，即：

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Author: DBQ(Du Baoqiang)

import pymysql   #導入模塊

#建立鏈接
conn = pymysql.connect(
    host='172.16.30.162',   #主機IP
    port=3306,              #端口
    user='tom',             #鏈接數據庫用戶
    password='tom123',      #鏈接密碼
    db='db1'                #鏈接的數據庫名稱
)

# #建立遊標, 並設置爲字典類型
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)

cursor.execute("select * from tb1")

result = cursor.fetchone()

print(result)

conn.commit()
cursor.close()
conn.close()


#執行結果：
{'host': '1.1.1.1', 'id': 1}

View Code

SQLAlchemy

SQLAlchemy是Python編程語言下的一款ORM框架，該框架創建在數據庫API之上，使用關係對象映射來操做數據庫。簡而言之，就是將對象轉換爲SQL語句，而後使用數據API執行SQL並獲取執行結果。

對象關係映射（Object Relational Mapping，簡稱ORM，或O/RM，或O/R mapping），是一種程序技術，用於實現面向對象編程語言裏不一樣類型系統的數據之間的轉換。從效果上說，它實際上是建立了一個可在編程語言裏使用的「虛擬對象數據庫」。

Python其餘的ORM框架，推薦博文：http://www.oschina.net/translate/sqlalchemy-vs-orms

既然ORM是一個框架或者說是中間件，不管怎樣，確定是會有消耗的，因此，用仍是不用？推薦這個博文：https://www.pureweber.com/article/orm/

SQLAlchemy自己沒法操做數據庫，其必須以pymysql等第三方插件。

Dialect用於和數據API交互，根據配置文件的不一樣調用不一樣的數據庫API，從而實現對數據庫的操做，以下代碼：

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:pass@host:port/dbname[?key=value&key=value...]
  
更多：http://docs.sqlalchemy.org/en/latest/dialects/index.html

一. 底層處理

使用Engine/ConnectionPooling/Dialect進行數據庫操做，Engine使用ConnectionPooling鏈接數據庫，然後再經過Dialect執行SQL語句。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Author: DBQ(Du Baoqiang)

from sqlalchemy import create_engine

engine = create_engine("mysql+pymysql://tom:tom123@172.16.30.162:3306/db1",max_overflow=5)

#執行SQL
cur = engine.execute(
    "INSERT INTO tb1(host) VALUES ('172.16.30.253')"    #插入一條數據
)

print('ID,',cur.lastrowid)    #打印新插入行的自增ID

#執行SQL
cur1 = engine.execute(
    "INSERT INTO tb1(host) VALUES(%s),(%s)",[('172.16.0.1'),('172.16.0.2')]  #一下插入多條記錄, 使用%s方式
)
print('ID,',cur1.lastrowid)
#執行SQL方式3
cur2 = engine.execute(
    "INSERT INTO tb1(host) VALUES(%(host)s),(%(host1)s)",host='172.16.1.1',host1='172.16.1.2'  #插入多條記錄,使用佔位符的形式
)

print('ID,',cur2.lastrowid)

#執行SQL
cur_select = engine.execute("SELECT * FROM tb1")

#獲取第一行數據
res = cur_select.fetchone()    #也存在指針的問題
print(res)
#前三行
res1 = cur_select.fetchmany(3)
print(res1)     
#獲取全部
res2 = cur_select.fetchall()  
print(res2)

二. ORM功能的使用

使用ORM/Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect全部的組件對數據進行操做。根據類建立對象，將對象轉換成SQL，然後執行SQL。

1. 建立表

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Author: DBQ(Du Baoqiang)

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer,String, ForeignKey,UniqueConstraint,Index
from sqlalchemy.orm import sessionmaker,relationships
from sqlalchemy import create_engine

engine = create_engine("mysql+pymysql://tom:tom123@172.16.30.162:3306/db1",max_overflow=5)

Base = declarative_base()

#建立一個單表
class Users(Base):
    '''
    必定要繼承Base
    '''
    __tablename__ = 'users'  #表名爲users
    id = Column(Integer,primary_key=True)  #id列, 整數數據類型, 主鍵
    name = Column(String(32))    #name列, 字符串類型, 長度32
    extra = Column(String(20))   #extra列,字符串類型,長度20

    __table_args__ = (
        UniqueConstraint('id','name',name='unx_id_name'),
        Index('ix_id_name','name','extra')
    )

#一對多
class Favor(Base):
    __tablename__ = 'favor'
    nid = Column(Integer,primary_key=True)
    caption = Column(String(50),default='red',unique=True)

class Person(Base):
    '''
    經過外鍵關聯favor表的nid實現一對多
    '''
    __tablename__ = 'person'
    nid = Column(Integer,primary_key=True)
    name = Column(String(32),index=True,nullable=True)
    favor_id = Column(Integer, ForeignKey('favor.nid'))   #外鍵,關聯favor表的nid


#多對多
class Group(Base):
    __tablename__ = 'group'
    id = Column(Integer,primary_key=True)
    name = Column(String(64),unique=True,nullable=True)
    port = Column(Integer,default=22)

class Server(Base):
    __tablename__ = 'server'
    id = Column(Integer,primary_key=True,autoincrement=True)
    hostname = Column(String(64),unique=True,nullable=False)

class ServerToGroup(Base):
    '''
    servertogroup這個表存放上述兩個表的對應關係,能夠多對多
    '''
    __tablename__ = 'servertogroup'
    nid = Column(Integer,primary_key=True,autoincrement=True)
    server_id = Column(Integer,ForeignKey('server.id'))
    group_id = Column(Integer,ForeignKey('group.id'))

def init_db():
    Base.metadata.create_all(engine)

def drop_db():
    Base.metadata.drop_all(engine)

#init_db()   #建立全部表
#drop_db()    #刪除全部表

View Code

2. 操做表

 

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Author: DBQ(Du Baoqiang)

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer,String, ForeignKey,UniqueConstraint,Index
from sqlalchemy.orm import sessionmaker,relationships
from sqlalchemy import create_engine

engine = create_engine("mysql+pymysql://tom:tom123@172.16.30.162:3306/db1",max_overflow=5)

Base = declarative_base()


#建立一個單表
class Users(Base):
    '''
    必定要繼承Base
    '''
    __tablename__ = 'users'  #表名爲users
    id = Column(Integer,primary_key=True)  #id列, 整數數據類型, 主鍵
    name = Column(String(32))    #name列, 字符串類型, 長度32
    extra = Column(String(20))   #extra列,字符串類型,長度20

    __table_args__ = (
        UniqueConstraint('id','name',name='unx_id_name'),
        Index('ix_id_name','name','extra')
    )

    def __repr__(self):
        return "%s-%s"%(self.id, self.name)


#一對多
class Favor(Base):
    __tablename__ = 'favor'
    nid = Column(Integer,primary_key=True)
    caption = Column(String(50),default='red',unique=True)

    def __repr__(self):
        return "%s-%s" %(self.nid, self.caption)

class Person(Base):
    '''
    經過外鍵關聯favor表的nid實現一對多
    '''
    __tablename__ = 'person'
    nid = Column(Integer,primary_key=True)
    name = Column(String(32),index=True,nullable=True)
    favor_id = Column(Integer, ForeignKey('favor.nid'))   #外鍵,關聯favor表的nid
    #與生成表結構無關, 僅用於查詢方便
    #favor = relationships('Favor',backref = 'pers')

#多對多
class Group(Base):
    __tablename__ = 'group'
    id = Column(Integer,primary_key=True)
    name = Column(String(64),unique=True,nullable=True)
    port = Column(Integer,default=22)
    #group = relationships('Group',secondary=ServerToGroup,backref='host_list')

class Server(Base):
    __tablename__ = 'server'
    id = Column(Integer,primary_key=True,autoincrement=True)
    hostname = Column(String(64),unique=True,nullable=False)


class ServerToGroup(Base):
    '''
    servertogroup這個表存放上述兩個表的對應關係,能夠多對多
    '''
    __tablename__ = 'servertogroup'
    nid = Column(Integer,primary_key=True,autoincrement=True)
    server_id = Column(Integer,ForeignKey('server.id'))
    group_id = Column(Integer,ForeignKey('group.id'))
    #group = relationships('Group',backref='s2g')
    #server = relationships('Server',backref='s2g')

def init_db():
    Base.metadata.create_all(engine)

def drop_db():
    Base.metadata.drop_all(engine)

Session = sessionmaker(bind=engine)
session = Session()

表結構+鏈接數據庫

• 增

• obj = Users(name='Tom',extra='mouse')
  session.add(obj)
  session.add_all([
      Users(name='Jerry',extra='Cat'),
      Users(name='Sam',extra='Human')
  ])
  
  session.commit()

  View Code
• 刪

• session.query(Users).filter(Users.id > 4).delete()   #刪除id>4的用戶
  session.commit()

  View Code
• 改

• session.query(Users).filter(Users.id > 3).update({"name":"sb"})   #先將id>3的用戶名字改成sb
  session.query(Users).filter(Users.id > 3).update({Users.name:Users.name + '123'},synchronize_session = False)  #然後在sb後拼接一個123
  
  session.query(Users).filter(Users.id > 3).update({"id": Users.id+1},synchronize_session = "evaluate")  #最後把大於3的id號+1
  
  session.commit()

  View Code
• 查

• res = session.query(Users).all()  #返回一個列表
  print(res)
  res1 = session.query(Users.name, Users.extra).all()  #返回一個列表,中包含元組
  print(res1)
  res2 = session.query(Users).filter_by(name='Jerry').all()  #返回一個列表
  print(res2)
  res3 = session.query(Users).filter_by(name='Jerry').first()
  print(res3)
  session.commit()

  View Code
• 其餘

• #條件
  ret = session.query(Users).filter_by(name='Jerry').all()
  ret = session.query(Users).filter(Users.id > 1, Users.name == 'Tom').all()  #並
  ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'Sam').all()   #id在1-3之間,而且名字是Sam
  ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()    #id在1,3,4裏的
  ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()   #取反
  ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='Sam'))).all()  #子查詢
  
  from sqlalchemy import and_, or_
  
  ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'Tom')).all()  #並
  ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'Tom')).all()  #或
  ret = session.query(Users).filter(
      or_(
          Users.id < 2,
          and_(Users.name == 'Sam', Users.id > 3),
          Users.extra != ""
      )).all()     #id<2 或者  用戶名是Sam並大於3的
  
  
  # 通配符
  ret = session.query(Users).filter(Users.name.like('J%')).all()     #J開頭後續任意字符
  ret = session.query(Users).filter(~Users.name.like('J%')).all()    #取反
  
  
  # 限制
  ret = session.query(Users)[0:5]    #顯示多少個值,我的感受有點相似於列表的切片同樣
  
  # 排序
  ret = session.query(Users).order_by(Users.id.desc()).all()   #降序
  ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()  #升序
  
  
  
  # 分組
  from sqlalchemy.sql import func
  
  ret = session.query(Users).group_by(Users.extra).all()
  
  ret = session.query(
      func.max(Users.id),
      func.sum(Users.id),
      func.min(Users.id)).group_by(Users.name).all()
  #結果:[(2, Decimal('2'), 2), (3, Decimal('3'), 3), (5, Decimal('5'), 5), (1, Decimal('1'), 1)]
  
  ret = session.query(
      func.max(Users.id),
      func.sum(Users.id),
      func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()   #添加條件最小id大於2
  
  
  # 連表
  
  ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()   #連表查詢, 條件 usersid 等於 Favor.nid
  ret = session.query(Person).join(Favor).all()    #左鏈接, 若是要用右鏈接,能夠把兩個表的位置換下
  #
  ret = session.query(Person).join(Favor, isouter=True).all()
  
  
  # 組合
  q1 = session.query(Users.name).filter(Users.id > 2)
  q2 = session.query(Favor.caption).filter(Favor.nid < 2)
  ret = q1.union(q2).all()
  
  q1 = session.query(Users.name).filter(Users.id > 2)
  q2 = session.query(Favor.caption).filter(Favor.nid < 2)
  ret = q1.union_all(q2).all()
  
  
  print(ret)
  session.commit()

  View Code

更多>>>，下載PDF文檔

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Author: DBQ(Du Baoqiang)

from sqlalchemy import create_engine,and_,or_,func,Table
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,ForeignKey,UniqueConstraint,DateTime
from  sqlalchemy.orm import sessionmaker,relationship

Base = declarative_base() #生成一個SqlORM 基類

# 服務器帳號和組
# HostUser2Group = Table('hostuser_2_group',Base.metadata,
#     Column('hostuser_id',ForeignKey('host_user.id'),primary_key=True),
#     Column('group_id',ForeignKey('group.id'),primary_key=True),
# )

# 用戶和組關係表，用戶能夠屬於多個組，一個組能夠有多我的
UserProfile2Group = Table('userprofile_2_group',Base.metadata,
    Column('userprofile_id',ForeignKey('user_profile.id'),primary_key=True),
    Column('group_id',ForeignKey('group.id'),primary_key=True),
)

# 程序登錄用戶和服務器帳戶，一我的能夠有多個服務器帳號，一個服務器帳號能夠給多我的用
UserProfile2HostUser= Table('userprofile_2_hostuser',Base.metadata,
    Column('userprofile_id',ForeignKey('user_profile.id'),primary_key=True),
    Column('hostuser_id',ForeignKey('host_user.id'),primary_key=True),
)


class Host(Base):
    __tablename__='host'
    id = Column(Integer,primary_key=True,autoincrement=True)
    hostname = Column(String(64),unique=True,nullable=False)
    ip_addr = Column(String(128),unique=True,nullable=False)
    port = Column(Integer,default=22)
    def __repr__(self):
        return  "<id=%s,hostname=%s, ip_addr=%s>" %(self.id,
                                                    self.hostname,
                                                    self.ip_addr)

class HostUser(Base):
    __tablename__ = 'host_user'
    id = Column(Integer,primary_key=True)
    AuthTypes = [
        (u'ssh-passwd',u'SSH/Password'),
        (u'ssh-key',u'SSH/KEY'),
    ]
    # auth_type = Column(ChoiceType(AuthTypes))
    auth_type = Column(String(64))
    username = Column(String(64),unique=True,nullable=False)
    password = Column(String(255))

    host_id = Column(Integer,ForeignKey('host.id'))
    
    # groups = relationship('Group',
    #                       secondary=HostUser2Group,
    #                       backref='host_list')

    __table_args__ = (UniqueConstraint('host_id','username', name='_host_username_uc'),)

    def __repr__(self):
        return  "<id=%s,name=%s>" %(self.id,self.username)


class Group(Base):
    __tablename__ = 'group'
    id = Column(Integer,primary_key=True)
    name = Column(String(64),unique=True,nullable=False)
    def __repr__(self):
        return  "<id=%s,name=%s>" %(self.id,self.name)


class UserProfile(Base):
    __tablename__ = 'user_profile'
    id = Column(Integer,primary_key=True)
    username = Column(String(64),unique=True,nullable=False)
    password = Column(String(255),nullable=False)
    # host_list = relationship('HostUser',
    #                       secondary=UserProfile2HostUser,
    #                       backref='userprofiles')
    # groups = relationship('Group',
    #                       secondary=UserProfile2Group,
    #                       backref='userprofiles')
    def __repr__(self):
        return  "<id=%s,name=%s>" %(self.id,self.username)


class AuditLog(Base):
    __tablename__ = 'audit_log'
    id = Column(Integer,primary_key=True)
    userprofile_id = Column(Integer,ForeignKey('user_profile.id'))
    hostuser_id = Column(Integer,ForeignKey('host_user.id'))
    action_choices2 = [
        (u'cmd',u'CMD'),
        (u'login',u'Login'),
        (u'logout',u'Logout'),
    ]
    action_type = Column(ChoiceType(action_choices2))
    #action_type = Column(String(64))
    cmd = Column(String(255))
    date = Column(DateTime)

    # user_profile = relationship("UserProfile")
    #bind_host = relationship("BindHost")


engine = create_engine("mysql+pymsql://root:123@localhost:3306/stupid_jumpserver",echo=False)
Base.metadata.create_all(engine) #建立全部表結構

表結構操做

 

參考：

• http://www.cnblogs.com/wupeiqi/articles/5699254.html