[dbsrgits/DBIx-Class-Schema-Loader.git] / t / dbixcl_common_tests.pm

package dbixcl_common_tests;

use strict;

use Test::More;
use DBIx::Class::Schema::Loader;
use DBI;

sub new {
    my $class = shift;

    my $self;

    if( ref($_[0]) eq 'HASH') {
       my $args = shift;
       $self = { (%$args) };
    }
    else {
       $self = { @_ };
    }

    # Only MySQL uses this
    $self->{innodb} ||= '';
    
    $self->{verbose} = $ENV{TEST_VERBOSE} || 0;

    return bless $self => $class;
}

sub skip_tests {
    my ($self, $why) = @_;

    plan skip_all => $why;
}

sub run_tests {
    my $self = shift;

    plan tests => 26;

    $self->create();

    my $namespace = 'DBIXCL_Test_' . $self->{vendor};

    my $debug = ($self->{verbose} > 1) ? 1 : 0;

    my $loader = DBIx::Class::Schema::Loader->new(
         dsn           => $self->{dsn},
         user          => $self->{user},
         password      => $self->{password},
         namespace     => $namespace,
         constraint    => '^loader_test.*',
         relationships => 1,
         debug         => $debug,
    );

    my $conn = $loader->connect();

    my $moniker1 = $loader->moniker('loader_test1');
    my $rsobj1 = $conn->resultset($moniker1);
    my $moniker2 = $loader->moniker('loader_test2');
    my $rsobj2 = $conn->resultset($moniker2);

    isa_ok( $rsobj1, "DBIx::Class::ResultSet" );
    isa_ok( $rsobj2, "DBIx::Class::ResultSet" );

    my $obj    = $rsobj1->find(1);
    is( $obj->id,  1 );
    is( $obj->dat, "foo" );
    is( $rsobj2->count, 4 );

    my ($obj2) = $rsobj2->find( dat => 'bbb' );
    is( $obj2->id, 2 );

    SKIP: {
        skip $self->{skip_rels}, 20 if $self->{skip_rels};

        my $moniker3 = $loader->moniker('loader_test3');
        my $rsobj3 = $conn->resultset($moniker3);
        my $moniker4 = $loader->moniker('loader_test4');
        my $rsobj4 = $conn->resultset($moniker4);
        my $moniker5 = $loader->moniker('loader_test5');
        my $rsobj5 = $conn->resultset($moniker5);
        my $moniker6 = $loader->moniker('loader_test6');
        my $rsobj6 = $conn->resultset($moniker6);
        my $moniker7 = $loader->moniker('loader_test7');
        my $rsobj7 = $conn->resultset($moniker7);
        my $moniker8 = $loader->moniker('loader_test8');
        my $rsobj8 = $conn->resultset($moniker8);
        my $moniker9 = $loader->moniker('loader_test9');
        my $rsobj9 = $conn->resultset($moniker9);

        isa_ok( $rsobj3, "DBIx::Class::ResultSet" );
        isa_ok( $rsobj4, "DBIx::Class::ResultSet" );
        isa_ok( $rsobj5, "DBIx::Class::ResultSet" );
        isa_ok( $rsobj6, "DBIx::Class::ResultSet" );
        isa_ok( $rsobj7, "DBIx::Class::ResultSet" );
        isa_ok( $rsobj8, "DBIx::Class::ResultSet" );
        isa_ok( $rsobj9, "DBIx::Class::ResultSet" );

        # basic rel test
        my $obj4 = $rsobj4->find(123);
        isa_ok( $obj4->fkid, "$namespace\::$moniker3");

        # fk def in comments should not be parsed
        my $obj5 = $rsobj5->find( id1 => 1, id2 => 1 );
        is( ref( $obj5->id2 ), '' );

        # mulit-col fk def (works for some, not others...)
        my $obj6 = $rsobj6->find(1);
        isa_ok( $obj6->loader_test2, "$namespace\::$moniker2" );
        SKIP: {
            skip "Multi-column FKs are only half-working for this vendor", 1
                unless $self->{multi_fk_broken};
            is( ref( $obj6->id2 ), '' );
        }

        # fk that references a non-pk key (UNIQUE)
        my $obj8 = $rsobj8->find(1);
        isa_ok( $obj8->loader_test7, "$namespace\::$moniker7" );

        # from Chisel's tests...
        SKIP: {
            if($self->{vendor} =~ /sqlite/i) {
                skip 'SQLite cannot do the advanced tests', 8;
            }

            my $moniker10 = $loader->moniker('loader_test10');
            my $rsobj10 = $conn->resultset($moniker10);
            my $moniker11 = $loader->moniker('loader_test11');
            my $rsobj11 = $conn->resultset($moniker11);

            isa_ok( $rsobj10, "DBIx::Class::ResultSet" ); 
            isa_ok( $rsobj11, "DBIx::Class::ResultSet" );

            my $obj10 = $rsobj10->create({ subject => 'xyzzy' });

            $obj10->update();
            ok( defined $obj10, '$obj10 is defined' );

            my $obj11 = $rsobj11->create({ loader_test10 => $obj10->id() });
            $obj11->update();
            ok( defined $obj11, '$obj11 is defined' );

            eval {
                my $obj10_2 = $obj11->loader_test10;
                $obj10_2->loader_test11( $obj11->id11() );
                $obj10_2->update();
            };
            is($@, '', 'No errors after eval{}');

            SKIP: {
                skip 'Previous eval block failed', 3
                    unless ($@ eq '');
        
                my $results = $rsobj10->search({ subject => 'xyzzy' });
                is( $results->count(), 1,
                    'One $rsobj10 returned from search' );

                my $obj10_3 = $results->first();
                isa_ok( $obj10_3, "$namespace\::$moniker10" );
                is( $obj10_3->loader_test11()->id(), $obj11->id(),
                    'found same $rsobj11 object we expected' );
            }
        }
    }
}

sub dbconnect {
    my ($self, $complain) = @_;

    DBI->connect(
         $self->{dsn}, $self->{user},
         $self->{password},
         {
             RaiseError => $complain,
             PrintError => $complain,
             AutoCommit => 1,
         }
    );
}

sub create {
    my $self = shift;

    my @statements = (
        qq{
            CREATE TABLE loader_test1 (
                id $self->{auto_inc_pk},
                dat VARCHAR(32)
            ) $self->{innodb};
        },

        q{ INSERT INTO loader_test1 (dat) VALUES('foo'); },
        q{ INSERT INTO loader_test1 (dat) VALUES('bar'); }, 
        q{ INSERT INTO loader_test1 (dat) VALUES('baz'); }, 

        qq{ 
            CREATE TABLE loader_test2 (
                id $self->{auto_inc_pk},
                dat VARCHAR(32)
            ) $self->{innodb};
        },

        q{ INSERT INTO loader_test2 (dat) VALUES('aaa'); }, 
        q{ INSERT INTO loader_test2 (dat) VALUES('bbb'); }, 
        q{ INSERT INTO loader_test2 (dat) VALUES('ccc'); }, 
        q{ INSERT INTO loader_test2 (dat) VALUES('ddd'); }, 
    );

    my @statements_reltests = (
        qq{
            CREATE TABLE loader_test3 (
                id INTEGER NOT NULL PRIMARY KEY,
                dat VARCHAR(32)
            ) $self->{innodb};
        },

        q{ INSERT INTO loader_test3 (id,dat) VALUES(1,'aaa'); }, 
        q{ INSERT INTO loader_test3 (id,dat) VALUES(2,'bbb'); }, 
        q{ INSERT INTO loader_test3 (id,dat) VALUES(3,'ccc'); }, 
        q{ INSERT INTO loader_test3 (id,dat) VALUES(4,'ddd'); }, 

        qq{
            CREATE TABLE loader_test4 (
                id INTEGER NOT NULL PRIMARY KEY,
                fkid INTEGER NOT NULL,
                dat VARCHAR(32),
                FOREIGN KEY (fkid) REFERENCES loader_test3 (id)
            ) $self->{innodb};
        },

        q{ INSERT INTO loader_test4 (id,fkid,dat) VALUES(123,1,'aaa'); },
        q{ INSERT INTO loader_test4 (id,fkid,dat) VALUES(124,2,'bbb'); }, 
        q{ INSERT INTO loader_test4 (id,fkid,dat) VALUES(125,3,'ccc'); },
        q{ INSERT INTO loader_test4 (id,fkid,dat) VALUES(126,4,'ddd'); },

        qq{
            CREATE TABLE loader_test5 (
                id1 INTEGER,
                id2 INTEGER, -- , id2 INTEGER REFERENCES loader_test1,
                dat TEXT,
                PRIMARY KEY (id1,id2)
            ) $self->{innodb};
        },

        q{ INSERT INTO loader_test5 (id1,id2,dat) VALUES (1,1,'aaa'); },

        qq{
            CREATE TABLE loader_test6 (
                id $self->{auto_inc_pk},
                id2 INTEGER,
                loader_test2 INTEGER,
                dat TEXT,
                FOREIGN KEY (loader_test2) REFERENCES loader_test2 (id),
                FOREIGN KEY (id, id2 ) REFERENCES loader_test5 (id1,id2)
            ) $self->{innodb};
        },

        (q{ INSERT INTO loader_test6 (id2,loader_test2,dat) } .
         q{ VALUES (1,1,'aaa'); }),

        qq{
            CREATE TABLE loader_test7 (
                id INTEGER NOT NULL PRIMARY KEY,
                id2 VARCHAR(8) NOT NULL UNIQUE,
                dat TEXT
            ) $self->{innodb};
        },

        q{ INSERT INTO loader_test7 (id,id2,dat) VALUES (1,'aaa','bbb'); },

        qq{
            CREATE TABLE loader_test8 (
                id INTEGER NOT NULL PRIMARY KEY,
                loader_test7 VARCHAR(8) NOT NULL,
                dat TEXT,
                FOREIGN KEY (loader_test7) REFERENCES loader_test7 (id2)
            ) $self->{innodb};
        },

        (q{ INSERT INTO loader_test8 (id,loader_test7,dat) } .
         q{ VALUES (1,'aaa','bbb'); }),

        qq{
            CREATE TABLE loader_test9 (
                loader_test9 TEXT NOT NULL
            ) $self->{innodb};
        },
    );

    my @statements_advanced = (
        qq{
            CREATE TABLE loader_test10 (
                id10 $self->{auto_inc_pk},
                subject VARCHAR(8),
                loader_test11 INTEGER
            ) $self->{innodb};
        },

        qq{
            CREATE TABLE loader_test11 (
                id11 $self->{auto_inc_pk},
                message VARCHAR(8) DEFAULT 'foo',
                loader_test10 INTEGER NOT NULL,
                FOREIGN KEY (loader_test10) REFERENCES loader_test10 (id10)
            ) $self->{innodb};
        },

        (q{ ALTER TABLE loader_test10 ADD CONSTRAINT } .
         q{ loader_test11_fk FOREIGN KEY (loader_test11) } .
         q{ REFERENCES loader_test11 (id11); }),
    );

    $self->{created} = 1;

    my $dbh = $self->dbconnect(1);
    $dbh->do($_) for (@statements);
    unless($self->{skip_rels}) {
        $dbh->do($_) for (@statements_reltests);
        unless($self->{vendor} =~ /sqlite/i) {
            $dbh->do($_) for (@statements_advanced);
        }
    }
    $dbh->disconnect();
}

sub DESTROY {
    my $self = shift;

    return unless $self->{created};

    my @tables = qw/
        loader_test1
        loader_test2
    /;

    my @tables_reltests = qw/
        loader_test4
        loader_test3
        loader_test6
        loader_test5
        loader_test8
        loader_test7
        loader_test9
    /;

    my @tables_advanced = qw/
        loader_test11
        loader_test10
    /;

    my $drop_fk_mysql =
        q{ALTER TABLE loader_test10 DROP FOREIGN KEY loader_test11_fk;};

    my $drop_fk =
        q{ALTER TABLE loader_test10 DROP CONSTRAINT loader_test11_fk;};

    my $dbh = $self->dbconnect(0);

    unless($self->{skip_rels}) {
        $dbh->do("DROP TABLE $_") for (@tables_reltests);
        unless($self->{vendor} =~ /sqlite/i) {
            if($self->{vendor} =~ /mysql/i) {
                $dbh->do($drop_fk_mysql);
            }
            else {
                $dbh->do($drop_fk);
            }
            $dbh->do("DROP TABLE $_") for (@tables_advanced);
        }
    }
    $dbh->do("DROP TABLE $_") for (@tables);
    $dbh->disconnect();
}

1;
Commit	Line	Data
a78e3fed	1	package dbixcl_common_tests;
	2
	3	use strict;
	4
	5	use Test::More;
18fca96a	6	use DBIx::Class::Schema::Loader;
a78e3fed	7	use DBI;
	8
	9	sub new {
	10	my $class = shift;
	11
	12	my $self;
	13
	14	if( ref($_[0]) eq 'HASH') {
	15	my $args = shift;
	16	$self = { (%$args) };
	17	}
	18	else {
	19	$self = { @_ };
	20	}
	21
	22	# Only MySQL uses this
	23	$self->{innodb} \|\|= '';
af6c2665	24
af6c2665	25	$self->{verbose} = $ENV{TEST_VERBOSE} \|\| 0;
a78e3fed	26
	27	return bless $self => $class;
	28	}
	29
	30	sub skip_tests {
	31	my ($self, $why) = @_;
	32
	33	plan skip_all => $why;
	34	}
	35
	36	sub run_tests {
	37	my $self = shift;
	38
	39	plan tests => 26;
	40
	41	$self->create();
	42
	43	my $namespace = 'DBIXCL_Test_' . $self->{vendor};
	44
af6c2665	45	my $debug = ($self->{verbose} > 1) ? 1 : 0;
af6c2665	46
18fca96a	47	my $loader = DBIx::Class::Schema::Loader->new(
a78e3fed	48	dsn => $self->{dsn},
	49	user => $self->{user},
	50	password => $self->{password},
	51	namespace => $namespace,
	52	constraint => '^loader_test.*',
	53	relationships => 1,
af6c2665	54	debug => $debug,
a78e3fed	55	);
a78e3fed	56
af6c2665	57	my $conn = $loader->connect();
	58
	59	my $moniker1 = $loader->moniker('loader_test1');
	60	my $rsobj1 = $conn->resultset($moniker1);
	61	my $moniker2 = $loader->moniker('loader_test2');
	62	my $rsobj2 = $conn->resultset($moniker2);
a78e3fed	63
af6c2665	64	isa_ok( $rsobj1, "DBIx::Class::ResultSet" );
af6c2665	65	isa_ok( $rsobj2, "DBIx::Class::ResultSet" );
a78e3fed	66
af6c2665	67	my $obj = $rsobj1->find(1);
a78e3fed	68	is( $obj->id, 1 );
a78e3fed	69	is( $obj->dat, "foo" );
af6c2665	70	is( $rsobj2->count, 4 );
a78e3fed	71
af6c2665	72	my ($obj2) = $rsobj2->find( dat => 'bbb' );
a78e3fed	73	is( $obj2->id, 2 );
	74
	75	SKIP: {
	76	skip $self->{skip_rels}, 20 if $self->{skip_rels};
	77
af6c2665	78	my $moniker3 = $loader->moniker('loader_test3');
	79	my $rsobj3 = $conn->resultset($moniker3);
	80	my $moniker4 = $loader->moniker('loader_test4');
	81	my $rsobj4 = $conn->resultset($moniker4);
	82	my $moniker5 = $loader->moniker('loader_test5');
	83	my $rsobj5 = $conn->resultset($moniker5);
	84	my $moniker6 = $loader->moniker('loader_test6');
	85	my $rsobj6 = $conn->resultset($moniker6);
	86	my $moniker7 = $loader->moniker('loader_test7');
	87	my $rsobj7 = $conn->resultset($moniker7);
	88	my $moniker8 = $loader->moniker('loader_test8');
	89	my $rsobj8 = $conn->resultset($moniker8);
	90	my $moniker9 = $loader->moniker('loader_test9');
	91	my $rsobj9 = $conn->resultset($moniker9);
	92
	93	isa_ok( $rsobj3, "DBIx::Class::ResultSet" );
	94	isa_ok( $rsobj4, "DBIx::Class::ResultSet" );
	95	isa_ok( $rsobj5, "DBIx::Class::ResultSet" );
	96	isa_ok( $rsobj6, "DBIx::Class::ResultSet" );
	97	isa_ok( $rsobj7, "DBIx::Class::ResultSet" );
	98	isa_ok( $rsobj8, "DBIx::Class::ResultSet" );
	99	isa_ok( $rsobj9, "DBIx::Class::ResultSet" );
a78e3fed	100
a78e3fed	101	# basic rel test
af6c2665	102	my $obj4 = $rsobj4->find(123);
af6c2665	103	isa_ok( $obj4->fkid, "$namespace\::$moniker3");
a78e3fed	104
a78e3fed	105	# fk def in comments should not be parsed
af6c2665	106	my $obj5 = $rsobj5->find( id1 => 1, id2 => 1 );
a78e3fed	107	is( ref( $obj5->id2 ), '' );
a78e3fed	108
af6c2665	109	# mulit-col fk def (works for some, not others...)
	110	my $obj6 = $rsobj6->find(1);
	111	isa_ok( $obj6->loader_test2, "$namespace\::$moniker2" );
a78e3fed	112	SKIP: {
	113	skip "Multi-column FKs are only half-working for this vendor", 1
	114	unless $self->{multi_fk_broken};
	115	is( ref( $obj6->id2 ), '' );
	116	}
	117
	118	# fk that references a non-pk key (UNIQUE)
af6c2665	119	my $obj8 = $rsobj8->find(1);
af6c2665	120	isa_ok( $obj8->loader_test7, "$namespace\::$moniker7" );
a78e3fed	121
	122	# from Chisel's tests...
	123	SKIP: {
	124	if($self->{vendor} =~ /sqlite/i) {
	125	skip 'SQLite cannot do the advanced tests', 8;
	126	}
	127
af6c2665	128	my $moniker10 = $loader->moniker('loader_test10');
	129	my $rsobj10 = $conn->resultset($moniker10);
	130	my $moniker11 = $loader->moniker('loader_test11');
	131	my $rsobj11 = $conn->resultset($moniker11);
a78e3fed	132
af6c2665	133	isa_ok( $rsobj10, "DBIx::Class::ResultSet" );
af6c2665	134	isa_ok( $rsobj11, "DBIx::Class::ResultSet" );
a78e3fed	135
af6c2665	136	my $obj10 = $rsobj10->create({ subject => 'xyzzy' });
a78e3fed	137
	138	$obj10->update();
	139	ok( defined $obj10, '$obj10 is defined' );
	140
af6c2665	141	my $obj11 = $rsobj11->create({ loader_test10 => $obj10->id() });
a78e3fed	142	$obj11->update();
	143	ok( defined $obj11, '$obj11 is defined' );
	144
	145	eval {
	146	my $obj10_2 = $obj11->loader_test10;
	147	$obj10_2->loader_test11( $obj11->id11() );
	148	$obj10_2->update();
	149	};
	150	is($@, '', 'No errors after eval{}');
	151
	152	SKIP: {
	153	skip 'Previous eval block failed', 3
	154	unless ($@ eq '');
	155
af6c2665	156	my $results = $rsobj10->search({ subject => 'xyzzy' });
a78e3fed	157	is( $results->count(), 1,
af6c2665	158	'One $rsobj10 returned from search' );
a78e3fed	159
a78e3fed	160	my $obj10_3 = $results->first();
af6c2665	161	isa_ok( $obj10_3, "$namespace\::$moniker10" );
a78e3fed	162	is( $obj10_3->loader_test11()->id(), $obj11->id(),
af6c2665	163	'found same $rsobj11 object we expected' );
a78e3fed	164	}
a78e3fed	165	}
a78e3fed	166	}
	167	}
	168
	169	sub dbconnect {
	170	my ($self, $complain) = @_;
	171
	172	DBI->connect(
	173	$self->{dsn}, $self->{user},
	174	$self->{password},
	175	{
	176	RaiseError => $complain,
	177	PrintError => $complain,
	178	AutoCommit => 1,
	179	}
	180	);
	181	}
	182
	183	sub create {
	184	my $self = shift;
	185
	186	my @statements = (
	187	qq{
	188	CREATE TABLE loader_test1 (
	189	id $self->{auto_inc_pk},
	190	dat VARCHAR(32)
	191	) $self->{innodb};
	192	},
	193
	194	q{ INSERT INTO loader_test1 (dat) VALUES('foo'); },
	195	q{ INSERT INTO loader_test1 (dat) VALUES('bar'); },
	196	q{ INSERT INTO loader_test1 (dat) VALUES('baz'); },
	197
	198	qq{
	199	CREATE TABLE loader_test2 (
	200	id $self->{auto_inc_pk},
	201	dat VARCHAR(32)
	202	) $self->{innodb};
	203	},
	204
	205	q{ INSERT INTO loader_test2 (dat) VALUES('aaa'); },
	206	q{ INSERT INTO loader_test2 (dat) VALUES('bbb'); },
	207	q{ INSERT INTO loader_test2 (dat) VALUES('ccc'); },
	208	q{ INSERT INTO loader_test2 (dat) VALUES('ddd'); },
	209	);
	210
	211	my @statements_reltests = (
	212	qq{
	213	CREATE TABLE loader_test3 (
	214	id INTEGER NOT NULL PRIMARY KEY,
	215	dat VARCHAR(32)
	216	) $self->{innodb};
	217	},
	218
	219	q{ INSERT INTO loader_test3 (id,dat) VALUES(1,'aaa'); },
	220	q{ INSERT INTO loader_test3 (id,dat) VALUES(2,'bbb'); },
	221	q{ INSERT INTO loader_test3 (id,dat) VALUES(3,'ccc'); },
	222	q{ INSERT INTO loader_test3 (id,dat) VALUES(4,'ddd'); },
	223
	224	qq{
	225	CREATE TABLE loader_test4 (
	226	id INTEGER NOT NULL PRIMARY KEY,
	227	fkid INTEGER NOT NULL,
	228	dat VARCHAR(32),
	229	FOREIGN KEY (fkid) REFERENCES loader_test3 (id)
230	) $self->{innodb};
231	},
232
233	q{ INSERT INTO loader_test4 (id,fkid,dat) VALUES(123,1,'aaa'); },
234	q{ INSERT INTO loader_test4 (id,fkid,dat) VALUES(124,2,'bbb'); },
235	q{ INSERT INTO loader_test4 (id,fkid,dat) VALUES(125,3,'ccc'); },
236	q{ INSERT INTO loader_test4 (id,fkid,dat) VALUES(126,4,'ddd'); },
237
238	qq{
239	CREATE TABLE loader_test5 (
240	id1 INTEGER,
241	id2 INTEGER, -- , id2 INTEGER REFERENCES loader_test1,
242	dat TEXT,
243	PRIMARY KEY (id1,id2)
244	) $self->{innodb};
245	},
246
247	q{ INSERT INTO loader_test5 (id1,id2,dat) VALUES (1,1,'aaa'); },
248
249	qq{
250	CREATE TABLE loader_test6 (
251	id $self->{auto_inc_pk},
252	id2 INTEGER,
253	loader_test2 INTEGER,
254	dat TEXT,
255	FOREIGN KEY (loader_test2) REFERENCES loader_test2 (id),
256	FOREIGN KEY (id, id2 ) REFERENCES loader_test5 (id1,id2)
257	) $self->{innodb};
258	},
259
260	(q{ INSERT INTO loader_test6 (id2,loader_test2,dat) } .
261	q{ VALUES (1,1,'aaa'); }),
262
263	qq{
264	CREATE TABLE loader_test7 (
265	id INTEGER NOT NULL PRIMARY KEY,
266	id2 VARCHAR(8) NOT NULL UNIQUE,
267	dat TEXT
268	) $self->{innodb};
269	},
270
271	q{ INSERT INTO loader_test7 (id,id2,dat) VALUES (1,'aaa','bbb'); },
272
273	qq{
274	CREATE TABLE loader_test8 (
275	id INTEGER NOT NULL PRIMARY KEY,
276	loader_test7 VARCHAR(8) NOT NULL,
277	dat TEXT,
278	FOREIGN KEY (loader_test7) REFERENCES loader_test7 (id2)
279	) $self->{innodb};
280	},
281
282	(q{ INSERT INTO loader_test8 (id,loader_test7,dat) } .
283	q{ VALUES (1,'aaa','bbb'); }),
284
285	qq{
286	CREATE TABLE loader_test9 (
287	loader_test9 TEXT NOT NULL
288	) $self->{innodb};
289	},
290	);
291
292	my @statements_advanced = (
293	qq{
294	CREATE TABLE loader_test10 (
295	id10 $self->{auto_inc_pk},
296	subject VARCHAR(8),
297	loader_test11 INTEGER
298	) $self->{innodb};
299	},
300
301	qq{
302	CREATE TABLE loader_test11 (
303	id11 $self->{auto_inc_pk},
304	message VARCHAR(8) DEFAULT 'foo',
305	loader_test10 INTEGER NOT NULL,
306	FOREIGN KEY (loader_test10) REFERENCES loader_test10 (id10)
307	) $self->{innodb};
308	},
309
310	(q{ ALTER TABLE loader_test10 ADD CONSTRAINT } .
311	q{ loader_test11_fk FOREIGN KEY (loader_test11) } .
312	q{ REFERENCES loader_test11 (id11); }),
313	);
314
315	$self->{created} = 1;
316
317	my $dbh = $self->dbconnect(1);
318	$dbh->do($_) for (@statements);
319	unless($self->{skip_rels}) {
320	$dbh->do($_) for (@statements_reltests);
321	unless($self->{vendor} =~ /sqlite/i) {
322	$dbh->do($_) for (@statements_advanced);
323	}
324	}
325	$dbh->disconnect();
326	}
327
328	sub DESTROY {
329	my $self = shift;
330
331	return unless $self->{created};
332
333	my @tables = qw/
334	loader_test1
335	loader_test2
336	/;
337
338	my @tables_reltests = qw/
339	loader_test4
340	loader_test3
341	loader_test6
342	loader_test5
343	loader_test8
344	loader_test7
345	loader_test9
346	/;
347
348	my @tables_advanced = qw/
349	loader_test11
350	loader_test10
351	/;
352
353	my $drop_fk_mysql =
354	q{ALTER TABLE loader_test10 DROP FOREIGN KEY loader_test11_fk;};
355
356	my $drop_fk =
357	q{ALTER TABLE loader_test10 DROP CONSTRAINT loader_test11_fk;};
358
359	my $dbh = $self->dbconnect(0);
360
361	unless($self->{skip_rels}) {
362	$dbh->do("DROP TABLE $_") for (@tables_reltests);
363	unless($self->{vendor} =~ /sqlite/i) {
364	if($self->{vendor} =~ /mysql/i) {
365	$dbh->do($drop_fk_mysql);
366	}
367	else {
368	$dbh->do($drop_fk);
369	}
370	$dbh->do("DROP TABLE $_") for (@tables_advanced);
371	}
372	}
373	$dbh->do("DROP TABLE $_") for (@tables);
374	$dbh->disconnect();
375	}
376
377	1;