python操做mysql（pymysql + sqlalchemy）

pymysql

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

下載安裝

pip3 install pymysql

使用操做

一、執行sql

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
  
# 建立鏈接
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
# 建立遊標
cursor = conn.cursor()
  
# 執行SQL，並返回收影響行數
effect_row = cursor.execute("update hosts set host = '1.1.1.2'")
  
# 執行SQL，並返回受影響行數
#effect_row = cursor.execute("update hosts set host = '1.1.1.2' where nid > %s", (1,))
  
# 執行SQL，並返回受影響行數
#effect_row = cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)])
  
  
# 提交，否則沒法保存新建或者修改的數據
conn.commit()
  
# 關閉遊標
cursor.close()
# 關閉鏈接
conn.close()

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

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
  
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
cursor = conn.cursor()
cursor.executemany("insert into hosts(host,color_id)values(%s,%s)", [("1.1.1.11",1),("1.1.1.11",2)])
conn.commit()
cursor.close()
conn.close()
  
# 獲取最新自增ID
new_id = cursor.lastrowid

三、獲取查詢數據

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
  
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
cursor = conn.cursor()
cursor.execute("select * from hosts")
  
# 獲取第一行數據
row_1 = cursor.fetchone()
  
# 獲取前n行數據
# row_2 = cursor.fetchmany(3)
# 獲取全部數據
# row_3 = cursor.fetchall()
  
conn.commit()
cursor.close()
conn.close()

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

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

四、fetch數據類型

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

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import pymysql
  
conn = pymysql.connect(host='127.0.0.1', port=3306, user='root', passwd='123', db='t1')
  
# 遊標設置爲字典類型
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
r = cursor.execute("call p1()")
  
result = cursor.fetchone()
  
conn.commit()
cursor.close()
conn.close()

 

 

1、對象映射關係（ORM）

orm英文全稱object relational mapping,就是對象映射關係程序，簡單來講咱們相似python這種面向對象的程序來講一切皆對象，可是咱們使用的數據庫卻都是關係型的，爲了保證一致的使用習慣，經過orm將編程語言的對象模型和數據庫的關係模型創建映射關係，這樣咱們在使用編程語言對數據庫進行操做的時候能夠直接使用編程語言的對象模型進行操做就能夠了，而不用直接使用sql語言

優勢：

• 隱藏了數據訪問細節，「封閉」的通用數據庫交互，ORM的核心。他使得咱們的通用數據庫交互變得簡單易行，而且徹底不用考慮該死的SQL語句。快速開發，由此而來
• ORM使咱們構造固化數據結構變得簡單易行

缺點：

• 無可避免的，自動化意味着映射和關聯管理，代價是犧牲性能（早期，這是全部不喜歡ORM人的共同點）。如今的各類ORM框架都在嘗試使用各類方法來減輕這塊（LazyLoad，Cache），效果仍是很顯著的

2、SQLAlchemy

在Python中，最有名的ORM框架是SQLAlchemy。用戶包括openstack＼Dropbox等知名公司或應用

Dialect用於和數據API進行交流，根據配置文件的不一樣調用不一樣的數據庫API，從而實現對數據庫的操做，SQLAlchemy自己沒法操做數據庫，其必須以來pymsql等第三方插件，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

安裝：

pip install SQLAlchemy
pip install pymysql 

1、內部處理

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

#!/usr/bin/env python
# coding=utf-8

from sqlalchemy import create_engine

engine = create_engine("mysql+pymysql://root:xiaoming.note5@115.159.193.77:3306/school?charset=utf8", max_overflow=5)

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

# 新插入行自增ID
cur.lastrowid

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

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

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

# 獲取第一行數據, 第n行，全部數據
cur.fetchone()
cur.fetchmany(3)
cur.fetchall()

2、ORM功能使用

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

一、外鍵關聯

建立表

# orm_fk.py
#!/usr/bin/env python
# coding=utf-8

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, Date
from sqlalchemy.orm import relationship

engine = create_engine("mysql+pymysql://root:xiaoming.note5@115.159.193.77/school", encoding='utf-8')
Base = declarative_base()

class Student(Base):
    __tablename__ = 'student'
    id = Column(Integer, primary_key=True)
    name = Column(String(32), nullable=False)
    age = Column(String(32), nullable=False)
    register_date = Column(Date, nullable=False)
    def __repr__(self):
        return '<%s name:%s>' % (self.id, self.name)

class StudyRecord(Base):
    __tablename__ = 'study_record'
    id = Column(Integer, primary_key=True)
    day = Column(Integer,nullable=False)
    status = Column(String(32), nullable=False)
    stu_id = Column(Integer, ForeignKey('student.id')) 

    student = relationship('Student', backref='my_study_record') # Student爲關聯的類

    def __repr__(self):
        return '<%s day:%s status:%s>' % (self.student.name, self.day, self.status)

Base.metadata.create_all(engine) #關聯student表裏的id

注：my_student = relationship("Student",backref="my_study_record")這個nb，容許你在user表裏經過backref字段反向查出全部它在addresses表裏的關聯項

插入數據

# cat orm_fk
#!/usr/bin/env python
# coding=utf-8

from sqlalchemy.orm import sessionmaker
from orm_fk import Student, StudyRecord, engine

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

session.add_all([
    Student(name='lihy', age=21, register_date='2016-10-15'),
    Student(name='liq', age=22, register_date='2016-11-16'),
    Student(name='zhuxj', age=23, register_date='2016-12-17'),
    StudyRecord(day=1, status='yes', stu_id=1),
    StudyRecord(day=2, status='yes', stu_id=1),
    StudyRecord(day=3, status='no', stu_id=1),
    StudyRecord(day=3, status='yes', stu_id=2),
])
session.commit()

st1 = Student(name='lium', age=22, register_date='2011-10-15')
st2 = Student(name='liuxj', age=25, register_date='2011-11-15')

sr1 = StudyRecord(day=4, status='yes', stu_id=1),
sr2 = StudyRecord(day=5, status='yes', stu_id=1), 
sr3 = StudyRecord(day=6, status='no', stu_id=1), 
sr4 = StudyRecord(day=7, status='yes', stu_id=2),

session.add_all([st1,st2,sr1,sr2,sr3,sr4])
session.commit()

查詢數據

#!/usr/bin/env python
# coding=utf-8

from sqlalchemy.orm import sessionmaker
from orm_fk import Student, StudyRecord, engine

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

stu_obj = session.query(Student).filter(Student.name=='lihy').first()
print(stu_obj.my_study_record)

二、多外鍵關聯

#!/usr/bin/env python
# coding=utf-8

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, Date
from sqlalchemy.orm import relationship

engine = create_engine("mysql+pymysql://root:xiaoming.note5@115.159.193.77/school", encoding='utf-8')
Base = declarative_base()

class Customer(Base):
    __tablename__ = 'customer'
    id = Column(Integer, primary_key=True)
    name = Column(String(32))

    billing_address_id = Column(Integer, ForeignKey('address.id'))
    shipping_address_id = Column(Integer, ForeignKey('address.id'))

    billing_address = relationship('Address', foreign_keys=[billing_address_id])
    shipping_address = relationship('Address', foreign_keys=[shipping_address_id])

    def __repr__(self):
        return '<%s name:%s billing_address:%s shipping_adress>' % (self.name, self.billing_address.street, self.shipping_address.street)

class Address(Base):
    __tablename__ = 'address'
    id = Column(Integer, primary_key=True)
    street = Column(String(64))
    city = Column(String(64))
    province = Column(String(64))

Base.metadata.create_all(engine)

#!/usr/bin/env python
# coding=utf-8

from sqlalchemy.orm import sessionmaker
from cj import Address, Customer, engine                                                                                                                                                                                          

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

session.add_all([
    Address(street='huaxia', city='SH', province='ShangHai'),
    Address(street='sunhua', city='BJ', province='HeNan'), 
    Address(street='xihuan', city='XC', province='ShangHai'), 
    Customer(name='lihy', billing_address_id=1, shipping_address_id=2),
    Customer(name='liq', billing_address_id=1, shipping_address_id=1),
])

session.commit()

#!/usr/bin/env python
# coding=utf-8

from sqlalchemy.orm import sessionmaker
from cj import Customer, Address, engine

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

ret = session.query(Customer).filter(Customer.name=='lihy').first()
print(ret.billing_address.street, ret.shipping_address.province)

三、多對多關聯

#!/usr/bin/env python
# coding=utf-8

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, Date, Table
from sqlalchemy.orm import relationship

engine = create_engine("mysql+pymysql://root:xiaoming.note5@115.159.193.77/school", encoding='utf-8')
Base = declarative_base()

bookidToAuthorid = Table('bookidToAuthorid', Base.metadata,
        Column('bookid', Integer, ForeignKey('books.id')),
        Column('authorid', Integer, ForeignKey('authors.id')),
    )
class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer, primary_key=True)
    name = Column(String(64))
    pub_date = Column(Date)
    authors = relationship('Author', secondary=bookidToAuthorid, backref='books')

    def __repr__(self):
        return self.name

class Author(Base):
    __tablename__ =  'authors'
    id = Column(Integer, primary_key=True)
    name = Column(String(32))

    def __repr__(self):
        return self.name

Base.metadata.create_all(engine)

#!/usr/bin/env python
# coding=utf-8

from sqlalchemy.orm import sessionmaker
from cj import Book, Author, engine

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

b1 = Book(name="learn python", pub_date='2011-10-15')
b2 = Book(name="learn linux", pub_date='2011-10-16')
b3 = Book(name="learn C++", pub_date='2011-10-17')

a1 = Author(name="lihy")
a2 = Author(name="liq")
a3 = Author(name="lium")

b1.authors = [a1, a3]
b3.authors = [a1, a2, a3]

session.add_all([b1, b2, b3, a1, a2, a3])
session.commit()

#!/usr/bin/env python
# coding=utf-8

from sqlalchemy.orm import sessionmaker
from cj import Book, Author, engine Session = sessionmaker(bind=engine) session = Session() ret = session.query(Book).filter(Book.name=='learn python').first() print(ret.authors)

多對多刪除

　　經過書刪除做者

未刪前：
[root@VM_255_164_centos mtm]# python3 query.py
[lihy, lium]

#!/usr/bin/env python
# coding=utf-8

from sqlalchemy.orm import sessionmaker
from cj import Book, Author, engine

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

author_obj = session.query(Author).filter(Author.name=='lihy').first()
book_obj = session.query(Book).filter_by(name="learn python").first()

book_obj.authors.remove(author_obj)
session.commit()

# 刪除後
# python3 query.py
[lium]

　　直接刪除做者，會把這個做者跟全部書的關聯數據也刪掉

#!/usr/bin/env python
# coding=utf-8

from sqlalchemy.orm import sessionmaker
from cj import Book, Author, engine

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

author_obj = session.query(Author).filter(Author.name=='lihy').first()

session.delete(author_obj)
session.commit()

 

查詢數據

mysql> select * from books;
+----+--------------+------------+
| id | name         | pub_date   |
+----+--------------+------------+
|  1 | learn python | 2011-10-15 |
|  2 | learn C++    | 2011-10-17 |
|  3 | learn linux  | 2011-10-16 |
+----+--------------+------------+
3 rows in set (0.00 sec)

print(session.query(Book.name, Book.pub_date).all())
# [('learn python', datetime.date(2011, 10, 15)), ('learn C++', datetime.date(2011, 10, 17)), ('learn linux', datetime.date(2011, 10, 16))]

多條件查詢

objs = session.query(Book).filter(Book.id>1).filter(Book.id<3).all()

統計

session.query(Book).filter(Book.name.like('l%')).count()

分組

#!/usr/bin/env python
# coding=utf-8

from sqlalchemy.orm import sessionmaker
from cj import Book, Author, engine
from sqlalchemy import func

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

print(session.query(func.count(Book.name), Book.name).group_by(Book.name).all())
# [(1, 'learn C++'), (1, 'learn linux'), (1, 'learn python')]

至關於原聲sql：

mysql> select count(books.name) AS count_1, books.name as books_name from books group by books.name;
+---------+--------------+
| count_1 | books_name   |
+---------+--------------+
|       1 | learn C++    |
|       1 | learn linux  |
|       1 | learn python |
+---------+--------------+
3 rows in set (0.00 sec)

修改

#!/usr/bin/env python
# coding=utf-8

from sqlalchemy.orm import sessionmaker
from cj import Book, Author, engine
from sqlalchemy import func

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

books_obj = session.query(Book).filter_by(name='learn python').first()
print(books_obj.pub_date)
books_obj.pub_date = "2011-11-11"
session.commit()
print(books_obj.pub_date)

# python3 d1.py 
2011-10-15
2011-11-11

回滾

#!/usr/bin/env python
# coding=utf-8

from sqlalchemy.orm import sessionmaker
from cj import Book, Author, engine
from sqlalchemy import func

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

books_obj = session.query(Book).filter_by(name='learn python').first()
print(books_obj.pub_date)
books_obj.pub_date = "2012-12-12"
print(books_obj.pub_date)
session.rollback()
print(books_obj.pub_date)

# 2011-11-11
# 2012-12-12 
# 2011-11-11

 

其餘：

# 刪
session.query(Book).filter(Book.id > 2).delete()
session.commit()

# 增
session.query(Book).filter(Book.id == 2).update({"pub_date": "2013-12-13"})
session.commit()
session.query(Book).filter(Book.id == 2).update({Book.pub_date: Book.pub_date + 10})

# 查
session.query(Book).all()


#　條件
ret = session.query(Users).filter_by(name='alex').all()
ret = session.query(Users).filter(Users.id > 1, Users.name == 'eric').all()
ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'eric').all()
ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
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='eric'))).all()
from sqlalchemy import and_, or_
ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'eric')).all()
ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'eric')).all()
ret = session.query(Users).filter(
    or_(
        Users.id < 2,
        and_(Users.name == 'eric', Users.id > 3),
        Users.extra != ""
    )).all()


# 通配符
ret = session.query(Users).filter(Users.name.like('e%')).all()
ret = session.query(Users).filter(~Users.name.like('e%')).all()

# 限制
ret = session.query(Users)[1:2]

# 排序
ret = session.query(Users).order_by(Users.name.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()

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()

# 連表

ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()

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()