python之sqlalchemy模塊

面向對象的一些特殊方法：必定要記住的方法....就四個方法

class Foo:
    def __init__(self, name):
        self.name = name

    def show(self):
        print(self.name)
    #實例化出來的對象加()就會運行call函數
    def __call__(self):
        pass

    def __getitem__(self, key):
        pass

    def __setitem__(self, key, value):
        pass

    def __delitem__(self, key):
        pass


obj1 = Foo('eric')

obj1()
obj1['k']
obj1['k'] = 123
del obj[k]
obj.__dict__

 

 

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

實現對數據庫的操做，如：

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

1、ORM的功能使用

1.建立表

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

Base =  declarative_base()#固定的生成一個基類
#在建立以前，須要先調用sqlalchemy模塊，以及該模塊中的屬性，

class UserType(Base):
    __tablename__ = 'usertype'
    id = Column(Integer,primary_key=True,autoincrement=True)
    title = Column(String(32),nullable=True,index=True)


class Users(Base):#每個類就表明着一個表
    __tablename__ = 'uses' #創建表名
    #和原生的大體是同樣的，裏面建立的一些方式都是同樣。
    # __tablename__：設置表名稱
    # Integer：整數類型
    # primary_key=True:主鍵
    # autoincrement=True：自增id
    # nullable=True:是否爲空
    # index=True：索引
    # unique=True：惟一約束
    # ForeignKey：創建外鍵，綁定到你對應的表的id
    # relationship：經過創建的外鍵，創建關係，
         -- 正向操做：即運行users中的user_type，能夠調取到外鍵的表內容
         -- 方向操做：即運行UserType，便可以運行主表的內容
    id = Column(Integer,primary_key = True,autoincrement=True)
    name = Column(String(32),nullable=True,index=True)
    email = Column(String(16),unique=True)
    user_type_id = Column(Integer,ForeignKey('usertype.id'))
# __table_args__：建立
    __table_args__ = (
        #創建惟一聯合索引，有約束的關係，即列與列之間是相同的有關係
        UniqueConstraint('id','name',name = 'ux_id_name'),
        #創建普通聯合索引，沒有約束，即列與列之間是相同的也不要緊
        Index('ix_n_name','name','email')
    )

#創建數據庫鏈接
'''
mysql+pymysql:數據庫+經過python中的pymysql進行鏈接
root：數據庫的帳號
1234qwer：數據庫的帳號密碼
127.0.0.1：ip地址
3306：端口號
db1：數據庫名稱
charset=utf8：編碼
max_overflow=5：最大鏈接數，
'''
# create_engine用來初始化數據庫鏈接
engine = create_engine('mysql+pymysql://root:1234qwer@127.0.0.1:3306/db1?charset=utf8',max_overflow=5)
#根據我建立的表提交到數據庫中，建立完以後能夠註釋掉，以避免重複建立。
Base.metadata.create_all(engine)

2.增長

#建立Session類型
Session = sessionmaker(bind=engine)
#建立session對象
session = Session()

#實例化一個對象
obj1=UserType(title='普通用戶')
#經過add添加到表中
session.add(obj1)

#建立多個用戶，
objs=[
    UserType(title='普通用戶'),
    UserType(title='高級用戶'),
    UserType(title='黑金用戶'),
]
#使用add_all,增長多個，進行添加
session.add_all(objs)

session.commit() #提交你對錶的操做
session.close()  #關閉表

3.查找

#建立Session類型
Session = sessionmaker(bind=engine)
#建立session對象
session = Session()

#獲得的是一個sql查詢的語句
#session.query():session是一個對象，query()是一個方法
print(session.query(UserType))
#all()取出全部的內容
user_type_list = session.query(UserType).all()
#user_type_list，獲取的是一個迭代器，須要經過遍歷取出裏面的內容
for row in user_type_list:
    print(row.id,row.title)

#根據篩選進行查找filter(UserType.id>2)=where UserType.id>2
user_type_list = session.query(UserType.id,UserType.title).filter(UserType.id>2)
for row in user_type_list:
    print(row.id,row.title)

4.刪除

#建立Session類型
Session = sessionmaker(bind=engine)
#建立session對象,能夠看作是鏈接當前的數據庫
session = Session()

#經過filter過濾出來，而後直接使用delete方法刪除你過濾出來的
session.query(UserType.id,UserType.title).filter(UserType.id>5).delete()

session.commit() #提交你對錶的操做
session.close()  #關閉表

　　

5.修改

#經過不一樣的類型，添加不一樣的值
'''
update:修改，方法中必定要用字典的形式
synchronize_session=False：字符串相加
synchronize_session='evaluate'：整數相加
'''
session.query(UserType.id,UserType.title).filter(UserType.id >2).update({'title':'鑽石'})
session.query(UserType.id,UserType.title).filter(UserType.id >2).update({UserType.title:UserType.title+'y'},synchronize_session=False)#字符串相加
session.query(UserType.id,UserType.title).filter(UserType.id >2).update({UserType.num:UserType.num+1},synchronize_session='evaluate') # 整數相加

問題集：

正向操做：即運行users中的user_type，能夠調取到外鍵的表內容

反向操做：即運行UserType，便可以運行主表的內容

問題1.獲取用戶信息以及與其關聯用戶類型名稱（FK，relationship=>正向操做）如下是不一樣的思路

#isouter=True:左鏈接，默認是inner,join:sql中的連表
user_list = session.query(Users,UserType).join(UserType,isouter=True)
# # print(user_list)#結果是一個連表的操做
for row in user_list:
    print(row[0].id,row[0].name,row[0].email,row[0].user_type_id,row[1].title)

 

#all():返回全部行，one():返回一行，不加參數是返回全部行
userlist = session.query(Users.name,UserType.title).join(UserType,isouter=True).all()
#在查詢的時候查詢的是Users.name,UserType.title，既能夠經過索引查找，也能夠經過固定的列名
for row in userlist:
    print(row[0],row[1],row.name,row.title)

正向操做：即運行users中的user_type，能夠調取到外鍵的表內容

#上面的兩個方法，都是須要進行連表，這個是經過在Users類中添加了，對外鍵的表創建的關聯。
# user_type = relationship('UserType',backref='xxoo')，因此就能夠直接查詢Users表，就能讀取外鍵表的內容
user_list = session.query(Users)
for row in user_list:
    print(row.name,row.id,row.user_type.title)

問題2.獲取用戶類型

#反向操做：即運行UserType，便可以運行主表的內容
type_list = session.query(UserType)
for row in type_list:
    #經過外鍵的表反查詢主表的內容，能夠經過反向操做，查詢不一樣的用戶的人數....
    print(row.id,row.title,session.query(Users).filter(Users.user_type_id==row.id).all())

 

#反向操做：即運行UserType，便可以運行主表的內容，user_type = relationship('UserType',backref='xxoo')，
#backref='xxoo'，表明着行。經過遍歷，就能取到主表的數據
#查看的是的外鍵的表，row.xxoo獲取的是外鍵的用戶，是一個對象，組成的列表，能夠經過遍歷，顯示列表中的用戶
type_list = session.query(UserType)
for row in type_list:
    #經過反向操做，
    print(row.id,row.title,[i.name for i in row.xxoo])