关联代理 SQLAlchemy

Question

This source 详细介绍了如何使用关联代理来创建具有 ORM 对象值的视图和对象。

但是，当我附加一个与数据库中现有对象匹配的值时（并且该值是唯一的或主键），它会创建一个冲突的对象，因此我无法提交。

所以在我的情况下，这仅作为视图有用，我需要使用 ORM 查询来检索要附加的对象。

这是我唯一的选择还是我可以使用合并（如果它是主键而不是唯一约束，我可能只能这样做），或者设置构造函数以使其使用数据库中的现有对象如果它存在而不是创建一个新对象？

例如来自文档：

user.keywords.append('cheese inspector')

# Is translated by the association proxy into the operation:

user.kw.append(Keyword('cheese inspector'))

但我想被翻译成更像：（当然查询可能会失败）。

keyword = session.query(Keyword).filter(Keyword.keyword == 'cheese inspector').one()
user.kw.append(keyword)

理想情况下

user.kw.append(Keyword('cheese inspector'))
session.merge() # retrieves identical object from the database, or keeps new one
session.commit() # success!

我想这甚至可能不是一个好主意，但在某些用例中可能是这样的:)

Answer 1

您链接到的文档页面上显示的示例是 composition 类型的关系（在 OOP 术语中），因此代表 owns 类型的关系，而不是在动词方面的 uses。因此，每个owner 都有自己的相同（就值而言）关键字的副本。

事实上，您可以完全使用您在问题中链接到的文档中的建议来创建自定义 creator 方法并破解它以重用给定键的现有对象，而不仅仅是创建一个新对象。在这种情况下，User 类和creator 函数的示例代码如下所示：

def _keyword_find_or_create(kw):
    keyword = Keyword.query.filter_by(keyword=kw).first()
    if not(keyword):
        keyword = Keyword(keyword=kw)
        # if aufoflush=False used in the session, then uncomment below
        #session.add(keyword)
        #session.flush()
    return keyword

class User(Base):
    __tablename__ = 'user'
    id = Column(Integer, primary_key=True)
    name = Column(String(64))
    kw = relationship("Keyword", secondary=lambda: userkeywords_table)
    keywords = association_proxy('kw', 'keyword', 
            creator=_keyword_find_or_create, # @note: this is the 
            )

Answer 2

我最近遇到了同样的问题。 SQLAlchemy 的创建者 Mike Bayer 向我推荐了“unique object” recipe，但也向我展示了一个使用事件侦听器的变体。后一种方法修改了关联代理，使UserKeyword.keyword 临时指向一个纯字符串，并且仅在该关键字不存在时创建一个新的关键字对象。

from sqlalchemy import event

# Same User and Keyword classes from documentation

class UserKeyword(Base):
    __tablename__ = 'user_keywords'

    # Columns
    user_id = Column(Integer, ForeignKey(User.id), primary_key=True)
    keyword_id = Column(Integer, ForeignKey(Keyword.id), primary_key=True)
    special_key = Column(String(50))

    # Bidirectional attribute/collection of 'user'/'user_keywords'
    user = relationship(
        User,
        backref=backref(
            'user_keywords',
            cascade='all, delete-orphan'
            )
        )

    # Reference to the 'Keyword' object
    keyword = relationship(Keyword)

    def __init__(self, keyword=None, user=None, special_key=None):
        self._keyword_keyword = keyword_keyword  # temporary, will turn into a
                                                 # Keyword when we attach to a 
                                                 # Session
        self.special_key = special_key

    @property
    def keyword_keyword(self):
        if self.keyword is not None:
            return self.keyword.keyword
        else:
            return self._keyword_keyword

    @event.listens_for(Session, "after_attach")
    def after_attach(session, instance):
        # when UserKeyword objects are attached to a Session, figure out what 
        # Keyword in the database it should point to, or create a new one
        if isinstance(instance, UserKeyword):
            with session.no_autoflush:
                keyword = session.query(Keyword).\
                    filter_by(keyword=instance._keyword_keyword).\
                    first()
                if keyword is None:
                    keyword = Keyword(keyword=instance._keyword_keyword)
                instance.keyword = keyword