Ví dụ về db-api trong python

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ớ. Đây là một cách dễ dàng để kiểm tra mọi thứ mà không cần phải xác định cơ sở dữ liệu thực tế ở bất kỳ đâu. Để kết nối chúng tôi sử dụng

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Cờ

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Giá trị trả về của là một phiên bản của , 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 a xử lý các chi tiết của cơ sở dữ liệu và đang được 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)

Lần đầu tiên một phương thức như hoặc được gọi, nó sẽ thiết lập một kết nối thực sự với cơ sở dữ liệu, sau đó được sử dụng để phát ra SQL

Xác định và tạo bảng

Ngôn ngữ biểu thức SQL xây dựng các biểu thức của nó trong hầu hết các trường hợp đối với các cột của bảng. Trong SQLAlchemy, một cột thường được đại diện bởi một đối tượng có tên là , và trong mọi trường hợp a được liên kết với một. Một tập hợp các đối tượng và các đối tượng con liên quan của chúng được gọi là siêu dữ liệu cơ sở dữ liệu. Trong hướng dẫn này, chúng tôi sẽ trình bày rõ ràng một số đối tượng, nhưng lưu ý rằng SA cũng có thể tự động “nhập” toàn bộ bộ đối tượng từ cơ sở dữ liệu hiện có (quá trình này được gọi là phản ánh bảng)

Chúng tôi xác định tất cả các bảng của mình trong một danh mục có tên là , sử dụng cấu trúc, tương tự như các câu lệnh SQL CREATE TABLE thông thường. Chúng ta sẽ tạo hai bảng, một trong số đó đại diện cho “người dùng” trong một ứng dụng và một bảng khác đại diện cho 0 hoặc nhiều “địa chỉ email” cho mỗi hàng trong bảng “người dùng”

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Tất cả về cách xác định đối tượng, cũng như cách tự động tạo chúng từ cơ sở dữ liệu hiện có, được mô tả trong Mô tả cơ sở dữ liệu bằng siêu dữ liệu

Tiếp theo, để nói rằng chúng tôi thực sự muốn tạo lựa chọn bảng thực sự bên trong cơ sở dữ liệu SQLite, chúng tôi sử dụng , chuyển cho nó phiên bản

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

sql>>> metadata_obj.create_all(engine)

Ghi chú

Người dùng quen thuộc với cú pháp của CREATE TABLE có thể nhận thấy rằng các cột VARCHAR được tạo không có độ dài; . Vì vậy, nếu chạy hướng dẫn này trên một trong những cơ sở dữ liệu đó, và bạn muốn sử dụng SQLAlchemy để phát hành CREATE TABLE, thì một "độ dài" có thể được cung cấp cho loại như bên dưới

Column("name", String(50))

Trường độ dài trên , cũng như các trường độ chính xác/tỷ lệ tương tự có sẵn trên , , v.v. không được tham chiếu bởi SQLAlchemy ngoài khi tạo bảng

Ngoài ra, Firebird và Oracle yêu cầu các trình tự để tạo mã định danh khóa chính mới và SQLAlchemy không tạo hoặc giả định các mã này mà không được hướng dẫn. Đối với điều đó, bạn sử dụng cấu trúc

from sqlalchemy import Sequence

Column("id", Integer, Sequence("user_id_seq"), primary_key=True)

Do đó, đầy đủ, hoàn hảo là

users = Table(
    "users",
    metadata_obj,
    Column("id", Integer, Sequence("user_id_seq"), primary_key=True),
    Column("name", String(50)),
    Column("fullname", String(50)),
    Column("nickname", String(50)),
)

Chúng tôi bao gồm cấu trúc dài dòng hơn này một cách riêng biệt để làm nổi bật sự khác biệt giữa cấu trúc tối thiểu chủ yếu chỉ hướng tới việc sử dụng trong Python, so với cấu trúc sẽ được sử dụng để phát ra các câu lệnh CREATE TABLE trên một nhóm phụ trợ cụ thể với các yêu cầu nghiêm ngặt hơn

Chèn biểu thức

Biểu thức SQL đầu tiên chúng ta sẽ tạo là cấu trúc, đại diện cho một câu lệnh INSERT. Điều này thường được tạo liên quan đến bảng mục tiêu của nó

Để xem mẫu SQL mà cấu trúc này tạo ra, hãy sử dụng hàm

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> str(ins)
'INSERT INTO users (id, name, fullname) VALUES (:id, :name, :fullname)'

Lưu ý ở trên rằng câu lệnh INSERT đặt tên cho mọi cột trong bảng

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> ins = users.insert().values(name="jack", fullname="Jack Jones")
>>> str(ins)
'INSERT INTO users (name, fullname) VALUES (:name, :fullname)'

Ở trên, trong khi phương pháp

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> ins.compile().params  
{'fullname': 'Jack Jones', 'name': 'jack'}

thi hành

Phần thú vị của an là thực hiện nó. Điều này được thực hiện bằng cách sử dụng kết nối cơ sở dữ liệu, được đại diện bởi đối tượng. Để có được một kết nối, chúng tôi sẽ sử dụng phương pháp

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Đối tượng đại diện cho tài nguyên kết nối DBAPI đã được kiểm tra tích cực. Hãy cho nó ăn đối tượng của chúng ta và xem điều gì sẽ xảy ra

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Vì vậy, câu lệnh INSERT hiện đã được cấp cho cơ sở dữ liệu. Mặc dù chúng tôi có các tham số liên kết “qmark” theo vị trí thay vì các tham số liên kết “có tên” trong đầu ra. Làm thế nào mà ? . Chúng ta có thể xem thủ công như sau

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Thế còn biến

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Giá trị của

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Thực thi nhiều câu lệnh

Ví dụ chèn của chúng tôi ở trên được cố ý rút ra một chút để hiển thị một số hành vi khác nhau của cấu trúc ngôn ngữ biểu thức. Trong trường hợp thông thường, một câu lệnh thường được biên dịch dựa trên các tham số được gửi đến phương thức

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Ở trên, vì chúng tôi đã chỉ định cả ba cột trong phương thức

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Để phát hành nhiều phần chèn bằng phương pháp

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Ở trên, chúng tôi lại dựa vào việc tạo tự động các mã định danh khóa chính của SQLite cho mỗi hàng

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Khi thực hiện nhiều bộ tham số, mỗi từ điển phải có cùng một bộ khóa; . e. bạn không thể có ít khóa hơn trong một số từ điển hơn những từ điển khác. Điều này là do câu lệnh được biên dịch theo từ điển đầu tiên trong danh sách và giả định rằng tất cả các từ điển đối số tiếp theo đều tương thích với câu lệnh đó

Phong cách gọi "executemany" có sẵn cho từng cấu trúc , và

lựa chọn

Chúng tôi đã bắt đầu với các phần chèn để cơ sở dữ liệu thử nghiệm của chúng tôi có một số dữ liệu trong đó. Phần thú vị hơn của dữ liệu là chọn nó. Chúng tôi sẽ đề cập đến các câu lệnh CẬP NHẬT và XÓA sau. Cấu trúc chính được sử dụng để tạo câu lệnh SELECT là hàm

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Ở trên, chúng tôi đã thực hiện một cuộc gọi cơ bản, đặt bảng

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Kết quả trả về lại là một đối tượng, hoạt động giống như một con trỏ DBAPI, bao gồm các phương thức như và. Các phương thức này trả về các đối tượng hàng, được cung cấp thông qua lớp. Đối tượng kết quả có thể được lặp trực tiếp để cung cấp một trình lặp của các đối tượng

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Ở trên, chúng ta thấy rằng việc in từng cái tạo ra một kết quả giống như bộ dữ liệu đơn giản. Cách chính tắc nhất trong Python để truy cập các giá trị của các bộ dữ liệu này khi các hàng được tìm nạp là thông qua phép gán bộ dữ liệu

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Đối tượng thực sự hoạt động giống như một bộ có tên Python, vì vậy chúng ta cũng có thể truy cập các thuộc tính này từ chính hàng đó bằng cách sử dụng quyền truy cập thuộc tính

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Để truy cập các cột thông qua tên bằng cách sử dụng chuỗi, khi tên cột được tạo theo chương trình hoặc chứa các ký tự không phải mã ascii, chế độ xem có thể được sử dụng để cung cấp quyền truy cập giống như từ điển

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Thay đổi trong phiên bản 1. 4. Đã thêm cung cấp quyền truy cập giống như từ điển vào một , thay thế việc sử dụng trực tiếp các khóa chuỗi/cột đối với đối tượng

Vì là một bộ nên dãy (i. e. quyền truy cập số nguyên hoặc lát) cũng có thể được sử dụng

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Một phương pháp truy cập cột chuyên biệt hơn là sử dụng cấu trúc SQL tương ứng trực tiếp với một cột cụ thể làm khóa ánh xạ;

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Đối tượng có hành vi "tự động đóng" để đóng đối tượng DBAPI

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Chọn các cột cụ thể

Nếu chúng tôi muốn kiểm soát cẩn thận hơn các cột được đặt trong mệnh đề COLUMNS của phần chọn, chúng tôi sẽ tham chiếu các đối tượng riêng lẻ từ. Chúng có sẵn dưới dạng thuộc tính được đặt tên ngoài thuộc tính

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Hãy quan sát điều gì đó thú vị về mệnh đề TỪ. Trong khi câu lệnh được tạo có chứa hai phần riêng biệt, phần “CHỌN cột” và phần “TỪ bảng”, cấu trúc của chúng tôi chỉ có một danh sách chứa các cột. Cái này hoạt động ra sao ?

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Nó đặt cả hai bảng vào mệnh đề TỪ. Nhưng ngoài ra, nó đã tạo ra một mớ hỗn độn thực sự. Những người quen thuộc với phép nối SQL biết rằng đây là một sản phẩm của Cartesian; . Vì vậy, để đưa một số sự tỉnh táo vào tuyên bố này, chúng ta cần một mệnh đề WHERE. Chúng tôi làm điều đó bằng cách sử dụng

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Vì vậy, điều đó có vẻ tốt hơn rất nhiều, chúng tôi đã thêm một biểu thức vào biểu thức của chúng tôi, biểu thức này có tác dụng thêm

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Chà, bất ngờ. Đây không phải là

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Như bạn có thể thấy, toán tử

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

nhà điều hành

Vì chúng ta đã tình cờ phát hiện ra mô hình toán tử của SQLAlchemy, chúng ta hãy xem qua một số khả năng của nó. Chúng ta đã thấy cách cân bằng hai cột với nhau

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Nếu chúng ta sử dụng một giá trị theo nghĩa đen (nghĩa đen, không phải đối tượng mệnh đề SQLAlchemy), chúng ta sẽ nhận được một tham số liên kết

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Chữ

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

sql>>> metadata_obj.create_all(engine)

Hóa ra, hầu hết các toán tử Python tạo ra một biểu thức SQL ở đây, như bằng, không bằng, v.v.

sql>>> metadata_obj.create_all(engine)

Nếu chúng ta cộng hai cột số nguyên với nhau, chúng ta sẽ nhận được một biểu thức cộng

sql>>> metadata_obj.create_all(engine)

Thật thú vị, loại của là quan trọng. Nếu chúng tôi sử dụng

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

sql>>> metadata_obj.create_all(engine)

Trong đó

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

sql>>> metadata_obj.create_all(engine)

Phần trên minh họa SQL được tạo cho một cơ sở dữ liệu được kết nối với cơ sở dữ liệu MySQL;

Nếu bạn gặp một toán tử thực sự không khả dụng, bạn luôn có thể sử dụng phương pháp này;

sql>>> metadata_obj.create_all(engine)

Chức năng này cũng có thể được sử dụng để làm rõ ràng các toán tử bitwise. Ví dụ

là AND theo bit của giá trị trong

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Khi sử dụng , kiểu trả về của biểu thức có thể quan trọng, đặc biệt khi toán tử được sử dụng trong biểu thức sẽ được gửi dưới dạng cột kết quả. Đối với trường hợp này, hãy đảm bảo loại rõ ràng, nếu không phải là loại thường được mong đợi, sử dụng

sql>>> metadata_obj.create_all(engine)

Đối với các toán tử boolean, hãy sử dụng phương thức này, phương thức này sẽ đảm bảo rằng kiểu trả về của biểu thức được xử lý dưới dạng boolean

sql>>> metadata_obj.create_all(engine)

liên từ

Chúng tôi muốn giới thiệu một số toán tử của chúng tôi bên trong các cấu trúc. Nhưng chúng ta cần gộp chúng lại với nhau thêm một chút, vì vậy trước tiên hãy giới thiệu một số liên từ. Liên từ là những từ nhỏ như AND và OR ghép các thứ lại với nhau. Chúng tôi cũng sẽ đánh vào KHÔNG. , và có thể hoạt động từ các hàm tương ứng mà SQLAlchemy cung cấp (lưu ý rằng chúng tôi cũng đưa vào một )

Column("name", String(50))

Và bạn cũng có thể sử dụng các toán tử AND, OR và NOT được sắp xếp lại theo từng bit, mặc dù do ưu tiên của toán tử Python, bạn phải xem dấu ngoặc đơn của mình

Column("name", String(50))

Vì vậy, với tất cả từ vựng này, hãy chọn tất cả người dùng có địa chỉ email tại AOL hoặc MSN, có tên bắt đầu bằng một chữ cái giữa “m” và “z”, đồng thời chúng ta cũng sẽ tạo một cột chứa tên đầy đủ của họ kết hợp với . Chúng tôi sẽ thêm hai cấu trúc mới vào câu lệnh này và. tạo mệnh đề BETWEEN và được sử dụng trong biểu thức cột để tạo nhãn bằng từ khóa

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Column("name", String(50))

Một lần nữa, SQLAlchemy đã tìm ra mệnh đề TỪ cho câu lệnh của chúng ta. Trên thực tế, nó sẽ xác định mệnh đề TỪ dựa trên tất cả các bit khác của nó;

Một lối tắt để sử dụng là xâu chuỗi nhiều mệnh đề lại với nhau. Ở trên cũng có thể được viết là

Column("name", String(50))

Cách mà chúng ta có thể xây dựng một cấu trúc thông qua các lệnh gọi phương thức liên tiếp được gọi là

Sử dụng SQL văn bản

Ví dụ cuối cùng của chúng tôi thực sự đã trở thành một số ít để gõ. Đi từ những gì người ta hiểu là một biểu thức SQL văn bản thành một cấu trúc Python nhóm các thành phần lại với nhau theo kiểu lập trình có thể khó. Đó là lý do tại sao SQLAlchemy cho phép bạn chỉ sử dụng các chuỗi, đối với những trường hợp khi SQL đã được biết và không cần câu lệnh hỗ trợ các tính năng động. Cấu trúc được sử dụng để soạn một câu lệnh văn bản được chuyển đến cơ sở dữ liệu hầu như không thay đổi. Dưới đây, chúng tôi tạo một đối tượng và thực hiện nó

Column("name", String(50))

Ở trên, chúng ta có thể thấy rằng các tham số ràng buộc được chỉ định bằng cách sử dụng định dạng dấu hai chấm được đặt tên; . Để gửi giá trị cho các tham số, chúng tôi đã chuyển chúng vào phương thức dưới dạng đối số bổ sung

Column("name", String(50))

from sqlalchemy import Sequence

Column("id", Integer, Sequence("user_id_seq"), primary_key=True)

from sqlalchemy import Sequence

Column("id", Integer, Sequence("user_id_seq"), primary_key=True)

from sqlalchemy import Sequence

Column("id", Integer, Sequence("user_id_seq"), primary_key=True)

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

from sqlalchemy import Sequence

Column("id", Integer, Sequence("user_id_seq"), primary_key=True)

from sqlalchemy import Sequence

Column("id", Integer, Sequence("user_id_seq"), primary_key=True)

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

from sqlalchemy import Sequence

Column("id", Integer, Sequence("user_id_seq"), primary_key=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

from sqlalchemy import Sequence

Column("id", Integer, Sequence("user_id_seq"), primary_key=True)

from sqlalchemy import Sequence

Column("id", Integer, Sequence("user_id_seq"), primary_key=True)

sql>>> metadata_obj.create_all(engine)

sql>>> metadata_obj.create_all(engine)

from sqlalchemy import Sequence

Column("id", Integer, Sequence("user_id_seq"), primary_key=True)

sql>>> metadata_obj.create_all(engine)

sql>>> metadata_obj.create_all(engine)

from sqlalchemy import Sequence

Column("id", Integer, Sequence("user_id_seq"), primary_key=True)

users = Table(
    "users",
    metadata_obj,
    Column("id", Integer, Sequence("user_id_seq"), primary_key=True),
    Column("name", String(50)),
    Column("fullname", String(50)),
    Column("nickname", String(50)),
)

users = Table(
    "users",
    metadata_obj,
    Column("id", Integer, Sequence("user_id_seq"), primary_key=True),
    Column("name", String(50)),
    Column("fullname", String(50)),
    Column("nickname", String(50)),
)

Sử dụng bí danh và truy vấn phụ

Bí danh trong SQL tương ứng với phiên bản “được đổi tên” của bảng hoặc câu lệnh CHỌN, xảy ra bất cứ khi nào bạn nói “CHỌN. TỪ chỗ nào đó NHƯ cái tên nào đó”.

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Trong SQLAlchemy, bất kỳ hoặc tùy chọn dựa trên nào khác có thể được chuyển thành bí danh bằng cách sử dụng phương thức tạo ra cấu trúc. là một đối tượng tham chiếu đến ánh xạ các đối tượng thông qua tập hợp của nó và có thể được sử dụng trong mệnh đề TỪ của bất kỳ câu lệnh CHỌN nào tiếp theo, bằng cách tham chiếu đến các phần tử cột của nó trong các cột hoặc mệnh đề WHERE của câu lệnh hoặc thông qua vị trí rõ ràng trong

Ví dụ: giả sử chúng tôi biết rằng người dùng của chúng tôi

sql>>> metadata_obj.create_all(engine)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

users = Table(
    "users",
    metadata_obj,
    Column("id", Integer, Sequence("user_id_seq"), primary_key=True),
    Column("name", String(50)),
    Column("fullname", String(50)),
    Column("nickname", String(50)),
)

Lưu ý rằng cấu trúc đã tạo ra các tên

sql>>> metadata_obj.create_all(engine)

sql>>> metadata_obj.create_all(engine)

sql>>> metadata_obj.create_all(engine)

sql>>> metadata_obj.create_all(engine)

Vì ở bên ngoài, chúng tôi đề cập đến bí danh bằng cách sử dụng chính cấu trúc, chúng tôi không cần quan tâm đến tên được tạo. Tuy nhiên, với mục đích gỡ lỗi, nó có thể được chỉ định bằng cách chuyển tên chuỗi cho phương thức

users = Table(
    "users",
    metadata_obj,
    Column("id", Integer, Sequence("user_id_seq"), primary_key=True),
    Column("name", String(50)),
    Column("fullname", String(50)),
    Column("nickname", String(50)),
)

Các cấu trúc hướng SELECT mở rộng từ có thể được biến thành các truy vấn con bí danh bằng cách sử dụng phương thức tạo ra một cấu trúc; . Giống như , cũng là một đối tượng có thể là một phần của bất kỳ CHỌN kèm theo nào bằng cách sử dụng các kỹ thuật tương tự mà người ta sẽ sử dụng cho một

Chúng ta có thể tự tham gia bảng

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

users = Table(
    "users",
    metadata_obj,
    Column("id", Integer, Sequence("user_id_seq"), primary_key=True),
    Column("name", String(50)),
    Column("fullname", String(50)),
    Column("nickname", String(50)),
)

Sử dụng tham gia

Chúng ta đã đi được nửa chặng đường để có thể xây dựng bất kỳ biểu thức SELECT nào. Nền tảng tiếp theo của CHỌN là biểu thức THAM GIA. Chúng tôi đã thực hiện phép nối trong các ví dụ của mình, bằng cách chỉ đặt hai bảng trong mệnh đề cột hoặc mệnh đề where của cấu trúc. Nhưng nếu chúng ta muốn tạo một cấu trúc “THAM GIA” hoặc “OUTERJOIN” thực sự, chúng ta sử dụng các phương thức và, thường được truy cập nhất từ ​​bảng bên trái trong phép nối

users = Table(
    "users",
    metadata_obj,
    Column("id", Integer, Sequence("user_id_seq"), primary_key=True),
    Column("name", String(50)),
    Column("fullname", String(50)),
    Column("nickname", String(50)),
)

Người đọc tỉnh táo sẽ thấy nhiều bất ngờ hơn; . Điều kiện BẬT của phép nối, như nó được gọi, được tạo tự động dựa trên đối tượng mà chúng ta đã đặt trên cách bảng

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

sql>>> metadata_obj.create_all(engine)

Tất nhiên, bạn có thể tham gia theo bất kỳ biểu thức nào bạn muốn, chẳng hạn như nếu chúng tôi muốn tham gia trên tất cả người dùng sử dụng cùng tên trong địa chỉ email làm tên người dùng của họ

users = Table(
    "users",
    metadata_obj,
    Column("id", Integer, Sequence("user_id_seq"), primary_key=True),
    Column("name", String(50)),
    Column("fullname", String(50)),
    Column("nickname", String(50)),
)

Khi chúng tôi tạo một cấu trúc, SQLAlchemy sẽ xem xét các bảng mà chúng tôi đã đề cập và sau đó đặt chúng vào mệnh đề TỪ của câu lệnh. Tuy nhiên, khi chúng tôi sử dụng THAM GIA, chúng tôi biết chúng tôi muốn mệnh đề TỪ nào, vì vậy ở đây chúng tôi sử dụng phương thức

users = Table(
    "users",
    metadata_obj,
    Column("id", Integer, Sequence("user_id_seq"), primary_key=True),
    Column("name", String(50)),
    Column("fullname", String(50)),
    Column("nickname", String(50)),
)

Phương thức này tạo ra các cấu trúc

sql>>> metadata_obj.create_all(engine)

users = Table(
    "users",
    metadata_obj,
    Column("id", Integer, Sequence("user_id_seq"), primary_key=True),
    Column("name", String(50)),
    Column("fullname", String(50)),
    Column("nickname", String(50)),
)

Đó là kết quả mà

sql>>> metadata_obj.create_all(engine)

sql>>> metadata_obj.create_all(engine)

users = Table(
    "users",
    metadata_obj,
    Column("id", Integer, Sequence("user_id_seq"), primary_key=True),
    Column("name", String(50)),
    Column("fullname", String(50)),
    Column("nickname", String(50)),
)

Nếu bạn không biết SQL nghĩa là gì, đừng lo lắng. Bộ tộc bí mật của Oracle DBA không muốn ma thuật đen của họ bị phát hiện;)

Biểu thức bảng chung (CTE)

Các biểu thức bảng phổ biến hiện được hỗ trợ bởi mọi cơ sở dữ liệu chính, bao gồm cả MySQL, MariaDB, SQLite, PostgreSQL, Oracle và MS SQL Server hiện đại. SQLAlchemy hỗ trợ cấu trúc này thông qua đối tượng, đối tượng này thường có được bằng cách sử dụng phương thức trên cấu trúc

>>> str(ins)
'INSERT INTO users (id, name, fullname) VALUES (:id, :name, :fullname)'

Cấu trúc CTE là một cách tuyệt vời để cung cấp nguồn hàng tương tự về mặt ngữ nghĩa với việc sử dụng truy vấn con, nhưng với định dạng đơn giản hơn nhiều trong đó nguồn hàng được giấu gọn gàng ở đầu truy vấn nơi có thể tham chiếu nó ở bất kỳ đâu trong

Khi chúng ta xây dựng một đối tượng, chúng ta sử dụng nó giống như bất kỳ bảng nào khác trong câu lệnh. Tuy nhiên, thay vì được thêm vào mệnh đề TỪ dưới dạng truy vấn con, nó lại xuất hiện ở trên cùng, điều này có lợi ích bổ sung là không gây bất ngờ cho tích cartesian

Định dạng RECURSIVE của CTE khả dụng khi một người sử dụng tham số. CTE đệ quy thường yêu cầu chúng tôi liên kết với chính mình dưới dạng bí danh. Hình thức chung của loại hoạt động này liên quan đến một UNION của CTE ban đầu chống lại chính nó. Lưu ý rằng các bảng ví dụ của chúng tôi không phù hợp để tạo ra một truy vấn thực sự hữu ích với tính năng này, biểu mẫu này trông giống như

>>> str(ins)
'INSERT INTO users (id, name, fullname) VALUES (:id, :name, :fullname)'

Mọi thứ khác

Các khái niệm về tạo biểu thức SQL đã được giới thiệu. Những gì còn lại là nhiều biến thể của cùng một chủ đề. Vì vậy, bây giờ chúng tôi sẽ lập danh mục những điều quan trọng còn lại mà chúng tôi cần biết

>>> str(ins)
'INSERT INTO users (id, name, fullname) VALUES (:id, :name, :fullname)'

>>> str(ins)
'INSERT INTO users (id, name, fullname) VALUES (:id, :name, :fullname)'

>>> str(ins)
'INSERT INTO users (id, name, fullname) VALUES (:id, :name, :fullname)'

>>> str(ins)
'INSERT INTO users (id, name, fullname) VALUES (:id, :name, :fullname)'

>>> str(ins)
'INSERT INTO users (id, name, fullname) VALUES (:id, :name, :fullname)'

>>> str(ins)
'INSERT INTO users (id, name, fullname) VALUES (:id, :name, :fullname)'

sql>>> metadata_obj.create_all(engine)

>>> str(ins)
'INSERT INTO users (id, name, fullname) VALUES (:id, :name, :fullname)'

sql>>> metadata_obj.create_all(engine)

>>> str(ins)
'INSERT INTO users (id, name, fullname) VALUES (:id, :name, :fullname)'

sql>>> metadata_obj.create_all(engine)

sql>>> metadata_obj.create_all(engine)

sql>>> metadata_obj.create_all(engine)

sql>>> metadata_obj.create_all(engine)

sql>>> metadata_obj.create_all(engine)

sql>>> metadata_obj.create_all(engine)

>>> ins = users.insert().values(name="jack", fullname="Jack Jones")
>>> str(ins)
'INSERT INTO users (name, fullname) VALUES (:name, :fullname)'

sql>>> metadata_obj.create_all(engine)

>>> ins = users.insert().values(name="jack", fullname="Jack Jones")
>>> str(ins)
'INSERT INTO users (name, fullname) VALUES (:name, :fullname)'

>>> ins = users.insert().values(name="jack", fullname="Jack Jones")
>>> str(ins)
'INSERT INTO users (name, fullname) VALUES (:name, :fullname)'

>>> ins = users.insert().values(name="jack", fullname="Jack Jones")
>>> str(ins)
'INSERT INTO users (name, fullname) VALUES (:name, :fullname)'

sql>>> metadata_obj.create_all(engine)

>>> ins = users.insert().values(name="jack", fullname="Jack Jones")
>>> str(ins)
'INSERT INTO users (name, fullname) VALUES (:name, :fullname)'

>>> from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
>>> metadata_obj = MetaData()
>>> users = Table(
..     "users",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("name", String),
..     Column("fullname", String),
.. )

>>> addresses = Table(
..     "addresses",
..     metadata_obj,
..     Column("id", Integer, primary_key=True),
..     Column("user_id", None, ForeignKey("users.id")),
..     Column("email_address", String, nullable=False),
.. )

Column("name", String(50))

>>> ins = users.insert().values(name="jack", fullname="Jack Jones")
>>> str(ins)
'INSERT INTO users (name, fullname) VALUES (:name, :fullname)'

Column("name", String(50))

Column("name", String(50))

Column("name", String(50))

Column("name", String(50))

Column("name", String(50))

>>> ins = users.insert().values(name="jack", fullname="Jack Jones")
>>> str(ins)
'INSERT INTO users (name, fullname) VALUES (:name, :fullname)'

>>> ins = users.insert().values(name="jack", fullname="Jack Jones")
>>> str(ins)
'INSERT INTO users (name, fullname) VALUES (:name, :fullname)'

Column("name", String(50))

>>> ins = users.insert().values(name="jack", fullname="Jack Jones")
>>> str(ins)
'INSERT INTO users (name, fullname) VALUES (:name, :fullname)'

Column("name", String(50))

Column("name", String(50))

>>> ins = users.insert().values(name="jack", fullname="Jack Jones")
>>> str(ins)
'INSERT INTO users (name, fullname) VALUES (:name, :fullname)'

>>> ins.compile().params  
{'fullname': 'Jack Jones', 'name': 'jack'}

sql>>> metadata_obj.create_all(engine)

>>> ins.compile().params  
{'fullname': 'Jack Jones', 'name': 'jack'}

>>> ins.compile().params  
{'fullname': 'Jack Jones', 'name': 'jack'}

Column("name", String(50))

>>> ins.compile().params  
{'fullname': 'Jack Jones', 'name': 'jack'}

>>> ins.compile().params  
{'fullname': 'Jack Jones', 'name': 'jack'}

Column("name", String(50))

>>> ins.compile().params  
{'fullname': 'Jack Jones', 'name': 'jack'}

>>> ins.compile().params  
{'fullname': 'Jack Jones', 'name': 'jack'}

>>> ins.compile().params  
{'fullname': 'Jack Jones', 'name': 'jack'}

>>> ins.compile().params  
{'fullname': 'Jack Jones', 'name': 'jack'}

Chèn, cập nhật và xóa

Chúng tôi đã chứng minh trước đó trong hướng dẫn này. Trường hợp tạo INSERT, phương thức tạo CẬP NHẬT. Cả hai cấu trúc này đều có một phương thức được gọi là chỉ định mệnh đề VALUES hoặc SET của câu lệnh

Phương thức chứa bất kỳ biểu thức cột nào dưới dạng giá trị

>>> ins.compile().params  
{'fullname': 'Jack Jones', 'name': 'jack'}

Khi sử dụng hoặc trong ngữ cảnh “thực thi nhiều”, chúng tôi cũng có thể muốn chỉ định các tham số ràng buộc được đặt tên mà chúng tôi có thể tham khảo trong danh sách đối số. Hai cấu trúc sẽ tự động tạo các trình giữ chỗ bị ràng buộc cho bất kỳ tên cột nào được chuyển trong từ điển được gửi tới tại thời điểm thực thi. Tuy nhiên, nếu chúng tôi muốn sử dụng các tham số được đặt tên được nhắm mục tiêu rõ ràng với các biểu thức tổng hợp, chúng tôi cần sử dụng cấu trúc. Khi sử dụng with hoặc , bản thân tên của các cột trong bảng được dành riêng cho việc tạo tên liên kết "tự động". Chúng ta có thể kết hợp việc sử dụng các tên liên kết có sẵn ngầm định và các tham số được đặt tên rõ ràng như trong ví dụ dưới đây

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Một câu lệnh CẬP NHẬT được phát ra bằng cách sử dụng cấu trúc. Điều này hoạt động giống như một INSERT, ngoại trừ có một mệnh đề WHERE bổ sung có thể được chỉ định

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Khi sử dụng trong ngữ cảnh “executemany”, chúng ta cũng có thể muốn sử dụng các tham số ràng buộc được đặt tên rõ ràng trong mệnh đề WHERE. Một lần nữa, là cấu trúc được sử dụng để đạt được điều này

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

>>> from sqlalchemy import create_engine
>>> engine = create_engine("sqlite:///:memory:", echo=True)

Column("name", String(50))