deleting element from table in sql-alchemy

Question

I am trying to delete a table entry in flask-sqlalchemy but I get the following error.

AttributeError: 'Join' object has no attribute 'delete'

(I included the entire error message below). The table I am trying to delete from is

class Groups(db.Model):

    id = db.Column(db.Integer, primary_key=True)
    leader_id = db.Column(db.Integer, db.ForeignKey('user.id'))
    name = db.Column(db.String(1000))
    start_datetime = db.Column(db.DateTime)
    email_notification = db.Column(db.String(6))
    member_count = db.Column(db.Integer)
    new_member_confirmed = db.Column(db.SmallInteger)
    next_jc = db.Column(db.DateTime)
    last_jc = db.Column(db.DateTime)
    meeting_location = db.Column(db.String(1000))
    meeting_time = db.Column(db.DateTime)
    meeting_period = db.Column(db.String(10))
    meeting_timezone = db.Column(db.String(1000))
    meeting_weekday = db.Column(db.String(1000))

    vote_list = db.relationship('Papers',
                            secondary="join(Papers, VoteList, Papers.arxiv_id == VoteList.arxiv_id)",
                            primaryjoin="and_(Groups.id == VoteList.group_id)") 
    members = db.relationship('User',
                          secondary="join(Members, User, User.id == Members.user_id)",
                          primaryjoin="and_(Groups.id == Members.group_id)") 

    def __repr__(self):
        return '<Groups %r>' % (self.id)

Here are the other tables which play a role in this

class VoteList(db.Model):

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
    group_id = db.Column(db.Integer, db.ForeignKey('groups.id'))
    arxiv_id = db.Column(db.String(1000), db.ForeignKey('papers.arxiv_id'))
    vote_datetime = db.Column(db.DateTime)

    def __repr__(self):
        return '<VoteList %r>' % (self.id)

class Members(db.Model):

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
    group_id = db.Column(db.Integer, db.ForeignKey('groups.id'))

    def __repr__(self):
         return '<Members %r>' % (self.id)

class User(db.Model):
    __searchable__ = ['username','email','position','institute','id']

    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(64), index=True, unique=True)
    email = db.Column(db.String(120), index=True, unique=True)
    start_datetime = db.Column(db.DateTime)
    password = db.Column(db.String(1000))
    position = db.Column(db.String(1000))
    institute = db.Column(db.String(1000))
    interests = db.Column(db.String(10000))
    CV_path = db.Column(db.String(1000))
    profile_picture_path = db.Column(db.String(1000))
    github_account = db.Column(db.String(1000))
    linkedin_account = db.Column(db.String(1000))
    jc_count = db.Column(db.Integer)
    query_count = db.Column(db.Integer)
    last_seen = db.Column(db.DateTime)
    confirmed = db.Column(db.SmallInteger) # use this instead of db.Boolean... otherwise there is an error in db.migrade

    followed = db.relationship('User', 
                           secondary=followers, 
                           primaryjoin=(followers.c.follower_id == id), 
                           secondaryjoin=(followers.c.followed_id == id), 
                           backref=db.backref('followers', lazy='dynamic'), 
                           lazy='dynamic')
    user_queries = db.relationship('Queries', backref='user')
    reading_list = db.relationship('Papers', 
                               secondary="join(Papers, ReadingList,     Papers.arxiv_id == ReadingList.arxiv_id)",
                               primaryjoin="and_(User.id ==     ReadingList.user_id)")
    group_leader = db.relationship('Groups', backref='user')
    vote_list = db.relationship('Papers', 
                            secondary="join(Papers, VoteList, Papers.arxiv_id == VoteList.arxiv_id)",
                            primaryjoin="and_(User.id == VoteList.user_id)")
    group_memberships = db.relationship('Groups',
                                    secondary="join(Members, Groups, Members.group_id == Groups.id)",
                                    primaryjoin="and_(User.id == Members.user_id)") 

and my attempt to delete is

>>> groups = models.Groups.query.all()
>>> groups
[<Groups 1>, <Groups 2>]
>>> db.session.delete(groups[1])
>>> db.session.commit()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/lib/python2.7/site-packages/sqlalchemy/orm/scoping.py", line 150, in do
    return getattr(self.registry(), name)(*args, **kwargs)
  File "/usr/local/lib/python2.7/site-packages/sqlalchemy/orm/session.py", line 790, in commit
    self.transaction.commit()
  File "/usr/local/lib/python2.7/site-packages/sqlalchemy/orm/session.py", line 392, in commit
    self._prepare_impl()
  File "/usr/local/lib/python2.7/site-packages/sqlalchemy/orm/session.py", line 372, in _prepare_impl
    self.session.flush()
  File "/usr/local/lib/python2.7/site-packages/sqlalchemy/orm/session.py", line 2004, in flush
    self._flush(objects)
  File "/usr/local/lib/python2.7/site-packages/sqlalchemy/orm/session.py", line 2122, in _flush
    transaction.rollback(_capture_exception=True)
  File "/usr/local/lib/python2.7/site-packages/sqlalchemy/util/langhelpers.py", line 60, in __exit__
    compat.reraise(exc_type, exc_value, exc_tb)
  File "/usr/local/lib/python2.7/site-packages/sqlalchemy/orm/session.py", line 2086, in _flush
    flush_context.execute()
  File "/usr/local/lib/python2.7/site-packages/sqlalchemy/orm/unitofwork.py", line 373, in execute
    rec.execute(self)
  File "/usr/local/lib/python2.7/site-packages/sqlalchemy/orm/unitofwork.py", line 485, in execute
    self.dependency_processor.process_deletes(uow, states)
  File "/usr/local/lib/python2.7/site-packages/sqlalchemy/orm/dependency.py", line 1023, in process_deletes
    secondary_update, secondary_delete)
  File "/usr/local/lib/python2.7/site-packages/sqlalchemy/orm/dependency.py", line 1098, in _run_crud
    statement = self.secondary.delete(sql.and_(*[
AttributeError: 'Join' object has no attribute 'delete'

any ideas what is going on here? carl

Answer 1

By reading the error code, it seems like SQL-Alchemy is also trying to delete the rows in other tables that are referenced by Group . However, because the reference seems to return a join, which doesn't have a delete function because the rows in a join aren't rows in a table but a combination of rows of different tables, an error is raised.

I couldn't find you a solution to your error because I couldn't replicate it because I didn't know the models of the other tables used in the relationships. If you add the models for Papers , VoteList , Members and User I would have a better chance of finding a solution.

As a side note: What relationships do you want to achieve exactly? A join like this is quite advanced and most of the time there is an easier way of achieving the desired result. In the case of Group.members , wouldn't it be best to have a foreignkey relationship from Member to User and from Member tot Group , the latter with a backref ( docs & api )? You could then use code similar to this to get all the members:

# somegroup = Group()
users = [member.user for member in somegroup.member]

EDIT : Judging by your models, it seems like you want a many-to-many relationship ( tutorial ) for Groups.members .