嵌套sqlalchemy过滤器与父和子

Question

采用以下方案：

class User(Base):
    id = Column(Integer, primary_key=True)
    name = Column(String)

class Photo(Base):
    id = Column(Integer, primary_key=True)
    user_id = Column(Integer, ForeignKey(User.id), nullable=False)
    user = relationship(User)

class Tag(Base):
    id = Column(Integer, primary_key=True)
    tag_name = Column(String)
    tag_version = Column(Integer)
    photo_id = Column(Integer, ForeignKey(Photo.id), nullable=False)
    photo = relationship(Photo)

如何创建SQLAlchemy查询以获取特定用户的所有照片，这些照片没有特定的标记和版本。

与"all the photos of the user with id "1234" that don't have a "cat" of version "2" tagged in them"一样。

同样有趣的是"all the users who have at least one photo without a specific tag"

我正在使用postgreSQL btw。

Answer 1

这是一个完整的示例，用于设置关系，创建一些示例数据，然后执行两个查询。

设定：

from datetime import datetime
from sqlalchemy import create_engine, Column, Integer, String, ForeignKey, not_
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, relationship

engine = create_engine('sqlite:///', echo=True)
Session = sessionmaker(bind=engine)
session = Session()
Base = declarative_base(bind=engine)


class User(Base):
    __tablename__ = 'user'

    id = Column(Integer, primary_key=True)
    name = Column(String, nullable=False)


class Photo(Base):
    __tablename__ = 'photo'

    id = Column(Integer, primary_key=True)
    name = Column(String, nullable=False)
    user_id = Column(Integer, ForeignKey(User.id), nullable=False)

    user = relationship(User, backref='photos')


class Tag(Base):
    __tablename__ = 'tag'

    id = Column(Integer, primary_key=True)
    name = Column(String, nullable=False)
    photo_id = Column(Integer, ForeignKey(Photo.id), nullable=False)

    photo = relationship(Photo, backref='tags')


Base.metadata.create_all()
session.add(User(name='davidism', photos=[
    Photo(name='sun', tags=[Tag(name='bright'), Tag(name='day')]),
    Photo(name='moon', tags=[Tag(name='bright'), Tag(name='night')])
]))
session.add(User(name='eran', photos=[
    Photo(name='party', tags=[Tag(name='people'), Tag(name='night')]),
    Photo(name='cat')
]))
session.commit()

查询所有没有标签的照片：

no_tags = session.query(Photo).outerjoin(Photo.tags).filter(not_(Photo.tags.any())).all()
print 'no tags: ', len(no_tags)

查询所有没有“夜晚”标签的照片：

not_night = session.query(Photo).outerjoin(Photo.tags).filter(not_(Photo.tags.any(Tag.name == 'night'))).all()
print 'not night: ', len(not_night)

Answer 2

假设存在backrefs Tag.photo = relationship(Photo, backref='tags')和 Photo.user = relationship(User, backref="photos")两者都可以使用any构造完成。这可能不会生成最佳SQL SELECT语句，但它非常干净sqlalchemy。

第1部分："all the photos of the user with id "1234" that don't have a "cat" of version "2" tagged in them"

def get_user_photos_without_tag(user_id, tag_name, tag_version):
    qry = (session.query(Photo)
            .filter(~Photo.tags.any(and_(
                Tag.tag_name == tag_name,
                Tag.tag_version == tag_version))
            )
            .filter(Photo.user_id == user_id)
        )
    return qry.all()

photos = get_user_photos_without_tag(1234, 'cat', 2)

第2部分："all the users who have at least one photo without a specific tag"

def get_user_with_photos_without_tag(tag_name, tag_version):
    qry = (session.query(User)
            .filter(User.photos.any(
                ~Photo.tags.any(and_(
                    Tag.tag_name == tag_name,
                    Tag.tag_version == tag_version))
                ))
        )
    return qry.all()

res = get_user_with_photos_without_tag('cat', 2)