Python SQLAlchemy ( ORM )

From

• A powerful general ORM framework in Python: SQLAlchemy: https://zhuanlan.zhihu.com/p/444930067
• A comprehensive guide to SQLAlchemy for Python ORM: https://zhuanlan.zhihu.com/p/387078089

SQLAlchemy documentation: https://www.sqlalchemy.org/

Getting started and advanced with SQLAlchemy: https://zhuanlan.zhihu.com/p/27400862

1. Introduction to ORM and SQLAlchemy

ORM stands for Object Relational Mapping (Object Relational Mapping). It is to map the " table structure of the relational database " to the " Python object ", so that the Python object can be directly manipulated without writing SQL to operate, that is, the object is considered at the code level, not SQL.

The specific implementation is

• Convert database tables to Python classes
• where the data columns are  attributes of the class
• Database operations as methods

advantage:

1. Concise and easy to read: abstract the data table into an object (data model), which is more intuitive and easy to read
2. Portable: Encapsulates a variety of database engines, the operation is basically the same for multiple databases, and the code is easy to maintain
3. Safer: Effectively avoid SQL injection

The most famous ORM framework in Python is SQLAlchemy. It can be combined with any third-party web framework, such as flask, tornado, django, fastapi, etc. Compared with Django ORM, SQLALchemy is closer to native SQL statements, so it is less difficult to learn.

SQLALchemy consists of the following 5 parts:

• Engine: framework engine
• Connection Pooling: database connection pool
• Dialect: Dialect, calling different database APIs (Oracle, postgresql, Mysql) and executing corresponding SQL statements. That is, the database DB API category.
• Schema / Types: mapping rules between "classes to tables"
• SQL Expression Language: SQL Expression Language

The diagram is as follows:

Running process:

• First, the operation entered by the user will be handed over to the ORM object
• Next, the ORM object will submit the user operation to SQLALchemy Core
• Secondly, the operation will be converted into SQL statements by Schema/Types and SQL Expression Language
• Then Egine will match the egine configured by the user, and take out a connection from the connection pool
• Finally, the link will call DBAPI through Dialect, and transfer the SQL statement to DBAPI for execution

Related concepts

common data types

install sqlalchemy

Install: pip install sqlalchemy

database connection string

SQLAlchemy must rely on other modules that manipulate the database to be used, which is the DBAPI mentioned above.

When SQLAlchemy is used with DBAPI, the connection string is also different, as follows:

MySQL-Python
    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>

pymysql
    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]

MySQL-Connector
    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>

cx_Oracle
    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]

connection engine

The beginning of any SQLAlchemy application is an Engine object, this object acts as a central source of connections to a particular database, providing what is called a connection pool for those database connections.

The Engine object is typically a global object that is created only once for a particular database server, and is configured with a URL string that will describe how to connect to the database host or backend.

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

Initially create the engine, which maintains a Pool (connection pool) and Dialect (dialect) inside the engine, and the dialect is used to identify the specific connection database type.

When the engine is created, the Pool and Dialect have also been created, but they are not actually connected to the database at this time, and they will not be connected to the database until the specific statement .connect() is executed.

There are many parameters of create_engine, I list some of the more commonly used ones:

• echo=False  -- if true, the engine will log all statements along with  repr() their argument list's default log handler.
• enable_from_linting  – Defaults to True. A warning will be issued if the given SELECT statement is found to be unlinked with elements that would result in a Cartesian product.
• encoding  -- defaults to utf-8
• future  -- use the 2.0 style
• hide_parameters  -- Boolean value, when set to True, SQL statement parameters will not be displayed in the info log, nor will they be formatted as StatementError objects.
• listeners  – a list of one or more  PoolListener objects that will receive connection pool events.
• logging_name  – string identifier, defaults to the hex string of the object id.
• max_identifier_length  – integer; overrides dialect-determined maximum identifier length.
• max_overflow=10  -- The number of connections allowed to "overflow" in the connection pool, i.e. the number of connections that can be opened above or beyond the pool size setting (5 by default).
• pool_size=5  -- The number of connections to keep open in the connection pool. The default is 5, when it is set to 0, it means unlimited connections
• Pool_recycle    sets the time to limit how long the database is not connected and disconnected automatically
• plugins  – list of strings of plugin names to load.

declaration mapping

That is, a class created in Python corresponds to a table in the database, and each attribute of the class is the field name of the table. This class corresponds to the class of the table in the database, and is called a mapping class.

We want to create a mapping class, which is defined based on the base class, and each mapping class must inherit this base class  declarative_base().

from sqlalchemy.orm import declarative_base
Base = declarative_base()

from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()

declarative_base() is a method encapsulated inside sqlalchemy. Through it, a base class is constructed. This base class and its subclasses can associate and map Python classes and database tables.

The database table model class is associated with the table through __tablename__, and Column represents the column of the data table.

Example:

• Create a new table called users, which is the user table.
• Create a new class called User which will be the class we map this table to. In the class we define the details of the table to map to, mainly the table name and the names and data types of the columns:

from sqlalchemy import Column, Integer, String


class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True)
    name = Column(String)
    fullname = Column(String)
    nickname = Column(String)

    def __repr__(self):
        return "<User(name='%s', fullname='%s', nickname='%s')>" % (
            self.name,
            self.fullname,
            self.nickname,
        )

__tablename__   represents the table name

Column:  Represents a column in the data table, and the data type is defined internally

primary_key: primary key

Create table to database

By defining the User class, we have defined information about the table, called table metadata, which is the metadata of the table. We can do this by inspecting the __table__ attribute:

User.__table__ 
Table('users', MetaData(),
            Column('id', Integer(), table=<users>, primary_key=True, nullable=False),
            Column('name', String(), table=<users>),
            Column('fullname', String(), table=<users>),
            Column('nickname', String(), table=<users>), schema=None)

Start creating the table: ignore it if it exists, execute the following code, and you will find that the users table is created in the db.

Base.metadata.create_all(engine)

Create a session (  session )

Session is used in sqlalchemy to create a session between the program and the database, and all objects need to be loaded and saved through the session object. That is, all operations on the table are implemented through sessions.

Create a factory through the sessionmaker call, and associate the Engine to ensure that each session can use the Engine to connect resources:

from sqlalchemy.orm import sessionmaker

Session = sessionmaker(bind=engine)
# 实例化
session = Session()

Common operation methods of session include:

1. flush: pre-submitted, submitted to the database file, not yet written into the database file
2. commit: commit a transaction
3. rollback: rollback
4. close: close

"add, update" object

>>> ed_user = User(name='ed', fullname='Ed Jones', nickname='edsnickname')
>>> session.add(ed_user)

A new user is added. At this time, the data is not in the synchronized database, but is in a waiting state.
In the above code, the instance object is only valid in the memory of the environment, and does not actually generate data in the table.
Only after the commit() method is executed, the data will actually be created in the data table.
If we query the database, all pending information is flushed first, and then the query is issued immediately.

>>> our_user = session.query(User).filter_by(name='ed').first() 
>>> our_user
<User(name='ed', fullname='Ed Jones', nickname='edsnickname')>

The result obtained at this time is not the final data in the database table, but an object of the mapping class.

Add, delete, modify, check

increase

add_user = Users("test", "[email protected]")
session.add(add_user)
session.commit()

session.add() will add the Model to the persistent space maintained by the current session (can be seen from session.dirty), and submit it to the database until commit.
Execute db.session.flush() after add, so that the properties of the object can be obtained in the session.
There are several methods for batch insertion, and their batches are compared, namely:
session.add_all() < bulk_save_object() < bulk_insert_mappings() < SQLAlchemy_core()

check

Query is the most commonly used operation. Here is the simplest query example:

users = session.query(Users).filter_by(id=1).all()
for item in users:
    print(item.name)

Usually we obtain data through the above query mode. It should be noted that through session.query() we query and return a Query object. At this time, we have not yet queried in the specific database. Only when the specific .all() is executed, . First() and other functions will actually operate the database.

Among them, query has two filtering methods, filter and filter_by, which are usually used.

The above example can also be written as:

users = session.query(Users).filter_by(Users.id == 1).all()

change

There are two ways to update data, one is to use the update method in query:

session.query(Users).filter_by(id=1).update({'name': "Jack"})

The other is to operate the corresponding table model:

users = session.query(Users).filter_by(name="Jack").first()
users.name = "test"
session.add(users)

Generally, you can choose the former for batch updates, but you need to use the latter for scenarios where you want to update the object attributes after querying them.

delete

Similar to updating data, there are two ways to delete data, the first one:

delete_users = session.query(Users).filter(Users.name == "test").first()
if delete_users:
    session.delete(delete_users)
    session.commit()

The second method: (recommended when deleting in batches)

session.query(Users).filter(Users.name == "test").delete()
session.commit()

rollback

Before  commit()  , the changes made to the properties of the instance object can be rolled back and returned to before the changes.

>>> session.rollback()

In essence, it just deletes a certain piece of data (that is, an instance of the mapping class) from memory, and does not perform any operations on the database.

Inquire

Query through  the query  keyword.

>>> for instance in session.query(User).order_by(User.id):
...     print(instance.name, instance.fullname)
ed Ed Jones
wendy Wendy Williams
mary Mary Contrary
fred Fred Flintstone

• query.filter()  filter
• query.filter_by()  filters based on keywords
• query.all()  returns a list
• query.first()  returns the first element
• query.one()  returns correctly when there is only one element
• query.one_or_none() , like one, but does not raise an error if no results are found
• query.scalar() , calls the one method, and returns the first column of the row on success
• query.count()  count
• query.order_by()  sorting

query.join()  connection query

>>> session.query(User).join(Address).\
...         filter(Address.email_address=='[email protected]').\
...         all()
[<User(name='jack', fullname='Jack Bean', nickname='gjffdd')>]

query(column.label())  can set an alias for the field name (column):

>>> for row in session.query(User.name.label('name_label')).all():
...    print(row.name_label)
ed
wendy
mary
fred

aliased() sets an alias for the query object:

>>> from sqlalchemy.orm import aliased
>>> user_alias = aliased(User, name='user_alias')

SQL>>> for row in session.query(user_alias, user_alias.name).all():
...    print(row.user_alias)
<User(name='ed', fullname='Ed Jones', nickname='eddie')>
<User(name='wendy', fullname='Wendy Williams', nickname='windy')>
<User(name='mary', fullname='Mary Contrary', nickname='mary')>
<User(name='fred', fullname='Fred Flintstone', nickname='freddy')>

Query common filter operators

# Equal to
query.filter(User.name == 'ed')

# Not equal to
query.filter(User.name != 'ed')

# like and ilike
query.filter(User.name.like('%ed%'))
query.filter(User.name.ilike('%ed%')) # case insensitive

# in
query.filter(User.name.in_(['ed', 'wendy', 'jack']))
query.filter(User.name.in_(
    session.query(User.name).filter(User.name.like('%ed%'))
))
# not in
query.filter(~User.name.in_(['ed', 'wendy', 'jack'])) 

# is
query.filter(User.name == None)
query.filter(User.name.is_(None))

# is not
query.filter(User.name != None)
query.filter(User.name.is_not(None))

# and
from sqlalchemy import and_
query.filter(and_(User.name == 'ed', User.fullname == 'Ed Jones'))
query.filter(User.name == 'ed', User.fullname == 'Ed Jones')
query.filter(User.name == 'ed').filter(User.fullname == 'Ed Jones')

# or
from sqlalchemy import or_
query.filter(or_(User.name == 'ed', User.name == 'wendy'))

# match
query.filter(User.name.match('wendy'))

Use textual SQL

Literal strings can be used flexibly Query in queries.

>>> from sqlalchemy import text
SQL>>> for user in session.query(User).\
...             filter(text("id<224")).\
...             order_by(text("id")).all():
...     print(user.name)
ed
wendy
mary
fred 

Use a colon to specify bind parameters. To specify a value, use Query.params()the method:

>>> session.query(User).filter(text("id<:value and name=:name")).\
...     params(value=224, name='fred').order_by(User.id).one()
<User(name='fred', fullname='Fred Flintstone', nickname='freddy')>

one-to-many

A user can have multiple email addresses, which means we need to create a new table to map and query with the user table.

>>> from sqlalchemy import ForeignKey
>>> from sqlalchemy.orm import relationship

>>> class Address(Base):
...     __tablename__ = 'addresses'
...     id = Column(Integer, primary_key=True)
...     email_address = Column(String, nullable=False)
...     user_id = Column(Integer, ForeignKey('users.id'))
...
...     user = relationship("User", back_populates="addresses")
...
...     def __repr__(self):
...         return "<Address(email_address='%s')>" % self.email_address

>>> User.addresses = relationship(
...     "Address", order_by=Address.id, back_populates="user")

ForeignKeyDefine the dependency relationship between two columns, indicating the user ID associated with the user table

The relationship  tells the ORM Addressclass itself that it should be linked to Userthe class, and back_populates  indicates the referenced complementary attribute name, which is its own table name.

many to many

In addition to the one-to-many table, there is also a many-to-many relationship. For example, in a blog site, there are many blogs BlogPost, each blog has many Keyword, and each blog Keywordcan correspond to many blogs.

For a normal many-to-many we need to create an unmapped Tableconstruct to be used as an association table. As follows:

>>> from sqlalchemy import Table, Text
>>> # association table
>>> post_keywords = Table('post_keywords', Base.metadata,
...     Column('post_id', ForeignKey('posts.id'), primary_key=True),
...     Column('keyword_id', ForeignKey('keywords.id'), primary_key=True)
... ) 

Next we define BlogPostand Keyword, using the complementary  relationship  construct, each referenced post_keywordstable as an association table:

>>> class BlogPost(Base):
...     __tablename__ = 'posts'
...
...     id = Column(Integer, primary_key=True)
...     user_id = Column(Integer, ForeignKey('users.id'))
...     headline = Column(String(255), nullable=False)
...     body = Column(Text)
...
...     # many to many BlogPost<->Keyword
...     keywords = relationship('Keyword',
...                             secondary=post_keywords,
...                             back_populates='posts')
...
...     def __init__(self, headline, body, author):
...         self.author = author
...         self.headline = headline
...         self.body = body
...
...     def __repr__(self):
...         return "BlogPost(%r, %r, %r)" % (self.headline, self.body, self.author)

>>> class Keyword(Base):
...     __tablename__ = 'keywords'
...
...     id = Column(Integer, primary_key=True)
...     keyword = Column(String(50), nullable=False, unique=True)
...     posts = relationship('BlogPost',
...                          secondary=post_keywords,
...                          back_populates='keywords')
...
...     def __init__(self, keyword):
...         self.keyword = keyword

The defining characteristic of a many-to-many relationship is that secondarythe keyword arguments refer to the object representing Tablethe associated table.

2. Use SQLAlchemy to manipulate tables

Create a single table

SQLAlchemy does not allow modifying the table structure. If you need to modify the table structure, you must delete the old table and create a new table, or execute the original SQL statement ALERT TABLE to modify.

This means that when using non-native SQL statements to modify the table structure, all existing records in the table will be lost, so we'd better design the entire table structure at one time to avoid later modification:

# models.py
import datetime
from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import scoped_session

from sqlalchemy import (
    create_engine,
    Column,
    Integer,
    String,
    Enum,
    DECIMAL,
    DateTime,
    Boolean,
    UniqueConstraint,
    Index,
)
from sqlalchemy.ext.declarative import declarative_base

# 基础类
Base = declarative_base()

# 创建引擎
engine = create_engine(
    "mysql+pymysql://tom:[email protected]:3306/db1?charset=utf8mb4",
    # "mysql+pymysql://[email protected]:3306/db1?charset=utf8mb4", # 无密码时
    # 超过链接池大小外最多创建的链接
    max_overflow=0,
    # 链接池大小
    pool_size=5,
    # 链接池中没有可用链接则最多等待的秒数，超过该秒数后报错
    pool_timeout=10,
    # 多久之后对链接池中的链接进行一次回收
    pool_recycle=1,
    # 查看原生语句（未格式化）
    echo=True,
)

# 绑定引擎
Session = sessionmaker(bind=engine)
# 创建数据库链接池，直接使用session即可为当前线程拿出一个链接对象conn
# 内部会采用threading.local进行隔离
session = scoped_session(Session)


class UserInfo(Base):
    """必须继承Base"""

    # 数据库中存储的表名
    __tablename__ = "userInfo"
    # 对于必须插入的字段，采用nullable=False进行约束，它相当于NOT NULL
    id = Column(Integer, primary_key=True, autoincrement=True, comment="主键")
    name = Column(String(32), index=True, nullable=False, comment="姓名")
    age = Column(Integer, nullable=False, comment="年龄")
    phone = Column(DECIMAL(6), nullable=False, unique=True, comment="手机号")
    address = Column(String(64), nullable=False, comment="地址")
    # 对于非必须插入的字段，不用采取nullable=False进行约束
    gender = Column(Enum("male", "female"), default="male", comment="性别")
    create_time = Column(DateTime, default=datetime.datetime.now, comment="创建时间")
    last_update_time = Column(
        DateTime, onupdate=datetime.datetime.now, comment="最后更新时间"
    )
    delete_status = Column(Boolean(), default=False, comment="是否删除")

    __table__args__ = (
        UniqueConstraint("name", "age", "phone"),  # 联合唯一约束
        Index("name", "addr", unique=True),  # 联合唯一索引
    )

    def __str__(self):
        return f"object : <id:{self.id} name:{self.name}>"


if __name__ == "__main__":
    # 删除表
    Base.metadata.drop_all(engine)
    # 创建表
    Base.metadata.create_all(engine)

record operation

new record

Add a single record:

# 获取链接池、ORM表对象
import models
​
​
user_instance = models.UserInfo(
    name="Jack",
    age=18,
    phone=330621,
    address="Beijing",
    gender="male"
)
​
models.session.add(user_instance)
​
# 提交
models.session.commit()
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

Add in batches

Adding in batches can reduce the number of TCP connections and improve insertion performance:

# 获取链接池、ORM表对象
import models
​
​
user_instance1 = models.UserInfo(
    name="Tom",
    age=19,
    phone=330624,
    address="Shanghai",
    gender="male"
)
​
user_instance2 = models.UserInfo(
    name="Mary",
    age=20,
    phone=330623,
    address="Chongqing",
    gender="female"
)
​
​
models.session.add_all(
    (
        user_instance1,
        user_instance2
    )
)
​
# 提交
models.session.commit()
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

modification record

Modify some records:

# 获取链接池、ORM表对象
import models
​
# 修改的信息：
#  - Jack -> Jack + son
# 在SQLAlchemy中，四则运算符号只能用于数值类型
# 如果是字符串类型需要在原本的基础值上做改变，必须设置
#  - age -> age + 1
# synchronize_session=False
​
models.session.query(models.UserInfo)\
    .filter_by(name="Jack")\
    .update(
        {
            "name": models.UserInfo.name + "son",
            "age": models.UserInfo.age + 1
        },
        synchronize_session=False
)
# 本次修改具有字符串字段在原值基础上做更改的操作，所以必须添加
# synchronize_session=False
# 如果只修改年龄，则不用添加
​
# 提交
models.session.commit()
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

Delete Record

Deleting records is relatively seldom used, just understand, generally add a delete_status field as above, if it is 1, it means delete:

# 获取链接池、ORM表对象
import models
​
models.session.query(models.UserInfo).filter_by(name="Mary").delete()
​
# 提交
models.session.commit()
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

single table query

basic query

To check all records and all fields, the all() method will return a list, which wraps the record object of each row:

# 获取链接池、ORM表对象
import models
​
result = models.session.query(models.UserInfo)\
    .all()
​
print(result)
# [<models.UserInfo object at 0x7f4d3d606fd0>, <models.UserInfo object at 0x7f4d3d606f70>]
​
for row in result:
    print(row)
# object : <id:1 name:Jackson>
# object : <id:2 name:Tom>
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

Check all records and certain fields (note that the tuple returned below is actually a named tuple, which can be directly operated by the . operator):

# 获取链接池、ORM表对象
import models
​
result = models.session.query(
    models.UserInfo.id,
    models.UserInfo.name,
    models.UserInfo.age
).all()
​
print(result)
# [(1, 'Jackson', 19), (2, 'Tom', 19)]
​
for row in result:
    print(row)
# (1, 'Jackson', 19)
# (2, 'Tom', 19)
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

Only take the first record, the first() method will return a single record object (note that the tuple returned below is actually a named tuple, which can be directly operated by the . operator):

# 获取链接池、ORM表对象
import models

result = models.session.query(
    models.UserInfo.id,
    models.UserInfo.name,
    models.UserInfo.age
).first()

print(result)
# (1, 'Jackson', 19)

# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

AS alias

Through the field's label() method, we can give it an alias:

# 获取链接池、ORM表对象
import models
​
result = models.session.query(
    models.UserInfo.name.label("s_name"),
    models.UserInfo.age.label("s_age")
).all()
​
for row in result:
    print(row.s_name)
    print(row.s_age)
​
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

conditional query

Filter by one condition:

# 获取链接池、ORM表对象
import models
​
result = models.session.query(
    models.UserInfo,
).filter(
    models.UserInfo.name == "Jackson"
).all()
​
# 上面是Python语句形式的过滤条件，由filter方法调用
# 亦可以使用ORM的形式进行过滤，通过filter_by方法调用
# 如下所示
# .filter_by(name="Jackson").all()
# 个人更推荐使用filter过滤，它看起来更直观，更简单，可以支持 == != > < >= <=等常见符号
​
# 过滤成功的结果数量
print(len(result))
# 1
​
# 过滤成功的结果
print(result)
# [<models.UserInfo object at 0x7f11391ea2b0>]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

AND query:

# 获取链接池、ORM表对象
import models
# 导入AND
from sqlalchemy import and_
​
result = models.session.query(
    models.UserInfo,
).filter(
    and_(
        models.UserInfo.name == "Jackson",
        models.UserInfo.gender == "male"
    )
).all()
​
# 过滤成功的结果数量
print(len(result))
# 1
​
# 过滤成功的结果
print(result)
# [<models.UserInfo object at 0x7f11391ea2b0>]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

OR query:

# 获取链接池、ORM表对象
import models
# 导入OR
from sqlalchemy import or_
​
result = models.session.query(
    models.UserInfo,
).filter(
    or_(
        models.UserInfo.name == "Jackson",
        models.UserInfo.gender == "male"
    )
).all()
​
# 过滤成功的结果数量
print(len(result))
# 1
​
# 过滤成功的结果
print(result)
# [<models.UserInfo object at 0x7f11391ea2b0>]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

NOT query:

# 获取链接池、ORM表对象
import models
# 导入NOT
from sqlalchemy import not_
​
result = models.session.query(
    models.UserInfo,
).filter(
    not_(
        models.UserInfo.name == "Jackson",
    )
).all()
​
# 过滤成功的结果数量
print(len(result))
# 1
​
# 过滤成功的结果
print(result)
# [<models.UserInfo object at 0x7f11391ea2b0>]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

range query

BETWEEN query:

# 获取链接池、ORM表对象
import models

result = models.session.query(
    models.UserInfo,
).filter(
    models.UserInfo.age.between(15, 21)
).all()

# 过滤成功的结果数量
print(len(result))
# 1

# 过滤成功的结果
print(result)
# [<models.UserInfo object at 0x7f11391ea2b0>]

# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

contains query

IN query:

# 获取链接池、ORM表对象
import models
​
result = models.session.query(
    models.UserInfo,
).filter(
    models.UserInfo.age.in_((18, 19, 20))
).all()
​
# 过滤成功的结果数量
print(len(result))
# 2
​
# 过滤成功的结果
print(result)
# [<models.UserInfo object at 0x7fdeeaa774f0>, <models.UserInfo object at 0x7fdeeaa77490>]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

NOT IN, just add ~:

# 获取链接池、ORM表对象
import models
​
result = models.session.query(
    models.UserInfo,
).filter(
    ~models.UserInfo.age.in_((18, 19, 20))
).all()
​
# 过滤成功的结果数量
print(len(result))
# 0
​
# 过滤成功的结果
print(result)
# []
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

fuzzy match

LIKE query:

# 获取链接池、ORM表对象
import models
​
result = models.session.query(
    models.UserInfo,
).filter(
    models.UserInfo.name.like("Jack%")
).all()
​
# 过滤成功的结果数量
print(len(result))
# 1
​
# 过滤成功的结果
print(result)
# [<models.UserInfo object at 0x7fee1614f4f0>]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

Paging query

Slice the list returned by the result all() once:

# 获取链接池、ORM表对象
import models
​
result = models.session.query(
    models.UserInfo,
).all()[0:1]
​
# 过滤成功的结果数量
print(len(result))
# 1
​
# 过滤成功的结果
print(result)
# [<models.UserInfo object at 0x7fee1614f4f0>]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

Sort query

ASC ascending order, DESC descending order, you need to specify the sorting rules:

# 获取链接池、ORM表对象
import models
​
result = models.session.query(
    models.UserInfo,
).filter(
    models.UserInfo.age > 12
).order_by(
    models.UserInfo.age.desc()
).all()
​
# 过滤成功的结果数量
print(len(result))
# 2
​
# 过滤成功的结果
print(result)
# [<models.UserInfo object at 0x7f90eccd26d0>, <models.UserInfo object at 0x7f90eccd2670>]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

aggregation grouping

Aggregation grouping and having filtering:

# 获取链接池、ORM表对象
import models
# 导入聚合函数
from sqlalchemy import func
​
result = models.session.query(
    func.sum(models.UserInfo.age)
).group_by(
    models.UserInfo.gender
).having(
    func.sum(models.UserInfo.id > 1)
).all()
​
# 过滤成功的结果数量
print(len(result))
# 1
​
# 过滤成功的结果
print(result)
# [(Decimal('38'),)]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

multi-table query

Create multiple tables

Five-table relationship:

Create table statement:

# models.py
from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import scoped_session
from sqlalchemy.orm import relationship
​
from sqlalchemy import (
    create_engine,
    Column,
    Integer,
    Date,
    String,
    Enum,
    ForeignKey,
    UniqueConstraint,
)
from sqlalchemy.ext.declarative import declarative_base
​
# 基础类
Base = declarative_base()
​
# 创建引擎
engine = create_engine(
    "mysql+pymysql://tom:[email protected]:3306/db1?charset=utf8mb4",
    # "mysql+pymysql://[email protected]:3306/db1?charset=utf8mb4", # 无密码时
    # 超过链接池大小外最多创建的链接
    max_overflow=0,
    # 链接池大小
    pool_size=5,
    # 链接池中没有可用链接则最多等待的秒数，超过该秒数后报错
    pool_timeout=10,
    # 多久之后对链接池中的链接进行一次回收
    pool_recycle=1,
    # 查看原生语句
    # echo=True
)
​
# 绑定引擎
Session = sessionmaker(bind=engine)
# 创建数据库链接池，直接使用session即可为当前线程拿出一个链接对象
# 内部会采用threading.local进行隔离
session = scoped_session(Session)
​
​
class StudentsNumberInfo(Base):
    """学号表"""
    __tablename__ = "studentsNumberInfo"
    id = Column(Integer, primary_key=True, autoincrement=True, comment="主键")
    number = Column(Integer, nullable=False, unique=True, comment="学生编号")
    admission = Column(Date, nullable=False, comment="入学时间")
    graduation = Column(Date, nullable=False, comment="毕业时间")
​
​
class TeachersInfo(Base):
    """教师表"""
    __tablename__ = "teachersInfo"
    id = Column(Integer, primary_key=True, autoincrement=True, comment="主键")
    number = Column(Integer, nullable=False, unique=True, comment="教师编号")
    name = Column(String(64), nullable=False, comment="教师姓名")
    gender = Column(Enum("male", "female"), nullable=False, comment="教师性别")
    age = Column(Integer, nullable=False, comment="教师年龄")
​
​
class ClassesInfo(Base):
    """班级表"""
    __tablename__ = "classesInfo"
    id = Column(Integer, primary_key=True, autoincrement=True, comment="主键")
    number = Column(Integer, nullable=False, unique=True, comment="班级编号")
    name = Column(String(64), nullable=False, unique=True, comment="班级名称")
    # 一对一关系必须为连接表的连接字段创建UNIQUE的约束，这样才能是一对一，否则是一对多
    fk_teacher_id = Column(
        Integer,
        ForeignKey(
            "teachersInfo.id",
            ondelete="CASCADE",
            onupdate="CASCADE",
        ),
        nullable=False,
        unique=True,
        comment="班级负责人"
    )
    # 下面这2个均属于逻辑字段，适用于正反向查询。在使用ORM的时候，我们不必每次都进行JOIN查询，而恰好正反向的查询使用频率会更高
    # 这种逻辑字段不会在物理层面上创建，它只适用于查询，本身不占据任何数据库的空间
    # sqlalchemy的正反向概念与Django有所不同，Django是外键字段在那边，那边就作为正
    # 而sqlalchemy是relationship字段在那边，那边就作为正
    # 比如班级表拥有 relationship 字段，而老师表不曾拥有
    # 那么用班级表的这个relationship字段查老师时，就称为正向查询
    # 反之，如果用老师来查班级，就称为反向查询
    # 另外对于这个逻辑字段而言，根据不同的表关系，创建的位置也不一样：
    #  - 1 TO 1：建立在任意一方均可，查询频率高的一方最好
    #  - 1 TO M：建立在M的一方
    #  - M TO M：中间表中建立2个逻辑字段，这样任意一方都可以先反向，再正向拿到另一方
    #  - 遵循一个原则，ForeignKey建立在那个表上，那个表上就建立relationship
    #  - 有几个ForeignKey，就建立几个relationship
    # 总而言之，使用ORM与原生SQL最直观的区别就是正反向查询能带来更高的代码编写效率，也更加简单
    # 甚至我们可以不用外键约束，只创建这种逻辑字段，让表与表之间的耦合度更低，但是这样要避免脏数据的产生
​
    # 班级负责人，这里是一对一关系，一个班级只有一个负责人
    leader_teacher = relationship(
        # 正向查询时所链接的表，当使用 classesInfo.leader_teacher 时，它将自动指向fk的那一条记录
        "TeachersInfo",
        # 反向查询时所链接的表，当使用 teachersInfo.leader_class 时，它将自动指向该老师所管理的班级
        backref="leader_class",
    )
​
​
class ClassesAndTeachersRelationship(Base):
    """任教老师与班级的关系表"""
    __tablename__ = "classesAndTeachersRelationship"
    id = Column(Integer, primary_key=True, autoincrement=True, comment="主键")
    # 中间表中注意不要设置单列的UNIQUE约束，否则就会变为一对一
    fk_teacher_id = Column(
        Integer,
        ForeignKey(
            "teachersInfo.id",
            ondelete="CASCADE",
            onupdate="CASCADE",
        ),
        nullable=False,
        comment="教师记录"
    )
​
    fk_class_id = Column(
        Integer,
        ForeignKey(
            "classesInfo.id",
            ondelete="CASCADE",
            onupdate="CASCADE",
        ),
        nullable=False,
        comment="班级记录"
    )
    # 多对多关系的中间表必须使用联合唯一约束，防止出现重复数据
    __table_args__ = (
        UniqueConstraint("fk_teacher_id", "fk_class_id"),
    )
​
    # 逻辑字段
    # 给班级用的，查看所有任教老师
    mid_to_teacher = relationship(
        "TeachersInfo",
        backref="mid",
    )
​
    # 给老师用的，查看所有任教班级
    mid_to_class = relationship(
        "ClassesInfo",
        backref="mid"
    )
​
​
class StudentsInfo(Base):
    """学生信息表"""
    __tablename__ = "studentsInfo"
    id = Column(Integer, primary_key=True, autoincrement=True, comment="主键")
    name = Column(String(64), nullable=False, comment="学生姓名")
    gender = Column(Enum("male", "female"), nullable=False, comment="学生性别")
    age = Column(Integer, nullable=False, comment="学生年龄")
    # 外键约束
    # 一对一关系必须为连接表的连接字段创建UNIQUE的约束，这样才能是一对一，否则是一对多
    fk_student_id = Column(
        Integer,
        ForeignKey(
            "studentsNumberInfo.id",
            ondelete="CASCADE",
            onupdate="CASCADE"
        ),
        nullable=False,
        comment="学生编号"
    )
    # 相比于一对一，连接表的连接字段不用UNIQUE约束即为多对一关系
    fk_class_id = Column(
        Integer,
        ForeignKey(
            "classesInfo.id",
            ondelete="CASCADE",
            onupdate="CASCADE"
        ),
        comment="班级编号"
    )
    # 逻辑字段
    # 所在班级, 这里是一对多关系，一个班级中可以有多名学生
    from_class = relationship(
        "ClassesInfo",
        backref="have_student",
    )
    # 学生学号，这里是一对一关系，一个学生只能拥有一个学号
    number_info = relationship(
        "StudentsNumberInfo",
        backref="student_info",
    )
​
​
if __name__ == "__main__":
    # 删除表
    Base.metadata.drop_all(engine)
    # 创建表
    Base.metadata.create_all(engine)

Insert data:

# 获取链接池、ORM表对象
import models
import datetime
​
​
models.session.add_all(
    (
        # 插入学号表数据
        models.StudentsNumberInfo(
            number=160201,
            admission=datetime.datetime.date(datetime.datetime(2016, 9, 1)),
            graduation=datetime.datetime.date(datetime.datetime(2021, 6, 15))
        ),
        models.StudentsNumberInfo(
            number=160101,
            admission=datetime.datetime.date(datetime.datetime(2016, 9, 1)),
            graduation=datetime.datetime.date(datetime.datetime(2021, 6, 15))
        ),
        models.StudentsNumberInfo(
            number=160301,
            admission=datetime.datetime.date(datetime.datetime(2016, 9, 1)),
            graduation=datetime.datetime.date(datetime.datetime(2021, 6, 15))
        ),
        models.StudentsNumberInfo(
            number=160102,
            admission=datetime.datetime.date(datetime.datetime(2016, 9, 1)),
            graduation=datetime.datetime.date(datetime.datetime(2021, 6, 15))
        ),
        models.StudentsNumberInfo(
            number=160302,
            admission=datetime.datetime.date(datetime.datetime(2016, 9, 1)),
            graduation=datetime.datetime.date(datetime.datetime(2021, 6, 15))
        ),
        models.StudentsNumberInfo(
            number=160202,
            admission=datetime.datetime.date(datetime.datetime(2016, 9, 1)),
            graduation=datetime.datetime.date(datetime.datetime(2021, 6, 15))
        ),
        # 插入教师表数据
        models.TeachersInfo(
            number=3341, name="David", gender="male", age=32,
        ),
        models.TeachersInfo(
            number=3342, name="Jason", gender="male", age=30,
        ),
        models.TeachersInfo(
            number=3343, name="Lisa", gender="female", age=28,
        ),
        # 插入班级表数据
        models.ClassesInfo(
            number=1601, name="one year one class", fk_teacher_id=1
        ),
        models.ClassesInfo(
            number=1602, name="one year two class", fk_teacher_id=2
        ),
        models.ClassesInfo(
            number=1603, name="one year three class", fk_teacher_id=3
        ),
        # 插入中间表数据
        models.ClassesAndTeachersRelationship(
            fk_class_id=1, fk_teacher_id=1
        ),
        models.ClassesAndTeachersRelationship(
            fk_class_id=2, fk_teacher_id=1
        ),
        models.ClassesAndTeachersRelationship(
            fk_class_id=3, fk_teacher_id=1
        ),
        models.ClassesAndTeachersRelationship(
            fk_class_id=1, fk_teacher_id=2
        ),
        models.ClassesAndTeachersRelationship(
            fk_class_id=3, fk_teacher_id=3
        ),
        # 插入学生表数据
        models.StudentsInfo(
            name="Jack", gender="male", age=17, fk_student_id=1, fk_class_id=2
        ),
        models.StudentsInfo(
            name="Tom", gender="male", age=18, fk_student_id=2, fk_class_id=1
        ),
        models.StudentsInfo(
            name="Mary", gender="female", age=16, fk_student_id=3,
            fk_class_id=3
        ),
        models.StudentsInfo(
            name="Anna", gender="female", age=17, fk_student_id=4,
            fk_class_id=1
        ),
        models.StudentsInfo(
            name="Bobby", gender="male", age=18, fk_student_id=6, fk_class_id=2
        ),
    )
)
​
models.session.commit()
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

JOIN query

INNER JOIN：

# 获取链接池、ORM表对象
import models
​
result = models.session.query(
    models.StudentsInfo.name,
    models.StudentsNumberInfo.number,
    models.ClassesInfo.number
).join(
    models.StudentsNumberInfo,
    models.StudentsInfo.fk_student_id == models.StudentsNumberInfo.id
).join(
    models.ClassesInfo,
    models.StudentsInfo.fk_class_id == models.ClassesInfo.id
).all()
​
print(result)
# [('Jack', 160201, 1602), ('Tom', 160101, 1601), ('Mary', 160301, 1603), ('Anna', 160102, 1601), ('Bobby', 160202, 1602)]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

LEFT JOIN only needs to specify the isouter keyword parameter as True in each JOIN:

session.query(
    左表.字段,
    右表.字段
)
.join(
    右表,
    链接条件,
    isouter=True
).all()

RIGHT JOIN needs to change the position of the table. SQLALchemy itself does not provide RIGHT JOIN, so you must pay attention to the driver order when using it. Small tables drive large tables (if you don’t pay attention to the order, the MySQL optimizer will also optimize):

session.query(
    左表.字段,
    右表.字段
)
.join(
    左表,
    链接条件,
    isouter=True
).all()

UNION&UNION ALL

To combine multiple query results, filter() must be used without all() method behind.

Because all() returns a list, and filter() returns a <class 'sqlalchemy.orm.query.Query'> query object. In addition, a certain field must be taken alone, and query() cannot be directly specified without specifying the field:

# 获取链接池、ORM表对象
import models
​
students_name = models.session.query(models.StudentsInfo.name).filter()
students_number = models.session.query(models.StudentsNumberInfo.number)\
    .filter()
class_name = models.session.query(models.ClassesInfo.name).filter()
​
result = students_name.union_all(students_number).union_all(class_name)
​
print(result.all())
# [
#      ('Jack',), ('Tom',), ('Mary',), ('Anna',), ('Bobby',),
#      ('160101',), ('160102',), ('160201',), ('160202',), ('160301',), ('160302',),
#      ('one year one class',), ('one year three class',), ('one year two class',)
# ]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

subquery

The subquery is implemented using subquery() as follows, querying for the youngest person in each class:

# 获取链接池、ORM表对象
import models
from sqlalchemy import func
​
# 子查询中所有字段的访问都需要加上c的前缀
# 如 sub_query.c.id、 sub_query.c.name等
sub_query = models.session.query(
    # 使用label()来为字段AS一个别名
    # 后续访问需要通过sub_query.c.alias进行访问
    func.min(models.StudentsInfo.age).label("min_age"),
    models.ClassesInfo.id,
    models.ClassesInfo.name
).join(
    models.ClassesInfo,
    models.StudentsInfo.fk_class_id == models.ClassesInfo.id
).group_by(
    models.ClassesInfo.id
).subquery()
​
​
result = models.session.query(
    models.StudentsInfo.name,
    sub_query.c.min_age,
    sub_query.c.name
).join(
    sub_query,
    sub_query.c.id == models.StudentsInfo.fk_class_id
).filter(
   sub_query.c.min_age == models.StudentsInfo.age
)
​
print(result.all())
# [('Jack', 17, 'one year two class'), ('Mary', 16, 'one year three class'), ('Anna', 17, 'one year one class')]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

Positive and negative query

Above we all query through JOIN, in fact we can also query through the logical field relationship.

The following is an example of a forward query. A forward query refers to starting a query from a table with a relationship logical field:

# 查询所有学生的所在班级，我们可以通过学生的from_class字段拿到其所在班级
# 另外，对于学生来说，班级只能有一个，所以have_student应当是一个对象
​
# 获取链接池、ORM表对象
import models
​
students_lst = models.session.query(
    models.StudentsInfo
).all()
​
for row in students_lst:
    print(f"""
            student name : {row.name}
            from : {row.from_class.name}
          """)
​
# student name : Mary
# from : one year three class
​
# student name : Anna
# from : one year one class
​
# student name : Bobby
# from : one year two class
​
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

The following is an example of a reverse query, which refers to querying from a table without a relationship logical field:

# 查询所有班级中的所有学生，学生表中有relationship，并且它的backref为have_student，所以我们可以通过班级.have_student来获取所有学生记录
​
# 另外，对于班级来说，学生可以有多个，所以have_student应当是一个序列
​
# 获取链接池、ORM表对象
import models
​
classes_lst = models.session.query(
    models.ClassesInfo
).all()
​
for row in classes_lst:
    print("class name :", row.name)
    for student in row.have_student:
        print("student name :", student.name)
​
# class name : one year one class
#      student name : Jack
#      student name : Anna
# class name : one year two class
#      student name : Tom
# class name : one year three class
#      student name : Mary
#      student name : Bobby
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

To sum up, the logical field of the forward query always gets an object, and the logical field of the reverse query always gets a list.

reverse method

Using the logical field relationship can directly add, delete, modify and query some cross-table records.

Since the logical field is a list-like existence (only for reverse queries, forward queries always get an object), most methods of lists can be used.

<class 'sqlalchemy.orm.collections.InstrumentedList'>
    - append()
    - clear()
    - copy()
    - count()
    - extend()
    - index()
    - insert()
    - pop()
    - remove()
    - reverse()
    - sort()

The actual machine demonstration will not be performed below, because we have made many constraints in the above tables.

# 比如
# 给老师增加班级
result = session.query(Teachers).first()
# extend方法：
result.re_class.extend([
    Classes(name="三年级一班",),
    Classes(name="三年级二班",),
])
​
# 比如
# 减少老师所在的班级
result = session.query(Teachers).first()
​
# 待删除的班级对象,集合查找比较快
delete_class_set = {
    session.query(Classes).filter_by(id=7).first(),
    session.query(Classes).filter_by(id=8).first(),
}
​
# 循换老师所在的班级
# remove方法：
for class_obj in result.re_class:
    if class_obj in delete_class_set:
        result.re_class.remove(class_obj)
​
# 比如
# 清空老师所任教的所有班级
# 拿出一个老师
result = session.query(Teachers).first()
result.re_class.clear()

Query case

1) To see how many students there are in each class:

JOIN queries:

# 获取链接池、ORM表对象
import models
​
from sqlalchemy import func
​
result = models.session.query(
    models.ClassesInfo.name,
    func.count(models.StudentsInfo.id)
).join(
    models.StudentsInfo,
    models.ClassesInfo.id == models.StudentsInfo.fk_class_id
).group_by(
    models.ClassesInfo.id
).all()
​
print(result)
# [('one year one class', 2), ('one year two class', 2), ('one year three class', 1)]
​
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

Positive and negative query:

# 获取链接池、ORM表对象
import models
​
result = {}
class_lst = models.session.query(
    models.ClassesInfo
).all()
​
for row in class_lst:
    for student in row.have_student:
        count = result.setdefault(row.name, 0)
        result[row.name] = count + 1
​
print(result.items())
# dict_items([('one year one class', 2), ('one year two class', 2), ('one year three class', 1)])
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

2) View each student's enrollment, graduation year, and class name:

JOIN queries:

# 获取链接池、ORM表对象
import models
​
result = models.session.query(
    models.StudentsNumberInfo.number,
    models.StudentsInfo.name,
    models.ClassesInfo.name,
    models.StudentsNumberInfo.admission,
    models.StudentsNumberInfo.graduation
).join(
    models.StudentsInfo,
    models.StudentsInfo.fk_class_id == models.ClassesInfo.id
).join(
    models.StudentsNumberInfo,
    models.StudentsNumberInfo.id == models.StudentsInfo.fk_student_id
).order_by(
    models.StudentsNumberInfo.number.asc()
).all()
​
print(result)
# [
#     (160101, 'Tom', 'one year one class', datetime.date(2016, 9, 1), datetime.date(2021, 6, 15)),
#     (160102, 'Anna', 'one year one class', datetime.date(2016, 9, 1), datetime.date(2021, 6, 15)),
#     (160201, 'Jack', 'one year two class', datetime.date(2016, 9, 1), datetime.date(2021, 6, 15)),
#     (160202, 'Bobby', 'one year two class', datetime.date(2016, 9, 1), datetime.date(2021, 6, 15)),
#     (160301, 'Mary', 'one year three class', datetime.date(2016, 9, 1), datetime.date(2021, 6, 15))
# ]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

Positive and negative query:

# 获取链接池、ORM表对象
import models
​
result = []
​
student_lst = models.session.query(
    models.StudentsInfo
).all()
​
for row in student_lst:
    result.append((
        row.number_info.number,
        row.name,
        row.from_class.name,
        row.number_info.admission,
        row.number_info.graduation
    ))
​
print(result)
# [
#     (160101, 'Tom', 'one year one class', datetime.date(2016, 9, 1), datetime.date(2021, 6, 15)),
#     (160102, 'Anna', 'one year one class', datetime.date(2016, 9, 1), datetime.date(2021, 6, 15)),
#     (160201, 'Jack', 'one year two class', datetime.date(2016, 9, 1), datetime.date(2021, 6, 15)),
#     (160202, 'Bobby', 'one year two class', datetime.date(2016, 9, 1), datetime.date(2021, 6, 15)),
#     (160301, 'Mary', 'one year three class', datetime.date(2016, 9, 1), datetime.date(2021, 6, 15))
# ]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

3) View the youngest student among the students taught by David:

JOIN queries:

# 获取链接池、ORM表对象
import models
​
result = models.session.query(
    models.TeachersInfo.name,
    models.StudentsInfo.name,
    models.StudentsInfo.age,
    models.ClassesInfo.name
).join(
    models.ClassesAndTeachersRelationship,
    models.ClassesAndTeachersRelationship.fk_class_id == models.ClassesInfo.id
).join(
    models.TeachersInfo,
    models.ClassesAndTeachersRelationship.fk_teacher_id == models.TeachersInfo.id
).join(
    models.StudentsInfo,
    models.StudentsInfo.fk_class_id == models.ClassesInfo.id
).filter(
    models.TeachersInfo.name == "David"
).order_by(
    models.StudentsInfo.age.asc(),
    models.StudentsInfo.id.asc()
).limit(1).all()
​
print(result)
# [('David', 'Mary', 16, 'one year three class')]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

Positive and negative query:

# 获取链接池、ORM表对象
import models
​
david = models.session.query(
    models.TeachersInfo
).filter(
    models.TeachersInfo.name == "David"
).first()
​
student_lst = []
​
# 反向查询拿到任教班级，反向是一个列表，所以直接for
for row in david.mid:
    cls = row.mid_to_class
    # 通过任教班级，反向拿到其下的所有学生
    cls_students = cls.have_student
    # 遍历学生
    for student in cls_students:
        student_lst.append(
            (
                david.name,
                student.name,
                student.age,
                cls.name
            )
        )
​
# 筛选出年龄最小的
min_age_student_lst = sorted(
    student_lst, key=lambda tpl: tpl[2])[0]
​
print(min_age_student_lst)
# ('David', 'Mary', 16, 'one year three class')
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

4) Check who is the person in charge of each class and who the teachers are:

JOIN queries:

# 获取链接池、ORM表对象
import models
​
from sqlalchemy import func
​
# 先查任课老师
sub_query = models.session.query(
    models.ClassesAndTeachersRelationship.fk_class_id.label("class_id"),
    func.group_concat(models.TeachersInfo.name).label("have_teachers")
).join(
    models.ClassesInfo,
    models.ClassesAndTeachersRelationship.fk_class_id == models.ClassesInfo.id
).join(
    models.TeachersInfo,
    models.ClassesAndTeachersRelationship.fk_teacher_id == models.TeachersInfo.id
).group_by(
    models.ClassesAndTeachersRelationship.fk_class_id
).subquery()
​
result = models.session.query(
    models.ClassesInfo.name.label("class_name"),
    models.TeachersInfo.name.label("leader_teacher"),
    sub_query.c.have_teachers.label("have_teachers")
).join(
    models.TeachersInfo,
    models.ClassesInfo.fk_teacher_id == models.TeachersInfo.id
).join(
    sub_query,
    sub_query.c.class_id == models.ClassesInfo.id
).all()
​
print(result)
# [('one year one class', 'David', 'Jason,David'), ('one year two class', 'Jason', 'David'), ('one year three class', 'Lisa', 'David,Lisa')]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

Positive and negative query:

# 获取链接池、ORM表对象
import models
​
result = []
​
# 获取所有班级
classes_lst = models.session.query(
    models.ClassesInfo
).all()
​
for cls in classes_lst:
    cls_message = [
        cls.name,
        cls.leader_teacher.name,
        [],
    ]
    for row in cls.mid:
        cls_message[-1].append(row.mid_to_teacher.name)
    result.append(cls_message)
​
print(result)
# [['one year one class', 'David', ['David', 'Jason']], ['one year two class', 'Jason', ['David']], ['one year three class', 'Lisa', ['David', 'Lisa']]]
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()

native SQL

View execution commands

If a query statement ends with filter(), the __str__ method of the object will return the formatted query statement:

print(
    models.session.query(models.StudentsInfo).filter()
)
​
SELECT `studentsInfo`.id AS `studentsInfo_id`, `studentsInfo`.name AS `studentsInfo_name`, `studentsInfo`.gender AS `studentsInfo_gender`, `studentsInfo`.age AS `studentsInfo_age`, `studentsInfo`.fk_student_id AS `studentsInfo_fk_student_id`, `studentsInfo`.fk_class_id AS `studentsInfo_fk_class_id`
FROM `studentsInfo`

Execute native commands

To execute native commands, use the session.execute() method, which will return a cursor object, as shown below:

# 获取链接池、ORM表对象
import models
​
cursor = models.session.execute(
    "SELECT * FROM studentsInfo WHERE id = (:uid)", params={'uid': 1})
​
print(cursor.fetchall())
​
# 关闭链接，亦可使用session.remove()，它将回收该链接
models.session.close()  # 获取链接池、ORM表对象

3. Python library (package) dictalchemy

Documentation: https://pythonhosted.org/dictalchemy/

dictalchemy is a Python library for converting SQLAlchemy models to dictionaries. It provides an easy way to convert SQLAlchemy model objects into dictionary form for easy processing and serialization in Python.

Installation: pip install dictalchemy

Installation: pip install dictalchemy3 (remove support for Python2, compatible with the latest SQLAlchemy)

example

from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, scoped_session
from dictalchemy import make_class_dictable

# 创建 SQLAlchemy 数据库引擎和会话
engine = create_engine('sqlite:///mydatabase.db')
Base = declarative_base(bind=engine)
session = scoped_session(sessionmaker(bind=engine))


# 定义 SQLAlchemy 模型
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, primary_key=True)
    username = Column(String)
    email = Column(String)


# 将模型类转换为可序列化的字典类型
make_class_dictable(User)

# 查询数据库获取模型对象
user = session.query(User).first()

# 将模型对象转换为字典
user_dict = user.to_dict()
print(user_dict)