From: Peter Rabbitson Date: Wed, 2 Sep 2009 18:30:52 +0000 (+0000) Subject: Merge 'trunk' into 'pg_unqualified_schema' X-Git-Tag: v0.08111~14^2~32 X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=ace8c3c63a08f26478ce6ce9e0f33c91fea94ce4;hp=d3944540917a76cd054d1bf4ed98f2571c077b2d;p=dbsrgits%2FDBIx-Class.git Merge 'trunk' into 'pg_unqualified_schema' r7464@Thesaurus (orig r7461): ribasushi | 2009-09-01 16:51:58 +0200 Fix insert_bulk with rebless r7465@Thesaurus (orig r7462): ribasushi | 2009-09-01 16:52:39 +0200 Comment r7466@Thesaurus (orig r7463): matthewt | 2009-09-01 17:17:08 +0200 clearer copyright r7467@Thesaurus (orig r7464): matthewt | 2009-09-01 17:18:31 +0200 split copyright and license r7469@Thesaurus (orig r7466): frew | 2009-09-01 20:27:36 +0200 pod describing strife with MSSQL r7483@Thesaurus (orig r7480): ribasushi | 2009-09-02 11:07:04 +0200 Streamline pg test-schemas cleanup r7484@Thesaurus (orig r7481): ribasushi | 2009-09-02 11:20:25 +0200 Centralize handling of minimum sqlt version to DBIx::Class Bump version to the latest unborked sqlt (still just a recommend) r7485@Thesaurus (orig r7482): ribasushi | 2009-09-02 11:31:50 +0200 Some cleanup... don't remember where it came from r7486@Thesaurus (orig r7483): ribasushi | 2009-09-02 12:19:11 +0200 First part of mysql insanity r7487@Thesaurus (orig r7484): ribasushi | 2009-09-02 12:25:35 +0200 Invoke default_join_type only on undefined types r7488@Thesaurus (orig r7485): ribasushi | 2009-09-02 12:42:39 +0200 No fancy methods for the default_jointype, as we don't have proper sqlahacks inheritance and they are... well hacks r7489@Thesaurus (orig r7486): ribasushi | 2009-09-02 13:00:07 +0200 Mysql v3 support (ick) --- diff --git a/lib/DBIx/Class/Storage/DBI/Pg.pm b/lib/DBIx/Class/Storage/DBI/Pg.pm index 2a7b529..0818aa7 100644 --- a/lib/DBIx/Class/Storage/DBI/Pg.pm +++ b/lib/DBIx/Class/Storage/DBI/Pg.pm @@ -21,10 +21,12 @@ sub with_deferred_fk_checks { sub last_insert_id { my ($self,$source,$col) = @_; - my $seq = ($source->column_info($col)->{sequence} ||= $self->get_autoinc_seq($source,$col)); - $self->throw_exception("could not fetch primary key for " . $source->name . ", could not " - . "get autoinc sequence for $col (check that table and column specifications are correct " - . "and in the correct case)") unless defined $seq; + my $seq = ($source->column_info($col)->{sequence} ||= $self->get_autoinc_seq($source,$col)) + or $self->throw_exception( "could not determine sequence for " + . $source->name + . ".$col, please consider adding a " + . "schema-qualified sequence to its column info" + ); $self->_dbh_last_insert_id ($self->_dbh, $seq); } @@ -55,7 +57,7 @@ sub _get_pg_search_path { } sub _dbh_get_autoinc_seq { - my ($self, $dbh, $schema, $table, @pri) = @_; + my ($self, $dbh, $schema, $table, $col) = @_; # get the list of postgres schemas to search. if we have a schema # specified, use that. otherwise, use the search path @@ -66,34 +68,68 @@ sub _dbh_get_autoinc_seq { @search_path = @{ $self->_get_pg_search_path($dbh) }; } + # find the sequence(s) of the column in question (should have nextval declared on it) + my @sequence_names; foreach my $search_schema (@search_path) { - foreach my $col (@pri) { - my $info = $dbh->column_info(undef,$search_schema,$table,$col)->fetchrow_hashref; - if($info) { - # if we get here, we have definitely found the right - # column. - if( defined $info->{COLUMN_DEF} and - $info->{COLUMN_DEF} - =~ /^nextval\(+'([^']+)'::(?:text|regclass)\)/i - ) { - my $seq = $1; - return $seq =~ /\./ ? $seq : $info->{TABLE_SCHEM} . "." . $seq; - } else { - # we have found the column, but cannot figure out - # the nextval seq - return; - } - } - } + my $info = $dbh->column_info(undef,$search_schema,$table,$col)->fetchrow_hashref; + if($info && defined $info->{COLUMN_DEF} + && $info->{COLUMN_DEF} =~ /^nextval\(+'([^']+)'::(?:text|regclass)\)/i + ) { + push @sequence_names, $1; + } } - return; + + if (@sequence_names != 1) { + $self->throw_exception (sprintf + q|Unable to reliably determine autoinc sequence name for '%s'.'%s' (possible candidates: %s)|, + $table, + $col, + join (', ', (@sequence_names ? @sequence_names : 'none found') ), + ); + } + + my $seq = $sequence_names[0]; + + if( $seq !~ /\./ ) { + my $sth = $dbh->prepare ( + 'SELECT * FROM "information_schema"."sequences" WHERE "sequence_name" = ?' + ); + $sth->execute ($seq); + + my @seen_in_schemas; + while (my $h = $sth->fetchrow_hashref) { + push @seen_in_schemas, $h->{sequence_schema}; + } + + if (not @seen_in_schemas) { + $self->throw_exception (sprintf + q|Automatically determined autoinc sequence name '%s' for '%s'.'%s' does not seem to exist...'|, + $seq, + $table, + $col, + ); + } + elsif (@seen_in_schemas > 1) { + $self->throw_exception (sprintf + q|Unable to reliably fully-qualify automatically determined autoinc sequence name '%s' for '%s'.'%s' (same name exist in schemas: %s)|, + $seq, + $table, + $col, + join (', ', (@seen_in_schemas)), + ); + } + else { + my $sql_maker = $self->sql_maker; + $seq = join ('.', map { $sql_maker->_quote ($_) } ($seen_in_schemas[0], $seq) ); + } + } + + return $seq; } sub get_autoinc_seq { my ($self,$source,$col) = @_; - my @pri = $source->primary_columns; - my $schema; my $table = $source->name; @@ -104,7 +140,7 @@ sub get_autoinc_seq { ($schema, $table) = ($1, $2); } - $self->dbh_do('_dbh_get_autoinc_seq', $schema, $table, @pri); + $self->dbh_do('_dbh_get_autoinc_seq', $schema, $table, $col); } sub sqlt_type { diff --git a/t/72pg.t b/t/72pg.t index 40ba3d3..4b94d9b 100644 --- a/t/72pg.t +++ b/t/72pg.t @@ -6,149 +6,147 @@ use Test::Exception; use lib qw(t/lib); use DBICTest; -{ - package DBICTest::Schema::Casecheck; - use strict; - use warnings; - use base 'DBIx::Class'; +my ($dsn, $user, $pass) = @ENV{map { "DBICTEST_PG_${_}" } qw/DSN USER PASS/}; - __PACKAGE__->load_components(qw/Core/); - __PACKAGE__->table('testschema.casecheck'); - __PACKAGE__->add_columns(qw/id name NAME uc_name storecolumn/); - __PACKAGE__->column_info_from_storage(1); - __PACKAGE__->set_primary_key('id'); +plan skip_all => <maybe::next::method($name, $value); - } -} +### load any test classes that are defined further down in the file -{ - package DBICTest::Schema::ArrayTest; +our @test_classes; #< array that will be pushed into by test classes defined in this file +DBICTest::Schema->load_classes( map {s/.+:://;$_} @test_classes ) if @test_classes; - use strict; - use warnings; - use base 'DBIx::Class'; - __PACKAGE__->load_components(qw/Core/); - __PACKAGE__->table('testschema.array_test'); - __PACKAGE__->add_columns(qw/id arrayfield/); - __PACKAGE__->column_info_from_storage(1); - __PACKAGE__->set_primary_key('id'); +### pre-connect tests +{ + my $s = DBICTest::Schema->connect($dsn, $user, $pass); -} + ok (!$s->storage->_dbh, 'definitely not connected'); -my ($dsn, $user, $pass) = @ENV{map { "DBICTEST_PG_${_}" } qw/DSN USER PASS/}; + # Check that datetime_parser returns correctly before we explicitly connect. + SKIP: { + eval { require DateTime::Format::Pg }; + skip "DateTime::Format::Pg required", 2 if $@; -plan skip_all => 'Set $ENV{DBICTEST_PG_DSN}, _USER and _PASS to run this test '. - '(note: This test drops and creates tables called \'artist\', \'casecheck\', \'array_test\' and \'sequence_test\''. - ' as well as following sequences: \'pkid1_seq\', \'pkid2_seq\' and \'nonpkid_seq\''. - ' as well as following schemas: \'testschema\',\'anothertestschema\'!)' - unless ($dsn && $user); + my $store = ref $s->storage; + is($store, 'DBIx::Class::Storage::DBI', 'Started with generic storage'); -DBICTest::Schema->load_classes( 'Casecheck', 'ArrayTest' ); + my $parser = $s->storage->datetime_parser; + is( $parser, 'DateTime::Format::Pg', 'datetime_parser is as expected'); + } -# make sure sqlt_type overrides work (::Storage::DBI::Pg does this) -{ - my $schema = DBICTest::Schema->connect($dsn, $user, $pass); - ok (!$schema->storage->_dbh, 'definitely not connected'); - is ($schema->storage->sqlt_type, 'PostgreSQL', 'sqlt_type correct pre-connection'); + # make sure sqlt_type overrides work (::Storage::DBI::Pg does this) + is ($s->storage->sqlt_type, 'PostgreSQL', 'sqlt_type correct pre-connection'); } +### connect, create postgres-specific test schema + my $schema = DBICTest::Schema->connect($dsn, $user, $pass); -# Check that datetime_parser returns correctly before we explicitly connect. -SKIP: { - eval { require DateTime::Format::Pg }; - skip "DateTime::Format::Pg required", 2 if $@; +my $dbh = $schema->storage->dbh; - my $store = ref $schema->storage; - is($store, 'DBIx::Class::Storage::DBI', 'Started with generic storage'); +drop_test_schema($dbh, 'no warn'); +create_test_schema($dbh); - my $parser = $schema->storage->datetime_parser; - is( $parser, 'DateTime::Format::Pg', 'datetime_parser is as expected'); -} +### begin main tests -my $dbh = $schema->storage->dbh; -$schema->source("Artist")->name("testschema.artist"); -$schema->source("SequenceTest")->name("testschema.sequence_test"); +### auto-pk / last_insert_id / sequence discovery { local $SIG{__WARN__} = sub {}; _cleanup ($schema); - my $artist_table_def = <do("CREATE SCHEMA testschema;"); - $dbh->do("CREATE TABLE testschema.artist $artist_table_def;"); - $dbh->do("CREATE TABLE testschema.sequence_test (pkid1 integer, pkid2 integer, nonpkid integer, name VARCHAR(100), CONSTRAINT pk PRIMARY KEY(pkid1, pkid2));"); - $dbh->do("CREATE SEQUENCE pkid1_seq START 1 MAXVALUE 999999 MINVALUE 0"); - $dbh->do("CREATE SEQUENCE pkid2_seq START 10 MAXVALUE 999999 MINVALUE 0"); - $dbh->do("CREATE SEQUENCE nonpkid_seq START 20 MAXVALUE 999999 MINVALUE 0"); - ok ( $dbh->do('CREATE TABLE testschema.casecheck (id serial PRIMARY KEY, "name" VARCHAR(1), "NAME" VARCHAR(2), "UC_NAME" VARCHAR(3), "storecolumn" VARCHAR(10));'), 'Creation of casecheck table'); - ok ( $dbh->do('CREATE TABLE testschema.array_test (id serial PRIMARY KEY, arrayfield INTEGER[]);'), 'Creation of array_test table'); - $dbh->do("CREATE SCHEMA anothertestschema;"); - $dbh->do("CREATE TABLE anothertestschema.artist $artist_table_def;"); - $dbh->do("CREATE SCHEMA yetanothertestschema;"); - $dbh->do("CREATE TABLE yetanothertestschema.artist $artist_table_def;"); - $dbh->do('set search_path=testschema,public'); -} - -# store_column is called once for create() for non sequence columns - -ok(my $storecolumn = $schema->resultset('Casecheck')->create({'storecolumn' => 'a'})); - -is($storecolumn->storecolumn, '#a'); # was '##a' - - -# This is in Core now, but it's here just to test that it doesn't break -$schema->class('Artist')->load_components('PK::Auto'); - -cmp_ok( $schema->resultset('Artist')->count, '==', 0, 'this should start with an empty artist table'); - -{ # test that auto-pk also works with the defined search path by - # un-schema-qualifying the table name - my $artist_name_save = $schema->source("Artist")->name; - $schema->source("Artist")->name("artist"); - - my $unq_new; - lives_ok { - $unq_new = $schema->resultset('Artist')->create({ name => 'baz' }); - } 'insert into unqualified, shadowed table succeeds'; - - is($unq_new && $unq_new->artistid, 1, "and got correct artistid"); - - #test with anothertestschema - $schema->source('Artist')->name('anothertestschema.artist'); - my $another_new = $schema->resultset('Artist')->create({ name => 'ribasushi'}); - is( $another_new->artistid,1, 'got correct artistid for yetanotherschema'); - - #test with yetanothertestschema - $schema->source('Artist')->name('yetanothertestschema.artist'); - my $yetanother_new = $schema->resultset('Artist')->create({ name => 'ribasushi'}); - is( $yetanother_new->artistid,1, 'got correct artistid for yetanotherschema'); - is( $yetanother_new->artistid,1, 'got correct artistid for yetanotherschema'); - - $schema->source("Artist")->name($artist_name_save); + $schema->source("Artist")->name("testschema.artist"); + + # This is in Core now, but it's here just to test that it doesn't break + $schema->class('Artist')->load_components('PK::Auto'); + cmp_ok( $schema->resultset('Artist')->count, '==', 0, 'this should start with an empty artist table'); + + # test that auto-pk also works with the defined search path by + # un-schema-qualifying the table name + my $artist_name_save = $schema->source("Artist")->name; + $schema->source("Artist")->name("artist"); + + my $unq_new; + lives_ok { + $unq_new = $schema->resultset('Artist')->create({ name => 'baz' }); + } 'insert into unqualified, shadowed table succeeds'; + + is($unq_new && $unq_new->artistid, 1, "and got correct artistid"); + + my @test_schemas = ( [qw| anothertestschema 1 |], + [qw| yetanothertestschema 1 |], + ); + foreach my $t ( @test_schemas ) { + my ($sch_name, $start_num) = @$t; + #test with anothertestschema + $schema->source('Artist')->name("$sch_name.artist"); + $schema->source('Artist')->column_info('artistid')->{sequence} = undef; #< clear sequence name cache + my $another_new; + lives_ok { + $another_new = $schema->resultset('Artist')->create({ name => 'Tollbooth Willy'}); + is( $another_new->artistid,$start_num, "got correct artistid for $sch_name") + or diag "USED SEQUENCE: ".($schema->source('Artist')->column_info('artistid')->{sequence} || ''); + } "$sch_name liid 1 did not die" + or diag "USED SEQUENCE: ".($schema->source('Artist')->column_info('artistid')->{sequence} || ''); + lives_ok { + $another_new = $schema->resultset('Artist')->create({ name => 'Adam Sandler'}); + is( $another_new->artistid,$start_num+1, "got correct artistid for $sch_name") + or diag "USED SEQUENCE: ".($schema->source('Artist')->column_info('artistid')->{sequence} || ''); + } "$sch_name liid 2 did not die" + or diag "USED SEQUENCE: ".($schema->source('Artist')->column_info('artistid')->{sequence} || ''); + + } + + + my @todo_schemas = ( + [qw| unq_nextval_schema 2 |], + [qw| unq_nextval_schema2 1 |], + ); + + foreach my $t ( @todo_schemas ) { + my ($sch_name, $start_num) = @$t; + + #test with anothertestschema + $schema->source('Artist')->name("$sch_name.artist"); + $schema->source('Artist')->column_info('artistid')->{sequence} = undef; #< clear sequence name cache + my $another_new; + lives_ok { + $another_new = $schema->resultset('Artist')->create({ name => 'Tollbooth Willy'}); + is( $another_new->artistid,$start_num, "got correct artistid for $sch_name") + or diag "USED SEQUENCE: ".($schema->source('Artist')->column_info('artistid')->{sequence} || ''); + } "$sch_name liid 1 did not die" + or diag "USED SEQUENCE: ".($schema->source('Artist')->column_info('artistid')->{sequence} || ''); + + lives_ok { + $another_new = $schema->resultset('Artist')->create({ name => 'Adam Sandler'}); + is( $another_new->artistid,$start_num+1, "got correct artistid for $sch_name") + or diag "USED SEQUENCE: ".($schema->source('Artist')->column_info('artistid')->{sequence} || ''); + } "$sch_name liid 2 did not die" + or diag "USED SEQUENCE: ".($schema->source('Artist')->column_info('artistid')->{sequence} || ''); + } + + $schema->source('Artist')->column_info('artistid')->{sequence} = undef; #< clear sequence name cache + $schema->source("Artist")->name($artist_name_save); } -my $new = $schema->resultset('Artist')->create({ name => 'foo' }); +lives_ok { + my $new = $schema->resultset('Artist')->create({ name => 'foo' }); + is($new->artistid, 4, "Auto-PK worked"); + $new = $schema->resultset('Artist')->create({ name => 'bar' }); + is($new->artistid, 5, "Auto-PK worked"); +} 'old auto-pk tests did not die either'; -is($new->artistid, 2, "Auto-PK worked"); -$new = $schema->resultset('Artist')->create({ name => 'bar' }); - -is($new->artistid, 3, "Auto-PK worked"); +### type_info tests my $test_type_info = { 'artistid' => { @@ -183,7 +181,6 @@ my $test_type_info = { }, }; - my $type_info = $schema->storage->columns_info_for('testschema.artist'); my $artistid_defval = delete $type_info->{artistid}->{default_value}; like($artistid_defval, @@ -192,6 +189,26 @@ like($artistid_defval, is_deeply($type_info, $test_type_info, 'columns_info_for - column data types'); + + + +####### Array tests + +BEGIN { + package DBICTest::Schema::ArrayTest; + push @main::test_classes, __PACKAGE__; + + use strict; + use warnings; + use base 'DBIx::Class'; + + __PACKAGE__->load_components(qw/Core/); + __PACKAGE__->table('testschema.array_test'); + __PACKAGE__->add_columns(qw/id arrayfield/); + __PACKAGE__->column_info_from_storage(1); + __PACKAGE__->set_primary_key('id'); + +} SKIP: { skip "Need DBD::Pg 2.9.2 or newer for array tests", 4 if $DBD::Pg::VERSION < 2.009002; @@ -221,6 +238,34 @@ SKIP: { } + +########## Case check + +BEGIN { + package DBICTest::Schema::Casecheck; + push @main::test_classes, __PACKAGE__; + + use strict; + use warnings; + use base 'DBIx::Class'; + + __PACKAGE__->load_components(qw/Core/); + __PACKAGE__->table('testschema.casecheck'); + __PACKAGE__->add_columns(qw/id name NAME uc_name storecolumn/); + __PACKAGE__->column_info_from_storage(1); + __PACKAGE__->set_primary_key('id'); + + sub store_column { + my ($self, $name, $value) = @_; + $value = '#'.$value if($name eq "storecolumn"); + $self->maybe::next::method($name, $value); + } +} + +# store_column is called once for create() for non sequence columns +ok(my $storecolumn = $schema->resultset('Casecheck')->create({'storecolumn' => 'a'})); +is($storecolumn->storecolumn, '#a'); # was '##a' + my $name_info = $schema->source('Casecheck')->column_info( 'name' ); is( $name_info->{size}, 1, "Case sensitive matching info for 'name'" ); @@ -230,12 +275,15 @@ is( $NAME_info->{size}, 2, "Case sensitive matching info for 'NAME'" ); my $uc_name_info = $schema->source('Casecheck')->column_info( 'uc_name' ); is( $uc_name_info->{size}, 3, "Case insensitive matching info for 'uc_name'" ); -# Test SELECT ... FOR UPDATE + + + +## Test SELECT ... FOR UPDATE + my $HaveSysSigAction = eval "require Sys::SigAction" && !$@; -if ($HaveSysSigAction) { +if( $HaveSysSigAction ) { Sys::SigAction->import( 'set_sig_handler' ); } - SKIP: { skip "Sys::SigAction is not available", 3 unless $HaveSysSigAction; # create a new schema @@ -307,6 +355,10 @@ SKIP: { }); } + +######## other Auto-pk tests + +$schema->source("SequenceTest")->name("testschema.sequence_test"); for (1..5) { my $st = $schema->resultset('SequenceTest')->create({ name => 'foo' }); is($st->pkid1, $_, "Oracle Auto-PK without trigger: First primary key"); @@ -320,6 +372,95 @@ sub _cleanup { my $schema = shift or return; local $SIG{__WARN__} = sub {}; +exit; +END { drop_test_schema($dbh) } + + +######### SUBROUTINES + +sub create_test_schema { + my $dbh = shift; + + local $SIG{__WARN__} = sub {}; + + my $std_artist_table = <do("CREATE SCHEMA testschema"); + $dbh->do("CREATE TABLE testschema.artist $std_artist_table"); + $dbh->do(<do("CREATE SEQUENCE pkid1_seq START 1 MAXVALUE 999999 MINVALUE 0"); + $dbh->do("CREATE SEQUENCE pkid2_seq START 10 MAXVALUE 999999 MINVALUE 0"); + $dbh->do("CREATE SEQUENCE nonpkid_seq START 20 MAXVALUE 999999 MINVALUE 0"); + $dbh->do(<do(<do("CREATE SCHEMA anothertestschema"); + $dbh->do("CREATE TABLE anothertestschema.artist $std_artist_table"); + $dbh->do("CREATE SCHEMA yetanothertestschema"); + $dbh->do("CREATE TABLE yetanothertestschema.artist $std_artist_table"); + $dbh->do('set search_path=testschema,public'); + $dbh->do("CREATE SCHEMA unq_nextval_schema"); + $dbh->do("CREATE SCHEMA unq_nextval_schema2"); + $dbh->do(<do('set search_path=public,testschema,yetanothertestschema'); + $dbh->do('create sequence public.artist_artistid_seq'); #< in the public schema + $dbh->do(<do('set search_path=testschema,public'); +} + + + +sub drop_test_schema { + my ( $dbh, $no_warn ) = @_; + + return unless $dbh->ping; + for my $stat ( 'DROP SCHEMA testschema CASCADE', 'DROP SCHEMA anothertestschema CASCADE', @@ -329,6 +470,7 @@ sub _cleanup { 'DROP SEQUENCE nonpkid_seq', ) { eval { $schema->storage->_do_query ($stat) }; + diag $@ if $@ && !$no_warn; } }