Страницы справочника OS X

Эта страница руководства для  версии 10.9 Mac OS X

Читать страницы руководства

DBIx::Class::Ordered(3)              User Contributed Perl Documentation             DBIx::Class::Ordered(3)



NAME
       DBIx::Class::Ordered - Modify the position of objects in an ordered list.

SYNOPSIS
       Create a table for your ordered data.

         CREATE TABLE items (
           item_id INTEGER PRIMARY KEY AUTOINCREMENT,
           name TEXT NOT NULL,
           position INTEGER NOT NULL
         );

       Optionally, add one or more columns to specify groupings, allowing you to maintain independent
       ordered lists within one table:

         CREATE TABLE items (
           item_id INTEGER PRIMARY KEY AUTOINCREMENT,
           name TEXT NOT NULL,
           position INTEGER NOT NULL,
           group_id INTEGER NOT NULL
         );

       Or even

         CREATE TABLE items (
           item_id INTEGER PRIMARY KEY AUTOINCREMENT,
           name TEXT NOT NULL,
           position INTEGER NOT NULL,
           group_id INTEGER NOT NULL,
           other_group_id INTEGER NOT NULL
         );

       In your Schema or DB class add "Ordered" to the top of the component list.

         __PACKAGE__->load_components(qw( Ordered ... ));

       Specify the column that stores the position number for each row.

         package My::Item;
         __PACKAGE__->position_column('position');

       If you are using one grouping column, specify it as follows:

         __PACKAGE__->grouping_column('group_id');

       Or if you have multiple grouping columns:

         __PACKAGE__->grouping_column(['group_id', 'other_group_id']);

       That's it, now you can change the position of your objects.

         #!/use/bin/perl
         use My::Item;

         my $item = My::Item->create({ name=>'Matt S. Trout' });
         # If using grouping_column:
         my $item = My::Item->create({ name=>'Matt S. Trout', group_id=>1 });

         my $rs = $item->siblings();
         my @siblings = $item->siblings();

         my $sibling;
         $sibling = $item->first_sibling();
         $sibling = $item->last_sibling();
         $sibling = $item->previous_sibling();
         $sibling = $item->next_sibling();

         $item->move_previous();
         $item->move_next();
         $item->move_first();
         $item->move_last();
         $item->move_to( $position );
         $item->move_to_group( 'groupname' );
         $item->move_to_group( 'groupname', $position );
         $item->move_to_group( {group_id=>'groupname', 'other_group_id=>'othergroupname'} );
         $item->move_to_group( {group_id=>'groupname', 'other_group_id=>'othergroupname'}, $position );

DESCRIPTION
       This module provides a simple interface for modifying the ordered position of DBIx::Class objects.

AUTO UPDATE
       All of the move_* methods automatically update the rows involved in the query.  This is not
       configurable and is due to the fact that if you move a record it always causes other records in the
       list to be updated.

METHODS
   position_column
         __PACKAGE__->position_column('position');

       Sets and retrieves the name of the column that stores the positional value of each record.  Defaults
       to "position".

   grouping_column
         __PACKAGE__->grouping_column('group_id');

       This method specifies a column to limit all queries in this module by.  This effectively allows you
       to have multiple ordered lists within the same table.

   null_position_value
         __PACKAGE__->null_position_value(undef);

       This method specifies a value of "position_column" which would never be assigned to a row during
       normal operation. When a row is moved, its position is set to this value temporarily, so that any
       unique constraints can not be violated. This value defaults to 0, which should work for all cases
       except when your positions do indeed start from 0.

   siblings
         my $rs = $item->siblings();
         my @siblings = $item->siblings();

       Returns an ordered resultset of all other objects in the same group excluding the one you called it
       on.

       The ordering is a backwards-compatibility artifact - if you need a resultset with no ordering applied
       use "_siblings"

   previous_siblings
         my $prev_rs = $item->previous_siblings();
         my @prev_siblings = $item->previous_siblings();

       Returns a resultset of all objects in the same group positioned before the object on which this
       method was called.

   next_siblings
         my $next_rs = $item->next_siblings();
         my @next_siblings = $item->next_siblings();

       Returns a resultset of all objects in the same group positioned after the object on which this method
       was called.

   previous_sibling
         my $sibling = $item->previous_sibling();

       Returns the sibling that resides one position back.  Returns 0 if the current object is the first
       one.

   first_sibling
         my $sibling = $item->first_sibling();

       Returns the first sibling object, or 0 if the first sibling is this sibling.

   next_sibling
         my $sibling = $item->next_sibling();

       Returns the sibling that resides one position forward. Returns 0 if the current object is the last
       one.

   last_sibling
         my $sibling = $item->last_sibling();

       Returns the last sibling, or 0 if the last sibling is this sibling.

   move_previous
         $item->move_previous();

       Swaps position with the sibling in the position previous in the list.  Returns 1 on success, and 0 if
       the object is already the first one.

   move_next
         $item->move_next();

       Swaps position with the sibling in the next position in the list.  Returns 1 on success, and 0 if the
       object is already the last in the list.

   move_first
         $item->move_first();

       Moves the object to the first position in the list.  Returns 1 on success, and 0 if the object is
       already the first.

   move_last
         $item->move_last();

       Moves the object to the last position in the list.  Returns 1 on success, and 0 if the object is
       already the last one.

   move_to
         $item->move_to( $position );

       Moves the object to the specified position.  Returns 1 on success, and 0 if the object is already at
       the specified position.

   move_to_group
         $item->move_to_group( $group, $position );

       Moves the object to the specified position of the specified group, or to the end of the group if
       $position is undef.  1 is returned on success, and 0 is returned if the object is already at the
       specified position of the specified group.

       $group may be specified as a single scalar if only one grouping column is in use, or as a hashref of
       column => value pairs if multiple grouping columns are in use.

   insert
       Overrides the DBIC insert() method by providing a default position number.  The default will be the
       number of rows in the table +1, thus positioning the new record at the last position.

   update
       Overrides the DBIC update() method by checking for a change to the position and/or group columns.
       Movement within a group or to another group is handled by repositioning the appropriate siblings.
       Position defaults to the end of a new group if it has been changed to undef.

   delete
       Overrides the DBIC delete() method by first moving the object to the last position, then deleting it,
       thus ensuring the integrity of the positions.

METHODS FOR EXTENDING ORDERED
       You would want to override the methods below if you use sparse (non-linear) or non-numeric position
       values. This can be useful if you are working with preexisting non-normalised position data, or if
       you need to work with materialized path columns.

   _position_from_value
         my $num_pos = $item->_position_from_value ( $pos_value )

       Returns the absolute numeric position of an object with a position value set to $pos_value. By
       default simply returns $pos_value.

   _position_value
         my $pos_value = $item->_position_value ( $pos )

       Returns the value of "position_column" of the object at numeric position $pos. By default simply
       returns $pos.

   _initial_position_value
         __PACKAGE__->_initial_position_value(0);

       This method specifies a value of "position_column" which is assigned to the first inserted element of
       a group, if no value was supplied at insertion time. All subsequent values are derived from this one
       by "_next_position_value" below. Defaults to 1.

   _next_position_value
         my $new_value = $item->_next_position_value ( $position_value )

       Returns a position value that would be considered "next" with regards to $position_value. Can be
       pretty much anything, given that "$position_value < $new_value" where "<" is the SQL comparison
       operator (usually works fine on strings). The default method expects $position_value to be numeric,
       and returns "$position_value + 1"

   _shift_siblings
         $item->_shift_siblings ($direction, @between)

       Shifts all siblings with positions values in the range @between (inclusive) by one position as
       specified by $direction (left if < 0,
        right if > 0). By default simply increments/decrements each "position_column" value by 1, doing so
       in a way as to not violate any existing constraints.

       Note that if you override this method and have unique constraints including the "position_column" the
       shift is not a trivial task.  Refer to the implementation source of the default method for more
       information.

PRIVATE METHODS
       These methods are used internally.  You should never have the need to use them.

   _group_rs
       This method returns a resultset containing all members of the row group (including the row itself).

   _siblings
       Returns an unordered resultset of all objects in the same group excluding the object you called this
       method on.

   _position
         my $num_pos = $item->_position;

       Returns the absolute numeric position of the current object, with the first object being at position
       1, its sibling at position 2 and so on.

   _grouping_clause
       This method returns one or more name=>value pairs for limiting a search by the grouping column(s).
       If the grouping column is not defined then this will return an empty list.

   _get_grouping_columns
       Returns a list of the column names used for grouping, regardless of whether they were specified as an
       arrayref or a single string, and returns () if there is no grouping.

   _is_in_group
           $item->_is_in_group( {user => 'fred', list => 'work'} )

       Returns true if the object is in the group represented by hashref $other

   _ordered_internal_update
       This is a short-circuited method, that is used internally by this module to update positioning values
       in isolation (i.e. without triggering any of the positioning integrity code).

       Some day you might get confronted by datasets that have ambiguous positioning data (e.g. duplicate
       position values within the same group, in a table without unique constraints). When manually fixing
       such data keep in mind that you can not invoke "update" in DBIx::Class::Row like you normally would,
       as it will get confused by the wrong data before having a chance to update the ill-defined row. If
       you really know what you are doing use this method which bypasses any hooks introduced by this
       module.

CAVEATS
   Resultset Methods
       Note that all Insert/Create/Delete overrides are happening on DBIx::Class::Row methods only. If you
       use the DBIx::Class::ResultSet versions of update or delete, all logic present in this module will be
       bypassed entirely (possibly resulting in a broken order-tree). Instead always use the update_all and
       delete_all methods, which will invoke the corresponding row method on every member of the given
       resultset.

   Race Condition on Insert
       If a position is not specified for an insert, a position will be chosen based either on
       "_initial_position_value" or "_next_position_value", depending if there are already some items in the
       current group. The space of time between the necessary selects and insert introduces a race
       condition.  Having unique constraints on your position/group columns, and using transactions (see
       "txn_do" in DBIx::Class::Storage) will prevent such race conditions going undetected.

   Multiple Moves
       Be careful when issuing move_* methods to multiple objects.  If you've pre-loaded the objects then
       when you move one of the objects the position of the other object will not reflect their new value
       until you reload them from the database - see "discard_changes" in DBIx::Class::Row.

       There are times when you will want to move objects as groups, such as changing the parent of several
       objects at once - this directly conflicts with this problem.  One solution is for us to write a
       ResultSet class that supports a parent() method, for example.  Another solution is to somehow
       automagically modify the objects that exist in the current object's result set to have the new
       position value.

   Default Values
       Using a database defined default_value on one of your group columns could result in the position not
       being assigned correctly.

AUTHOR
        Original code framework
          Aran Deltac <bluefeet@cpan.org>

        Constraints support and code generalisation
          Peter Rabbitson <ribasushi@cpan.org>

LICENSE
       You may distribute this code under the same terms as Perl itself.



perl v5.12.5                                     2011-07-27                          DBIx::Class::Ordered(3)