Flask-appbuilder many-to-may relationship sqlalchemy.exc.NoReferencedTableError Error - python-2.7

I've read through all of these (https://stackoverflow.com/search?q=sqlalchemy.exc.NoReferencedTableError%3A), the Flask-appbuilder docs, the sqlalchemy docs, and the Flask-sqlalchemy docs and more. Unfortunately, I can't find any full examples of a many-to-many sqlalchemy relationship.
I have a python Flask app using flask-appbuilder (which relies on flask-sqlalchemy). My app/model.py file has this:
field_feature_association = Table('field_feature_association',Base.metadata,
Column('field_id', Integer, ForeignKey('field.id')),
Column('feature_id',Integer, ForeignKey('feature.id')),
schema="main"
)
class field(Model):
__tablename__ = 'field'
id = Column(Integer, primary_key=True)
name = Column(String(70), nullable=False)
database_type = Column(String(70)) #varchar(255), text, int
joinable_to = Column(Text())
notes = Column(Text()) #don't use this for X
table_id = Column(Integer, ForeignKey('table.id'))
table = relationship("table")
features = relationship("feature",
secondary = field_feature_association,
backref = backref('fields'),
)
def __repr__(self):
return self.name
class feature(Model):
__tablename__ = 'feature'
id = Column(Integer, primary_key=True)
name = Column(String(70), unique = True, nullable=False)
field_id = Column(Integer, ForeignKey('field.id'))
#field = relationship("field")
def __repr__(self):
return self.name
It's generating this error:
sqlalchemy.exc.NoReferencedTableError: Foreign key associated with column 'field_feature_association.feature_id' could not find table 'feature' with which to generate a foreign key to target column 'id'
Thoughts on how to fix this error?

Here is a working sample of many-to-many in SQLAlchemy. Moreover I modified your model and it works fine:
field_feature_association = db.Table('field_feature_association', db.Model.metadata,
db.Column('field_id', db.Integer, db.ForeignKey('field.id')),
db.Column('feature_id', db.Integer, db.ForeignKey('feature.id')),
schema="main"
)
class Field(db.Model):
__tablename__ = 'field'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(70), nullable=False)
database_type = db.Column(db.String(70)) # varchar(255), text, int
joinable_to = db.Column(db.Text())
notes = db.Column(db.Text()) # don't use this for X
features = db.relationship("Feature",
secondary=field_feature_association,
backref=db.backref('fields'),
)
def __repr__(self):
return self.name
class Feature(db.Model):
__tablename__ = 'feature'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(70), unique=True, nullable=False)
field_id = db.Column(db.Integer, db.ForeignKey('field.id'))
# field = relationship("field")
def __repr__(self):
return self.name
and this is how to use it:
field = Field()
field.name="filed1"
feature = Feature()
feature.name = "feature1"
field.features.append(feature)
db.session.add(field)
db.session.commit()
My database object is imported as ’db’ and I have used it explicitely to refer to other types.

Related

ForeignKey serialized as empty dict and not getting populated with data

I've two models Profile & Product representing One-Many relationship. One profile can have many products. I'm serializing all the fields. The column which has ForeignKey is coming out to be empty dictionary. The following model will make my issue more clear.
from backend_olx import db
from marshmallow import Schema, fields
from datetime import datetime
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
created_by = db.Column(db.Integer, db.ForeignKey('profile.id'), nullable=False)
purchased_by = db.Column(db.Integer, db.ForeignKey('profile.id'), nullable=True)
name = db.Column(db.String(50), nullable=False)
price = db.Column(db.Integer, nullable=False)
description = db.Column(db.Text, nullable=False)
def __repr__(self):
return '<Product Name %r>' % self.name
class Profile(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(50), nullable=False, unique=True)
email = db.Column(db.String(100), nullable=False, unique=True)
products_sold = db.relationship('Product', backref='profile_sold', foreign_keys="Product.created_by",lazy=True)
products_purchased = db.relationship('Product', backref='profile_purchased', foreign_keys="Product.purchased_by",lazy=True)
def __repr__(self):
return '<User %r>' % self.username
class ProfileSchema(Schema):
id = fields.Int(dump_only=True)
username = fields.Str()
email = fields.Str()
products_sold = fields.Nested('ProductSchema', many=True)
products_purchased = fields.Nested('ProductSchema', many=True)
class ProductSchema(Schema):
id = fields.Int(dump_only=True)
name = fields.Str()
price = fields.Int()
created_by = fields.Nested('ProfileSchema')
purchased_by = fields.Nested('ProfileSchema')
profile_schema = ProfileSchema()
profiles_schema = ProfileSchema(many=True)
product_schema = ProductSchema()
products_schema = ProductSchema(many=True)
The Nested() method in ProfileSchema is working as expected but it is giving { } in ProductSchema.
I want created_by and purchased_by fields to be populated as well.
How to go about ths?
You can't just pass a foreign key and expect Nested to know what to do about it. You need to pass a relation instead.
Create a relation for both fields and use the relation name in the schema.
I typically use xxx_id for column name and xxx for relation name.
class Product(db.Model):
id = db.Column(db.Integer, primary_key=True)
created_by_id = db.Column(db.Integer, db.ForeignKey('profile.id'), nullable=False)
purchased_by_id = db.Column(db.Integer, db.ForeignKey('profile.id'), nullable=True)
name = db.Column(db.String(50), nullable=False)
price = db.Column(db.Integer, nullable=False)
description = db.Column(db.Text, nullable=False)
# Setup relations here
created_by = db.relationship(...)
purchased_by = db.relationship(...)
class ProductSchema(Schema):
id = fields.Int(dump_only=True)
name = fields.Str()
price = fields.Int()
created_by = fields.Nested('ProfileSchema')
purchased_by = fields.Nested('ProfileSchema')

sqlite3.IntegrityError: FOREIGN KEY constraint failed

I have an sqlite database in my flask server with three tables as seen below:
from database import db
class ChordNode(db.Model):
__tablename__ = 'chordnode'
id = db.Column(db.Integer, primary_key=True)
hashed_id = db.Column(db.String)
successor = db.Column(db.String)
predecessor = db.Column(db.String)
is_bootstrap = db.Column(db.Boolean, default=False)
storage = db.relationship("KeyValuePair")
node_map = db.relationship("NodeRecord", cascade="delete")
def __repr__(self):
return 'Chord node {}, with successor: {}, predecessor: {}, ' \
'bootstrap: {}'.format(self.hashed_id, self.successor,
self.predecessor, self.is_bootstrap)
class KeyValuePair(db.Model):
__tablename__ = 'keyvaluepair'
id = db.Column(db.Integer, primary_key=True)
chordnode_id = db.Column(db.String, db.ForeignKey('chordnode.hashed_id'), nullable=True)
hashed_id = db.Column(db.String)
value = db.Column(db.String)
def __repr__(self):
return '<key-value pair: {}:{}, responsible Chord node: {}'.format(self.hashed_id,
self.value, self.chordnode_id)
class NodeRecord(db.Model):
__tablename__ = 'noderecord'
id = db.Column(db.Integer, primary_key=True)
bootstrap_id = db.Column(db.Integer, db.ForeignKey('chordnode.id'), nullable=False)
ip_port = db.Column(db.String)
def __repr__(self):
return 'Node record {} on boo
tstrap node with id {}'.format(self.ip_port,
self.bootstrap_id)
When i insert into ChordNode class or Noderecord everything works fine but inserting a record into KeyValuePair produces this error:
sqlalchemy.exc.IntegrityError: (sqlite3.IntegrityError) FOREIGN KEY constraint failed
However KeyValuePair's foreign key is exactly the same as ChordNode's corresponding.
Any ideas about what else could be wrong with this and why this error occurs?

How to resolve this flask sqlalchemy error "sqlalchemy.exc.InvalidRequestError"?

from datetime import datetime
from pack import db,login_manager
from flask_login import UserMixin
# SQLALCHEMY_TRACK_MODIFICATIONS = False
#login_manager.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20), unique = True, nullable = False)
email = db.Column(db.String(150), unique = True, nullable = False)
password = db.Column(db.String(60), nullable = False)
profile_pic = db.Column(db.String(20), nullable = False, default = "default_profile_pic.jpg")
posts = db.relationship('Post', backref = 'author', lazy = True)
comments = db.relationship('Comment', backref = 'commentor', lazy = True)
def __repr__(self):
return f"User('{self.username}','{self.email}','{self.profile_pic}')"
class Post(db.Model,UserMixin):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(100), nullable = False)
date_posted = db.Column(db.DateTime, nullable = False, default = datetime.utcnow)
content = db.Column(db.Text, nullable = False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable = False)
post_comments = db.relationship('Comment', backref = 'commentor', lazy = 'dynamic')
def __repr__(self):
return f"Post('{self.title}','{self.content}','{self.date_posted}','{self.comments}')"
class Comment(db.Model):
id = db.Column(db.Integer, primary_key=True)
comment = db.Column(db.String(100000), nullable = False)
timestamp = db.Column(db.DateTime, nullable = False, default = datetime.utcnow, index = True)
user_comment_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable = False)
post_comment_id = db.Column(db.Integer, db.ForeignKey('post.id'))
def __repr__(self):
return f"Post('{self.comment}','{self.user_comment_id}','{self.post_comment_id}')"
This give this error:
sqlalchemy.exc.InvalidRequestError: One or more mappers failed to initialize - can't proceed with initialization of other mappers. Triggering mapper: 'mapped class Post->post'. Original exception was: Error creating backref 'commentor' on relationship 'Post.post_comments': property of that name exists on mapper 'mapped class Comment->comment'
Please help me resolve this error. I want to add a feature to comment on a post and for that i am trying to connect the Comment model with Post and User models.
In your error you have: Post.post_comments': property of that name exists on mapper 'mapped class Comment->comment.
It seems that in User you have comments which creates a backref 'commentor' in Comment and in Post you have post_comments which also creates a backref 'commentor' in Comment.
For example in Post, you can change post_comment to :
post_comments = db.relationship('Comment', backref = 'post_commented', lazy = 'dynamic')
Edit:
When defining a One to Many relationship with backref parameter, there is no need of user_id (in Post), user_comment_id (in Comment), post_comment_id (in Comment): Simply remove them.
You should have another look at https://docs.sqlalchemy.org/en/13/orm/basic_relationships.html#one-to-many (the backref part)

Flask SQLAlchemy custom field name for foreign key?

Relationship = Many Heros have one Planet.
I'd like to be able to call hero.home_planet because the Star Wars characters move around in space a lot. But under my model, the field is called planet_id.
Is there a way to set a custom name for a foreign key field?
Like a planet_id = db.Column( name ='home_planet')?
Could I just change the name of the table name to __tablename__ = 'home_planet'?
class Hero(db.Model):
__tablename__ = 'heroes'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
race = db.Column(db.String())
planet_id = db.Column(db.Integer, db.ForeignKey('planets.id'), nullable=True)
def __repr__(self):
return '<Hero %r>' % self.name
With flask_sqlalchemy:
class Planet(db.Model)
__tablename__ = 'planet'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100))
heros = db.relationship('Hero', backref='home_planet')
class Hero(db.Model):
__tablename__ = 'heroes'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String())
race = db.Column(db.String())
planet_id = db.Column(db.Integer, db.ForeignKey('planets.id'), nullable=True)
def __repr__(self):
return '<Hero %r>' % self.name
Now you can call your_hero.home_planet
It's worth going through the SQLAlchemy docs to learn about the huge number of options you can use here, but it sounds like a simple relationship() will work:
planet = relationship('Planet', backref='heroes')
You can now call my_hero.planet, or the reverse my_planet.heroes

Self-Referential Association Relationship SQLalchemy

In my flask application with flask-sqlalchemy i need to create association between two contact
here is my Contact model
class Contact(db.Model):
__tablename__ = 'contact'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(120), nullable=False, unique=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
to_contacts = db.relationship('Contact',
secondary='ContactRelation',
primaryjoin='id==contactrelation.c.from_contact_id',
secondaryjoin='id==contactrelation.c.to_contact_id',
backref='from_contacts')
and my association class ContactRelation:
class ContactRelation(db.Model):
__tablename__ = 'contactrelation'
id = db.Column(db.Integer, primary_key=True)
from_contact_id = db.Column(db.Integer, db.ForeignKey('contact.id'))
to_contact_id = db.Column(db.Integer, db.ForeignKey('contact.id'))
relation_type = db.Column(db.String(100), nullable=True)
i have error :
AttributeError: type object 'ContactRelation' has no attribute 'c'
Thanks to Michel and Simon on SQLAlchemy mailing list i need association_proxy and two relation to Contact relation.
class Contact(db.Model):
__tablename__ = 'contact'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Unicode(120), nullable=False, unique=False)
created_on = db.Column(db.DateTime, default=datetime.utcnow)
birthday = db.Column(db.DateTime)
background = db.Column(db.Text)
photo = db.Column(db.Unicode(120))
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
to_contacts = association_proxy('to_relations', 'to_contact')
from_contacts = association_proxy('from_relations', 'from_contact')
class ContactRelation(db.Model):
__tablename__ = 'contactrelation'
id = db.Column(db.Integer, primary_key=True)
from_contact_id = db.Column(db.Integer, db.ForeignKey('contact.id'))
to_contact_id = db.Column(db.Integer, db.ForeignKey('contact.id'))
relation_type = db.Column(db.String(100), nullable=True)
from_contact = db.relationship(Contact,
primaryjoin=(from_contact_id == Contact.id),
backref='to_relations')
to_contact = db.relationship(Contact,
primaryjoin=(to_contact_id == Contact.id),
backref='from_relations')
Self-referential many-to-many relationship with Association Object.
User Class:
class User(Base):
__tablename__ = "User"
id = Column(String(36), primary_key=True, default=lambda : str(uuid1()))
Association Class:
class UserIgnore(Base):
__tablename__ = "UserIgnore"
id = Column(String(36), primary_key=True, default=lambda : str(uuid1()))
ignored_by_id = Column("ignored_by_id", String(36), ForeignKey("User.id"), primary_key=True)
ignored_by = relationship("User", backref="ignored_list", primaryjoin=(User.id == ignored_by_id))
ignored_id = Column("ignored_id", String(36), ForeignKey("User.id"), primary_key=True)
ignored = relationship("User", backref="ignored_by_list", primaryjoin=(User.id == ignored_id))
Access the relationship objects with
someUser.ignored_list
or
someUser.ignored_by_list
Thanks to Sean
Your relationship is not correctly designed. A secondary should be an ordinary table, not a mapped class. If you want the extra data (relation_type) on your ContactRelation, you should use the Association Table pattern described in the SQLAlchemy Relationship docs: http://docs.sqlalchemy.org/en/rel_1_1/orm/basic_relationships.html#association-object
it seems that if you change the to_contacts to something like below, your problem will be solved:
to_contacts = db.relationship('Contact',
secondary='ContactRelation',
primaryjoin='id==contactrelation.from_contact_id',
secondaryjoin='id==contactrelation.to_contact_id',
backref='from_contacts')