view release on metacpan or  search on metacpan

README  view on Meta::CPAN

  /-=-------\        /-=-------\       /-=----------\
  |         |        |         |       |            |  (interface roles)
  | Handles |        | Handles |       |  Handles   |
  | Version |        | Deploy  |       | Versioning |
  | Storage |        |         |       |            |
  |         |        \-+--+--+-/       \-+---+---+--/
  \-+--+--+-/          |  |  |           |   |   |
    |  |  |            |  |  |           |   |   |
    |  |  |            |  |  |           |   |   |
    v  v  v            v  v  v           v   v   v
 +----------+        +--------+        +-----------+
 |          |        |        |        |           |  (implementations)
 | Version  |        | Deploy |        |  Version  |
 | Storage  |        | Method |        |  Handler  |
 | Standard |        | SQLT   |        | Monotonic |
 |          |        |        |        |           |
 +----------+        +--------+        +-----------+
    The nice thing about this is that we have well defined interfaces for
    the objects that comprise the "DeploymentHandler", the smaller objects
    can be tested in isolation, and the smaller objects can even be swapped
    in easily. But the real win is that you can subclass the
    "DeploymentHandler" without knowing about the underlying delegation; you
    just treat it like normal Perl and write methods that do what you want.

THIS SUCKS
    You started your project and weren't using
    "DBIx::Class::DeploymentHandler"? Lucky for you I had you in mind when I
    wrote this doc.

    First, define the version in your main schema file (maybe using
    $VERSION).

    Then you'll want to just install the version_storage:

     my $s = My::Schema->connect(...);
     my $dh = DBIx::Class::DeploymentHandler->new({ schema => $s });

     $dh->prepare_version_storage_install;
     $dh->install_version_storage;

    Then set your database version:

     $dh->add_database_version({ version => $s->schema_version });

    Now you should be able to use "DBIx::Class::DeploymentHandler" like
    normal!

LOGGING
    This is a complex tool, and because of that sometimes you'll want to see
    what exactly is happening. The best way to do that is to use the built
    in logging functionality. It the standard six log levels; "fatal",
    "error", "warn", "info", "debug", and "trace". Most of those are pretty
    self explanatory. Generally a safe level to see what all is going on is
    debug, which will give you everything except for the exact SQL being
    run.

    To enable the various logging levels all you need to do is set an
    environment variables: "DBICDH_FATAL", "DBICDH_ERROR", "DBICDH_WARN",
    "DBICDH_INFO", "DBICDH_DEBUG", and "DBICDH_TRACE". Each level can be set
    on its own, but the default is the first three on and the last three
    off, and the levels cascade, so if you turn on trace the rest will turn
    on automatically.

DONATIONS
    If you'd like to thank me for the work I've done on this module, don't
    give me a donation. I spend a lot of free time creating free software,
    but I do it because I love it.

    Instead, consider donating to someone who might actually need it.
    Obviously you should do research when donating to a charity, so don't
    just take my word on this. I like Matthew 25: Ministries:
    <http://www.m25m.org/>, but there are a host of other charities that can
    do much more good than I will with your money. (Third party charity info
    here:
    <http://www.charitynavigator.org/index.cfm?bay=search.summary&orgid=6901
    >

METHODS
    This is just a "stub" section to make clear that the bulk of
    implementation is documented in DBIx::Class::DeploymentHandler::Dad.
    Since that is implemented using Moose class, see "ATTRIBUTES" in
    DBIx::Class::DeploymentHandler::Dad and "ORTHODOX METHODS" in
    DBIx::Class::DeploymentHandler::Dad for methods callable on the
    resulting object.

  new
      my $s = My::Schema->connect(...);
      my $dh = DBIx::Class::DeploymentHandler->new({
        schema              => $s,
        databases           => 'SQLite',
        sql_translator_args => { add_drop_table => 0 },
      });

  prepare_version_storage_install
     $dh->prepare_version_storage_install

    Creates the needed ".sql" file to install the version storage and not
    the rest of the tables

  prepare_install
     $dh->prepare_install

    First prepare all the tables to be installed and the prepare just the
    version storage

  install_version_storage
     $dh->install_version_storage

    Install the version storage and not the rest of the tables

AUTHOR
    Arthur Axel "fREW" Schmidt <frioux+cpan@gmail.com>

COPYRIGHT AND LICENSE
    This software is copyright (c) 2025 by Arthur Axel "fREW" Schmidt.

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