SQLAlchemy自引用多对一关系：示例

Question

As I was following the SQLAlchemy documentation on adjacency list relationships , I was able to replicate their Node example as follows:

node_tree = Node(data='root', children=[
    Node(data='child1'),
    Node(data='child2', children=[
        Node(data='subchild1'),
        Node(data='subchild2'),
    ]),
    Node(data='child3'),
])

However, I was not able to do the same for the many-to-one relationship. What would an example of this look like?

Answer 1

Working from the example and many-to-one class definition provided at the aforementioned link (only difference is the added remote_side argument), plus a nice __repr__ for visualization...

class Node(Base):
    __tablename__ = 'node'
    id = Column(Integer, primary_key=True)
    parent_id = Column(Integer, ForeignKey('node.id'))
    data = Column(String(50))
    parent = relationship("Node", remote_side=[id])

    def __repr__(self):
        return "Node(data={!r})".format(self.data)

# Create tree.
node_tree = Node(data='root')
child1 = Node(data='child1', parent=node_tree)
child2 = Node(data='child2', parent=node_tree)
subchild1 = Node(data='subchild1', parent=child2)
subchild2 = Node(data='subchild2', parent=child2)
child3 = Node(data='child3', parent=node_tree)

# For viewing the session as it works.
def print_session_state(operation):
    print(operation)
    print('new: {}'.format(session.new))
    print('dirty: {}\n'.format(session.dirty))

# When child2 is added...
session.add(child2)
print_session_state('add child2')
# Roll back.
session.rollback()
print_session_state('rollback')
# When subchild1 is added...
session.add(subchild1)
print_session_state('add subchild1')

The result:

add child2
new: IdentitySet([Node(data='child2'), Node(data='root')])
dirty: IdentitySet([])

rollback
new: IdentitySet([])
dirty: IdentitySet([])

add subchild1
new: IdentitySet([Node(data='subchild1'), Node(data='child2'), Node(data='root')])
dirty: IdentitySet([])

The first thing you'll notice is that the instantiation isn't as pretty, since the hierarchy is defined from the bottom up this time.

Also, the cascading behavior is different. With the one-to-many relationship, each Node was aware of its children (plural) and cascading traveled down the tree.

With many-to-one, each Node is only aware of its parent (singular) and cascading travels up the tree, such that only those Node s in the same branch of the tree as the starting point are reached.