/opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext
Edit: /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyc (16319B)
ó
ÃÌ4]c @ s’ d Z d d l m Z d d l m Z d d l m Z d g Z d d „ Z d „ Z d „ Z
d „ Z d
„ Z d e
f d „ ƒ YZ d
„ Z d S( s½ A custom list that manages index/position information for contained
elements.
:author: Jason Kirtland
``orderinglist`` is a helper for mutable ordered relationships. It will
intercept list operations performed on a :func:`.relationship`-managed
collection and
automatically synchronize changes in list position onto a target scalar
attribute.
Example: A ``slide`` table, where each row refers to zero or more entries
in a related ``bullet`` table. The bullets within a slide are
displayed in order based on the value of the ``position`` column in the
``bullet`` table. As entries are reordered in memory, the value of the
``position`` attribute should be updated to reflect the new sort order::
Base = declarative_base()
class Slide(Base):
__tablename__ = 'slide'
id = Column(Integer, primary_key=True)
name = Column(String)
bullets = relationship("Bullet", order_by="Bullet.position")
class Bullet(Base):
__tablename__ = 'bullet'
id = Column(Integer, primary_key=True)
slide_id = Column(Integer, ForeignKey('slide.id'))
position = Column(Integer)
text = Column(String)
The standard relationship mapping will produce a list-like attribute on each
``Slide`` containing all related ``Bullet`` objects,
but coping with changes in ordering is not handled automatically.
When appending a ``Bullet`` into ``Slide.bullets``, the ``Bullet.position``
attribute will remain unset until manually assigned. When the ``Bullet``
is inserted into the middle of the list, the following ``Bullet`` objects
will also need to be renumbered.
The :class:`.OrderingList` object automates this task, managing the
``position`` attribute on all ``Bullet`` objects in the collection. It is
constructed using the :func:`.ordering_list` factory::
from sqlalchemy.ext.orderinglist import ordering_list
Base = declarative_base()
class Slide(Base):
__tablename__ = 'slide'
id = Column(Integer, primary_key=True)
name = Column(String)
bullets = relationship("Bullet", order_by="Bullet.position",
collection_class=ordering_list('position'))
class Bullet(Base):
__tablename__ = 'bullet'
id = Column(Integer, primary_key=True)
slide_id = Column(Integer, ForeignKey('slide.id'))
position = Column(Integer)
text = Column(String)
With the above mapping the ``Bullet.position`` attribute is managed::
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
The :class:`.OrderingList` construct only works with **changes** to a
collection, and not the initial load from the database, and requires that the
list be sorted when loaded. Therefore, be sure to specify ``order_by`` on the
:func:`.relationship` against the target ordering attribute, so that the
ordering is correct when first loaded.
.. warning::
:class:`.OrderingList` only provides limited functionality when a primary
key column or unique column is the target of the sort. Operations
that are unsupported or are problematic include:
* two entries must trade values. This is not supported directly in the
case of a primary key or unique constraint because it means at least
one row would need to be temporarily removed first, or changed to
a third, neutral value while the switch occurs.
* an entry must be deleted in order to make room for a new entry.
SQLAlchemy's unit of work performs all INSERTs before DELETEs within a
single flush. In the case of a primary key, it will trade
an INSERT/DELETE of the same primary key for an UPDATE statement in order
to lessen the impact of this limitation, however this does not take place
for a UNIQUE column.
A future feature will allow the "DELETE before INSERT" behavior to be
possible, alleviating this limitation, though this feature will require
explicit configuration at the mapper level for sets of columns that
are to be handled in this way.
:func:`.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 :func:`.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``.
i ( t util( t
collection( t collection_adaptert
ordering_listc s" t d | ˆ ‰ ‡ ‡ f d † S( s Prepares an :class:`OrderingList` factory for use in mapper definitions.
Returns an object suitable for use as an argument to a Mapper
relationship's ``collection_class`` option. e.g.::
from sqlalchemy.ext.orderinglist import ordering_list
class Slide(Base):
__tablename__ = 'slide'
id = Column(Integer, primary_key=True)
name = Column(String)
bullets = relationship("Bullet", order_by="Bullet.position",
collection_class=ordering_list('position'))
:param attr:
Name of the mapped attribute to use for storage and retrieval of
ordering information
:param count_from:
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.
Additional arguments are passed to the :class:`.OrderingList` constructor.
t
count_fromc s
t ˆ ˆ S( N( t OrderingList( ( t attrt kw( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyt
¢ t ( t _unsugar_count_from( R R R ( ( R R sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyR ‚ s c C s | S( s7 Numbering function: consecutive integers starting at 0.( ( t indexR ( ( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyt count_from_0¨ s c C s | d S( s7 Numbering function: consecutive integers starting at 1.i ( ( R R ( ( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyt count_from_1® s c s8 ‡ f d † } y d ˆ | _ Wn t k
r3 n X| S( sE Numbering function: consecutive integers starting at arbitrary start.c s | ˆ S( N( ( R R ( t start( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyt f· s s
count_from_%i( t __name__t TypeError( R R ( ( R sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyt count_from_n_factory´ s
c K s | j d d ƒ } | j d d ƒ d k r{ | d k r{ | d k rO t | d | j r> | j ƒ n d S( N( R' R t removeR t _referenced_by_ownerR, ( R R t adapter( ( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyR- E s iÿÿÿÿc C s& t t | ƒ j | ƒ } | j ƒ | S( N( R' R R R, ( R R R ( ( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyR L s
c C sä t | t ƒ r´ | j p d } | j p* d } | d k rL | t | ƒ 7} n | j p^ t | ƒ } | d k r€ | t | ƒ 7} n x] t | | | ƒ D] } | j | | | ƒ q“ Wn, | j | | t ƒ t
t | ƒ j | | ƒ d S( Ni i ( t
isinstancet slicet stepR R) t stopt ranget __setitem__R" R# R' R ( R R R R2 R R3 t i( ( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyR5 Q s c C s$ t t | ƒ j | ƒ | j ƒ d S( N( R' R t __delitem__R, ( R R ( ( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyR7 a s c C s* t t | ƒ j | | | ƒ | j ƒ d S( N( R' R t __setslice__R, ( R R t endt values( ( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyR8 e s c C s' t t | ƒ j | | ƒ | j ƒ d S( N( R' R t __delslice__R, ( R R R9 ( ( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyR; i s c C s t | j | j t | ƒ f f S( N( t
_reconstitutet __class__t __dict__t list( R ( ( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyt
__reduce__m s N(! R t
__module__t __doc__R t FalseR R R R$ R, R# R" R( R* R t addsR+ R- R R5 R7 R8 R; R@ R? t localst itemst func_namet funcR t callablet hasattrR ( ( ( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyR Ó s2 ; "
c C s3 | j | ƒ } | j j | ƒ t j | | ƒ | S( s« Reconstitute an :class:`.OrderingList`.
This is the adjoint to :meth:`.OrderingList.__reduce__`. It is used for
unpickling :class:`.OrderingList` objects.
( t __new__R> t updateR? t extend( t clst dict_RF t obj( ( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyR< { s N( RB R R t orm.collectionsR R t __all__R R R R
R R
R? R R< ( ( ( sN /opt/alt/python27/lib64/python2.7/site-packages/sqlalchemy/ext/orderinglist.pyt y s &
¨