File Coverage

blib/lib/Mojo/PgX/Cursor/Results.pm

Criterion	Covered	Total	%
statement	6	57	10.5
branch	0	16	0.0
condition			n/a
subroutine	2	15	13.3
pod	8	8	100.0
total	16	96	16.6

package Mojo::PgX::Cursor::Results;

require Mojo::IOLoop;
require Mojo::PgX::Cursor::Cursor;

use Time::HiRes qw(time);

use Mojo::Base -base;

has [qw(seconds_blocked)];

sub array {
  my $self = shift->_fetch;
  $self->{remaining}--;
  return $self->{results}->array;
}

sub columns { shift->_results->columns }

sub cursor {
  my $self = shift;
  if (@_) {
    $self->wait;
    $self->{cursor} = shift;
    $self->{remaining} = 0;
    delete $self->{delay};
    delete $self->{next};
    delete $self->{results};
    return $self->_load_next;
  }
  return $self->{cursor};
}

sub expand {
  my $self = shift;
  $self->{expand}++;
  if ($self->{results}) {
      $self->{results}->expand;
  }
  return $self;
}

sub hash {
  my $self = shift->_fetch;
  $self->{remaining}--;
  return $self->{results}->hash;
}

sub new {
  my $self = shift->SUPER::new(@_);
  return $self->_load_next;
}

sub rows {
  my $self = shift;
  return $self->_results->rows unless @_;
  $self->{rows} = shift;
  return $self;
}

sub wait {
  my $self = shift;
  if ($self->{delay}) {
    $self->{delay}->wait;
  }
  return $self;
}

sub _fetch {
  my $self = shift;
  return $self if $self->{remaining};
  unless ($self->{next}) {
    my $start = time;
    $self->wait;
    $self->{seconds_blocked} += time - $start;
    delete $self->{delay};
  }
  $self->{results} = delete $self->{next};
  $self->{remaining} = $self->{results}->rows;
  return $self->_load_next;
}

sub _load_next {
  my $self = shift;
  $self->{delay} = Mojo::IOLoop->delay(
    sub {
      $self->cursor->fetch($self->{rows}, shift->begin);
    },
    sub {
      $self->{next} = $_[2];
      $self->{next}->expand if ($self->{expand});
    },
  );
  return $self;
}

sub _results {
  my $self = shift;
  return $self->{results} if $self->{results};
  return $self->_fetch->{results};
}

1;
__END__