X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBI%2FOracle%2FGeneric.pm;h=8c6b9d35c6d385c8089b0b837b9a245b148695e4;hb=0e773352a;hp=d976f38d07cb4c8df025539b1814595e63b7135a;hpb=e66002835945589b7174d524ba5add64e714abd2;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Storage/DBI/Oracle/Generic.pm b/lib/DBIx/Class/Storage/DBI/Oracle/Generic.pm index d976f38..8c6b9d3 100644 --- a/lib/DBIx/Class/Storage/DBI/Oracle/Generic.pm +++ b/lib/DBIx/Class/Storage/DBI/Oracle/Generic.pm @@ -8,6 +8,7 @@ use Try::Tiny; use namespace::clean; __PACKAGE__->sql_limit_dialect ('RowNum'); +__PACKAGE__->sql_quote_char ('"'); =head1 NAME @@ -19,7 +20,6 @@ DBIx::Class::Storage::DBI::Oracle::Generic - Oracle Support for DBIx::Class use base 'DBIx::Class::Core'; __PACKAGE__->add_columns({ id => { sequence => 'mysequence', auto_nextval => 1 } }); __PACKAGE__->set_primary_key('id'); - __PACKAGE__->sequence('mysequence'); # Somewhere in your Code # add some data to a table with a hierarchical relationship @@ -80,6 +80,21 @@ use base qw/DBIx::Class::Storage::DBI/; use mro 'c3'; __PACKAGE__->sql_maker_class('DBIx::Class::SQLMaker::Oracle'); +__PACKAGE__->datetime_parser_type('DateTime::Format::Oracle'); + +sub _determine_supports_insert_returning { + my $self = shift; + +# TODO find out which version supports the RETURNING syntax +# 8i has it and earlier docs are a 404 on oracle.com + + return 1 + if $self->_server_info->{normalized_dbms_version} >= 8.001; + + return 0; +} + +__PACKAGE__->_use_insert_returning_bound (1); sub deployment_statements { my $self = shift;; @@ -106,7 +121,7 @@ sub _dbh_last_insert_id { my @ids = (); foreach my $col (@columns) { my $seq = ($source->column_info($col)->{sequence} ||= $self->get_autoinc_seq($source,$col)); - my $id = $self->_sequence_fetch( 'currval', $seq ); + my $id = $self->_sequence_fetch( 'CURRVAL', $seq ); push @ids, $id; } return @ids; @@ -116,15 +131,20 @@ sub _dbh_get_autoinc_seq { my ($self, $dbh, $source, $col) = @_; my $sql_maker = $self->sql_maker; + my ($ql, $qr) = map { $_ ? (quotemeta $_) : '' } $sql_maker->_quote_chars; my $source_name; if ( ref $source->name eq 'SCALAR' ) { $source_name = ${$source->name}; + + # the ALL_TRIGGERS match further on is case sensitive - thus uppercase + # stuff unless it is already quoted + $source_name = uc ($source_name) if $source_name !~ /\"/; } else { $source_name = $source->name; + $source_name = uc($source_name) unless $ql; } - $source_name = uc($source_name) unless $sql_maker->quote_char; # trigger_body is a LONG local $dbh->{LongReadLen} = 64 * 1024 if ($dbh->{LongReadLen} < 64 * 1024); @@ -133,37 +153,105 @@ sub _dbh_get_autoinc_seq { local $sql_maker->{bindtype} = 'normal'; # look up the correct sequence automatically - my ( $schema, $table ) = $source_name =~ /(\w+)\.(\w+)/; + my ( $schema, $table ) = $source_name =~ /( (?:${ql})? \w+ (?:${qr})? ) \. ( (?:${ql})? \w+ (?:${qr})? )/x; + + # if no explicit schema was requested - use the default schema (which in the case of Oracle is the db user) + $schema ||= uc( ($self->_dbi_connect_info||[])->[1] || ''); + my ($sql, @bind) = $sql_maker->select ( 'ALL_TRIGGERS', - ['trigger_body', 'table_owner'], + [qw/TRIGGER_BODY TABLE_OWNER TRIGGER_NAME/], { - $schema ? (owner => $schema) : (), - table_name => $table || $source_name, - triggering_event => { -like => '%INSERT%' }, - status => 'ENABLED', + $schema ? (OWNER => $schema) : (), + TABLE_NAME => $table || $source_name, + TRIGGERING_EVENT => { -like => '%INSERT%' }, # this will also catch insert_or_update + TRIGGER_TYPE => { -like => '%BEFORE%' }, # we care only about 'before' triggers + STATUS => 'ENABLED', }, ); - my $sth = $dbh->prepare($sql); - $sth->execute (@bind); - while (my ($insert_trigger, $schema) = $sth->fetchrow_array) { - my ($seq_name) = $insert_trigger =~ m/("?[.\w"]+"?)\.nextval .+ into \s+ :new\.$col/xmsi; + # to find all the triggers that mention the column in question a simple + # regex grep since the trigger_body above is a LONG and hence not searchable + my @triggers = ( map + { my %inf; @inf{qw/body schema name/} = @$_; \%inf } + ( grep + { $_->[0] =~ /\:new\.${ql}${col}${qr} | \:new\.$col/xi } + @{ $dbh->selectall_arrayref( $sql, {}, @bind ) } + ) + ); + + # extract all sequence names mentioned in each trigger + for (@triggers) { + $_->{sequences} = [ $_->{body} =~ / ( "? [\.\w\"\-]+ "? ) \. nextval /xig ]; + } + + my $chosen_trigger; - next unless $seq_name; + # if only one trigger matched things are easy + if (@triggers == 1) { - if ($seq_name !~ /\./) { - $seq_name = join '.' => $schema, $seq_name; + if ( @{$triggers[0]{sequences}} == 1 ) { + $chosen_trigger = $triggers[0]; } + else { + $self->throw_exception( sprintf ( + "Unable to introspect trigger '%s' for column %s.%s (references multiple sequences). " + . "You need to specify the correct 'sequence' explicitly in '%s's column_info.", + $triggers[0]{name}, + $source_name, + $col, + $col, + ) ); + } + } + # got more than one matching trigger - see if we can narrow it down + elsif (@triggers > 1) { + + my @candidates = grep + { $_->{body} =~ / into \s+ \:new\.$col /xi } + @triggers + ; + + if (@candidates == 1 && @{$candidates[0]{sequences}} == 1) { + $chosen_trigger = $candidates[0]; + } + else { + $self->throw_exception( sprintf ( + "Unable to reliably select a BEFORE INSERT trigger for column %s.%s (possibilities: %s). " + . "You need to specify the correct 'sequence' explicitly in '%s's column_info.", + $source_name, + $col, + ( join ', ', map { "'$_->{name}'" } @triggers ), + $col, + ) ); + } + } + if ($chosen_trigger) { + my $seq_name = $chosen_trigger->{sequences}[0]; + + $seq_name = "$chosen_trigger->{schema}.$seq_name" + unless $seq_name =~ /\./; + + return \$seq_name if $seq_name =~ /\"/; # may already be quoted in-trigger return $seq_name; } - $self->throw_exception("Unable to find a sequence %INSERT% trigger on table '$source_name'."); + + $self->throw_exception( sprintf ( + "No suitable BEFORE INSERT triggers found for column %s.%s. " + . "You need to specify the correct 'sequence' explicitly in '%s's column_info.", + $source_name, + $col, + $col, + )); } sub _sequence_fetch { my ( $self, $type, $seq ) = @_; - my ($id) = $self->_get_dbh->selectrow_array("SELECT ${seq}.${type} FROM DUAL"); + + # use the maker to leverage quoting settings + my $sql_maker = $self->sql_maker; + my ($id) = $self->_get_dbh->selectrow_array ($sql_maker->select('DUAL', [ ref $seq ? \"$$seq.$type" : "$seq.$type" ] ) ); return $id; } @@ -184,20 +272,19 @@ sub _ping { } sub _dbh_execute { - my $self = shift; - my ($dbh, $op, $extra_bind, $ident, $bind_attributes, @args) = @_; + my ($self, $dbh, $sql, @args) = @_; my (@res, $tried); - my $wantarray = wantarray(); + my $want = wantarray; my $next = $self->next::can; do { try { - my $exec = sub { $self->$next($dbh, $op, $extra_bind, $ident, $bind_attributes, @args) }; + my $exec = sub { $self->$next($dbh, $sql, @args) }; - if (!defined $wantarray) { + if (!defined $want) { $exec->(); } - elsif (! $wantarray) { + elsif (! $want) { $res[0] = $exec->(); } else { @@ -210,7 +297,6 @@ sub _dbh_execute { if (! $tried and $_ =~ /ORA-01003/) { # ORA-01003: no statement parsed (someone changed the table somehow, # invalidating your cursor.) - my ($sql, $bind) = $self->_prep_for_execute($op, $extra_bind, $ident, \@args); delete $dbh->{CachedKids}{$sql}; } else { @@ -219,7 +305,16 @@ sub _dbh_execute { }; } while (! $tried++); - return $wantarray ? @res : $res[0]; + return wantarray ? @res : $res[0]; +} + +sub _dbh_execute_array { + #my ($self, $sth, $tuple_status, @extra) = @_; + + # DBD::Oracle warns loudly on partial execute_array failures + local $_[1]->{PrintWarn} = 0; + + shift->next::method(@_); } =head2 get_autoinc_seq @@ -239,10 +334,6 @@ sub get_autoinc_seq { This sets the proper DateTime::Format module for use with L. -=cut - -sub datetime_parser_type { return "DateTime::Format::Oracle"; } - =head2 connect_call_datetime_setup Used as: @@ -291,56 +382,57 @@ sub connect_call_datetime_setup { ); } -=head2 source_bind_attributes - -Handle LOB types in Oracle. Under a certain size (4k?), you can get away -with the driver assuming your input is the deprecated LONG type if you -encode it as a hex string. That ain't gonna fly at larger values, where -you'll discover you have to do what this does. - -This method had to be overridden because we need to set ora_field to the -actual column, and that isn't passed to the call (provided by Storage) to -bind_attribute_by_data_type. - -According to L, the ora_field isn't always necessary, but -adding it doesn't hurt, and will save your bacon if you're modifying a -table with more than one LOB column. - -=cut - -sub source_bind_attributes -{ - require DBD::Oracle; - my $self = shift; - my($source) = @_; - - my %bind_attributes; - - foreach my $column ($source->columns) { - my $data_type = $source->column_info($column)->{data_type} || ''; - next unless $data_type; +### Note originally by Ron "Quinn" Straight +### http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=dbsrgits/DBIx-Class.git;a=commitdiff;h=5db2758de644d53e07cd3e05f0e9037bf40116fc +# +# Handle LOB types in Oracle. Under a certain size (4k?), you can get away +# with the driver assuming your input is the deprecated LONG type if you +# encode it as a hex string. That ain't gonna fly at larger values, where +# you'll discover you have to do what this does. +# +# This method had to be overridden because we need to set ora_field to the +# actual column, and that isn't passed to the call (provided by Storage) to +# bind_attribute_by_data_type. +# +# According to L, the ora_field isn't always necessary, but +# adding it doesn't hurt, and will save your bacon if you're modifying a +# table with more than one LOB column. +# +sub _dbi_attrs_for_bind { + my ($self, $ident, $bind) = @_; + my $attrs = $self->next::method($ident, $bind); + + for my $i (0 .. $#$attrs) { + if (keys %{$attrs->[$i]||{}} and my $col = $bind->[$i][0]{dbic_colname}) { + $attrs->[$i]{ora_field} = $col; + } + } - my %column_bind_attrs = $self->bind_attribute_by_data_type($data_type); + $attrs; +} - if ($data_type =~ /^[BC]LOB$/i) { - if ($DBD::Oracle::VERSION eq '1.23') { - $self->throw_exception( -"BLOB/CLOB support in DBD::Oracle == 1.23 is broken, use an earlier or later ". -"version.\n\nSee: https://rt.cpan.org/Public/Bug/Display.html?id=46016\n" - ); - } +my $dbd_loaded; +sub bind_attribute_by_data_type { + my ($self, $dt) = @_; + + $dbd_loaded ||= do { + require DBD::Oracle; + if ($DBD::Oracle::VERSION eq '1.23') { + $self->throw_exception( + "BLOB/CLOB support in DBD::Oracle == 1.23 is broken, use an earlier or later ". + "version.\n\nSee: https://rt.cpan.org/Public/Bug/Display.html?id=46016\n" + ); + } + 1; + }; - $column_bind_attrs{'ora_type'} = uc($data_type) eq 'CLOB' + if ($self->_is_lob_type($dt)) { + return { + ora_type => $self->_is_text_lob_type($dt) ? DBD::Oracle::ORA_CLOB() : DBD::Oracle::ORA_BLOB() - ; - $column_bind_attrs{'ora_field'} = $column; - } - - $bind_attributes{$column} = \%column_bind_attrs; + }; } - - return \%bind_attributes; } sub _svp_begin { @@ -376,7 +468,9 @@ sub relname_to_table_alias { my $alias = $self->next::method(@_); - return $self->sql_maker->_shorten_identifier($alias, [$relname]); + # we need to shorten here in addition to the shortening in SQLA itself, + # since the final relnames are a crucial for the join optimizer + return $self->sql_maker->_shorten_identifier($alias); } =head2 with_deferred_fk_checks