package SQL::Translator;
# ----------------------------------------------------------------------
-# $Id: Translator.pm,v 1.63 2004-12-13 16:32:07 grommit Exp $
+# $Id: Translator.pm,v 1.68 2005-06-09 02:02:00 grommit Exp $
# ----------------------------------------------------------------------
# Copyright (C) 2002-4 The SQLFairy Authors
#
require 5.004;
-$VERSION = '0.06';
-$REVISION = sprintf "%d.%02d", q$Revision: 1.63 $ =~ /(\d+)\.(\d+)/;
+$VERSION = '0.07';
+$REVISION = sprintf "%d.%02d", q$Revision: 1.68 $ =~ /(\d+)\.(\d+)/;
$DEBUG = 0 unless defined $DEBUG;
$ERROR = "";
my $filters = $self->{filters} ||= [];
return @$filters unless @_;
- # Set. Convert args to list of [\&code,\%args]
+ # Set. Convert args to list of [\&code,@args]
foreach (@_) {
- $_ = [$_,{}] if not ref($_) eq "ARRAY";
- my ($name,$args) = @$_;
- if ( isa($name,"CODE") ) {
- push @$filters, $_;
+ my ($filt,@args) = ref($_) eq "ARRAY" ? @$_ : $_;
+ if ( isa($filt,"CODE") ) {
+ push @$filters, [$filt,@args];
next;
}
else {
- $self->debug("Adding $name filter. Args:".Dumper($args)."\n");
- my $code = _load_sub("$name\::filter", "SQL::Translator::Filter");
- return $self->error("ERROR:".$self->error) unless $code;
- push @$filters, [$code,$args];
+ $self->debug("Adding $filt filter. Args:".Dumper(\@args)."\n");
+ $filt = _load_sub("$filt\::filter", "SQL::Translator::Filter")
+ || return $self->error(__PACKAGE__->error);
+ push @$filters, [$filt,@args];
}
}
return @$filters;
my $filt_num = 0;
foreach ($self->filters) {
$filt_num++;
- my ($code,$args) = @$_;
- eval { $code->($self->schema, $args) };
+ my ($code,@args) = @$_;
+ eval { $code->($self->schema, @args) };
my $err = $@ || $self->error || 0;
return $self->error("Error with filter $filt_num : $err") if $err;
}
# MODULE - is the name of the module to load.
#
# PATH - optional list of 'package paths' to look for the module in. e.g
-# If you called load(Bar => 'Foo', 'My::Modules') it will try to load the mod
-# Bar then Foo::Bar then My::Modules::Bar.
+# If you called load('Super::Foo' => 'My', 'Other') it will
+# try to load the mod Super::Foo then My::Super::Foo then Other::Super::Foo.
#
# Returns package name of the module actually loaded or false and sets error.
#
eval { require $file };
next if $@ =~ /Can't locate $file in \@INC/;
- eval { $file->import(@_) } unless $@;
- return __PACKAGE__->error("Error loading $name as $module : $@") if $@;
+ eval { $module->import() } unless $@;
+ return __PACKAGE__->error("Error loading $name as $module : $@")
+ if $@ && $@ !~ /"SQL::Translator::Producer" is not exported/;
return $module; # Module loaded ok
}
sub _load_sub {
my ($tool, @path) = @_;
- # Passed a module name or module and sub name
my (undef,$module,$func_name) = $tool =~ m/((.*)::)?(\w+)$/;
if ( my $module = load($module => @path) ) {
my $sub = "$module\::$func_name";
Set or retreive the filters to run over the schema during the
translation, before the producer creates its output. Filters are sub
routines called, in order, with the schema object to filter as the 1st
-arg and a hashref of options as the 2nd. They are free to do whatever
-they want to the schema object, which will be handed to any following
-filters, then used by the producer.
+arg and a hash of options (passed as a list) for the rest of the args.
+They are free to do whatever they want to the schema object, which will be
+handed to any following filters, then used by the producer.
Filters are set as an array, which gives the order they run in.
Like parsers and producers, they can be defined by a module name, a
module name relative to the SQL::Translator::Filter namespace, a module
name and function name together or a reference to an anonymous subroutine.
When using a module name a function called C<filter> will be invoked in
-that package to do the work. To pass args to the filter set it as an array
-ref with the 1st value giving the filter and the rest being a hash of
-args.
+that package to do the work.
+
+To pass args to the filter set it as an array ref with the 1st value giving
+the filter (name or sub) and the rest its args. e.g.
$tr->filters(
sub {
my $schema = shift;
# Do stuff to schema here!
},
- [ "Foo", foo => "bar", hello => "world" ],
- [ "Filter3" ],
+ DropFKeys,
+ [ "Names", table => 'lc' ],
+ [ "Foo", foo => "bar", hello => "world" ],
+ [ "Filter5" ],
);
-Although you would normally set them in the constructor, which calls
+Although you normally set them in the constructor, which calls
through to filters. i.e.
my $translator = SQL::Translator->new(
...
filters => [
sub { ... },
- [ Foo, foo => "bar" ],
+ [ "Names", table => 'lc' ],
],
...
);
the end of the current list.
Returns the filters as a list of array refs, the 1st value being a
-reference to the filter sub routine and the 2nd a hashref its args.
+reference to the filter sub and the rest its args.
=head2 show_warnings