[dbsrgits/DBIx-Class.git] / lib / DBIx / Class / Schema / Versioned.pm

package DBIx::Class::Version::Table;
use base 'DBIx::Class';
use strict;
use warnings;

__PACKAGE__->load_components(qw/ Core/);
__PACKAGE__->table('SchemaVersions');

__PACKAGE__->add_columns
    ( 'Version' => {
        'data_type' => 'VARCHAR',
        'is_auto_increment' => 0,
        'default_value' => undef,
        'is_foreign_key' => 0,
        'name' => 'Version',
        'is_nullable' => 0,
        'size' => '10'
        },
      'Installed' => {
          'data_type' => 'VARCHAR',
          'is_auto_increment' => 0,
          'default_value' => undef,
          'is_foreign_key' => 0,
          'name' => 'Installed',
          'is_nullable' => 0,
          'size' => '20'
          },
      );
__PACKAGE__->set_primary_key('Version');

package DBIx::Class::Version;
use base 'DBIx::Class::Schema';
use strict;
use warnings;

__PACKAGE__->register_class('Table', 'DBIx::Class::Version::Table');


# ---------------------------------------------------------------------------
package DBIx::Class::Schema::Versioned;

use strict;
use warnings;
use base 'DBIx::Class';
use POSIX 'strftime';
use Data::Dumper;

__PACKAGE__->mk_classdata('_filedata');
__PACKAGE__->mk_classdata('upgrade_directory');
__PACKAGE__->mk_classdata('backup_directory');
__PACKAGE__->mk_classdata('do_backup');

sub schema_version {
  my ($self) = @_;
  my $class = ref($self)||$self;
  my $version;
  {
    no strict 'refs';
    $version = ${"${class}::VERSION"};
  }
  return $version;
}

sub connection {
  my $self = shift;
  $self->next::method(@_);
  $self->_on_connect;
  return $self;
}

sub _on_connect
{
    my ($self) = @_;
    $self->{vschema} = DBIx::Class::Version->connect(@{$self->storage->connect_info()});

    my $pversion = $self->get_db_version();

    if($pversion eq $self->schema_version)
    {
        warn "This version is already installed\n";
        return 1;
    }

    if(!$pversion)
    {
        warn "Your DB is currently unversioned. Please call upgrade on your schema to sync the DB.\n";
        return 1;
    }

    my $file = $self->ddl_filename(
                                   $self->storage->sqlt_type,
                                   $self->upgrade_directory,
                                   $self->schema_version
                                   );
    if(!$file)
    {
        # No upgrade path between these two versions
        return 1;
    }


    ## Don't do this yet, do only on command?
    ## If we do this later, where does the Version table get updated??
    warn "Versions out of sync. This is " . $self->schema_version . 
        ", your database contains version $pversion, please call upgrade on your Schema.\n";
}

sub get_db_version
{
    my ($self, $rs) = @_;

    my $vtable = $self->{vschema}->resultset('Table');
    return 0 unless ($self->_source_exists($vtable));

    my $psearch = $vtable->search(undef, 
                                    { select => [
                                                 { 'max' => 'Installed' },
                                                 ],
                                          as => ['maxinstall'],
                                      })->first;
    my $pversion = $vtable->search({ Installed => $psearch->get_column('maxinstall'),
                                })->first;
    $pversion = $pversion->Version if($pversion);
    return $pversion;
}

sub _source_exists
{
    my ($self, $rs) = @_;

    my $c = eval {
        $rs->search({ 1, 0 })->count;
    };
    return 0 if $@ || !defined $c;

    return 1;
}

sub backup
{
    my ($self) = @_;
    ## Make each ::DBI::Foo do this
    $self->storage->backup($self->backup_directory());
}

sub _generate_db_schema
{
    my ($self) = @_;


}
sub upgrade
{
    my ($self) = @_;
    my $db_version = $self->get_db_version();

    if (!$db_version) {
      my %driver_to_db_map = (
        'mysql' => 'MySQL',
        'Pg' => 'PostgreSQL',
        'Oracle' => 'Oracle'
      );
      my $db = $driver_to_db_map{$self->storage->dbh->{Driver}->{Name}};
      unless ($db) {
        print "Sorry, this is an unsupported DB\n";
        return;
      }

      require SQL::Translator;
      require SQL::Translator::Diff;

      my $db_tr = SQL::Translator->new({ 
        add_drop_table => 1, 
        parser => 'DBI',
        parser_args => { 
          dsn => 'dbi:mysql:dbname=takkle_test', 
          db_user => 'newtakkle', 
          db_password => 'takkle123' 
          } 
      });

      $db_tr->producer($db);      
      my $dbic_tr = SQL::Translator->new;
      $dbic_tr->parser('SQL::Translator::Parser::DBIx::Class');
      $dbic_tr = $self->storage->configure_sqlt($dbic_tr, $db);
      $dbic_tr->data($self);
      $dbic_tr->producer($db);

      $db_tr->schema->name('1');
      $dbic_tr->schema->name('2');


      # is this really necessary?
      foreach my $tr ($db_tr, $dbic_tr) {
        my $data = $tr->data;
        $tr->parser->($tr, $$data);
      }
      
      my $diff = SQL::Translator::Diff::schema_diff($db_tr->schema, $db, 
                                                    $dbic_tr->schema, $db,
                                                    { ignore_constraint_names => 1, ignore_index_names => 1, caseopt => 1 });

      my $filename = $self->ddl_filename(
                                 $self->storage->sqlt_type,
                                 $self->upgrade_directory,
                                 $self->schema_version,
                                 'PRE',
                                 );
      my $file;
      if(!open($file, ">$filename"))
      {
          $self->throw_exception("Can't open $filename for writing ($!)");
          next;
      }
      print $file $diff;
      close($file);

      print "WARNING: There may be differences between your DB and your DBIC schema. Please review and if necessary run the SQL $filename to sync your DB.\n";
    } else {
      my $file = $self->ddl_filename(
                                 $self->storage->sqlt_type,
                                 $self->upgrade_directory,
                                 $self->schema_version,
                                 $db_version,
                                 );

      if(!-f $file)
      {
         warn "Upgrade not possible, no upgrade file found ($file)\n";
         return;
      }

      my $fh;
      open $fh, "<$file" or warn("Can't open upgrade file, $file ($!)");
      my @data = split(/[;\n]/, join('', <$fh>));
      close($fh);
      @data = grep { $_ && $_ !~ /^-- / } @data;
      @data = grep { $_ !~ /^(BEGIN TRANACTION|COMMIT)/m } @data;
      
      $self->_filedata(\@data);
      $self->backup() if($self->do_backup);

      $self->txn_do(sub {
        $self->do_upgrade();
      });
    }

    my $vtable = $self->{vschema}->resultset('Table');
    $vtable->create({ Version => $self->schema_version,
                      Installed => strftime("%Y-%m-%d %H:%M:%S", gmtime())
                      });

}

sub do_upgrade
{
    my ($self) = @_;

    ## overridable sub, per default just run all the commands.
    $self->run_upgrade(qr/create/i);
    $self->run_upgrade(qr/alter table .*? add/i);
    $self->run_upgrade(qr/alter table .*? (?!drop)/i);
    $self->run_upgrade(qr/alter table .*? drop/i);
    $self->run_upgrade(qr/drop/i);
}

sub run_upgrade
{
    my ($self, $stm) = @_;
#    print "Reg: $stm\n";
    my @statements = grep { $_ =~ $stm } @{$self->_filedata};
#    print "Statements: ", join("\n", @statements), "\n";
    $self->_filedata([ grep { $_ !~ /$stm/i } @{$self->_filedata} ]);

    for (@statements)
    {
        $self->storage->debugobj->query_start($_) if $self->storage->debug;
        $self->storage->dbh->do($_) or warn "SQL was:\n $_";
        $self->storage->debugobj->query_end($_) if $self->storage->debug;
    }

    return 1;
}

1;

=head1 NAME

DBIx::Class::Schema::Versioned - DBIx::Class::Schema plugin for Schema upgrades

=head1 SYNOPSIS

  package Library::Schema;
  use base qw/DBIx::Class::Schema/;   
  # load Library::Schema::CD, Library::Schema::Book, Library::Schema::DVD
  __PACKAGE__->load_classes(qw/CD Book DVD/);

  __PACKAGE__->load_components(qw/+DBIx::Class::Schema::Versioned/);
  __PACKAGE__->upgrade_directory('/path/to/upgrades/');
  __PACKAGE__->backup_directory('/path/to/backups/');

  sub backup
  {
    my ($self) = @_;
    # my special backup process
  }

  sub upgrade
  {
    my ($self) = @_;

    ## overridable sub, per default just runs all the commands.

    $self->run_upgrade(qr/create/i);
    $self->run_upgrade(qr/alter table .*? add/i);
    $self->run_upgrade(qr/alter table .*? (?!drop)/i);
    $self->run_upgrade(qr/alter table .*? drop/i);
    $self->run_upgrade(qr/drop/i);
    $self->run_upgrade(qr//i);   
  }

=head1 DESCRIPTION

This module is a component designed to extend L<DBIx::Class::Schema>
classes, to enable them to upgrade to newer schema layouts. To use this
module, you need to have called C<create_ddl_dir> on your Schema to
create your upgrade files to include with your delivery.

A table called I<SchemaVersions> is created and maintained by the
module. This contains two fields, 'Version' and 'Installed', which
contain each VERSION of your Schema, and the date+time it was installed.

If you would like to influence which levels of version change need
upgrades in your Schema, you can override the method C<ddl_filename>
in L<DBIx::Class::Schema>. Return a false value if there is no upgrade
path between the two versions supplied. By default, every change in
your VERSION is regarded as needing an upgrade.

The actual upgrade is called manually by calling C<upgrade> on your
schema object. Code is run at connect time to determine whether an
upgrade is needed, if so, a warning "Versions out of sync" is
produced.

NB: At the moment, SQLite upgrading is rather spotty, as SQL::Translator::Diff
returns SQL statements that SQLite does not support.


=head1 METHODS

=head2 backup

This is an overwritable method which is called just before the upgrade, to
allow you to make a backup of the database. Per default this method attempts
to call C<< $self->storage->backup >>, to run the standard backup on each
database type. 

This method should return the name of the backup file, if appropriate..

=head2 upgrade

This is the main upgrade method which calls the overridable do_upgrade and
also handles the backups and updating of the SchemaVersion table.

=head2 do_upgrade

This is an overwritable method used to run your upgrade. The freeform method
allows you to run your upgrade any way you please, you can call C<run_upgrade>
any number of times to run the actual SQL commands, and in between you can
sandwich your data upgrading. For example, first run all the B<CREATE>
commands, then migrate your data from old to new tables/formats, then 
issue the DROP commands when you are finished.

=head2 run_upgrade

 $self->run_upgrade(qr/create/i);

Runs a set of SQL statements matching a passed in regular expression. The
idea is that this method can be called any number of times from your
C<upgrade> method, running whichever commands you specify via the
regex in the parameter.

=head2 upgrade_directory

Use this to set the directory your upgrade files are stored in.

=head2 backup_directory

Use this to set the directory you want your backups stored in.

=head2 schema_version

Returns the current schema class' $VERSION; does -not- use $schema->VERSION
since that varies in results depending on if version.pm is installed, and if
so the perl or XS versions. If you want this to change, bug the version.pm
author to make vpp and vxs behave the same.

=head1 AUTHOR

Jess Robinson <castaway@desert-island.demon.co.uk>
Commit	Line	Data
c9d2e0a2	1	package DBIx::Class::Version::Table;
	2	use base 'DBIx::Class';
	3	use strict;
	4	use warnings;
	5
	6	__PACKAGE__->load_components(qw/ Core/);
	7	__PACKAGE__->table('SchemaVersions');
	8
	9	__PACKAGE__->add_columns
	10	( 'Version' => {
	11	'data_type' => 'VARCHAR',
	12	'is_auto_increment' => 0,
	13	'default_value' => undef,
	14	'is_foreign_key' => 0,
	15	'name' => 'Version',
	16	'is_nullable' => 0,
	17	'size' => '10'
	18	},
	19	'Installed' => {
	20	'data_type' => 'VARCHAR',
	21	'is_auto_increment' => 0,
	22	'default_value' => undef,
	23	'is_foreign_key' => 0,
	24	'name' => 'Installed',
	25	'is_nullable' => 0,
	26	'size' => '20'
	27	},
	28	);
	29	__PACKAGE__->set_primary_key('Version');
	30
	31	package DBIx::Class::Version;
	32	use base 'DBIx::Class::Schema';
	33	use strict;
	34	use warnings;
	35
	36	__PACKAGE__->register_class('Table', 'DBIx::Class::Version::Table');
	37
	38
	39	# ---------------------------------------------------------------------------
	40	package DBIx::Class::Schema::Versioned;
	41
	42	use strict;
	43	use warnings;
	44	use base 'DBIx::Class';
	45	use POSIX 'strftime';
	46	use Data::Dumper;
	47
	48	__PACKAGE__->mk_classdata('_filedata');
	49	__PACKAGE__->mk_classdata('upgrade_directory');
8795fefb	50	__PACKAGE__->mk_classdata('backup_directory');
f925f7cb	51	__PACKAGE__->mk_classdata('do_backup');
c9d2e0a2	52
42416a0b	53	sub schema_version {
	54	my ($self) = @_;
	55	my $class = ref($self)\|\|$self;
	56	my $version;
	57	{
	58	no strict 'refs';
	59	$version = ${"${class}::VERSION"};
	60	}
	61	return $version;
	62	}
	63
a2800991	64	sub connection {
	65	my $self = shift;
	66	$self->next::method(@_);
	67	$self->_on_connect;
	68	return $self;
	69	}
	70
737416a4	71	sub _on_connect
c9d2e0a2	72	{
c9d2e0a2	73	my ($self) = @_;
e6129e56	74	$self->{vschema} = DBIx::Class::Version->connect(@{$self->storage->connect_info()});
e2c0df8e	75
0d865134	76	my $pversion = $self->get_db_version();
0d865134	77
42416a0b	78	if($pversion eq $self->schema_version)
c9d2e0a2	79	{
	80	warn "This version is already installed\n";
	81	return 1;
	82	}
	83
c9d2e0a2	84	if(!$pversion)
c9d2e0a2	85	{
0d865134	86	warn "Your DB is currently unversioned. Please call upgrade on your schema to sync the DB.\n";
c9d2e0a2	87	return 1;
	88	}
	89
	90	my $file = $self->ddl_filename(
	91	$self->storage->sqlt_type,
	92	$self->upgrade_directory,
42416a0b	93	$self->schema_version
c9d2e0a2	94	);
	95	if(!$file)
	96	{
	97	# No upgrade path between these two versions
	98	return 1;
	99	}
	100
c9d2e0a2	101
	102	## Don't do this yet, do only on command?
	103	## If we do this later, where does the Version table get updated??
42416a0b	104	warn "Versions out of sync. This is " . $self->schema_version .
c9d2e0a2	105	", your database contains version $pversion, please call upgrade on your Schema.\n";
c9d2e0a2	106	}
c9d2e0a2	107
e6129e56	108	sub get_db_version
	109	{
	110	my ($self, $rs) = @_;
	111
	112	my $vtable = $self->{vschema}->resultset('Table');
0d865134	113	return 0 unless ($self->_source_exists($vtable));
0d865134	114
e6129e56	115	my $psearch = $vtable->search(undef,
	116	{ select => [
	117	{ 'max' => 'Installed' },
	118	],
	119	as => ['maxinstall'],
	120	})->first;
f925f7cb	121	my $pversion = $vtable->search({ Installed => $psearch->get_column('maxinstall'),
e6129e56	122	})->first;
	123	$pversion = $pversion->Version if($pversion);
	124	return $pversion;
	125	}
	126
a2800991	127	sub _source_exists
c9d2e0a2	128	{
	129	my ($self, $rs) = @_;
	130
	131	my $c = eval {
	132	$rs->search({ 1, 0 })->count;
	133	};
	134	return 0 if $@ \|\| !defined $c;
	135
	136	return 1;
	137	}
	138
	139	sub backup
	140	{
	141	my ($self) = @_;
	142	## Make each ::DBI::Foo do this
8795fefb	143	$self->storage->backup($self->backup_directory());
c9d2e0a2	144	}
c9d2e0a2	145
0d865134	146	sub _generate_db_schema
	147	{
	148	my ($self) = @_;
	149
	150
	151
	152
	153
	154
	155	}
c9d2e0a2	156	sub upgrade
	157	{
	158	my ($self) = @_;
0d865134	159	my $db_version = $self->get_db_version();
c9d2e0a2	160
0d865134	161	if (!$db_version) {
	162	my %driver_to_db_map = (
	163	'mysql' => 'MySQL',
	164	'Pg' => 'PostgreSQL',
	165	'Oracle' => 'Oracle'
	166	);
	167	my $db = $driver_to_db_map{$self->storage->dbh->{Driver}->{Name}};
	168	unless ($db) {
	169	print "Sorry, this is an unsupported DB\n";
	170	return;
	171	}
	172
	173	require SQL::Translator;
	174	require SQL::Translator::Diff;
	175
	176	my $db_tr = SQL::Translator->new({
	177	add_drop_table => 1,
	178	parser => 'DBI',
	179	parser_args => {
	180	dsn => 'dbi:mysql:dbname=takkle_test',
	181	db_user => 'newtakkle',
	182	db_password => 'takkle123'
	183	}
	184	});
	185
	186	$db_tr->producer($db);
	187	my $dbic_tr = SQL::Translator->new;
	188	$dbic_tr->parser('SQL::Translator::Parser::DBIx::Class');
	189	$dbic_tr = $self->storage->configure_sqlt($dbic_tr, $db);
	190	$dbic_tr->data($self);
	191	$dbic_tr->producer($db);
	192
	193	$db_tr->schema->name('1');
	194	$dbic_tr->schema->name('2');
	195
	196
	197	# is this really necessary?
	198	foreach my $tr ($db_tr, $dbic_tr) {
	199	my $data = $tr->data;
	200	$tr->parser->($tr, $$data);
	201	}
	202
	203	my $diff = SQL::Translator::Diff::schema_diff($db_tr->schema, $db,
	204	$dbic_tr->schema, $db,
	205	{ ignore_constraint_names => 1, ignore_index_names => 1, caseopt => 1 });
	206
	207	my $filename = $self->ddl_filename(
	208	$self->storage->sqlt_type,
	209	$self->upgrade_directory,
	210	$self->schema_version,
	211	'PRE',
	212	);
	213	my $file;
	214	if(!open($file, ">$filename"))
	215	{
	216	$self->throw_exception("Can't open $filename for writing ($!)");
	217	next;
	218	}
	219	print $file $diff;
	220	close($file);
	221
	222	print "WARNING: There may be differences between your DB and your DBIC schema. Please review and if necessary run the SQL $filename to sync your DB.\n";
	223	} else {
	224	my $file = $self->ddl_filename(
b98d9e8a	225	$self->storage->sqlt_type,
	226	$self->upgrade_directory,
	227	$self->schema_version,
0d865134	228	$db_version,
b98d9e8a	229	);
b98d9e8a	230
0d865134	231	if(!-f $file)
	232	{
	233	warn "Upgrade not possible, no upgrade file found ($file)\n";
	234	return;
	235	}
	236
	237	my $fh;
	238	open $fh, "<$file" or warn("Can't open upgrade file, $file ($!)");
	239	my @data = split(/[;\n]/, join('', <$fh>));
	240	close($fh);
	241	@data = grep { $_ && $_ !~ /^-- / } @data;
	242	@data = grep { $_ !~ /^(BEGIN TRANACTION\|COMMIT)/m } @data;
	243
	244	$self->_filedata(\@data);
	245	$self->backup() if($self->do_backup);
	246
	247	$self->txn_do(sub {
	248	$self->do_upgrade();
	249	});
b98d9e8a	250	}
b98d9e8a	251
e6129e56	252	my $vtable = $self->{vschema}->resultset('Table');
	253	$vtable->create({ Version => $self->schema_version,
	254	Installed => strftime("%Y-%m-%d %H:%M:%S", gmtime())
	255	});
f925f7cb	256
e6129e56	257	}
c9d2e0a2	258
e6129e56	259	sub do_upgrade
	260	{
	261	my ($self) = @_;
	262
	263	## overridable sub, per default just run all the commands.
c9d2e0a2	264	$self->run_upgrade(qr/create/i);
	265	$self->run_upgrade(qr/alter table .*? add/i);
	266	$self->run_upgrade(qr/alter table .*? (?!drop)/i);
	267	$self->run_upgrade(qr/alter table .*? drop/i);
	268	$self->run_upgrade(qr/drop/i);
c9d2e0a2	269	}
c9d2e0a2	270
c9d2e0a2	271	sub run_upgrade
	272	{
	273	my ($self, $stm) = @_;
	274	# print "Reg: $stm\n";
	275	my @statements = grep { $_ =~ $stm } @{$self->_filedata};
	276	# print "Statements: ", join("\n", @statements), "\n";
	277	$self->_filedata([ grep { $_ !~ /$stm/i } @{$self->_filedata} ]);
	278
	279	for (@statements)
	280	{
70f39278	281	$self->storage->debugobj->query_start($_) if $self->storage->debug;
c9d2e0a2	282	$self->storage->dbh->do($_) or warn "SQL was:\n $_";
70f39278	283	$self->storage->debugobj->query_end($_) if $self->storage->debug;
c9d2e0a2	284	}
	285
	286	return 1;
	287	}
	288
e2c0df8e	289	1;
e2c0df8e	290
c9d2e0a2	291	=head1 NAME
c9d2e0a2	292
7d9fbacf	293	DBIx::Class::Schema::Versioned - DBIx::Class::Schema plugin for Schema upgrades
c9d2e0a2	294
	295	=head1 SYNOPSIS
	296
	297	package Library::Schema;
	298	use base qw/DBIx::Class::Schema/;
	299	# load Library::Schema::CD, Library::Schema::Book, Library::Schema::DVD
	300	__PACKAGE__->load_classes(qw/CD Book DVD/);
	301
	302	__PACKAGE__->load_components(qw/+DBIx::Class::Schema::Versioned/);
	303	__PACKAGE__->upgrade_directory('/path/to/upgrades/');
8795fefb	304	__PACKAGE__->backup_directory('/path/to/backups/');
c9d2e0a2	305
	306	sub backup
	307	{
	308	my ($self) = @_;
	309	# my special backup process
	310	}
	311
	312	sub upgrade
	313	{
	314	my ($self) = @_;
	315
	316	## overridable sub, per default just runs all the commands.
	317
	318	$self->run_upgrade(qr/create/i);
	319	$self->run_upgrade(qr/alter table .*? add/i);
	320	$self->run_upgrade(qr/alter table .*? (?!drop)/i);
	321	$self->run_upgrade(qr/alter table .*? drop/i);
	322	$self->run_upgrade(qr/drop/i);
	323	$self->run_upgrade(qr//i);
	324	}
	325
	326	=head1 DESCRIPTION
	327
	328	This module is a component designed to extend L<DBIx::Class::Schema>
	329	classes, to enable them to upgrade to newer schema layouts. To use this
	330	module, you need to have called C<create_ddl_dir> on your Schema to
	331	create your upgrade files to include with your delivery.
	332
	333	A table called I<SchemaVersions> is created and maintained by the
	334	module. This contains two fields, 'Version' and 'Installed', which
	335	contain each VERSION of your Schema, and the date+time it was installed.
	336
	337	If you would like to influence which levels of version change need
	338	upgrades in your Schema, you can override the method C<ddl_filename>
	339	in L<DBIx::Class::Schema>. Return a false value if there is no upgrade
	340	path between the two versions supplied. By default, every change in
	341	your VERSION is regarded as needing an upgrade.
	342
8795fefb	343	The actual upgrade is called manually by calling C<upgrade> on your
	344	schema object. Code is run at connect time to determine whether an
	345	upgrade is needed, if so, a warning "Versions out of sync" is
	346	produced.
	347
c9d2e0a2	348	NB: At the moment, SQLite upgrading is rather spotty, as SQL::Translator::Diff
	349	returns SQL statements that SQLite does not support.
	350
	351
	352	=head1 METHODS
	353
	354	=head2 backup
	355
	356	This is an overwritable method which is called just before the upgrade, to
	357	allow you to make a backup of the database. Per default this method attempts
	358	to call C<< $self->storage->backup >>, to run the standard backup on each
	359	database type.
	360
e6129e56	361	This method should return the name of the backup file, if appropriate..
c9d2e0a2	362
	363	=head2 upgrade
	364
e6129e56	365	This is the main upgrade method which calls the overridable do_upgrade and
	366	also handles the backups and updating of the SchemaVersion table.
	367
	368	=head2 do_upgrade
	369
c9d2e0a2	370	This is an overwritable method used to run your upgrade. The freeform method
	371	allows you to run your upgrade any way you please, you can call C<run_upgrade>
	372	any number of times to run the actual SQL commands, and in between you can
	373	sandwich your data upgrading. For example, first run all the B<CREATE>
	374	commands, then migrate your data from old to new tables/formats, then
	375	issue the DROP commands when you are finished.
	376
	377	=head2 run_upgrade
	378
	379	$self->run_upgrade(qr/create/i);
	380
	381	Runs a set of SQL statements matching a passed in regular expression. The
	382	idea is that this method can be called any number of times from your
	383	C<upgrade> method, running whichever commands you specify via the
	384	regex in the parameter.
	385
8795fefb	386	=head2 upgrade_directory
	387
	388	Use this to set the directory your upgrade files are stored in.
	389
	390	=head2 backup_directory
	391
	392	Use this to set the directory you want your backups stored in.
	393
42416a0b	394	=head2 schema_version
	395
	396	Returns the current schema class' $VERSION; does -not- use $schema->VERSION
	397	since that varies in results depending on if version.pm is installed, and if
	398	so the perl or XS versions. If you want this to change, bug the version.pm
	399	author to make vpp and vxs behave the same.
	400
c9d2e0a2	401	=head1 AUTHOR
	402
	403	Jess Robinson <castaway@desert-island.demon.co.uk>