Eu tenho um projeto onde gostaria de armazenar uma grande estrutura (objetos aninhados) em um banco de dados relacional (Postgres). É parte de uma estrutura maior e eu não me importo com o formato de serialização - estou feliz por ser um blob em uma coluna - gostaria apenas de poder persistir e restaurá-lo rapidamente.

Para os meus propósitos, o SQLAlchemy PickleType faz principalmente o trabalho. O problema que tenho é que eu gostaria que os cheques sujos funcionassem (algo para o qual os Mutable Types são usados). Eu gostaria que eles funcionassem não apenas se eu alterasse as informações nos caminhos, mas também nos limites (que ficam em outro nível abaixo).

class Group(Base):
    __tablename__ = 'group'

    id = Column(Integer, primary_key=True)
    name = Column(String, nullable=False)
    paths = Column(types.PickleType)

class Path(object):
    def __init__(self, style, bounds):
        self.style = style
        self.bounds = bounds

class Bound(object):
    def __init__(self, l, t, r, b):
        self.l = l
        self.t = t
        self.r = r
        self.b = b

# this is all fine
g = Group(name='g1', paths=[Path('blah', Bound(1,1,2,3)),
                            Path('other_style', Bound(1,1,2,3)),])
session.add(g)
session.commit()

# so is this
g.name = 'g2'
assert g in session.dirty
session.commit()

# but this won't work without some sort of tracking on the deeper objects
g.paths[0].style = 'something else'
assert g in session.dirty # nope

Eu brinquei com os tipos Mutable tentando fazê-lo funcionar, mas não tive sorte. Em outros lugares, eu uso os tipos mutáveis ​​para uma coluna json, o que é bom - de uma maneira que parece mais simples, porque com essas classes você precisa rastrear mudanças em objetos dentro dos objetos também.

Quaisquer pensamentos apreciados.