ken/DBIx-Custom at e5d6e22546e1d3eb5f56d26f5daae7b9e195bdbb ・ Gitprep

DBIx-Custom / t / common.t /

Newer ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ Older

1912 lines | 63.029kb

added common test executing ... bd35c82 Yuki Kimoto authored on 2011-08-07	1	use Test::More;
	2	use strict;
	3	use warnings;
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	4	use Encode qw/encode_utf8/;
cleanup test 41a84b1 Yuki Kimoto authored on 2011-08-10	5	use FindBin;
	6	use lib "$FindBin::Bin/common";
	7
added common test executing ... bd35c82 Yuki Kimoto authored on 2011-08-07	8	my $dbi;
	9
	10	plan skip_all => $ENV{DBIX_CUSTOM_SKIP_MESSAGE} \|\| 'common.t is always skipped'
	11	unless $ENV{DBIX_CUSTOM_TEST_RUN}
	12	&& eval { $dbi = DBIx::Custom->connect; 1 };
	13
	14	plan 'no_plan';
	15
test cleanup e5d6e22 Yuki Kimoto authored on 2011-08-10	16	use MyDBI1;
	17	{
	18	package MyDBI4;
	19
	20	use strict;
	21	use warnings;
	22
	23	use base 'DBIx::Custom';
	24
	25	sub connect {
	26	my $self = shift->SUPER::connect(@_);
	27
	28	$self->include_model(
	29	MyModel2 => [
	30	'book',
	31	{class => 'Company', name => 'company'}
	32	]
	33	);
	34	}
	35
	36	package MyModel2::Base1;
	37
	38	use strict;
	39	use warnings;
	40
	41	use base 'DBIx::Custom::Model';
	42
	43	package MyModel2::book;
	44
	45	use strict;
	46	use warnings;
	47
	48	use base 'MyModel2::Base1';
	49
	50	sub insert {
	51	my ($self, $param) = @_;
	52
	53	return $self->SUPER::insert(param => $param);
	54	}
	55
	56	sub list { shift->select; }
	57
	58	package MyModel2::Company;
	59
	60	use strict;
	61	use warnings;
	62
	63	use base 'MyModel2::Base1';
	64
	65	sub insert {
	66	my ($self, $param) = @_;
	67
	68	return $self->SUPER::insert(param => $param);
	69	}
	70
	71	sub list { shift->select; }
	72	}
	73	{
	74	package MyDBI5;
	75
	76	use strict;
	77	use warnings;
	78
	79	use base 'DBIx::Custom';
	80
	81	sub connect {
	82	my $self = shift->SUPER::connect(@_);
	83
	84	$self->include_model('MyModel4');
	85	}
	86	}
	87	{
	88	package MyDBI6;
	89
	90	use base 'DBIx::Custom';
	91
	92	sub connect {
	93	my $self = shift->SUPER::connect(@_);
	94
	95	$self->include_model('MyModel5');
	96
	97	return $self;
	98	}
	99	}
	100	{
	101	package MyDBI7;
	102
	103	use base 'DBIx::Custom';
	104
	105	sub connect {
	106	my $self = shift->SUPER::connect(@_);
	107
	108	$self->include_model('MyModel6');
	109
	110
	111	return $self;
	112	}
	113	}
	114	{
	115	package MyDBI8;
	116
	117	use base 'DBIx::Custom';
	118
	119	sub connect {
	120	my $self = shift->SUPER::connect(@_);
	121
	122	$self->include_model('MyModel7');
	123
	124	return $self;
	125	}
	126	}
	127
	128	{
	129	package MyDBI9;
	130
	131	use base 'DBIx::Custom';
	132
	133	sub connect {
	134	my $self = shift->SUPER::connect(@_);
	135
	136	$self->include_model('MyModel8')->setup_model;
	137
	138	return $self;
	139	}
	140	}
	141
cleanup test de329a9 Yuki Kimoto authored on 2011-08-08	142	$SIG{__WARN__} = sub { warn $_[0] unless $_[0] =~ /DEPRECATED/};
	143	sub test { print "# $_[0]\n" }
	144
added common test executing ... bd35c82 Yuki Kimoto authored on 2011-08-07	145	# Constant
	146	my $create_table1 = $dbi->create_table1;
cleanup test 058b0fd Yuki Kimoto authored on 2011-08-08	147	my $create_table1_2 = $dbi->create_table1_2;
test cleanup 723ba3d Yuki Kimoto authored on 2011-08-10	148	my $create_table1_type = $dbi->create_table1_type;
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	149	my $create_table2 = $dbi->create_table2;
test cleanup 1d42ba8 Yuki Kimoto authored on 2011-08-10	150	my $create_table2_2 = $dbi->create_table2_2;
	151	my $create_table3 = $dbi->create_table3;
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	152	my $create_table_reserved = $dbi->create_table_reserved;
cleanup test bf179eb Yuki Kimoto authored on 2011-08-10	153	my $q = substr($dbi->quote, 0, 1);
	154	my $p = substr($dbi->quote, 1, 1) \|\| $q;
added common test executing ... bd35c82 Yuki Kimoto authored on 2011-08-07	155
	156	# Variable
cleanup test de329a9 Yuki Kimoto authored on 2011-08-08	157	# Variables
	158	my $builder;
	159	my $datas;
	160	my $sth;
	161	my $source;
	162	my @sources;
	163	my $select_source;
	164	my $insert_source;
	165	my $update_source;
	166	my $param;
	167	my $params;
	168	my $sql;
	169	my $result;
	170	my $row;
	171	my @rows;
	172	my $rows;
	173	my $query;
	174	my @queries;
	175	my $select_query;
	176	my $insert_query;
	177	my $update_query;
	178	my $ret_val;
	179	my $infos;
added common test executing ... bd35c82 Yuki Kimoto authored on 2011-08-07	180	my $model;
cleanup test de329a9 Yuki Kimoto authored on 2011-08-08	181	my $model2;
	182	my $where;
	183	my $update_param;
	184	my $insert_param;
	185	my $join;
cleanup test a86c18b Yuki Kimoto authored on 2011-08-10	186	my $binary;
added common test executing ... bd35c82 Yuki Kimoto authored on 2011-08-07	187
	188	# Drop table
	189	eval { $dbi->execute('drop table table1') };
	190
	191	# Create table
	192	$dbi->execute($create_table1);
	193	$model = $dbi->create_model(table => 'table1');
	194	$model->insert({key1 => 1, key2 => 2});
	195	is_deeply($model->select->all, [{key1 => 1, key2 => 2}]);
	196
cleanup test de329a9 Yuki Kimoto authored on 2011-08-08	197	test 'DBIx::Custom::Result test';
	198	$dbi->delete_all(table => 'table1');
	199	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	200	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	201	$source = "select key1, key2 from table1";
	202	$query = $dbi->create_query($source);
	203	$result = $dbi->execute($query);
	204
	205	@rows = ();
	206	while (my $row = $result->fetch) {
	207	push @rows, [@$row];
	208	}
	209	is_deeply(\@rows, [[1, 2], [3, 4]], "fetch");
	210
	211	$result = $dbi->execute($query);
	212	@rows = ();
	213	while (my $row = $result->fetch_hash) {
	214	push @rows, {%$row};
	215	}
	216	is_deeply(\@rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "fetch_hash");
	217
	218	$result = $dbi->execute($query);
	219	$rows = $result->fetch_all;
	220	is_deeply($rows, [[1, 2], [3, 4]], "fetch_all");
	221
	222	$result = $dbi->execute($query);
	223	$rows = $result->fetch_hash_all;
	224	is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "all");
	225
	226	test 'Insert query return value';
	227	$source = "insert into table1 {insert_param key1 key2}";
	228	$query = $dbi->execute($source, {}, query => 1);
	229	$ret_val = $dbi->execute($query, param => {key1 => 1, key2 => 2});
	230	ok($ret_val);
	231
	232	test 'Direct query';
	233	$dbi->delete_all(table => 'table1');
	234	$insert_source = "insert into table1 {insert_param key1 key2}";
	235	$dbi->execute($insert_source, param => {key1 => 1, key2 => 2});
	236	$result = $dbi->execute('select * from table1;');
	237	$rows = $result->all;
	238	is_deeply($rows, [{key1 => 1, key2 => 2}]);
	239
	240	test 'Filter basic';
	241	$dbi->delete_all(table => 'table1');
	242	$dbi->register_filter(twice => sub { $_[0] * 2},
	243	three_times => sub { $_[0] * 3});
	244
	245	$insert_source = "insert into table1 {insert_param key1 key2};";
	246	$insert_query = $dbi->execute($insert_source, {}, query => 1);
	247	$insert_query->filter({key1 => 'twice'});
	248	$dbi->execute($insert_query, param => {key1 => 1, key2 => 2});
	249	$result = $dbi->execute('select * from table1;');
	250	$rows = $result->filter({key2 => 'three_times'})->all;
	251	is_deeply($rows, [{key1 => 2, key2 => 6}], "filter fetch_filter");
	252
	253	test 'Filter in';
	254	$dbi->delete_all(table => 'table1');
	255	$insert_source = "insert into table1 {insert_param key1 key2};";
	256	$insert_query = $dbi->execute($insert_source, {}, query => 1);
	257	$dbi->execute($insert_query, param => {key1 => 2, key2 => 4});
	258	$select_source = "select * from table1 where {in table1.key1 2} and {in table1.key2 2}";
	259	$select_query = $dbi->execute($select_source,{}, query => 1);
	260	$select_query->filter({'table1.key1' => 'twice'});
	261	$result = $dbi->execute($select_query, param => {'table1.key1' => [1,5], 'table1.key2' => [2,4]});
	262	$rows = $result->all;
	263	is_deeply($rows, [{key1 => 2, key2 => 4}], "filter");
	264
cleanup test 08c3c54 Yuki Kimoto authored on 2011-08-08	265	test 'DBIx::Custom::SQLTemplate basic tag';
	266	$dbi->execute('drop table table1');
cleanup test 058b0fd Yuki Kimoto authored on 2011-08-08	267	$dbi->execute($create_table1_2);
cleanup test 08c3c54 Yuki Kimoto authored on 2011-08-08	268	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});
	269	$dbi->insert(table => 'table1', param => {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});
	270
	271	$source = "select * from table1 where key1 = :key1 and {<> key2} and {< key3} and {> key4} and {>= key5};";
	272	$query = $dbi->execute($source, {}, query => 1);
	273	$result = $dbi->execute($query, param => {key1 => 1, key2 => 3, key3 => 4, key4 => 3, key5 => 5});
	274	$rows = $result->all;
	275	is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "basic tag1");
	276
	277	$source = "select * from table1 where key1 = :key1 and {<> key2} and {< key3} and {> key4} and {>= key5};";
	278	$query = $dbi->execute($source, {}, query => 1);
	279	$result = $dbi->execute($query, {key1 => 1, key2 => 3, key3 => 4, key4 => 3, key5 => 5});
	280	$rows = $result->all;
	281	is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "basic tag1");
	282
	283	$source = "select * from table1 where {<= key1} and {like key2};";
	284	$query = $dbi->execute($source, {}, query => 1);
	285	$result = $dbi->execute($query, param => {key1 => 1, key2 => '%2%'});
	286	$rows = $result->all;
	287	is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "basic tag2");
	288
	289	test 'DIB::Custom::SQLTemplate in tag';
	290	$dbi->execute('drop table table1');
cleanup test 058b0fd Yuki Kimoto authored on 2011-08-08	291	$dbi->execute($create_table1_2);
cleanup test 08c3c54 Yuki Kimoto authored on 2011-08-08	292	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});
	293	$dbi->insert(table => 'table1', param => {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});
	294
	295	$source = "select * from table1 where {in key1 2};";
	296	$query = $dbi->execute($source, {}, query => 1);
	297	$result = $dbi->execute($query, param => {key1 => [9, 1]});
	298	$rows = $result->all;
	299	is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "basic");
	300
	301	test 'DBIx::Custom::SQLTemplate insert tag';
	302	$dbi->delete_all(table => 'table1');
	303	$insert_source = 'insert into table1 {insert_param key1 key2 key3 key4 key5}';
	304	$dbi->execute($insert_source, param => {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});
	305
	306	$result = $dbi->execute('select * from table1;');
	307	$rows = $result->all;
	308	is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "basic");
	309
	310	test 'DBIx::Custom::SQLTemplate update tag';
	311	$dbi->delete_all(table => 'table1');
	312	$insert_source = "insert into table1 {insert_param key1 key2 key3 key4 key5}";
	313	$dbi->execute($insert_source, param => {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});
	314	$dbi->execute($insert_source, param => {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});
	315
	316	$update_source = 'update table1 {update_param key1 key2 key3 key4} where {= key5}';
	317	$dbi->execute($update_source, param => {key1 => 1, key2 => 1, key3 => 1, key4 => 1, key5 => 5});
	318
	319	$result = $dbi->execute('select * from table1 order by key1;');
	320	$rows = $result->all;
	321	is_deeply($rows, [{key1 => 1, key2 => 1, key3 => 1, key4 => 1, key5 => 5},
	322	{key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10}], "basic");
	323
cleanup test 058b0fd Yuki Kimoto authored on 2011-08-08	324	test 'Named placeholder';
	325	$dbi->execute('drop table table1');
	326	$dbi->execute($create_table1_2);
	327	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});
	328	$dbi->insert(table => 'table1', param => {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});
	329
	330	$source = "select * from table1 where key1 = :key1 and key2 = :key2";
	331	$result = $dbi->execute($source, param => {key1 => 1, key2 => 2});
	332	$rows = $result->all;
	333	is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}]);
	334
	335	$source = "select * from table1 where key1 = \n:key1\n and key2 = :key2";
	336	$result = $dbi->execute($source, param => {key1 => 1, key2 => 2});
	337	$rows = $result->all;
	338	is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}]);
	339
	340	$source = "select * from table1 where key1 = :key1 or key1 = :key1";
	341	$result = $dbi->execute($source, param => {key1 => [1, 2]});
	342	$rows = $result->all;
	343	is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}]);
	344
	345	$source = "select * from table1 where key1 = :table1.key1 and key2 = :table1.key2";
	346	$result = $dbi->execute(
	347	$source,
	348	param => {'table1.key1' => 1, 'table1.key2' => 1},
	349	filter => {'table1.key2' => sub { $_[0] * 2 }}
	350	);
	351	$rows = $result->all;
	352	is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}]);
	353
	354	$dbi->execute('drop table table1');
	355	$dbi->execute($create_table1);
	356	$dbi->insert(table => 'table1', param => {key1 => '2011-10-14 12:19:18', key2 => 2});
	357	$source = "select * from table1 where key1 = '2011-10-14 12:19:18' and key2 = :key2";
	358	$result = $dbi->execute(
	359	$source,
	360	param => {'key2' => 2},
	361	);
	362
	363	$rows = $result->all;
	364	is_deeply($rows, [{key1 => '2011-10-14 12:19:18', key2 => 2}]);
	365
	366	$dbi->delete_all(table => 'table1');
	367	$dbi->insert(table => 'table1', param => {key1 => 'a:b c:d', key2 => 2});
	368	$source = "select * from table1 where key1 = 'a\\:b c\\:d' and key2 = :key2";
	369	$result = $dbi->execute(
	370	$source,
	371	param => {'key2' => 2},
	372	);
	373	$rows = $result->all;
	374	is_deeply($rows, [{key1 => 'a:b c:d', key2 => 2}]);
	375
test cleanup fcea70e Yuki Kimoto authored on 2011-08-10	376	test 'Error case';
	377	eval {DBIx::Custom->connect(dsn => 'dbi:SQLit')};
	378	ok($@, "connect error");
	379
	380	eval{$dbi->execute("{p }", {}, query => 1)};
	381	ok($@, "create_query invalid SQL template");
added EXPERIMENTAL DBIx::Cus... 38f4ef1 Yuki Kimoto authored on 2011-08-09	382
cleanup test 1c9417d Yuki Kimoto authored on 2011-08-10	383	test 'insert';
cleanup test bf179eb Yuki Kimoto authored on 2011-08-10	384	eval { $dbi->execute('drop table table1') };
	385	$dbi->execute($create_table1);
cleanup test 1c9417d Yuki Kimoto authored on 2011-08-10	386	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	387	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	388	$result = $dbi->execute('select * from table1;');
	389	$rows = $result->all;
	390	is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "basic");
	391
	392	$dbi->execute('delete from table1');
	393	$dbi->register_filter(
	394	twice => sub { $_[0] * 2 },
	395	three_times => sub { $_[0] * 3 }
	396	);
	397	$dbi->default_bind_filter('twice');
	398	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2}, filter => {key1 => 'three_times'});
	399	$result = $dbi->execute('select * from table1;');
	400	$rows = $result->all;
	401	is_deeply($rows, [{key1 => 3, key2 => 4}], "filter");
	402	$dbi->default_bind_filter(undef);
	403
cleanup test bf179eb Yuki Kimoto authored on 2011-08-10	404	$dbi->execute('drop table table1');
	405	$dbi->execute($create_table1);
cleanup test 1c9417d Yuki Kimoto authored on 2011-08-10	406	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2}, append => ' ');
	407	$rows = $dbi->select(table => 'table1')->all;
	408	is_deeply($rows, [{key1 => 1, key2 => 2}], 'insert append');
	409
	410	eval{$dbi->insert(table => 'table1', noexist => 1)};
	411	like($@, qr/noexist/, "invalid");
	412
	413	eval{$dbi->insert(table => 'table', param => {';' => 1})};
	414	like($@, qr/safety/);
	415
cleanup test bf179eb Yuki Kimoto authored on 2011-08-10	416	eval { $dbi->execute("drop table ${q}table$p") };
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	417	$dbi->execute($create_table_reserved);
cleanup test 1c9417d Yuki Kimoto authored on 2011-08-10	418	$dbi->apply_filter('table', select => {out => sub { $_[0] * 2}});
	419	$dbi->insert(table => 'table', param => {select => 1});
cleanup test bf179eb Yuki Kimoto authored on 2011-08-10	420	$result = $dbi->execute("select * from ${q}table$p");
cleanup test 1c9417d Yuki Kimoto authored on 2011-08-10	421	$rows = $result->all;
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	422	is_deeply($rows, [{select => 2, update => undef}], "reserved word");
cleanup test 1c9417d Yuki Kimoto authored on 2011-08-10	423
cleanup test bf179eb Yuki Kimoto authored on 2011-08-10	424	eval { $dbi->execute('drop table table1') };
cleanup test 1c9417d Yuki Kimoto authored on 2011-08-10	425	$dbi->execute($create_table1);
	426	$dbi->insert({key1 => 1, key2 => 2}, table => 'table1');
	427	$dbi->insert({key1 => 3, key2 => 4}, table => 'table1');
	428	$result = $dbi->execute('select * from table1;');
	429	$rows = $result->all;
	430	is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "basic");
	431
cleanup test bf179eb Yuki Kimoto authored on 2011-08-10	432	eval { $dbi->execute('drop table table1') };
cleanup test 1c9417d Yuki Kimoto authored on 2011-08-10	433	$dbi->execute($create_table1);
	434	$dbi->insert(table => 'table1', param => {key1 => \"'1'", key2 => 2});
	435	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	436	$result = $dbi->execute('select * from table1;');
	437	$rows = $result->all;
	438	is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "basic");
	439
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	440	test 'update';
	441	eval { $dbi->execute('drop table table1') };
	442	$dbi->execute($create_table1_2);
	443	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});
	444	$dbi->insert(table => 'table1', param => {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});
	445	$dbi->update(table => 'table1', param => {key2 => 11}, where => {key1 => 1});
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	446	$result = $dbi->execute('select * from table1 order by key1;');
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	447	$rows = $result->all;
	448	is_deeply($rows, [{key1 => 1, key2 => 11, key3 => 3, key4 => 4, key5 => 5},
	449	{key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10}],
	450	"basic");
	451
	452	$dbi->execute("delete from table1");
	453	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});
	454	$dbi->insert(table => 'table1', param => {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});
	455	$dbi->update(table => 'table1', param => {key2 => 12}, where => {key2 => 2, key3 => 3});
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	456	$result = $dbi->execute('select * from table1 order by key1;');
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	457	$rows = $result->all;
	458	is_deeply($rows, [{key1 => 1, key2 => 12, key3 => 3, key4 => 4, key5 => 5},
	459	{key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10}],
	460	"update key same as search key");
	461
	462	$dbi->update(table => 'table1', param => {key2 => [12]}, where => {key2 => 2, key3 => 3});
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	463	$result = $dbi->execute('select * from table1 order by key1;');
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	464	$rows = $result->all;
	465	is_deeply($rows, [{key1 => 1, key2 => 12, key3 => 3, key4 => 4, key5 => 5},
	466	{key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10}],
	467	"update key same as search key : param is array ref");
	468
	469	$dbi->execute("delete from table1");
	470	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});
	471	$dbi->insert(table => 'table1', param => {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});
	472	$dbi->register_filter(twice => sub { $_[0] * 2 });
	473	$dbi->update(table => 'table1', param => {key2 => 11}, where => {key1 => 1},
	474	filter => {key2 => sub { $_[0] * 2 }});
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	475	$result = $dbi->execute('select * from table1 order by key1;');
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	476	$rows = $result->all;
	477	is_deeply($rows, [{key1 => 1, key2 => 22, key3 => 3, key4 => 4, key5 => 5},
	478	{key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10}],
	479	"filter");
	480
	481	$result = $dbi->update(table => 'table1', param => {key2 => 11}, where => {key1 => 1}, append => ' ');
	482
	483	eval{$dbi->update(table => 'table1', where => {key1 => 1}, noexist => 1)};
	484	like($@, qr/noexist/, "invalid");
	485
	486	eval{$dbi->update(table => 'table1')};
	487	like($@, qr/where/, "not contain where");
	488
	489	eval { $dbi->execute('drop table table1') };
	490	$dbi->execute($create_table1);
	491	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	492	$where = $dbi->where;
	493	$where->clause(['and', 'key1 = :key1', 'key2 = :key2']);
	494	$where->param({key1 => 1, key2 => 2});
	495	$dbi->update(table => 'table1', param => {key1 => 3}, where => $where);
	496	$result = $dbi->select(table => 'table1');
	497	is_deeply($result->all, [{key1 => 3, key2 => 2}], 'update() where');
	498
	499	eval { $dbi->execute('drop table table1') };
	500	$dbi->execute($create_table1);
	501	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	502	$dbi->update(
	503	table => 'table1',
	504	param => {key1 => 3},
	505	where => [
	506	['and', 'key1 = :key1', 'key2 = :key2'],
	507	{key1 => 1, key2 => 2}
	508	]
	509	);
	510	$result = $dbi->select(table => 'table1');
	511	is_deeply($result->all, [{key1 => 3, key2 => 2}], 'update() where');
	512
	513	eval { $dbi->execute('drop table table1') };
	514	$dbi->execute($create_table1);
	515	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	516	$where = $dbi->where;
	517	$where->clause(['and', 'key2 = :key2']);
	518	$where->param({key2 => 2});
	519	$dbi->update(table => 'table1', param => {key1 => 3}, where => $where);
	520	$result = $dbi->select(table => 'table1');
	521	is_deeply($result->all, [{key1 => 3, key2 => 2}], 'update() where');
	522
	523	eval{$dbi->update(table => 'table1', param => {';' => 1})};
	524	like($@, qr/safety/);
	525
	526	eval{$dbi->update(table => 'table1', param => {'key1' => 1}, where => {';' => 1})};
	527	like($@, qr/safety/);
	528
	529	eval { $dbi->execute('drop table table1') };
	530	eval { $dbi->execute("drop table ${q}table$p") };
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	531	$dbi->execute($create_table_reserved);
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	532	$dbi->apply_filter('table', select => {out => sub { $_[0] * 2}});
	533	$dbi->apply_filter('table', update => {out => sub { $_[0] * 3}});
	534	$dbi->insert(table => 'table', param => {select => 1});
	535	$dbi->update(table => 'table', where => {select => 1}, param => {update => 2});
	536	$result = $dbi->execute("select * from ${q}table$p");
	537	$rows = $result->all;
	538	is_deeply($rows, [{select => 2, update => 6}], "reserved word");
	539
	540	eval {$dbi->update_all(table => 'table', param => {';' => 2}) };
	541	like($@, qr/safety/);
	542
	543	eval { $dbi->execute("drop table ${q}table$p") };
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	544	$dbi->execute($create_table_reserved);
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	545	$dbi->apply_filter('table', select => {out => sub { $_[0] * 2}});
	546	$dbi->apply_filter('table', update => {out => sub { $_[0] * 3}});
	547	$dbi->insert(table => 'table', param => {select => 1});
	548	$dbi->update(table => 'table', where => {'table.select' => 1}, param => {update => 2});
	549	$result = $dbi->execute("select * from ${q}table$p");
	550	$rows = $result->all;
	551	is_deeply($rows, [{select => 2, update => 6}], "reserved word");
	552
	553	eval { $dbi->execute('drop table table1') };
	554	$dbi->execute($create_table1_2);
	555	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});
	556	$dbi->insert(table => 'table1', param => {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});
	557	$dbi->update({key2 => 11}, table => 'table1', where => {key1 => 1});
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	558	$result = $dbi->execute('select * from table1 order by key1;');
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	559	$rows = $result->all;
	560	is_deeply($rows, [{key1 => 1, key2 => 11, key3 => 3, key4 => 4, key5 => 5},
	561	{key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10}],
	562	"basic");
	563
	564	eval { $dbi->execute('drop table table1') };
	565	$dbi->execute($create_table1_2);
	566	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});
	567	$dbi->insert(table => 'table1', param => {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});
	568	$dbi->update(table => 'table1', param => {key2 => \"'11'"}, where => {key1 => 1});
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	569	$result = $dbi->execute('select * from table1 order by key1;');
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	570	$rows = $result->all;
	571	is_deeply($rows, [{key1 => 1, key2 => 11, key3 => 3, key4 => 4, key5 => 5},
	572	{key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10}],
	573	"basic");
	574
	575	test 'update_all';
	576	eval { $dbi->execute('drop table table1') };
	577	$dbi->execute($create_table1_2);
	578	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});
	579	$dbi->insert(table => 'table1', param => {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});
	580	$dbi->register_filter(twice => sub { $_[0] * 2 });
	581	$dbi->update_all(table => 'table1', param => {key2 => 10}, filter => {key2 => 'twice'});
	582	$result = $dbi->execute('select * from table1;');
	583	$rows = $result->all;
	584	is_deeply($rows, [{key1 => 1, key2 => 20, key3 => 3, key4 => 4, key5 => 5},
	585	{key1 => 6, key2 => 20, key3 => 8, key4 => 9, key5 => 10}],
	586	"filter");
	587
	588
	589	test 'delete';
	590	eval { $dbi->execute('drop table table1') };
	591	$dbi->execute($create_table1);
	592	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	593	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	594	$dbi->delete(table => 'table1', where => {key1 => 1});
	595	$result = $dbi->execute('select * from table1;');
	596	$rows = $result->all;
	597	is_deeply($rows, [{key1 => 3, key2 => 4}], "basic");
	598
	599	$dbi->execute("delete from table1;");
	600	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	601	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	602	$dbi->register_filter(twice => sub { $_[0] * 2 });
	603	$dbi->delete(table => 'table1', where => {key2 => 1}, filter => {key2 => 'twice'});
	604	$result = $dbi->execute('select * from table1;');
	605	$rows = $result->all;
	606	is_deeply($rows, [{key1 => 3, key2 => 4}], "filter");
	607
	608	$dbi->delete(table => 'table1', where => {key1 => 1}, append => ' ');
	609
	610	$dbi->delete_all(table => 'table1');
	611	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	612	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	613	$dbi->delete(table => 'table1', where => {key1 => 1, key2 => 2});
	614	$rows = $dbi->select(table => 'table1')->all;
	615	is_deeply($rows, [{key1 => 3, key2 => 4}], "delete multi key");
	616
	617	eval{$dbi->delete(table => 'table1', where => {key1 => 1}, noexist => 1)};
	618	like($@, qr/noexist/, "invalid");
	619
	620	eval { $dbi->execute('drop table table1') };
	621	$dbi->execute($create_table1);
	622	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	623	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	624	$where = $dbi->where;
	625	$where->clause(['and', 'key1 = :key1', 'key2 = :key2']);
	626	$where->param({ke1 => 1, key2 => 2});
	627	$dbi->delete(table => 'table1', where => $where);
	628	$result = $dbi->select(table => 'table1');
	629	is_deeply($result->all, [{key1 => 3, key2 => 4}], 'delete() where');
	630
	631	eval { $dbi->execute('drop table table1') };
	632	$dbi->execute($create_table1);
	633	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	634	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	635	$dbi->delete(
	636	table => 'table1',
	637	where => [
	638	['and', 'key1 = :key1', 'key2 = :key2'],
	639	{ke1 => 1, key2 => 2}
	640	]
	641	);
	642	$result = $dbi->select(table => 'table1');
	643	is_deeply($result->all, [{key1 => 3, key2 => 4}], 'delete() where');
	644
	645	eval { $dbi->execute('drop table table1') };
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	646	$dbi->execute($create_table1);
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	647	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	648	$dbi->delete(table => 'table1', where => {key1 => 1}, prefix => ' ');
	649	$result = $dbi->execute('select * from table1;');
	650	$rows = $result->all;
	651	is_deeply($rows, [], "basic");
	652
	653	test 'delete error';
	654	eval { $dbi->execute('drop table table1') };
	655	$dbi->execute($create_table1);
	656	eval{$dbi->delete(table => 'table1')};
	657	like($@, qr/"where" must be specified/,
	658	"where key-value pairs not specified");
	659
	660	eval{$dbi->delete(table => 'table1', where => {';' => 1})};
	661	like($@, qr/safety/);
	662
	663	$dbi = DBIx::Custom->connect;
	664	eval { $dbi->execute("drop table ${q}table$p") };
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	665	$dbi->execute($create_table_reserved);
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	666	$dbi->apply_filter('table', select => {out => sub { $_[0] * 2}});
	667	$dbi->insert(table => 'table', param => {select => 1});
	668	$dbi->delete(table => 'table', where => {select => 1});
	669	$result = $dbi->execute("select * from ${q}table$p");
	670	$rows = $result->all;
	671	is_deeply($rows, [], "reserved word");
	672
	673	test 'delete_all';
	674	eval { $dbi->execute('drop table table1') };
	675	$dbi->execute($create_table1);
	676	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	677	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	678	$dbi->delete_all(table => 'table1');
	679	$result = $dbi->execute('select * from table1;');
	680	$rows = $result->all;
	681	is_deeply($rows, [], "basic");
	682
	683
	684	test 'select';
	685	eval { $dbi->execute('drop table table1') };
	686	$dbi->execute($create_table1);
	687	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	688	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	689	$rows = $dbi->select(table => 'table1')->all;
	690	is_deeply($rows, [{key1 => 1, key2 => 2},
	691	{key1 => 3, key2 => 4}], "table");
	692
	693	$rows = $dbi->select(table => 'table1', column => ['key1'])->all;
	694	is_deeply($rows, [{key1 => 1}, {key1 => 3}], "table and columns and where key");
	695
	696	$rows = $dbi->select(table => 'table1', where => {key1 => 1})->all;
	697	is_deeply($rows, [{key1 => 1, key2 => 2}], "table and columns and where key");
	698
	699	$rows = $dbi->select(table => 'table1', column => ['key1'], where => {key1 => 3})->all;
	700	is_deeply($rows, [{key1 => 3}], "table and columns and where key");
	701
	702	$rows = $dbi->select(table => 'table1', append => "order by key1 desc limit 1")->all;
	703	is_deeply($rows, [{key1 => 3, key2 => 4}], "append statement");
	704
	705	$dbi->register_filter(decrement => sub { $_[0] - 1 });
	706	$rows = $dbi->select(table => 'table1', where => {key1 => 2}, filter => {key1 => 'decrement'})
	707	->all;
	708	is_deeply($rows, [{key1 => 1, key2 => 2}], "filter");
	709
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	710	eval { $dbi->execute("drop table table2") };
	711	$dbi->execute($create_table2);
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	712	$dbi->insert(table => 'table2', param => {key1 => 1, key3 => 5});
	713	$rows = $dbi->select(
	714	table => [qw/table1 table2/],
	715	column => 'table1.key1 as table1_key1, table2.key1 as table2_key1, key2, key3',
	716	where => {'table1.key2' => 2},
	717	relation => {'table1.key1' => 'table2.key1'}
	718	)->all;
	719	is_deeply($rows, [{table1_key1 => 1, table2_key1 => 1, key2 => 2, key3 => 5}], "relation : exists where");
	720
	721	$rows = $dbi->select(
	722	table => [qw/table1 table2/],
	723	column => ['table1.key1 as table1_key1', 'table2.key1 as table2_key1', 'key2', 'key3'],
	724	relation => {'table1.key1' => 'table2.key1'}
	725	)->all;
	726	is_deeply($rows, [{table1_key1 => 1, table2_key1 => 1, key2 => 2, key3 => 5}], "relation : no exists where");
	727
	728	eval{$dbi->select(table => 'table1', noexist => 1)};
	729	like($@, qr/noexist/, "invalid");
	730
	731	$dbi = DBIx::Custom->connect;
test cleanup af035c8 Yuki Kimoto authored on 2011-08-10	732	eval { $dbi->execute("drop table ${q}table$p") };
	733	$dbi->execute($create_table_reserved);
test cleanup c05af26 Yuki Kimoto authored on 2011-08-10	734	$dbi->apply_filter('table', select => {out => sub { $_[0] * 2}});
	735	$dbi->insert(table => 'table', param => {select => 1, update => 2});
	736	$result = $dbi->select(table => 'table', where => {select => 1});
	737	$rows = $result->all;
	738	is_deeply($rows, [{select => 2, update => 2}], "reserved word");
	739
	740	test 'fetch filter';
	741	eval { $dbi->execute('drop table table1') };
	742	$dbi->register_filter(
	743	twice => sub { $_[0] * 2 },
	744	three_times => sub { $_[0] * 3 }
	745	);
	746	$dbi->default_fetch_filter('twice');
	747	$dbi->execute($create_table1);
	748	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	749	$result = $dbi->select(table => 'table1');
	750	$result->filter({key1 => 'three_times'});
	751	$row = $result->one;
	752	is_deeply($row, {key1 => 3, key2 => 4}, "default_fetch_filter and filter");
	753
	754	test 'filters';
	755	$dbi = DBIx::Custom->new;
	756
	757	is($dbi->filters->{decode_utf8}->(encode_utf8('あ')),
	758	'あ', "decode_utf8");
	759
	760	is($dbi->filters->{encode_utf8}->('あ'),
	761	encode_utf8('あ'), "encode_utf8");
	762
	763	test 'transaction';
	764	$dbi = DBIx::Custom->connect;
	765	eval { $dbi->execute('drop table table1') };
	766	$dbi->execute($create_table1);
	767	$dbi->dbh->begin_work;
	768	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	769	$dbi->insert(table => 'table1', param => {key1 => 2, key2 => 3});
	770	$dbi->dbh->commit;
	771	$result = $dbi->select(table => 'table1');
	772	is_deeply(scalar $result->all, [{key1 => 1, key2 => 2}, {key1 => 2, key2 => 3}],
	773	"commit");
	774
	775	$dbi = DBIx::Custom->connect;
	776	eval { $dbi->execute('drop table table1') };
	777	$dbi->execute($create_table1);
	778	$dbi->dbh->begin_work(0);
	779	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	780	$dbi->dbh->rollback;
	781
	782	$result = $dbi->select(table => 'table1');
	783	ok(! $result->fetch_first, "rollback");
	784
	785	test 'cache';
	786	eval { $dbi->execute('drop table table1') };
	787	$dbi->cache(1);
	788	$dbi->execute($create_table1);
	789	$source = 'select * from table1 where key1 = :key1 and key2 = :key2;';
	790	$dbi->execute($source, {}, query => 1);
	791	is_deeply($dbi->{_cached}->{$source},
	792	{sql => "select * from table1 where key1 = ? and key2 = ?;", columns => ['key1', 'key2'], tables => []}, "cache");
	793
	794	eval { $dbi->execute('drop table table1') };
	795	$dbi->execute($create_table1);
	796	$dbi->{_cached} = {};
	797	$dbi->cache(0);
	798	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	799	is(scalar keys %{$dbi->{_cached}}, 0, 'not cache');
	800
	801	test 'execute';
	802	eval { $dbi->execute('drop table table1') };
	803	$dbi->execute($create_table1);
	804	{
	805	local $Carp::Verbose = 0;
	806	eval{$dbi->execute('select * frm table1')};
	807	like($@, qr/\Qselect * frm table1;/, "fail prepare");
	808	like($@, qr/\.t /, "fail : not verbose");
	809	}
	810	{
	811	local $Carp::Verbose = 1;
	812	eval{$dbi->execute('select * frm table1')};
	813	like($@, qr/Custom.*\.t /s, "fail : verbose");
	814	}
	815
	816	eval{$dbi->execute('select * from table1', no_exists => 1)};
	817	like($@, qr/wrong/, "invald SQL");
	818
	819	$query = $dbi->execute('select * from table1 where key1 = :key1', {}, query => 1);
	820	$dbi->dbh->disconnect;
	821	eval{$dbi->execute($query, param => {key1 => {a => 1}})};
	822	ok($@, "execute fail");
	823
	824	{
	825	local $Carp::Verbose = 0;
	826	eval{$dbi->execute('select * from table1 where {0 key1}', {}, query => 1)};
	827	like($@, qr/\Q.t /, "caller spec : not vebose");
	828	}
	829	{
	830	local $Carp::Verbose = 1;
	831	eval{$dbi->execute('select * from table1 where {0 key1}', {}, query => 1)};
	832	like($@, qr/QueryBuilder.*\.t /s, "caller spec : not vebose");
	833	}
	834
	835
	836	test 'transaction';
	837	$dbi = DBIx::Custom->connect;
	838	eval { $dbi->execute('drop table table1') };
	839	$dbi->execute($create_table1);
	840
	841	$dbi->begin_work;
	842
	843	eval {
	844	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	845	die "Error";
	846	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	847	};
	848
	849	$dbi->rollback if $@;
	850
	851	$result = $dbi->select(table => 'table1');
	852	$rows = $result->all;
	853	is_deeply($rows, [], "rollback");
	854
	855	$dbi->begin_work;
	856
	857	eval {
	858	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	859	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	860	};
	861
	862	$dbi->commit unless $@;
	863
	864	$result = $dbi->select(table => 'table1');
	865	$rows = $result->all;
	866	is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "commit");
	867
	868	$dbi->dbh->{AutoCommit} = 0;
	869	eval{ $dbi->begin_work };
	870	ok($@, "exception");
	871	$dbi->dbh->{AutoCommit} = 1;
added EXPERIMENTAL DBIx::Cus... 38f4ef1 Yuki Kimoto authored on 2011-08-09	872
test cleanup 723ba3d Yuki Kimoto authored on 2011-08-10	873	test 'cache';
	874	eval { $dbi->execute('drop table table1') };
	875	$dbi->cache(1);
	876	$dbi->execute($create_table1);
	877	$source = 'select * from table1 where key1 = :key1 and key2 = :key2;';
	878	$dbi->execute($source, {}, query => 1);
	879	is_deeply($dbi->{_cached}->{$source},
	880	{sql => "select * from table1 where key1 = ? and key2 = ?;", columns => ['key1', 'key2'], tables => []}, "cache");
	881
	882	eval { $dbi->execute('drop table table1') };
	883	$dbi->execute($create_table1);
	884	$dbi->{_cached} = {};
	885	$dbi->cache(0);
	886	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	887	is(scalar keys %{$dbi->{_cached}}, 0, 'not cache');
	888
	889	test 'execute';
	890	eval { $dbi->execute('drop table table1') };
	891	$dbi->execute($create_table1);
	892	{
	893	local $Carp::Verbose = 0;
	894	eval{$dbi->execute('select * frm table1')};
	895	like($@, qr/\Qselect * frm table1;/, "fail prepare");
	896	like($@, qr/\.t /, "fail : not verbose");
	897	}
	898	{
	899	local $Carp::Verbose = 1;
	900	eval{$dbi->execute('select * frm table1')};
	901	like($@, qr/Custom.*\.t /s, "fail : verbose");
	902	}
	903
	904	eval{$dbi->execute('select * from table1', no_exists => 1)};
	905	like($@, qr/wrong/, "invald SQL");
	906
	907	$query = $dbi->execute('select * from table1 where key1 = :key1', {}, query => 1);
	908	$dbi->dbh->disconnect;
	909	eval{$dbi->execute($query, param => {key1 => {a => 1}})};
	910	ok($@, "execute fail");
	911
	912	{
	913	local $Carp::Verbose = 0;
	914	eval{$dbi->execute('select * from table1 where {0 key1}', {}, query => 1)};
	915	like($@, qr/\Q.t /, "caller spec : not vebose");
	916	}
	917	{
	918	local $Carp::Verbose = 1;
	919	eval{$dbi->execute('select * from table1 where {0 key1}', {}, query => 1)};
	920	like($@, qr/QueryBuilder.*\.t /s, "caller spec : not vebose");
	921	}
	922
	923
	924	test 'transaction';
	925	$dbi = DBIx::Custom->connect;
	926	eval { $dbi->execute('drop table table1') };
	927	$dbi->execute($create_table1);
	928
	929	$dbi->begin_work;
	930
	931	eval {
	932	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	933	die "Error";
	934	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	935	};
	936
	937	$dbi->rollback if $@;
	938
	939	$result = $dbi->select(table => 'table1');
	940	$rows = $result->all;
	941	is_deeply($rows, [], "rollback");
	942
	943	$dbi->begin_work;
	944
	945	eval {
	946	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	947	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	948	};
	949
	950	$dbi->commit unless $@;
	951
	952	$result = $dbi->select(table => 'table1');
	953	$rows = $result->all;
	954	is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "commit");
	955
	956	$dbi->dbh->{AutoCommit} = 0;
	957	eval{ $dbi->begin_work };
	958	ok($@, "exception");
	959	$dbi->dbh->{AutoCommit} = 1;
	960
	961
	962	test 'method';
	963	$dbi->method(
	964	one => sub { 1 }
	965	);
	966	$dbi->method(
	967	two => sub { 2 }
	968	);
	969	$dbi->method({
	970	twice => sub {
	971	my $self = shift;
	972	return $_[0] * 2;
	973	}
	974	});
	975
	976	is($dbi->one, 1, "first");
	977	is($dbi->two, 2, "second");
	978	is($dbi->twice(5), 10 , "second");
	979
	980	eval {$dbi->XXXXXX};
	981	ok($@, "not exists");
	982
	983	test 'out filter';
	984	$dbi = DBIx::Custom->connect;
	985	eval { $dbi->execute('drop table table1') };
	986	$dbi->execute($create_table1);
	987	$dbi->register_filter(twice => sub { $_[0] * 2 });
	988	$dbi->register_filter(three_times => sub { $_[0] * 3});
	989	$dbi->apply_filter(
	990	'table1', 'key1' => {out => 'twice', in => 'three_times'},
	991	'key2' => {out => 'three_times', in => 'twice'});
	992	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	993	$result = $dbi->execute('select * from table1;');
	994	$row = $result->fetch_hash_first;
	995	is_deeply($row, {key1 => 2, key2 => 6}, "insert");
	996	$result = $dbi->select(table => 'table1');
	997	$row = $result->one;
	998	is_deeply($row, {key1 => 6, key2 => 12}, "insert");
	999
	1000	$dbi = DBIx::Custom->connect;
	1001	eval { $dbi->execute('drop table table1') };
	1002	$dbi->execute($create_table1);
	1003	$dbi->register_filter(twice => sub { $_[0] * 2 });
	1004	$dbi->register_filter(three_times => sub { $_[0] * 3});
	1005	$dbi->apply_filter(
	1006	'table1', 'key1' => {out => 'twice', in => 'three_times'},
	1007	'key2' => {out => 'three_times', in => 'twice'});
	1008	$dbi->apply_filter(
	1009	'table1', 'key1' => {out => undef}
	1010	);
	1011	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	1012	$result = $dbi->execute('select * from table1;');
	1013	$row = $result->one;
	1014	is_deeply($row, {key1 => 1, key2 => 6}, "insert");
	1015
	1016	$dbi = DBIx::Custom->connect;
	1017	eval { $dbi->execute('drop table table1') };
	1018	$dbi->execute($create_table1);
	1019	$dbi->register_filter(twice => sub { $_[0] * 2 });
	1020	$dbi->apply_filter(
	1021	'table1', 'key1' => {out => 'twice', in => 'twice'}
	1022	);
	1023	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2}, filter => {key1 => undef});
	1024	$dbi->update(table => 'table1', param => {key1 => 2}, where => {key2 => 2});
	1025	$result = $dbi->execute('select * from table1;');
	1026	$row = $result->one;
	1027	is_deeply($row, {key1 => 4, key2 => 2}, "update");
	1028
	1029	$dbi = DBIx::Custom->connect;
	1030	eval { $dbi->execute('drop table table1') };
	1031	$dbi->execute($create_table1);
	1032	$dbi->register_filter(twice => sub { $_[0] * 2 });
	1033	$dbi->apply_filter(
	1034	'table1', 'key1' => {out => 'twice', in => 'twice'}
	1035	);
	1036	$dbi->insert(table => 'table1', param => {key1 => 2, key2 => 2}, filter => {key1=> undef});
	1037	$dbi->delete(table => 'table1', where => {key1 => 1});
	1038	$result = $dbi->execute('select * from table1;');
	1039	$rows = $result->all;
	1040	is_deeply($rows, [], "delete");
	1041
	1042	$dbi = DBIx::Custom->connect;
	1043	eval { $dbi->execute('drop table table1') };
	1044	$dbi->execute($create_table1);
	1045	$dbi->register_filter(twice => sub { $_[0] * 2 });
	1046	$dbi->apply_filter(
	1047	'table1', 'key1' => {out => 'twice', in => 'twice'}
	1048	);
	1049	$dbi->insert(table => 'table1', param => {key1 => 2, key2 => 2}, filter => {key1 => undef});
	1050	$result = $dbi->select(table => 'table1', where => {key1 => 1});
	1051	$result->filter({'key2' => 'twice'});
	1052	$rows = $result->all;
	1053	is_deeply($rows, [{key1 => 4, key2 => 4}], "select");
	1054
	1055	$dbi = DBIx::Custom->connect;
	1056	eval { $dbi->execute('drop table table1') };
	1057	$dbi->execute($create_table1);
	1058	$dbi->register_filter(twice => sub { $_[0] * 2 });
	1059	$dbi->apply_filter(
	1060	'table1', 'key1' => {out => 'twice', in => 'twice'}
	1061	);
	1062	$dbi->insert(table => 'table1', param => {key1 => 2, key2 => 2}, filter => {key1 => undef});
	1063	$result = $dbi->execute("select * from table1 where key1 = :key1 and key2 = :key2;",
	1064	param => {key1 => 1, key2 => 2},
	1065	table => ['table1']);
	1066	$rows = $result->all;
	1067	is_deeply($rows, [{key1 => 4, key2 => 2}], "execute");
	1068
	1069	$dbi = DBIx::Custom->connect;
	1070	eval { $dbi->execute('drop table table1') };
	1071	$dbi->execute($create_table1);
	1072	$dbi->register_filter(twice => sub { $_[0] * 2 });
	1073	$dbi->apply_filter(
	1074	'table1', 'key1' => {out => 'twice', in => 'twice'}
	1075	);
	1076	$dbi->insert(table => 'table1', param => {key1 => 2, key2 => 2}, filter => {key1 => undef});
	1077	$result = $dbi->execute("select * from {table table1} where key1 = :key1 and key2 = :key2;",
	1078	param => {key1 => 1, key2 => 2});
	1079	$rows = $result->all;
	1080	is_deeply($rows, [{key1 => 4, key2 => 2}], "execute table tag");
	1081
	1082	$dbi = DBIx::Custom->connect;
	1083	eval { $dbi->execute('drop table table1') };
	1084	eval { $dbi->execute('drop table table2') };
	1085	$dbi->execute($create_table1);
	1086	$dbi->execute($create_table2);
	1087	$dbi->register_filter(twice => sub { $_[0] * 2 });
	1088	$dbi->register_filter(three_times => sub { $_[0] * 3 });
	1089	$dbi->apply_filter(
	1090	'table1', 'key2' => {out => 'twice', in => 'twice'}
	1091	);
	1092	$dbi->apply_filter(
	1093	'table2', 'key3' => {out => 'three_times', in => 'three_times'}
	1094	);
	1095	$dbi->insert(table => 'table1', param => {key1 => 5, key2 => 2}, filter => {key2 => undef});
	1096	$dbi->insert(table => 'table2', param => {key1 => 5, key3 => 6}, filter => {key3 => undef});
	1097	$result = $dbi->select(
	1098	table => ['table1', 'table2'],
	1099	column => ['key2', 'key3'],
	1100	where => {'table1.key2' => 1, 'table2.key3' => 2}, relation => {'table1.key1' => 'table2.key1'});
	1101
	1102	$result->filter({'key2' => 'twice'});
	1103	$rows = $result->all;
	1104	is_deeply($rows, [{key2 => 4, key3 => 18}], "select : join");
	1105
	1106	$result = $dbi->select(
	1107	table => ['table1', 'table2'],
	1108	column => ['key2', 'key3'],
	1109	where => {'key2' => 1, 'key3' => 2}, relation => {'table1.key1' => 'table2.key1'});
	1110
	1111	$result->filter({'key2' => 'twice'});
	1112	$rows = $result->all;
	1113	is_deeply($rows, [{key2 => 4, key3 => 18}], "select : join : omit");
	1114
	1115	test 'each_column';
	1116	$dbi = DBIx::Custom->connect;
	1117	eval { $dbi->execute("drop table ${q}table$p") };
	1118	eval { $dbi->execute('drop table table1') };
	1119	eval { $dbi->execute('drop table table2') };
test cleranup 5e1d777 Yuki Kimoto authored on 2011-08-10	1120	eval { $dbi->execute('drop table table3') };
test cleanup 723ba3d Yuki Kimoto authored on 2011-08-10	1121	$dbi->execute($create_table1_type);
	1122	$dbi->execute($create_table2);
	1123
	1124	$infos = [];
	1125	$dbi->each_column(sub {
	1126	my ($self, $table, $column, $cinfo) = @_;
	1127
	1128	if ($table =~ /^table\d/) {
	1129	my $info = [$table, $column, $cinfo->{COLUMN_NAME}];
	1130	push @$infos, $info;
	1131	}
	1132	});
	1133	$infos = [sort { $a->[0] cmp $b->[0] \|\| $a->[1] cmp $b->[1] } @$infos];
	1134	is_deeply($infos,
	1135	[
	1136	['table1', 'key1', 'key1'],
	1137	['table1', 'key2', 'key2'],
	1138	['table2', 'key1', 'key1'],
	1139	['table2', 'key3', 'key3']
	1140	]
	1141
	1142	);
	1143	test 'each_table';
	1144	$dbi = DBIx::Custom->connect;
	1145	eval { $dbi->execute('drop table table1') };
	1146	eval { $dbi->execute('drop table table2') };
	1147	$dbi->execute($create_table2);
	1148	$dbi->execute($create_table1_type);
	1149
	1150	$infos = [];
	1151	$dbi->each_table(sub {
	1152	my ($self, $table, $table_info) = @_;
	1153
	1154	if ($table =~ /^table\d/) {
	1155	my $info = [$table, $table_info->{TABLE_NAME}];
	1156	push @$infos, $info;
	1157	}
	1158	});
	1159	$infos = [sort { $a->[0] cmp $b->[0] \|\| $a->[1] cmp $b->[1] } @$infos];
	1160	is_deeply($infos,
	1161	[
	1162	['table1', 'table1'],
	1163	['table2', 'table2'],
	1164	]
	1165	);
	1166
	1167	test 'limit';
	1168	$dbi = DBIx::Custom->connect;
	1169	eval { $dbi->execute('drop table table1') };
	1170	$dbi->execute($create_table1);
	1171	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	1172	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 4});
	1173	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 6});
	1174	$dbi->register_tag(
	1175	limit => sub {
	1176	my ($count, $offset) = @_;
	1177
	1178	my $s = '';
	1179	$s .= "limit $count";
	1180	$s .= " offset $offset" if defined $offset;
	1181
	1182	return [$s, []];
	1183	}
	1184	);
	1185	$rows = $dbi->select(
	1186	table => 'table1',
	1187	where => {key1 => 1},
	1188	append => "order by key2 {limit 1 0}"
	1189	)->all;
	1190	is_deeply($rows, [{key1 => 1, key2 => 2}]);
	1191	$rows = $dbi->select(
	1192	table => 'table1',
	1193	where => {key1 => 1},
	1194	append => "order by key2 {limit 2 1}"
	1195	)->all;
	1196	is_deeply($rows, [{key1 => 1, key2 => 4},{key1 => 1, key2 => 6}]);
	1197	$rows = $dbi->select(
	1198	table => 'table1',
	1199	where => {key1 => 1},
	1200	append => "order by key2 {limit 1}"
	1201	)->all;
	1202	is_deeply($rows, [{key1 => 1, key2 => 2}]);
	1203
	1204	test 'connect super';
test cleanup e5d6e22 Yuki Kimoto authored on 2011-08-10	1205	$dbi = DBIx::Custom->connect;
test cleanup 723ba3d Yuki Kimoto authored on 2011-08-10	1206	eval { $dbi->execute('drop table table1') };
	1207	$dbi->execute($create_table1);
	1208	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	1209	is($dbi->select(table => 'table1')->one->{key1}, 1);
	1210
test cleanup e5d6e22 Yuki Kimoto authored on 2011-08-10	1211	$dbi = DBIx::Custom->new;
test cleanup 723ba3d Yuki Kimoto authored on 2011-08-10	1212	$dbi->connect;
	1213	eval { $dbi->execute('drop table table1') };
	1214	$dbi->execute($create_table1);
	1215	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	1216	is($dbi->select(table => 'table1')->one->{key1}, 1);
	1217
test cleanup e5d6e22 Yuki Kimoto authored on 2011-08-10	1218	$dbi = DBIx::Custom->connect;
test cleanup 723ba3d Yuki Kimoto authored on 2011-08-10	1219	eval { $dbi->execute('drop table table1') };
	1220	$dbi->execute($create_table1);
	1221	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	1222	is($dbi->select(table => 'table1')->one->{key1}, 1);
	1223
	1224	test 'end_filter';
	1225	$dbi = DBIx::Custom->connect;
	1226	eval { $dbi->execute('drop table table1') };
	1227	$dbi->execute($create_table1);
	1228	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	1229	$result = $dbi->select(table => 'table1');
	1230	$result->filter(key1 => sub { $_[0] * 2 }, key2 => sub { $_[0] * 4 });
	1231	$result->end_filter(key1 => sub { $_[0] * 3 }, key2 => sub { $_[0] * 5 });
	1232	$row = $result->fetch_first;
	1233	is_deeply($row, [6, 40]);
	1234
	1235	$dbi = DBIx::Custom->connect;
	1236	eval { $dbi->execute('drop table table1') };
	1237	$dbi->execute($create_table1);
	1238	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	1239	$result = $dbi->select(table => 'table1');
	1240	$result->filter([qw/key1 key2/] => sub { $_[0] * 2 });
	1241	$result->end_filter([[qw/key1 key2/] => sub { $_[0] * 3 }]);
	1242	$row = $result->fetch_first;
	1243	is_deeply($row, [6, 12]);
	1244
	1245	$dbi = DBIx::Custom->connect;
	1246	eval { $dbi->execute('drop table table1') };
	1247	$dbi->execute($create_table1);
	1248	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	1249	$result = $dbi->select(table => 'table1');
	1250	$result->filter([[qw/key1 key2/] => sub { $_[0] * 2 }]);
	1251	$result->end_filter([qw/key1 key2/] => sub { $_[0] * 3 });
	1252	$row = $result->fetch_first;
	1253	is_deeply($row, [6, 12]);
	1254
	1255	$dbi->register_filter(five_times => sub { $_[0] * 5 });
	1256	$result = $dbi->select(table => 'table1');
	1257	$result->filter(key1 => sub { $_[0] * 2 }, key2 => sub { $_[0] * 4 });
	1258	$result->end_filter({key1 => sub { $_[0] * 3 }, key2 => 'five_times' });
	1259	$row = $result->one;
	1260	is_deeply($row, {key1 => 6, key2 => 40});
	1261
	1262	$dbi->register_filter(five_times => sub { $_[0] * 5 });
	1263	$dbi->apply_filter('table1',
	1264	key1 => {end => sub { $_[0] * 3 } },
	1265	key2 => {end => 'five_times'}
	1266	);
	1267	$result = $dbi->select(table => 'table1');
	1268	$result->filter(key1 => sub { $_[0] * 2 }, key2 => sub { $_[0] * 4 });
	1269	$row = $result->one;
	1270	is_deeply($row, {key1 => 6, key2 => 40}, 'apply_filter');
	1271
	1272	$dbi->register_filter(five_times => sub { $_[0] * 5 });
	1273	$dbi->apply_filter('table1',
	1274	key1 => {end => sub { $_[0] * 3 } },
	1275	key2 => {end => 'five_times'}
	1276	);
	1277	$result = $dbi->select(table => 'table1');
	1278	$result->filter(key1 => sub { $_[0] * 2 }, key2 => sub { $_[0] * 4 });
	1279	$result->filter(key1 => undef);
	1280	$result->end_filter(key1 => undef);
	1281	$row = $result->one;
	1282	is_deeply($row, {key1 => 1, key2 => 40}, 'apply_filter overwrite');
	1283
test cleanup b7c037f Yuki Kimoto authored on 2011-08-10	1284	test 'remove_end_filter and remove_filter';
	1285	$dbi = DBIx::Custom->connect;
	1286	eval { $dbi->execute('drop table table1') };
	1287	$dbi->execute($create_table1);
	1288	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	1289	$result = $dbi->select(table => 'table1');
	1290	$row = $result
	1291	->filter(key1 => sub { $_[0] * 2 }, key2 => sub { $_[0] * 4 })
	1292	->remove_filter
	1293	->end_filter(key1 => sub { $_[0] * 3 }, key2 => sub { $_[0] * 5 })
	1294	->remove_end_filter
	1295	->fetch_first;
	1296	is_deeply($row, [1, 2]);
	1297
	1298	test 'empty where select';
	1299	$dbi = DBIx::Custom->connect;
	1300	eval { $dbi->execute('drop table table1') };
	1301	$dbi->execute($create_table1);
	1302	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	1303	$result = $dbi->select(table => 'table1', where => {});
	1304	$row = $result->one;
	1305	is_deeply($row, {key1 => 1, key2 => 2});
	1306
	1307	test 'select query option';
	1308	$dbi = DBIx::Custom->connect;
	1309	eval { $dbi->execute('drop table table1') };
	1310	$dbi->execute($create_table1);
	1311	$query = $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2}, query => 1);
	1312	is(ref $query, 'DBIx::Custom::Query');
	1313	$query = $dbi->update(table => 'table1', where => {key1 => 1}, param => {key2 => 2}, query => 1);
	1314	is(ref $query, 'DBIx::Custom::Query');
	1315	$query = $dbi->delete(table => 'table1', where => {key1 => 1}, query => 1);
	1316	is(ref $query, 'DBIx::Custom::Query');
	1317	$query = $dbi->select(table => 'table1', where => {key1 => 1, key2 => 2}, query => 1);
	1318	is(ref $query, 'DBIx::Custom::Query');
	1319
	1320	test 'where';
	1321	$dbi = DBIx::Custom->connect;
	1322	eval { $dbi->execute('drop table table1') };
	1323	$dbi->execute($create_table1);
	1324	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	1325	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	1326	$where = $dbi->where->clause(['and', 'key1 = :key1', 'key2 = :key2']);
	1327	is("$where", "where ( key1 = :key1 and key2 = :key2 )", 'no param');
	1328
	1329	$where = $dbi->where
	1330	->clause(['and', 'key1 = :key1', 'key2 = :key2'])
	1331	->param({key1 => 1});
	1332
	1333	$result = $dbi->select(
	1334	table => 'table1',
	1335	where => $where
	1336	);
	1337	$row = $result->all;
	1338	is_deeply($row, [{key1 => 1, key2 => 2}]);
	1339
	1340	$result = $dbi->select(
	1341	table => 'table1',
	1342	where => [
	1343	['and', 'key1 = :key1', 'key2 = :key2'],
	1344	{key1 => 1}
	1345	]
	1346	);
	1347	$row = $result->all;
	1348	is_deeply($row, [{key1 => 1, key2 => 2}]);
	1349
	1350	$where = $dbi->where
	1351	->clause(['and', 'key1 = :key1', 'key2 = :key2'])
	1352	->param({key1 => 1, key2 => 2});
	1353	$result = $dbi->select(
	1354	table => 'table1',
	1355	where => $where
	1356	);
	1357	$row = $result->all;
	1358	is_deeply($row, [{key1 => 1, key2 => 2}]);
	1359
	1360	$where = $dbi->where
	1361	->clause(['and', 'key1 = :key1', 'key2 = :key2'])
	1362	->param({});
	1363	$result = $dbi->select(
	1364	table => 'table1',
	1365	where => $where,
	1366	);
	1367	$row = $result->all;
	1368	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}]);
	1369
	1370	$where = $dbi->where
	1371	->clause(['and', ['or', 'key1 > :key1', 'key1 < :key1'], 'key2 = :key2'])
	1372	->param({key1 => [0, 3], key2 => 2});
	1373	$result = $dbi->select(
	1374	table => 'table1',
	1375	where => $where,
	1376	);
	1377	$row = $result->all;
	1378	is_deeply($row, [{key1 => 1, key2 => 2}]);
	1379
	1380	$where = $dbi->where;
	1381	$result = $dbi->select(
	1382	table => 'table1',
	1383	where => $where
	1384	);
	1385	$row = $result->all;
	1386	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}]);
	1387
	1388	eval {
	1389	$where = $dbi->where
	1390	->clause(['uuu']);
	1391	$result = $dbi->select(
	1392	table => 'table1',
	1393	where => $where
	1394	);
	1395	};
	1396	ok($@);
	1397
	1398	$where = $dbi->where;
	1399	is("$where", '');
	1400
	1401	$where = $dbi->where
	1402	->clause(['or', ('key1 = :key1') x 2])
	1403	->param({key1 => [1, 3]});
	1404	$result = $dbi->select(
	1405	table => 'table1',
	1406	where => $where,
	1407	);
	1408	$row = $result->all;
	1409	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}]);
	1410
	1411	$where = $dbi->where
	1412	->clause(['or', ('key1 = :key1') x 2])
	1413	->param({key1 => [1]});
	1414	$result = $dbi->select(
	1415	table => 'table1',
	1416	where => $where,
	1417	);
	1418	$row = $result->all;
	1419	is_deeply($row, [{key1 => 1, key2 => 2}]);
	1420
	1421	$where = $dbi->where
	1422	->clause(['or', ('key1 = :key1') x 2])
	1423	->param({key1 => 1});
	1424	$result = $dbi->select(
	1425	table => 'table1',
	1426	where => $where,
	1427	);
	1428	$row = $result->all;
	1429	is_deeply($row, [{key1 => 1, key2 => 2}]);
	1430
	1431	$where = $dbi->where
	1432	->clause('key1 = :key1')
	1433	->param({key1 => 1});
	1434	$result = $dbi->select(
	1435	table => 'table1',
	1436	where => $where,
	1437	);
	1438	$row = $result->all;
	1439	is_deeply($row, [{key1 => 1, key2 => 2}]);
	1440
	1441	$where = $dbi->where
	1442	->clause('key1 = :key1 key2 = :key2')
	1443	->param({key1 => 1});
	1444	eval{$where->to_string};
	1445	like($@, qr/one column/);
	1446
	1447	$where = $dbi->where
	1448	->clause(['or', ('key1 = :key1') x 3])
	1449	->param({key1 => [$dbi->not_exists, 1, 3]});
	1450	$result = $dbi->select(
	1451	table => 'table1',
	1452	where => $where,
	1453	);
	1454	$row = $result->all;
	1455	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], 'not_exists');
	1456
	1457	$where = $dbi->where
	1458	->clause(['or', ('key1 = :key1') x 3])
	1459	->param({key1 => [1, $dbi->not_exists, 3]});
	1460	$result = $dbi->select(
	1461	table => 'table1',
	1462	where => $where,
	1463	);
	1464	$row = $result->all;
	1465	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], 'not_exists');
	1466
	1467	$where = $dbi->where
	1468	->clause(['or', ('key1 = :key1') x 3])
	1469	->param({key1 => [1, 3, $dbi->not_exists]});
	1470	$result = $dbi->select(
	1471	table => 'table1',
	1472	where => $where,
	1473	);
	1474	$row = $result->all;
	1475	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], 'not_exists');
	1476
	1477	$where = $dbi->where
	1478	->clause(['or', ('key1 = :key1') x 3])
	1479	->param({key1 => [1, $dbi->not_exists, $dbi->not_exists]});
	1480	$result = $dbi->select(
	1481	table => 'table1',
	1482	where => $where,
	1483	);
	1484	$row = $result->all;
	1485	is_deeply($row, [{key1 => 1, key2 => 2}], 'not_exists');
	1486
	1487	$where = $dbi->where
	1488	->clause(['or', ('key1 = :key1') x 3])
	1489	->param({key1 => [$dbi->not_exists, 1, $dbi->not_exists]});
	1490	$result = $dbi->select(
	1491	table => 'table1',
	1492	where => $where,
	1493	);
	1494	$row = $result->all;
	1495	is_deeply($row, [{key1 => 1, key2 => 2}], 'not_exists');
	1496
	1497	$where = $dbi->where
	1498	->clause(['or', ('key1 = :key1') x 3])
	1499	->param({key1 => [$dbi->not_exists, $dbi->not_exists, 1]});
	1500	$result = $dbi->select(
	1501	table => 'table1',
	1502	where => $where,
	1503	);
	1504	$row = $result->all;
	1505	is_deeply($row, [{key1 => 1, key2 => 2}], 'not_exists');
	1506
	1507	$where = $dbi->where
	1508	->clause(['or', ('key1 = :key1') x 3])
	1509	->param({key1 => [$dbi->not_exists, $dbi->not_exists, $dbi->not_exists]});
	1510	$result = $dbi->select(
	1511	table => 'table1',
	1512	where => $where,
	1513	);
	1514	$row = $result->all;
	1515	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], 'not_exists');
	1516
	1517	$where = $dbi->where
	1518	->clause(['or', ('key1 = :key1') x 3])
	1519	->param({key1 => []});
	1520	$result = $dbi->select(
	1521	table => 'table1',
	1522	where => $where,
	1523	);
	1524	$row = $result->all;
	1525	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], 'not_exists');
	1526
	1527	$where = $dbi->where
	1528	->clause(['and', '{> key1}', '{< key1}' ])
	1529	->param({key1 => [2, $dbi->not_exists]});
	1530	$result = $dbi->select(
	1531	table => 'table1',
	1532	where => $where,
	1533	);
	1534	$row = $result->all;
	1535	is_deeply($row, [{key1 => 3, key2 => 4}], 'not_exists');
	1536
	1537	$where = $dbi->where
	1538	->clause(['and', '{> key1}', '{< key1}' ])
	1539	->param({key1 => [$dbi->not_exists, 2]});
	1540	$result = $dbi->select(
	1541	table => 'table1',
	1542	where => $where,
	1543	);
	1544	$row = $result->all;
	1545	is_deeply($row, [{key1 => 1, key2 => 2}], 'not_exists');
	1546
	1547	$where = $dbi->where
	1548	->clause(['and', '{> key1}', '{< key1}' ])
	1549	->param({key1 => [$dbi->not_exists, $dbi->not_exists]});
	1550	$result = $dbi->select(
	1551	table => 'table1',
	1552	where => $where,
	1553	);
	1554	$row = $result->all;
	1555	is_deeply($row, [{key1 => 1, key2 => 2},{key1 => 3, key2 => 4}], 'not_exists');
	1556
	1557	$where = $dbi->where
	1558	->clause(['and', '{> key1}', '{< key1}' ])
	1559	->param({key1 => [0, 2]});
	1560	$result = $dbi->select(
	1561	table => 'table1',
	1562	where => $where,
	1563	);
	1564	$row = $result->all;
	1565	is_deeply($row, [{key1 => 1, key2 => 2}], 'not_exists');
	1566
	1567	$where = $dbi->where
	1568	->clause(['and', 'key1 is not null', 'key2 is not null' ]);
	1569	$result = $dbi->select(
	1570	table => 'table1',
	1571	where => $where,
	1572	);
	1573	$row = $result->all;
	1574	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], 'not_exists');
	1575
	1576	eval {$dbi->where(ppp => 1) };
	1577	like($@, qr/invalid/);
	1578
	1579	$where = $dbi->where(
	1580	clause => ['and', ['or'], ['and', 'key1 = :key1', 'key2 = :key2']],
	1581	param => {key1 => 1, key2 => 2}
	1582	);
	1583	$result = $dbi->select(
	1584	table => 'table1',
	1585	where => $where,
	1586	);
	1587	$row = $result->all;
	1588	is_deeply($row, [{key1 => 1, key2 => 2}]);
	1589
	1590
	1591	$where = $dbi->where(
	1592	clause => ['and', ['or'], ['or', ':key1', ':key2']],
	1593	param => {}
	1594	);
	1595	$result = $dbi->select(
	1596	table => 'table1',
	1597	where => $where,
	1598	);
	1599	$row = $result->all;
	1600	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}]);
	1601
	1602	$where = $dbi->where;
	1603	$where->clause(['and', ':key1{=}']);
	1604	$where->param({key1 => undef});
	1605	$result = $dbi->execute("select * from table1 $where", {key1 => 1});
	1606	$row = $result->all;
	1607	is_deeply($row, [{key1 => 1, key2 => 2}]);
	1608
	1609	$where = $dbi->where;
	1610	$where->clause(['and', ':key1{=}']);
	1611	$where->param({key1 => undef});
	1612	$where->if('defined');
	1613	$where->map;
	1614	$result = $dbi->execute("select * from table1 $where", {key1 => 1});
	1615	$row = $result->all;
	1616	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}]);
	1617
	1618	$where = $dbi->where;
	1619	$where->clause(['or', ':key1{=}', ':key1{=}']);
	1620	$where->param({key1 => [undef, undef]});
	1621	$result = $dbi->execute("select * from table1 $where", {key1 => [1, 0]});
	1622	$row = $result->all;
	1623	is_deeply($row, [{key1 => 1, key2 => 2}]);
	1624	$result = $dbi->execute("select * from table1 $where", {key1 => [0, 1]});
	1625	$row = $result->all;
	1626	is_deeply($row, [{key1 => 1, key2 => 2}]);
	1627
	1628	$where = $dbi->where;
	1629	$where->clause(['and', ':key1{=}']);
	1630	$where->param({key1 => [undef, undef]});
	1631	$where->if('defined');
	1632	$where->map;
	1633	$result = $dbi->execute("select * from table1 $where", {key1 => [1, 0]});
	1634	$row = $result->all;
	1635	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}]);
	1636	$result = $dbi->execute("select * from table1 $where", {key1 => [0, 1]});
	1637	$row = $result->all;
	1638	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}]);
	1639
	1640	$where = $dbi->where;
	1641	$where->clause(['and', ':key1{=}']);
	1642	$where->param({key1 => 0});
	1643	$where->if('length');
	1644	$where->map;
	1645	$result = $dbi->execute("select * from table1 $where", {key1 => 1});
	1646	$row = $result->all;
	1647	is_deeply($row, [{key1 => 1, key2 => 2}]);
	1648
	1649	$where = $dbi->where;
	1650	$where->clause(['and', ':key1{=}']);
	1651	$where->param({key1 => ''});
	1652	$where->if('length');
	1653	$where->map;
	1654	$result = $dbi->execute("select * from table1 $where", {key1 => 1});
	1655	$row = $result->all;
	1656	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}]);
	1657
	1658	$where = $dbi->where;
	1659	$where->clause(['and', ':key1{=}']);
	1660	$where->param({key1 => 5});
	1661	$where->if(sub { ($_[0] \|\| '') eq 5 });
	1662	$where->map;
	1663	$result = $dbi->execute("select * from table1 $where", {key1 => 1});
	1664	$row = $result->all;
	1665	is_deeply($row, [{key1 => 1, key2 => 2}]);
	1666
	1667	$where = $dbi->where;
	1668	$where->clause(['and', ':key1{=}']);
	1669	$where->param({key1 => 7});
	1670	$where->if(sub { ($_[0] \|\| '') eq 5 });
	1671	$where->map;
	1672	$result = $dbi->execute("select * from table1 $where", {key1 => 1});
	1673	$row = $result->all;
	1674	is_deeply($row, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}]);
	1675
	1676	$where = $dbi->where;
	1677	$where->param({id => 1, author => 'Ken', price => 1900});
	1678	$where->map(id => 'book.id',
	1679	author => ['book.author', sub { '%' . $_[0] . '%' }],
	1680	price => ['book.price', {if => sub { $_[0] eq 1900 }}]
	1681	);
	1682	is_deeply($where->param, {'book.id' => 1, 'book.author' => '%Ken%',
	1683	'book.price' => 1900});
	1684
	1685	$where = $dbi->where;
	1686	$where->param({id => 0, author => 0, price => 0});
	1687	$where->map(
	1688	id => 'book.id',
	1689	author => ['book.author', sub { '%' . $_[0] . '%' }],
	1690	price => ['book.price', sub { '%' . $_[0] . '%' },
	1691	{if => sub { $_[0] eq 0 }}]
	1692	);
	1693	is_deeply($where->param, {'book.id' => 0, 'book.author' => '%0%', 'book.price' => '%0%'});
	1694
	1695	$where = $dbi->where;
	1696	$where->param({id => '', author => '', price => ''});
	1697	$where->if('length');
	1698	$where->map(
	1699	id => 'book.id',
	1700	author => ['book.author', sub { '%' . $_[0] . '%' }],
	1701	price => ['book.price', sub { '%' . $_[0] . '%' },
	1702	{if => sub { $_[0] eq 1 }}]
	1703	);
	1704	is_deeply($where->param, {});
	1705
	1706	$where = $dbi->where;
	1707	$where->param({id => undef, author => undef, price => undef});
	1708	$where->if('length');
	1709	$where->map(
	1710	id => 'book.id',
	1711	price => ['book.price', {if => 'exists'}]
	1712	);
	1713	is_deeply($where->param, {'book.price' => undef});
	1714
	1715	$where = $dbi->where;
	1716	$where->param({price => 'a'});
	1717	$where->if('length');
	1718	$where->map(
	1719	id => ['book.id', {if => 'exists'}],
	1720	price => ['book.price', sub { '%' . $_[0] }, {if => 'exists'}]
	1721	);
	1722	is_deeply($where->param, {'book.price' => '%a'});
	1723
	1724	$where = $dbi->where;
	1725	$where->param({id => [1, 2], author => 'Ken', price => 1900});
	1726	$where->map(
	1727	id => 'book.id',
	1728	author => ['book.author', sub { '%' . $_[0] . '%' }],
	1729	price => ['book.price', {if => sub { $_[0] eq 1900 }}]
	1730	);
	1731	is_deeply($where->param, {'book.id' => [1, 2], 'book.author' => '%Ken%',
	1732	'book.price' => 1900});
	1733
	1734	$where = $dbi->where;
	1735	$where->if('length');
	1736	$where->param({id => ['', ''], author => 'Ken', price => 1900});
	1737	$where->map(
	1738	id => 'book.id',
	1739	author => ['book.author', sub { '%' . $_[0] . '%' }],
	1740	price => ['book.price', {if => sub { $_[0] eq 1900 }}]
	1741	);
	1742	is_deeply($where->param, {'book.id' => [$dbi->not_exists, $dbi->not_exists], 'book.author' => '%Ken%',
	1743	'book.price' => 1900});
	1744
	1745	$where = $dbi->where;
	1746	$where->param({id => ['', ''], author => 'Ken', price => 1900});
	1747	$where->map(
	1748	id => ['book.id', {if => 'length'}],
	1749	author => ['book.author', sub { '%' . $_[0] . '%' }, {if => 'defined'}],
	1750	price => ['book.price', {if => sub { $_[0] eq 1900 }}]
	1751	);
	1752	is_deeply($where->param, {'book.id' => [$dbi->not_exists, $dbi->not_exists], 'book.author' => '%Ken%',
	1753	'book.price' => 1900});
	1754
	1755	test 'dbi_option default';
	1756	$dbi = DBIx::Custom->new;
	1757	is_deeply($dbi->dbi_option, {});
	1758
	1759	test 'register_tag_processor';
	1760	$dbi = DBIx::Custom->connect;
	1761	$dbi->register_tag_processor(
	1762	a => sub { 1 }
	1763	);
	1764	is($dbi->query_builder->tag_processors->{a}->(), 1);
	1765
	1766	test 'register_tag';
	1767	$dbi = DBIx::Custom->connect;
	1768	$dbi->register_tag(
	1769	b => sub { 2 }
	1770	);
	1771	is($dbi->query_builder->tags->{b}->(), 2);
	1772
	1773	test 'table not specify exception';
	1774	$dbi = DBIx::Custom->connect;
	1775	eval {$dbi->insert};
	1776	like($@, qr/table/);
	1777	eval {$dbi->update};
	1778	like($@, qr/table/);
	1779	eval {$dbi->delete};
	1780	like($@, qr/table/);
	1781	eval {$dbi->select};
	1782	like($@, qr/table/);
test cleanup 723ba3d Yuki Kimoto authored on 2011-08-10	1783
test cleanup 34c937b Yuki Kimoto authored on 2011-08-10	1784	test 'more tests';
	1785	$dbi = DBIx::Custom->connect;
	1786	eval{$dbi->apply_filter('table', 'column', [])};
	1787	like($@, qr/apply_filter/);
	1788
	1789	eval{$dbi->apply_filter('table', 'column', {outer => 2})};
	1790	like($@, qr/apply_filter/);
	1791
	1792	$dbi->apply_filter(
	1793
	1794	);
	1795	$dbi = DBIx::Custom->connect;
	1796	eval { $dbi->execute('drop table table1') };
	1797	$dbi->execute($create_table1);
	1798	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	1799	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	1800	$dbi->apply_filter('table1', 'key2',
	1801	{in => sub { $_[0] * 3 }, out => sub { $_[0] * 2 }});
	1802	$rows = $dbi->select(table => 'table1', where => {key2 => 1})->all;
	1803	is_deeply($rows, [{key1 => 1, key2 => 6}]);
	1804
	1805	$dbi = DBIx::Custom->connect;
	1806	eval { $dbi->execute('drop table table1') };
	1807	$dbi->execute($create_table1);
	1808	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});
	1809	$dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});
	1810	$dbi->apply_filter('table1', 'key2', {});
	1811	$rows = $dbi->select(table => 'table1', where => {key2 => 2})->all;
	1812	is_deeply($rows, [{key1 => 1, key2 => 2}]);
	1813
	1814	$dbi = DBIx::Custom->connect;
	1815	eval {$dbi->apply_filter('table1', 'key2', {out => 'no'})};
	1816	like($@, qr/not registered/);
	1817	eval {$dbi->apply_filter('table1', 'key2', {in => 'no'})};
	1818	like($@, qr/not registered/);
	1819	$dbi->method({one => sub { 1 }});
	1820	is($dbi->one, 1);
	1821
	1822	eval{DBIx::Custom->connect(dsn => undef)};
	1823	like($@, qr/_connect/);
	1824
	1825	$dbi = DBIx::Custom->connect;
	1826	eval { $dbi->execute('drop table table1') };
	1827	$dbi->execute($create_table1);
	1828	$dbi->register_filter(twice => sub { $_[0] * 2 });
	1829	$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2},
	1830	filter => {key1 => 'twice'});
	1831	$row = $dbi->select(table => 'table1')->one;
	1832	is_deeply($row, {key1 => 2, key2 => 2});
	1833	eval {$dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2},
	1834	filter => {key1 => 'no'}) };
	1835	like($@, qr//);
	1836
	1837	$dbi->register_filter(one => sub { });
	1838	$dbi->default_fetch_filter('one');
	1839	ok($dbi->default_fetch_filter);
	1840	$dbi->default_bind_filter('one');
	1841	ok($dbi->default_bind_filter);
	1842	eval{$dbi->default_fetch_filter('no')};
	1843	like($@, qr/not registered/);
	1844	eval{$dbi->default_bind_filter('no')};
	1845	like($@, qr/not registered/);
	1846	$dbi->default_bind_filter(undef);
	1847	ok(!defined $dbi->default_bind_filter);
	1848	$dbi->default_fetch_filter(undef);
	1849	ok(!defined $dbi->default_fetch_filter);
	1850	eval {$dbi->execute('select * from table1 {} {= author') };
	1851	like($@, qr/Tag not finished/);
	1852
	1853	$dbi = DBIx::Custom->connect;
	1854	eval { $dbi->execute('drop table table1') };
	1855	$dbi->execute($create_table1);
	1856	$dbi->register_filter(one => sub { 1 });
	1857	$result = $dbi->select(table => 'table1');
	1858	eval {$result->filter(key1 => 'no')};
	1859	like($@, qr/not registered/);
	1860	eval {$result->end_filter(key1 => 'no')};
	1861	like($@, qr/not registered/);
	1862	$result->default_filter(undef);
	1863	ok(!defined $result->default_filter);
	1864	$result->default_filter('one');
	1865	is($result->default_filter->(), 1);
	1866
	1867	test 'dbi_option';
	1868	$dbi = DBIx::Custom->connect(dbi_option => {PrintError => 1});
	1869	ok($dbi->dbh->{PrintError});
	1870	$dbi = DBIx::Custom->connect(dbi_options => {PrintError => 1});
	1871	ok($dbi->dbh->{PrintError});
	1872
	1873	test 'DBIx::Custom::Result stash()';
	1874	$result = DBIx::Custom::Result->new;
	1875	is_deeply($result->stash, {}, 'default');
	1876	$result->stash->{foo} = 1;
	1877	is($result->stash->{foo}, 1, 'get and set');
test cleanup 1d42ba8 Yuki Kimoto authored on 2011-08-10	1878
	1879
	1880
	1881
	1882
	1883
	1884
	1885
	1886
	1887
	1888
	1889
	1890
	1891
	1892
	1893
	1894
	1895
	1896
	1897
	1898
	1899
	1900
	1901
	1902
	1903
	1904
	1905
	1906
	1907
	1908
	1909
	1910
	1911
cleanup test 08c3c54 Yuki Kimoto authored on 2011-08-08	1912	1;