Rose::DBx::Object::MoreHelpers - more mixin helpers for RDBO

 package MyRDBO;
 use base qw( Rose::DB::Object );
 use Rose::DBx::Object::MoreHelpers;

 find
 get_set_on_save
 add_on_save
 count
 iterator

 # 'title' has no unique constraints on it
 my $object = Object->new(title => 'Foo');
 $object->save unless $object->exists;

    perldoc Rose::DBx::Object::MoreHelpers

package Rose::DBx::Object::MoreHelpers;

use warnings;
use strict;

use Rose::Object::MixIn;
our @ISA = qw(Rose::Object::MixIn);

use Carp;
use Data::Dump qw( dump );
use Scalar::Util qw( blessed );

use Rose::DB::Object::Manager;
use Rose::DB::Object::Metadata::Relationship::OneToMany;
Rose::DB::Object::Metadata::Relationship::OneToMany
    ->default_auto_method_types(
    qw(
        find
        get_set_on_save
        add_on_save
        count
        iterator
        )
    );
use Rose::DB::Object::Metadata::Relationship::ManyToMany;
Rose::DB::Object::Metadata::Relationship::ManyToMany
    ->default_auto_method_types(
    qw(
        find
        get_set_on_save
        add_on_save
        count
        iterator
        )
    );

use Rose::Class::MakeMethods::Generic ( scalar => ['debug'], );

our $VERSION = '0.08';

__PACKAGE__->export_tags(
    all => [
        qw(
            primary_key_uri_escaped primary_key_value
            flatten exists has_related has_related_pages
            fetch_all fetch_all_iterator
            )
    ],

    # This exists for the benefit of the test suite
    all_noprereq => [
        qw(
            primary_key_uri_escaped primary_key_value
            flatten exists has_related has_related_pages
            fetch_all fetch_all_iterator
            )
    ],
);

sub primary_key_uri_escaped {
    my $self = shift;
    my $val  = $self->primary_key_value;
    my @vals = ref $val ? @$val : ($val);
    my @esc;
    for my $v (@vals) {
        $v = '' unless defined $v;
        $v =~ s/;/\%3b/g;
        push @esc, $v;
    }
    if ( !grep { length($_) } @esc ) {
        return 0;
    }
    my $pk = join( ';;', @esc );
    $pk =~ s!/!\%2f!g;
    return $pk;
}

sub primary_key_value {
    my $self = shift;
    my @cols = $self->meta->primary_key_column_names;
    my @vals;
    for my $m (@cols) {
        push( @vals, scalar $self->$m );
    }
    return scalar(@vals) > 1 ? \@vals : $vals[0];
}

sub unique_value {
    my $self  = shift;
    my @ukeys = $self->meta->unique_keys_column_names;
    if (@ukeys) {
        for my $k (@ukeys) {
            if ( scalar(@$k) == 1 ) {
                my $method = $k->[0];
                return $self->$method;    # TODO column alias ??
            }
        }
    }
    return $self->primary_key_value;
}

sub moniker {
    my $self  = shift;
    my $class = $self->meta->class;
    $class =~ s/^.+:://;
    return $class;
}

sub flatten {
    my $self = shift;
    if ( $Rose::DB::Object::VERSION < 0.7712 ) {
        croak "Rose::DB::Object VERSION 0.7712 or later required";
    }
    elsif ( !$self->can('as_tree') ) {
        croak "You must load Rose::DB::Object::Helpers as_tree() method";
    }
    return $self->as_tree( @_, force_load => 1 );
}

sub exists {
    my $self = shift;
    my @arg  = @_;
    if ( !@arg && ref($self) ) {
        for my $col ( $self->meta->column_accessor_method_names ) {
            push( @arg, $col, $self->$col ) if defined( $self->$col );
        }
    }
    my $count = Rose::DB::Object::Manager->get_objects_count(
        object_class => ref($self) || $self,
        query => [@arg]
    );

    return $count if defined($count);
    croak "Error: " . Rose::DB::Object::Manager->error;
}

sub has_related {
    my $self   = shift;
    my $rel    = shift or croak "need Relationship name";
    my $method = $rel . '_count';
    if ( $self->can($method) ) {
        return $self->$method;
    }
    else {
        my $other = $self->$rel;
        if ( ref $other eq 'ARRAY' ) {
            return scalar @$other;
        }
        else {
            return $other ? 1 : 0;
        }
    }
}

sub has_related_pages {
    my $self   = shift;
    my $rel    = shift or croak "need Relationship name";
    my $pgsize = shift or croak "need page_size";
    if ( $pgsize =~ m/\D/ ) {
        croak "page_size must be an integer";
    }
    my $n = $self->has_related($rel);
    return 0 if !$n;
    if ( $n % $pgsize ) {
        return int( $n / $pgsize ) + 1;
    }
    else {
        return $n / $pgsize;
    }
}

sub fetch_all {
    my $self  = shift;
    my $class = $self->meta->class;
    return Rose::DB::Object::Manager->get_objects(
        object_class => $class,
        @_
    );
}

sub fetch_all_iterator {
    my $self  = shift;
    my $class = $self->meta->class;
    return Rose::DB::Object::Manager->get_objects_iterator(
        object_class => $class,
        @_
    );
}

sub column_is_boolean {
    my $self = shift;
    my $col  = shift;
    croak "column_name required" unless defined $col;
    if (    $self->meta->column($col)
        and $self->meta->column($col)->type eq 'boolean' )
    {
        return 1;
    }
    else {
        return 0;
    }
}

1;