lib/DBIx/Class/Schema/Loader/DBI/SQLite.pm

   1 package DBIx::Class::Schema::Loader::DBI::SQLite;
   2
   3 use strict;
   4 use warnings;
   5 use base qw/
   6     DBIx::Class::Schema::Loader::DBI::Component::QuotedDefault
   7     DBIx::Class::Schema::Loader::DBI
   8 /;
   9 use Carp::Clan qw/^DBIx::Class/;
  10 use Text::Balanced qw( extract_bracketed );
  11 use Class::C3;
  12
  13 our $VERSION = '0.07001';
  14
  15 =head1 NAME
  16
  17 DBIx::Class::Schema::Loader::DBI::SQLite - DBIx::Class::Schema::Loader::DBI SQLite Implementation.
  18
  19 =head1 DESCRIPTION
  20
  21 See L<DBIx::Class::Schema::Loader> and L<DBIx::Class::Schema::Loader::Base>.
  22
  23 =head1 METHODS
  24
  25 =head2 rescan
  26
  27 SQLite will fail all further commands on a connection if the underlying schema
  28 has been modified.  Therefore, any runtime changes requiring C<rescan> also
  29 require us to re-connect to the database.  The C<rescan> method here handles
  30 that reconnection for you, but beware that this must occur for any other open
  31 sqlite connections as well.
  32
  33 =cut
  34
  35 sub _setup {
  36     my $self = shift;
  37
  38     $self->next::method(@_);
  39
  40     if (not defined $self->preserve_case) {
  41         $self->preserve_case(0);
  42     }
  43 }
  44
  45 sub rescan {
  46     my ($self, $schema) = @_;
  47
  48     $schema->storage->disconnect if $schema->storage;
  49     $self->next::method($schema);
  50 }
  51
  52 # A hack so that qualify_objects can be tested on SQLite, SQLite does not
  53 # actually have schemas.
  54 {
  55     sub _table_as_sql {
  56         my $self = shift;
  57         local $self->{db_schema};
  58         return $self->next::method(@_);
  59     }
  60
  61     sub _table_pk_info {
  62         my $self = shift;
  63         local $self->{db_schema};
  64         return $self->next::method(@_);
  65     }
  66 }
  67
  68 sub _columns_info_for {
  69     my $self = shift;
  70     my ($table) = @_;
  71
  72     my $result = $self->next::method(@_);
  73
  74     my $dbh = $self->schema->storage->dbh;
  75     local $dbh->{FetchHashKeyName} = 'NAME_lc';
  76
  77     my $sth = $dbh->prepare(
  78       "pragma table_info(" . $dbh->quote_identifier($table) . ")"
  79     );
  80     $sth->execute;
  81     my $cols = $sth->fetchall_hashref('name');
  82
  83     my ($num_pk, $pk_col) = (0);
  84     # SQLite doesn't give us the info we need to do this nicely :(
  85     # If there is exactly one column marked PK, and its type is integer,
  86     # set it is_auto_increment. This isn't 100%, but it's better than the
  87     # alternatives.
  88     while (my ($col_name, $info) = each %$result) {
  89       if ($cols->{$col_name}{pk}) {
  90         $num_pk ++;
  91         if (lc($cols->{$col_name}{type}) eq 'integer') {
  92           $pk_col = $col_name;
  93         }
  94       }
  95     }
  96
  97     while (my ($col, $info) = each %$result) {
  98         if ((eval { ${ $info->{default_value} } }||'') eq 'CURRENT_TIMESTAMP') {
  99             ${ $info->{default_value} } = 'current_timestamp';
 100         }
 101         if ($num_pk == 1 and defined $pk_col and $pk_col eq $col) {
 102           $info->{is_auto_increment} = 1;
 103         }
 104     }
 105
 106     return $result;
 107 }
 108
 109 sub _table_fk_info {
 110     my ($self, $table) = @_;
 111
 112     my $dbh = $self->schema->storage->dbh;
 113     my $sth = $dbh->prepare(
 114         "pragma foreign_key_list(" . $dbh->quote_identifier($table) . ")"
 115     );
 116     $sth->execute;
 117
 118     my @rels;
 119     while (my $fk = $sth->fetchrow_hashref) {
 120         my $rel = $rels[ $fk->{id} ] ||= {
 121             local_columns => [],
 122             remote_columns => undef,
 123             remote_table => $fk->{table}
 124         };
 125
 126         push @{ $rel->{local_columns} }, $self->_lc($fk->{from});
 127         push @{ $rel->{remote_columns} }, $self->_lc($fk->{to}) if defined $fk->{to};
 128         warn "This is supposed to be the same rel but remote_table changed from ",
 129             $rel->{remote_table}, " to ", $fk->{table}
 130             if $rel->{remote_table} ne $fk->{table};
 131     }
 132     $sth->finish;
 133     return \@rels;
 134 }
 135
 136 sub _table_uniq_info {
 137     my ($self, $table) = @_;
 138
 139     my $dbh = $self->schema->storage->dbh;
 140     my $sth = $dbh->prepare(
 141         "pragma index_list(" . $dbh->quote($table) . ")"
 142     );
 143     $sth->execute;
 144
 145     my @uniqs;
 146     while (my $idx = $sth->fetchrow_hashref) {
 147         next unless $idx->{unique};
 148
 149         my $name = $idx->{name};
 150
 151         my $get_idx_sth = $dbh->prepare("pragma index_info(" . $dbh->quote($name) . ")");
 152         $get_idx_sth->execute;
 153         my @cols;
 154         while (my $idx_row = $get_idx_sth->fetchrow_hashref) {
 155             push @cols, $self->_lc($idx_row->{name});
 156         }
 157         $get_idx_sth->finish;
 158
 159         # Rename because SQLite complains about sqlite_ prefixes on identifiers
 160         # and ignores constraint names in DDL.
 161         $name = (join '_', @cols) . '_unique';
 162
 163         push @uniqs, [ $name => \@cols ];
 164     }
 165     $sth->finish;
 166     return \@uniqs;
 167 }
 168
 169 sub _tables_list {
 170     my ($self, $opts) = @_;
 171
 172     my $dbh = $self->schema->storage->dbh;
 173     my $sth = $dbh->prepare("SELECT * FROM sqlite_master");
 174     $sth->execute;
 175     my @tables;
 176     while ( my $row = $sth->fetchrow_hashref ) {
 177         next unless $row->{type} =~ /^(?:table|view)\z/i;
 178         next if $row->{tbl_name} =~ /^sqlite_/;
 179         push @tables, $row->{tbl_name};
 180     }
 181     $sth->finish;
 182     return $self->_filter_tables(\@tables, $opts);
 183 }
 184
 185 =head1 SEE ALSO
 186
 187 L<DBIx::Class::Schema::Loader>, L<DBIx::Class::Schema::Loader::Base>,
 188 L<DBIx::Class::Schema::Loader::DBI>
 189
 190 =head1 AUTHOR
 191
 192 See L<DBIx::Class::Schema::Loader/AUTHOR> and L<DBIx::Class::Schema::Loader/CONTRIBUTORS>.
 193
 194 =head1 LICENSE
 195
 196 This library is free software; you can redistribute it and/or modify it under
 197 the same terms as Perl itself.
 198
 199 =cut
 200
 201 1;