SQLAlchemy 0.7 Documentation

Release: 0.7.6 | Release Date: March 14, 2012
SQLAlchemy 0.7 Documentation » SQLAlchemy ORM » ORM Extensions » Ordering List

Ordering List

Ordering List

A custom list that manages index/position information for its children.

author:Jason Kirtland

orderinglist is a helper for mutable ordered relationships. It will intercept list operations performed on a relationship collection and automatically synchronize changes in list position with an attribute on the related objects. (See advdatamapping_entitycollections for more information on the general pattern.)

Example: Two tables that store slides in a presentation. Each slide has a number of bullet points, displayed in order by the ‘position’ column on the bullets table. These bullets can be inserted and re-ordered by your end users, and you need to update the ‘position’ column of all affected rows when changes are made.

slides_table = Table('Slides', metadata,
                     Column('id', Integer, primary_key=True),
                     Column('name', String))

bullets_table = Table('Bullets', metadata,
                      Column('id', Integer, primary_key=True),
                      Column('slide_id', Integer, ForeignKey('Slides.id')),
                      Column('position', Integer),
                      Column('text', String))

 class Slide(object):
     pass
 class Bullet(object):
     pass

 mapper(Slide, slides_table, properties={
       'bullets': relationship(Bullet, order_by=[bullets_table.c.position])
 })
 mapper(Bullet, bullets_table)

The standard relationship mapping will produce a list-like attribute on each Slide containing all related Bullets, but coping with changes in ordering is totally your responsibility. If you insert a Bullet into that list, there is no magic- it won’t have a position attribute unless you assign it it one, and you’ll need to manually renumber all the subsequent Bullets in the list to accommodate the insert.

An orderinglist can automate this and manage the ‘position’ attribute on all related bullets for you.

mapper(Slide, slides_table, properties={
       'bullets': relationship(Bullet,
                           collection_class=ordering_list('position'),
                           order_by=[bullets_table.c.position])
})
mapper(Bullet, bullets_table)

s = Slide()
s.bullets.append(Bullet())
s.bullets.append(Bullet())
s.bullets[1].position
>>> 1
s.bullets.insert(1, Bullet())
s.bullets[2].position
>>> 2

Use the ordering_list function to set up the collection_class on relationships (as in the mapper example above). This implementation depends on the list starting in the proper order, so be SURE to put an order_by on your relationship.

Warning

ordering_list only provides limited functionality when a primary key column or unique column is the target of the sort. Since changing the order of entries often means that two rows must trade values, this is not possible when the value is constrained by a primary key or unique constraint, since one of the rows would temporarily have to point to a third available value so that the other row could take its old value. ordering_list doesn’t do any of this for you, nor does SQLAlchemy itself.

ordering_list takes the name of the related object’s ordering attribute as an argument. By default, the zero-based integer index of the object’s position in the ordering_list is synchronized with the ordering attribute: index 0 will get position 0, index 1 position 1, etc. To start numbering at 1 or some other integer, provide count_from=1.

Ordering values are not limited to incrementing integers. Almost any scheme can implemented by supplying a custom ordering_func that maps a Python list index to any value you require.

API Reference

sqlalchemy.ext.orderinglist.ordering_list(attr, count_from=None, **kw)

Prepares an OrderingList factory for use in mapper definitions.

Returns an object suitable for use as an argument to a Mapper relationship’s collection_class option. Arguments are:

attr
Name of the mapped attribute to use for storage and retrieval of ordering information
count_from (optional)
Set up an integer-based ordering, starting at count_from. For example, ordering_list('pos', count_from=1) would create a 1-based list in SQL, storing the value in the ‘pos’ column. Ignored if ordering_func is supplied.

Passes along any keyword arguments to OrderingList constructor.

sqlalchemy.ext.orderinglist.count_from_0(index, collection)

Numbering function: consecutive integers starting at 0.

sqlalchemy.ext.orderinglist.count_from_1(index, collection)

Numbering function: consecutive integers starting at 1.

sqlalchemy.ext.orderinglist.count_from_n_factory(start)

Numbering function: consecutive integers starting at arbitrary start.

class sqlalchemy.ext.orderinglist.OrderingList(ordering_attr=None, ordering_func=None, reorder_on_append=False)

A custom list that manages position information for its children.

See the module and __init__ documentation for more details. The ordering_list factory function is used to configure OrderingList collections in mapper relationship definitions.

__init__(ordering_attr=None, ordering_func=None, reorder_on_append=False)

A custom list that manages position information for its children.

OrderingList is a collection_class list implementation that syncs position in a Python list with a position attribute on the mapped objects.

This implementation relies on the list starting in the proper order, so be sure to put an order_by on your relationship.

Parameters:
  • ordering_attr – Name of the attribute that stores the object’s order in the relationship.
  • ordering_func

    Optional. A function that maps the position in the Python list to a value to store in the ordering_attr. Values returned are usually (but need not be!) integers.

    An ordering_func is called with two positional parameters: the index of the element in the list, and the list itself.

    If omitted, Python list indexes are used for the attribute values. Two basic pre-built numbering functions are provided in this module: count_from_0 and count_from_1. For more exotic examples like stepped numbering, alphabetical and Fibonacci numbering, see the unit tests.

  • reorder_on_append

    Default False. When appending an object with an existing (non-None) ordering value, that value will be left untouched unless reorder_on_append is true. This is an optimization to avoid a variety of dangerous unexpected database writes.

    SQLAlchemy will add instances to the list via append() when your object loads. If for some reason the result set from the database skips a step in the ordering (say, row ‘1’ is missing but you get ‘2’, ‘3’, and ‘4’), reorder_on_append=True would immediately renumber the items to ‘1’, ‘2’, ‘3’. If you have multiple sessions making changes, any of whom happen to load this collection even in passing, all of the sessions would try to “clean up” the numbering in their commits, possibly causing all but one to fail with a concurrent modification error. Spooky action at a distance.

    Recommend leaving this with the default of False, and just call reorder() if you’re doing append() operations with previously ordered instances or when doing some housekeeping after manual sql operations.

append(entity)

L.append(object) – append object to end

insert(index, entity)

L.insert(index, object) – insert object before index

pop([index]) → item -- remove and return item at index (default last).

Raises IndexError if list is empty or index is out of range.

remove(entity)

L.remove(value) – remove first occurrence of value. Raises ValueError if the value is not present.

reorder()

Synchronize ordering for the entire collection.

Sweeps through the list and ensures that each object has accurate ordering information set.