use Test::More;

use strict;

use warnings;

use Encode qw/encode_utf8/;

use FindBin;

use Scalar::Util 'isweak';

my $dbi;

plan skip_all => $ENV{DBIX_CUSTOM_SKIP_MESSAGE} || 'common.t is always skipped'

  unless $ENV{DBIX_CUSTOM_TEST_RUN}

    && eval { $dbi = DBIx::Custom->connect; 1 };

plan 'no_plan';

$SIG{__WARN__} = sub { warn $_[0] unless $_[0] =~ /DEPRECATED/};

sub test { print "# $_[0]\n" }

# Constant

my $table1 = $dbi->table1;

my $table2 = $dbi->table2;

my $table2_alias = $dbi->table2_alias;

my $table3 = $dbi->table3;

my $key1 = $dbi->key1;

my $key2 = $dbi->key2;

my $key3 = $dbi->key3;

my $key4 = $dbi->key4;

my $key5 = $dbi->key5;

my $key6 = $dbi->key6;

my $key7 = $dbi->key7;

my $key8 = $dbi->key8;

my $key9 = $dbi->key9;

my $key10 = $dbi->key10;

my $create_table1 = $dbi->create_table1;

my $create_table1_2 = $dbi->create_table1_2;

my $create_table1_type = $dbi->create_table1_type;

my $create_table1_highperformance = $dbi->create_table1_highperformance;

my $create_table2 = $dbi->create_table2;

my $create_table2_2 = $dbi->create_table2_2;

my $create_table3 = $dbi->create_table3;

my $create_table_reserved = $dbi->create_table_reserved;

my $q = substr($dbi->quote, 0, 1);

my $p = substr($dbi->quote, 1, 1) || $q;

my $date_typename = $dbi->date_typename;

my $datetime_typename = $dbi->datetime_typename;

my $date_datatype = $dbi->date_datatype;

my $datetime_datatype = $dbi->datetime_datatype;

# Variables

my $builder;

my $datas;

my $sth;

my $source;

my @sources;

my $select_source;

my $insert_source;

my $update_source;

my $param;

my $params;

my $sql;

my $result;

my $row;

my @rows;

my $rows;

my $query;

my @queries;

my $select_query;

my $insert_query;

my $update_query;

my $ret_val;

my $infos;

my $model;

my $model2;

my $where;

my $update_param;

my $insert_param;

my $join;

my $binary;

my $user_table_info;

my $user_column_info;

my $values_clause;

my $assign_clause;

my $reuse;

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 MyModel2::Base1;

    use strict;

    use warnings;

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

    package MyModel2::table1;

    use strict;

    use warnings;

    use base 'MyModel2::Base1';

    sub insert {

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

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

    }

    sub list { shift->select; }

    package MyModel2::table2;

    use strict;

    use warnings;

    use base 'MyModel2::Base1';

    sub insert {

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

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

    }

    sub list { shift->select; }

    package MyModel2::TABLE1;

    use strict;

    use warnings;

    use base 'MyModel2::Base1';

    sub insert {

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

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

    }

    sub list { shift->select; }

    package MyModel2::TABLE2;

    use strict;

    use warnings;

    use base 'MyModel2::Base1';

    sub insert {

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

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

    }

    sub list { shift->select; }

}

{

     package MyDBI5;

    use strict;

    use warnings;

    use base 'DBIx::Custom';

    sub connect {

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

        $self->include_model('MyModel4');

    }

}

{

    package MyDBI6;

    use base 'DBIx::Custom';

    sub connect {

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

        $self->include_model('MyModel5');

        return $self;

    }

}

{

    package MyDBI7;

    use base 'DBIx::Custom';

    sub connect {

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

        $self->include_model('MyModel6');

        return $self;

    }

}

{

    package MyDBI8;

    use base 'DBIx::Custom';

    sub connect {

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

        $self->include_model('MyModel7');

        return $self;

    }

}

{

    package MyDBI9;

    use base 'DBIx::Custom';

    sub connect {

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

        $self->include_model('MyModel8');

        return $self;

    }

}

test 'execute reuse option';

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);

}

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

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

ok(keys %$reuse);

ok((keys %$reuse)[0] !~ /\?/);

# Get user table info

$dbi = DBIx::Custom->connect;

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

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

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

$dbi->execute($create_table1);

$dbi->execute($create_table2);

$dbi->execute($create_table3);

$user_table_info = $dbi->get_table_info(exclude => $dbi->exclude_table);

# Create table

$dbi = DBIx::Custom->connect;

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

$dbi->execute($create_table1);

$model = $dbi->create_model(table => $table1);

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

is_deeply($model->select->all, [{$key1 => 1, $key2 => 2}]);

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

$dbi->execute($create_table1);

$model = $dbi->create_model(table => $table1);

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

is_deeply($model->select($key1)->all, [{$key1 => 1}]);

test 'DBIx::Custom::Result test';

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

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

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

$source = "select $key1, $key2 from $table1";

$query = $dbi->create_query($source);

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

@rows = ();

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

    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};

}

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

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

$rows = $result->fetch_all;

is_deeply($rows, [[1, 2], [3, 4]], "fetch_all");

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

$rows = $result->fetch_hash_all;

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

test 'Insert query return value';

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

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

$ret_val = $dbi->execute($query, {$key1 => 1, $key2 => 2});

ok($ret_val);

test 'Direct query';

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

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

$dbi->execute($insert_source, {$key1 => 1, $key2 => 2});

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

$rows = $result->all;

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});

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

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

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

$dbi->execute($insert_query, {$key1 => 1, $key2 => 2});

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

$rows = $result->filter({$key2 => 'three_times'})->all;

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

test 'Filter in';

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

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

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

$dbi->execute($insert_query, {$key1 => 2, $key2 => 4});

$select_source = "select * from $table1 where {in $table1.$key1 2} and {in $table1.$key2 2}";

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

$select_query->filter({"$table1.$key1" => 'twice'});

$result = $dbi->execute($select_query, {"$table1.$key1" => [1,5], "$table1.$key2" => [2,4]});

$rows = $result->all;

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

test 'DBIx::Custom::SQLTemplate basic tag';

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

$dbi->execute($create_table1_2);

$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);

$source = "select * from $table1 where $key1 = :$key1 and {<> $key2} and {< $key3} and {> $key4} and {>= $key5}";

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

$result = $dbi->execute($query, {$key1 => 1, $key2 => 3, $key3 => 4, $key4 => 3, $key5 => 5});

$rows = $result->all;

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

$source = "select * from $table1 where $key1 = :$key1 and {<> $key2} and {< $key3} and {> $key4} and {>= $key5}";

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

$result = $dbi->execute($query, {$key1 => 1, $key2 => 3, $key3 => 4, $key4 => 3, $key5 => 5});

$rows = $result->all;

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

$source = "select * from $table1 where {<= $key1} and {like $key2}";

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

$result = $dbi->execute($query, {$key1 => 1, $key2 => '%2%'});

$rows = $result->all;

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

test 'DIB::Custom::SQLTemplate in tag';

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

$dbi->execute($create_table1_2);

$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);

$source = "select * from $table1 where {in $key1 2}";

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

$result = $dbi->execute($query, {$key1 => [9, 1]});

$rows = $result->all;

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

test 'DBIx::Custom::SQLTemplate insert tag';

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

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

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

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

$rows = $result->all;

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

test 'DBIx::Custom::SQLTemplate update tag';

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

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

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

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

$update_source = "update $table1 {update_param $key1 $key2 $key3 $key4} where {= $key5}";

$dbi->execute($update_source, {$key1 => 1, $key2 => 1, $key3 => 1, $key4 => 1, $key5 => 5});

$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");

test 'Named placeholder';

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

$dbi->execute($create_table1_2);

$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);

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

$result = $dbi->execute($source, {$key1 => 1, $key2 => 2});

$rows = $result->all;

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

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

$result = $dbi->execute($source, {$key1 => 1, $key2 => 2});

$rows = $result->all;

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

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

$result = $dbi->execute($source, {$key1 => [1, 2]});

$rows = $result->all;

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 }}

);

$rows = $result->all;

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

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

$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},

);

$rows = $result->all;

like($rows->[0]->{$key1}, qr/2011-10-14 12:19:18/);

is($rows->[0]->{$key2}, 2);

$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},

);

$rows = $result->all;

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

test 'Error case';

eval {DBIx::Custom->connect(dsn => 'dbi:SQLit')};

ok($@, "connect error");

eval{$dbi->execute("{p }", {}, query => 1)};

ok($@, "create_query invalid SQL template");

test 'insert';

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

$dbi->execute($create_table1);

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

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

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

$rows   = $result->all;

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

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

$dbi->execute($create_table1);

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

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

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

$rows   = $result->all;

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 }

);

$dbi->default_bind_filter('twice');

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

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

$rows   = $result->all;

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

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

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

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

$rows   = $result->all;

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

$dbi->default_bind_filter(undef);

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

$dbi->execute($create_table1);

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

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

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

eval{$dbi->insert({';' => 1}, table => 'table')};

like($@, qr/safety/);

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

$dbi->execute($create_table_reserved);

$dbi->apply_filter('table', select => {out => sub { $_[0] * 2}});

$dbi->insert({select => 1}, table => 'table');

$result = $dbi->execute("select * from ${q}table$p");

$rows   = $result->all;

is_deeply($rows, [{select => 2, update => undef}], "reserved word");

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

$dbi->execute($create_table1);

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

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

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

$rows   = $result->all;

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);

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

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

$rows   = $result->all;

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" }});

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

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

$rows   = $result->all;

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'

);

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

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

$rows   = $result->all;

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 }

);

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

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

$rows   = $result->all;

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 }

);

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

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

$rows   = $result->all;

is($rows->[0]->{$key1}, $rows->[0]->{$key2});

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

$dbi->execute($create_table1_2);

$param = {$key1 => 1};

$dbi->insert($param, table => $table1, created_at => $key2);

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

is_deeply($param, {$key1 => 1});

$row   = $result->one;

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

like($row->{$key2}, qr/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);

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

$dbi->execute($create_table1_2);

$param = {$key1 => 1};

$dbi->insert($param, table => $table1, updated_at => $key3);

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

is_deeply($param, {$key1 => 1});

$row   = $result->one;

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

like($row->{$key3}, qr/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);

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

$dbi->execute($create_table1_2);

$param = {$key1 => 1};

$dbi->insert($param, table => $table1, created_at => $key2, updated_at => $key3);

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

is_deeply($param, {$key1 => 1});

$row   = $result->one;

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

like($row->{$key2}, qr/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);

like($row->{$key3}, qr/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);

is($row->{$key2}, $row->{$key3});

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

$dbi->execute($create_table1_2);

$model = $dbi->create_model(table => $table1, created_at => $key2);

$param = {$key1 => 1};

$model->insert($param);

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

is_deeply($param, {$key1 => 1});

$row   = $result->one;

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

like($row->{$key2}, qr/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);

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

$dbi->execute($create_table1_2);

$param = {$key1 => 1};

$model = $dbi->create_model(table => $table1, updated_at => $key3);

$model->insert($param);

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

is_deeply($param, {$key1 => 1});

$row   = $result->one;

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

like($row->{$key3}, qr/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);

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

$dbi->execute($create_table1_2);

$param = {$key1 => 1};

$model = $dbi->create_model(table => $table1, created_at => $key2, updated_at => $key3);

$model->insert($param);

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

is_deeply($param, {$key1 => 1});

$row   = $result->one;

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

like($row->{$key2}, qr/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);

like($row->{$key3}, qr/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);

is($row->{$key2}, $row->{$key3});

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

);

$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

);

$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,

    );

};

like($@, qr/primary_key/);

eval {

    $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

);

$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

    );

};

is($affected, 0);

test 'model update_or_insert';

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

$dbi->execute($create_table1);

$model = $dbi->create_model(

    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

    );

};

like($@, qr/one/);

test 'default_bind_filter';

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

$dbi->register_filter(

    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'});

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

$rows   = $result->all;

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

$dbi->default_bind_filter(undef);

test 'update';

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

$dbi->execute($create_table1_2);

$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->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");

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

$dbi->execute($create_table1_2);

$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->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");

$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->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");

$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");

$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 }});

$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");

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

eval{$dbi->update(table => $table1)};

like($@, qr/where/, "not contain where");

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

$dbi->execute($create_table1);

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

$where = $dbi->where;

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

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

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

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

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

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}

    ]

);

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

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

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

$dbi->execute($create_table1);

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

$where = $dbi->where;

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

$where->param({$key2 => 2});

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

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

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

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

like($@, qr/safety/);

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

like($@, qr/safety/);

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

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

$dbi->execute($create_table_reserved);

$dbi->apply_filter('table', select => {out => sub { $_[0] * 2}});

$dbi->apply_filter('table', update => {out => sub { $_[0] * 3}});

$dbi->insert({select => 1}, table => 'table');

$dbi->update({update => 2}, table => 'table', where => {select => 1});

$result = $dbi->execute("select * from ${q}table$p");

$rows   = $result->all;

is_deeply($rows, [{select => 2, update => 6}], "reserved word");

eval {$dbi->update_all({';' => 2}, table => 'table') };

like($@, qr/safety/);

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

$dbi->execute($create_table_reserved);

$dbi->apply_filter('table', select => {out => sub { $_[0] * 2}});

$dbi->apply_filter('table', update => {out => sub { $_[0] * 3}});

$dbi->insert({select => 1}, table => 'table');

$dbi->update({update => 2}, table => 'table', where => {'table.select' => 1});

$result = $dbi->execute("select * from ${q}table$p");

$rows   = $result->all;

is_deeply($rows, [{select => 2, update => 6}], "reserved word");

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

$dbi->execute($create_table1_2);

$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->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");

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

$dbi->execute($create_table1_2);

$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->update({$key2 => 11}, table => $table1, where => {$key1 => 1},

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");

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

$dbi->execute($create_table1_2);

$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->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");

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

$dbi->execute($create_table1);

$dbi->update_timestamp(

    $key1 => '5'

);

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

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

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

$rows   = $result->all;

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' }

);

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

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

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

$rows   = $result->all;

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 }

);

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

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

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

$rows   = $result->all;

is($rows->[0]->{$key1}, $rows->[0]->{$key2});

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

$dbi->execute($create_table1_2);

$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);

$param = {$key2 => 11};

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

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");

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

$dbi->execute($create_table1_2);

$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);

$param = {$key2 => 11};

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

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");

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

$dbi->execute($create_table1_2);

$param = {$key3 => 4};

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

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

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

is_deeply($param, {$key3 => 4});

$row   = $result->one;

is($row->{$key3}, 4);

like($row->{$key2}, qr/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);

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

$dbi->execute($create_table1_2);

$param = {$key3 => 4};

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

$dbi->update($param, table => $table1, updated_at => $key2, where => {$key3 => 3});

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

is_deeply($param, {$key3 => 4});

$row   = $result->one;

is($row->{$key3}, 4);

like($row->{$key2}, qr/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);

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

$dbi->execute($create_table1_2);

$model = $dbi->create_model(table => $table1, updated_at => $key2);

$param = {$key3 => 4};

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

$model->update($param, where => {$key1 => 1});

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

is_deeply($param, {$key3 => 4});

$row   = $result->one;

is($row->{$key3}, 4);

like($row->{$key2}, qr/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);

test 'update_all';

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

$dbi->execute($create_table1_2);

$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_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");

test 'delete';

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

$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 => {$key1 => 1});

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

$rows   = $result->all;

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

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

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

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

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

$dbi->delete(table => $table1, where => {$key2 => 1}, filter => {$key2 => 'twice'});

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

$rows   = $result->all;

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

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

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

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

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

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

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

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

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

$dbi->execute($create_table1);

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

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

$where = $dbi->where;

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

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

$dbi->delete(table => $table1, where => $where);

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

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

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

$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}

    ]

);

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

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

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

$dbi->execute($create_table1);

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

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

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

$rows   = $result->all;

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

test 'delete error';