Python与数据库[2] -> 关系对象映射/ORM[5] -> 利用 sqlalchemy 实现关系表查询功能

利用 sqlalchemy 实现关系表查询功能

---

下面的例子将完成一个通过关系表进行查询的功能，示例中的数据表均在MySQL中建立，建立过程可以使用 SQL 命令或编写 Python 适配器完成。

示例中用到的表主要有3张，一张personInfo个人信息表，一张account_store账号信息表，以及一张person_account_rel的个人信息与账号关系表。

示例中将会通过已知的人物年龄和id通过个人信息表查出个人姓名(仅为参考示例，请忽略怪异的查找逻辑 :) )，随后根据关系表得到的人物名字所对应的账号id，再根据给定的账号信息筛选出所需的账号密码结果。

完整代码如下

 from sqlalchemy import create_engine, exc, orm
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.sql.schema import Table, ForeignKey, Column
 from sqlalchemy.sql.sqltypes import Integer, VARCHAR
 from sqlalchemy.dialects.mysql.base import TINYINT
 from sqlalchemy.orm import relationship

 # declarative_base function will return a class which using active record pattern
 # It will combine object opeartion and data operation automatically
 Base = declarative_base()

 # This is rel table
 t_PersonAccount_Rel = Table('personaccount_rel',
                             Base.metadata,
                             Column('name', VARCHAR(8), ForeignKey('person_info.name')),
                             Column('account_id', Integer, ForeignKey('account_store.account_id')))

 # Create table based on Base obj
 class PersonInfo(Base):
     __table__ = Table('person_info',
                         Base.metadata,
                         Column('id', TINYINT(4)),
                         Column('age', Integer),
                         Column('name', VARCHAR(8), primary_key=True))

     # Need to search via person --> account
     # So build up a relationship between person and account
     # relationship(class_name, class, class_name)
     AccountStore = relationship('AccountStore',
                                 secondary=t_PersonAccount_Rel,
                                 backref='PersonInfo')

 class AccountStore(Base):
     __table__ = Table('account_store',
                         Base.metadata,
                         Column('account_id', Integer, primary_key=True),
                         Column('items', VARCHAR(20)),
                         Column('account', VARCHAR(50)),
                         Column('password', VARCHAR(50)))

     def __repr__(self):
         return 'Items: %s\nAccount: %s\nPassword: %s' % (self.items, self.account, self.password)

 class SqlalchemyActor():
     def __init__(self, dsn):
         try:
             engine = create_engine(dsn, echo=False, max_overflow=5, encoding='utf-8')
         except ImportError:
             raise RuntimeError
         engine.connect()

         # sessionmaker is a factory obj, generate a Session instance, reload __call__ function
         # __call__ function will return a session class each time
         Session = orm.sessionmaker(bind=engine)
         # use Session() to create a class, and assign it to an attribute
         self.session = Session()
         # Assign costom table and engine to attribute
         self.account = AccountStore.__table__
         self.engine = engine
         # Bind engine and table
         # Method one: assign manually one by one
         self.account.metadata.bind = engine
         # Method two: use reflect to map all/partly Table schema
         #Base.metadata.reflect(engine)

 class PersonInfoCriteria():
     """
     This is the criteria for PersonInfo
     Replace None with input value
     """
     def __init__(self, **kwargs):
         self.id = None
         self.age = None
         self.name = None
         self.result = None

         for field, argument in kwargs.items():
             if str(field) == 'id':
                 self.id = argument
             if str(field) == 'age':
                 self.age = argument
             if str(field) == 'name':
                 self.name = argument

 class PersonInfoService():
     """
     This is the service for PersonInfo
     Generate condition and filter out expression for filter(SQL) according to criteria value
     """

     # This function to build criteria(expression/clause) for filter(SQL)
     # Note: PersonInfo is based on declarative_base,
     # so PersonInfo.attr == value is an condition expression(clause) for sqlalchemy function
     # also PersonInfo.attr.like(value) too, like function equal to "%" in SQL
     # finally return the list of clauses
     @staticmethod
     def _criteria_builder(person_info_criteria):
         clauses = []
         if person_info_criteria.id:
             clauses.append(PersonInfo.id == person_info_criteria.id)
         if person_info_criteria.age:
             clauses.append(PersonInfo.age == person_info_criteria.age)
         if person_info_criteria.name:
             if '%' in person_info_criteria.name:
                 clauses.append(PersonInfo.name.like(person_info_criteria.name))
             else:
                 clauses.append(PersonInfo.name == person_info_criteria.name)
         return clauses

     @staticmethod
     def find(person_info_criteria, session):
         # Build clauses for session filter
         clauses = PersonInfoService._criteria_builder(person_info_criteria)
         # Query PersonInfo and filter according to clauses, use all() function to return as list
         person_info_criteria.result = session.query(PersonInfo).filter(*clauses).all()
         return person_info_criteria.result

 class AccountStoreCriteria():
     def __init__(self, **kwargs):
         self.items = None
         self.account = None
         self.password = None
         self.account_id = None
         self.person_info = None
         self.result = None

         for field, argument in kwargs.items():
             if field == 'items':
                 self.items = argument
             if field == 'account':
                 self.account = argument
             if field == 'password':
                 self.password = argument
             if field == 'account_id':
                 self.account_id = argument
             if field == 'person_info':
                 self.person_info = argument

 class AccountStoreService():

     @staticmethod
     def _criteria_builder(account_store_criteria):
         clauses = []
         if account_store_criteria.items:
             clauses.append(AccountStore.items == account_store_criteria.items)
         if account_store_criteria.account:
             if '%' in account_store_criteria.account:
                 clauses.append(AccountStore.account.like(account_store_criteria.account))
             else:
                 clauses.append(AccountStore.account == account_store_criteria.account)
         if account_store_criteria.password:
             clauses.append(AccountStore.password == account_store_criteria.password)
         if account_store_criteria.account_id:
             clauses.append(AccountStore.accout_id == account_store_criteria.account_id)

         # person_info from PersonInfoService filter
         # Note: pnif.AccountStore is an instrumentedList type obj
         # sqlalchemy use instrumentedList to simulate one-to-many and many-to-many relationships
         # sqlalchemy does not support in_ many to many relationships yet
         # in_() function to filter out account id in range
         # SQL: SELECT * FROM account_store WHERE account_store.account_id in (...)
         if account_store_criteria.person_info:
             account_ids = []
             for pnif in account_store_criteria.person_info:
                 for acid in pnif.AccountStore:
                     account_ids.append(acid.account_id)
             clauses.append(AccountStore.account_id.in_(account_ids))

         return clauses

     @staticmethod
     def find(account_store_criteria, session):
         clauses = AccountStoreService._criteria_builder(account_store_criteria)
         account_store_criteria.result = session.query(AccountStore).filter(*clauses).all()
         return account_store_criteria.result

 if __name__ == '__main__':
     #dsn = 'mssql+pyodbc://ItpReadOnly:@reaedonlyENC@encitp.cn.ao.ericsson.se\itp:0/ITP'
     dsn = 'mysql+mysqldb://root:root@localhost/test_db'
     ses = SqlalchemyActor(dsn)
     session = ses.session

     # Filter out the person information according to id and age
     id, age = 2, 7
     clauses = PersonInfoCriteria(id=id, age=age)
     # re is an obj list of PersonInfo, use obj.attr to fetch value
     person_info = PersonInfoService.find(clauses, session)
     name = person_info[0].name
     print('Filter out user: %s' % name)

     # Filter out the account id according to name via relation table
     items = ['WeChat', 'Qq']
     for it in items:
         clauses = AccountStoreCriteria(items=it, person_info=person_info)
         account_info = AccountStoreService.find(clauses, session)
         for ac in account_info:
             print(30*'-'+'\n%s' % name)
             print(ac)

下面将分段进行解释
首先对所需的模块进行相应的导入

from sqlalchemy import create_engine, exc, orm
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.sql.schema import Table, ForeignKey, Column
from sqlalchemy.sql.sqltypes import Integer, VARCHAR
from sqlalchemy.dialects.mysql.base import TINYINT
from sqlalchemy.orm import relationship

随后利用声明层函数产生一个声明层类，这个声明层类使用了Active Record设计模式，能够自动将对象的修改变为表格的修改

# declarative_base function will return a class which using active record pattern
# It will combine object opeartion and data operation automatically
Base = declarative_base()

接下来将进行表格建立的工作，首先建立一张关系表类对应数据库中的关系表格，此处的关系表格采用显示的ORM方式，即不基于声明层的表格类，同时定义外键信息。

# This is rel table
t_PersonAccount_Rel = Table('personaccount_rel',
                            Base.metadata,
                            Column('name', VARCHAR(8), ForeignKey('person_info.name')),
                            Column('account_id', Integer, ForeignKey('account_store.account_id')))

随后利用声明层建立起两张信息表，由于需要通过个人信息表与关系表两张表查找到账号的信息，因此在定义PersonInfo表类的时候，需要同时定义一个关系对象，利用relationship函数建立起表中的关系对象。

# Create table based on Base obj
class PersonInfo(Base):
    __table__ = Table('person_info',
                        Base.metadata,
                        Column('id', TINYINT(4)),
                        Column('age', Integer),
                        Column('name', VARCHAR(8), primary_key=True))

    # Need to search via person --> account
    # So build up a relationship between person and account
    # relationship(class_name, class, class_name)
    AccountStore = relationship('AccountStore',
                                secondary=t_PersonAccount_Rel,
                                backref='PersonInfo')

class AccountStore(Base):
    __table__ = Table('account_store',
                        Base.metadata,
                        Column('account_id', Integer, primary_key=True),
                        Column('items', VARCHAR(20)),
                        Column('account', VARCHAR(50)),
                        Column('password', VARCHAR(50)))

    def __repr__(self):
        return 'Items: %s\nAccount: %s\nPassword: %s' % (self.items, self.account, self.password)

最后定义一个sqlalchemy的执行器，利用基本建立步骤建立起各项对应关系

Note: 由于使用的是声明层，因此此处的metadata的绑定可以省略，这部分可参考声明层表对象的两种建立方式。

class SqlalchemyActor():
    def __init__(self, dsn):
        try:
            engine = create_engine(dsn, echo=False, max_overflow=5, encoding='utf-8')
        except ImportError:
            raise RuntimeError
        engine.connect()

        # sessionmaker is a factory obj, generate a Session instance, reload __call__ function
        # __call__ function will return a session class each time
        Session = orm.sessionmaker(bind=engine)
        # use Session() to create a class, and assign it to an attribute
        self.session = Session()
        # Assign costom table and engine to attribute
        self.account = AccountStore.__table__
        self.engine = engine
        # Bind engine and table
        # Method one: assign manually one by one
        self.account.metadata.bind = engine
        # Method two: use reflect to map all/partly Table schema
        #Base.metadata.reflect(engine)

接着，将进行信息标准类及信息筛选类的建立，利用这两个类来完成类似于SQL中的条件信息筛选。

首先是信息标准类，用于存储所需要进行处理的条件信息，根据传入的参数对筛选信息类的属性进行赋值。

class PersonInfoCriteria():
    """
    This is the criteria for PersonInfo
    Replace None with input value
    """
    def __init__(self, **kwargs):
        self.id = None
        self.age = None
        self.name = None
        self.result = None

        for field, argument in kwargs.items():
            if str(field) == 'id':
                self.id = argument
            if str(field) == 'age':
                self.age = argument
            if str(field) == 'name':
                self.name = argument

接着建立起一个个人信息的处理服务类 PersonInfoService，在这个类中将建立起两个静态方法，首先是_criteria_builder静态方法(确切来说应该算是clauses_builder)，该静态方法会根据属性的存在，来建立起一个clauses条件语句的列表，随后再定义一个查找函数，利用query获取表格信息，再利用filter函数及前面的clause条件语句进行筛选得到最终的结果。

Note: 此处值得注意的是，由于此处的PersonInfo是一个声明层表格类，因此其==号两边的返回结果将不是bool值的True或False，而是一个等价于SQL条件的语句，一般用于filter函数中实现条件筛选。参考filter()函数的传入参数形式。

class PersonInfoService():
    """
    This is the service for PersonInfo
    Generate condition and filter out expression for filter(SQL) according to criteria value
    """

    # This function to build criteria(expression/clause) for filter(SQL)
    # Note: PersonInfo is based on declarative_base,
    # so PersonInfo.attr == value is an condition expression(clause) for sqlalchemy function
    # also PersonInfo.attr.like(value) too, like function equal to "%" in SQL
    # finally return the list of clauses
    @staticmethod
    def _criteria_builder(person_info_criteria):
        clauses = []
        if person_info_criteria.id:
            clauses.append(PersonInfo.id == person_info_criteria.id)
        if person_info_criteria.age:
            clauses.append(PersonInfo.age == person_info_criteria.age)
        if person_info_criteria.name:
            if '%' in person_info_criteria.name:
                clauses.append(PersonInfo.name.like(person_info_criteria.name))
            else:
                clauses.append(PersonInfo.name == person_info_criteria.name)
        return clauses

    @staticmethod
    def find(person_info_criteria, session):
        # Build clauses for session filter
        clauses = PersonInfoService._criteria_builder(person_info_criteria)
        # Query PersonInfo and filter according to clauses, use all() function to return as list
        person_info_criteria.result = session.query(PersonInfo).filter(*clauses).all()
        return person_info_criteria.result

与前面类似，此处针对account_store类建立其标准类及服务类

Note: 此处应当注意的是，由于需要通过关系表的查询，因此需要在这个筛选标准类中多增加一项筛选标准，即传入的PersonInfo筛选结果，若传入了person_info项目，则说明需要对个人信息进行关系筛选。

class AccountStoreCriteria():
    def __init__(self, **kwargs):
        self.items = None
        self.account = None
        self.password = None
        self.account_id = None
        self.person_info = None
        self.result = None

        for field, argument in kwargs.items():
            if field == 'items':
                self.items = argument
            if field == 'account':
                self.account = argument
            if field == 'password':
                self.password = argument
            if field == 'account_id':
                self.account_id = argument
            if field == 'person_info':
                self.person_info = argument

Note: 此处的表格服务类值得注意的是，在创建条件子句时，对于中间表的处理。由于在sqlalchemy的in_()函数尚且不支持多对多筛选，此处sqlalchemy利用instrumentedList来处理一对多或多对多的情况，在之前建立的Account_Store关系对象中，AccountStore即是instrumentList类型，可以利用instrumentList.in_(list)建立条件语句。此处利用for循环首先获取所有需要的account_id信息，生成一个列表，随后利用id列表建立等价于SQL的IN条件语句，添加到clause中。关于instrumentedList，参考stackoverflow的答案。

class AccountStoreService():

    @staticmethod
    def _criteria_builder(account_store_criteria):
        clauses = []
        if account_store_criteria.items:
            clauses.append(AccountStore.items == account_store_criteria.items)
        if account_store_criteria.account:
            if '%' in account_store_criteria.account:
                clauses.append(AccountStore.account.like(account_store_criteria.account))
            else:
                clauses.append(AccountStore.account == account_store_criteria.account)
        if account_store_criteria.password:
            clauses.append(AccountStore.password == account_store_criteria.password)
        if account_store_criteria.account_id:
            clauses.append(AccountStore.accout_id == account_store_criteria.account_id)

        # person_info from PersonInfoService filter
        # Note: pnif.AccountStore is an instrumentedList type obj
        # sqlalchemy use instrumentedList to simulate one-to-many and many-to-many relationships
        # sqlalchemy does not support in_ many to many relationships yet
        # in_() function to filter out account id in range
        # SQL: SELECT * FROM account_store WHERE account_store.account_id in (...)
        if account_store_criteria.person_info:
            account_ids = []
            for pnif in account_store_criteria.person_info:
                for acid in pnif.AccountStore:
                    account_ids.append(acid.account_id)
            clauses.append(AccountStore.account_id.in_(account_ids))

        return clauses

    @staticmethod
    def find(account_store_criteria, session):
        clauses = AccountStoreService._criteria_builder(account_store_criteria)
        account_store_criteria.result = session.query(AccountStore).filter(*clauses).all()
        return account_store_criteria.result

最后是执行的主程序，连接本地数据库，通过id和age筛选出name信息，随后利用关系表通过name与account_id的对应，以及所需账户类型，找到账户信息，最终显示。

if __name__ == '__main__':
    dsn = 'mysql+mysqldb://root:root@localhost/test_db'
    ses = SqlalchemyActor(dsn)
    session = ses.session

    # Filter out the person information according to id and age
    id, age = 2, 7
    clauses = PersonInfoCriteria(id=id, age=age)
    # re is an obj list of PersonInfo, use obj.attr to fetch value
    person_info = PersonInfoService.find(clauses, session)
    name = person_info[0].name
    print('Filter out user: %s' % name)

    # Filter out the account id according to name via relation table
    items = ['WeChat', 'Qq']
    for it in items:
        clauses = AccountStoreCriteria(items=it, person_info=person_info)
        account_info = AccountStoreService.find(clauses, session)
        for ac in account_info:
            print(30*'-'+'\n%s' % name)
            print(ac)

运行代码得到结果

Filter out user: LIKE
------------------------------
LIKE
Items: WeChat
Account: hereisac
Password: 12345
------------------------------
LIKE
Items: Qq
Account: re32isac
Password: 123435

从最终显示的结果可以看到，通过一系列筛选过程，得到了最终所需的账号密码信息

相关阅读

---

1. ORM 与 sqlalchemy 模块

2. sqlalchemy 的基本使用

3. 建立声明层表对象的两种方式

4. 声明层 ORM 访问方式