lib/SQL/Translator/Parser/YAML.pm

   1 package SQL::Translator::Parser::YAML;
   2
   3 use strict;
   4 use warnings;
   5 use vars qw($VERSION);
   6 $VERSION = '1.59';
   7
   8 use SQL::Translator::Schema;
   9 use SQL::Translator::Utils qw(header_comment);
  10 use Data::Dumper;
  11 use YAML qw(Load);
  12
  13 sub parse {
  14     my ($translator, $data) = @_;
  15     $data = Load($data);
  16     $data = $data->{'schema'};
  17
  18     warn "YAML data:",Dumper( $data ) if $translator->debug;
  19
  20     my $schema = $translator->schema;
  21
  22     #
  23     # Tables
  24     #
  25     my @tables =
  26         map   { $data->{'tables'}{ $_->[1] } }
  27         sort  { $a->[0] <=> $b->[0] }
  28         map   { [ $data->{'tables'}{ $_ }{'order'} || 0, $_ ] }
  29         keys %{ $data->{'tables'} }
  30     ;
  31
  32     for my $tdata ( @tables ) {
  33
  34         my $table = $schema->add_table(
  35             map {
  36               $tdata->{$_} ? ($_ => $tdata->{$_}) : ()
  37             } (qw/name extra options/)
  38         ) or die $schema->error;
  39
  40         my @fields =
  41             map   { $tdata->{'fields'}{ $_->[1] } }
  42             sort  { $a->[0] <=> $b->[0] }
  43             map   { [ $tdata->{'fields'}{ $_ }{'order'}, $_ ] }
  44             keys %{ $tdata->{'fields'} }
  45         ;
  46
  47         for my $fdata ( @fields ) {
  48             $table->add_field( %$fdata ) or die $table->error;
  49             $table->primary_key( $fdata->{'name'} )
  50                 if $fdata->{'is_primary_key'};
  51         }
  52
  53         for my $idata ( @{ $tdata->{'indices'} || [] } ) {
  54             $table->add_index( %$idata ) or die $table->error;
  55         }
  56
  57         for my $cdata ( @{ $tdata->{'constraints'} || [] } ) {
  58             $table->add_constraint( %$cdata ) or die $table->error;
  59         }
  60     }
  61
  62     #
  63     # Views
  64     #
  65     my @views =
  66         map   { $data->{'views'}{ $_->[1] } }
  67         sort  { $a->[0] <=> $b->[0] }
  68         map   { [ $data->{'views'}{ $_ }{'order'}, $_ ] }
  69         keys %{ $data->{'views'} }
  70     ;
  71
  72     for my $vdata ( @views ) {
  73         $schema->add_view( %$vdata ) or die $schema->error;
  74     }
  75
  76     #
  77     # Triggers
  78     #
  79     my @triggers =
  80         map   { $data->{'triggers'}{ $_->[1] } }
  81         sort  { $a->[0] <=> $b->[0] }
  82         map   { [ $data->{'triggers'}{ $_ }{'order'}, $_ ] }
  83         keys %{ $data->{'triggers'} }
  84     ;
  85
  86     for my $tdata ( @triggers ) {
  87         $schema->add_trigger( %$tdata ) or die $schema->error;
  88     }
  89
  90     #
  91     # Procedures
  92     #
  93     my @procedures =
  94         map   { $data->{'procedures'}{ $_->[1] } }
  95         sort  { $a->[0] <=> $b->[0] }
  96         map   { [ $data->{'procedures'}{ $_ }{'order'}, $_ ] }
  97         keys %{ $data->{'procedures'} }
  98     ;
  99
 100     for my $tdata ( @procedures ) {
 101         $schema->add_procedure( %$tdata ) or die $schema->error;
 102     }
 103
 104     if ( my $tr_data = $data->{'translator'} ) {
 105         $translator->add_drop_table( $tr_data->{'add_drop_table'} );
 106         $translator->filename( $tr_data->{'filename'} );
 107         $translator->no_comments( $tr_data->{'no_comments'} );
 108         $translator->parser_args( $tr_data->{'parser_args'} );
 109         $translator->producer_args( $tr_data->{'producer_args'} );
 110         $translator->parser_type( $tr_data->{'parser_type'} );
 111         $translator->producer_type( $tr_data->{'producer_type'} );
 112         $translator->show_warnings( $tr_data->{'show_warnings'} );
 113         $translator->trace( $tr_data->{'trace'} );
 114     }
 115
 116     return 1;
 117 }
 118
 119 1;
 120
 121 __END__
 122
 123 =head1 NAME
 124
 125 SQL::Translator::Parser::YAML - Parse a YAML representation of a schema
 126
 127 =head1 SYNOPSIS
 128
 129     use SQL::Translator;
 130
 131     my $translator = SQL::Translator->new(parser => "YAML");
 132
 133 =head1 DESCRIPTION
 134
 135 C<SQL::Translator::Parser::YAML> parses a schema serialized with YAML.
 136
 137 =head1 AUTHORS
 138
 139 Darren Chamberlain E<lt>darren@cpan.orgE<gt>,
 140 Ken Y. Clark E<lt>kclark@cpan.orgE<gt>.