@@ -38,9 +38,9 @@ is($model->count, 2);

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

 $dbi->separator('-');

 $row = $model->select(

-    table => 'table1',

-    column => {table2 => [qw/key3/]},

-    join => ['left outer join table2 on table1.key1 = table2.key1']

+  table => 'table1',

+  column => {table2 => [qw/key3/]},

+  join => ['left outer join table2 on table1.key1 = table2.key1']

 )->one;

 is_deeply($row, {"table2-key3" => 2});

@@ -38,9 +38,9 @@ is($model->count, 2);

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

 $dbi->separator('-');

 $row = $model->select(

-    table => 'table1',

-    column => {table2 => [qw/key3/]},

-    join => ['left outer join table2 on table1.key1 = table2.key1']

+  table => 'table1',

+  column => {table2 => [qw/key3/]},

+  join => ['left outer join table2 on table1.key1 = table2.key1']

 )->one;

 is_deeply($row, {"table2-key3" => 2});

@@ -85,158 +85,158 @@ my $affected;

 require MyDBI1;

 {

-    package MyDBI4;

-

-    use strict;

-    use warnings;

-

-    use base 'DBIx::Custom';

-

-    sub connect {

-        my $self = shift->SUPER::connect(@_);

-        

-        $self->include_model(

-            MyModel2 => [

-                $table1,

-                {class => $table2, name => $table2}

-            ]

-        );

-    }

+  package MyDBI4;

-    package MyModel2::Base1;

+  use strict;

+  use warnings;

-    use strict;

-    use warnings;

+  use base 'DBIx::Custom';

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

+  sub connect {

+    my $self = shift->SUPER::connect(@_);

+    

+    $self->include_model(

+      MyModel2 => [

+          $table1,

+          {class => $table2, name => $table2}

+      ]

+    );

+  }

-    package MyModel2::table1;

+  package MyModel2::Base1;

-    use strict;

-    use warnings;

+  use strict;

+  use warnings;

-    use base 'MyModel2::Base1';

+  use base 'DBIx::Custom::Model';

-    sub insert {

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

-        

-        return $self->SUPER::insert($param);

-    }

+  package MyModel2::table1;

-    sub list { shift->select; }

+  use strict;

+  use warnings;

-    package MyModel2::table2;

+  use base 'MyModel2::Base1';

-    use strict;

-    use warnings;

+  sub insert {

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

+    

+    return $self->SUPER::insert($param);

+  }

-    use base 'MyModel2::Base1';

+  sub list { shift->select; }

-    sub insert {

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

-        

-        return $self->SUPER::insert($param);

-    }

+  package MyModel2::table2;

-    sub list { shift->select; }

+  use strict;

+  use warnings;

-    package MyModel2::TABLE1;

+  use base 'MyModel2::Base1';

-    use strict;

-    use warnings;

+  sub insert {

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

+    

+    return $self->SUPER::insert($param);

+  }

-    use base 'MyModel2::Base1';

+  sub list { shift->select; }

-    sub insert {

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

-        

-        return $self->SUPER::insert($param);

-    }

+  package MyModel2::TABLE1;

-    sub list { shift->select; }

+  use strict;

+  use warnings;

-    package MyModel2::TABLE2;

+  use base 'MyModel2::Base1';

-    use strict;

-    use warnings;

+  sub insert {

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

+    

+    return $self->SUPER::insert($param);

+  }

-    use base 'MyModel2::Base1';

+  sub list { shift->select; }

-    sub insert {

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

-        

-        return $self->SUPER::insert($param);

-    }

+  package MyModel2::TABLE2;

-    sub list { shift->select; }

+  use strict;

+  use warnings;

+

+  use base 'MyModel2::Base1';

+

+  sub insert {

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

+    

+    return $self->SUPER::insert($param);

+  }

+

+  sub list { shift->select; }

 }

 {

-     package MyDBI5;

+   package MyDBI5;

-    use strict;

-    use warnings;

+  use strict;

+  use warnings;

-    use base 'DBIx::Custom';

+  use base 'DBIx::Custom';

-    sub connect {

-        my $self = shift->SUPER::connect(@_);

-        

-        $self->include_model('MyModel4');

-    }

+  sub connect {

+    my $self = shift->SUPER::connect(@_);

+    

+    $self->include_model('MyModel4');

+  }

 }

 {

-    package MyDBI6;

+  package MyDBI6;

+  

+  use base 'DBIx::Custom';

+  

+  sub connect {

+    my $self = shift->SUPER::connect(@_);

-    use base 'DBIx::Custom';

+    $self->include_model('MyModel5');

-    sub connect {

-        my $self = shift->SUPER::connect(@_);

-        

-        $self->include_model('MyModel5');

-        

-        return $self;

-    }

+    return $self;

+  }

 }

 {

-    package MyDBI7;

+  package MyDBI7;

+  

+  use base 'DBIx::Custom';

+  

+  sub connect {

+    my $self = shift->SUPER::connect(@_);

-    use base 'DBIx::Custom';

+    $self->include_model('MyModel6');

-    sub connect {

-        my $self = shift->SUPER::connect(@_);

-        

-        $self->include_model('MyModel6');

-        

-        

-        return $self;

-    }

+    

+    return $self;

+  }

 }

 {

-    package MyDBI8;

+  package MyDBI8;

+  

+  use base 'DBIx::Custom';

+  

+  sub connect {

+    my $self = shift->SUPER::connect(@_);

-    use base 'DBIx::Custom';

+    $self->include_model('MyModel7');

-    sub connect {

-        my $self = shift->SUPER::connect(@_);

-        

-        $self->include_model('MyModel7');

-        

-        return $self;

-    }

+    return $self;

+  }

 }

 {

-    package MyDBI9;

+  package MyDBI9;

+  

+  use base 'DBIx::Custom';

+  

+  sub connect {

+    my $self = shift->SUPER::connect(@_);

-    use base 'DBIx::Custom';

+    $self->include_model('MyModel8');

-    sub connect {

-        my $self = shift->SUPER::connect(@_);

-        

-        $self->include_model('MyModel8');

-        

-        return $self;

-    }

+    return $self;

+  }

 }

 test 'execute reuse option';

@@ -244,7 +244,7 @@ eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $reuse = {};

 for my $i (1 .. 2) {

-  $dbi->insert({$key1 => 1, $key2 => 2}, table => $table1, reuse => $reuse);

+$dbi->insert({$key1 => 1, $key2 => 2}, table => $table1, reuse => $reuse);

 }

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

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

@@ -285,14 +285,14 @@ $result = $dbi->execute($query);

 @rows = ();

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

-    push @rows, [@$row];

+  push @rows, [@$row];

 }

 is_deeply(\@rows, [[1, 2], [3, 4]], "fetch");

 $result = $dbi->execute($query);

 @rows = ();

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

-    push @rows, {%$row};

+  push @rows, {%$row};

 }

 is_deeply(\@rows, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}], "fetch_hash");

@@ -325,8 +325,8 @@ is_deeply($rows, [{$key1 => 1, $key2 => 2}]);

 test 'Filter basic';

 $dbi->delete_all(table => $table1);

-$dbi->register_filter(twice       => sub { $_[0] * 2}, 

-                    three_times => sub { $_[0] * 3});

+$dbi->register_filter(twice => sub { $_[0] * 2}, 

+  three_times => sub { $_[0] * 3});

 $insert_source  = "insert into $table1 {insert_param $key1 $key2}";

 $insert_query = $dbi->execute($insert_source, {}, query => 1);

@@ -405,7 +405,7 @@ $dbi->execute($update_source, {$key1 => 1, $key2 => 1, $key3 => 1, $key4 => 1, $

 $result = $dbi->execute("select * from $table1 order by $key1");

 $rows = $result->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 1, $key3 => 1, $key4 => 1, $key5 => 5},

-                  {$key1 => 6, $key2 => 7, $key3 => 8, $key4 => 9, $key5 => 10}], "basic");

+                {$key1 => 6, $key2 => 7, $key3 => 8, $key4 => 9, $key5 => 10}], "basic");

 test 'Named placeholder';

 eval { $dbi->execute("drop table $table1") };

@@ -430,9 +430,9 @@ is_deeply($rows, [{$key1 => 1, $key2 => 2, $key3 => 3, $key4 => 4, $key5 => 5}])

 $source = "select * from $table1 where $key1 = :$table1.$key1 and $key2 = :$table1.$key2";

 $result = $dbi->execute(

-    $source,

-    {"$table1.$key1" => 1, "$table1.$key2" => 1},

-    filter => {"$table1.$key2" => sub { $_[0] * 2 }}

+  $source,

+  {"$table1.$key1" => 1, "$table1.$key2" => 1},

+  filter => {"$table1.$key2" => sub { $_[0] * 2 }}

 );

 $rows = $result->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 2, $key3 => 3, $key4 => 4, $key5 => 5}]);

@@ -442,8 +442,8 @@ $dbi->execute($create_table1);

 $dbi->insert({$key1 => '2011-10-14 12:19:18', $key2 => 2}, table => $table1);

 $source = "select * from $table1 where $key1 = '2011-10-14 12:19:18' and $key2 = :$key2";

 $result = $dbi->execute(

-    $source,

-    {$key2 => 2},

+  $source,

+  {$key2 => 2},

 );

 $rows = $result->all;

@@ -454,8 +454,8 @@ $dbi->delete_all(table => $table1);

 $dbi->insert({$key1 => 'a:b c:d', $key2 => 2}, table => $table1);

 $source = "select * from $table1 where $key1 = 'a\\:b c\\:d' and $key2 = :$key2";

 $result = $dbi->execute(

-    $source,

-    {$key2 => 2},

+  $source,

+  {$key2 => 2},

 );

 $rows = $result->all;

 is_deeply($rows, [{$key1 => 'a:b c:d', $key2 => 2}]);

@@ -486,8 +486,8 @@ is_deeply($rows, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}], "basic");

 $dbi->execute("delete from $table1");

 $dbi->register_filter(

-    twice       => sub { $_[0] * 2 },

-    three_times => sub { $_[0] * 3 }

+  twice       => sub { $_[0] * 2 },

+  three_times => sub { $_[0] * 3 }

 );

 $dbi->default_bind_filter('twice');

 $dbi->insert({$key1 => 1, $key2 => 2}, table => $table1, filter => {$key1 => 'three_times'});

@@ -538,7 +538,7 @@ is_deeply($rows, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}], "basic");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->insert({$key1 => 1, $key2 => 2}, table => $table1,

-  wrap => {$key1 => sub { "$_[0] - 1" }});

+wrap => {$key1 => sub { "$_[0] - 1" }});

 $dbi->insert({$key1 => 3, $key2 => 4}, table => $table1);

 $result = $dbi->execute("select * from $table1");

 $rows   = $result->all;

@@ -547,7 +547,7 @@ is_deeply($rows, [{$key1 => 0, $key2 => 2}, {$key1 => 3, $key2 => 4}], "basic");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->insert_timestamp(

-    $key1 => '5'

+  $key1 => '5'

 );

 $dbi->insert({$key2 => 2}, table => $table1, timestamp => 1);

 $result = $dbi->execute("select * from $table1");

@@ -557,7 +557,7 @@ is_deeply($rows, [{$key1 => 5, $key2 => 2}], "basic");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->insert_timestamp(

-    [$key1, $key2] => sub { 5 }

+  [$key1, $key2] => sub { 5 }

 );

 $dbi->insert(table => $table1, timestamp => 1);

 $result = $dbi->execute("select * from $table1");

@@ -567,7 +567,7 @@ is_deeply($rows, [{$key1 => 5, $key2 => 5}], "basic");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->insert_timestamp(

-    [$key1, $key2] => sub { "" . DBIx::Custom->new }

+  [$key1, $key2] => sub { "" . DBIx::Custom->new }

 );

 $dbi->insert(table => $table1, timestamp => 1);

 $result = $dbi->execute("select * from $table1");

@@ -651,9 +651,9 @@ is_deeply($rows, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}], "basic");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1_2);

 $dbi->insert([{$key1 => 1}, {$key1 => 3}] ,

-  table => $table1,

-  updated_at => $key2,

-  created_at => $key3

+table => $table1,

+updated_at => $key2,

+created_at => $key3

 );

 $result = $dbi->execute("select * from $table1");

 $rows   = $result->all;

@@ -667,7 +667,7 @@ like($rows->[1]->{$key3}, qr/\d{2}:/);

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->insert([{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}] ,

-  table => $table1, filter => {$key1 => sub { $_[0] * 2 }});

+table => $table1, filter => {$key1 => sub { $_[0] * 2 }});

 $result = $dbi->execute("select * from $table1");

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 2, $key2 => 2}, {$key1 => 6, $key2 => 4}], "basic");

@@ -676,61 +676,61 @@ test 'update_or_insert';

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->update_or_insert(

-    {$key2 => 2},

-    table => $table1,

-    primary_key => $key1,

-    id => 1

+  {$key2 => 2},

+  table => $table1,

+  primary_key => $key1,

+  id => 1

 );

 $row = $dbi->select(id => 1, table => $table1, primary_key => $key1)->one;

 is_deeply($row, {$key1 => 1, $key2 => 2}, "basic");

 $dbi->update_or_insert(

-    {$key2 => 3},

-    table => $table1,

-    primary_key => $key1,

-    id => 1

+  {$key2 => 3},

+  table => $table1,

+  primary_key => $key1,

+  id => 1

 );

 $rows = $dbi->select(id => 1, table => $table1, primary_key => $key1)->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 3}], "basic");

 eval {

-    $dbi->update_or_insert(

-        {$key2 => 3},

-        table => $table1,

-    );

+  $dbi->update_or_insert(

+    {$key2 => 3},

+    table => $table1,

+  );

 };

 like($@, qr/primary_key/);

 eval {

-    $dbi->insert({$key1 => 1}, table => $table1);

-    $dbi->update_or_insert(

-        {$key2 => 3},

-        table => $table1,

-        primary_key => $key1,

-        id => 1

-    );

+  $dbi->insert({$key1 => 1}, table => $table1);

+  $dbi->update_or_insert(

+    {$key2 => 3},

+    table => $table1,

+    primary_key => $key1,

+    id => 1

+  );

 };

 like($@, qr/one/);

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->update_or_insert(

-    {},

-    table => $table1,

-    primary_key => $key1,

-    id => 1

+  {},

+  table => $table1,

+  primary_key => $key1,

+  id => 1

 );

 $row = $dbi->select(id => 1, table => $table1, primary_key => $key1)->one;

 is($row->{$key1}, 1);

 eval { 

-    $affected = $dbi->update_or_insert(

-        {},

-        table => $table1,

-        primary_key => $key1,

-        id => 1

-    );

+  $affected = $dbi->update_or_insert(

+    {},

+    table => $table1,

+    primary_key => $key1,

+    id => 1

+  );

 };

 is($affected, 0);

@@ -738,27 +738,27 @@ test 'model update_or_insert';

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $model = $dbi->create_model(

-    table => $table1,

-    primary_key => $key1

+  table => $table1,

+  primary_key => $key1

 );

 $model->update_or_insert({$key2 => 2}, id => 1);

 $row = $model->select(id => 1)->one;

 is_deeply($row, {$key1 => 1, $key2 => 2}, "basic");

 eval {

-    $model->insert({$key1 => 1});

-    $model->update_or_insert(

-        {$key2 => 3},

-        id => 1

-    );

+  $model->insert({$key1 => 1});

+  $model->update_or_insert(

+    {$key2 => 3},

+    id => 1

+  );

 };

 like($@, qr/one/);

 test 'default_bind_filter';

 $dbi->execute("delete from $table1");

 $dbi->register_filter(

-    twice       => sub { $_[0] * 2 },

-    three_times => sub { $_[0] * 3 }

+  twice       => sub { $_[0] * 2 },

+  three_times => sub { $_[0] * 3 }

 );

 $dbi->default_bind_filter('twice');

 $dbi->insert({$key1 => 1, $key2 => 2}, table => $table1, filter => {$key1 => 'three_times'});

@@ -776,8 +776,8 @@ $dbi->update({$key2 => 11}, table => $table1, where => {$key1 => 1});

 $result = $dbi->execute("select * from $table1 order by $key1");

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 11, $key3 => 3, $key4 => 4, $key5 => 5},

-                  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

-                  "basic");

+  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

+  "basic");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1_2);

@@ -787,9 +787,9 @@ $dbi->update(param => {$key2 => 11}, table => $table1, where => {$key1 => 1});

 $result = $dbi->execute("select * from $table1 order by $key1");

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 11, $key3 => 3, $key4 => 4, $key5 => 5},

-                  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

-                  "basic");

-                  

+  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

+  "basic");

+                

 $dbi->execute("delete from $table1");

 $dbi->insert({$key1 => 1, $key2 => 2, $key3 => 3, $key4 => 4, $key5 => 5}, table => $table1);

 $dbi->insert({$key1 => 6, $key2 => 7, $key3 => 8, $key4 => 9, $key5 => 10}, table => $table1);

@@ -797,27 +797,27 @@ $dbi->update({$key2 => 12}, table => $table1, where => {$key2 => 2, $key3 => 3})

 $result = $dbi->execute("select * from $table1 order by $key1");

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 12, $key3 => 3, $key4 => 4, $key5 => 5},

-                  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

-                  "update key same as search key");

+  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

+  "update key same as search key");

 $dbi->update({$key2 => [12]}, table => $table1, where => {$key2 => 2, $key3 => 3});

 $result = $dbi->execute("select * from $table1 order by $key1");

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 12, $key3 => 3, $key4 => 4, $key5 => 5},

-                  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

-                  "update key same as search key : param is array ref");

+  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

+  "update key same as search key : param is array ref");

 $dbi->execute("delete from $table1");

 $dbi->insert({$key1 => 1, $key2 => 2, $key3 => 3, $key4 => 4, $key5 => 5}, table => $table1);

 $dbi->insert({$key1 => 6, $key2 => 7, $key3 => 8, $key4 => 9, $key5 => 10}, table => $table1);

 $dbi->register_filter(twice => sub { $_[0] * 2 });

 $dbi->update({$key2 => 11}, table => $table1, where => {$key1 => 1},

-              filter => {$key2 => sub { $_[0] * 2 }});

+            filter => {$key2 => sub { $_[0] * 2 }});

 $result = $dbi->execute("select * from $table1 order by $key1");

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 22, $key3 => 3, $key4 => 4, $key5 => 5},

-                  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

-                  "filter");

+  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

+  "filter");

 $result = $dbi->update({$key2 => 11}, table => $table1, where => {$key1 => 1}, append => '   ');

@@ -838,12 +838,12 @@ eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

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

 $dbi->update(

-    {$key1 => 3},

-    table => $table1,

-    where => [

-        ['and', "$key1 = :$key1", "$key2 = :$key2"],

-        {$key1 => 1, $key2 => 2}

-    ]

+  {$key1 => 3},

+  table => $table1,

+  where => [

+    ['and', "$key1 = :$key1", "$key2 = :$key2"],

+    {$key1 => 1, $key2 => 2}

+  ]

 );

 $result = $dbi->select(table => $table1);

 is_deeply($result->all, [{$key1 => 3, $key2 => 2}], 'update() where');

@@ -896,8 +896,8 @@ $dbi->update({$key2 => 11}, table => $table1, where => {$key1 => 1});

 $result = $dbi->execute("select * from $table1 order by $key1");

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 11, $key3 => 3, $key4 => 4, $key5 => 5},

-                  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

-                  "basic");

+  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

+  "basic");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1_2);

@@ -908,8 +908,8 @@ wrap => {$key2 => sub { "$_[0] - 1" }});

 $result = $dbi->execute("select * from $table1 order by $key1");

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 10, $key3 => 3, $key4 => 4, $key5 => 5},

-                  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

-                  "basic");

+  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

+  "basic");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1_2);

@@ -919,13 +919,13 @@ $dbi->update({$key2 => \"'11'"}, table => $table1, where => {$key1 => 1});

 $result = $dbi->execute("select * from $table1 order by $key1");

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 11, $key3 => 3, $key4 => 4, $key5 => 5},

-                  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

-                  "basic");

+  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

+  "basic");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->update_timestamp(

-    $key1 => '5'

+  $key1 => '5'

 );

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

 $dbi->update(table => $table1, timestamp => 1, where => {$key2 => 2});

@@ -936,7 +936,7 @@ is_deeply($rows, [{$key1 => 5, $key2 => 2}], "basic");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->update_timestamp(

-    [$key1, $key2] => sub { '5' }

+  [$key1, $key2] => sub { '5' }

 );

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

 $dbi->update_all(table => $table1, timestamp => 1);

@@ -947,7 +947,7 @@ is_deeply($rows, [{$key1 => 5, $key2 => 5}], "basic");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->update_timestamp(

-    [$key1, $key2] => sub { "" . DBIx::Custom->new }

+  [$key1, $key2] => sub { "" . DBIx::Custom->new }

 );

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

 $dbi->update_all(table => $table1, timestamp => 1);

@@ -965,8 +965,8 @@ is_deeply($param, {$key2 => 11});

 $result = $dbi->execute("select * from $table1 order by $key1");

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 11, $key3 => 3, $key4 => 4, $key5 => 5},

-                  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

-                  "basic");

+  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

+  "basic");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1_2);

@@ -978,8 +978,8 @@ is_deeply($param, {$key2 => 11});

 $result = $dbi->execute("select * from $table1 order by $key1");

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 11, $key3 => 3, $key4 => 4, $key5 => 5},

-                  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

-                  "basic");

+  {$key1 => 6, $key2 => 7,  $key3 => 8, $key4 => 9, $key5 => 10}],

+  "basic");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1_2);

@@ -1025,9 +1025,8 @@ $dbi->update_all({$key2 => 10}, table => $table1, filter => {$key2 => 'twice'});

 $result = $dbi->execute("select * from $table1");

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 20, $key3 => 3, $key4 => 4, $key5 => 5},

-                  {$key1 => 6, $key2 => 20, $key3 => 8, $key4 => 9, $key5 => 10}],

-                  "filter");

-

+  {$key1 => 6, $key2 => 20, $key3 => 8, $key4 => 9, $key5 => 10}],

+  "filter");

 test 'delete';

 eval { $dbi->execute("drop table $table1") };

@@ -1073,11 +1072,11 @@ $dbi->execute($create_table1);

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

 $dbi->insert({$key1 => 3, $key2 => 4}, table => $table1);

 $dbi->delete(

-    table => $table1,

-    where => [

-        ['and', "$key1 = :$key1", "$key2 = :$key2"],

-        {ke1 => 1, $key2 => 2}

-    ]

+  table => $table1,

+  where => [

+    ['and', "$key1 = :$key1", "$key2 = :$key2"],

+    {ke1 => 1, $key2 => 2}

+  ]

 );

 $result = $dbi->select(table => $table1);

 is_deeply($result->all, [{$key1 => 3, $key2 => 4}], 'delete() where');

@@ -1120,7 +1119,6 @@ $result = $dbi->execute("select * from $table1");

 $rows   = $result->all;

 is_deeply($rows, [], "basic");

-

 test 'select';

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

@@ -1128,7 +1126,7 @@ $dbi->insert({$key1 => 1, $key2 => 2}, table => $table1);

 $dbi->insert({$key1 => 3, $key2 => 4}, table => $table1);

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

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

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

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

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

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

@@ -1141,24 +1139,24 @@ is_deeply($rows, [{$key1 => 3}], "table and columns and where key");

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

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

-            ->all;

+          ->all;

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

 eval { $dbi->execute("drop table $table2") };

 $dbi->execute($create_table2);

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

 $rows = $dbi->select(

-    table => [$table1, $table2],

-    column => "$table1.$key1 as ${table1}_$key1, $table2.$key1 as ${table2}_$key1, $key2, $key3",

-    where   => {"$table1.$key2" => 2},

-    relation  => {"$table1.$key1" => "$table2.$key1"}

+  table => [$table1, $table2],

+  column => "$table1.$key1 as ${table1}_$key1, $table2.$key1 as ${table2}_$key1, $key2, $key3",

+  where   => {"$table1.$key2" => 2},

+  relation  => {"$table1.$key1" => "$table2.$key1"}

 )->all;

 is_deeply($rows, [{"${table1}_$key1" => 1, "${table2}_$key1" => 1, $key2 => 2, $key3 => 5}], "relation : exists where");

 $rows = $dbi->select(

-    table => [$table1, $table2],

-    column => ["$table1.$key1 as ${table1}_$key1", "${table2}.$key1 as ${table2}_$key1", $key2, $key3],

-    relation  => {"$table1.$key1" => "$table2.$key1"}

+  table => [$table1, $table2],

+  column => ["$table1.$key1 as ${table1}_$key1", "${table2}.$key1 as ${table2}_$key1", $key2, $key3],

+  relation  => {"$table1.$key1" => "$table2.$key1"}

 )->all;

 is_deeply($rows, [{"${table1}_$key1" => 1, "${table2}_$key1" => 1, $key2 => 2, $key3 => 5}], "relation : no exists where");

@@ -1180,8 +1178,8 @@ is_deeply($row, {$key1 => 1});

 test 'fetch filter';

 eval { $dbi->execute("drop table $table1") };

 $dbi->register_filter(

-    twice       => sub { $_[0] * 2 },

-    three_times => sub { $_[0] * 3 }

+  twice       => sub { $_[0] * 2 },

+  three_times => sub { $_[0] * 3 }

 );

 $dbi->default_fetch_filter('twice');

 $dbi->execute($create_table1);

@@ -1210,10 +1208,10 @@ test 'filters';

 $dbi = DBIx::Custom->new;

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

-   'あ', "decode_utf8");

+  'あ', "decode_utf8");

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

-   encode_utf8('あ'), "encode_utf8");

+  encode_utf8('あ'), "encode_utf8");

 test 'transaction1';

 $dbi = DBIx::Custom->connect;

@@ -1240,21 +1238,21 @@ $dbi->commit;

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

 $result = $dbi->select(table => $table1);

 is_deeply(scalar $result->all, [{$key1 => 1, $key2 => 2}, {$key1 => 2, $key2 => 3}],

-          "commit");

+  "commit");

 test 'execute';

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 {

-    local $Carp::Verbose = 0;

-    eval{$dbi->execute("select * frm $table1")};

-    like($@, qr/\Qselect * frm $table1/, "fail prepare");

-    like($@, qr/\.t /, "fail : not verbose");

+  local $Carp::Verbose = 0;

+  eval{$dbi->execute("select * frm $table1")};

+  like($@, qr/\Qselect * frm $table1/, "fail prepare");

+  like($@, qr/\.t /, "fail : not verbose");

 }

 {

-    local $Carp::Verbose = 1;

-    eval{$dbi->execute("select * frm $table1")};

-    like($@, qr/Custom.*\.t /s, "fail : verbose");

+  local $Carp::Verbose = 1;

+  eval{$dbi->execute("select * frm $table1")};

+  like($@, qr/Custom.*\.t /s, "fail : verbose");

 }

 $query = $dbi->execute("select * from $table1 where $key1 = :$key1", {}, query => 1);

@@ -1263,14 +1261,14 @@ eval{$dbi->execute($query, {$key1 => {a => 1}})};

 ok($@, "execute fail");

 {

-    local $Carp::Verbose = 0;

-    eval{$dbi->execute("select * from $table1 where {0 $key1}", {}, query => 1)};

-    like($@, qr/\Q.t /, "caller spec : not vebose");

+  local $Carp::Verbose = 0;

+  eval{$dbi->execute("select * from $table1 where {0 $key1}", {}, query => 1)};

+  like($@, qr/\Q.t /, "caller spec : not vebose");

 }

 {

-    local $Carp::Verbose = 1;

-    eval{$dbi->execute("select * from $table1 where {0 $key1}", {}, query => 1)};

-    like($@, qr/QueryBuilder.*\.t /s, "caller spec : not vebose");

+  local $Carp::Verbose = 1;

+  eval{$dbi->execute("select * from $table1 where {0 $key1}", {}, query => 1)};

+  like($@, qr/QueryBuilder.*\.t /s, "caller spec : not vebose");

 }

@@ -1282,9 +1280,9 @@ $dbi->execute($create_table1);

 $dbi->begin_work;

 eval {

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

-    die "Error";

-    $dbi->insert({$key1 => 3, $key2 => 4}, table => $table1);

+  $dbi->insert({$key1 => 1, $key2 => 2}, table => $table1);

+  die "Error";

+  $dbi->insert({$key1 => 3, $key2 => 4}, table => $table1);

 };

 $dbi->rollback if $@;

@@ -1296,8 +1294,8 @@ is_deeply($rows, [], "rollback");

 $dbi->begin_work;

 eval {

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

-    $dbi->insert({$key1 => 3, $key2 => 4}, table => $table1);

+  $dbi->insert({$key1 => 1, $key2 => 2}, table => $table1);

+  $dbi->insert({$key1 => 3, $key2 => 4}, table => $table1);

 };

 $dbi->commit unless $@;

@@ -1318,7 +1316,7 @@ $dbi->execute($create_table1);

 $source = "select * from $table1 where $key1 = :$key1 and $key2 = :$key2";

 $dbi->execute($source, {}, query => 1);

 is_deeply($dbi->{_cached}->{$source}, 

-          {sql => " select * from $table1 where $key1 = ?  and $key2 = ? ", columns => [$key1, $key2], tables => []}, "cache");

+  {sql => " select * from $table1 where $key1 = ?  and $key2 = ? ", columns => [$key1, $key2], tables => []}, "cache");

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

@@ -1331,15 +1329,15 @@ test 'execute';

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 {

-    local $Carp::Verbose = 0;

-    eval{$dbi->execute("select * frm $table1")};

-    like($@, qr/\Qselect * frm $table1/, "fail prepare");

-    like($@, qr/\.t /, "fail : not verbose");

+  local $Carp::Verbose = 0;

+  eval{$dbi->execute("select * frm $table1")};

+  like($@, qr/\Qselect * frm $table1/, "fail prepare");

+  like($@, qr/\.t /, "fail : not verbose");

 }

 {

-    local $Carp::Verbose = 1;

-    eval{$dbi->execute("select * frm $table1")};

-    like($@, qr/Custom.*\.t /s, "fail : verbose");

+  local $Carp::Verbose = 1;

+  eval{$dbi->execute("select * frm $table1")};

+  like($@, qr/Custom.*\.t /s, "fail : verbose");

 }

 $query = $dbi->execute("select * from $table1 where $key1 = :$key1", {}, query => 1);

@@ -1348,28 +1346,28 @@ eval{$dbi->execute($query, {$key1 => {a => 1}})};

 ok($@, "execute fail");

 {

-    local $Carp::Verbose = 0;

-    eval{$dbi->execute("select * from $table1 where {0 $key1}", {}, query => 1)};

-    like($@, qr/\Q.t /, "caller spec : not vebose");

+  local $Carp::Verbose = 0;

+  eval{$dbi->execute("select * from $table1 where {0 $key1}", {}, query => 1)};

+  like($@, qr/\Q.t /, "caller spec : not vebose");

 }

 {

-    local $Carp::Verbose = 1;

-    eval{$dbi->execute("select * from $table1 where {0 $key1}", {}, query => 1)};

-    like($@, qr/QueryBuilder.*\.t /s, "caller spec : not vebose");

+  local $Carp::Verbose = 1;

+  eval{$dbi->execute("select * from $table1 where {0 $key1}", {}, query => 1)};

+  like($@, qr/QueryBuilder.*\.t /s, "caller spec : not vebose");

 }

 test 'method';

 $dbi->helper(

-    one => sub { 1 }

+  one => sub { 1 }

 );

 $dbi->helper(

-    two => sub { 2 }

+  two => sub { 2 }

 );

 $dbi->method({

-    twice => sub {

-        my $self = shift;

-        return $_[0] * 2;

-    }

+  twice => sub {

+    my $self = shift;

+    return $_[0] * 2;

+  }

 });

 is($dbi->one, 1, "first");

@@ -1386,8 +1384,8 @@ $dbi->execute($create_table1);

 $dbi->register_filter(twice => sub { $_[0] * 2 });

 $dbi->register_filter(three_times => sub { $_[0] * 3});

 $dbi->apply_filter(

-    $table1, $key1 => {out => 'twice', in => 'three_times'}, 

-              $key2 => {out => 'three_times', in => 'twice'});

+  $table1, $key1 => {out => 'twice', in => 'three_times'}, 

+            $key2 => {out => 'three_times', in => 'twice'});

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

 $result = $dbi->execute("select * from $table1");

 $row   = $result->fetch_hash_one;

@@ -1407,10 +1405,10 @@ $dbi->execute($create_table1);

 $dbi->register_filter(twice => sub { $_[0] * 2 });

 $dbi->register_filter(three_times => sub { $_[0] * 3});

 $dbi->apply_filter(

-    $table1, $key1 => {out => 'twice', in => 'three_times'}, 

-              $key2 => {out => 'three_times', in => 'twice'});

+  $table1, $key1 => {out => 'twice', in => 'three_times'}, 

+            $key2 => {out => 'three_times', in => 'twice'});

 $dbi->apply_filter(

-    $table1, $key1 => {out => undef}

+  $table1, $key1 => {out => undef}

 ); 

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

 $result = $dbi->execute("select * from $table1");

@@ -1422,7 +1420,7 @@ eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->register_filter(twice => sub { $_[0] * 2 });

 $dbi->apply_filter(

-    $table1, $key1 => {out => 'twice', in => 'twice'}

+  $table1, $key1 => {out => 'twice', in => 'twice'}

 );

 $dbi->insert({$key1 => 1, $key2 => 2},table => $table1, filter => {$key1 => undef});

 $dbi->update({$key1 => 2}, table => $table1, where => {$key2 => 2});

@@ -1435,7 +1433,7 @@ eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->register_filter(twice => sub { $_[0] * 2 });

 $dbi->apply_filter(

-    $table1, $key1 => {out => 'twice', in => 'twice'}

+  $table1, $key1 => {out => 'twice', in => 'twice'}

 );

 $dbi->insert({$key1 => 2, $key2 => 2}, table => $table1, filter => {$key1=> undef});

 $dbi->delete(table => $table1, where => {$key1 => 1});

@@ -1448,7 +1446,7 @@ eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->register_filter(twice => sub { $_[0] * 2 });

 $dbi->apply_filter(

-    $table1, $key1 => {out => 'twice', in => 'twice'}

+  $table1, $key1 => {out => 'twice', in => 'twice'}

 );

 $dbi->insert({$key1 => 2, $key2 => 2}, table => $table1, filter => {$key1 => undef});

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

@@ -1461,12 +1459,12 @@ eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->register_filter(twice => sub { $_[0] * 2 });

 $dbi->apply_filter(

-    $table1, $key1 => {out => 'twice', in => 'twice'}

+  $table1, $key1 => {out => 'twice', in => 'twice'}

 );

 $dbi->insert({$key1 => 2, $key2 => 2}, table => $table1, filter => {$key1 => undef});

 $result = $dbi->execute("select * from $table1 where $key1 = :$key1 and $key2 = :$key2",

-                        {$key1 => 1, $key2 => 2},

-                        table => [$table1]);

+  {$key1 => 1, $key2 => 2},

+  table => [$table1]);

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 4, $key2 => 2}], "execute");

@@ -1475,11 +1473,11 @@ eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->register_filter(twice => sub { $_[0] * 2 });

 $dbi->apply_filter(

-    $table1, $key1 => {out => 'twice', in => 'twice'}

+  $table1, $key1 => {out => 'twice', in => 'twice'}

 );

 $dbi->insert({$key1 => 2, $key2 => 2}, table => $table1, filter => {$key1 => undef});

 $result = $dbi->execute("select * from {table $table1} where $key1 = :$key1 and $key2 = :$key2",

-                        {$key1 => 1, $key2 => 2});

+  {$key1 => 1, $key2 => 2});

 $rows   = $result->all;

 is_deeply($rows, [{$key1 => 4, $key2 => 2}], "execute table tag");

@@ -1491,26 +1489,26 @@ $dbi->execute($create_table2);

 $dbi->register_filter(twice => sub { $_[0] * 2 });

 $dbi->register_filter(three_times => sub { $_[0] * 3 });

 $dbi->apply_filter(

-    $table1, $key2 => {out => 'twice', in => 'twice'}

+  $table1, $key2 => {out => 'twice', in => 'twice'}

 );

 $dbi->apply_filter(

-    $table2, $key3 => {out => 'three_times', in => 'three_times'}

+  $table2, $key3 => {out => 'three_times', in => 'three_times'}

 );

 $dbi->insert({$key1 => 5, $key2 => 2}, table => $table1, filter => {$key2 => undef});

 $dbi->insert({$key1 => 5, $key3 => 6}, table => $table2, filter => {$key3 => undef});

 $result = $dbi->select(

-     table => [$table1, $table2],

-     column => [$key2, $key3],

-     where => {"$table1.$key2" => 1, "$table2.$key3" => 2}, relation => {"$table1.$key1" => "$table2.$key1"});

+  table => [$table1, $table2],

+  column => [$key2, $key3],

+  where => {"$table1.$key2" => 1, "$table2.$key3" => 2}, relation => {"$table1.$key1" => "$table2.$key1"});

 $result->filter({$key2 => 'twice'});

 $rows   = $result->all;

 is_deeply($rows, [{$key2 => 4, $key3 => 18}], "select : join");

 $result = $dbi->select(

-     table => [$table1, $table2],

-     column => [$key2, $key3],

-     where => {$key2 => 1, $key3 => 2}, relation => {"$table1.$key1" => "$table2.$key1"});

+  table => [$table1, $table2],

+  column => [$key2, $key3],

+  where => {$key2 => 1, $key3 => 2}, relation => {"$table1.$key1" => "$table2.$key1"});

 $result->filter({$key2 => 'twice'});

 $rows   = $result->all;

@@ -1586,8 +1584,8 @@ is_deeply($row, {$key1 => 6, $key2 => 40});

 $dbi->register_filter(five_times => sub { $_[0] * 5 });

 $dbi->apply_filter($table1,

-    $key1 => {end => sub { $_[0] * 3 } },

-    $key2 => {end => 'five_times'}

+  $key1 => {end => sub { $_[0] * 3 } },

+  $key2 => {end => 'five_times'}

 );

 $result = $dbi->select(table => $table1);

 $result->filter($key1 => sub { $_[0] * 2 }, $key2 => sub { $_[0] * 4 });

@@ -1596,8 +1594,8 @@ is_deeply($row, {$key1 => 6, $key2 => 40}, 'apply_filter');

 $dbi->register_filter(five_times => sub { $_[0] * 5 });

 $dbi->apply_filter($table1,

-    $key1 => {end => sub { $_[0] * 3 } },

-    $key2 => {end => 'five_times'}

+  $key1 => {end => sub { $_[0] * 3 } },

+  $key2 => {end => 'five_times'}

 );

 $result = $dbi->select(table => $table1);

 $result->filter($key1 => sub { $_[0] * 2 }, $key2 => sub { $_[0] * 4 });

@@ -1620,11 +1618,11 @@ $dbi->execute($create_table1);

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

 $result = $dbi->select(table => $table1);

 $row = $result

-       ->filter($key1 => sub { $_[0] * 2 }, $key2 => sub { $_[0] * 4 })

-       ->remove_filter

-       ->end_filter($key1 => sub { $_[0] * 3 }, $key2 => sub { $_[0] * 5 })

-       ->remove_end_filter

-       ->fetch_one;

+  ->filter($key1 => sub { $_[0] * 2 }, $key2 => sub { $_[0] * 4 })

+  ->remove_filter

+  ->end_filter($key1 => sub { $_[0] * 3 }, $key2 => sub { $_[0] * 5 })

+  ->remove_end_filter

+  ->fetch_one;

 is_deeply($row, [1, 2]);

 test 'empty where select';

@@ -1659,70 +1657,70 @@ $where = $dbi->where->clause(['and', "$key1 = :$key1", "$key2 = :$key2"]);

 is("$where", "where ( $key1 = :$key1 and $key2 = :$key2 )", 'no param');

 $where = $dbi->where

-             ->clause(['and', "$key1 = :$key1", "$key2 = :$key2"])

-             ->param({$key1 => 1});

+  ->clause(['and', "$key1 = :$key1", "$key2 = :$key2"])

+  ->param({$key1 => 1});

 $result = $dbi->select(

-    table => $table1,

-    where => $where

+  table => $table1,

+  where => $where

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}]);

 $result = $dbi->select(

-    table => $table1,

-    where => [

-        ['and', "$key1 = :$key1", "$key2 = :$key2"],

-        {$key1 => 1}

-    ]

+  table => $table1,

+  where => [

+    ['and', "$key1 = :$key1", "$key2 = :$key2"],

+    {$key1 => 1}

+  ]

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}]);

 $where = $dbi->where

-             ->clause(['and', "$key1 = :$key1", "$key2 = :$key2"])

-             ->param({$key1 => 1, $key2 => 2});

+  ->clause(['and', "$key1 = :$key1", "$key2 = :$key2"])

+  ->param({$key1 => 1, $key2 => 2});

 $result = $dbi->select(

-    table => $table1,

-    where => $where

+  table => $table1,

+  where => $where

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}]);

 $where = $dbi->where

-             ->clause(['and', "$key1 = :$key1", "$key2 = :$key2"])

-             ->param({});

+  ->clause(['and', "$key1 = :$key1", "$key2 = :$key2"])

+  ->param({});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}]);

 $where = $dbi->where

-             ->clause(['and', ['or', "$key1 > :$key1", "$key1 < :$key1"], "$key2 = :$key2"])

-             ->param({$key1 => [0, 3], $key2 => 2});

+  ->clause(['and', ['or', "$key1 > :$key1", "$key1 < :$key1"], "$key2 = :$key2"])

+  ->param({$key1 => [0, 3], $key2 => 2});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 ); 

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}]);

 $where = $dbi->where;

 $result = $dbi->select(

-    table => $table1,

-    where => $where

+  table => $table1,

+  where => $where

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}]);

 eval {

 $where = $dbi->where

-             ->clause(['uuu']);

+           ->clause(['uuu']);

 $result = $dbi->select(

-    table => $table1,

-    where => $where

+  table => $table1,

+  where => $where

 );

 };

 ok($@);

@@ -1731,170 +1729,170 @@ $where = $dbi->where;

 is("$where", '');

 $where = $dbi->where

-             ->clause(['or', ("$key1 = :$key1") x 2])

-             ->param({$key1 => [1, 3]});

+  ->clause(['or', ("$key1 = :$key1") x 2])

+  ->param({$key1 => [1, 3]});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}]);

 $where = $dbi->where

-             ->clause(['or', ("$key1 = :$key1") x 2])

-             ->param({$key1 => [1]});

+   ->clause(['or', ("$key1 = :$key1") x 2])

+   ->param({$key1 => [1]});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}]);

 $where = $dbi->where

-             ->clause(['or', ("$key1 = :$key1") x 2])

-             ->param({$key1 => 1});

+  ->clause(['or', ("$key1 = :$key1") x 2])

+  ->param({$key1 => 1});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}]);

 $where = $dbi->where

-             ->clause("$key1 = :$key1")

-             ->param({$key1 => 1});

+  ->clause("$key1 = :$key1")

+  ->param({$key1 => 1});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}]);

 $where = $dbi->where

-             ->clause(['or', ("$key1 = :$key1") x 3])

-             ->param({$key1 => [$dbi->not_exists, 1, 3]});

+  ->clause(['or', ("$key1 = :$key1") x 3])

+  ->param({$key1 => [$dbi->not_exists, 1, 3]});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}], 'not_exists');

 $where = $dbi->where

-             ->clause(['or', ("$key1 = :$key1") x 3])

-             ->param({$key1 => [1, $dbi->not_exists, 3]});

+  ->clause(['or', ("$key1 = :$key1") x 3])

+  ->param({$key1 => [1, $dbi->not_exists, 3]});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}], 'not_exists');

 $where = $dbi->where

-             ->clause(['or', ("$key1 = :$key1") x 3])

-             ->param({$key1 => [1, 3, $dbi->not_exists]});

+  ->clause(['or', ("$key1 = :$key1") x 3])

+  ->param({$key1 => [1, 3, $dbi->not_exists]});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}], 'not_exists');

 $where = $dbi->where

-             ->clause(['or', ("$key1 = :$key1") x 3])

-             ->param({$key1 => [1, $dbi->not_exists, $dbi->not_exists]});

+  ->clause(['or', ("$key1 = :$key1") x 3])

+  ->param({$key1 => [1, $dbi->not_exists, $dbi->not_exists]});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}], 'not_exists');

 $where = $dbi->where

-             ->clause(['or', ("$key1 = :$key1") x 3])

-             ->param({$key1 => [$dbi->not_exists, 1, $dbi->not_exists]});

+  ->clause(['or', ("$key1 = :$key1") x 3])

+  ->param({$key1 => [$dbi->not_exists, 1, $dbi->not_exists]});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}], 'not_exists');

 $where = $dbi->where

-             ->clause(['or', ("$key1 = :$key1") x 3])

-             ->param({$key1 => [$dbi->not_exists, $dbi->not_exists, 1]});

+  ->clause(['or', ("$key1 = :$key1") x 3])

+  ->param({$key1 => [$dbi->not_exists, $dbi->not_exists, 1]});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}], 'not_exists');

 $where = $dbi->where

-             ->clause(['or', ("$key1 = :$key1") x 3])

-             ->param({$key1 => [$dbi->not_exists, $dbi->not_exists, $dbi->not_exists]});

+  ->clause(['or', ("$key1 = :$key1") x 3])

+  ->param({$key1 => [$dbi->not_exists, $dbi->not_exists, $dbi->not_exists]});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}], 'not_exists');

 $where = $dbi->where

-             ->clause(['or', ("$key1 = :$key1") x 3])

-             ->param({$key1 => []});

+  ->clause(['or', ("$key1 = :$key1") x 3])

+  ->param({$key1 => []});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}], 'not_exists');

 $where = $dbi->where

-             ->clause(['and', "{> $key1}", "{< $key1}" ])

-             ->param({$key1 => [2, $dbi->not_exists]});

+  ->clause(['and', "{> $key1}", "{< $key1}" ])

+  ->param({$key1 => [2, $dbi->not_exists]});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 3, $key2 => 4}], 'not_exists');

 $where = $dbi->where

-             ->clause(['and', "{> $key1}", "{< $key1}" ])

-             ->param({$key1 => [$dbi->not_exists, 2]});

+  ->clause(['and', "{> $key1}", "{< $key1}" ])

+  ->param({$key1 => [$dbi->not_exists, 2]});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}], 'not_exists');

 $where = $dbi->where

-             ->clause(['and', "{> $key1}", "{< $key1}" ])

-             ->param({$key1 => [$dbi->not_exists, $dbi->not_exists]});

+  ->clause(['and', "{> $key1}", "{< $key1}" ])

+  ->param({$key1 => [$dbi->not_exists, $dbi->not_exists]});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2},{$key1 => 3, $key2 => 4}], 'not_exists');

 $where = $dbi->where

-             ->clause(['and', "{> $key1}", "{< $key1}" ])

-             ->param({$key1 => [0, 2]});

+  ->clause(['and', "{> $key1}", "{< $key1}" ])

+  ->param({$key1 => [0, 2]});

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}], 'not_exists');

 $where = $dbi->where

-             ->clause(['and',"$key1 is not null", "$key2 is not null" ]);

+  ->clause(['and',"$key1 is not null", "$key2 is not null" ]);

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}], 'not_exists');

@@ -1903,24 +1901,24 @@ eval {$dbi->where(ppp => 1) };

 like($@, qr/invalid/);

 $where = $dbi->where(

-    clause => ['and', ['or'], ['and', "$key1 = :$key1", "$key2 = :$key2"]],

-    param => {$key1 => 1, $key2 => 2}

+  clause => ['and', ['or'], ['and', "$key1 = :$key1", "$key2 = :$key2"]],

+  param => {$key1 => 1, $key2 => 2}

 );

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}]);

 $where = $dbi->where(

-    clause => ['and', ['or'], ['or', ":$key1", ":$key2"]],

-    param => {}

+  clause => ['and', ['or'], ['or', ":$key1", ":$key2"]],

+  param => {}

 );

 $result = $dbi->select(

-    table => $table1,

-    where => $where,

+  table => $table1,

+  where => $where,

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}]);

@@ -1949,12 +1947,12 @@ $dbi->execute($create_table1);

 $dbi->insert({$key1 => 1, $key2 => '00:00:00'}, table => $table1);

 $dbi->insert({$key1 => 1, $key2 => '3'}, table => $table1);

 $where = $dbi->where

-             ->clause(['and', "$key1 = :$key1", "$key2 = '00:00:00'"])

-             ->param({$key1 => 1});

+  ->clause(['and', "$key1 = :$key1", "$key2 = '00:00:00'"])

+  ->param({$key1 => 1});

 $result = $dbi->select(

-    table => $table1,

-    where => $where

+  table => $table1,

+  where => $where

 );

 $row = $result->all;

 is_deeply($row, [{$key1 => 1, $key2 => '00:00:00'}]);

@@ -1962,14 +1960,14 @@ is_deeply($row, [{$key1 => 1, $key2 => '00:00:00'}]);

 test 'register_tag_processor';

 $dbi = DBIx::Custom->connect;

 $dbi->register_tag_processor(

-    a => sub { 1 }

+  a => sub { 1 }

 );

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

 test 'register_tag';

 $dbi = DBIx::Custom->connect;

 $dbi->register_tag(

-    b => sub { 2 }

+  b => sub { 2 }

 );

 is($dbi->{_tags}->{b}->(), 2);

@@ -1995,7 +1993,7 @@ $dbi->execute($create_table1);

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

 $dbi->insert({$key1 => 3, $key2 => 4}, table => $table1);

 $dbi->apply_filter($table1, $key2, 

-                   {in => sub { $_[0] * 3 }, out => sub { $_[0] * 2 }});

+                 {in => sub { $_[0] * 3 }, out => sub { $_[0] * 2 }});

 $rows = $dbi->select(table => $table1, where => {$key2 => 1})->all;

 is_deeply($rows, [{$key1 => 1, $key2 => 6}]);

@@ -2024,11 +2022,11 @@ eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

 $dbi->register_filter(twice => sub { $_[0] * 2 });

 $dbi->insert({$key1 => 1, $key2 => 2}, table => $table1,

-             filter => {$key1 => 'twice'});

+           filter => {$key1 => 'twice'});

 $row = $dbi->select(table => $table1)->one;

 is_deeply($row, {$key1 => 2, $key2 => 2});

 eval {$dbi->insert({$key1 => 1, $key2 => 2}, table => $table1,

-             filter => {$key1 => 'no'}) };

+           filter => {$key1 => 'no'}) };

 like($@, qr//);

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

@@ -2081,17 +2079,17 @@ eval { $dbi->execute("drop table $table1") };