File: README

package info (click to toggle)
liborlite-migrate-perl 1.10-2
  • links: PTS, VCS
  • area: main
  • in suites: buster, sid, stretch
  • size: 248 kB
  • ctags: 152
  • sloc: perl: 1,885; makefile: 2
file content (195 lines) | stat: -rw-r--r-- 6,613 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
NAME
    ORLite::Migrate - Extremely light weight SQLite-specific schema
    migration

SYNOPSIS
      # Build your ORM class using a patch timeline
      # stored in the shared files directory.
      use ORLite::Migrate {
          create       => 1,
          file         => 'sqlite.db',
          timeline     => File::Spec->catdir(
              File::ShareDir::module_dir('My::Module'), 'patches',
          ),
          user_version => 8,
      };

      # migrate-1.pl - A trivial schema patch
      #!/usr/bin/perl
      
  use strict;
      use DBI ();
      
  # Locate the SQLite database
      my $file = <STDIN>;
      chomp($file);
      unless ( -f $file and -w $file ) {
          die "SQLite file $file does not exist";
      }
      
  # Connect to the SQLite database
      my $dbh = DBI->connect("dbi:SQLite(RaiseError=>1):$file");
      unless ( $dbh ) {
        die "Failed to connect to $file";
      }
      
  $dbh->do( <<'END_SQL' );
      create table foo (
          id integer not null primary key,
          name varchar(32) not null
      )
      END_SQL

DESCRIPTION
    SQLite is a light weight single file SQL database that provides an
    excellent platform for embedded storage of structured data.

    ORLite is a light weight single class Object-Relational Mapper (ORM)
    system specifically designed for (and limited to only) work with SQLite.

    ORLite::Migrate is a light weight single class Database Schema Migration
    enhancement for ORLite.

    It provides a simple implementation of schema versioning within the
    SQLite database using the built-in "user_version" pragma (which is set
    to zero by default).

    When setting up the ORM class, an additional "timeline" parameter is
    provided, which should be either a monolithic timeline class, or a
    directory containing standalone migration scripts.

    A "timeline" is a set of revisioned schema changed, to be applied in
    order and representing the evolution of the database schema over time.
    The end of the timeline, representing by the highest revision number,
    represents the "current" anticipated schema for the application.

    Because the patch sequence can be calculated from any arbitrary starting
    version, by keeping the historical set of changes in your application as
    schema patches it is possible for the user of any older application
    version to install the most current version of an application and have
    their database upgraded smoothly and safely.

    The recommended location to store the migration timeline is a shared
    files directory, locatable using one of the functions from
    File::ShareDir.

    The timeline for your application can be specified in two different
    forms, with different advantages and disadvantages.

  Timeline Directories
    A Timeline Directory is a directory on the filesystem containing a set
    of Perl scripts named in a consistent pattern.

    These patch scripts are named in the form migrate-$version.pl, where
    $version is the schema version to migrate to. A typical timeline
    directory will look something like the following.

      migrate-01.pl
      migrate-02.pl
      migrate-03.pl
      migrate-04.pl
      migrate-05.pl
      migrate-06.pl
      migrate-07.pl
      migrate-08.pl
      migrate-09.pl
      migrate-10.pl

    ORLite::Migrate formulates a migration plan that starts at the current
    database "user_version" pragma value, executing the migration script
    that has the version "user_version + 1", then executing "user_version +
    2" and so on.

    It will continue stepping forwards until it runs out of patches to
    execute.

    The main advantage of a timeline directory is that each patch is run in
    its own process and interpreter. Hundreds of patches can be produced by
    many different authors, with certainty that the changes described in
    each will be executed as intended.

    The main disadvantage of using a timeline directory is that your
    application must be able to identify the Perl interpreter it is run in
    so that it can execute a sub-process. This may be difficult or
    impossible for cases such as PAR-packaged applications and Perl
    interpreters embedded inside .exe wrappers or larger non-Perl
    applications.

    In general, it is recommended that you use the timeline directory
    approach unless you encounter a situation in which sub-process execution
    (or locating the patch files) is difficult.

  Timeline Classes
    A timeline class places all of the schema patches into a single Perl
    module, with each patch represented as a method name.

    The following is an example of a trivial timeline class.

      package t::lib::MyTimeline;
      
  use strict;
      use base 'ORLite::Migrate::Timeline';
      
  my $UPGRADE1 = <<'END_SQL';
      
  create table foo (
          id integer not null primary key,
          name varchar(32) not null
      );
      
  insert into foo values ( 1, 'foo' )
      
  END_SQL
      
  sub upgrade1 {
          my $self = shift;
          foreach ( split /;\s+/, $UPGRADE1 ) {
              $self->do($_);
          }
          return 1;
      }
      
  sub upgrade2 {
          $_[0]->do("insert into foo values ( 2, 'bar' )");
      }
      
  sub upgrade3 {
          $_[0]->do("insert into foo values ( 3, 'baz' )");
      }
      
  1;

    As with the patch files, the current state of the "user_version" pragma
    will be examined, and each "upgradeN" method will be called to advance
    the schema forwards.

    The main advantage of a timeline class is that you will not need to
    execute sub-processes, and so a timeline class will continue to function
    even in unusual or exotic process contents such as PAR packaging or .exe
    wrappers.

    The main disadvantage of a timeline class is that the entire timeline
    code must be loaded into memory no matter how many patch steps are
    needed (and stay in memory after the migration has completed), and all
    patches share a common interpreter and thus can potentially pollute or
    corrupt each other.

SUPPORT
    Bugs should be reported via the CPAN bug tracker at

    <http://rt.cpan.org/NoAuth/ReportBug.html?Queue=ORLite-Migrate>

    For other issues, contact the author.

AUTHOR
    Adam Kennedy <adamk@cpan.org>

COPYRIGHT
    Copyright 2009 - 2012 Adam Kennedy.

    This program is free software; you can redistribute it and/or modify it
    under the same terms as Perl itself.

    The full text of the license can be found in the LICENSE file included
    with this module.