1 package SQL::Translator;
3 # ----------------------------------------------------------------------
4 # $Id: Translator.pm,v 1.36 2003-07-09 05:59:24 allenday Exp $
5 # ----------------------------------------------------------------------
6 # Copyright (C) 2003 Ken Y. Clark <kclark@cpan.org>,
7 # darren chamberlain <darren@cpan.org>,
8 # Chris Mungall <cjm@fruitfly.org>
10 # This program is free software; you can redistribute it and/or
11 # modify it under the terms of the GNU General Public License as
12 # published by the Free Software Foundation; version 2.
14 # This program is distributed in the hope that it will be useful, but
15 # WITHOUT ANY WARRANTY; without even the implied warranty of
16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 # General Public License for more details.
19 # You should have received a copy of the GNU General Public License
20 # along with this program; if not, write to the Free Software
21 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
23 # -------------------------------------------------------------------
26 use vars qw( $VERSION $REVISION $DEFAULT_SUB $DEBUG $ERROR );
27 use base 'Class::Base';
30 $REVISION = sprintf "%d.%02d", q$Revision: 1.36 $ =~ /(\d+)\.(\d+)/;
31 $DEBUG = 0 unless defined $DEBUG;
37 use File::Spec::Functions qw(catfile);
38 use File::Basename qw(dirname);
40 use SQL::Translator::Schema;
42 # ----------------------------------------------------------------------
43 # The default behavior is to "pass through" values (note that the
44 # SQL::Translator instance is the first value ($_[0]), and the stuff
45 # to be parsed is the second value ($_[1])
46 # ----------------------------------------------------------------------
47 $DEFAULT_SUB = sub { $_[0]->schema } unless defined $DEFAULT_SUB;
49 # ----------------------------------------------------------------------
53 # new takes an optional hash of arguments. These arguments may
54 # include a parser, specified with the keys "parser" or "from",
55 # and a producer, specified with the keys "producer" or "to".
57 # The values that can be passed as the parser or producer are
58 # given directly to the parser or producer methods, respectively.
59 # See the appropriate method description below for details about
60 # what each expects/accepts.
61 # ----------------------------------------------------------------------
63 my ( $self, $config ) = @_;
65 # Set the parser and producer.
67 # If a 'parser' or 'from' parameter is passed in, use that as the
68 # parser; if a 'producer' or 'to' parameter is passed in, use that
69 # as the producer; both default to $DEFAULT_SUB.
71 $self->parser ($config->{'parser'} || $config->{'from'} || $DEFAULT_SUB);
72 $self->producer($config->{'producer'} || $config->{'to'} || $DEFAULT_SUB);
75 # Set up callbacks for formatting of pk,fk,table,package names in producer
77 $self->format_table_name($config->{'format_table_name'});
78 $self->format_package_name($config->{'format_package_name'});
79 $self->format_fk_name($config->{'format_fk_name'});
80 $self->format_pk_name($config->{'format_pk_name'});
83 # Set the parser_args and producer_args
85 for my $pargs ( qw[ parser_args producer_args ] ) {
86 $self->$pargs( $config->{$pargs} ) if defined $config->{ $pargs };
90 # Set the data source, if 'filename' or 'file' is provided.
92 $config->{'filename'} ||= $config->{'file'} || "";
93 $self->filename( $config->{'filename'} ) if $config->{'filename'};
96 # Finally, if there is a 'data' parameter, use that in
97 # preference to filename and file
99 if ( my $data = $config->{'data'} ) {
100 $self->data( $data );
104 # Set various other options.
106 $self->{'debug'} = defined $config->{'debug'} ? $config->{'debug'} : $DEBUG;
108 $self->add_drop_table( $config->{'add_drop_table'} );
110 $self->no_comments( $config->{'no_comments'} );
112 $self->show_warnings( $config->{'show_warnings'} );
114 $self->trace( $config->{'trace'} );
116 $self->validate( $config->{'validate'} );
121 # ----------------------------------------------------------------------
122 # add_drop_table([$bool])
123 # ----------------------------------------------------------------------
126 if ( defined (my $arg = shift) ) {
127 $self->{'add_drop_table'} = $arg ? 1 : 0;
129 return $self->{'add_drop_table'} || 0;
132 # ----------------------------------------------------------------------
133 # no_comments([$bool])
134 # ----------------------------------------------------------------------
138 if ( defined $arg ) {
139 $self->{'no_comments'} = $arg ? 1 : 0;
141 return $self->{'no_comments'} || 0;
145 # ----------------------------------------------------------------------
146 # producer([$producer_spec])
148 # Get or set the producer for the current translator.
149 # ----------------------------------------------------------------------
153 # producer as a mutator
155 my $producer = shift;
157 # Passed a module name (string containing "::")
158 if ($producer =~ /::/) {
161 # Module name was passed directly
162 # We try to load the name; if it doesn't load, there's
163 # a possibility that it has a function name attached to
165 if (load($producer)) {
166 $func_name = "produce";
169 # Module::function was passed
171 # Passed Module::Name::function; try to recover
172 my @func_parts = split /::/, $producer;
173 $func_name = pop @func_parts;
174 $producer = join "::", @func_parts;
176 # If this doesn't work, then we have a legitimate
178 load($producer) or die "Can't load $producer: $@";
181 # get code reference and assign
182 $self->{'producer'} = \&{ "$producer\::$func_name" };
183 $self->{'producer_type'} = $producer;
184 $self->debug("Got producer: $producer\::$func_name\n");
187 # passed an anonymous subroutine reference
188 elsif (isa($producer, 'CODE')) {
189 $self->{'producer'} = $producer;
190 $self->{'producer_type'} = "CODE";
191 $self->debug("Got producer: code ref\n");
194 # passed a string containing no "::"; relative package name
196 my $Pp = sprintf "SQL::Translator::Producer::$producer";
197 load($Pp) or die "Can't load $Pp: $@";
198 $self->{'producer'} = \&{ "$Pp\::produce" };
199 $self->{'producer_type'} = $Pp;
200 $self->debug("Got producer: $Pp\n");
203 # At this point, $self->{'producer'} contains a subroutine
204 # reference that is ready to run
206 # Anything left? If so, it's producer_args
207 $self->producer_args(@_) if (@_);
210 return $self->{'producer'};
213 # ----------------------------------------------------------------------
216 # producer_type is an accessor that allows producer subs to get
217 # information about their origin. This is poptentially important;
218 # since all producer subs are called as subroutine references, there is
219 # no way for a producer to find out which package the sub lives in
220 # originally, for example.
221 # ----------------------------------------------------------------------
222 sub producer_type { $_[0]->{'producer_type'} }
224 # ----------------------------------------------------------------------
225 # producer_args([\%args])
227 # Arbitrary name => value pairs of paramters can be passed to a
228 # producer using this method.
230 # If the first argument passed in is undef, then the hash of arguments
231 # is cleared; all subsequent elements are added to the hash of name,
232 # value pairs stored as producer_args.
233 # ----------------------------------------------------------------------
236 return $self->_args("producer", @_);
239 # ----------------------------------------------------------------------
240 # parser([$parser_spec])
241 # ----------------------------------------------------------------------
245 # parser as a mutator
249 # Passed a module name (string containing "::")
250 if ($parser =~ /::/) {
253 # Module name was passed directly
254 # We try to load the name; if it doesn't load, there's
255 # a possibility that it has a function name attached to
258 $func_name = "parse";
261 # Module::function was passed
263 # Passed Module::Name::function; try to recover
264 my @func_parts = split /::/, $parser;
265 $func_name = pop @func_parts;
266 $parser = join "::", @func_parts;
268 # If this doesn't work, then we have a legitimate
270 load($parser) or die "Can't load $parser: $@";
273 # get code reference and assign
274 $self->{'parser'} = \&{ "$parser\::$func_name" };
275 $self->{'parser_type'} = $parser;
276 $self->debug("Got parser: $parser\::$func_name\n");
279 # passed an anonymous subroutine reference
280 elsif ( isa( $parser, 'CODE' ) ) {
281 $self->{'parser'} = $parser;
282 $self->{'parser_type'} = "CODE";
283 $self->debug("Got parser: code ref\n");
286 # passed a string containing no "::"; relative package name
288 my $Pp = "SQL::Translator::Parser::$parser";
289 load( $Pp ) or die "Can't load $Pp: $@";
290 $self->{'parser'} = \&{ "$Pp\::parse" };
291 $self->{'parser_type'} = $Pp;
292 $self->debug("Got parser: $Pp\n");
296 # At this point, $self->{'parser'} contains a subroutine
297 # reference that is ready to run
299 $self->parser_args( @_ ) if (@_);
302 return $self->{'parser'};
305 # ----------------------------------------------------------------------
306 sub parser_type { $_[0]->{'parser_type'} }
310 return $self->_args("parser", @_);
316 if ( defined $arg ) {
317 $self->{'show_warnings'} = $arg ? 1 : 0;
319 return $self->{'show_warnings'} || 0;
323 # filename - get or set the filename
327 my $filename = shift;
329 my $msg = "Cannot use directory '$filename' as input source";
330 return $self->error($msg);
331 } elsif (ref($filename) eq 'ARRAY') {
332 $self->{'filename'} = $filename;
333 $self->debug("Got array of files: ".join(', ',@$filename)."\n");
334 } elsif (-f _ && -r _) {
335 $self->{'filename'} = $filename;
336 $self->debug("Got filename: '$self->{'filename'}'\n");
338 my $msg = "Cannot use '$filename' as input source: ".
339 "file does not exist or is not readable.";
340 return $self->error($msg);
347 # ----------------------------------------------------------------------
350 # if $self->{'data'} is not set, but $self->{'filename'} is, then
351 # $self->{'filename'} is opened and read, with the results put into
353 # ----------------------------------------------------------------------
357 # Set $self->{'data'} based on what was passed in. We will
358 # accept a number of things; do our best to get it right.
361 if (isa($data, "SCALAR")) {
362 $self->{'data'} = $data;
365 if (isa($data, 'ARRAY')) {
366 $data = join '', @$data;
368 elsif (isa($data, 'GLOB')) {
372 elsif (! ref $data && @_) {
373 $data = join '', $data, @_;
375 $self->{'data'} = \$data;
379 # If we have a filename but no data yet, populate.
380 if (not $self->{'data'} and my $filename = $self->filename) {
381 $self->debug("Opening '$filename' to get contents.\n");
386 my @files = ref($filename) eq 'ARRAY' ? @$filename : ($filename);
388 foreach my $file (@files) {
389 unless (open FH, $file) {
390 return $self->error("Can't read file '$file': $!");
396 return $self->error("Can't close file '$file': $!");
400 $self->{'data'} = \$data;
403 return $self->{'data'};
406 # ----------------------------------------------------------------------
409 # Returns the SQL::Translator::Schema object
413 unless ( defined $self->{'schema'} ) {
414 $self->{'schema'} = SQL::Translator::Schema->new;
417 return $self->{'schema'};
420 # ----------------------------------------------------------------------
424 if ( defined $arg ) {
425 $self->{'trace'} = $arg ? 1 : 0;
427 return $self->{'trace'} || 0;
430 # ----------------------------------------------------------------------
431 # translate([source], [\%args])
433 # translate does the actual translation. The main argument is the
434 # source of the data to be translated, which can be a filename, scalar
435 # reference, or glob reference.
437 # Alternatively, translate takes optional arguements, which are passed
438 # to the appropriate places. Most notable of these arguments are
439 # parser and producer, which can be used to set the parser and
440 # producer, respectively. This is the applications last chance to set
443 # translate returns a string.
444 # ----------------------------------------------------------------------
447 my ($args, $parser, $parser_type, $producer, $producer_type);
448 my ($parser_output, $producer_output);
452 # Passed a reference to a hash?
453 if (isa($_[0], 'HASH')) {
455 $self->debug("translate: Got a hashref\n");
459 # Passed a GLOB reference, i.e., filehandle
460 elsif (isa($_[0], 'GLOB')) {
461 $self->debug("translate: Got a GLOB reference\n");
465 # Passed a reference to a string containing the data
466 elsif (isa($_[0], 'SCALAR')) {
467 # passed a ref to a string
468 $self->debug("translate: Got a SCALAR reference (string)\n");
472 # Not a reference; treat it as a filename
473 elsif (! ref $_[0]) {
474 # Not a ref, it's a filename
475 $self->debug("translate: Got a filename\n");
476 $self->filename($_[0]);
479 # Passed something else entirely.
481 # We're not impressed. Take your empty string and leave.
484 # Actually, if data, parser, and producer are set, then we
485 # can continue. Too bad, because I like my comment
487 return "" unless ($self->data &&
493 # You must pass in a hash, or you get nothing.
498 # ----------------------------------------------------------------------
499 # Can specify the data to be transformed using "filename", "file",
500 # "data", or "datasource".
501 # ----------------------------------------------------------------------
502 if (my $filename = ($args->{'filename'} || $args->{'file'})) {
503 $self->filename($filename);
506 if (my $data = ($args->{'data'} || $args->{'datasource'})) {
510 # ----------------------------------------------------------------
512 # ----------------------------------------------------------------
513 my $data = $self->data;
514 unless (ref($data) eq 'SCALAR' and length $$data) {
515 return $self->error("Empty data file!");
518 # ----------------------------------------------------------------
519 # Local reference to the parser subroutine
520 # ----------------------------------------------------------------
521 if ($parser = ($args->{'parser'} || $args->{'from'})) {
522 $self->parser($parser);
524 $parser = $self->parser;
525 $parser_type = $self->parser_type;
527 # ----------------------------------------------------------------
528 # Local reference to the producer subroutine
529 # ----------------------------------------------------------------
530 if ($producer = ($args->{'producer'} || $args->{'to'})) {
531 $self->producer($producer);
533 $producer = $self->producer;
534 $producer_type = $self->producer_type;
536 # ----------------------------------------------------------------
537 # Execute the parser, then execute the producer with that output.
538 # Allowances are made for each piece to die, or fail to compile,
539 # since the referenced subroutines could be almost anything. In
540 # the future, each of these might happen in a Safe environment,
541 # depending on how paranoid we want to be.
542 # ----------------------------------------------------------------
543 eval { $parser_output = $parser->($self, $$data) };
544 if ($@ || ! $parser_output) {
545 my $msg = sprintf "translate: Error with parser '%s': %s",
546 $parser_type, ($@) ? $@ : " no results";
547 return $self->error($msg);
550 if ( $self->validate ) {
551 my $schema = $self->schema;
552 return $self->error('Invalid schema') unless $schema->is_valid;
555 eval { $producer_output = $producer->($self) };
556 if ($@ || ! $producer_output) {
557 my $msg = sprintf "translate: Error with producer '%s': %s",
558 $producer_type, ($@) ? $@ : " no results";
559 return $self->error($msg);
562 return $producer_output;
565 # ----------------------------------------------------------------------
568 # Hacky sort of method to list all available parsers. This has
571 # - Only finds things in the SQL::Translator::Parser namespace
573 # - Only finds things that are located in the same directory
574 # as SQL::Translator::Parser. Yeck.
576 # This method will fail in several very likely cases:
578 # - Parser modules in different namespaces
580 # - Parser modules in the SQL::Translator::Parser namespace that
581 # have any XS componenets will be installed in
582 # arch_lib/SQL/Translator.
584 # ----------------------------------------------------------------------
586 return shift->_list("parser");
589 # ----------------------------------------------------------------------
592 # See notes for list_parsers(), above; all the problems apply to
593 # list_producers as well.
594 # ----------------------------------------------------------------------
596 return shift->_list("producer");
600 # ======================================================================
602 # ======================================================================
604 # ----------------------------------------------------------------------
605 # _args($type, \%args);
607 # Gets or sets ${type}_args. Called by parser_args and producer_args.
608 # ----------------------------------------------------------------------
612 $type = "${type}_args" unless $type =~ /_args$/;
614 unless (defined $self->{$type} && isa($self->{$type}, 'HASH')) {
615 $self->{$type} = { };
619 # If the first argument is an explicit undef (remember, we
620 # don't get here unless there is stuff in @_), then we clear
621 # out the producer_args hash.
622 if (! defined $_[0]) {
624 %{$self->{$type}} = ();
627 my $args = isa($_[0], 'HASH') ? shift : { @_ };
628 %{$self->{$type}} = (%{$self->{$type}}, %$args);
634 # ----------------------------------------------------------------------
636 # ----------------------------------------------------------------------
639 my $type = shift || return ();
640 my $uctype = ucfirst lc $type;
643 load("SQL::Translator::$uctype") or return ();
644 my $path = catfile "SQL", "Translator", $uctype;
646 my $dir = catfile $_, $path;
647 $self->debug("_list_${type}s searching $dir");
650 my $dh = IO::Dir->new($dir);
651 for (grep /\.pm$/, $dh->read) {
653 $found{ join "::", "SQL::Translator::$uctype", $_ } = 1;
660 # ----------------------------------------------------------------------
663 # Loads a Perl module. Short circuits if a module is already loaded.
664 # ----------------------------------------------------------------------
666 my $module = do { my $m = shift; $m =~ s[::][/]g; "$m.pm" };
667 return 1 if $INC{$module};
674 return __PACKAGE__->error($@) if ($@);
678 # ----------------------------------------------------------------------
679 sub format_table_name {
682 $self->{'_format_table_name'} = $sub if ref $sub eq 'CODE';
683 return $self->{'_format_table_name'}->( $sub, @_ )
684 if defined $self->{'_format_table_name'};
688 # ----------------------------------------------------------------------
689 sub format_package_name {
692 $self->{'_format_package_name'} = $sub if ref $sub eq 'CODE';
693 return $self->{'_format_package_name'}->( $sub, @_ )
694 if defined $self->{'_format_package_name'};
698 # ----------------------------------------------------------------------
702 if ( ref $_[0] eq 'CODE' ) {
703 $self->{'_format_pk_name'} = shift;
707 if ( defined $self->{'_format_pk_name'} ) {
708 return $self->{'_format_pk_name'}->( @_ );
715 return $self->{'_format_pk_name'};
717 # $self->{'_format_fk_name'} = $sub if ref $sub eq 'CODE';
718 # return $self->{'_format_fk_name'}->( $sub, @_ )
719 # if defined $self->{'_format_fk_name'};
723 # ----------------------------------------------------------------------
727 if ( ref $_[0] eq 'CODE' ) {
728 $self->{'_format_pk_name'} = shift;
732 if ( defined $self->{'_format_pk_name'} ) {
733 return $self->{'_format_pk_name'}->( @_ );
740 return $self->{'_format_pk_name'};
743 # ----------------------------------------------------------------------
746 # Calls UNIVERSAL::isa($ref, $type). I think UNIVERSAL::isa is ugly,
747 # but I like function overhead.
748 # ----------------------------------------------------------------------
750 my ($ref, $type) = @_;
751 return UNIVERSAL::isa($ref, $type);
754 # ----------------------------------------------------------------------
756 my ( $self, $arg ) = @_;
757 if ( defined $arg ) {
758 $self->{'validate'} = $arg ? 1 : 0;
760 return $self->{'validate'} || 0;
765 # ----------------------------------------------------------------------
766 # Who killed the pork chops?
767 # What price bananas?
770 # ----------------------------------------------------------------------
776 SQL::Translator - manipulate structured data definitions (SQL and more)
782 my $translator = SQL::Translator->new(
785 # Print Parse::RecDescent trace
787 # Don't include comments in output
789 # Print name mutations, conflicts
791 # Add "drop table" statements
793 # Validate schema object
795 # Make all table names CAPS in producers which support this option
796 format_table_name => sub {my $tablename = shift; return uc($tablename)},
797 # Null-op formatting, only here for documentation's sake
798 format_package_name => sub {return shift},
799 format_fk_name => sub {return shift},
800 format_pk_name => sub {return shift},
803 my $output = $translator->translate(
806 # Or an arrayref of filenames, i.e. [ $file1, $file2, $file3 ]
808 ) or die $translator->error;
814 SQL::Translator is a group of Perl modules that converts
815 vendor-specific SQL table definitions into other formats, such as
816 other vendor-specific SQL, ER diagrams, documentation (POD and HTML),
817 XML, and Class::DBI classes. The main focus of SQL::Translator is
818 SQL, but parsers exist for other structured data formats, including
819 Excel spreadsheets and arbitrarily delimited text files. Through the
820 separation of the code into parsers and producers with an object model
821 in between, it's possible to combine any parser with any producer, to
822 plug in custom parsers or producers, or to manipulate the parsed data
823 via the built-in object model. Presently only the definition parts of
824 SQL are handled (CREATE, ALTER), not the manipulation of data (INSERT,
829 The constructor is called C<new>, and accepts a optional hash of options.
880 All options are, well, optional; these attributes can be set via
881 instance methods. Internally, they are; no (non-syntactical)
882 advantage is gained by passing options to the constructor.
886 =head2 add_drop_table
888 Toggles whether or not to add "DROP TABLE" statements just before the
893 Toggles whether to print comments in the output. Accepts a true or false
894 value, returns the current value.
898 The C<producer> method is an accessor/mutator, used to retrieve or
899 define what subroutine is called to produce the output. A subroutine
900 defined as a producer will be invoked as a function (I<not a method>)
901 and passed 2 parameters: its container C<SQL::Translator> instance and a
902 data structure. It is expected that the function transform the data
903 structure to a string. The C<SQL::Transformer> instance is provided for
904 informational purposes; for example, the type of the parser can be
905 retrieved using the C<parser_type> method, and the C<error> and
906 C<debug> methods can be called when needed.
908 When defining a producer, one of several things can be passed in: A
909 module name (e.g., C<My::Groovy::Producer>), a module name relative to
910 the C<SQL::Translator::Producer> namespace (e.g., C<MySQL>), a module
911 name and function combination (C<My::Groovy::Producer::transmogrify>),
912 or a reference to an anonymous subroutine. If a full module name is
913 passed in (for the purposes of this method, a string containing "::"
914 is considered to be a module name), it is treated as a package, and a
915 function called "produce" will be invoked: C<$modulename::produce>.
916 If $modulename cannot be loaded, the final portion is stripped off and
917 treated as a function. In other words, if there is no file named
918 F<My/Groovy/Producer/transmogrify.pm>, C<SQL::Translator> will attempt
919 to load F<My/Groovy/Producer.pm> and use C<transmogrify> as the name of
920 the function, instead of the default C<produce>.
922 my $tr = SQL::Translator->new;
924 # This will invoke My::Groovy::Producer::produce($tr, $data)
925 $tr->producer("My::Groovy::Producer");
927 # This will invoke SQL::Translator::Producer::Sybase::produce($tr, $data)
928 $tr->producer("Sybase");
930 # This will invoke My::Groovy::Producer::transmogrify($tr, $data),
931 # assuming that My::Groovy::Producer::transmogrify is not a module
933 $tr->producer("My::Groovy::Producer::transmogrify");
935 # This will invoke the referenced subroutine directly, as
936 # $subref->($tr, $data);
937 $tr->producer(\&my_producer);
939 There is also a method named C<producer_type>, which is a string
940 containing the classname to which the above C<produce> function
941 belongs. In the case of anonymous subroutines, this method returns
944 Finally, there is a method named C<producer_args>, which is both an
945 accessor and a mutator. Arbitrary data may be stored in name => value
946 pairs for the producer subroutine to access:
948 sub My::Random::producer {
949 my ($tr, $data) = @_;
950 my $pr_args = $tr->producer_args();
952 # $pr_args is a hashref.
954 Extra data passed to the C<producer> method is passed to
957 $tr->producer("xSV", delimiter => ',\s*');
959 # In SQL::Translator::Producer::xSV:
960 my $args = $tr->producer_args;
961 my $delimiter = $args->{'delimiter'}; # value is ,\s*
965 The C<parser> method defines or retrieves a subroutine that will be
966 called to perform the parsing. The basic idea is the same as that of
967 C<producer> (see above), except the default subroutine name is
968 "parse", and will be invoked as C<$module_name::parse($tr, $data)>.
969 Also, the parser subroutine will be passed a string containing the
970 entirety of the data to be parsed.
972 # Invokes SQL::Translator::Parser::MySQL::parse()
973 $tr->parser("MySQL");
975 # Invokes My::Groovy::Parser::parse()
976 $tr->parser("My::Groovy::Parser");
978 # Invoke an anonymous subroutine directly
980 my $dumper = Data::Dumper->new([ $_[1] ], [ "SQL" ]);
981 $dumper->Purity(1)->Terse(1)->Deepcopy(1);
982 return $dumper->Dump;
985 There is also C<parser_type> and C<parser_args>, which perform
986 analogously to C<producer_type> and C<producer_args>
990 Toggles whether to print warnings of name conflicts, identifier
991 mutations, etc. Probably only generated by producers to let the user
992 know when something won't translate very smoothly (e.g., MySQL "enum"
993 fields into Oracle). Accepts a true or false value, returns the
998 The C<translate> method calls the subroutines referenced by the
999 C<parser> and C<producer> data members (described above). It accepts
1000 as arguments a number of things, in key => value format, including
1001 (potentially) a parser and a producer (they are passed directly to the
1002 C<parser> and C<producer> methods).
1004 Here is how the parameter list to C<translate> is parsed:
1010 1 argument means it's the data to be parsed; which could be a string
1011 (filename) or a reference to a scalar (a string stored in memory), or a
1012 reference to a hash, which is parsed as being more than one argument
1015 # Parse the file /path/to/datafile
1016 my $output = $tr->translate("/path/to/datafile");
1018 # Parse the data contained in the string $data
1019 my $output = $tr->translate(\$data);
1023 More than 1 argument means its a hash of things, and it might be
1024 setting a parser, producer, or datasource (this key is named
1025 "filename" or "file" if it's a file, or "data" for a SCALAR reference.
1027 # As above, parse /path/to/datafile, but with different producers
1028 for my $prod ("MySQL", "XML", "Sybase") {
1029 print $tr->translate(
1031 filename => "/path/to/datafile",
1035 # The filename hash key could also be:
1036 datasource => \$data,
1042 =head2 filename, data
1044 Using the C<filename> method, the filename of the data to be parsed
1045 can be set. This method can be used in conjunction with the C<data>
1046 method, below. If both the C<filename> and C<data> methods are
1047 invoked as mutators, the data set in the C<data> method is used.
1049 $tr->filename("/my/data/files/create.sql");
1053 my $create_script = do {
1055 open CREATE, "/my/data/files/create.sql" or die $!;
1058 $tr->data(\$create_script);
1060 C<filename> takes a string, which is interpreted as a filename.
1061 C<data> takes a reference to a string, which is used as the data to be
1062 parsed. If a filename is set, then that file is opened and read when
1063 the C<translate> method is called, as long as the data instance
1064 variable is not set.
1068 Returns the SQL::Translator::Schema object.
1072 Turns on/off the tracing option of Parse::RecDescent.
1076 Whether or not to validate the schema object after parsing and before
1081 Ken Y. Clark, E<lt>kclark@cpan.orgE<gt>,
1082 darren chamberlain E<lt>darren@cpan.orgE<gt>,
1083 Chris Mungall E<lt>cjm@fruitfly.orgE<gt>,
1084 Allen Day E<lt>allenday@users.sourceforge.netE<gt>,
1085 Sam Angiuoli E<lt>angiuoli@users.sourceforge.netE<gt>,
1086 Ying Zhang E<lt>zyolive@yahoo.comE<gt>,
1087 Mike Mellilo <mmelillo@users.sourceforge.net>.
1091 This program is free software; you can redistribute it and/or modify
1092 it under the terms of the GNU General Public License as published by
1093 the Free Software Foundation; version 2.
1095 This program is distributed in the hope that it will be useful, but
1096 WITHOUT ANY WARRANTY; without even the implied warranty of
1097 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
1098 General Public License for more details.
1100 You should have received a copy of the GNU General Public License
1101 along with this program; if not, write to the Free Software
1102 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
1107 Please use http://rt.cpan.org/ for reporting bugs.
1112 L<SQL::Translator::Parser>,
1113 L<SQL::Translator::Producer>,
1114 L<Parse::RecDescent>,
1117 L<Text::RecordParser>,