lib/SQL/Translator/Parser/DDL/PostgreSQL.pm

   1 use MooseX::Declare;
   2 role SQL::Translator::Parser::DDL::PostgreSQL {
   3     use MooseX::Types::Moose qw(Str);
   4     use MooseX::MultiMethods;
   5     use SQL::Translator::Constants qw(:sqlt_types :sqlt_constants);
   6     use SQL::Translator::Types qw(Schema);
   7     use aliased 'SQL::Translator::Object::Column';
   8     use aliased 'SQL::Translator::Object::Constraint';
   9     use aliased 'SQL::Translator::Object::ForeignKey';
  10     use aliased 'SQL::Translator::Object::Index';
  11     use aliased 'SQL::Translator::Object::PrimaryKey';
  12     use aliased 'SQL::Translator::Object::Table';
  13     use aliased 'SQL::Translator::Object::View';
  14
  15     multi method parse(Schema $data) { $data }
  16
  17     multi method parse(Str $data) {
  18         my $translator = $self->translator;
  19         my $parser = Parse::RecDescent->new($self->grammar);
  20
  21 #        $::RD_TRACE  = $translator->trace ? 1 : undef;
  22 #        $DEBUG       = $translator->debug;
  23
  24         unless (defined $parser) {
  25             return $translator->error("Error instantiating Parse::RecDescent ".
  26                 "instance: Bad grammer");
  27         }
  28
  29         my $result = $parser->startrule($data);
  30         die "Parse failed.\n" unless defined $result;
  31 #        warn Dumper($result) if $DEBUG;
  32
  33         my $schema = $translator->schema;
  34         my @tables =
  35 sort { ( $result->{tables}{ $a }{'order'} || 0 ) <=> ( $result->{tables}{ $b }{'order'} || 0 ) }
  36          keys %{ $result->{tables} };
  37
  38         for my $table_name ( @tables ) {
  39             my $tdata = $result->{tables}{ $table_name };
  40             my $table = Table->new({ name => $tdata->{table_name} });
  41             $schema->add_table($table);
  42
  43             $table->extra(temporary => 1) if $tdata->{'temporary'};
  44             $table->comments( $tdata->{'comments'} );
  45
  46             my @fields =
  47 sort { $tdata->{'fields'}{ $a }{'order'} <=> $tdata->{'fields'}{ $b }{'order'} }
  48             keys %{ $tdata->{'fields'} };
  49
  50             for my $fname ( @fields ) {
  51                 my $fdata = $tdata->{'fields'}{ $fname };
  52                 next if $fdata->{'drop'};
  53                 my $field = Column->new({
  54                     name              => $fdata->{'name'},
  55                     data_type         => $fdata->{'data_type'},
  56                     sql_data_type     => $self->data_type_mapping->{$fdata->{data_type}} || -999999,
  57                     size              => $fdata->{'size'},
  58                     default_value     => $fdata->{'default'},
  59                     is_auto_increment => $fdata->{'is_auto_increment'},
  60                     is_nullable       => $fdata->{'is_nullable'},
  61                     comments          => $fdata->{'comments'},
  62                     table             => $table,
  63                 });
  64                 $table->add_column($field);
  65
  66                 $table->primary_key( $field->name ) if $fdata->{is_primary_key};
  67
  68                 for my $cdata ( @{ $fdata->{constraints} } ) {
  69                     next unless $cdata->{type} eq 'foreign_key';
  70                     $cdata->{fields} ||= [ $field->name ];
  71                     push @{ $tdata->{constraints} }, $cdata;
  72                 }
  73             }
  74
  75             for my $idata ( @{ $tdata->{indices} || [] } ) {
  76                 my $index = Index->new({
  77                     name    => $idata->{name},
  78                     type    => uc $idata->{type},
  79                     columns => $idata->{fields},
  80                 });
  81             }
  82
  83             for my $cdata ( @{ $tdata->{'constraints'} || [] } ) {
  84                 my $constraint = Constraint->new({
  85                     name             => $cdata->{name},
  86                     type             => $cdata->{type},
  87                     fields           => $cdata->{fields},
  88                     reference_table  => $cdata->{reference_table},
  89                     reference_fields => $cdata->{reference_fields},
  90                     match_type       => $cdata->{match_type} || '',
  91                     on_delete        => $cdata->{on_delete} || $cdata->{on_delete_do},
  92                     on_update        => $cdata->{on_update} || $cdata->{on_update_do},
  93                     expression       => $cdata->{expression},
  94                     table            => $table,
  95                 });
  96                 $table->add_constraint($constraint);
  97             }
  98         }
  99
 100         for my $vinfo (@{$result->{views}}) {
 101           my $sql = $vinfo->{sql};
 102           $sql =~ s/\A\s+|\s+\z//g;
 103           my $view = View->new({
 104             name    => $vinfo->{view_name},
 105             sql     => $sql,
 106 #            columns => $vinfo->{fields},
 107           });
 108
 109           $schema->add_view($view);
 110
 111           $view->extra ( temporary => 1 ) if $vinfo->{is_temporary};
 112         }
 113
 114         return 1; #$schema;
 115     }
 116 }