1 package DBIx::Class::Version::Table;
2 use base 'DBIx::Class';
6 __PACKAGE__->load_components(qw/ Core/);
7 __PACKAGE__->table('SchemaVersions');
9 __PACKAGE__->add_columns
11 'data_type' => 'VARCHAR',
12 'is_auto_increment' => 0,
13 'default_value' => undef,
14 'is_foreign_key' => 0,
20 'data_type' => 'VARCHAR',
21 'is_auto_increment' => 0,
22 'default_value' => undef,
23 'is_foreign_key' => 0,
24 'name' => 'Installed',
29 __PACKAGE__->set_primary_key('Version');
31 package DBIx::Class::Version;
32 use base 'DBIx::Class::Schema';
36 __PACKAGE__->register_class('Table', 'DBIx::Class::Version::Table');
39 # ---------------------------------------------------------------------------
40 package DBIx::Class::Schema::Versioned;
44 use base 'DBIx::Class';
48 __PACKAGE__->mk_classdata('_filedata');
49 __PACKAGE__->mk_classdata('upgrade_directory');
50 __PACKAGE__->mk_classdata('backup_directory');
55 my $vschema = DBIx::Class::Version->connect(@{$self->storage->connect_info()});
56 my $vtable = $vschema->resultset('Table');
59 if(!$self->exists($vtable))
61 # $vschema->storage->debug(1);
62 $vschema->storage->ensure_connected();
68 my $psearch = $vtable->search(undef,
70 { 'max' => 'Installed' },
74 $pversion = $vtable->search({ Installed => $psearch->get_column('maxinstall'),
76 $pversion = $pversion->Version if($pversion);
78 # warn("Previous version: $pversion\n");
79 if($pversion eq $self->VERSION)
81 warn "This version is already installed\n";
89 $vtable->create({ Version => $self->VERSION,
90 Installed => strftime("%Y-%m-%d %H:%M:%S", gmtime())
92 ## If we let the user do this, where does the Version table get updated?
93 warn "No previous version found, calling deploy to install this version.\n";
98 my $file = $self->ddl_filename(
99 $self->storage->sqlt_type,
100 $self->upgrade_directory,
105 # No upgrade path between these two versions
109 $file = $self->ddl_filename(
110 $self->storage->sqlt_type,
111 $self->upgrade_directory,
115 # $file =~ s/@{[ $self->VERSION ]}/"${pversion}-" . $self->VERSION/e;
118 warn "Upgrade not possible, no upgrade file found ($file)\n";
123 open $fh, "<$file" or warn("Can't open upgrade file, $file ($!)");
124 my @data = split(/;\n/, join('', <$fh>));
126 @data = grep { $_ && $_ !~ /^-- / } @data;
127 @data = grep { $_ !~ /^(BEGIN TRANACTION|COMMIT)/m } @data;
129 $self->_filedata(\@data);
131 ## Don't do this yet, do only on command?
132 ## If we do this later, where does the Version table get updated??
133 warn "Versions out of sync. This is " . $self->VERSION .
134 ", your database contains version $pversion, please call upgrade on your Schema.\n";
135 # $self->upgrade($pversion, $self->VERSION);
140 my ($self, $rs) = @_;
143 $rs->search({ 1, 0 })->count;
145 return 0 if $@ || !defined $c;
153 ## Make each ::DBI::Foo do this
154 $self->storage->backup($self->backup_directory());
161 ## overridable sub, per default just run all the commands.
165 $self->run_upgrade(qr/create/i);
166 $self->run_upgrade(qr/alter table .*? add/i);
167 $self->run_upgrade(qr/alter table .*? (?!drop)/i);
168 $self->run_upgrade(qr/alter table .*? drop/i);
169 $self->run_upgrade(qr/drop/i);
170 # $self->run_upgrade(qr//i);
172 my $vschema = DBIx::Class::Version->connect(@{$self->storage->connect_info()});
173 my $vtable = $vschema->resultset('Table');
174 $vtable->create({ Version => $self->VERSION,
175 Installed => strftime("%Y-%m-%d %H:%M:%S", gmtime())
182 my ($self, $stm) = @_;
183 # print "Reg: $stm\n";
184 my @statements = grep { $_ =~ $stm } @{$self->_filedata};
185 # print "Statements: ", join("\n", @statements), "\n";
186 $self->_filedata([ grep { $_ !~ /$stm/i } @{$self->_filedata} ]);
190 $self->storage->debugfh->print("$_\n") if $self->storage->debug;
191 # print "Running \n>>$_<<\n";
192 $self->storage->dbh->do($_) or warn "SQL was:\n $_";
202 DBIx::Class::Versioning - DBIx::Class::Schema plugin for Schema upgrades
206 package Library::Schema;
207 use base qw/DBIx::Class::Schema/;
208 # load Library::Schema::CD, Library::Schema::Book, Library::Schema::DVD
209 __PACKAGE__->load_classes(qw/CD Book DVD/);
211 __PACKAGE__->load_components(qw/+DBIx::Class::Schema::Versioned/);
212 __PACKAGE__->upgrade_directory('/path/to/upgrades/');
213 __PACKAGE__->backup_directory('/path/to/backups/');
218 # my special backup process
225 ## overridable sub, per default just runs all the commands.
227 $self->run_upgrade(qr/create/i);
228 $self->run_upgrade(qr/alter table .*? add/i);
229 $self->run_upgrade(qr/alter table .*? (?!drop)/i);
230 $self->run_upgrade(qr/alter table .*? drop/i);
231 $self->run_upgrade(qr/drop/i);
232 $self->run_upgrade(qr//i);
237 This module is a component designed to extend L<DBIx::Class::Schema>
238 classes, to enable them to upgrade to newer schema layouts. To use this
239 module, you need to have called C<create_ddl_dir> on your Schema to
240 create your upgrade files to include with your delivery.
242 A table called I<SchemaVersions> is created and maintained by the
243 module. This contains two fields, 'Version' and 'Installed', which
244 contain each VERSION of your Schema, and the date+time it was installed.
246 If you would like to influence which levels of version change need
247 upgrades in your Schema, you can override the method C<ddl_filename>
248 in L<DBIx::Class::Schema>. Return a false value if there is no upgrade
249 path between the two versions supplied. By default, every change in
250 your VERSION is regarded as needing an upgrade.
252 The actual upgrade is called manually by calling C<upgrade> on your
253 schema object. Code is run at connect time to determine whether an
254 upgrade is needed, if so, a warning "Versions out of sync" is
257 NB: At the moment, SQLite upgrading is rather spotty, as SQL::Translator::Diff
258 returns SQL statements that SQLite does not support.
265 This is an overwritable method which is called just before the upgrade, to
266 allow you to make a backup of the database. Per default this method attempts
267 to call C<< $self->storage->backup >>, to run the standard backup on each
270 This method should return the name of the backup file, if appropriate.
272 C<backup> is called from C<upgrade>, make sure you call it, if you write your
273 own <upgrade> method.
277 This is an overwritable method used to run your upgrade. The freeform method
278 allows you to run your upgrade any way you please, you can call C<run_upgrade>
279 any number of times to run the actual SQL commands, and in between you can
280 sandwich your data upgrading. For example, first run all the B<CREATE>
281 commands, then migrate your data from old to new tables/formats, then
282 issue the DROP commands when you are finished.
286 $self->run_upgrade(qr/create/i);
288 Runs a set of SQL statements matching a passed in regular expression. The
289 idea is that this method can be called any number of times from your
290 C<upgrade> method, running whichever commands you specify via the
291 regex in the parameter.
293 =head2 upgrade_directory
295 Use this to set the directory your upgrade files are stored in.
297 =head2 backup_directory
299 Use this to set the directory you want your backups stored in.
303 Jess Robinson <castaway@desert-island.demon.co.uk>