Hướng dẫn này bao gồm API SQLAlchemy ORM nổi tiếng đã được sử dụng trong nhiều năm. Kể từ SQLAlchemy 1. 4, có hai kiểu sử dụng ORM riêng biệt được gọi là 1. phong cách x và 2. 0, kiểu thứ hai tạo ra một loạt các thay đổi nổi bật nhất xung quanh cách các truy vấn ORM được xây dựng và thực thi
Kế hoạch là trong SQLAlchemy 2. 0, 1. x của việc sử dụng ORM sẽ được coi là kế thừa và không còn xuất hiện trong tài liệu và nhiều khía cạnh của nó sẽ bị xóa. Tuy nhiên, yếu tố trọng tâm nhất của 1. Việc sử dụng ORM kiểu x, đối tượng
>>> Session.configure[bind=engine] # once engine is available3, sẽ vẫn khả dụng cho các trường hợp sử dụng cũ lâu dài
Hướng dẫn này có thể áp dụng cho những người dùng muốn tìm hiểu cách SQLAlchemy đã được sử dụng trong nhiều năm, đặc biệt là những người dùng làm việc với các ứng dụng hiện có hoặc tài liệu học tập có liên quan trong 1. phong cách x
Để có phần giới thiệu về SQLAlchemy từ phiên bản 1 mới. 2/4. 0, xem SQLAlchemy 1. 2/4. 0 Hướng dẫn
Trình ánh xạ quan hệ đối tượng SQLAlchemy trình bày một phương pháp liên kết các lớp Python do người dùng định nghĩa với các bảng cơ sở dữ liệu và các thể hiện của các lớp [đối tượng] đó với các hàng trong bảng tương ứng của chúng. Nó bao gồm một hệ thống đồng bộ hóa một cách rõ ràng tất cả các thay đổi về trạng thái giữa các đối tượng và các hàng liên quan của chúng, được gọi là một đơn vị công việc, cũng như một hệ thống để thể hiện các truy vấn cơ sở dữ liệu theo các lớp do người dùng xác định và các mối quan hệ được xác định của chúng với nhau
ORM trái ngược với Ngôn ngữ biểu thức SQLAlchemy, trên đó ORM được xây dựng. Trong khi Ngôn ngữ biểu thức SQL, được giới thiệu trong Hướng dẫn ngôn ngữ biểu thức SQL [1. x API], trình bày một hệ thống biểu diễn các cấu trúc nguyên thủy của cơ sở dữ liệu quan hệ một cách trực tiếp mà không cần ý kiến, ORM trình bày một mô hình sử dụng mức độ cao và trừu tượng, bản thân nó là một ví dụ về việc sử dụng Ngôn ngữ Biểu thức được áp dụng
Mặc dù có sự trùng lặp giữa các kiểu sử dụng của ORM và Ngôn ngữ biểu thức, nhưng những điểm tương đồng là bề ngoài hơn so với lúc đầu chúng có thể xuất hiện. Một cách tiếp cận cấu trúc và nội dung của dữ liệu từ góc độ của mô hình miền do người dùng xác định, mô hình này được duy trì và làm mới một cách minh bạch từ mô hình lưu trữ cơ bản của nó. Phương pháp khác tiếp cận nó từ quan điểm của lược đồ theo nghĩa đen và biểu diễn biểu thức SQL được cấu tạo rõ ràng thành các thông báo được cơ sở dữ liệu sử dụng riêng lẻ
Một ứng dụng thành công có thể được xây dựng bằng cách sử dụng riêng Trình ánh xạ quan hệ đối tượng. Trong các tình huống nâng cao, một ứng dụng được xây dựng bằng ORM có thể thỉnh thoảng sử dụng Ngôn ngữ biểu thức trực tiếp ở một số khu vực nhất định yêu cầu tương tác cơ sở dữ liệu cụ thể
Hướng dẫn sau đây ở định dạng doctest, nghĩa là mỗi dòng
>>> Session.configure[bind=engine] # once engine is available4 đại diện cho nội dung mà bạn có thể nhập tại dấu nhắc lệnh Python và văn bản sau đây đại diện cho giá trị trả về dự kiến
Kiểm tra phiên bản
Kiểm tra nhanh để xác minh rằng chúng tôi đang sử dụng ít nhất phiên bản 1. 4 của SQLAlchemy
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.0
Đang kết nối
Đối với hướng dẫn này, chúng tôi sẽ sử dụng cơ sở dữ liệu SQLite chỉ trong bộ nhớ. Để kết nối, chúng tôi sử dụng
>>> Session.configure[bind=engine] # once engine is available5
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]
Cờ
>>> Session.configure[bind=engine] # once engine is available6 là lối tắt để thiết lập ghi nhật ký SQLAlchemy, được thực hiện thông qua mô-đun
>>> Session.configure[bind=engine] # once engine is available7 tiêu chuẩn của Python. Khi nó được bật, chúng ta sẽ thấy tất cả SQL được tạo. Nếu bạn đang làm việc thông qua hướng dẫn này và muốn tạo ra ít đầu ra hơn, hãy đặt nó thành
>>> Session.configure[bind=engine] # once engine is available8. Hướng dẫn này sẽ định dạng SQL phía sau cửa sổ bật lên để nó không cản trở chúng ta;
Giá trị trả về của
>>> Session.configure[bind=engine] # once engine is available5 là một phiên bản của
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]00 và nó đại diện cho giao diện cốt lõi của cơ sở dữ liệu, được điều chỉnh thông qua một phương ngữ xử lý các chi tiết của cơ sở dữ liệu và DBAPI đang sử dụng. Trong trường hợp này, phương ngữ SQLite sẽ diễn giải các hướng dẫn cho mô-đun
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]01 tích hợp Python
Lần đầu tiên một phương thức như
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]02 hoặc
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]03 được gọi,
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]00 sẽ thiết lập kết nối DBAPI thực tới cơ sở dữ liệu, kết nối này sau đó được sử dụng để phát ra SQL. Khi sử dụng ORM, chúng tôi thường không sử dụng trực tiếp
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]00 sau khi tạo;
Khai báo một ánh xạ
Khi sử dụng ORM, quy trình cấu hình bắt đầu bằng cách mô tả các bảng cơ sở dữ liệu mà chúng ta sẽ xử lý, sau đó bằng cách xác định các lớp của riêng chúng ta sẽ được ánh xạ tới các bảng đó. Trong SQLAlchemy hiện đại, hai tác vụ này thường được thực hiện cùng nhau, sử dụng một hệ thống được gọi là Phần mở rộng khai báo, cho phép chúng tôi tạo các lớp bao gồm các chỉ thị để mô tả bảng cơ sở dữ liệu thực mà chúng sẽ được ánh xạ tới.
Các lớp được ánh xạ bằng hệ thống Khai báo được định nghĩa theo thuật ngữ của một lớp cơ sở duy trì một danh mục các lớp và bảng liên quan đến cơ sở đó - đây được gọi là lớp cơ sở khai báo. Ứng dụng của chúng tôi thường sẽ chỉ có một phiên bản của cơ sở này trong một mô-đun thường được nhập. Chúng tôi tạo lớp cơ sở bằng hàm
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]06, như sau
>>> Session.configure[bind=engine] # once engine is available6
Bây giờ chúng ta có một “cơ sở”, chúng ta có thể định nghĩa bất kỳ số lượng lớp được ánh xạ nào theo nó. Chúng tôi sẽ bắt đầu chỉ với một bảng duy nhất có tên là
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]07, bảng này sẽ lưu trữ các bản ghi cho người dùng cuối sử dụng ứng dụng của chúng tôi. Một lớp mới có tên là
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 sẽ là lớp mà chúng tôi ánh xạ bảng này. Trong lớp, chúng tôi xác định chi tiết về bảng mà chúng tôi sẽ ánh xạ tới, chủ yếu là tên bảng, tên và kiểu dữ liệu của các cột
>>> Session.configure[bind=engine] # once engine is available9
Một lớp sử dụng Khai báo ở mức tối thiểu cần có thuộc tính
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]09 và ít nhất một
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]10 là một phần của khóa chính. SQLAlchemy không bao giờ tự đưa ra bất kỳ giả định nào về bảng mà một lớp tham chiếu tới, kể cả việc nó không có quy ước dựng sẵn cho tên, kiểu dữ liệu hoặc ràng buộc. Nhưng điều này không có nghĩa là bắt buộc phải có bản soạn sẵn;
Khi lớp của chúng ta được xây dựng, Khai báo sẽ thay thế tất cả các đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]10 bằng các bộ truy cập Python đặc biệt được gọi là bộ mô tả; . Lớp được ánh xạ “có công cụ” sẽ cung cấp cho chúng ta phương tiện để tham chiếu đến bảng của chúng ta trong ngữ cảnh SQL cũng như duy trì và tải các giá trị của các cột từ cơ sở dữ liệu
Ngoài những gì quá trình ánh xạ thực hiện với lớp của chúng ta, thì lớp này chủ yếu vẫn là một lớp Python bình thường, mà chúng ta có thể định nghĩa bất kỳ số lượng thuộc tính và phương thức thông thường nào mà ứng dụng của chúng ta cần
Tạo một lược đồ
Với lớp
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 của chúng tôi được xây dựng thông qua hệ thống Khai báo, chúng tôi đã xác định thông tin về bảng của mình, được gọi là siêu dữ liệu bảng. Đối tượng được SQLAlchemy sử dụng để biểu diễn thông tin này cho một bảng cụ thể được gọi là đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]13 và ở đây Declarative đã tạo một đối tượng cho chúng ta. Chúng ta có thể thấy đối tượng này bằng cách kiểm tra thuộc tính
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]14
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.06
Khi chúng tôi khai báo lớp của mình, Declarative đã sử dụng siêu dữ liệu Python để thực hiện các hoạt động bổ sung sau khi khai báo lớp hoàn tất; . Đối tượng này là một đối tượng ẩn sau mà chúng ta thường không cần xử lý trực tiếp [mặc dù nó có thể cung cấp nhiều thông tin về ánh xạ của chúng ta khi chúng ta cần]
Đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]13 là thành viên của một bộ sưu tập lớn hơn được gọi là
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]18. Khi sử dụng Khai báo, đối tượng này có sẵn bằng cách sử dụng thuộc tính
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]19 của lớp cơ sở khai báo của chúng tôi
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]18 là một sổ đăng ký bao gồm khả năng phát ra một tập hợp giới hạn các lệnh tạo lược đồ tới cơ sở dữ liệu. Vì cơ sở dữ liệu SQLite của chúng tôi thực sự không có bảng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]07, chúng tôi có thể sử dụng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]18 để đưa ra các câu lệnh CREATE TABLE cho cơ sở dữ liệu cho tất cả các bảng chưa tồn tại. Dưới đây, chúng tôi gọi phương thức
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]23, chuyển vào
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]00 của chúng tôi làm nguồn kết nối cơ sở dữ liệu. Chúng ta sẽ thấy rằng các lệnh đặc biệt được phát ra đầu tiên để kiểm tra sự hiện diện của bảng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]07 và sau đó là câu lệnh
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]26 thực tế
>>> Session.configure[bind=engine] # once engine is available9
Tạo một thể hiện của lớp đã ánh xạ
Khi ánh xạ hoàn tất, bây giờ hãy tạo và kiểm tra một đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]1
Mặc dù chúng tôi không chỉ định nó trong hàm tạo, nhưng thuộc tính
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]28 vẫn tạo ra giá trị là
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]29 khi chúng tôi truy cập nó [trái ngược với hành vi thông thường của Python là tăng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]30 cho một thuộc tính không xác định]. Công cụ của SQLAlchemy thường tạo ra giá trị mặc định này cho các thuộc tính ánh xạ cột khi truy cập lần đầu. Đối với những thuộc tính mà chúng tôi thực sự đã gán một giá trị, hệ thống thiết bị sẽ theo dõi các phép gán đó để sử dụng trong một câu lệnh INSERT cuối cùng sẽ được phát ra cơ sở dữ liệu
Tạo một phiên
Bây giờ chúng tôi đã sẵn sàng để bắt đầu nói chuyện với cơ sở dữ liệu. "Xử lý" của ORM đối với cơ sở dữ liệu là
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31. Khi chúng tôi thiết lập ứng dụng lần đầu tiên, ở cùng cấp độ với câu lệnh
>>> Session.configure[bind=engine] # once engine is available5 của chúng tôi, chúng tôi xác định một lớp
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 sẽ phục vụ như một nhà máy cho các đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 mới
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]9
Trong trường hợp ứng dụng của bạn chưa có
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]00 khi bạn xác định các đối tượng cấp mô-đun, chỉ cần thiết lập nó như thế này
>>> Session.configure[bind=engine] # once engine is available1
Sau này, khi bạn tạo công cụ của mình với
>>> Session.configure[bind=engine] # once engine is available5, hãy kết nối nó với
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 bằng cách sử dụng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]38
>>> Session.configure[bind=engine] # once engine is available
Lớp
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 tùy chỉnh này sẽ tạo các đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 mới được liên kết với cơ sở dữ liệu của chúng tôi. Các đặc điểm giao dịch khác cũng có thể được xác định khi gọi
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]41; . Sau đó, bất cứ khi nào bạn cần trao đổi với cơ sở dữ liệu, bạn khởi tạo một
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 ở trên được liên kết với
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]00 hỗ trợ SQLite của chúng tôi, nhưng nó chưa mở bất kỳ kết nối nào. Khi được sử dụng lần đầu tiên, nó sẽ truy xuất kết nối từ nhóm kết nối được duy trì bởi
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]00 và giữ kết nối đó cho đến khi chúng tôi thực hiện tất cả các thay đổi và/hoặc đóng đối tượng phiên
Thêm và cập nhật đối tượng
Để duy trì đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 của chúng tôi, chúng tôi
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]47 nó vào
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 của chúng tôi
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]0
Tại thời điểm này, chúng tôi nói rằng phiên bản đang chờ xử lý; .
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 sẽ phát hành SQL để duy trì
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]50 ngay khi cần, sử dụng quy trình được gọi là flush. Nếu chúng tôi truy vấn cơ sở dữ liệu cho
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]50, tất cả thông tin đang chờ xử lý sẽ được xóa trước tiên và truy vấn được đưa ra ngay sau đó
Ví dụ: bên dưới, chúng tôi tạo một đối tượng
>>> Session.configure[bind=engine] # once engine is available3 mới tải các phiên bản của
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08. Chúng tôi “lọc theo” thuộc tính
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]54 của
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]55 và cho biết rằng chúng tôi chỉ muốn kết quả đầu tiên trong danh sách đầy đủ các hàng. Phiên bản
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 được trả về tương đương với phiên bản mà chúng tôi đã thêm
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]1
Trên thực tế,
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 đã xác định rằng hàng được trả về là cùng một hàng với hàng đã được biểu thị trong bản đồ đối tượng bên trong của nó, vì vậy chúng tôi thực sự đã lấy lại phiên bản giống hệt như mà chúng tôi vừa thêm vào
Khái niệm ORM tại nơi làm việc ở đây được gọi là bản đồ nhận dạng và đảm bảo rằng tất cả các hoạt động trên một hàng cụ thể trong một
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 hoạt động trên cùng một bộ dữ liệu. Khi một đối tượng có khóa chính cụ thể xuất hiện trong
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31, tất cả các truy vấn SQL trên
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 đó sẽ luôn trả về cùng một đối tượng Python cho khóa chính cụ thể đó;
Chúng ta có thể thêm nhiều đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 cùng một lúc bằng cách sử dụng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]62
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]2
Ngoài ra, chúng tôi đã quyết định biệt danh của Ed không hay lắm, vì vậy hãy thay đổi nó
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]3
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 đang chú ý. Ví dụ, nó biết rằng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]50 đã được sửa đổi
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]4
và ba đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 mới đang chờ xử lý
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]5
Chúng tôi nói với
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 rằng chúng tôi muốn phát hành tất cả các thay đổi còn lại đối với cơ sở dữ liệu và cam kết giao dịch đã được tiến hành trong suốt. Chúng tôi làm điều này thông qua
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]67.
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 phát ra câu lệnh
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]69 cho sự thay đổi tên hiệu trên “ed”, cũng như câu lệnh
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]70 cho ba đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 mới mà chúng tôi đã thêm
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]67 xóa các thay đổi còn lại vào cơ sở dữ liệu và cam kết giao dịch. Các tài nguyên kết nối được tham chiếu bởi phiên hiện được trả lại cho nhóm kết nối. Các hoạt động tiếp theo với phiên này sẽ diễn ra trong một giao dịch mới, giao dịch này sẽ lấy lại tài nguyên kết nối khi cần lần đầu
Nếu chúng ta nhìn vào thuộc tính
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]28 của Ed, trước đó là
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]29, thì bây giờ nó có giá trị
Sau khi
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 chèn các hàng mới vào cơ sở dữ liệu, tất cả các mã định danh mới được tạo và các giá trị mặc định do cơ sở dữ liệu tạo sẽ có sẵn trên phiên bản, ngay lập tức hoặc thông qua tải khi truy cập lần đầu. Trong trường hợp này, toàn bộ hàng đã được tải lại khi truy cập vì một giao dịch mới đã được bắt đầu sau khi chúng tôi phát hành
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]67. SQLAlchemy theo mặc định làm mới dữ liệu từ một giao dịch trước đó vào lần đầu tiên nó được truy cập trong một giao dịch mới, để trạng thái gần đây nhất khả dụng. Mức tải lại có thể định cấu hình như được mô tả trong Sử dụng phiên
Quay lại
Vì
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31 hoạt động trong một giao dịch, chúng tôi cũng có thể khôi phục các thay đổi đã thực hiện. Hãy thực hiện hai thay đổi mà chúng tôi sẽ hoàn nguyên;
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]6
và chúng tôi sẽ thêm một người dùng sai khác,
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]80
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]7
Truy vấn phiên, chúng ta có thể thấy rằng họ đang chuyển sang giao dịch hiện tại
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]8
Lùi lại, chúng ta có thể thấy rằng tên của
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]78 đã trở lại với
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]55 và
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]80 đã bị loại khỏi phiên
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]9
ban hành CHỌN minh họa những thay đổi được thực hiện đối với cơ sở dữ liệu
>>> Session.configure[bind=engine] # once engine is available60
truy vấn
Đối tượng
>>> Session.configure[bind=engine] # once engine is available3 được tạo bằng phương thức
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]85 trên
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31. Hàm này nhận một số lượng đối số khác nhau, có thể là bất kỳ sự kết hợp nào giữa các lớp và bộ mô tả công cụ lớp. Dưới đây, chúng tôi chỉ ra một
>>> Session.configure[bind=engine] # once engine is available3 tải các phiên bản
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08. Khi được đánh giá trong ngữ cảnh lặp, danh sách các đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 hiện tại được trả về
>>> Session.configure[bind=engine] # once engine is available61
>>> Session.configure[bind=engine] # once engine is available3 cũng chấp nhận các bộ mô tả công cụ ORM làm đối số. Bất cứ khi nào nhiều thực thể lớp hoặc thực thể dựa trên cột được biểu thị dưới dạng đối số cho hàm
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]85, kết quả trả về được biểu thị dưới dạng bộ
>>> Session.configure[bind=engine] # once engine is available62
Các bộ dữ liệu được trả về bởi
>>> Session.configure[bind=engine] # once engine is available3 được đặt tên là các bộ dữ liệu, được cung cấp bởi lớp
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]93 và có thể được xử lý giống như một đối tượng Python thông thường. Các tên giống như tên của thuộc tính cho một thuộc tính và tên lớp cho một lớp
>>> Session.configure[bind=engine] # once engine is available63
Bạn có thể kiểm soát tên của các biểu thức cột riêng lẻ bằng cách sử dụng cấu trúc
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]94, có sẵn từ bất kỳ đối tượng có nguồn gốc từ
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]95 nào, cũng như bất kỳ thuộc tính lớp nào được ánh xạ tới một [chẳng hạn như
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]96]
>>> Session.configure[bind=engine] # once engine is available64
Tên được đặt cho một thực thể đầy đủ, chẳng hạn như
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08, giả sử rằng nhiều thực thể có mặt trong lệnh gọi tới
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]98, có thể được kiểm soát bằng cách sử dụng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]99
>>> Session.configure[bind=engine] # once engine is available65
Các hoạt động cơ bản với
>>> Session.configure[bind=engine] # once engine is available3 bao gồm phát hành LIMIT và OFFSET, thuận tiện nhất là sử dụng các lát mảng Python và thường kết hợp với ORDER BY
>>> Session.configure[bind=engine] # once engine is available66
và lọc kết quả, được thực hiện với
>>> Session.configure[bind=engine] # once engine is available601, sử dụng đối số từ khóa
>>> Session.configure[bind=engine] # once engine is available67
…hoặc
>>> Session.configure[bind=engine] # once engine is available602, sử dụng các cấu trúc ngôn ngữ biểu thức SQL linh hoạt hơn. Những thứ này cho phép bạn sử dụng các toán tử Python thông thường với các thuộc tính cấp độ lớp trên lớp được ánh xạ của bạn
>>> Session.configure[bind=engine] # once engine is available68
Đối tượng
>>> Session.configure[bind=engine] # once engine is available3 hoàn toàn có thể tạo ra, có nghĩa là hầu hết các lời gọi phương thức đều trả về một đối tượng
>>> Session.configure[bind=engine] # once engine is available3 mới mà có thể thêm các tiêu chí tiếp theo vào đó. Ví dụ: để truy vấn người dùng có tên “ed” với tên đầy đủ là “Ed Jones”, bạn có thể gọi
>>> Session.configure[bind=engine] # once engine is available602 hai lần, tham gia tiêu chí bằng cách sử dụng
>>> Session.configure[bind=engine] # once engine is available606
>>> Session.configure[bind=engine] # once engine is available69
Toán tử bộ lọc phổ biến
Dưới đây là danh sách một số toán tử phổ biến nhất được sử dụng trong
>>> Session.configure[bind=engine] # once engine is available602
Ghi chú
hầu hết các chương trình phụ trợ không hỗ trợ trực tiếp ILIKE. Đối với những thứ đó, toán tử
>>> Session.configure[bind=engine] # once engine is available608 hiển thị một biểu thức kết hợp LIKE với hàm LOWER SQL được áp dụng cho mỗi toán hạng
>>> Session.configure[bind=engine] # once engine is available
609>>> Session.configure[bind=engine] # once engine is available
90>>> Session.configure[bind=engine] # once engine is available
610>>> Session.configure[bind=engine] # once engine is available
91>>> Session.configure[bind=engine] # once engine is available
611>>> Session.configure[bind=engine] # once engine is available
92>>> Session.configure[bind=engine] # once engine is available
612>>> Session.configure[bind=engine] # once engine is available
93>>> Session.configure[bind=engine] # once engine is available
606>>> Session.configure[bind=engine] # once engine is available
94
Ghi chú
Đảm bảo bạn sử dụng
>>> Session.configure[bind=engine] # once engine is available614 chứ không phải toán tử Python>>> Session.configure[bind=engine] # once engine is available615
>>> Session.configure[bind=engine] # once engine is available
616>>> Session.configure[bind=engine] # once engine is available
95
Ghi chú
Đảm bảo bạn sử dụng
>>> Session.configure[bind=engine] # once engine is available617 chứ không phải toán tử Python>>> Session.configure[bind=engine] # once engine is available618
Ghi chú
>>> Session.configure[bind=engine] # once engine is available619 sử dụng hàm>>> Session.configure[bind=engine] # once engine is available620 hoặc>>> Session.configure[bind=engine] # once engine is available621 dành riêng cho cơ sở dữ liệu;
Trả về danh sách và vô hướng
Một số phương thức trên
>>> Session.configure[bind=engine] # once engine is available3 lập tức ra lệnh SQL và trả về giá trị chứa kết quả cơ sở dữ liệu đã tải. Đây là một chuyến tham quan ngắn
>>> Session.configure[bind=engine] # once engine is available
623 trả về một danh sách>>> Session.configure[bind=engine] # once engine is available
96Cảnh báo
Khi đối tượng
>>> Session.configure[bind=engine] # once engine is available
3 trả về danh sách các đối tượng được ánh xạ ORM, chẳng hạn như đối tượng>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]
08 ở trên, các mục được loại bỏ trùng lặp dựa trên khóa chính, vì kết quả được diễn giải từ tập kết quả SQL. Nghĩa là, nếu truy vấn SQL trả về một hàng có>>> Session.configure[bind=engine] # once engine is available
626 hai lần, thì bạn sẽ chỉ nhận được một đối tượng duy nhất là>>> Session.configure[bind=engine] # once engine is available
627 trong danh sách kết quả. Điều này không áp dụng cho trường hợp khi các cột riêng lẻ được truy vấn>>> Session.configure[bind=engine] # once engine is available
628 áp dụng giới hạn là một và trả về kết quả đầu tiên dưới dạng vô hướng>>> Session.configure[bind=engine] # once engine is available
97>>> Session.configure[bind=engine] # once engine is available
629 tìm nạp đầy đủ tất cả các hàng và nếu không có chính xác một nhận dạng đối tượng hoặc hàng tổng hợp trong kết quả, sẽ phát sinh lỗi. Với nhiều hàng được tìm thấy>>> Session.configure[bind=engine] # once engine is available
98Không tìm thấy hàng nào
>>> Session.configure[bind=engine] # once engine is available
99Phương pháp
>>> Session.configure[bind=engine] # once engine is available
629 rất phù hợp cho các hệ thống muốn xử lý “không tìm thấy mục nào” so với “tìm thấy nhiều mục” theo cách khác nhau;>>> Session.configure[bind=engine] # once engine is available
631 giống như>>> Session.configure[bind=engine] # once engine is available
629, ngoại trừ việc nếu không tìm thấy kết quả nào, nó sẽ không gây ra lỗi; . Tuy nhiên, giống như>>> Session.configure[bind=engine] # once engine is available
629, nó sẽ phát sinh lỗi nếu tìm thấy nhiều kết quả>>> Session.configure[bind=engine] # once engine is available
635 gọi phương thức>>> Session.configure[bind=engine] # once engine is available
629 và khi thành công trả về cột đầu tiên của hàng>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.0
60
Sử dụng SQL văn bản
Các chuỗi ký tự có thể được sử dụng linh hoạt với
>>> Session.configure[bind=engine] # once engine is available3, bằng cách chỉ định việc sử dụng chúng với cấu trúc
>>> Session.configure[bind=engine] # once engine is available638, được hầu hết các phương thức áp dụng chấp nhận. Ví dụ:
>>> Session.configure[bind=engine] # once engine is available639 và
>>> Session.configure[bind=engine] # once engine is available640
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.061
Các tham số liên kết có thể được chỉ định bằng SQL dựa trên chuỗi, sử dụng dấu hai chấm. Để chỉ định các giá trị, hãy sử dụng phương pháp
>>> Session.configure[bind=engine] # once engine is available641
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.062
Để sử dụng một câu lệnh hoàn toàn dựa trên chuỗi, cấu trúc
>>> Session.configure[bind=engine] # once engine is available638 đại diện cho một câu lệnh hoàn chỉnh có thể được chuyển đến
>>> Session.configure[bind=engine] # once engine is available643. Nếu không có thêm thông số kỹ thuật, ORM sẽ khớp các cột trong ánh xạ ORM với kết quả được trả về bởi câu lệnh SQL dựa trên tên cột
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.063
Để nhắm mục tiêu tốt hơn các cột được ánh xạ tới CHỌN văn bản, cũng như để khớp trên một tập hợp con cột cụ thể theo thứ tự tùy ý, các cột được ánh xạ riêng lẻ được chuyển theo thứ tự mong muốn tới
>>> Session.configure[bind=engine] # once engine is available644
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.064
Khi chọn từ một cấu trúc
>>> Session.configure[bind=engine] # once engine is available638,
>>> Session.configure[bind=engine] # once engine is available3 vẫn có thể chỉ định những cột và thực thể nào sẽ được trả về;
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.065
Đếm
>>> Session.configure[bind=engine] # once engine is available3 bao gồm một phương pháp tiện lợi để đếm được gọi là
>>> Session.configure[bind=engine] # once engine is available649
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.066
Phương thức
>>> Session.configure[bind=engine] # once engine is available649 được sử dụng để xác định có bao nhiêu hàng mà câu lệnh SQL sẽ trả về. Nhìn vào SQL được tạo ở trên, SQLAlchemy luôn đặt bất kỳ thứ gì chúng ta đang truy vấn vào một truy vấn phụ, sau đó đếm các hàng từ truy vấn đó. Trong một số trường hợp, điều này có thể được rút gọn thành
>>> Session.configure[bind=engine] # once engine is available651 đơn giản hơn, tuy nhiên, các phiên bản hiện đại của SQLAlchemy không cố gắng đoán khi nào điều này là phù hợp, vì SQL chính xác có thể được phát ra bằng các phương tiện rõ ràng hơn
Đối với các tình huống cần chỉ định cụ thể “thứ cần đếm”, chúng ta có thể chỉ định trực tiếp hàm “count” bằng cách sử dụng biểu thức
>>> Session.configure[bind=engine] # once engine is available652, có sẵn từ cấu trúc
>>> Session.configure[bind=engine] # once engine is available653. Dưới đây chúng tôi sử dụng nó để trả về số lượng của từng tên người dùng riêng biệt
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.067
Để đạt được
>>> Session.configure[bind=engine] # once engine is available651 đơn giản của chúng tôi, chúng tôi có thể áp dụng nó như
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.068
Việc sử dụng
>>> Session.configure[bind=engine] # once engine is available655 có thể bị loại bỏ nếu chúng ta biểu thị số đếm trực tiếp bằng khóa chính
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.069
Xây dựng mối quan hệ
Hãy xem xét cách một bảng thứ hai, liên quan đến
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08, có thể được ánh xạ và truy vấn. Người dùng trong hệ thống của chúng tôi có thể lưu trữ bất kỳ số lượng địa chỉ email nào được liên kết với tên người dùng của họ. Điều này ngụ ý một liên kết cơ bản cho nhiều liên kết từ
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]07 đến một bảng mới lưu trữ địa chỉ email, mà chúng tôi sẽ gọi là
>>> Session.configure[bind=engine] # once engine is available659. Sử dụng khai báo, chúng tôi định nghĩa bảng này cùng với lớp được ánh xạ của nó,
>>> Session.configure[bind=engine] # once engine is available660
>>> Session.configure[bind=engine] # once engine is available90
Lớp trên giới thiệu cấu trúc
>>> Session.configure[bind=engine] # once engine is available661, là một lệnh được áp dụng cho
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]10 cho biết rằng các giá trị trong cột này phải bị ràng buộc là các giá trị có trong cột từ xa được đặt tên. Đây là một tính năng cốt lõi của cơ sở dữ liệu quan hệ và là "chất keo" biến đổi một tập hợp các bảng không được liên kết với nhau để có các mối quan hệ chồng chéo phong phú.
>>> Session.configure[bind=engine] # once engine is available661 ở trên thể hiện rằng các giá trị trong cột
>>> Session.configure[bind=engine] # once engine is available664 phải bị ràng buộc với các giá trị đó trong cột
>>> Session.configure[bind=engine] # once engine is available665, i. e. khóa chính của nó
Chỉ thị thứ hai, được gọi là
>>> Session.configure[bind=engine] # once engine is available666, nói với ORM rằng chính lớp
>>> Session.configure[bind=engine] # once engine is available660 phải được liên kết với lớp
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08, sử dụng thuộc tính
>>> Session.configure[bind=engine] # once engine is available669.
>>> Session.configure[bind=engine] # once engine is available666 sử dụng các mối quan hệ khóa ngoại giữa hai bảng để xác định bản chất của liên kết này, xác định rằng
>>> Session.configure[bind=engine] # once engine is available669 sẽ là nhiều trên một. Một chỉ thị bổ sung
>>> Session.configure[bind=engine] # once engine is available666 được đặt trên lớp được ánh xạ
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 dưới thuộc tính
>>> Session.configure[bind=engine] # once engine is available674. Trong cả hai chỉ thị
>>> Session.configure[bind=engine] # once engine is available666, tham số
>>> Session.configure[bind=engine] # once engine is available676 được gán để chỉ các tên thuộc tính bổ sung;
Mặt trái của mối quan hệ nhiều-một luôn là một-nhiều. Một danh mục đầy đủ các cấu hình
>>> Session.configure[bind=engine] # once engine is available666 có sẵn tại Các mẫu mối quan hệ cơ bản
Hai mối quan hệ bổ sung
>>> Session.configure[bind=engine] # once engine is available669 và
>>> Session.configure[bind=engine] # once engine is available674 được gọi là mối quan hệ hai chiều và là một tính năng chính của SQLAlchemy ORM. Phần Sử dụng tham số mối quan hệ 'backref' cũ thảo luận chi tiết về tính năng "backref"
Các đối số của
>>> Session.configure[bind=engine] # once engine is available666 liên quan đến lớp từ xa có thể được chỉ định bằng cách sử dụng các chuỗi, giả sử hệ thống Khai báo đang được sử dụng. Khi tất cả các ánh xạ hoàn tất, các chuỗi này được đánh giá là biểu thức Python để tạo đối số thực tế, trong trường hợp trên là lớp
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08. Các tên được phép trong quá trình đánh giá này bao gồm, trong số những thứ khác, tên của tất cả các lớp đã được tạo theo cơ sở đã khai báo
Xem chuỗi tài liệu cho
>>> Session.configure[bind=engine] # once engine is available666 để biết thêm chi tiết về kiểu đối số
Chúng tôi sẽ cần tạo bảng
>>> Session.configure[bind=engine] # once engine is available659 trong cơ sở dữ liệu, vì vậy chúng tôi sẽ phát hành một CREATE khác từ siêu dữ liệu của mình, bảng này sẽ bỏ qua các bảng đã được tạo
>>> Session.configure[bind=engine] # once engine is available91
Truy vấn với các phép nối
Bây giờ chúng ta có hai bảng, chúng ta có thể hiển thị thêm một số tính năng của
>>> Session.configure[bind=engine] # once engine is available3, cụ thể là cách tạo truy vấn xử lý cả hai bảng cùng một lúc. Trang Wikipedia về SQL THAM GIA cung cấp phần giới thiệu tốt về các kỹ thuật tham gia, một số trong số đó chúng tôi sẽ minh họa ở đây
Để xây dựng một phép nối ngầm đơn giản giữa
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 và
>>> Session.configure[bind=engine] # once engine is available660, chúng ta có thể sử dụng
>>> Session.configure[bind=engine] # once engine is available639 để đánh đồng các cột liên quan của chúng với nhau. Dưới đây, chúng tôi tải các thực thể
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 và
>>> Session.configure[bind=engine] # once engine is available660 cùng một lúc bằng phương pháp này
>>> Session.configure[bind=engine] # once engine is available92
Mặt khác, cú pháp THAM GIA SQL thực tế, dễ đạt được nhất bằng cách sử dụng phương thức
>>> Session.configure[bind=engine] # once engine is available695
>>> Session.configure[bind=engine] # once engine is available93
>>> Session.configure[bind=engine] # once engine is available695 biết cách nối giữa
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 và
>>> Session.configure[bind=engine] # once engine is available660 vì chỉ có một khóa ngoại giữa chúng. Nếu không có hoặc một số khóa ngoại, thì
>>> Session.configure[bind=engine] # once engine is available695 sẽ hoạt động tốt hơn khi sử dụng một trong các dạng sau
>>> Session.configure[bind=engine] # once engine is available94
Như bạn mong đợi, ý tưởng tương tự cũng được sử dụng cho phép nối “bên ngoài”, sử dụng hàm
>>> Session.configure[bind=engine] # once engine is available900
>>> Session.configure[bind=engine] # once engine is available95
Tài liệu tham khảo cho
>>> Session.configure[bind=engine] # once engine is available695 chứa thông tin chi tiết và ví dụ về các kiểu gọi được phương thức này chấp nhận;
Sử dụng bí danh
Khi truy vấn trên nhiều bảng, nếu cùng một bảng cần được tham chiếu nhiều lần, thì SQL thường yêu cầu bảng đó được đặt bí danh bằng một tên khác, để có thể phân biệt nó với các lần xuất hiện khác của bảng đó. Điều này được hỗ trợ bằng cách sử dụng cấu trúc
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]99. Khi tham gia vào các mối quan hệ bằng cách sử dụng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]99, phương thức thuộc tính đặc biệt
>>> Session.configure[bind=engine] # once engine is available905 có thể được sử dụng để thay đổi mục tiêu của một mối quan hệ tham chiếu đến một đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]99 đã cho. Dưới đây, chúng tôi kết hợp với thực thể
>>> Session.configure[bind=engine] # once engine is available660 hai lần, để xác định vị trí người dùng có hai địa chỉ email riêng biệt cùng một lúc
>>> Session.configure[bind=engine] # once engine is available96
Ngoài việc sử dụng phương pháp
>>> Session.configure[bind=engine] # once engine is available905, người ta thường thấy phương pháp
>>> Session.configure[bind=engine] # once engine is available695 kết hợp với một mục tiêu cụ thể bằng cách chỉ ra mục tiêu đó một cách riêng biệt
>>> Session.configure[bind=engine] # once engine is available97
Sử dụng truy vấn phụ
>>> Session.configure[bind=engine] # once engine is available3 phù hợp để tạo các câu lệnh có thể được sử dụng làm truy vấn con. Giả sử chúng tôi muốn tải các đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 cùng với số lượng bản ghi
>>> Session.configure[bind=engine] # once engine is available660 mà mỗi người dùng có. Cách tốt nhất để tạo SQL như thế này là lấy số lượng địa chỉ được nhóm theo id người dùng và THAM GIA với cha mẹ. Trong trường hợp này, chúng tôi sử dụng LEFT OUTER JOIN để lấy lại các hàng cho những người dùng không có bất kỳ địa chỉ nào, e. g
>>> Session.configure[bind=engine] # once engine is available98
Sử dụng
>>> Session.configure[bind=engine] # once engine is available3, chúng tôi xây dựng một tuyên bố như thế này từ trong ra ngoài. Trình truy cập
>>> Session.configure[bind=engine] # once engine is available914 trả về một biểu thức SQL đại diện cho câu lệnh được tạo bởi một
>>> Session.configure[bind=engine] # once engine is available3 cụ thể - đây là một phiên bản của cấu trúc
>>> Session.configure[bind=engine] # once engine is available916, được mô tả trong Hướng dẫn ngôn ngữ biểu thức SQL [1. xAPI]
>>> Session.configure[bind=engine] # once engine is available99
Từ khóa
>>> Session.configure[bind=engine] # once engine is available917 tạo ra các hàm SQL và phương thức
>>> Session.configure[bind=engine] # once engine is available918 trên
>>> Session.configure[bind=engine] # once engine is available3 tạo ra một cấu trúc biểu thức SQL đại diện cho một câu lệnh CHỌN được nhúng trong một bí danh [nó thực sự là viết tắt của
>>> Session.configure[bind=engine] # once engine is available920]
Sau khi chúng tôi có câu lệnh của mình, nó sẽ hoạt động giống như một cấu trúc
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]13, chẳng hạn như cấu trúc chúng tôi đã tạo cho
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]07 khi bắt đầu hướng dẫn này. Các cột trên câu lệnh có thể truy cập thông qua một thuộc tính có tên là
>>> Session.configure[bind=engine] # once engine is available923
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]10
Chọn Thực thể từ Truy vấn Con
Ở trên, chúng tôi vừa chọn một kết quả bao gồm một cột từ truy vấn con. Nếu chúng ta muốn truy vấn con ánh xạ tới một thực thể thì sao?
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]11
Sử dụng EXISTS
Từ khóa EXISTS trong SQL là toán tử boolean trả về True nếu biểu thức đã cho chứa bất kỳ hàng nào. Nó có thể được sử dụng trong nhiều tình huống thay cho phép nối và cũng hữu ích để định vị các hàng không có hàng tương ứng trong bảng liên quan
Có một cấu trúc EXISTS rõ ràng, giống như thế này
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]12
>>> Session.configure[bind=engine] # once engine is available3 có một số toán tử sử dụng EXISTS tự động. Ở trên, tuyên bố có thể được thể hiện dọc theo mối quan hệ
>>> Session.configure[bind=engine] # once engine is available674 bằng cách sử dụng
>>> Session.configure[bind=engine] # once engine is available927
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]13
>>> Session.configure[bind=engine] # once engine is available927 cũng lấy tiêu chí để giới hạn các hàng khớp
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]14
>>> Session.configure[bind=engine] # once engine is available929 là cùng một toán tử như
>>> Session.configure[bind=engine] # once engine is available927 cho các mối quan hệ nhiều-một [lưu ý cả toán tử
>>> Session.configure[bind=engine] # once engine is available931 ở đây, có nghĩa là “KHÔNG”]
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]15
Toán tử quan hệ chung
Đây là tất cả các toán tử xây dựng trên các mối quan hệ - mỗi toán tử được liên kết với tài liệu API của nó bao gồm đầy đủ chi tiết về cách sử dụng và hành vi
>>> Session.configure[bind=engine] # once engine is available
932 [so sánh nhiều-một “bằng”]>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]
16>>> Session.configure[bind=engine] # once engine is available
933 [so sánh nhiều-một “không bằng”]>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]
17IS NULL [so sánh nhiều-một, cũng sử dụng
>>> Session.configure[bind=engine] # once engine is available
932]>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]
18>>> Session.configure[bind=engine] # once engine is available
935 [được sử dụng cho các bộ sưu tập một-nhiều]>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]
19>>> Session.configure[bind=engine] # once engine is available
927 [được sử dụng cho các bộ sưu tập]>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]
90>>> Session.configure[bind=engine] # once engine is available
929 [được sử dụng cho các tham chiếu vô hướng]>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]
91>>> Session.configure[bind=engine] # once engine is available
938 [được sử dụng cho bất kỳ mối quan hệ nào]>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]
92
háo hức tải
Nhớ lại trước đó chúng ta đã minh họa một thao tác lazy loading, khi chúng ta truy cập vào bộ sưu tập
>>> Session.configure[bind=engine] # once engine is available674 của một
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 và SQL đã được phát ra. Nếu bạn muốn giảm số lượng truy vấn [trong nhiều trường hợp, đáng kể], chúng ta có thể áp dụng tải háo hức cho thao tác truy vấn. SQLAlchemy cung cấp ba loại tải háo hức, hai trong số đó là tự động và loại thứ ba liên quan đến tiêu chí tùy chỉnh. Cả ba thường được gọi thông qua các chức năng được gọi là tùy chọn truy vấn cung cấp hướng dẫn bổ sung cho
>>> Session.configure[bind=engine] # once engine is available3 về cách chúng tôi muốn các thuộc tính khác nhau được tải, thông qua phương pháp
>>> Session.configure[bind=engine] # once engine is available942
Chọn tải
Trong trường hợp này, chúng tôi muốn chỉ ra rằng
>>> Session.configure[bind=engine] # once engine is available674 sẽ tải háo hức. Một lựa chọn tốt để tải một tập hợp các đối tượng cũng như các tập hợp liên quan của chúng là tùy chọn
>>> Session.configure[bind=engine] # once engine is available944, phát ra câu lệnh CHỌN thứ hai để tải đầy đủ các tập hợp được liên kết với kết quả vừa tải. Cái tên “selectin” bắt nguồn từ thực tế là câu lệnh SELECT sử dụng mệnh đề IN để định vị các hàng liên quan cho nhiều đối tượng cùng một lúc
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]93
đã tham gia tải
Chức năng tải háo hức tự động khác được biết đến nhiều hơn và được gọi là
>>> Session.configure[bind=engine] # once engine is available945. Kiểu tải này phát ra THAM GIA, theo mặc định là THAM GIA NGOÀI TRÁI, để đối tượng chính cũng như đối tượng hoặc bộ sưu tập liên quan được tải trong một bước. Chúng tôi minh họa tải cùng một bộ sưu tập
>>> Session.configure[bind=engine] # once engine is available659 theo cách này - lưu ý rằng mặc dù bộ sưu tập
>>> Session.configure[bind=engine] # once engine is available674 trên
>>> Session.configure[bind=engine] # once engine is available948 thực sự được điền ngay bây giờ, truy vấn sẽ tạo ra phép nối bổ sung bất kể
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]94
Lưu ý rằng mặc dù OUTER THAM GIA dẫn đến hai hàng, chúng tôi vẫn chỉ nhận được một phiên bản của
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 trở lại. Điều này là do
>>> Session.configure[bind=engine] # once engine is available3 áp dụng chiến lược "duy nhất", dựa trên danh tính đối tượng, cho các thực thể được trả về. Điều này đặc biệt để có thể áp dụng tải háo hức đã tham gia mà không ảnh hưởng đến kết quả truy vấn
Mặc dù
>>> Session.configure[bind=engine] # once engine is available945 đã xuất hiện từ lâu nhưng
>>> Session.configure[bind=engine] # once engine is available944 là một hình thức tải háo hức mới hơn.
>>> Session.configure[bind=engine] # once engine is available944 có xu hướng phù hợp hơn để tải các bộ sưu tập có liên quan trong khi
>>> Session.configure[bind=engine] # once engine is available945 có xu hướng phù hợp hơn cho các mối quan hệ nhiều-một, do thực tế là chỉ có một hàng được tải cho cả khách hàng tiềm năng và đối tượng liên quan. Một hình thức tải khác,
>>> Session.configure[bind=engine] # once engine is available955, cũng tồn tại, có thể được sử dụng thay cho
>>> Session.configure[bind=engine] # once engine is available944 khi sử dụng các khóa chính tổng hợp trên một số phụ trợ nhất định
Tham gia rõ ràng + Eagerload
Kiểu tải háo hức thứ ba là khi chúng tôi đang xây dựng THAM GIA một cách rõ ràng để xác định vị trí các hàng chính và muốn áp dụng thêm bảng bổ sung cho một đối tượng hoặc bộ sưu tập có liên quan trên đối tượng chính. Tính năng này được cung cấp thông qua hàm
>>> Session.configure[bind=engine] # once engine is available957 và thường hữu ích nhất để tải trước đối tượng nhiều thành một trên một truy vấn cần lọc trên cùng một đối tượng đó. Dưới đây chúng tôi minh họa việc tải một hàng
>>> Session.configure[bind=engine] # once engine is available660 cũng như đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 có liên quan, lọc trên
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 có tên là “jack” và sử dụng
>>> Session.configure[bind=engine] # once engine is available957 để áp dụng các cột “user” cho thuộc tính
>>> Session.configure[bind=engine] # once engine is available669
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]95
Để biết thêm thông tin về tải háo hức, bao gồm cách định cấu hình các hình thức tải khác nhau theo mặc định, hãy xem phần Kỹ thuật tải mối quan hệ
Đang xóa
Hãy thử xóa
>>> Session.configure[bind=engine] # once engine is available948 và xem nó diễn ra như thế nào. Chúng tôi sẽ đánh dấu đối tượng là đã xóa trong phiên, sau đó chúng tôi sẽ đưa ra truy vấn
>>> Session.configure[bind=engine] # once engine is available964 để xem không còn hàng nào
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]96
Càng xa càng tốt. Làm thế nào về các đối tượng
>>> Session.configure[bind=engine] # once engine is available660 của Jack?
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]97
Uh oh, họ vẫn ở đó. Phân tích tuôn ra SQL, chúng ta có thể thấy rằng cột
>>> Session.configure[bind=engine] # once engine is available966 của mỗi địa chỉ được đặt thành NULL, nhưng các hàng không bị xóa. SQLAlchemy không cho rằng xóa tầng, bạn phải bảo nó làm như vậy
Định cấu hình Cascade xóa/xóa trẻ mồ côi
Chúng tôi sẽ định cấu hình các tùy chọn xếp tầng trên mối quan hệ
>>> Session.configure[bind=engine] # once engine is available674 để thay đổi hành vi. Mặc dù SQLAlchemy cho phép bạn thêm các thuộc tính và mối quan hệ mới vào ánh xạ tại bất kỳ thời điểm nào, nhưng trong trường hợp này, mối quan hệ hiện tại cần phải bị xóa, vì vậy chúng tôi cần phá bỏ hoàn toàn các ánh xạ và bắt đầu lại - chúng tôi sẽ đóng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]31
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]98
và sử dụng một
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]06 mới
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]99
Tiếp theo, chúng tôi sẽ khai báo lớp
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08, thêm vào mối quan hệ
>>> Session.configure[bind=engine] # once engine is available659 bao gồm cấu hình tầng [chúng tôi cũng sẽ loại bỏ hàm tạo]
>>> Session.configure[bind=engine] # once engine is available10
Sau đó, chúng tôi tạo lại
>>> Session.configure[bind=engine] # once engine is available660, lưu ý rằng trong trường hợp này, chúng tôi đã tạo mối quan hệ
>>> Session.configure[bind=engine] # once engine is available669 thông qua lớp
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 rồi
>>> Session.configure[bind=engine] # once engine is available11
Bây giờ khi chúng tôi tải người dùng
>>> Session.configure[bind=engine] # once engine is available948 [bên dưới sử dụng
>>> Session.configure[bind=engine] # once engine is available976, tải theo khóa chính], việc xóa một địa chỉ khỏi bộ sưu tập
>>> Session.configure[bind=engine] # once engine is available659 tương ứng sẽ dẫn đến việc
>>> Session.configure[bind=engine] # once engine is available660 đó bị xóa
>>> Session.configure[bind=engine] # once engine is available12
Xóa Jack sẽ xóa cả Jack và
>>> Session.configure[bind=engine] # once engine is available660 còn lại được liên kết với người dùng
>>> Session.configure[bind=engine] # once engine is available13
Xây dựng mối quan hệ Nhiều - Nhiều
Chúng tôi đang chuyển sang vòng tiền thưởng ở đây, nhưng hãy thể hiện mối quan hệ nhiều-nhiều. Chúng tôi cũng sẽ giới thiệu một số tính năng khác, chỉ để tham quan. Chúng tôi sẽ biến ứng dụng của mình thành một ứng dụng blog, nơi người dùng có thể viết các mục
>>> Session.configure[bind=engine] # once engine is available980, có các mục
>>> Session.configure[bind=engine] # once engine is available981 được liên kết với chúng
Đối với nhiều-nhiều đơn giản, chúng ta cần tạo một cấu trúc
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]13 chưa được ánh xạ để dùng làm bảng liên kết. Điều này trông giống như sau
>>> Session.configure[bind=engine] # once engine is available14
Ở trên, chúng ta có thể thấy việc khai báo trực tiếp một
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]13 hơi khác so với khai báo một lớp được ánh xạ.
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]13 là một hàm tạo, vì vậy mỗi đối số riêng lẻ của
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]10 được phân tách bằng dấu phẩy. Đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]10 cũng được đặt tên rõ ràng, thay vì được lấy từ tên thuộc tính được gán
Tiếp theo, chúng tôi xác định
>>> Session.configure[bind=engine] # once engine is available980 và
>>> Session.configure[bind=engine] # once engine is available981, sử dụng các cấu trúc bổ sung của
>>> Session.configure[bind=engine] # once engine is available666, mỗi cấu trúc đề cập đến bảng
>>> Session.configure[bind=engine] # once engine is available990 như một bảng kết hợp
>>> Session.configure[bind=engine] # once engine is available15
Ghi chú
Các khai báo lớp trên minh họa các phương thức
>>> Session.configure[bind=engine] # once engine is available991 rõ ràng. Hãy nhớ rằng, khi sử dụng Declarative, nó là tùy chọn
Ở trên, mối quan hệ nhiều-nhiều là
>>> Session.configure[bind=engine] # once engine is available992. Tính năng xác định của mối quan hệ nhiều-nhiều là đối số từ khóa
>>> Session.configure[bind=engine] # once engine is available993 tham chiếu đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]13 đại diện cho bảng liên kết. Bảng này chỉ chứa các cột tham chiếu hai bên của mối quan hệ;
Chúng tôi cũng muốn lớp
>>> Session.configure[bind=engine] # once engine is available980 của chúng tôi có trường
>>> Session.configure[bind=engine] # once engine is available996. Chúng tôi sẽ thêm điều này như một mối quan hệ hai chiều khác, ngoại trừ một vấn đề mà chúng tôi gặp phải là một người dùng có thể có nhiều bài đăng trên blog. Khi chúng tôi truy cập
>>> Session.configure[bind=engine] # once engine is available997, chúng tôi muốn có thể lọc kết quả hơn nữa để không tải toàn bộ bộ sưu tập. Đối với điều này, chúng tôi sử dụng cài đặt được chấp nhận bởi
>>> Session.configure[bind=engine] # once engine is available666 có tên là
>>> Session.configure[bind=engine] # once engine is available999, cài đặt này định cấu hình chiến lược trình tải thay thế trên thuộc tính
>>> Session.configure[bind=engine] # once engine is available16
Tạo bảng mới
>>> Session.configure[bind=engine] # once engine is available91
Cách sử dụng không quá khác biệt so với những gì chúng tôi đã và đang làm. Hãy cung cấp cho Wendy một số bài đăng trên blog
>>> Session.configure[bind=engine] # once engine is available18
Chúng tôi đang lưu trữ các từ khóa duy nhất trong cơ sở dữ liệu, nhưng chúng tôi biết rằng chúng tôi chưa có bất kỳ từ khóa nào, vì vậy chúng tôi chỉ có thể tạo chúng
>>> Session.configure[bind=engine] # once engine is available19
Bây giờ chúng tôi có thể tra cứu tất cả các bài đăng trên blog với từ khóa 'firstpost'. Chúng tôi sẽ sử dụng toán tử
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.0600 để xác định vị trí “các bài đăng trên blog trong đó bất kỳ từ khóa nào của nó có chuỗi từ khóa ‘firstpost’”
>>> Session.configure[bind=engine] # once engine is available0
Nếu chúng tôi muốn tra cứu các bài đăng thuộc sở hữu của người dùng
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.0601, chúng tôi có thể yêu cầu truy vấn thu hẹp đối tượng
>>> from sqlalchemy import create_engine >>> engine = create_engine["sqlite:///:memory:", echo=True]08 đó với tư cách là cha mẹ
>>> Session.configure[bind=engine] # once engine is available1
Hoặc chúng ta có thể sử dụng mối quan hệ
>>> import sqlalchemy >>> sqlalchemy.__version__ 1.4.0603 của chính Wendy, là mối quan hệ “động”, để truy vấn trực tiếp từ đó