File Coverage

lib/DBIx/EAV/ResultSet.pm

Criterion	Covered	Total	%
statement	117	134	87.3
branch	41	50	82.0
condition	11	14	78.5
subroutine	27	31	87.1
pod	7	19	36.8
total	203	248	81.8

package DBIx::EAV::ResultSet;

use Moo;
use DBIx::EAV::Entity;
use DBIx::EAV::Cursor;
use Data::Dumper;
use Carp qw/ croak confess /;
use overload
    '0+'   => "_to_num",
    'bool' => "_to_bool",
    fallback => 1;

my $sql = SQL::Abstract->new;

has 'eav',      is => 'ro', required => 1;
has 'type',     is => 'ro', required => 1;
has '_query',   is => 'rw', default => sub { [] }, init_arg => 'query';
has '_options', is => 'rw', default => sub { {} }, init_arg => 'options';
has 'cursor',   is => 'rw',
                lazy      => 1,
                init_arg  => undef,
                predicate => '_has_cursor',
                clearer   => '_clear_cursor',
                builder   => '_build_cursor';

has 'entity_class', is => 'ro', init_arg => undef, lazy => 1, default => sub {
    my $self = shift;
    $self->eav->_resolve_entity_class($self->type->name) || 'DBIx::EAV::Entity';
};

sub _to_num { $_[0]->count }

sub _to_bool { 1 }


sub _build_cursor {
    my $self = shift;

    DBIx::EAV::Cursor->new(
        eav     => $self->eav,
        type    => $self->type,
        query   => $self->_query,
        options => $self->_options,
    );
}


sub new_entity {
    my ($self, $data) = @_;
    my $entity = $self->entity_class->new( eav => $self->eav, type => $self->type );
    $entity->set($data) if ref $data eq 'HASH';
    $entity;
}


sub inflate_entity {
    my ($self, $data) = @_;
    my $type = $self->type;
    $type = $self->eav->type_by_id($data->{entity_type_id})
        if $data->{entity_type_id} && $data->{entity_type_id} != $type->id;

    my $entity = $self->entity_class->new( eav => $self->eav, type => $type, raw => $data );
    $entity->load_attributes;
    $entity;
}


{
    no warnings;
    *create = \&insert;
}

sub insert {
    my ($self, $data) = @_;
    $self->new_entity($data)->save;
}


sub populate {
    my ($self, $data) = @_;
    die 'Call populate(\@items)' unless ref $data eq 'ARRAY';

    my @result;
    foreach my $item (@$data) {
        push @result, $self->insert($item);
    }

    return wantarray ? @result : \@result;
}


sub update {
    my ($self, $data, $where) = @_;

    $where //= {};
    $where->{entity_type_id} = $self->type->id;

    # do a direct update for static attributes

}


sub delete {
    my $self = shift;
    my $eav = $self->eav;
    my $type = $self->type;
    my $entities_table = $eav->table('entities');

    # Call delete_all for SQLite since it doesn't
    # support delete with joins.
    # Better solution welcome.
    return $self->delete_all if
        $self->eav->schema->db_driver_name eq 'SQLite';

    unless ($eav->schema->database_cascade_delete) {

        # delete links by relationship id
        my @ids = map { $_->{id} } $type->relationships;

        $eav->table('entity_relationships')->delete(
            {
                relationship_id => \@ids,
                $entities_table->name.'.entity_type_id' => $type->id
            },
            { join => { $entities_table->name =>  [{ 'me.left_entity_id' => 'their.id' }, { 'me.right_entity_id' => 'their.id' }] } }
        );

        # delete attributes:
        # - group attrs by data type so only one DELETE command is sent per data type
        # - restrict by entity_type_id so we dont delete parent/sibiling/child data
        my %types;
        push @{ $types{$_->{data_type}} }, $_->{id}
            for $type->attributes(no_static => 1);

        while (my ($data_type, $ids) = each %types) {

            my $value_table = $eav->table('value_'.$data_type);
            $value_table->delete(
                {
                    attribute_id => $ids,
                    $entities_table->name.'.entity_type_id' => $type->id
                },
                { join => { $entities_table->name => { 'me.entity_id' => 'their.id' } } }
            );
        }
    }

    $entities_table->delete({ entity_type_id => $type->id });
}


sub delete_all {
    my $self = shift;

    my $rs = scalar @_ > 0 ? $self->search_rs(@_) : $self;
    my $i = 0;

    while (my $entity = $rs->next) {
        $entity->delete;
        $i++;
    }

    $i;
}


sub find {
    my ($self, $criteria, $options) = @_;

    croak "Missing find() criteria."
        unless defined $criteria;

    # simple id search
    return $self->search_rs({ id => $criteria }, $options)->next
        unless ref $criteria;

    my $rs = $self->search_rs($criteria, $options);
    my $result = $rs->next;

    # criteria is a search query, die if this query returns multiple items
    croak "find() returned more than one entity. If this is what you want, use search or search_rs."
        if defined $result && defined $rs->cursor->next;

    $result;
}


sub search {
    my ($self, $query, $options) = @_;

    my $rs = $self->search_rs($query, $options);

    return wantarray ? $rs->all : $rs;
}

sub search_rs {
    my ($self, $query, $options) = @_;

    # simple combine queries using AND
    my @new_query = @{ $self->_query };
    push @new_query, $query if $query;

    # merge options
    my $merged_options = $self->_merge_options($options);

    (ref $self)->new(
        eav      => $self->eav,
        type     => $self->type,
        query    => \@new_query,
        options  => $merged_options
    );
}


sub _merge_options {
    my ($self, $options) = @_;

    my %merged = %{ $self->_options };

    return \%merged
        unless defined $options;

    confess "WTF" if $options eq '';

    foreach my $opt (keys %$options) {

        # doesnt even exist, just copy
        if (not exists $merged{$opt}) {
            $merged{$opt} = $options->{$opt};
        }

        # having: combine queries using AND
        elsif ($opt eq 'having') {

            $merged{$opt} = [$merged{$opt}, $options->{$opt}];
        }

        # merge array
        elsif (ref $merged{$opt} eq 'ARRAY') {

            $merged{$opt} = [
                @{$merged{$opt}},
                ref $options->{$opt} eq 'ARRAY' ? @{$options->{$opt}} : $options->{$opt}
            ];
        }

        else {
            $merged{$opt} = $options->{$opt};
        }
    }

    \%merged;
}


sub count {
    my $self = shift;
    return $self->search(@_)->count if @_;

    # from DBIx::Class::ResultSet::count()
    # this is a little optimization - it is faster to do the limit
    # adjustments in software, instead of a subquery
    my $options = $self->_options;
    my ($limit, $offset) = @$options{qw/ limit offset /};

    my $count = $self->_count_rs($options)->cursor->next->{count};

    $count -= $offset if $offset;
    $count = 0 if $count < 0;
    $count = $limit if $limit && $count > $limit;

    $count;
}


sub _count_rs {
    my ($self, $options) = @_;
    my %tmp_options = ( %$options, select => [\'COUNT(*) AS count'] );

    # count using subselect if needed
    $tmp_options{from} = $self->as_query
        if $options->{group_by} || $options->{distinct};

    delete @tmp_options{qw/ limit offset order_by group_by distinct /};

    (ref $self)->new(
        eav      => $self->eav,
        type     => $self->type,
        query    => [@{ $self->_query }],
        options  => \%tmp_options
    );
}


sub as_query {
    my $self = shift;
    $self->cursor->as_query;
}


sub reset {
    my $self = shift;
    $self->_clear_cursor;
    $self;
}

sub first {
    $_[0]->reset->next;
}

sub next {
    my $self = shift;

    # fetch next
    my $entity_row = $self->cursor->next;
    return unless defined $entity_row;

    # instantiate entity
    $self->inflate_entity($entity_row);
}

sub all {
    my $self = shift;
    my @entities;

    $self->reset;

    while (my $entity = $self->next) {
        push @entities, $entity;
    }

    $self->reset;

    return wantarray ? @entities : \@entities;
}

sub pager {
    die "pager() not implemented";
}

sub distinct {
    die "distinct() not implemented";
}

sub storage_size {
    die "storage_size() not implemented";
}


1;

__END__