SQL::Translator::Filter::Globals - Add global fields and indices to all tables.

  # e.g. Add timestamp field to all tables.
  use SQL::Translator;

  my $sqlt = SQL::Translator->new(
      from => 'MySQL',
      to   => 'MySQL',
      filters => [
        Globals => {
            fields => [
                {
                    name => 'modified'
                    data_type => 'TIMESTAMP'
                }
            ],
            indices => [
                { 
                    fields => 'modifed',
                },
            ]
            constraints => [
                {
                }
            ]
        },
      ],
  ) || die "SQLFairy error : ".SQL::Translator->error;
  my $sql = $sqlt->translate || die "SQLFairy error : ".$sqlt->error;

package SQL::Translator::Filter::Globals;

# -------------------------------------------------------------------
# Copyright (C) 2002-2009 SQLFairy Authors
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; version 2.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
# 02111-1307  USA
# -------------------------------------------------------------------

use strict;
use vars qw/$VERSION/;
$VERSION = '1.59';

sub filter {
    my $schema = shift;
    my %args = @_;
    my $global_table = $args{global_table} ||= '_GLOBAL_';

    my (@global_fields, @global_indices, @global_constraints);
    push @global_fields,      @{ $args{fields} }      if $args{fields};
    push @global_indices,     @{ $args{indices} }     if $args{indices};
    push @global_constraints, @{ $args{constraints} } if $args{constraints};

    # Pull fields and indices off global table and then remove it.
    if ( my $gtbl = $schema->get_table( $global_table ) ) {

        foreach ( $gtbl->get_fields ) {
            # We don't copy the order attrib so the added fields should get
            # pushed on the end of each table.
            push @global_fields, {
                name                  => $_->name,
                comments              => "".$_->comments,
                data_type             => $_->data_type,
                default_value         => $_->default_value,
                size                  => [$_->size],
                extra                 => scalar($_->extra),
                foreign_key_reference => $_->foreign_key_reference,
                is_auto_increment     => $_->is_auto_increment,
                is_foreign_key        => $_->is_foreign_key,
                is_nullable           => $_->is_nullable,
                is_primary_key        => $_->is_primary_key,
                is_unique             => $_->is_unique,
                is_valid              => $_->is_valid,
            };
        }

        foreach ( $gtbl->get_indices ) {
            push @global_indices, {
                name    => $_->name,
                type    => $_->type,
                fields  => [$_->fields],
                options => [$_->options],
                extra   => scalar($_->extra),
            };
        }

        foreach ( $gtbl->get_constraints ) {
            push @global_constraints, {
                name             => $_->name,
                fields           => [$_->fields],
                deferrable       => $_->deferrable,
                expression       => $_->expression,
                match_type       => $_->match_type,
                options          => [$_->options],
                on_delete        => $_->on_delete,
                on_update        => $_->on_update,
                reference_fields => [$_->reference_fields],
                reference_table  => $_->reference_table,
                table            => $_->table,
                type             => $_->type,
                extra            => scalar($_->extra),
            };
        }

        $schema->drop_table($gtbl);
    }

    # Add globalis to tables
    foreach my $tbl ( $schema->get_tables ) {

        foreach my $new_fld ( @global_fields ) {
            # Don't add if field already there
            next if $tbl->get_field( $new_fld->{name} );
            $tbl->add_field( %$new_fld );
        }

        foreach my $new_index ( @global_indices ) {
            $tbl->add_index( %$new_index );
        }

        foreach my $new_constraint ( @global_constraints ) {
            $tbl->add_constraint( %$new_constraint );
        }
    }
}

1;

__END__