sqlalchemy

orm介紹

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

orm的優勢:

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

缺點:

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

sqlalchemy

在Python中，最有名的ORM框架是SQLAlchemy。用戶包括openstack＼Dropbox等知名公司或應用，主要用戶列表http://www.sqlalchemy.org/organizations.html#openstack

sqlalchemy的基本使用

建立表結構

 1 mport sqlalchemy
 2 from sqlalchemy import create_engine
 3 from sqlalchemy.ext.declarative import declarative_base
 4 from sqlalchemy import Column, Integer, String
 5  
 6 engine = create_engine("mysql+pymysql://root:alex3714@localhost/testdb",
 7                                     encoding='utf-8', echo=True)
 8  
 9  
10 Base = declarative_base() #生成orm基類
11  
12 class User(Base):
13     __tablename__ = 'user' #表名
14     id = Column(Integer, primary_key=True)
15     name = Column(String(32))
16     password = Column(String(64))
17  
18 Base.metadata.create_all(engine) #建立表結構

View Code

建立數據

 1 Session_class = sessionmaker(bind=engine) #建立與數據庫的會話session class ,注意,這裏返回給session的是個class,不是實例
 2 Session = Session_class() #生成session實例
 3  
 4  
 5 user_obj = User(name="alex",password="alex3714") #生成你要建立的數據對象
 6 print(user_obj.name,user_obj.id)  #此時還沒建立對象呢，不信你打印一下id發現仍是None
 7  
 8 Session.add(user_obj) #把要建立的數據對象添加到這個session裏， 一會統一建立
 9 print(user_obj.name,user_obj.id) #此時也依然還沒建立
10  
11 Session.commit() #現此才統一提交，建立數據

View Code

查詢

 1 my_user = Session.query(User).filter_by(name="alex").first()
 2 print(my_user)
 3 
 4 #輸出
 5 <__main__.User object at 0x105b4ba90>
 6 
 7 print(my_user.id,my_user.name,my_user.password)
 8 
 9 #輸出
10 alex alex3714

不過剛纔上面的顯示的內存對象對址你是沒辦法分清返回的是什麼數據的，除非打印具體字段看一下，若是想讓它變的可讀，只需在定義表的類下面加上這樣的代碼

1 def __repr__(self):
2     return "<User(name='%s',  password='%s')>" % (
3         self.name, self.password)

修改

1 my_user = Session.query(User).filter_by(name="alex").first()
2  
3 my_user.name = "Alex Li"
4  
5 Session.commit()

回滾

 1 my_user = Session.query(User).filter_by(id=1).first()
 2 my_user.name = "Jack"
 3  
 4  
 5 fake_user = User(name='Rain', password='12345')
 6 Session.add(fake_user)
 7  
 8 print(Session.query(User).filter(User.name.in_(['Jack','rain'])).all() )  #這時看session裏有你剛添加和修改的數據
 9  
10 Session.rollback() #此時你rollback一下
11  
12 print(Session.query(User).filter(User.name.in_(['Jack','rain'])).all() ) #再查就發現剛纔添加的數據沒有了。
13  
14 # Session
15 # Session.commit()

獲取全部數據

1 print(Session.query(User.name,User.id).all() )

多條件查詢

1 objs = Session.query(User).filter(User.id>0).filter(User.id<7).all()

統計

Session.query(User).filter(User.name.like("Ra%")).count()

分組

from sqlalchemy import func
print(Session.query(func.count(User.name),User.name).group_by(User.name).all() )

外鍵關聯

 1 from sqlalchemy import ForeignKey
 2 from sqlalchemy.orm import relationship
 3  
 4 class Address(Base):
 5     __tablename__ = 'addresses'
 6     id = Column(Integer, primary_key=True)
 7     email_address = Column(String(32), nullable=False)
 8     user_id = Column(Integer, ForeignKey('user.id'))
 9  
10     user = relationship("User", backref="addresses") #這個nb，容許你在user表裏經過backref字段反向查出全部它在addresses表裏的關聯項
11  
12     def __repr__(self):
13         return "<Address(email_address='%s')>" % self.email_address

建立關聯對象

1 obj = Session.query(User).filter(User.name=='rain').all()[0]
2 print(obj.addresses)
3  
4 obj.addresses = [Address(email_address="r1@126.com"), #添加關聯對象
5                  Address(email_address="r2@126.com")]
6  
7  
8 Session.commit()

反查

1 obj = Session.query(User).first()
2 for i in obj.addresses: #經過user對象反查關聯的addresses記錄
3     print(i)
4  
5 addr_obj = Session.query(Address).first()
6 print(addr_obj.user.name)  #在addr_obj裏直接查關聯的user表

連表查詢

1 ret=Session.query(User,Address).filter(User.id==Address.id).all()
2 print(ret)

多外鍵關聯

 1 from sqlalchemy import Integer, ForeignKey, String, Column
 2 from sqlalchemy.ext.declarative import declarative_base
 3 from sqlalchemy.orm import relationship
 4  
 5 Base = declarative_base()
 6  
 7 class Customer(Base):
 8     __tablename__ = 'customer'
 9     id = Column(Integer, primary_key=True)
10     name = Column(String)
11  
12     billing_address_id = Column(Integer, ForeignKey("address.id"))
13     shipping_address_id = Column(Integer, ForeignKey("address.id"))
14  
15     billing_address = relationship("Address", foreign_keys=[billing_address_id])
16     shipping_address = relationship("Address", foreign_keys=[shipping_address_id])
17  
18 class Address(Base):
19     __tablename__ = 'address'
20     id = Column(Integer, primary_key=True)
21     street = Column(String)
22     city = Column(String)
23     state = Column(String)

多對多關係

多對多建立

 1 #一本書能夠有多個做者，一個做者又能夠出版多本書
 2 
 3 
 4 from sqlalchemy import Table, Column, Integer,String,DATE, ForeignKey
 5 from sqlalchemy.orm import relationship
 6 from sqlalchemy.ext.declarative import declarative_base
 7 from sqlalchemy import create_engine
 8 from sqlalchemy.orm import sessionmaker
 9 
10 
11 Base = declarative_base()
12 
13 book_m2m_author = Table('book_m2m_author', Base.metadata,
14                         Column('book_id',Integer,ForeignKey('books.id')),
15                         Column('author_id',Integer,ForeignKey('authors.id')),
16                         )
17 
18 class Book(Base):
19     __tablename__ = 'books'
20     id = Column(Integer,primary_key=True)
21     name = Column(String(64))
22     pub_date = Column(DATE)
23     authors = relationship('Author',secondary=book_m2m_author,backref='books')
24 
25     def __repr__(self):
26         return self.name
27 
28 class Author(Base):
29     __tablename__ = 'authors'
30     id = Column(Integer, primary_key=True)
31     name = Column(String(32))
32 
33     def __repr__(self):
34         return self.name
35 
36 Session_class = sessionmaker(bind=engine) #建立與數據庫的會話session class ,注意,這裏返回給session的是個class,不是實例
37 s = Session_class() #生成session實例
38  
39 b1 = Book(name="跟Alex學Python")
40 b2 = Book(name="跟Alex學把妹")
41 b3 = Book(name="跟Alex學裝逼")
42 b4 = Book(name="跟Alex學開車")
43  
44 a1 = Author(name="Alex")
45 a2 = Author(name="Jack")
46 a3 = Author(name="Rain")
47  
48 b1.authors = [a1,a2]
49 b2.authors = [a1,a2,a3]
50  
51 s.add_all([b1,b2,b3,b4,a1,a2,a3])
52  
53 s.commit()

View Code

查詢數據

1 print('--------經過書表查關聯的做者---------')
2  
3 book_obj = s.query(Book).filter_by(name="跟Alex學Python").first()
4 print(book_obj.name, book_obj.authors)
5  
6 print('--------經過做者表查關聯的書---------')
7 author_obj =s.query(Author).filter_by(name="Alex").first()
8 print(author_obj.name , author_obj.books)
9 s.commit()

輸出以下：

1 --------經過書表查關聯的做者---------
2 跟Alex學Python [Alex, Jack]
3 --------經過做者表查關聯的書---------
4 Alex [跟Alex學把妹, 跟Alex學Python]

多對多刪除

經過書刪除做者

1 author_obj =s.query(Author).filter_by(name="Jack").first()
2  
3 book_obj = s.query(Book).filter_by(name="跟Alex學把妹").first()
4  
5 book_obj.authors.remove(author_obj) #從一本書裏刪除一個做者
6 s.commit()

直接刪除做者

1 author_obj =s.query(Author).filter_by(name="Alex").first()
2 # print(author_obj.name , author_obj.books)
3 s.delete(author_obj)
4 s.commit()