@@ -1,3 +1,6 @@

+0.1618

+  added helper method

+  added begin_work, commit, and rollback method

 0.1617

   L<DBIx::Custom> is now stable. APIs keep backword compatible in the feature.

 0.1616

@@ -1,6 +1,6 @@

 package DBIx::Custom;

-our $VERSION = '0.1617';

+our $VERSION = '0.1618';

 use 5.008001;

 use strict;

@@ -15,19 +15,8 @@ use DBIx::Custom::Query;

 use DBIx::Custom::QueryBuilder;

 use Encode qw/encode_utf8 decode_utf8/;

-__PACKAGE__->attr('dbh');

-__PACKAGE__->attr([qw/user password data_source/]);

-__PACKAGE__->attr([qw/default_bind_filter default_fetch_filter/]);

-

-__PACKAGE__->dual_attr('filters', default => sub { {} },

-                                  inherit => 'hash_copy');

-__PACKAGE__->register_filter(

-    encode_utf8 => sub { encode_utf8($_[0]) },

-    decode_utf8 => sub { decode_utf8($_[0]) }

-);

-

-__PACKAGE__->attr(result_class => 'DBIx::Custom::Result');

-__PACKAGE__->attr(query_builder  => sub {DBIx::Custom::QueryBuilder->new});

+__PACKAGE__->attr([qw/data_source dbh default_bind_filter

+                      default_fetch_filter password user/]);

 __PACKAGE__->attr(cache => 1);

 __PACKAGE__->attr(cache_method => sub {

@@ -45,7 +34,30 @@ __PACKAGE__->attr(cache_method => sub {

     }

 });

+__PACKAGE__->dual_attr('filters', default => sub { {} },

+                                  inherit => 'hash_copy');

 __PACKAGE__->attr(filter_check => 1);

+__PACKAGE__->attr(query_builder  => sub {DBIx::Custom::QueryBuilder->new});

+__PACKAGE__->attr(result_class => 'DBIx::Custom::Result');

+

+# DBI methods

+foreach my $method (qw/begin_work commit rollback/) {

+    my $code = sub {

+        my $self = shift;

+        my $ret = eval {$self->dbh->$method};

+        croak $@ if $@;

+        return $ret;

+    };

+    no strict 'refs';

+    my $pkg = __PACKAGE__;

+    *{"${pkg}::$method"} = $code;

+};

+

+# Regster filter

+__PACKAGE__->register_filter(

+    encode_utf8 => sub { encode_utf8($_[0]) },

+    decode_utf8 => sub { decode_utf8($_[0]) }

+);

 sub connect {

     my $proto = shift;

@@ -80,70 +92,67 @@ sub connect {

     return $self;

 }

-sub register_filter {

-    my $invocant = shift;

+sub create_query {

+    my ($self, $source) = @_;

-    # Register filter

-    my $filters = ref $_[0] eq 'HASH' ? $_[0] : {@_};

-    $invocant->filters({%{$invocant->filters}, %$filters});

+    # Cache

+    my $cache = $self->cache;

-    return $invocant;

-}

-

-our %VALID_INSERT_ARGS = map { $_ => 1 } qw/table param append filter/;

+    # Create query

+    my $query;

+    if ($cache) {

+        

+        # Get query

+        my $q = $self->cache_method->($self, $source);

+        

+        # Create query

+        $query = DBIx::Custom::Query->new($q) if $q;

+    }

+    

+    unless ($query) {

-sub insert {

-    my ($self, %args) = @_;

+        # Create SQL object

+        my $builder = $self->query_builder;

+        

+        # Create query

+        $query = $builder->build_query($source);

-    # Check arguments

-    foreach my $name (keys %args) {

-        croak qq{"$name" is invalid argument}

-          unless $VALID_INSERT_ARGS{$name};

+        # Cache query

+        $self->cache_method->($self, $source,

+                             {sql     => $query->sql, 

+                              columns => $query->columns})

+          if $cache;

     }

-    # Arguments

-    my $table  = $args{table} || '';

-    my $param  = $args{param} || {};

-    my $append = $args{append} || '';

-    my $filter = $args{filter};

-    

-    # Insert keys

-    my @insert_keys = keys %$param;

-    

-    # Templte for insert

-    my $source = "insert into $table {insert_param "

-               . join(' ', @insert_keys) . '}';

-    $source .= " $append" if $append;

+    # Prepare statement handle

+    my $sth;

+    eval { $sth = $self->dbh->prepare($query->{sql})};

+    $self->_croak($@, qq{. SQL: "$query->{sql}"}) if $@;

-    # Execute query

-    my $ret_val = $self->execute($source, param  => $param, 

-                                          filter => $filter);

+    # Set statement handle

+    $query->sth($sth);

-    return $ret_val;

+    return $query;

 }

-our %VALID_UPDATE_ARGS

-  = map { $_ => 1 } qw/table param where append filter allow_update_all/;

+our %VALID_DELETE_ARGS

+  = map { $_ => 1 } qw/table where append filter allow_delete_all/;

-sub update {

+sub delete {

     my ($self, %args) = @_;

     # Check arguments

     foreach my $name (keys %args) {

         croak qq{"$name" is invalid argument}

-          unless $VALID_UPDATE_ARGS{$name};

+          unless $VALID_DELETE_ARGS{$name};

     }

     # Arguments

     my $table            = $args{table} || '';

-    my $param            = $args{param} || {};

     my $where            = $args{where} || {};

-    my $append = $args{append} || '';

+    my $append = $args{append};

     my $filter           = $args{filter};

-    my $allow_update_all = $args{allow_update_all};

-    

-    # Update keys

-    my @update_keys = keys %$param;

+    my $allow_delete_all = $args{allow_delete_all};

     # Where keys

     my @where_keys = keys %$where;

@@ -151,15 +160,10 @@ sub update {

     # Not exists where keys

     croak qq{"where" argument must be specified and } .

           qq{contains the pairs of column name and value}

-      if !@where_keys && !$allow_update_all;

-    

-    # Update clause

-    my $update_clause = '{update_param ' . join(' ', @update_keys) . '}';

+      if !@where_keys && !$allow_delete_all;

     # Where clause

     my $where_clause = '';

-    my $new_where = {};

-    

     if (@where_keys) {

         $where_clause = 'where ';

         $where_clause .= "{= $_} and " for @where_keys;

@@ -167,79 +171,103 @@ sub update {

     }

     # Source of SQL

-    my $source = "update $table $update_clause $where_clause";

+    my $source = "delete from $table $where_clause";

     $source .= " $append" if $append;

-    # Rearrange parameters

-    foreach my $wkey (@where_keys) {

-        

-        if (exists $param->{$wkey}) {

-            $param->{$wkey} = [$param->{$wkey}]

-              unless ref $param->{$wkey} eq 'ARRAY';

-            

-            push @{$param->{$wkey}}, $where->{$wkey};

-        }

-        else {

-            $param->{$wkey} = $where->{$wkey};

-        }

-    }

-    

     # Execute query

-    my $ret_val = $self->execute($source, param  => $param, 

+    my $ret_val = $self->execute($source, param  => $where, 

                                  filter => $filter);

     return $ret_val;

 }

-sub update_all { shift->update(allow_update_all => 1, @_) };

+sub delete_all { shift->delete(allow_delete_all => 1, @_) }

-our %VALID_DELETE_ARGS

-  = map { $_ => 1 } qw/table where append filter allow_delete_all/;

+our %VALID_EXECUTE_ARGS = map { $_ => 1 } qw/param filter/;

-sub delete {

-    my ($self, %args) = @_;

+sub execute{

+    my ($self, $query, %args)  = @_;

     # Check arguments

     foreach my $name (keys %args) {

         croak qq{"$name" is invalid argument}

-          unless $VALID_DELETE_ARGS{$name};

+          unless $VALID_EXECUTE_ARGS{$name};

     }

-    # Arguments

-    my $table            = $args{table} || '';

-    my $where            = $args{where} || {};

-    my $append = $args{append};

-    my $filter           = $args{filter};

-    my $allow_delete_all = $args{allow_delete_all};

+    my $params = $args{param} || {};

-    # Where keys

-    my @where_keys = keys %$where;

+    # First argument is the soruce of SQL

+    $query = $self->create_query($query)

+      unless ref $query;

-    # Not exists where keys

-    croak qq{"where" argument must be specified and } .

-          qq{contains the pairs of column name and value}

-      if !@where_keys && !$allow_delete_all;

+    my $filter = $args{filter} || $query->filter || {};

-    # Where clause

-    my $where_clause = '';

-    if (@where_keys) {

-        $where_clause = 'where ';

-        $where_clause .= "{= $_} and " for @where_keys;

-        $where_clause =~ s/ and $//;

+    # Create bind value

+    my $bind_values = $self->_build_bind_values($query, $params, $filter);

+    

+    # Execute

+    my $sth      = $query->sth;

+    my $affected;

+    eval {$affected = $sth->execute(@$bind_values)};

+    $self->_croak($@) if $@;

+    

+    # Return resultset if select statement is executed

+    if ($sth->{NUM_OF_FIELDS}) {

+        

+        # Create result

+        my $result = $self->result_class->new(

+            sth            => $sth,

+            default_filter => $self->default_fetch_filter,

+            filters        => $self->filters,

+            filter_check   => $self->filter_check

+        );

+

+        return $result;

+    }

+    return $affected;

+}

+

+our %VALID_INSERT_ARGS = map { $_ => 1 } qw/table param append filter/;

+

+sub insert {

+    my ($self, %args) = @_;

+

+    # Check arguments

+    foreach my $name (keys %args) {

+        croak qq{"$name" is invalid argument}

+          unless $VALID_INSERT_ARGS{$name};

     }

-    # Source of SQL

-    my $source = "delete from $table $where_clause";

+    # Arguments

+    my $table  = $args{table} || '';

+    my $param  = $args{param} || {};

+    my $append = $args{append} || '';

+    my $filter = $args{filter};

+    

+    # Insert keys

+    my @insert_keys = keys %$param;

+    

+    # Templte for insert

+    my $source = "insert into $table {insert_param "

+               . join(' ', @insert_keys) . '}';

     $source .= " $append" if $append;

     # Execute query

-    my $ret_val = $self->execute($source, param  => $where, 

-                                 filter => $filter);

+    my $ret_val = $self->execute($source, param  => $param, 

+                                          filter => $filter);

     return $ret_val;

 }

-sub delete_all { shift->delete(allow_delete_all => 1, @_) }

+sub register_filter {

+    my $invocant = shift;

+    

+    # Register filter

+    my $filters = ref $_[0] eq 'HASH' ? $_[0] : {@_};

+    $invocant->filters({%{$invocant->filters}, %$filters});

+    

+    return $invocant;

+}

 our %VALID_SELECT_ARGS

   = map { $_ => 1 } qw/table column where append relation filter param/;

@@ -320,112 +348,77 @@ sub select {

     return $result;

 }

-sub create_query {

-    my ($self, $source) = @_;

-    

-    # Cache

-    my $cache = $self->cache;

+our %VALID_UPDATE_ARGS

+  = map { $_ => 1 } qw/table param where append filter allow_update_all/;

+

+sub update {

+    my ($self, %args) = @_;

-    # Create query

-    my $query;

-    if ($cache) {

-        

-        # Get query

-        my $q = $self->cache_method->($self, $source);

-        

-        # Create query

-        $query = DBIx::Custom::Query->new($q) if $q;

+    # Check arguments

+    foreach my $name (keys %args) {

+        croak qq{"$name" is invalid argument}

+          unless $VALID_UPDATE_ARGS{$name};

     }

-    unless ($query) {

-

-        # Create SQL object

-        my $builder = $self->query_builder;

-        

-        # Create query

-        $query = $builder->build_query($source);

-

-        # Cache query

-        $self->cache_method->($self, $source,

-                             {sql     => $query->sql, 

-                              columns => $query->columns})

-          if $cache;

-    }

+    # Arguments

+    my $table            = $args{table} || '';

+    my $param            = $args{param} || {};

+    my $where            = $args{where} || {};

+    my $append = $args{append} || '';

+    my $filter           = $args{filter};

+    my $allow_update_all = $args{allow_update_all};

-    # Prepare statement handle

-    my $sth;

-    eval { $sth = $self->dbh->prepare($query->{sql})};

-    $self->_croak($@, qq{. SQL: "$query->{sql}"}) if $@;

+    # Update keys

+    my @update_keys = keys %$param;

-    # Set statement handle

-    $query->sth($sth);

+    # Where keys

+    my @where_keys = keys %$where;

-    return $query;

-}

-

-sub _croak {

-    my ($self, $error, $append) = @_;

-    $append ||= "";

+    # Not exists where keys

+    croak qq{"where" argument must be specified and } .

+          qq{contains the pairs of column name and value}

+      if !@where_keys && !$allow_update_all;

-    # Verbose

-    if ($Carp::Verbose) { croak $error }

+    # Update clause

+    my $update_clause = '{update_param ' . join(' ', @update_keys) . '}';

-    # Not verbose

-    else {

-        

-        # Remove line and module infromation

-        my $at_pos = rindex($error, ' at ');

-        $error = substr($error, 0, $at_pos);

-        $error =~ s/\s+$//;

-        

-        croak "$error$append";

-    }

-}

-

-our %VALID_EXECUTE_ARGS = map { $_ => 1 } qw/param filter/;

-

-sub execute{

-    my ($self, $query, %args)  = @_;

+    # Where clause

+    my $where_clause = '';

+    my $new_where = {};

-    # Check arguments

-    foreach my $name (keys %args) {

-        croak qq{"$name" is invalid argument}

-          unless $VALID_EXECUTE_ARGS{$name};

+    if (@where_keys) {

+        $where_clause = 'where ';

+        $where_clause .= "{= $_} and " for @where_keys;

+        $where_clause =~ s/ and $//;

     }

-    my $params = $args{param} || {};

-    

-    # First argument is the soruce of SQL

-    $query = $self->create_query($query)

-      unless ref $query;

-    

-    my $filter = $args{filter} || $query->filter || {};

-    

-    # Create bind value

-    my $bind_values = $self->_build_bind_values($query, $params, $filter);

-    

-    # Execute

-    my $sth      = $query->sth;

-    my $affected;

-    eval {$affected = $sth->execute(@$bind_values)};

-    $self->_croak($@) if $@;

+    # Source of SQL

+    my $source = "update $table $update_clause $where_clause";

+    $source .= " $append" if $append;

-    # Return resultset if select statement is executed

-    if ($sth->{NUM_OF_FIELDS}) {

+    # Rearrange parameters

+    foreach my $wkey (@where_keys) {

-        # Create result

-        my $result = $self->result_class->new(

-            sth            => $sth,

-            default_filter => $self->default_fetch_filter,

-            filters        => $self->filters,

-            filter_check   => $self->filter_check

-        );

-

-        return $result;

+        if (exists $param->{$wkey}) {

+            $param->{$wkey} = [$param->{$wkey}]

+              unless ref $param->{$wkey} eq 'ARRAY';

+            

+            push @{$param->{$wkey}}, $where->{$wkey};

+        }

+        else {

+            $param->{$wkey} = $where->{$wkey};

+        }

     }

-    return $affected;

+    

+    # Execute query

+    my $ret_val = $self->execute($source, param  => $param, 

+                                 filter => $filter);

+    

+    return $ret_val;

 }

+sub update_all { shift->update(allow_update_all => 1, @_) };

+

 sub _build_bind_values {

     my ($self, $query, $params, $filter) = @_;

@@ -487,6 +480,25 @@ sub _check_filter {

     }

 }

+sub _croak {

+    my ($self, $error, $append) = @_;

+    $append ||= "";

+    

+    # Verbose

+    if ($Carp::Verbose) { croak $error }

+    

+    # Not verbose

+    else {

+        

+        # Remove line and module infromation

+        my $at_pos = rindex($error, ' at ');

+        $error = substr($error, 0, $at_pos);

+        $error =~ s/\s+$//;

+        

+        croak "$error$append";

+    }

+}

+

 1;

 =head1 NAME

@@ -1105,21 +1117,37 @@ You can custamize SQL builder object

 =head1 ATTRIBUTES

-=head2 C<user>

+=head2 C<cache>

-    my $user = $dbi->user;

-    $dbi     = $dbi->user('Ken');

+    my $cache = $dbi->cache;

+    $dbi      = $dbi->cache(1);

-User name.

-C<connect()> method use this value to connect the database.

-    

-=head2 C<password>

+Enable parsed L<DBIx::Custom::Query> object caching.

+Default to 1.

-    my $password = $dbi->password;

-    $dbi         = $dbi->password('lkj&le`@s');

+=head2 C<cache_method>

-Password.

-C<connect()> method use this value to connect the database.

+    $dbi          = $dbi->cache_method(\&cache_method);

+    $cache_method = $dbi->cache_method

+

+Method to set and get caches.

+

+B<Example:>

+

+    $dbi->cache_method(

+        sub {

+            my $self = shift;

+            

+            $self->{_cached} ||= {};

+            

+            if (@_ > 1) {

+                $self->{_cached}{$_[0]} = $_[1] 

+            }

+            else {

+                return $self->{_cached}{$_[0]}

+            }

+        }

+    );

 =head2 C<data_source>

@@ -1136,14 +1164,6 @@ C<connect()> method use this value to connect the database.

 L<DBI> object. You can call all methods of L<DBI>.

-=head2 C<filters>

-

-    my $filters = $dbi->filters;

-    $dbi        = $dbi->filters(\%filters);

-

-Filter functions.

-"encode_utf8" and "decode_utf8" is registered by default.

-

 =head2 C<default_bind_filter>

     my $default_bind_filter = $dbi->default_bind_filter

@@ -1158,13 +1178,31 @@ Default filter when parameter binding is executed.

 Default filter when row is fetched.

-=head2 C<result_class>

+=head2 C<filters>

-    my $result_class = $dbi->result_class;

-    $dbi             = $dbi->result_class('DBIx::Custom::Result');

+    my $filters = $dbi->filters;

+    $dbi        = $dbi->filters(\%filters);

-Result class for select statement.

-Default to L<DBIx::Custom::Result>.

+Filter functions.

+"encode_utf8" and "decode_utf8" is registered by default.

+

+=head2 C<filter_check>

+

+    my $filter_check = $dbi->filter_check;

+    $dbi             = $dbi->filter_check(0);

+

+Enable filter check. 

+Default to 1.

+This check maybe damege performance.

+If you require performance, set C<filter_check> attribute to 0.

+

+=head2 C<password>

+

+    my $password = $dbi->password;

+    $dbi         = $dbi->password('lkj&le`@s');

+

+Password.

+C<connect()> method use this value to connect the database.

 =head2 C<query_builder>

@@ -1175,53 +1213,44 @@ SQL builder. C<query_builder()> must be

 the instance of L<DBIx::Custom::QueryBuilder> subclass.

 Default to L<DBIx::Custom::QueryBuilder> object.

-=head2 C<cache>

-

-    my $cache = $dbi->cache;

-    $dbi      = $dbi->cache(1);

-

-Enable parsed L<DBIx::Custom::Query> object caching.

-Default to 1.

+=head2 C<result_class>

-=head2 C<cache_method>

+    my $result_class = $dbi->result_class;

+    $dbi             = $dbi->result_class('DBIx::Custom::Result');

-    $dbi          = $dbi->cache_method(\&cache_method);

-    $cache_method = $dbi->cache_method

+Result class for select statement.

+Default to L<DBIx::Custom::Result>.

-Method to set and get caches.

+=head2 C<user>

-B<Example:>

+    my $user = $dbi->user;

+    $dbi     = $dbi->user('Ken');

-    $dbi->cache_method(

-        sub {

-            my $self = shift;

-            

-            $self->{_cached} ||= {};

-            

-            if (@_ > 1) {

-                $self->{_cached}{$_[0]} = $_[1] 

-            }

-            else {

-                return $self->{_cached}{$_[0]}

-            }

-        }

-    );

+User name.

+C<connect()> method use this value to connect the database.

+    

+=head1 METHODS

-=head2 C<filter_check>

+L<DBIx::Custom> inherits all methods from L<Object::Simple>

+and implements the following new ones.

-    my $filter_check = $dbi->filter_check;

-    $dbi             = $dbi->filter_check(0);

+=head2 begin_work

-Enable filter check. 

-Default to 1.

-This check maybe damege performance.

-If you require performance, set C<filter_check> attribute to 0.

+    $dbi->begin_work;

-=head1 METHODS

+Start transaction.

+This is same as L<DBI>'s C<begin_work>.

 L<DBIx::Custom> inherits all methods from L<Object::Simple>

 and implements the following new ones.

+=head2 commit

+

+    $dbi->commit;

+

+Commit transaction.

+This is same as L<DBI>'s C<commit>.

+

 =head2 C<connect>

     my $dbi = DBIx::Custom->connect(data_source => "dbi:mysql:database=dbname",

@@ -1232,74 +1261,40 @@ L<DBIx::Custom> is a wrapper of L<DBI>.

 C<AutoCommit> and C<RaiseError> options are true, 

 and C<PrintError> option is false by default. 

-=head2 C<insert>

-

-    $dbi->insert(table  => $table, 

-                 param  => \%param,

-                 append => $append,

-                 filter => \%filter);

-

-Execute insert statement.

-C<insert> method have C<table>, C<param>, C<append>

-and C<filter> arguments.

-C<table> is a table name.

-C<param> is the pairs of column name value. this must be hash reference.

-C<append> is a string added at the end of the SQL statement.

-C<filter> is filters when parameter binding is executed.

-This is overwrites C<default_bind_filter>.

-Return value of C<insert()> is the count of affected rows.

-

-B<Example:>

-

-    $dbi->insert(table  => 'books', 

-                 param  => {title => 'Perl', author => 'Taro'},

-                 append => "some statement",

-                 filter => {title => 'encode_utf8'})

-

-=head2 C<update>

-

-    $dbi->update(table  => $table, 

-                 param  => \%params,

-                 where  => \%where,

-                 append => $append,

-                 filter => \%filter)

-

-Execute update statement.

-C<update> method have C<table>, C<param>, C<where>, C<append>

-and C<filter> arguments.

-C<table> is a table name.

-C<param> is column-value pairs. this must be hash reference.

-C<where> is where clause. this must be hash reference.

-C<append> is a string added at the end of the SQL statement.

-C<filter> is filters when parameter binding is executed.

-This is overwrites C<default_bind_filter>.

-Return value of C<update()> is the count of affected rows.

+=head2 C<create_query>

+    

+    my $query = $dbi->create_query(

+        "select * from books where {= author} and {like title};"

+    );

-B<Example:>

+Create the instance of L<DBIx::Custom::Query> from the source of SQL.

+If you want to get high performance,

+use C<create_query()> method and execute it by C<execute()> method

+instead of suger methods.

-    $dbi->update(table  => 'books',

-                 param  => {title => 'Perl', author => 'Taro'},

-                 where  => {id => 5},

-                 append => "some statement",

-                 filter => {title => 'encode_utf8'});

+    $dbi->execute($query, {author => 'Ken', title => '%Perl%'});

-=head2 C<update_all>

+=head2 C<execute>

-    $dbi->update_all(table  => $table, 

-                     param  => \%params,

-                     filter => \%filter,

-                     append => $append);

+    my $result = $dbi->execute($query,  param => $params, filter => \%filter);

+    my $result = $dbi->execute($source, param => $params, filter => \%filter);

-Execute update statement to update all rows.

-Arguments is same as C<update> method,

-except that C<update_all> don't have C<where> argument.

-Return value of C<update_all()> is the count of affected rows.

+Execute query or the source of SQL.

+Query is L<DBIx::Custom::Query> object.

+Return value is L<DBIx::Custom::Result> if select statement is executed,

+or the count of affected rows if insert, update, delete statement is executed.

 B<Example:>

-    $dbi->update_all(table  => 'books', 

-                     param  => {author => 'taro'},

-                     filter => {author => 'encode_utf8'});

+    my $result = $dbi->execute(

+        "select * from books where {= author} and {like title}", 

+        param => {author => 'Ken', title => '%Perl%'}

+    );

+    

+    while (my $row = $result->fetch) {

+        my $author = $row->[0];

+        my $title  = $row->[1];

+    }

 =head2 C<delete>

@@ -1336,6 +1331,90 @@ B<Example:>

     $dbi->delete_all(table => 'books');

+=head2 C<insert>

+

+    $dbi->insert(table  => $table, 

+                 param  => \%param,

+                 append => $append,

+                 filter => \%filter);

+

+Execute insert statement.

+C<insert> method have C<table>, C<param>, C<append>

+and C<filter> arguments.

+C<table> is a table name.

+C<param> is the pairs of column name value. this must be hash reference.

+C<append> is a string added at the end of the SQL statement.

+C<filter> is filters when parameter binding is executed.

+This is overwrites C<default_bind_filter>.

+Return value of C<insert()> is the count of affected rows.

+

+B<Example:>

+

+    $dbi->insert(table  => 'books', 

+                 param  => {title => 'Perl', author => 'Taro'},

+                 append => "some statement",

+                 filter => {title => 'encode_utf8'})

+

+=head2 C<register_filter>

+

+    $dbi->register_filter(%filters);

+    $dbi->register_filter(\%filters);

+    

+Register filter. Registered filters is available in the following attributes

+or arguments.

+

+=over 4

+

+=item *

+

+C<default_bind_filter>, C<default_fetch_filter>

+

+=item *

+

+C<filter> argument of C<insert()>, C<update()>,

+C<update_all()>, C<delete()>, C<delete_all()>, C<select()>

+methods

+

+=item *

+

+C<execute()> method

+

+=item *

+

+C<default_filter> and C<filter> of C<DBIx::Custom::Query>

+

+=item *

+

+C<default_filter> and C<filter> of C<DBIx::Custom::Result>

+

+=back

+

+B<Example:>

+

+    $dbi->register_filter(

+        encode_utf8 => sub {

+            my $value = shift;

+            

+            require Encode;

+            

+            return Encode::encode('UTF-8', $value);

+        },

+        decode_utf8 => sub {

+            my $value = shift;

+            

+            require Encode;

+            

+            return Encode::decode('UTF-8', $value)

+        }

+    );

+

+=head2 rollback

+

+    $dbi->rollback;

+

+Rollback transaction.

+This is same as L<DBI>'s C<rollback>.

+

 =head2 C<select>

     my $result = $dbi->select(table    => $table,

@@ -1391,93 +1470,50 @@ First element is a string. it contains tags,

 such as "{= title} or {like author}".

 Second element is paramters.

-=head2 C<create_query>

-    

-    my $query = $dbi->create_query(

-        "select * from books where {= author} and {like title};"

-    );

-

-Create the instance of L<DBIx::Custom::Query> from the source of SQL.

-If you want to get high performance,

-use C<create_query()> method and execute it by C<execute()> method

-instead of suger methods.

-

-    $dbi->execute($query, {author => 'Ken', title => '%Perl%'});

-

-=head2 C<execute>

+=head2 C<update>

-    my $result = $dbi->execute($query,  param => $params, filter => \%filter);

-    my $result = $dbi->execute($source, param => $params, filter => \%filter);

+    $dbi->update(table  => $table, 

+                 param  => \%params,

+                 where  => \%where,

+                 append => $append,

+                 filter => \%filter)

-Execute query or the source of SQL.

-Query is L<DBIx::Custom::Query> object.

-Return value is L<DBIx::Custom::Result> if select statement is executed,

-or the count of affected rows if insert, update, delete statement is executed.

+Execute update statement.

+C<update> method have C<table>, C<param>, C<where>, C<append>

+and C<filter> arguments.

+C<table> is a table name.

+C<param> is column-value pairs. this must be hash reference.

+C<where> is where clause. this must be hash reference.

+C<append> is a string added at the end of the SQL statement.

+C<filter> is filters when parameter binding is executed.

+This is overwrites C<default_bind_filter>.

+Return value of C<update()> is the count of affected rows.

 B<Example:>

-    my $result = $dbi->execute(

-        "select * from books where {= author} and {like title}", 

-        param => {author => 'Ken', title => '%Perl%'}

-    );

-    

-    while (my $row = $result->fetch) {

-        my $author = $row->[0];

-        my $title  = $row->[1];

-    }

-

-=head2 C<register_filter>

-

-    $dbi->register_filter(%filters);

-    $dbi->register_filter(\%filters);

-    

-Register filter. Registered filters is available in the following attributes

-or arguments.

-

-=over 4

-

-=item *

-

-C<default_bind_filter>, C<default_fetch_filter>

-

-=item *

-

-C<filter> argument of C<insert()>, C<update()>,

-C<update_all()>, C<delete()>, C<delete_all()>, C<select()>

-methods

-

-=item *

-

-C<execute()> method

-

-=item *

-

-C<default_filter> and C<filter> of C<DBIx::Custom::Query>

+    $dbi->update(table  => 'books',

+                 param  => {title => 'Perl', author => 'Taro'},

+                 where  => {id => 5},

+                 append => "some statement",

+                 filter => {title => 'encode_utf8'});

-=item *

+=head2 C<update_all>

-C<default_filter> and C<filter> of C<DBIx::Custom::Result>

+    $dbi->update_all(table  => $table, 

+                     param  => \%params,

+                     filter => \%filter,

+                     append => $append);

-=back

+Execute update statement to update all rows.

+Arguments is same as C<update> method,

+except that C<update_all> don't have C<where> argument.

+Return value of C<update_all()> is the count of affected rows.

 B<Example:>

-    $dbi->register_filter(

-        encode_utf8 => sub {

-            my $value = shift;

-            

-            require Encode;

-            

-            return Encode::encode('UTF-8', $value);

-        },

-        decode_utf8 => sub {

-            my $value = shift;

-            

-            require Encode;

-            

-            return Encode::decode('UTF-8', $value)

-        }

-    );

+    $dbi->update_all(table  => 'books', 

+                     param  => {author => 'taro'},

+                     filter => {author => 'encode_utf8'});

 =head1 STABILITY

@@ -5,7 +5,7 @@ use warnings;

 use base 'Object::Simple';

-__PACKAGE__->attr([qw/sql columns default_filter filter sth/]);

+__PACKAGE__->attr([qw/columns default_filter filter sql sth/]);

 1;

@@ -19,13 +19,6 @@ DBIx::Custom::Query - Query

 =head1 ATTRIBUTES

-=head2 C<sql>

-

-    my $sql = $query->sql;

-    $query  = $query->sql('select * from books where author = ?;');

-

-SQL statement.

-

 =head2 C<columns>

     my $columns = $query->columns;

@@ -49,6 +42,13 @@ Default filter when parameter binding is executed.

 Filters when parameter binding is executed.

 This overwrites C<default_filter>.

+=head2 C<sql>

+

+    my $sql = $query->sql;

+    $query  = $query->sql('select * from books where author = ?;');

+

+SQL statement.

+

 =head2 C<sth>

     my $sth = $query->sth;

@@ -12,7 +12,10 @@ use DBIx::Custom::QueryBuilder::TagProcessors;

 # Carp trust relationship

 push @DBIx::Custom::CARP_NOT, __PACKAGE__;

+# Attributes

 __PACKAGE__->dual_attr('tag_processors', default => sub { {} }, inherit => 'hash_copy');

+

+# Resister tag processor

 __PACKAGE__->register_tag_processor(

     '?'     => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_placeholder_tag,

     '='     => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_equal_tag,

@@ -27,6 +30,18 @@ __PACKAGE__->register_tag_processor(

     'update_param' => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_update_param_tag

 );

+sub build_query {

+    my ($self, $source)  = @_;

+    

+    # Parse

+    my $tree = $self->_parse($source);

+    

+    # Build query

+    my $query = $self->_build_query($tree);

+    

+    return $query;

+}

+

 sub register_tag_processor {

     my $self = shift;

@@ -37,14 +52,70 @@ sub register_tag_processor {

     return $self;

 }

-sub build_query {

-    my ($self, $source)  = @_;

+sub _build_query {

+    my ($self, $tree) = @_;

-    # Parse

-    my $tree = $self->_parse($source);

+    # SQL

+    my $sql = '';

-    # Build query

-    my $query = $self->_build_query($tree);

+    # All Columns

+    my $all_columns = [];

+    

+    # Build SQL 

+    foreach my $node (@$tree) {

+        

+        # Text

+        if ($node->{type} eq 'text') { $sql .= $node->{value} }

+        

+        # Tag

+        else {

+            

+            # Tag name

+            my $tag_name = $node->{tag_name};

+            

+            # Tag arguments

+            my $tag_args = $node->{tag_args};

+            

+            # Get tag processor

+            my $tag_processor = $self->tag_processors->{$tag_name};

+            

+            # Tag processor is not registered

+            croak qq{Tag "$tag_name" in "{a }" is not registered}

+              unless $tag_processor;

+            

+            # Tag processor not sub reference

+            croak qq{Tag processor "$tag_name" must be sub reference}

+              unless ref $tag_processor eq 'CODE';

+            

+            # Execute tag processor

+            my $r = $tag_processor->(@$tag_args);

+            

+            # Check tag processor return value

+            croak qq{Tag processor "$tag_name" must return [STRING, ARRAY_REFERENCE]}

+              unless ref $r eq 'ARRAY' && defined $r->[0] && ref $r->[1] eq 'ARRAY';

+            

+            # Part of SQL statement and colum names

+            my ($part, $columns) = @$r;

+            

+            # Add columns

+            push @$all_columns, @$columns;

+            

+            # Join part tag to SQL

+            $sql .= $part;

+        }

+    }

+

+    # Check placeholder count

+    my $placeholder_count = $self->_placeholder_count($sql);

+    my $column_count      = @$all_columns;

+    croak qq{Placeholder count in "$sql" must be same as column count $column_count}

+      unless $placeholder_count eq @$all_columns;

+    

+    # Add semicolon

+    $sql .= ';' unless $sql =~ /;$/;

+    

+    # Query

+    my $query = DBIx::Custom::Query->new(sql => $sql, columns => $all_columns);

     return $query;

 }

@@ -190,74 +261,6 @@ sub _parse {

     return \@tree;

 }

-sub _build_query {

-    my ($self, $tree) = @_;

-    

-    # SQL

-    my $sql = '';

-    

-    # All Columns

-    my $all_columns = [];

-    

-    # Build SQL 

-    foreach my $node (@$tree) {

-        

-        # Text

-        if ($node->{type} eq 'text') { $sql .= $node->{value} }

-        

-        # Tag

-        else {

-            

-            # Tag name

-            my $tag_name = $node->{tag_name};

-            

-            # Tag arguments

-            my $tag_args = $node->{tag_args};

-            

-            # Get tag processor

-            my $tag_processor = $self->tag_processors->{$tag_name};

-            

-            # Tag processor is not registered

-            croak qq{Tag "$tag_name" in "{a }" is not registered}

-              unless $tag_processor;

-            

-            # Tag processor not sub reference

-            croak qq{Tag processor "$tag_name" must be sub reference}

-              unless ref $tag_processor eq 'CODE';

-            

-            # Execute tag processor

-            my $r = $tag_processor->(@$tag_args);

-            

-            # Check tag processor return value

-            croak qq{Tag processor "$tag_name" must return [STRING, ARRAY_REFERENCE]}

-              unless ref $r eq 'ARRAY' && defined $r->[0] && ref $r->[1] eq 'ARRAY';

-            

-            # Part of SQL statement and colum names

-            my ($part, $columns) = @$r;

-            

-            # Add columns

-            push @$all_columns, @$columns;

-            

-            # Join part tag to SQL

-            $sql .= $part;

-        }

-    }

-

-    # Check placeholder count

-    my $placeholder_count = $self->_placeholder_count($sql);

-    my $column_count      = @$all_columns;

-    croak qq{Placeholder count in "$sql" must be same as column count $column_count}

-      unless $placeholder_count eq @$all_columns;

-    

-    # Add semicolon

-    $sql .= ';' unless $sql =~ /;$/;

-    

-    # Query

-    my $query = DBIx::Custom::Query->new(sql => $sql, columns => $all_columns);

-    

-    return $query;

-}

-

 sub _placeholder_count {

     my ($self, $expand) = @_;

@@ -8,33 +8,9 @@ use Carp 'croak';

 # Carp trust relationship

 push @DBIx::Custom::QueryBuilder::CARP_NOT, __PACKAGE__;

-sub _expand_basic_tag {

-    my ($name, $column) = @_;

-    

-    # Check arguments

-    croak qq{Column name must be specified in tag "{$name }"}

-      unless $column;

-    

-    return ["$column $name ?", [$column]];

-}

-

 sub expand_equal_tag              { _expand_basic_tag('=',    @_) }

-sub expand_not_equal_tag          { _expand_basic_tag('<>',   @_) }

-sub expand_greater_than_tag       { _expand_basic_tag('>',    @_) }

-sub expand_lower_than_tag         { _expand_basic_tag('<',    @_) }

 sub expand_greater_than_equal_tag { _expand_basic_tag('>=',   @_) }

-sub expand_lower_than_equal_tag   { _expand_basic_tag('<=',   @_) }

-sub expand_like_tag               { _expand_basic_tag('like', @_) }

-

-sub expand_placeholder_tag {

-    my $column = shift;

-    

-    # Check arguments

-    croak qq{Column name must be specified in tag "{? }"}

-      unless $column;

-    

-    return ['?', [$column]];

-}

+sub expand_greater_than_tag       { _expand_basic_tag('>',    @_) }

 sub expand_in_tag {

     my ($column, $count) = @_;

@@ -74,6 +50,21 @@ sub expand_insert_param_tag {

     return [$s, \@columns];

 }

+sub expand_like_tag               { _expand_basic_tag('like', @_) }

+sub expand_lower_than_equal_tag   { _expand_basic_tag('<=',   @_) }

+sub expand_lower_than_tag         { _expand_basic_tag('<',    @_) }

+sub expand_not_equal_tag          { _expand_basic_tag('<>',   @_) }

+

+sub expand_placeholder_tag {

+    my $column = shift;

+    

+    # Check arguments

+    croak qq{Column name must be specified in tag "{? }"}

+      unless $column;

+    

+    return ['?', [$column]];

+}

+

 sub expand_update_param_tag {

     my @columns = @_;

@@ -85,6 +76,16 @@ sub expand_update_param_tag {

     return [$s, \@columns];

 }

+sub _expand_basic_tag {

+    my ($name, $column) = @_;

+    

+    # Check arguments

+    croak qq{Column name must be specified in tag "{$name }"}

+      unless $column;

+    

+    return ["$column $name ?", [$column]];

+}

+

 1;

 =head1 NAME

@@ -115,37 +116,29 @@ same as the count of column names.

         return [$s, $columns];

     }

-=head2 C<expand_placeholder_tag>

-

-    ('NAME')  ->  ['?', ['NAME']]

-

 =head2 C<expand_equal_tag>

     ('NAME')  ->  ['NAME = ?', ['NAME']]

-=head2 C<expand_not_equal_tag>

+=head2 C<expand_greater_than_equal_tag>

-    ('NAME')  ->  ['NAME <> ?', ['NAME']]

+    ('NAME')  ->  ['NAME >= ?', ['NAME']]

 =head2 C<expand_greater_than_tag>

     ('NAME')  ->  ['NAME > ?', ['NAME']]

-=head2 C<expand_lower_than_tag>

-

-    ('NAME')  ->  ['NAME < ?', ['NAME']]

-

-=head2 C<expand_greater_than_equal_tag>

+=head2 C<expand_like_tag>

-    ('NAME')  ->  ['NAME >= ?', ['NAME']]

+    ('NAME')  ->  ['NAME like ?', ['NAME']]

 =head2 C<expand_lower_than_equal_tag>

     ('NAME')  ->  ['NAME <= ?', ['NAME']]

-=head2 C<expand_like_tag>

+=head2 C<expand_lower_than_tag>

-    ('NAME')  ->  ['NAME like ?', ['NAME']]

+    ('NAME')  ->  ['NAME < ?', ['NAME']]

 =head2 C<expand_in_tag>

@@ -156,6 +149,14 @@ same as the count of column names.

     ('NAME1', 'NAME2')

       ->  ['(NAME1, NAME2) values (?, ?, ?)', ['NAME1', 'NAME2']]

+=head2 C<expand_not_equal_tag>

+

+    ('NAME')  ->  ['NAME <> ?', ['NAME']]

+

+=head2 C<expand_placeholder_tag>

+

+    ('NAME')  ->  ['?', ['NAME']]

+

 =head2 C<expand_update_param_tag>

     ('NAME1', 'NAME2')

@@ -7,7 +7,7 @@ use base 'Object::Simple';

 use Carp 'croak';

-__PACKAGE__->attr([qw/sth filters default_filter filter filter_check/]);

+__PACKAGE__->attr([qw/default_filter filter filter_check filters sth/]);

 sub fetch {

     my $self = shift;

@@ -45,6 +45,17 @@ sub fetch {

     return \@row;

 }

+sub fetch_all {

+    my $self = shift;

+    

+    # Fetch all rows

+    my $rows = [];

+    while(my $row = $self->fetch) {

+        push @$rows, $row;

+    }

+    return $rows;

+}

+

 sub fetch_first {

     my $self = shift;

@@ -60,36 +71,6 @@ sub fetch_first {

     return $row;

 }

-sub fetch_multi {

-    my ($self, $count) = @_;

-    

-    # Row count not specifed

-    croak 'Row count must be specified'

-      unless $count;

-    

-    # Fetch multi rows

-    my $rows = [];

-    for (my $i = 0; $i < $count; $i++) {

-        my $row = $self->fetch;

-        last unless $row;

-        push @$rows, $row;

-    }

-    

-    return unless @$rows;

-    return $rows;

-}

-

-sub fetch_all {

-    my $self = shift;

-    

-    # Fetch all rows

-    my $rows = [];

-    while(my $row = $self->fetch) {

-        push @$rows, $row;

-    }

-    return $rows;

-}

-

 sub fetch_hash {

     my $self = shift;

@@ -128,6 +109,18 @@ sub fetch_hash {

     return $row_hash;

 }

+sub fetch_hash_all {

+    my $self = shift;

+    

+    # Fetch all rows as hash

+    my $rows = [];

+    while(my $row = $self->fetch_hash) {

+        push @$rows, $row;

+    }

+    

+    return $rows;

+}

+

 sub fetch_hash_first {

     my $self = shift;

@@ -162,15 +155,22 @@ sub fetch_hash_multi {

     return $rows;

 }

-sub fetch_hash_all {

-    my $self = shift;

+sub fetch_multi {

+    my ($self, $count) = @_;

-    # Fetch all rows as hash

+    # Row count not specifed

+    croak 'Row count must be specified'

+      unless $count;

+    

+    # Fetch multi rows

     my $rows = [];

-    while(my $row = $self->fetch_hash) {

+    for (my $i = 0; $i < $count; $i++) {

+        my $row = $self->fetch;

+        last unless $row;

         push @$rows, $row;

     }

+    return unless @$rows;

     return $rows;

 }

@@ -261,13 +261,6 @@ Fetch row into hash.

 =head1 ATTRIBUTES

-=head2 C<sth>

-

-    my $sth = $reuslt->sth

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

-

-Statement handle of L<DBI>.

-

 =head2 C<default_filter>

     my $default_filter = $result->default_filter;

@@ -284,6 +277,27 @@ Default filter when a row is fetched.

 Filters when a row is fetched.

 This overwrites C<default_filter>.

+=head2 C<filters>

+

+    my $filters = $result->filters;

+    $result     = $result->filters(\%filters);

+

+Resistered filters.

+

+=head2 C<filter_check>

+

+    my $filter_check = $result->filter_check;

+    $result          = $result->filter_check;

+

+Enable filter validation.

+

+=head2 C<sth>

+

+    my $sth = $reuslt->sth

+    $result = $result->sth($sth);

+

+Statement handle of L<DBI>.

+

 =head1 METHODS