DBIx::Class::Ordered man page on MacOSX

Man page or keyword search:  
man Server   23457 pages
apropos Keyword Search (all sections)
Output format
MacOSX logo
[printable version]

DBIx::Class::Ordered(3User Contributed Perl DocumentatiDBIx::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.

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.16.2			  2012-10-18	       DBIx::Class::Ordered(3)
[top]

List of man pages available for MacOSX

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net