We Keep Coding

Ordering relationship by property of child elements

I use flask-sqlalchemy on a Flask project to model my database.
I need to sort the elements of a many-to-many relationship based on properties of different child elements of one side.
I have "Work" (the parent element), "Tag" (the children), "Type" (a one-to-many relationship on Tag) and "Block" (a one-to-many relationship on Type). Tags and Works are joined with a mapping table "work_tag_mapping".
In essence, each tag has exactly one type, each type belongs to exactly one block, and many tags can be added on many works.
I now want the list of tags on a work be sorted by block first and type second (both have a "position" column for that purpose).
Here are my tables (simplified for the sake of the question):
class Work(db.Model):
__tablename__ = 'work'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255, collation='utf8_bin'))
tags = db.relationship('Tag', order_by="Tag.type.block.position, Tag.type.position", secondary=work_tag_mapping)
class Tag(db.Model):
__tablename__ = 'tag'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255, collation='utf8_bin'))
type_id = db.Column(db.Integer, db.ForeignKey('type.id'), nullable=False)
type = db.relationship('Type')
work_tag_mapping = db.Table('work_tag_mapping',
db.Column('id', db.Integer, primary_key=True),
db.Column('work_id', db.Integer, db.ForeignKey('work.id'), nullable=False),
db.Column('tag_id', db.Integer, db.ForeignKey('tag.id'), nullable=False)
)
class Type(db.Model):
__tablename__ = 'type'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255, collation='utf8_bin'))
position = db.Column(db.Integer)
block_id = db.Column(db.Integer, db.ForeignKey('block.id'), nullable=False)
block = db.relationship('Block')
class Block(db.Model):
__tablename__ = 'block'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255, collation='utf8_bin'))
position = db.Column(db.Integer)
Now, it is the "order_by" in the "tags" relationship that doesn't work as I initially hoped.
The error I get is "sqlalchemy.exc.InvalidRequestError: Property 'type' is not an instance of ColumnProperty (i.e. does not correspond directly to a Column)."
I am new to SQLalchemy, Flask and indeed Python, and none of the ressources or questions here mention a case like this.

While this appears not to be possible directly, adding a getter and performing the sorting on retrieval does the trick. Adding lazy='dynamic' ensures the collection behaves as a query, so joins can be performed.
_tags = db.relationship('Tag', lazy='dynamic')
#hybrid_property
def tags(self):
return self._tags.join(Type).join(Block).order_by(Block.position, Type.position)

How to use Dict[str, str] as a relationship property in sqlalchemy

Suppose I have a model that conceptually should just be a dictionary from one simple type to another for a parent. I've tried to implement custom collection class but it seems that it isn't the right approach, because a custom collection should take something of type L1 as an argument when it adds it to collection. But the interface I want is Root(children={'a': 'a'})
class L1(Base):
__tablename__ = 'l1s'
id = sa.Column(sa.Integer, primary_key=True)
parent_id = sa.Column(sa.Integer, sa.ForeignKey('roots.id'))
name = sa.Column(sa.String, unique=True)
value = sa.Column(sa.String)
class Root(Base):
__tablename__ = 'roots'
id = sa.Column(sa.Integer, primary_key=True)
name = sa.Column(sa.String, unique=True)
children = relationship('L1', backref='parent', collection_class=partial(AsSimpleDict, L1, 'name', 'value'))

I think what you might be looking for is the combination of a collection_class relationship and association_proxy.
class Parent(declarative.Base):
__tablename__ = 'parent'
id = Column("parent_id", Integer, primary_key=True)
_config = relationship("Config",
collection_class=attribute_mapped_collection('key'),
cascade="all, delete-orphan")
config = association_proxy('_config', 'value',
creator=lambda k, v: Config(key=k, value=v))
class Config(declarative.Base):
__tablename__ = 'config'
id = Column("config_id", Integer, primary_key=True)
parent_id = Column(Integer, ForeignKey('parent.parent_id'))
playlist = relationship("Parent", back_populates="_config")
key = Column(String)
value = Column(String)
My understanding is that in this example, _config is effectively a key -> Config object dict, and that the association proxy takes this and presents it as a key -> value dict. Finally, the creator function turns parent.config[key] = value assignments into the creation of a Config object behind the scenes.

Sqlalchemy Define Multiple One-to-One Relationships between same Schemas (and a backref)

I cannot seem to get around a AmbigiousForeignKeyError here. Here is currently what I'm dealing with
class Node(Base):
__tablename__ = 'nodes'
id = Column(Integer, primary_key=true)
prev_change = relationship("NodeChange", back_populates="new_node", uselist=False)
next_change = relationship("NodeChange", back_populates="old_node", uselist=False)
Class NodeChange(Base):
__tablename__ = "node_changes"
id = Column(Integer, primary_key=true)
date = Column(Date)
old_node_id = Column(Integer, ForeignKey('nodes.id'))
old_node = relationship("Node", foreign_keys=[old_node_id])
new_node_id = Column(Integer, ForeignKey('nodes.id'))
new_node = relationship("Node", foreign_keys=[new_node_id])
The idea behind this is to traverse node objects via node change objects that store time related information (is the change viable or not etc.)
Both relationships here are one-to-one. I have gotten this working while excluding the prev_change and next_change backrefs, but cannot get the 2 way relationship working without encountering a AmbigiousForeignKeyError.

The easiest way to fix this looks to be:
remove the prev_change and next_change relationships from Node
add them as backref to the old_node and new_node
This is how new relationships look like:
old_node = relationship(
"Node", foreign_keys=[old_node_id],
backref=backref('prev_change', uselist=False),
)
new_node = relationship(
"Node", foreign_keys=[new_node_id],
backref=backref('next_change', uselist=False),
)

Combining relationships

I have a model Zone, a model Entity and a model Transit. Transit is minimally defined as:
class Entity(db.Model):
__tablename__ = 'entities'
id = db.Column(db.Integer, primary_key=True)
contained_by = db.Column(db.Integer, db.ForeignKey('entities.id'))
contains = db.relationship('Entity', backref='container')
discriminator = db.Column('type', db.String(50))
__mapper_args__ = {'polymorphic_on': discriminator}
class Zone(Entity):
__mapper_args__ = {'polymorphic_identity': 'zones'}
routes = db.relationship('Transit')
(stuff goes here)
class Transit(db.Model):
__tablename__ = "transits"
start = db.Column(db.Integer, db.ForeignKey('zones.id'))
end = db.Column(db.Integer, db.ForeignKey('zones.id'))
Zone also has a couple of bits about distance and how defensible it is, but that is irrelevant for this.
First off, due to the fact that Zone is subclassed from Entity using single-table inheritance can I reference zones.id?
Secondly, will the Zone.routes property merge Transit.start and Transit.end?

no, you need to use the table name, which in your case (Single-table inheritance) is entities
no, these will not be merged. You can create two relationships, and have a (hybrid) property which would combine both, but this will only be for reading purposes, as when you would like to modify this property (for example, add Transits), you would still need to specify both sides (start and end).
I am not sure I understand the question here
update-1: as requested in comment, Concrete-Table inheritance code below:
class Zone(Entity):
__mapper_args__ = {'polymorphic_identity': 'zones'}
__tablename__ = "zones"
id = Column(Integer, ForeignKey('entities.id'), primary_key=True)
#property
def transits(self):
return self.transits_from_here + self.transits_to_here
class Transit(Base):
__tablename__ = "transits"
id = Column(Integer, primary_key=True)
start = Column(Integer, ForeignKey('zones.id'))
end = Column(Integer, ForeignKey('zones.id'))
s_zone = relationship(Zone, primaryjoin=(start==Zone.id), backref="transits_from_here")
e_zone = relationship(Zone, primaryjoin=(end==Zone.id), backref="transits_to_here")

Delete parent if the child is deleted

I want to delete the parent row if the associated rows in child tables have been removed.
class Child(Base):
__tablename__ = "children"
id = Column(Integer, primary_key=True)
parent_id = Column(Integer, ForeignKey("parents.id", ondelete='CASCADE'))
class Parent(Base):
__tablename__ = "parents"
id = Column(Integer, primary_key=True)
child = relationship(Child, backref="parent", passive_deletes=True)
If I remove the child
child_obj = session.query(Child).first()
session.delete(child_obj)
session.commit()
It does delete the child obj but parent remains as it is. I want to remove the parent as well using cascading.

You can read this thread:
Linking Relationships with Backref
class User(Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True)
name = Column(String)
addresses = relationship("Address", backref="user")
class Address(Base):
__tablename__ = 'address'
id = Column(Integer, primary_key=True)
email = Column(String)
user_id = Column(Integer, ForeignKey('user.id'))
And you can define it in your child class:
parent = relationship(Parent, backref=backref("children", cascade="all,delete"))

You could do this for simple* cases by creating a listener that intercepts deletions of Child instances and deletes the parent if there are no other children.
import sqlalchemy as sa
#sa.event.listens_for(sessionmaker, 'persistent_to_deleted')
def intercept_persistent_to_deleted(session, object_):
# We are only interested in instances of Child.
if not isinstance(object_, Child):
return
p = object_.parent
# Handle null parents.
if p is None:
return
cs = session.query(Child).filter(Child.parent == p).count()
if cs == 0:
session.delete(p)
* I would recommend thorough testing if your code is doing things like deleting children and then creating new children with the deleted children's parents in the same session. The listener works in this case:
c = session.query(Child).first()
p = c.parent
session.delete(c)
c1 = Child(parent=p)
session.add(c1)
session.commit()
but hasn't been tested on anything more complicated.

The behavior you're referring to is kinda simple. But once the application gets larger, you'd need more sophisticated methods. I, personally, implement a static method remove for every class. It takes the id and any other parameter necessary to know the delete scheme.
The answer is already given... But that's - not efficient - approach just to give you an example.
class Child(Base):
__tablename__ = "children"
id = Column(Integer, primary_key=True)
parent_id = Column(Integer, ForeignKey("parents.id", ondelete='CASCADE'))
#staticmethod
def remove(_id_):
child = Child.query().get(_id_)
Parent.remove(child.parent_id)
session.delete(child)
class Parent(Base):
__tablename__ = "parents"
id = Column(Integer, primary_key=True)
child = relationship(Child, backref="parent", passive_deletes=True)
#staticmethod
def remove(_id_):
parent = parent.query().get(_id_)
session.delete(parent)
If you, for example, added a Column named is_old - in the Child class - that's a binary integer 0 or 1 and wanted to delete the parent of the Child that has is_old == 1, It'll be very easy task.