Instrumentedlist sqlalchemy relationship

The Flask Mega-Tutorial Part VIII: Followers -

String()) documents = corrosion-corrintel.infoonship('Documents', When I try I get an "AttributeError: 'InstrumentedList' object has no attribute. This page provides Python code examples for corrosion-corrintel.infotions. InstrumentedList): out = "" for x in value: if x is None: continue if hasattr(x, .: param str relationship_field: the model attribute used for relationship:param str. AttributeError: 'InstrumentedList' object has no attribute 'order_by' http://www. or just wait .

While it may not seem obvious at first, the association table with its two foreign keys is able to efficiently answer all the queries about the relationship. Many-to-One and One-to-One A many-to-one is similar to a one-to-many relationship.

The difference is that this relationship is looked at from the "many" side. A one-to-one relationship is a special case of a one-to-many.

The representation is similar, but a constraint is added to the database to prevent the "many" side to have more than one link. While there are cases in which this type of relationship is useful, it isn't as common as the other types.

Representing Followers Looking at the summary of all the relationship types, it is easy to determine that the proper data model to track followers is the many-to-many relationship, because a user follows many users, and a user has many followers.

But there is a twist. In the students and teachers example I had two entities that were related through the many-to-many relationship. But in the case of followers, I have users following other users, so there is just users.

So what is the second entity of the many-to-many relationship? The second entity of the relationship is also the users. A relationship in which instances of a class are linked to other instances of the same class is called a self-referential relationship, and that is exactly what I have here.

Here is a diagram of the self-referential many-to-many relationship that keeps track of followers: The followers table is the association table of the relationship.

The foreign keys in this table are both pointing at entries in the user table, since it is linking users to users. Each record in this table represents one link between a follower user and a followed user.

Like the students and teachers example, a setup like this one allows the database to answer all the questions about followed and follower users that I will ever need. Database Model Representation Let's add followers to the database first. Here is the followers association table: Note that I am not declaring this table as a model, like I did for the users and posts tables.

Since this is an auxiliary table that has no data other than the foreign keys, I created it without an associated model class. Now I can declare the many-to-many relationship in the users table: Many-to-many followers relationship class User UserMixin, db. Like I did for the posts one-to-many relationship, I'm using the db. This relationship links User instances to other User instances, so as a convention let's say that for a pair of users linked by this relationship, the left side user is following the right side user.

I'm defining the relationship as seen from the left side user with the name followed, because when I query this relationship from the left side I will get the list of followed users i. Let's examine all the arguments to the db. Since this is a self-referential relationship, I have to use the same class on both sides.

From the left side, the relationship is named followed, so from the right side I am going to use the name followers to represent all the left side users that are linked to the target user in the right side.

The additional lazy argument indicates the execution mode for this query. A mode of dynamic sets up the query to not run until specifically requested, which is also how I set up the posts one-to-many relationship.

python - sqlalchemy: 'InstrumentedList' object has no attribute 'filter' - Stack Overflow

Don't worry if this is hard to understand. I will show you how to work with these queries in a moment, and then everything will become clearer. The changes to the database need to be recorded in a new database migration: For example, if I had two users stored in user1 and user2 variables, I can make the first follow the second with this simple statement: Instead, I'm going to implement the "follow" and "unfollow" functionality as methods in the User model.

It is always best to move the application logic away from view functions and into models or other auxiliary classes or modules, because as you will see later in this chapter, that makes unit testing much easier. Below are the changes in the user model to add and remove relationships: Add and remove followers class User UserMixin, db. For example, if I ask user1 to follow user2, but it turns out that this following relationship already exists in the database, I do not want to add a duplicate.

The same logic can be applied to unfollowing. The query is terminated with a count method, which returns the number of results. The result of this query is going to be 0 or 1, so checking for the count being 1 or greater than 0 is actually equivalent.

Other query terminators you have seen me use in the past are all and first. Obtaining the Posts from Followed Users Support for followers in the database is almost complete, but I'm actually missing one important feature. It produces a dictionary class that will apply a particular attribute of the mapped class as a key.

Below we map an Item class containing a dictionary of Note items keyed to the Note. Such as, when assigning to Item. Note 'a', 'atext''b': Using a regular Python property allows virtually any detail or combination of details about the object to be used as the key, as below when we establish it as a tuple of Note. Assigning to this reverse relationship, the Note is added to the Item.

The New Flask Mega-Tutorial

The key value must be immutable for the lifetime of the object. You can not, for example, map on foreign key values if those key values will change during the session, i. Returns a MappedCollection factory with a keying function generated from keyfunc, a callable that takes an entity and returns a key value.

In other cases, special decorators are needed to tell SQLAlchemy more detail about how the collection operates. Do I need a custom collection implementation?

In most cases not at all! For the first use case, the orm. See Simple Validators for an example of this. This approach leaves the underlying mapped collection unaffected and avoids the need to carefully tailor collection behavior on a method-by-method basis. They can of course be combined with the above two approaches.

Collections in SQLAlchemy are transparently instrumented. Instrumentation means that normal operations on the collection are tracked and result in changes being written to the database at flush time. Additionally, collection operations can fire events which indicate some secondary operation must take place. The collections package understands the basic interface of lists, sets and dicts and will automatically apply instrumentation to those built-in types and their subclasses.

Object-derived types that implement a basic collection interface are detected and instrumented via duck-typing: The ORM needs to know which methods to use to append, remove and iterate over members of the collection.

When using a type like list or set, the appropriate methods are well-known and used automatically when present. This set-like class does not provide the expected add method, so we must supply an explicit mapping for the ORM via a decorator.

SQLAlchemy will add instances via the append method.

SQLAlchemy ORM for Beginners

Default methods can be changed as well: There is no requirement to be list- or set-like at all. Append and remove methods will be called with a mapped entity as the single argument, and iterator methods are called with no arguments and must return an iterator.

The decorators fall into two groups: They are not written with parens: