view release on metacpan or  search on metacpan

lib/DBIO/Ordered.pm  view on Meta::CPAN

    if ($self->is_column_changed($_)) {
      $self->store_column($_, delete $self->{_column_data_in_storage}{$_});
      delete $self->{_dirty_columns}{$_};
    }
  }

  if ($self->_is_in_group($to_group)) {
    my $ret;
    if (defined $to_position) {
      $ret = $self->move_to($to_position);
    }
    return $ret || 0;
  }

  my $guard = $self->result_source->schema->txn_scope_guard;

  $self->move_last;

  $self->set_inflated_columns({ %$to_group, $position_column => undef });
  my $new_group_last_posval = $self->_last_sibling_posval;
  my $new_group_last_position = $self->_position_from_value($new_group_last_posval);

  if (not defined($to_position) or $to_position > $new_group_last_position) {
    $self->set_column(
      $position_column => $new_group_last_position
        ? $self->_next_position_value($new_group_last_posval)
        : $self->_initial_position_value
    );
  }
  else {
    my $bumped_pos_val = $self->_position_value($to_position);
    my @between = map { $self->_position_value($_) } ($to_position, $new_group_last_position);
    $self->_shift_siblings(1, @between);
    $self->set_column($position_column => $bumped_pos_val);
  }

  $self->_ordered_internal_update;
  $guard->commit;
  return 1;
}


sub insert {
  my $self = shift;
  my $position_column = $self->position_column;

  unless ($self->get_column($position_column)) {
    my $lsib_posval = $self->_last_sibling_posval;
    $self->set_column(
      $position_column => (defined $lsib_posval
        ? $self->_next_position_value($lsib_posval)
        : $self->_initial_position_value
      )
    );
  }

  return $self->next::method(@_);
}


sub update {
  my $self = shift;

  return $self->next::method(@_) if $self->result_source->schema->{_ORDERED_INTERNAL_UPDATE};

  my $upd = shift;
  $self->set_inflated_columns($upd) if $upd;

  my $position_column = $self->position_column;
  my @group_columns = $self->_grouping_columns;

  my $changed_ordering_cols = { map { $_ => $self->get_column($_) } grep { $self->is_column_changed($_) } ($position_column, @group_columns) };

  if (! keys %$changed_ordering_cols) {
    return $self->next::method(undef, @_);
  }
  elsif (grep { exists $changed_ordering_cols->{$_} } @group_columns) {
    $self->move_to_group(
      { $self->_grouping_clause },
      (exists $changed_ordering_cols->{$position_column}
        ? $changed_ordering_cols->{$position_column}
        : $self->_position
      ),
    );
  }
  else {
    $self->move_to($changed_ordering_cols->{$position_column});
  }

  return $self;
}


sub delete {
  my $self = shift;
  my $guard = $self->result_source->schema->txn_scope_guard;
  $self->move_last;
  $self->next::method(@_);
  $guard->commit;
  return $self;
}

sub _track_storage_value {
  my ($self, $col) = @_;
  return (
    $self->next::method($col)
      ||
    grep { $_ eq $col } ($self->position_column, $self->_grouping_columns)
  );
}


sub _position_from_value {
  my ($self, $val) = @_;
  return 0 unless defined $val;
  return $val;
}


sub _position_value {
  my ($self, $pos) = @_;