SQLAlchemy 中的對象關系映射器 · ZetCode 中文系列教程

# SQLAlchemy 中的對象關系映射器 > 原文： [http://zetcode.com/db/sqlalchemy/orm/](http://zetcode.com/db/sqlalchemy/orm/) 在 SQLAlchemy 教程的這一部分中，我們介紹了 SQLAlchemy 的對象關系映射器。 ## 對象關系映射使用 Python 數據庫 API 進行編程可為開發者提供直接訪問數據庫的全部功能。這種直接訪問也有一些缺點。它們在大型項目中尤其引人注目。我們將兩種語言混合在一起：SQL 和 Python。結果是它使 SQL 語句更難測試和維護。在典型的 Web 應用中，除了 Python 和 SQL（或任何其他服務器端編程語言）外，我們還具有 HTML，CSS，JavaScript。 Python 和 SQL 捆綁在一起使項目變得更加復雜。在編程理論中，我們嘗試將業務邏輯與數據訪問以及表示分離。因此，需要一種將 Python 代碼與 SQL 代碼分開的解決方案。另一個問題是我們所謂的對象關系阻抗不匹配。當關系數據庫管理系統被以面向對象的編程語言或風格編寫的程序使用時，通常會遇到一系列概念和技術難題。在 Python 中，我們處理放置在對象內的數據。在數據庫系統中，數據存儲在表中。程序員需要在兩種處理數據的方式之間進行轉換。這與我們應用的核心問題無關。解決方案之一是對象關系映射。 ORM 工具解決了上述問題。有幾種用于 Python 語言的 ORM 工具。 SQLAlchemy 是使用最廣泛的方法之一。 ## SQLAlchemy ORM SQLAlchemy 對象關系映射器將（a）用戶定義的 Python 類映射到數據庫表，（b）將表行映射到實例對象，并且（c）將列映射到實例屬性。 SQLAlchemy ORM 建立在 SQLAlchemy 表達式語言之上。使用 ORM 時，我們首先配置將要使用的數據庫表。然后，我們定義將要映射到它們的類。現代 SQLAlchemy 使用聲明式系統來執行這些任務。將創建一個聲明性基類，該基類維護類和表的目錄。使用`declarative_base()`函數創建一個聲明性基類。 ## 會話完成配置后，我們創建一個會話。會話是 SQLAlchemy ORM 中持久性操作的主要接口。它建立并維護我們的程序與數據庫之間的所有對話。 ## 建立表以下程序在內存中創建一個表，然后將數據打印到控制臺。 `orm_create_table.py` ```py #!/usr/bin/python # -*- coding: utf-8 -*- from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String from sqlalchemy.orm import sessionmaker eng = create_engine('sqlite:///:memory:') Base = declarative_base() class Car(Base): __tablename__ = "Cars" Id = Column(Integer, primary_key=True) Name = Column(String) Price = Column(Integer) Base.metadata.bind = eng Base.metadata.create_all() Session = sessionmaker(bind=eng) ses = Session() ses.add_all( [Car(Id=1, Name='Audi', Price=52642), Car(Id=2, Name='Mercedes', Price=57127), Car(Id=3, Name='Skoda', Price=9000), Car(Id=4, Name='Volvo', Price=29000), Car(Id=5, Name='Bentley', Price=350000), Car(Id=6, Name='Citroen', Price=21000), Car(Id=7, Name='Hummer', Price=41400), Car(Id=8, Name='Volkswagen', Price=21600)]) ses.commit() rs = ses.query(Car).all() for car in rs: print car.Name, car.Price ``` 在`Cars`表中創建了八輛汽車。 ```py Base = declarative_base() ``` 使用`declarative_base()`函數創建一個聲明性基類。 ```py class Car(Base): __tablename__ = "Cars" Id = Column(Integer, primary_key=True) Name = Column(String) Price = Column(Integer) ``` 用戶定義的`Car`類映射到`Cars`表。該類繼承自聲明性基類。 ```py Base.metadata.bind = eng ``` 聲明式`Base`綁定到數據庫引擎。 ```py Base.metadata.create_all() ``` `create_all()`方法創建所有已配置的表；在我們的例子中，只有一張表。 ```py Session = sessionmaker(bind=eng) ses = Session() ``` 創建會話對象。 ```py ses.add_all( [Car(Id=1, Name='Audi', Price=52642), Car(Id=2, Name='Mercedes', Price=57127), ... ``` 使用`add_all()`方法，我們將`Car`類的指定實例添加到會話中。 ```py ses.commit() ``` 使用`commit()`方法將更改提交到數據庫。 ```py rs = ses.query(Car).all() ``` 我們從 Cars 表中查詢所有數據。 `query()`方法加載`Car`類的所有實例，其`all()`方法將查詢表示的所有結果作為列表返回。 ```py for car in rs: print car.Name, car.Price ``` 我們遍歷結果集并為所有返回的行打印兩列。 ```py $ ./orm_create_table.py Audi 52642 Mercedes 57127 Skoda 9000 Volvo 29000 Bentley 350000 Citroen 21000 Hummer 41400 Volkswagen 21600 ``` 這是示例的輸出。 ## 添加新的汽車在下一個示例中，我們將單個汽車添加到`Cars`表中。 `orm_add_car.py` ```py #!/usr/bin/python # -*- coding: utf-8 -*- from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String from sqlalchemy.orm import sessionmaker eng = create_engine('sqlite:///test.db') Base = declarative_base() class Car(Base): __tablename__ = "Cars" Id = Column(Integer, primary_key=True) Name = Column(String) Price = Column(Integer) Session = sessionmaker(bind=eng) ses = Session() c1 = Car(Name='Oldsmobile', Price=23450) ses.add(c1) ses.commit() rs = ses.query(Car).all() for car in rs: print car.Name, car.Price ``` 該腳本連接到 SQLite 數據庫，并向`Cars`表添加新行。 ```py eng = create_engine('sqlite:///test.db') ``` 我們連接到 SQLite `test.db`數據庫。 ```py Base = declarative_base() class Car(Base): __tablename__ = "Cars" Id = Column(Integer, primary_key=True) Name = Column(String) Price = Column(Integer) ``` 執行用戶定義的類到數據庫表的映射。 ```py Session = sessionmaker(bind=eng) ses = Session() ``` 創建會話對象，該對象是 ORM 到數據庫的中介。 ```py c1 = Car(Name='Oldsmobile', Price=23450) ``` 創建映射的`Car`類的新實例。 ```py ses.add(c1) ``` `add()`方法將新對象添加到會話中。 ```py ses.commit() ``` 所做的更改將提交到數據庫。 ```py $ ./orm_add_car.py Audi 52642 Mercedes 57127 Skoda 9000 Volvo 29000 Bentley 350000 Citroen 21000 Hummer 41400 Volkswagen 21600 Oldsmobile 23450 ``` 我們確認新車已成功添加到數據庫中。 ## 過濾數據會話查詢的`filter()`方法用于在查詢對象上應用過濾條件。 `orm_query_like.py` ```py #!/usr/bin/python # -*- coding: utf-8 -*- from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String from sqlalchemy.orm import sessionmaker eng = create_engine('sqlite:///test.db') Base = declarative_base() Base.metadata.bind = eng class Car(Base): __tablename__ = "Cars" Id = Column(Integer, primary_key=True) Name = Column(String) Price = Column(Integer) Session = sessionmaker(bind=eng) ses = Session() rs = ses.query(Car).filter(Car.Name.like('%en')) for car in rs: print car.Name, car.Price ``` 該示例打印名稱以`"en"`字符串結尾的汽車。 ```py rs = ses.query(Car).filter(Car.Name.like('%en')) ``` `filter()`方法采用一個過濾條件，它是一個 SQL 表達式對象。使用`like()`方法創建標準。 ```py $ ./orm_query_like.py Citroen 21000 Volkswagen 21600 ``` 表中有兩輛以`"en"`字符串結尾的汽車。 `in_()`方法實現 SQL `IN`運算符。 `orm_query_in.py` ```py #!/usr/bin/python # -*- coding: utf-8 -*- from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String from sqlalchemy.orm import sessionmaker eng = create_engine('sqlite:///test.db') Base = declarative_base() class Car(Base): __tablename__ = "Cars" Id = Column(Integer, primary_key=True) Name = Column(String) Price = Column(Integer) Session = sessionmaker(bind=eng) ses = Session() rs = ses.query(Car).filter(Car.Id.in_([2, 4, 6, 8])) for car in rs: print car.Id, car.Name, car.Price ``` 該代碼示例選擇并打印 SQL `IN`運算符選擇的具有 ID 的行的列。 ```py rs = ses.query(Car).filter(Car.Id.in_([2, 4, 6, 8])) ``` 過濾條件是通過`in_()`方法創建的。該方法采用 ID 列表。 ```py $ ./orm_query_in.py 2 Mercedes 57127 4 Volvo 29000 6 Citroen 21000 8 Volkswagen 21600 ``` 這是示例的輸出。 ## 外鍵在最后一個示例中，我們處理了兩個表之間的關系。建立外鍵。 `orm_foreign_key.py` ```py #!/usr/bin/python # -*- coding: utf-8 -*- from sqlalchemy import create_engine, ForeignKey from sqlalchemy.ext.declarative import declarative_base from sqlalchemy import Column, Integer, String from sqlalchemy.orm import sessionmaker, relationship eng = create_engine('sqlite:///test.db') Base = declarative_base() class Author(Base): __tablename__ = "Authors" AuthorId = Column(Integer, primary_key=True) Name = Column(String) Books = relationship("Book") class Book(Base): __tablename__ = "Books" BookId = Column(Integer, primary_key=True) Title = Column(String) AuthorId = Column(Integer, ForeignKey("Authors.AuthorId")) Author = relationship("Author") Session = sessionmaker(bind=eng) ses = Session() res = ses.query(Author).filter(Author.Name=="Leo Tolstoy").first() for book in res.Books: print book.Title res = ses.query(Book).filter(Book.Title=="Emma").first() print res.Author.Name ``` 我們有`Author`和`Book`類，它們映射到`Authors`和`Books`數據庫表。（用于創建表的 SQL 在第一章中列出）。在兩個表之間實現了外鍵約束。外鍵由`ForeignKey`類型和`relationship()`函數定義。 ```py Books = relationship("Book") ``` 在兩個類之間建立了一對多的關系。 `relationship()`函數的第一個參數是與之建立關系的類的名稱。結果，作者對象將具有`Books`屬性。 ```py AuthorId = Column(Integer, ForeignKey("Authors.AuthorId")) ``` `Book`類的`AuthorId`是外鍵。它由`ForeignKey`類型定義。它引用`Authors`表中的`AuthorId`列。 ```py Author = relationship("Author") ``` 此行為`Book`類創建`Author`屬性。 ```py res = ses.query(Author).filter(Author.Name=="Leo Tolstoy").first() ``` 在此查詢中，我們獲得了列夫·托爾斯泰（Leo Tolstoy）撰寫的所有書籍。 `filter()`方法對查詢應用過濾條件。 `first()`方法獲取作者對象。 ```py for book in res.Books: print book.Title ``` 我們瀏覽結果集并打印所有檢索到的書。 `Books`屬性是使用`relationship()`函數創建的。 ```py res = ses.query(Book).filter(Book.Title=="Emma").first() print res.Author.Name ``` 該查詢返回`Emma`標題的作者。該查詢返回具有內置`Author`屬性的`book`對象。 ```py $ ./orm_foreign_key.py War and Peace Anna Karenia Jane Austen ``` 這是示例的輸出。在 SQLAlchemy 教程的這一部分中，我們使用了 SQLAlchemy 的 ORM。