@@ -1,3 +1,22 @@

+0.1502

+  update document

+  moved host attribute to DBIx::Custom::MySQL

+  moved port attribute to DBIx::Custom::MySQL

+  moved database attribute to DBIx::Custom::MySQL and DBIx::Custom::SQLite

+  

+0.1501

+  removed register_format()

+  removed formats()

+  removed run_transaction()

+  removed create_table()

+  removed drop_table()

+  changed select() arguments

+  changed insert() arguments

+  changed update() arguments

+  changed update_all() arguments

+  changed delete() arguments

+  changed delete_all() arguments

+  changed execute() arguments

 0.1402

   remove finish(), error()

   can receive code ref to filter()

@@ -10,31 +10,23 @@ use DBI;

 use DBIx::Custom::Result;

 use DBIx::Custom::SQLTemplate;

 use DBIx::Custom::Query;

+use Encode qw/encode_utf8 decode_utf8/;

 __PACKAGE__->attr('dbh');

-__PACKAGE__->class_attr(_query_caches     => sub { {} });

-__PACKAGE__->class_attr(_query_cache_keys => sub { [] });

-

-__PACKAGE__->class_attr('query_cache_max', default => 50,

-                                           inherit => 'scalar_copy');

-

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

-__PACKAGE__->attr([qw/database host port/]);

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

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

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

                                   inherit => 'hash_copy');

 __PACKAGE__->register_filter(

-    encode_utf8 => sub { encode('UTF-8', $_[0]) },

-    decode_utf8 => sub { decode('UTF-8', $_[0]) }

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

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

 );

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

 __PACKAGE__->attr(sql_template => sub { DBIx::Custom::SQLTemplate->new });

-

-

 sub register_filter {

     my $invocant = shift;

@@ -71,7 +63,6 @@ sub connect {

     my $data_source = $self->data_source;

     my $user        = $self->user;

     my $password    = $self->password;

-    my $options     = $self->options;

     # Connect

     my $dbh = eval{DBI->connect(

@@ -82,7 +73,6 @@ sub connect {

             RaiseError => 1,

             PrintError => 0,

             AutoCommit => 1,

-            %{$options || {} }

         }

     )};

@@ -130,36 +120,28 @@ sub reconnect {

 sub create_query {

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

-    my $class = ref $self;

-    

-    if (ref $template eq 'ARRAY') {

-        $template = $template->[1];

-    }

-    

     # Create query from SQL template

     my $sql_template = $self->sql_template;

-    # Try to get cached query

-    my $cached_query = $class->_query_caches->{"$template"};

+    # Get cached query

+    my $cache = $self->{_cache}->{"$template"};

     # Create query

     my $query;

-    if ($cached_query) {

+    if ($cache) {

         $query = DBIx::Custom::Query->new(

-            sql       => $cached_query->sql,

-            columns => $cached_query->columns

+            sql       => $cache->sql,

+            columns   => $cache->columns

         );

     }

     else {

         $query = eval{$sql_template->create_query($template)};

         croak($@) if $@;

-        $class->_add_query_cache("$template", $query);

+        $self->{_cache}->{$template} = $query

+          unless $self->{_cache};

     }

-    # Connect if not

-    $self->connect unless $self->connected;

-    

     # Prepare statement handle

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

@@ -549,41 +531,17 @@ sub select {

     return $result;

 }

-sub _add_query_cache {

-    my ($class, $template, $query) = @_;

-    

-    # Query information

-    my $query_cache_keys = $class->_query_cache_keys;

-    my $query_caches     = $class->_query_caches;

-    

-    # Already cached

-    return $class if $query_caches->{$template};

-    

-    # Cache

-    $query_caches->{$template} = $query;

-    push @$query_cache_keys, $template;

-    

-    # Check cache overflow

-    my $overflow = @$query_cache_keys - $class->query_cache_max;

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

-        my $template = shift @$query_cache_keys;

-        delete $query_caches->{$template};

-    }

-    

-    return $class;

-}

-

 =head1 NAME

-DBIx::Custom - DBI with hash bind and filtering system 

+DBIx::Custom - DBI with hash parameter binding and filtering system

 =head1 VERSION

-Version 0.1501

+Version 0.1502

 =cut

-our $VERSION = '0.1501';

+our $VERSION = '0.1502';

 $VERSION = eval $VERSION;

 =head1 STATE

@@ -598,23 +556,23 @@ This module is not stable. Method name and functionality will be change.

     # Insert 

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

-                 param  => {title => 'perl', author => 'Ken'}

+                 param  => {title => 'perl', author => 'Ken'},

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

     # Update 

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

                  param  => {title => 'aaa', author => 'Ken'}, 

-                 where  => {id => 5}

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

+                 where  => {id => 5},

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

     # Update all

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

-                     param  => {title => 'aaa'}

+                     param  => {title => 'aaa'},

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

     # Delete

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

-                 where  => {author => 'Ken'}

+                 where  => {author => 'Ken'},

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

     # Delete all

@@ -625,13 +583,11 @@ This module is not stable. Method name and functionality will be change.

     # Select(more complex)

     my $result = $dbi->select(

-        'books',

-        {

-            columns => [qw/author title/],

-            where   => {author => 'Ken'},

-            append  => 'order by id limit 1',

-            filter  => {tilte => 'encode_utf8'}

-        }

+        table  => 'books',

+        column => [qw/author title/],

+        where  => {author => 'Ken'},

+        append => 'order by id limit 1',

+        filter => {tilte => 'encode_utf8'}

     );

     # Execute SQL

@@ -656,157 +612,87 @@ This module is not stable. Method name and functionality will be change.

     }

+    # DBI instance

+    my $dbh = $dbi->dbh;

 =head1 ATTRIBUTES

 =head2 user

-Database user name

+Database user name.

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

     $user = $dbi->user;

 =head2 password

-Database password

+Database password.

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

     $password = $dbi->password;

 =head2 data_source

-Database data source

+Database data source.

     $dbi         = $dbi->data_source("dbi:mysql:dbname=$database");

     $data_source = $dbi->data_source;

 If you know data source more, See also L<DBI>.

-=head2 database

-

-Database name

-

-    $dbi      = $dbi->database('books');

-    $database = $dbi->database;

-

-=head2 host

-

-Host name

-

-    $dbi  = $dbi->host('somehost.com');

-    $host = $dbi->host;

-

-You can also set IP address like '127.03.45.12'.

-

-=head2 port

-

-Port number

-

-    $dbi  = $dbi->port(1198);

-    $port = $dbi->port;

-

-=head2 options

-

-DBI options

-

-    $dbi     = $dbi->options({PrintError => 0, RaiseError => 1});

-    $options = $dbi->options;

-

 =head2 sql_template

-SQLTemplate object

+SQLTemplate instance. sql_template attribute must be 

+the instance of L<DBIx::Cutom::SQLTemplate> subclass.

     $dbi          = $dbi->sql_template(DBIx::Cutom::SQLTemplate->new);

     $sql_template = $dbi->sql_template;

-See also L<DBIx::Custom::SQLTemplate>.

+the instance of DBIx::Cutom::SQLTemplate is set to 

+this attribute by default.

 =head2 filters

 Filters

-    $dbi     = $dbi->filters({filter1 => sub { }, filter2 => sub {}});

+    $dbi     = $dbi->filters({%filters});

     $filters = $dbi->filters;

-    

-This method is generally used to get a filter.

-    $filter = $dbi->filters->{encode_utf8};

+encode_utf8 and decode_utf8 is set to this attribute by default.

-If you add filter, use register_filter method.

+    $encode_utf8 = $dbi->filters->{encode_utf8};

+    $decode_utf8 = $dbi->filters->{decode_utf8};

 =head2 default_query_filter

-Default query filter

+Default query filter.

-    $dbi                  = $dbi->default_query_filter($default_query_filter);

+    $dbi                  = $dbi->default_query_filter('encode_utf8');

     $default_query_filter = $dbi->default_query_filter

-Query filter example

-    

-    $dbi->register_filter(encode_utf8 => sub {

-        my $value = shift;

-        

-        require Encode 'encode_utf8';

-        

-        return encode_utf8($value);

-    });

-    

-    $dbi->default_query_filter('encode_utf8')

-

-Bind filter arguemts is

-

-    1. $value : Value

-    3. $dbi   : DBIx::Custom instance

-

 =head2 default_fetch_filter

-Fetching filter

+Fetching filter.

-    $dbi                  = $dbi->default_fetch_filter($default_fetch_filter);

+    $dbi                  = $dbi->default_fetch_filter('decode_utf8');

     $default_fetch_filter = $dbi->default_fetch_filter;

-Fetch filter example

-

-    $dbi->register_filter(decode_utf8 => sub {

-        my $value = shift;

-        

-        require Encode 'decode_utf8';

-        

-        return decode_utf8($value);

-    });

-

-    $dbi->default_fetch_filter('decode_utf8');

-

-Fetching filter arguemts is

-

-    1. Value

-    2. DBIx::Custom instance

-

 =head2 result_class

-Resultset class

+Result class.

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

     $result_class = $dbi->result_class;

-Default is L<DBIx::Custom::Result>

+L<DBIx::Custom::Result> is set to this attribute by default.

 =head2 dbh

-Database handle

+Database handle.

     $dbi = $dbi->dbh($dbh);

     $dbh = $dbi->dbh;

-=head2 query_cache_max

-

-Query cache max

-

-    $class           = DBIx::Custom->query_cache_max(50);

-    $query_cache_max = DBIx::Custom->query_cache_max;

-

-Default value is 50

-

 =head1 METHODS

 This class is L<Object::Simple> subclass.

@@ -814,20 +700,29 @@ You can use all methods of L<Object::Simple>

 =head2 auto_commit

-Set and Get auto commit

+Auto commit.

-    $self        = $dbi->auto_commit($auto_commit);

+    $self        = $dbi->auto_commit(1);

     $auto_commit = $dbi->auto_commit;

-    

+

+This is equal to

+

+    $dbi->dbh->{AutoCommit} = 1;

+    $auto_commit = $dbi->dbh->{AutoCommit};

+

 =head2 connect

-Connect to database

+Connect to database.

+    

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

+                                    user => 'ken', password => '!LFKD%$&');

-    $dbi->connect;

+"AutoCommit" and "RaiseError" option is true, 

+and "PrintError" option is false by dfault.

 =head2 disconnect

-Disconnect database

+Disconnect database.

     $dbi->disconnect;

@@ -835,7 +730,7 @@ If database is already disconnected, this method do nothing.

 =head2 reconnect

-Reconnect to database

+Reconnect to database.

     $dbi->reconnect;

@@ -847,11 +742,11 @@ Check if database is connected.

 =head2 register_filter

-Resister filter

+Resister filter.

-    $dbi->register_filter($fname1 => $filter1, $fname => $filter2);

+    $dbi->register_filter(%filters);

-register_filter example

+Example.

     $dbi->register_filter(

         encode_utf8 => sub {

@@ -872,7 +767,7 @@ register_filter example

 =head2 create_query

-Create Query object parsing SQL template

+Create Query instance parsing SQL template

     my $query = $dbi->create_query("select * from authors where {= name} and {= age}");

@@ -1029,10 +924,6 @@ You can join multi tables

         "where table1.id = table2.id",       # join clause (must start 'where')

     );

-=head1 DBIx::Custom default configuration

-

-By default, "AutoCommit" and "RaiseError" is true.

-

 =head1 AUTHOR

 Yuki Kimoto, C<< <kimoto.yuki at gmail.com> >>

@@ -3,11 +3,17 @@ package DBIx::Custom::MySQL;

 use warnings;

 use strict;

-use base 'DBIx::Custom::Basic';

+use base 'DBIx::Custom';

+

 use Carp 'croak';

+__PACKAGE__->attr([qw/database host port/]);

+

 sub connect {

-    my $self = shift;

+    my $proto = shift;

+    

+    # Create

+    my $self = ref $proto ? $proto : $proto->new(@_);

     # Create data source

     if (!$self->data_source) {

@@ -15,11 +21,9 @@ sub connect {

         my $host     = $self->host;

         my $port     = $self->port;

         my $data_source = "dbi:mysql:";

-        my $data_source_original = $data_source;

         $data_source .= "database=$database;" if $database;

         $data_source .= "host=$host;"         if $host;

         $data_source .= "port=$port;"         if $port;

-        $data_source =~ s/:$// if $data_source eq $data_source_original;

         $self->data_source($data_source);

     }

@@ -42,38 +46,69 @@ sub last_insert_id {

 =head1 NAME

-DBIx::Custom::MySQL - DBIx::Custom MySQL implementation

+DBIx::Custom::MySQL - a MySQL implementation of DBIx::Custom

 =head1 SYNOPSYS

-    # New

-    my $dbi = DBIx::Custom::MySQL->new(user => 'taro', $password => 'kliej&@K',

-                                       database => 'sample_db');

+    # Connect

+    my $dbi = DBIx::Custom::MySQL->connect(user      => 'taro', 

+                                           password => 'kliej&@K',

+                                           database  => 'your_database');

+    

+    # Last insert id

+    my $id = $dbi->last_insert_id;

-=head1 METHODS

+=head1 ATTRIBUTES

-This class is L<DBIx::Custom::Basic> subclass.

-You can use all methods of L<DBIx::Custom::Basic>

+This class is L<DBIx::Custom> subclass.

+You can use all attributes of L<DBIx::Custom>

-=head2 connect

+=head2 database

-Connect to database

+Database name

-    $self->connect;

+    $dbi      = $dbi->database('your_database');

+    $database = $dbi->database;

-If you set database, host, or port, data source is automatically created.

+=head2 host

-=head2 last_insert_id

+Database host name.

-    $last_insert_id = $dbi->last_insert_id;

+    $dbi  = $dbi->host('somehost.com');

+    $host = $dbi->host;

+

+IP address can be set to host attribute.

+

+    $dbi->host('127.03.45.12');

+

+=head2 port

+

+Database port.

+

+    $dbi  = $dbi->port(1198);

+    $port = $dbi->port;

+

+=head1 METHODS

+

+This class is L<DBIx::Custom> subclass.

+You can use all methods of L<DBIx::Custom>.

+

+=head2 connect - overridden

+

+Connect to database.

+

+    # Connect

+    my $dbi = DBIx::Custom::MySQL->connect(user      => 'taro', 

+                                           password => 'kliej&@K',

+                                           database  => 'your_database');

+

+=head2 last_insert_id

-The folloing is last_insert_id sample.

+Last insert ID.

-    $dbi->insert('books', {title => 'Perl', author => 'taro'});

     $last_insert_id = $dbi->last_insert_id;

-This is equal to MySQL function

+This is equal to MySQL last_insert_id() function.

-    last_insert_id()

 =cut

@@ -11,60 +11,53 @@ __PACKAGE__->attr([qw/sql columns default_filter filter sth/]);

 =head1 NAME

-DBIx::Custom::Query - DBIx::Custom query

+DBIx::Custom::Query - query used by DBIx::Custom

 =head1 SYNOPSIS

     # New

     my $query = DBIx::Custom::Query->new;

-    # Create by using create_query

-    my $query = DBIx::Custom->create_query($template);

-    

 =head1 ATTRIBUTES

 =head2 sth

-Statement handle

+Statement handle.

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

     $sth   = $query->sth;

 =head2 sql

-SQL

+SQL statement.

     $query = $query->sql($sql);

     $sql   = $query->sql;

 =head2 default_filter

-Filter excuted when value is bind

+Default filter.

-    $query          = $query->default_filter($default_filter);

+    $query          = $query->default_filter($filter);

     $default_filter = $query->default_filter;

 =head2 filter

-Filter excuted when value is bind

+Filter.

-    $query  = $query->filter($filter);

+    $query  = $query->filter({%filter});

     $filter = $query->filter;

 =head2 columns

-Key informations

+Column names.

-    $query   = $query->columns($columns);

+    $query   = $query->columns([@columns]);

     $columns = $query->columns;

 =head1 METHODS

 This class is L<Object::Simple> subclass.

-You can use all methods of L<Object::Simple>

-

-=head2 new

-

-    my $query = DBIx::Custom::Query->new;

+You can use all methods of L<Object::Simple>.

 =cut

@@ -10,83 +10,59 @@ use Carp 'croak';

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

 sub fetch {

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

-    

-    my $sth     = $self->{sth};

-    my $filters = $self->{filters} || {};

-    my $filter  = $self->{filter} || {};

+

+    $_[0]->{filters} ||= {};

+    $_[0]->{filter}  ||= {};

     # Fetch

-    my $row = $sth->fetchrow_arrayref;

+    my @row = $_[0]->{sth}->fetchrow_array;

     # Cannot fetch

-    return unless $row;

+    return unless @row;

-    # Key

-    my $columns  = $sth->{NAME_lc};

-    

     # Filter

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

-        my $fname  = $filter->{$columns->[$i]} || $self->{default_filter} || '';

+    for (my $i = 0; $i < @{$_[0]->{sth}->{NAME_lc}}; $i++) {

+        my $fname  = $_[0]->{filter}->{$_[0]->{sth}->{NAME_lc}->[$i]} 

+                  || $_[0]->{default_filter};

+        

+        croak "Filter \"$fname\" is not registered."

+          if $fname && ! exists $_[0]->{filters}->{$fname};

-        if ($fname) {

-            my $filter;

-            

-            if (ref $fname) {

-                $filter = $fname;

-            }

-            else {

-                croak "Filter \"$fname\" is not registered."

-                  unless exists $filters->{$fname};

-                  

-                $filter = $filters->{$fname};

-            }

-            $row->[$i] = $filter->($row->[$i]);

-        }

+        next unless $fname;

+        

+        $row[$i] = ref $fname

+                   ? $fname->($row[$i]) 

+                   : $_[0]->{filters}->{$fname}->($row[$i]);

     }

-    return wantarray ? @$row : $row;

+    return wantarray ? @row : \@row;

 }

 sub fetch_hash {

-    my $self = shift;

-    my $sth            = $self->{sth};

-    my $filters        = $self->{filters} || {};

-    my $filter         = $self->{filter} || {};

+    $_[0]->{filters} ||= {};

+    $_[0]->{filter}  ||= {};

     # Fetch

-    my $row = $sth->fetchrow_arrayref;

+    my $row = $_[0]->{sth}->fetchrow_arrayref;

     # Cannot fetch

     return unless $row;

-    # Keys

-    my $columns  = $sth->{NAME_lc};

-    

     # Filter

     my $row_hash = {};

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

+    for (my $i = 0; $i < @{$_[0]->{sth}->{NAME_lc}}; $i++) {

+        

+        my $fname  = $_[0]->{filter}->{$_[0]->{sth}->{NAME_lc}->[$i]}

+                  || $_[0]->{default_filter};

-        my $fname  = $filter->{$columns->[$i]} || $self->{default_filter} || '';

+        croak "Filter \"$fname\" is not registered."

+          if $fname && ! exists $_[0]->{filters}->{$fname};

-        if ($fname) {

-            my $filter;

-            

-            if (ref $fname) {

-                $filter = $fname;

-            }

-            else {

-                croak "Filter \"$fname\" is not registered."

-                  unless exists $filters->{$fname};

-                  

-                $filter = $filters->{$fname};

-            }

-            $row_hash->{$columns->[$i]} = $filter->($row->[$i]);

-        }

-        else {

-            $row_hash->{$columns->[$i]} = $row->[$i];

-        }

+        $row_hash->{$_[0]->{sth}->{NAME_lc}->[$i]}

+          = !$fname    ? $row->[$i] :

+            ref $fname ? $fname->($row->[$i]) :

+            $_[0]->{filters}->{$fname}->($row->[$i]);

     }

     return wantarray ? %$row_hash : $row_hash;

@@ -3,11 +3,17 @@ package DBIx::Custom::SQLite;

 use strict;

 use warnings;

-use base 'DBIx::Custom::Basic';

+use base 'DBIx::Custom';

+

 use Carp 'croak';

+__PACKAGE__->attr('database');

+

 sub connect {

-    my $self = shift;

+    my $proto = shift;

+    

+    # Create

+    my $self = ref $proto ? $proto : $proto->new(@_);

     # Create data source

     if (!$self->data_source && (my $database = $self->database)) {

@@ -60,28 +66,46 @@ sub last_insert_rowid {

 =head1 NAME

-DBIx::Custom::SQLite - DBIx::Custom SQLite implementation

+DBIx::Custom::SQLite - a SQLite implementation of DBIx::Custom

 =head1 SYNOPSYS

     use DBIx::Custom::SQLite;

-    # New

-    my $dbi = DBIx::Custom::SQLite->new(user => 'taro', $password => 'kl&@K',

-                                        database => 'sample');

+    # Connect

+    my $dbi = DBIx::Custom::SQLite->connect(user      => 'taro', 

+                                            password => 'kl&@K',

+                                            database  => 'your_database');

     # Connect memory database

-    my $dbi->connect_memory;

+    my $dbi = DBIx::Custom::SQLite->connect_memory;

+    

+    # Reconnect memory database

+    $dbi->reconnect_memory;

+    

+    # Last insert row ID

+    my $id = $dbi->last_insert_rowid;

+=head1 ATTRIBUTES

+

+This class is L<DBIx::Custom> subclass.

+You can use all attributes of L<DBIx::Custom>.

+

+=head2 database

+

+Database name

+

+    $dbi      = $dbi->database('your_database');

+    $database = $dbi->database;

 =head1 METHODS

-This class is L<DBIx::Custom::Basic> subclass.

-You can use all methods of L<DBIx::Custom::Basic>

+This class is L<DBIx::Custom> subclass.

+You can use all methods of L<DBIx::Custom>.

-=head2 connect

+=head2 connect - overridden

-Connect to database

+Connect to database.

     $dbi->connect;

@@ -89,29 +113,22 @@ If you set database, host, or port, data source is automatically created.

 =head2 connect_memory

-Connect memory database

+Connect memory database.

     $dbi->connect_memory;

 =head2 reconnect_memory

-Reconnect to memory databsse

+Reconnect to memory databsse.

     $dbi->reconnect_memory;

 =head2 last_insert_rowid

-Get last insert id

+Last insert row ID.

     $last_insert_rowid = $dbi->last_insert_rowid;

-The folloing is last_insert_rowid sample.

-

-    $dbi->insert('books', {title => 'Perl', author => 'taro'});

-    $last_insert_rowid = $dbi->last_insert_rowid;

-

-This is equal to SQLite function

-

-    last_insert_rowid()

+This is equal to SQLite last_insert_rowid() function.

 =cut

@@ -1,10 +1,9 @@

 #!perl -T

-use Test::More tests => 7;

+use Test::More tests => 6;

 BEGIN {

 	use_ok( 'DBIx::Custom' );

-	use_ok( 'DBIx::Custom::Basic' );

 	use_ok( 'DBIx::Custom::MySQL' );

 	use_ok( 'DBIx::Custom::Query' );

 	use_ok( 'DBIx::Custom::Result' );

@@ -12,7 +12,7 @@ plan 'no_plan';

 use DBIx::Custom;

 use Scalar::Util 'blessed';

 {

-    my $dbi = DBIx::Custom->new(

+    my $dbi = DBIx::Custom->connect(

         user => $USER,

         password => $PASSWORD,

         data_source => "dbi:mysql:dbname=$DATABASE"

@@ -339,8 +339,6 @@ $dbi->delete(table => 'table1', where => {key1 => 1, key2 => 2});

 $rows = $dbi->select(table => 'table1')->fetch_hash_all;

 is_deeply($rows, [{key1 => 3, key2 => 4}], "$test : delete multi key");

-__END__

-

 test 'delete error';

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

 $dbi->execute($CREATE_TABLE->{0});

@@ -368,20 +366,20 @@ $rows = $dbi->select(table => 'table1')->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 2},

                   {key1 => 3, key2 => 4}], "$test : table");

-$rows = $dbi->select(table => 'table1', columns => ['key1'])->fetch_hash_all;

+$rows = $dbi->select(table => 'table1', column => ['key1'])->fetch_hash_all;

 is_deeply($rows, [{key1 => 1}, {key1 => 3}], "$test : table and columns and where key");

 $rows = $dbi->select(table => 'table1', where => {key1 => 1})->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 2}], "$test : table and columns and where key");

-$rows = $dbi->select(table => 'table1', columns => ['key1'], where => {key1 => 3})->fetch_hash_all;

+$rows = $dbi->select(table => 'table1', column => ['key1'], where => {key1 => 3})->fetch_hash_all;

 is_deeply($rows, [{key1 => 3}], "$test : table and columns and where key");

 $rows = $dbi->select(table => 'table1', append => "order by key1 desc limit 1")->fetch_hash_all;

 is_deeply($rows, [{key1 => 3, key2 => 4}], "$test : append statement");

 $dbi->register_filter(decrement => sub { $_[0] - 1 });

-$rows = $dbi->select(table => 'table1', {where => {key1 => 2}, filter => {key1 => 'decrement'})

+$rows = $dbi->select(table => 'table1', where => {key1 => 2}, filter => {key1 => 'decrement'})

             ->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 2}], "$test : filter");

@@ -389,57 +387,12 @@ $dbi->execute($CREATE_TABLE->{2});

 $dbi->insert(table => 'table2', param => {key1 => 1, key3 => 5});

 $rows = $dbi->select(

     table => [qw/table1 table2/],

-    columns => ['table1.key1 as table1_key1', 'table2.key1 as table2_key1', 'key2', 'key3'],

+    column => ['table1.key1 as table1_key1', 'table2.key1 as table2_key1', 'key2', 'key3'],

     where   => {'table1.key2' => 2},

     append  => "where table1.key1 = table2.key1"

 )->fetch_hash_all;

 is_deeply($rows, [{table1_key1 => 1, table2_key1 => 1, key2 => 2, key3 => 5}], "$test : join");

-test 'Cache';

-$dbi = DBIx::Custom->connect($NEW_ARGS->{0});

-DBIx::Custom->query_cache_max(2);

-$dbi->execute($CREATE_TABLE->{0});

-delete $DBIx::Custom::CLASS_ATTRS->{_query_caches};

-delete $DBIx::Custom::CLASS_ATTRS->{_query_cache_keys};

-$tmpls[0] = "insert into table1 {insert key1 key2}";

-$queries[0] = $dbi->create_query($tmpls[0]);

-is(DBIx::Custom->_query_caches->{$tmpls[0]}{sql}, $queries[0]->sql, "$test : sql first");

-is(DBIx::Custom->_query_caches->{$tmpls[0]}{columns}, $queries[0]->columns, "$test : columns first");

-is_deeply(DBIx::Custom->_query_cache_keys, [@tmpls], "$test : cache key first");

-

-$tmpls[1] = "select * from table1";

-$queries[1] = $dbi->create_query($tmpls[1]);

-is(DBIx::Custom->_query_caches->{$tmpls[0]}{sql}, $queries[0]->sql, "$test : sql first");

-is(DBIx::Custom->_query_caches->{$tmpls[0]}{columns}, $queries[0]->columns, "$test : columns first");

-is(DBIx::Custom->_query_caches->{$tmpls[1]}{sql}, $queries[1]->sql, "$test : sql second");

-is(DBIx::Custom->_query_caches->{$tmpls[1]}{columns}, $queries[1]->columns, "$test : columns second");

-is_deeply(DBIx::Custom->_query_cache_keys, [@tmpls], "$test : cache key second");

-

-$tmpls[2] = "select key1, key2 from table1";

-$queries[2] = $dbi->create_query($tmpls[2]);

-ok(!exists DBIx::Custom->_query_caches->{$tmpls[0]}, "$test : cache overflow deleted key");

-is(DBIx::Custom->_query_caches->{$tmpls[1]}{sql}, $queries[1]->sql, "$test : sql cache overflow deleted key");

-is(DBIx::Custom->_query_caches->{$tmpls[1]}{columns}, $queries[1]->columns, "$test : columns cache overflow deleted key");

-is(DBIx::Custom->_query_caches->{$tmpls[2]}{sql}, $queries[2]->sql, "$test : sql cache overflow deleted key");

-is(DBIx::Custom->_query_caches->{$tmpls[2]}{columns}, $queries[2]->columns, "$test : columns cache overflow deleted key");

-is_deeply(DBIx::Custom->_query_cache_keys, [@tmpls[1, 2]], "$test : cache key third");

-

-$queries[1] = $dbi->create_query($tmpls[1]);

-ok(!exists DBIx::Custom->_query_caches->{$tmpls[0]}, "$test : cache overflow deleted key");

-is(DBIx::Custom->_query_caches->{$tmpls[1]}{sql}, $queries[1]->sql, "$test : sql cache overflow deleted key");

-is_deeply(DBIx::Custom->_query_caches->{$tmpls[1]}{columns}, $queries[1]->columns, "$test : columns cache overflow deleted key");

-is(DBIx::Custom->_query_caches->{$tmpls[2]}{sql}, $queries[2]->sql, "$test : sql cache overflow deleted key");

-is_deeply(DBIx::Custom->_query_caches->{$tmpls[2]}{columns}, $queries[2]->columns, "$test : columns cache overflow deleted key");

-is_deeply(DBIx::Custom->_query_cache_keys, [@tmpls[1, 2]], "$test : cache key third");

-

-$query = $dbi->create_query($tmpls[0]);

-$query->filter('aaa');

-$query = $dbi->create_query($tmpls[0]);

-ok(!$query->filter, "$test : only cached sql and columns");

-$query->filter('bbb');

-$query = $dbi->create_query($tmpls[0]);

-ok(!$query->filter, "$test : only cached sql and columns");

-

 test 'fetch filter';

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

 $dbi->register_filter(

@@ -457,8 +410,8 @@ is_deeply($row, {key1 => 3, key2 => 4}, "$test: default_fetch_filter and filter"

 test 'filters';

 $dbi = DBIx::Custom->new;

-ok($dbi->filters->{decode_utf8}->(encode_utf8('あ')),

-   'あ', "$test : decode_utf8;);

+is($dbi->filters->{decode_utf8}->(encode_utf8('あ')),

+   'あ', "$test : decode_utf8");

 is($dbi->filters->{encode_utf8}->('あ'),

    encode_utf8('あ'), "$test : encode_utf8");

@@ -26,7 +26,6 @@ $dbi = DBIx::Custom->new(

     database => 'a',

     password => 'b',

     data_source => 'c',

-    options => {d => 1, e => 2},

     filters => {

         f => 3,

     },

@@ -36,7 +35,7 @@ $dbi = DBIx::Custom->new(

     sql_template => $SQL_TMPL->{0},

 );

 is_deeply($dbi,{user => 'a', database => 'a', password => 'b', data_source => 'c', 

-                options => {d => 1, e => 2}, filters => {f => 3}, default_bind_filter => 'f',

+                filters => {f => 3}, default_bind_filter => 'f',

                 default_fetch_filter => 'g', result_class => 'g',

                 sql_template => $SQL_TMPL->{0}}, $test);

 isa_ok($dbi, 'DBIx::Custom');

@@ -102,8 +101,3 @@ test 'register_filters';

 $dbi = DBIx::Custom->new;

 $dbi->register_filter(a => sub {1});

 is($dbi->filters->{a}->(), 1, $test);

-

-test 'Accessor';

-$dbi = DBIx::Custom->new;

-$dbi->options({opt1 => 1, opt2 => 2});

-is_deeply(scalar $dbi->options, {opt1 => 1, opt2 => 2}, "$test : options");

@@ -44,4 +44,9 @@ $dbi = $CLASS->new(user => $USER, password => $PASSWORD,

 $dbi->connect;

 is(ref $dbi->dbh, 'DBI::db', $test);

-

+test 'attributes';

+$dbi = DBIx::Custom::MySQL->new;

+$dbi->host('a');

+is($dbi->host, 'a', "$test: host");

+$dbi->port('b');

+is($dbi->port, 'b', "$test: port");

@@ -35,8 +35,7 @@ my $db_file;

 my $id;

 test 'connect_memory';

-$dbi = DBIx::Custom::SQLite->new;

-$dbi->connect_memory;

+$dbi = DBIx::Custom::SQLite->connect(database => ':memory:');

 $ret_val = $dbi->execute($CREATE_TABLE->{0});

 ok(defined $ret_val, $test);

 $dbi->insert(table => 'table1', param => {key1 => 'a', key2 => 2});