NAME

DBIx::Custom::Result - Result of select statement

SYNOPSIS

  # Result
  my $result = $dbi->select(table => 'book');
  # Fetch a row and put it into array reference
  while (my $row = $result->fetch) {
    my $author = $row->[0];
    my $title  = $row->[1];
  }
  
  # Fetch only a first row and put it into array reference
  my $row = $result->fetch_one;
  
  # Fetch all rows and put them into array of array reference
  my $rows = $result->fetch_all;
  # Fetch a row and put it into hash reference
  while (my $row = $result->fetch_hash) {
    my $title  = $row->{title};
    my $author = $row->{author};
  }
  
  # Fetch only a first row and put it into hash reference
  my $row = $result->fetch_hash_one;
  my $row = $result->one; # Alias for "fetch_hash_one"
  
  # Fetch all rows and put them into array of hash reference
  my $rows = $result->fetch_hash_all;
  my $rows = $result->all; # Alias for "fetch_hash_all"

ATTRIBUTES

dbi

  my $dbi = $result->dbi;
  $result = $result->dbi($dbi);

DBIx::Custom object.

sth

  my $sth = $reuslt->sth
  $result = $result->sth($sth);

Statement handle of DBI.

METHODS

DBIx::Custom::Result inherits all methods from Object::Simple and implements the following new ones.

all

  my $rows = $result->all;

Same as fetch_hash_all.

fetch

  my $row = $result->fetch;

Fetch a row and put it into array reference.

fetch_all

  my $rows = $result->fetch_all;

Fetch all rows and put them into array of array reference.

fetch_one

  my $row = $result->fetch_one;

Fetch only a first row and put it into array reference, and finish statement handle.

fetch_hash

  my $row = $result->fetch_hash;

Fetch a row and put it into hash reference.

fetch_hash_all

  my $rows = $result->fetch_hash_all;

Fetch all rows and put them into array of hash reference.

fetch_hash_one

  my $row = $result->fetch_hash_one;

Fetch only a first row and put it into hash reference, and finish statement handle.

fetch_hash_multi

  my $rows = $result->fetch_hash_multi(5);

Fetch multiple rows and put them into array of hash reference.

fetch_multi

  my $rows = $result->fetch_multi(5);

Fetch multiple rows and put them into array of array reference.

filter

  $result->filter(title  => sub { uc $_[0] }, author => 'to_upper');
  $result->filter([qw/title author/] => 'to_upper');

Set filter for column. You can use subroutine or filter name as filter. This filter is executed after "type_rule" filter.

flat

  my @list = $result->flat;

All values is added to flatten list.

  my @list = $dbi->select(['id', 'title'])->flat;

"flat" method return the following data.

  (1, 'Perl', 2, 'Ruby')

You can create key-value pair easily.

  my %titles = $dbi->select(['id', 'title'])->flat;

kv

  my $key_value = $result->kv;

Get key-value pairs.

  my $books = $dbi->select(['id', 'title', 'author'])->kv;

If "all" method return the following data:

  [
    {id => 1, title => 'Perl', author => 'Ken'},
    {id => 2, title => 'Ruby', author => 'Taro'}
  ]

"kv" method return the following data.

  {
    1 => {title => 'Perl', author => 'Ken'},
    2 => {title => 'Ruby', author => 'Taro'}
  }

First column value become key.

kvs

  my $key_values = $result->kvs;

Get key-values pairs.

  my $books = $dbi->select(['author', 'title', 'price'])->kvs;

If "all" method return the following data:

  [
    {author => 'Ken', title => 'Perl', price => 1000},
    {author => 'Ken', title => 'Good', price => 2000},
    {author => 'Taro', title => 'Ruby', price => 3000}
    {author => 'Taro', title => 'Sky', price => 4000}
  ]

"kvs" method return the following data.

  {
    Ken => [
      {title => 'Perl', price => 1000},
      {title => 'Good', price => 2000}
    ],
    Taro => [
      {title => 'Ruby', price => 3000},
      {title => 'Sky', price => 4000}
    ]
  }

  my $header = $result->header;

Get header column names.

one

  my $row = $result->one;

Alias for "fetch_hash_one".

stash

  my $stash = $result->stash;
  my $foo = $result->stash->{foo};
  $result->stash->{foo} = $foo;

Stash is hash reference to save some data.

type_rule

  # Merge type rule
  $result->type_rule(
    # DATE
    9 => sub { ... },
    # DATETIME or TIMESTAMP
    11 => sub { ... }
  );
  # Replace type rule(by reference)
  $result->type_rule([
    # DATE
    9 => sub { ... },
    # DATETIME or TIMESTAMP
    11 => sub { ... }
  ]);

This is same as DBIx::Custom's "type_rule"'s <from>.

type_rule_off

  $result = $result->type_rule_off;

Turn "from1" and "from2" type rule off. By default, type rule is on.

type_rule_on

  $result = $result->type_rule_on;

Turn "from1" and "from2" type rule on. By default, type rule is on.

type_rule1_off

  $result = $result->type_rule1_off;

Turn "from1" type rule off. By default, type rule is on.

type_rule1_on

  $result = $result->type_rule1_on;

Turn "from1" type rule on. By default, type rule is on.

type_rule2_off

  $result = $result->type_rule2_off;

Turn "from2" type rule off. By default, type rule is on.

type_rule2_on

  $result = $result->type_rule2_on;

Turn "from2" type rule on. By default, type rule is on.

value

  my $value = $result->value;

Get first column's first value.

  my $count = $dbi->select('count(*)', table => 'book')->value;

This is almost same as the following one.

  my $count = $dbi->select('count(*)')->fetch_one->[0];

values

  my $values = $result->values;

Get first column's values.

  my $tables = $dbi->select('show tables')->values;

This is same as the following one.

  my $rows = $dbi->select('show tables')->fetch_all;
  my $tables = [map { $_->[0] } @$rows];