2. 程式人生 > >python對Mysql操作和使用ORM框架（SQLAlchemy）

python對Mysql操作和使用ORM框架（SQLAlchemy）

阿新 • • 發佈：2019-01-07

普通多次查詢

user_id_list = session.query(HostToHostUser.host_user_id).join(Host).filter(Host.hostname=='c2').all()
user_id_list = zip(*user_id_list)
user_list = session.query(HostUser.username).filter(HostUser.nid.in_(list(user_id_list)[0])).all()
print(user_list)

 

python對Mysql操作和使用ORM框架（SQLAlchemy）

http://www.cnblogs.com/pycode/p/mysql-orm.html

python對mysql的操作

Mysql 常見操作

資料庫操作

  • 建立資料庫

　　　　create database fuzjtest

  • 刪除資料庫

　　　　drop database fuzjtest

  • 查詢資料庫

　　　　show databases

  • 切換資料庫

　　　　use databas 123123 ###使用者授權

  • 建立使用者

　　　　create user '使用者名稱'@'IP地址' identified by '密碼';

  • 刪除使用者

　　　　drop user '使用者名稱'@'IP地址';

  • 修改使用者

　　　　rename user '使用者名稱'@'IP地址'; to '新使用者名稱'@'IP地址';;

  • 修改密碼

　　　　set password for '使用者名稱'@'IP地址' = Password('新密碼')

  • 檢視許可權

　　　　 show grants for '使用者'@'IP地址'

  • 授權

　　　　grant 許可權 on 資料庫.表 to '使用者'@'IP地址'

  • 取消許可權
    revoke 許可權 on 資料庫.表 from '使用者'@'IP地址'

    PS：使用者許可權相關資料儲存在mysql資料庫的user表中，所以也可以直接對其進行操作（不建議）
    授權資料庫

 相關許可權

 對資料庫授權

 對使用者和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 表名(
    列名  型別  是否可以為空，
    列名  型別  是否可以為空
)

     

    • 引數

 

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

2.預設值，建立列時可以指定預設值，當插入資料時如果未主動設定，則自動新增預設值
          create table tb1(
              nid int not null defalut 2,
              num int not null
          )
3.自增，如果為某列設定自增列，插入資料時無需設定此列，預設將自增（表中只能有一個自增列）
          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)
          )
          注意：1、對於自增列，必須是索引（含主鍵）。
               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;

 4.主鍵，一種特殊的唯一索引，不允許有空值，如果主鍵使用單個列，則它的值必須唯一，如果是多列，則其組合必須唯一。
          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)
          )

 5.外來鍵，一個特殊的索引，只能是指定內容
          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 表名

  • 清空表

    delete from 表名
    truncate table 表名

  • 修改表

    • 新增列：

　　　　　　alter table 表名 add 列名 型別

    • 刪除列：

　　　　　　alter table 表名 drop column 列名

    • 修改列：
      alter table 表名 modify column 列名 型別; -- 型別
      alter table 表名 change 原列名 新列名 型別; -- 列名，型別

    • 新增主鍵：

    • 刪除主鍵：
      alter table 表名 drop primary key;
      alter table 表名 modify 列名 int, drop 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;

 

基本操作

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

 

  • 刪
delete from 表
delete from 表 where id＝1 and name＝'fuzj'

 

  • 改
 update 表 set name ＝ 'fuzj' where id>1

 

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

 

  • 高階操作

    • 條件

       

      select * from 表 where id > 1 and name != 'alex' 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 表)

       

       

    • 萬用字元

      select * from 表 where name like 'ale%' - ale開頭的所有（多個字串）
select * from 表 where name like 'ale_' - ale開頭的所有（一個字元）

       

    • 限制

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

       

    • 排序

      select * from 表 order by 列 asc - 根據 “列” 從小到大排列
select * from 表 order by 列 desc - 根據 “列” 從大到小排列
select * from 表 order by 列1 desc,列2 asc - 根據 “列1” 從大到小排列，如果相同則按列2從小到大排序

       

    • 分組

       

      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之前

       

       

    • 連表

       

      無對應關係則不顯示
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

       

       

    • 組合

       

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

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

       

       

      python操作Mysql

      python3中第三方模組pymysql，提供python對mysql的操作
      pip3 install pymysql

  • 執行sql語句

 

import pymysql

# 建立連線
conn = pymysql.connect(host='127.0.0.1', port=3306, user='fuzj', passwd='123123', db='fuzj')

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

#conn.set_charset('utf-8')
# 執行SQL，並返回收影響行數
#effect_row = cursor.execute("create table user (id int not NULL auto_increment primary key  ,name char(16) not null) ")    #建立一個user表
#print(effect_row)
# 執行SQL，並返回受影響行數，使用佔位符 實現動態傳參
cursor.execute('SET CHARACTER SET utf8;')
effect_row = cursor.execute("insert into user (name) values (%s) ", ('323'))
effect_row = cursor.executemany("insert into user (name) values (%s) ", [('123',),('456',),('789',),('0',),('1',),('2',),('3',)])

#print(effect_row)
# 執行多個SQL，並返回受影響行數，列表中每個元素都相當於一個條件
effect_row = cursor.executemany("update user set name = %s WHERE  id = %s", [("fuzj",1),("jeck",2)])
print(effect_row)

 

 

  • 獲取新建立資料自增ID
#使用遊標的lastrowid方法獲取
new_id = cursor.lastrowid

 

  • 獲取查詢資料

 

import pymysql

# 建立連線
conn = pymysql.connect(host='127.0.0.1', port=3306, user='fuzj', passwd='123123', db='fuzj')

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


cursor.execute("select * from user")

# 獲取第一行資料
row_1 = cursor.fetchone()
print(row_1)
# 獲取前n行資料
row_2 = cursor.fetchmany(3)
print(row_2)
# 獲取所有資料
row_3 = cursor.fetchall()
print(row_3)
conn.commit()
cursor.close()
conn.close()import pymysql

# 建立連線
conn = pymysql.connect(host='127.0.0.1', port=3306, user='fuzj', passwd='123123', db='fuzj')

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


cursor.execute("select * from user")

# 獲取第一行資料
row_1 = cursor.fetchone()
print(row_1)
# 獲取前n行資料
row_2 = cursor.fetchmany(3)
print(row_2)
# 獲取所有資料，返回元組形式
row_3 = cursor.fetchall()
print(row_3)
conn.commit()
cursor.close()
conn.close()

 

 

輸出：

(1, 'fuzj')
((2, 'jeck'), (3, '323'), (4, '123'))
((5, '456'), (6, '789'), (7, '0'), (8, '1'), (9, '2'), (10, '3'), (11, '323'), (12, '123'), (13, '456'), (14, '789'), (15, '0'), (16, '1'), (17, '2'), (18, '3'), (19, '323'), (20, '123'), (21, '456'), (22, '789'), (23, '0'), (24, '1'), (25, '2'), (26, '3'))

 

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

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

  • fetch資料型別

 

import pymysql

# 建立連線
conn = pymysql.connect(host='127.0.0.1', port=3306, user='fuzj', passwd='123123', db='fuzj')

# 建立遊標
#cursor = conn.cursor()
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)

cursor.execute("select * from user")

row_1 = cursor.fetchone()
print(row_1)
# 獲取前n行資料
row_2 = cursor.fetchmany(3)
print(row_2)
# 獲取所有資料
row_3 = cursor.fetchall()
print(row_3)
conn.commit()
cursor.close()
conn.close()

 

 

輸出結果：

 

{'id': 1, 'name': 'fuzj'}
[{'id': 2, 'name': 'jeck'}, {'id': 3, 'name': '323'}, {'id': 4, 'name': '123'}]
[{'id': 5, 'name': '456'}, {'id': 6, 'name': '789'}, {'id': 7, 'name': '0'}, {'id': 8, 'name': '1'}, {'id': 9, 'name': '2'}, {'id': 10, 'name': '3'}, {'id': 11, 'name': '323'}, {'id': 12, 'name': '123'}, {'id': 13, 'name': '456'}, {'id': 14, 'name': '789'}, {'id': 15, 'name': '0'}, {'id': 16, 'name': '1'}, {'id': 17, 'name': '2'}, {'id': 18, 'name': '3'}, {'id': 19, 'name': '323'}, {'id': 20, 'name': '123'}, {'id': 21, 'name': '456'}, {'id': 22, 'name': '789'}, {'id': 23, 'name': '0'}, {'id': 24, 'name': '1'}, {'id': 25, 'name': '2'}, {'id': 26, 'name': '3'}]

 

 

ORM框架

SQLAlchemy是Python程式語言下的一款ORM框架，該框架建立在資料庫API之上，使用關係物件對映進行資料庫操作，簡言之便是：將物件轉換成SQL，然後使用資料API執行SQL並獲取執行結果。

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

 

 

  • 底層處理

使用 Engine/ConnectionPooling/Dialect 進行資料庫操作，Engine使用ConnectionPooling連線資料庫，然後再通過Dialect執行SQL語句。

 

from sqlalchemy import create_engine

#建立引擎
engine = create_engine("mysql+pymysql://fuzj:[email protected]:3306/fuzj", max_overflow=5)
#執行sql語句
engine.execute("INSERT INTO user (name) VALUES ('dadadadad')")

result = engine.execute('select * from user')
res = result.fetchall()
print(res)

 

 

  • ORM功能使用
    使用 ORM/Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 所有元件對資料進行操作。根據類建立物件，物件轉換成SQL，執行SQL。

    • 建立表

     

    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

engine = create_engine("mysql+pymysql://fuzj:[email protected]:3306/123", max_overflow=5)

Base = declarative_base()

# 建立單表
class Users(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True)
name = Column(String(32))
extra = Column(String(16))

__table_args__ = (
UniqueConstraint('id', 'name', name='uix_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):
__tablename__ = 'person'
nid = Column(Integer, primary_key=True)
name = Column(String(32), index=True, nullable=True)
favor_id = Column(Integer, ForeignKey("favor.nid"))

# 多對多
class ServerToGroup(Base):
__tablename__ = 'servertogroup'
nid = Column(Integer, primary_key=True, autoincrement=True)
server_id = Column(Integer, ForeignKey('server.id'))
group_id = Column(Integer, ForeignKey('group.id'))

class Group(Base):
__tablename__ = 'group'
id = Column(Integer, primary_key=True)
name = Column(String(64), unique=True, nullable=False)

class Server(Base):
__tablename__ = 'server'

id = Column(Integer, primary_key=True, autoincrement=True)
hostname = Column(String(64), unique=True, nullable=False)
port = Column(Integer, default=22)

Base.metadata.create_all(engine)  #建立表
# Base.metadata.drop_all(engine)   #刪除表

     

     

    • 增

     

    obj = Users(name="alex0", extra='sb')
session.add(obj)
session.add_all([
    Users(name="alex1", extra='sb'),
    Users(name="alex2", extra='sb'),
])
session.commit()

     

     

    • 刪
    session.query(Users).filter(Users.id > 2).delete()
session.commit()

     

    • 改
    session.query(Users).filter(Users.id > 2).update({"name" : "099"})
session.query(Users).filter(Users.id > 2).update({Users.name: Users.name + "099"}, synchronize_session=False)
session.query(Users).filter(Users.id > 2).update({"num": Users.num + 1}, synchronize_session="evaluate")
session.commit()

     

    • 查
    ret = session.query(Users).all()
ret = session.query(Users.name, Users.extra).all()
ret = session.query(Users).filter_by(name='alex').all()
ret = session.query(Users).filter_by(name='alex').first()

     

    • 其它

 

#　條件
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()

 

 

  • ORM解決中文編碼問題 sqlalchemy 預設使用latin-1進行編碼。所以當出現中文時就會報如下錯誤：
UnicodeEncodeError: 'latin-1' codec can't encode characters in position 39-41: ordinal not in range(256)

 

解決方法：

在連線資料庫的時候直接指定字元編碼：

#engine = create_engine("mysql+pymysql://fuzj:[email protected]:3306/fuzj?charset=utf8", max_overflow=5,encoding='utf-8')

 

參考：http://firefish.blog.51cto.com/298258/112794

  • ORM 指定查詢返回資料格式 預設使用query查詢返回的結果為一個物件

 

res = session.query(User).all()
print(res)
#使用for迴圈遍歷列表才能取出name
for i in res:
    print(i.name)

輸出結果：
[<__main__.User object at 0x10385c438>, <__main__.User object at 0x10385c4a8>, <__main__.User object at 0x10385c550>, <__main__.User object at 0x10385c5f8>, <__main__.User object at 0x10385c6a0>]
fuzj
jie
張三
李四
王五

 

 

使用__repr__定義返回的資料

 

class User(Base):
    __tablename__ = 'user'
    nid = Column(Integer,primary_key=True,autoincrement=True)
    name = Column(String(10),nullable=False)
    role = Column(Integer,ForeignKey('role.rid'))
    group = relationship("Role",backref='uuu')    #Role為類名

    def __repr__(self):
        output = "(%s,%s,%s)" %(self.nid,self.name,self.role)
        return output
        
res = session.query(User).all()
print(res)

輸出：
[(1,fuzj,1), (2,jie,2), (3,張三,2), (4,李四,1), (5,王五,3)]

 

 

  • ORM 一對多具體使用

    mysql表中一對多指的是表A中的資料和表B中的資料存在對應的對映關係，表A中的資料在表B中對應存在多個對應關係，如表A存放使用者的角色 DBA，SA，表B中存放使用者，表B通過外來鍵關聯之表A中，多個使用者可以屬於同一個角色

    • 設計兩張表，user表和role表，

      user 表中存放使用者，role表中存放使用者角色，role表中角色對應user表中多個使用者，user表中一個使用者只對應role表中一個角色，中間通過外來鍵約束

     

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

engine = create_engine("mysql+pymysql://fuzj:[email protected]:3306/fuzj?charset=utf8", max_overflow=5,encoding='utf-8') 
Base = declarative_base()

class Role(Base):
    __tablename__ = 'role'
    rid = Column(Integer, primary_key=True, autoincrement=True)    #主鍵，自增
    role_name = Column(String(10))

    def __repr__(self):
        output = "(%s,%s)" %(self.rid,self.role_name)
        return output

class User(Base):
    __tablename__ = 'user'
    nid = Column(Integer,primary_key=True,autoincrement=True)
    name = Column(String(10),nullable=False)
    role = Column(Integer,ForeignKey('role.rid'))  #外來鍵關聯

    def __repr__(self):
        output = "(%s,%s,%s)" %(self.nid,self.name,self.role)
        return output
Base.metadata.create_all(engine)

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

#新增角色資料
session.add(Role(role_name='dba'))
session.add(Role(role_name='sa'))
session.add(Role(role_name='net'))

#新增使用者資料
session.add_all([
    User(name='fuzj',role='1'),
    User(name='jie',role='2'),
    User(name='張三',role='2'),
    User(name='李四',role='1'),
    User(name='王五',role='3'),
])
session.commit()
session.close()

     

     

    • 普通連表查詢

     

    res = session.query(User,Role).join(Role).all()    #查詢所有使用者,及對應的role id
res1 = session.query(User.name,Role.role_name).join(Role).all()  #查詢所有使用者和角色,
res2 = session.query(User.name,Role.role_name).join(Role,isouter=True).filter(Role.role_name=='sa').all() #查詢所有DBA的使用者
print(res)
print(res1)
print(res2)

輸出結果：
[((1,fuzj,1), (1,dba)), ((2,jie,2), (2,sa)), ((3,張三,2), (2,sa)), ((4,李四,1), (1,dba)), ((5,王五,3), (3,net))]
[('fuzj', 'dba'), ('jie', 'sa'), ('張三', 'sa'), ('李四', 'dba'), ('王五', 'net')]
[('jie', 'sa'), ('張三', 'sa')]

     

     

    • 使用relationship 新增影射關係進行查詢

      • 首先在User表中新增relationship影射關係
      class User(Base):
    __tablename__ = 'user'
    nid = Column(Integer,primary_key=True,autoincrement=True)
    name = Column(String(10),nullable=False)
    role = Column(Integer,ForeignKey('role.rid'))
    group = relationship("Role",backref='uuu')    #Role為類名

       

      • 查詢

       

      #正向查詢
print('正向查詢')
res = session.query(User).all()  #查詢所有的使用者和角色
for i in res:
    print(i.name,i.group.role_name)    #此時的i.group 就是role表對應的關係
res = session.query(User).filter(User.name=='fuzj').first()  #查詢fuzj使用者和角色
print(res.name,res.group.role_name)

print('反向查詢')
#反向查詢
res = session.query(Role).filter(Role.role_name =='dba').first()   #查詢dba組下的所有使用者
print(res.uuu)   #此時 print的結果為[(1,fuzj,1), (4,李四,1)]
for i in res.uuu:
    print(i.name,res.role_name)

輸出結果：
正向查詢
fuzj dba
jie sa
張三 sa
李四 dba
王五 net
fuzj dba
反向查詢
[(1,fuzj,1), (4,李四,1)]
fuzj dba
李四 dba

       

       

    • 說明

      relationship 在user表中建立了新的欄位，這個欄位只用來存放user表中和role表中的對應關係，在資料庫中並不實際存在
      正向查詢： 先從user表中查到符合name的使用者之後，此時結果中已經存在和role表中的對應關係，group物件即role表，所以直接使用obj.group.role_name就可以取出對應的角色
      反向查詢：relationship引數中backref='uuu'，會在role表中的每個欄位中加入uuu，而uuu對應的就是本欄位在user表中對應的所有使用者，所以，obj.uuu.name會取出來使用者名稱
      所謂正向和反向查詢是對於relationship關係對映所在的表而說，如果通過該表（user表）去查詢對應的關係表（role表），就是正向查詢，反正通過對應的關係表（role表）去查詢該表（user表）即為反向查詢。而relationship往往會和ForeignKey共存在一個表中。

  • ORM 多對多具體使用

    Mysql多對多關係指的是兩張表A和B本沒有任何關係，而是通過第三張表C建立關係，通過關係表C，使得表A在表B中存在多個關聯資料，表B在表A中同樣存在多個關聯資料

    • 建立三張表 host表 hostuser表 host_to_hostuser表

    host表中存放主機，hostuser表中存放主機的使用者， host_to_hostuser表中存放主機使用者對應的主機，hostuser表中使用者對應host表中多個主機，host表中主機對應hostuser表中多個使用者，中間關係通過host_to_hostuser表進行關聯。host_to_hostuser和host表、user表進行外來鍵約束

     

    from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,ForeignKey
from sqlalchemy.orm import sessionmaker,relationship
from sqlalchemy import create_engine
class Host(Base):
    __tablename__ = 'host'
    nid = Column(Integer, primary_key=True,autoincrement=True)
    hostname = Column(String(32))
    port = Column(String(32))
    ip = Column(String(32))

class HostUser(Base):
    __tablename__ = 'host_user'
    nid = Column(Integer, primary_key=True,autoincrement=True)
    username = Column(String(32))

class HostToHostUser(Base):
    __tablename__ = 'host_to_host_user'
    nid = Column(Integer, primary_key=True,autoincrement=True)

    host_id = Column(Integer,ForeignKey('host.nid'))
    host_user_id = Column(Integer,ForeignKey('host_user.nid'))

Base.metadata.create_all(engine)

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

#新增資料
session.add_all([
    Host(hostname='c1',port='22',ip='1.1.1.1'),
    Host(hostname='c2',port='22',ip='1.1.1.2'),
    Host(hostname='c3',port='22',ip='1.1.1.3'),
    Host(hostname='c4',port='22',ip='1.1.1.4'),
    Host(hostname='c5',port='22',ip='1.1.1.5'),
])

session.add_all([
    HostUser(username='root'),
    HostUser(username='db'),
    HostUser(username='nb'),
    HostUser(username='sb'),
])

session.add_all([
    HostToHostUser(host_id=1,host_user_id=1),
    HostToHostUser(host_id=1,host_user_id=2),
    HostToHostUser(host_id=1,host_user_id=3),
    HostToHostUser(host_id=2,host_user_id=2),
    HostToHostUser(host_id=2,host_user_id=4),
    HostToHostUser(host_id=2,host_user_id=3),
])

session.commit()
session.close()

     

     

    • 普通多次查詢

     

    host_id = session.query(Host.nid).filter(Host.hostname=='c2').first()   #查詢hostbane對應的hostid,返回結果為元組(2,)
user_id_list = session.query(HostToHostUser.host_user_id).filter(HostToHostUser.host_id==host_id[0]).all()  #查詢hostid對應的所有userid
user_id_list = zip(*user_id_list)   #user_id_list 初始值為[(2,), (4,), (3,)],使用zip轉換為[2,4,3]物件
#print(list(user_id_list))    #結果為[(2, 4, 3)]
user_list = session.query(HostUser.username).filter(HostUser.nid.in_(list(user_id_list)[0])).all()  #查詢符合條件的使用者
print(user_list)

#或者：
user_id_list = session.query(HostToHostUser.host_user_id).join(Host).filter(Host.hostname=='c2').all()
user_id_list = zip(*user_id_list)
user_list = session.query(HostUser.username).filter(HostUser.nid.in_(list(user_id_list)[0])).all()
print(user_list)

     

     

    

輸出結果：
    [('db',), ('nb',), ('sb',)]

     

    • 使用relationship對映關係查詢

      • 首先在關係表Host_to_hostuser中加入relationship關係對映

       

      class HostToHostUser(Base):
    __tablename__ = 'host_to_host_user'
    nid = Column(Integer, primary_key=True,autoincrement=True)

    host_id = Column(Integer,ForeignKey('host.nid'))
    host_user_id = Column(Integer,ForeignKey('host_user.nid'))
    host = relationship('Host',backref='h') #對應host表
    host_user = relationship('HostUser',backref='u') #對應host_user表

       

       

      • 查詢

       

      #查詢一個伺服器上有哪些使用者
res = session.query(Host).filter(Host.hostname=='c2').first()  #返回的是符合條件的伺服器物件
res2 = res.h    #通過relationship反向查詢 Host_to_Hostuser中的對應關係
for i in res2:   #i為host_to_hostuser表和host表中c2主機有對應關係的條目
    print(i.host_user.username)        #正向查詢, 通過relationship ,找到host_to_hostuser中對應的hostuser 即i.host_user

#查詢此使用者有哪些伺服器
res = session.query(HostUser).filter(HostUser.username=='sb').first()
for i in res.u:
    print(i.host.hostname)

       

       

    • 擴充套件查詢

    不查詢關係表，直接在hostuser表中指定關係表，然後獲取host表

在host表中使用 relationship的secondary指定關係表。

 

class Host(Base):
    __tablename__ = 'host'
    nid = Column(Integer, primary_key=True,autoincrement=True)
    hostname = Column(String(32))
    port = Column(String(32))
    ip = Column(String(32))
    host_user = relationship('HostUser',secondary=lambda :HostToHostUser.__table__,backref='h')

注意使用lambda是為了使表的順序不在閒置

查詢：

host_obj = session.query(Host).filter(Host.hostname=='c1').first()
for i in host_obj.host_user:
    print(i.username)

相關推薦

python對Mysql操作和使用ORM框架（SQLAlchemy）

普通多次查詢 user_id_list = session.query(HostToHostUser.host_user_id).join(Host).filter(Host.hostname=='c2').all() user_id_list = zip(*user_id_list) us

Pisces的ORM框架（一） 需求背景和設計要點

需求背景 框架設計的時間點是2013年年底，當時我正在設計和開發一個視覺化的開發平臺。 這個平臺的首要特點是——使用者通過拖拽元件的方式，設計出表單，進而同步生成表單對映的業務物件的結構——譬如最簡單的例子，使用者物件對映的資料表是什麼，有多少欄位，每個欄位名、

python中關於操作時間的方法（二）：使用datetime模塊

log time模塊 bsp lib .py nth mon target ear 使用datetime模塊來獲取當前的日期和時間 1 import datetime 2 i=datetime.datetime.now() 3 print ("當前的日期和時間是%

python入門學習-列表和元組（1）

索引 個人 .so .cn pytho 入門 main 範圍 mage 數據結構是通過某種方式（例如對元素進行編號）組織在一起的數據元素的集合。這些數據元素可以是數字或者字符，甚至可以是其他數據結構。 在python中，最基本的數據結構是序列（seque

python學習筆記列表和元組（三）

python列表（list）是Python以及其他語言中最常用到的數據結構之一。Python使用使用中括號 [ ] 來解析列表。列表是可變的（mutable）——可以改變列表的內容。對應操作：1、查（[]切片操作） name = [‘tom‘,‘張三‘,‘joker‘,‘李四‘] print(name[2])

Python使用MySQL數據庫(新)（轉）

scroll 得到 插入 分享圖片 user for too linux values http://www.cnblogs.com/fnng/p/3565912.html 一，安裝mysql 如果是windows 用戶，mysql 的安裝非常簡單，直接下載安裝文件

Python基礎學習---語法和資料型別（一）

1 #!/usr/bin/python3 x="a" y="b" # 換行輸出 print( x ) print( y ) print('---------') # 不換行輸出 print( x, end=" " ) print( y, end=" " ) print()

Python語言資料結構和語言結構（2）

1. Python預備基礎 變數的命名 變數命名規則主要有以下幾條： 變數名只能包含字母、數字和下劃線，其中下劃線和字母可以開頭，數字不行，即info_1可以，而1_info不行； 變數名內不能包含空格，可以用下劃線替代，即info_1，而非info 1； 不能與Pyt

改善深層神經網路——超引數除錯、Batch正則化和程式框架（7）

目錄 1.超引數除錯 深度神經網路需要除錯的超引數（Hyperparameters）較多，包括： α：學習因子 β：動量梯度下降因子 ：Adam演算法引數 #layers：神經網路層數

MySQL操作命令大全使用（一）

資料庫操作命令 1，連線資料庫 mysql -u root -p Enter password: **** 或者mysql -uroot –proot -u 使用者名稱 –p 密碼 視覺化連線工具 navicat 2，退出MySQL exit; 或 q

使用Java的反射簡單的實現ORM框架（五）

用反射機制能幹什麼事          剛開始在使用jdbc時侯，在編寫訪問資料庫時寫到想吐，有八個表，每個表都有增刪改查中操作      那時候還不知道有反射機制這個概念，所以就對不同的表建立不同的dao類,這樣不僅開發速率地，而且程式碼      冗餘的厲害

spark安裝配置和程式碼框架（轉）

之前查閱原始碼啊，效能測試啊調優啊。。基本告一段落，專案也接近尾聲，那麼整理下spark所有配置引數與優化策略，方便以後開發與配置： Spark安裝配置與程式碼框架  spark-default.conf 配置 spark.executor.instance

python numpy 如何獲取和更改陣列（array）的形狀、維數-shape&reshape

主要用到shape, reshape函式 我們先搞清np.ndarrayd陣列的特點 import numpy as np ex = np.arange(0,12,1) ex # 括號裡的0可以省

easyui.utils.js 自己封裝的 使用easyui過程中方便操作和取值（一）

注意：該easyui.utils.js  會在我自己使用過程中不斷完善，大家一起進步。 在js上新增 以下 (function($){   function  其他方法。 })(jQuery); 的目的是為了防止該js檔案中的function與瀏覽器本身的一些functi

深入Java日記——自己寫一個ORM框架（1）

眾所周知，ORM框架有很多，例如Hibernate，MyBatis，還有BeetlSQL等等，裡面獲取有很多我們不需要的功能，本系列部落格主要教大家如何寫一個簡單的ORM框架 這個ORM框架主要有以下功能： 1. 生成JavaBean程式碼 2. 通過

OSGI企業應用開發（九）整合Spring和Mybatis框架（二）

上篇文章中，我們完成了在OSGI應用中整合Spring和Mybatis框架的準備工作，本節我們繼續Spring和Mybatis框架的整合。 一、解決OSGI整合Spring中的Placeholder問題 使用Spring框架的朋友應該都知道，我們可以在B

Python中的類和元類（metaclass）以及黑魔法（__metaclass__）

一、Python中的類 首先在這裡討論的python類，都是基於新式類進行討論。 在python中，一切皆為物件。 在理解元類之前我們先來重新理解一下python中的類。 class Joker: pass 當Python在執行帶clas

Python網絡爬蟲之Scrapy框架（CrawlSpider）

setting ref 網頁 del tle python網絡 yield 介紹 import 目錄 Python網絡爬蟲之Scrapy框架（CrawlSpider） CrawlSpider使用

27. Python對Mysql的操作（2）

python mysql1.遊標遊標是系統為用戶開設的一個數據緩沖區，存放SQL語句的執行結果用戶可以用SQL語句逐一從遊標中獲取記錄，並賦給主變量，交由python進一步處理，一組主變量一次只能存放一條記錄僅使用主變量並不能完全滿足SQL語句向應用程序輸出數據的要求遊標提供了一種對從表中檢索出的數據進行操作

Python 對Mysql的操作

簡化 execute use 創建 back delet ces values update Python連接數據庫的七個步驟 1、導入模塊 >>> import MySQLdb #因為裏面有大小寫，可以使用as mysql使之簡化