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         unless (defined $parser) {
  22             return $translator->error("Error instantiating Parse::RecDescent ".
  23                 "instance: Bad grammar");
  24         }
  25
  26         my $result = $parser->startrule($data);
  27         die "Parse failed.\n" unless defined $result;
  28
  29         my $schema = $translator->schema;
  30         my @tables =
  31          sort { ( $result->{tables}{ $a }{'order'} || 0 ) <=> ( $result->{tables}{ $b }{'order'} || 0 ) }
  32          keys %{ $result->{tables} };
  33
  34         for my $table_name ( @tables ) {
  35             my $tdata = $result->{tables}{ $table_name };
  36             my $table = Table->new({ name => $tdata->{table_name}, schema => $schema });
  37             $schema->add_table($table);
  38
  39             $table->extra({ temporary => 1 }) if $tdata->{'temporary'};
  40             $table->comments( $tdata->{'comments'} );
  41
  42             my @fields = sort { $tdata->{'fields'}{ $a }{'order'} <=> $tdata->{'fields'}{ $b }{'order'} } keys %{ $tdata->{'fields'} };
  43
  44             for my $fname ( @fields ) {
  45                 my $fdata = $tdata->{'fields'}{ $fname };
  46                 next if $fdata->{'drop'};
  47                 my $field = Column->new({
  48                     name              => $fdata->{'name'},
  49                     data_type         => $fdata->{'data_type'},
  50                     sql_data_type     => $self->data_type_mapping->{$fdata->{data_type}} || -999999,
  51                     size              => $fdata->{'size'},
  52                     default_value     => $fdata->{'default'},
  53                     is_auto_increment => $fdata->{'is_auto_increment'},
  54                     is_nullable       => $fdata->{'is_nullable'},
  55                     table             => $table,
  56                 });
  57                 $field->comments($fdata->{comments});
  58
  59                 $table->add_column($field);
  60                 $table->primary_key($field->name) if $fdata->{is_primary_key};
  61
  62                 for my $cdata ( @{ $fdata->{constraints} } ) {
  63                     next unless lc $cdata->{type} eq 'foreign_key';
  64                     $cdata->{fields} ||= [ $field->name ];
  65                     push @{ $tdata->{constraints} }, $cdata;
  66                 }
  67             }
  68
  69             for my $idata ( @{ $tdata->{indices} || [] } ) {
  70                 my $index = Index->new({
  71                     name    => $idata->{name},
  72                     type    => uc $idata->{type},
  73                     table   => $table,
  74                 });
  75                 $index->add_column($table->get_column($_)) for @{$idata->{fields}};
  76                 $table->add_index($index);
  77             }
  78
  79             for my $cdata ( @{ $tdata->{'constraints'} || [] } ) {
  80                 my $constraint;
  81                 $cdata->{type} =~ s/_/ /g;
  82                 if (uc $cdata->{type} eq PRIMARY_KEY) {
  83                     $constraint = PrimaryKey->new({ name => $cdata->{name} || '', table => $table });
  84                     $table->get_column($_)->is_primary_key(1) for @{$cdata->{fields}};
  85                 } elsif (uc $cdata->{type} eq FOREIGN_KEY) {
  86                     $constraint = ForeignKey->new({ name => $cdata->{name} || '',
  87                                                     table => $table,
  88                                                     reference_table => $cdata->{reference_table},
  89                                                     reference_columns => $cdata->{reference_fields},
  90                                                     on_delete => $cdata->{on_delete} || $cdata->{on_delete_do},
  91                                                     on_update => $cdata->{on_update} || $cdata->{on_update_do} });
  92                     $table->get_column($_)->is_foreign_key(1) for @{$cdata->{fields}};
  93                     $table->get_column($_)->foreign_key_reference($constraint) for @{$cdata->{fields}};
  94                 } else {
  95                     $constraint = Constraint->new({ name => $cdata->{name} || '', type => uc $cdata->{type}, table => $table });
  96                 }
  97                 $constraint->add_column($table->get_column($_)) for @{$cdata->{fields}};
  98                 $table->add_constraint($constraint);
  99             }
 100         }
 101
 102         for my $vinfo (@{$result->{views}}) {
 103           my $sql = $vinfo->{sql};
 104           $sql =~ s/\A\s+|\s+\z//g;
 105           my $view = View->new({
 106             name    => $vinfo->{view_name},
 107             sql     => $sql,
 108           });
 109
 110           $schema->add_view($view);
 111
 112           $view->extra ( temporary => 1 ) if $vinfo->{is_temporary};
 113         }
 114
 115         return 1;
 116     }
 117 }