SQL-Translator

 view release on metacpan or  search on metacpan

AUTHORS  view on Meta::CPAN

-   Aaron Schrab <aaron@schrab.com>
-   Adam Strzelecki <ono@java.pl>
-   Alexander Hartmaier <abraxxa@cpan.org>
-   Allen Day <allenday@users.sourceforge.net>
-   Amiri Barksdale <amiri@roosterpirates.com>
-   Anders Nor Berle <berle@cpan.org>
-   André Walker <andre@andrewalker.net>
-   Andreas 'ac0v' Specht <ac0v@sys-network.de>
-   Andrew Moore <amoore@cpan.org>
-   Andrew Gregory <andrew.gregory.8@gmail.com>
-   Andrew Pam <andrew.pam@strategicdata.com.au>
-   Arthur Axel "fREW" Schmidt <frioux@gmail.com>
-   Ben Faga <faga@cshl.edu>
-   Cedric Carree <beg0@free.fr>
-   Chris Hilton <chilton@alterpoint.com>
-   Chris Mungall <cjm@fruitfly.org>
-   Chris To <christot@users.sourceforge.net>
-   Colin Newell <colin.newell@gmail.com>
-   Dagfinn Ilmari Mannsåker <ilmari@ilmari.org>
-   Daniel Ruoso <daniel@ruoso.com>
-   Darren Chamberlain <dlc@users.sourceforge.net>

lib/SQL/Translator/Parser/DB2.pm  view on Meta::CPAN

        data_type         => $fdata->{'data_type'},
        size              => $fdata->{'size'},
        default_value     => $fdata->{'default'},
        is_auto_increment => $fdata->{'is_auto_inc'},
        is_nullable       => $fdata->{'is_nullable'},
        comments          => $fdata->{'comments'},
      ) or die $table->error;

      $table->primary_key($field->name) if $fdata->{'is_primary_key'};

      for my $cdata (@{ $fdata->{'constraints'} }) {
        next unless $cdata->{'type'} eq 'foreign_key';
        $cdata->{'fields'} ||= [ $field->name ];
        push @{ $tdata->{'constraints'} }, $cdata;
      }
    }

    for my $idata (@{ $tdata->{'indices'} || [] }) {
      my $index = $table->add_index(
        name   => $idata->{'name'},
        type   => uc $idata->{'type'},
        fields => $idata->{'fields'},
      ) or die $table->error;
    }

    for my $cdata (@{ $tdata->{'constraints'} || [] }) {
      my $constraint = $table->add_constraint(
        name             => $cdata->{'name'},
        type             => $cdata->{'type'},
        fields           => $cdata->{'fields'},
        reference_table  => $cdata->{'reference_table'},
        reference_fields => $cdata->{'reference_fields'},
        match_type       => $cdata->{'match_type'} || '',
        on_delete        => $cdata->{'on_delete'}  || $cdata->{'on_delete_do'},
        on_update        => $cdata->{'on_update'}  || $cdata->{'on_update_do'},
      ) or die $table->error;
    }
  }

  for my $def (@{ $result->{'views'} || [] }) {
    my $view = $schema->add_view(
      name => $def->{'name'},
      sql  => $def->{'sql'},
    );
  }

lib/SQL/Translator/Parser/JSON.pm  view on Meta::CPAN

    for my $fdata (@fields) {
      $table->add_field(%$fdata) or die $table->error;
      $table->primary_key($fdata->{'name'})
          if $fdata->{'is_primary_key'};
    }

    for my $idata (@{ $tdata->{'indices'} || [] }) {
      $table->add_index(%$idata) or die $table->error;
    }

    for my $cdata (@{ $tdata->{'constraints'} || [] }) {
      $table->add_constraint(%$cdata) or die $table->error;
    }

    $table->comments($tdata->{'comments'})
        if exists $tdata->{'comments'};

  }

  #
  # Views
  #

lib/SQL/Translator/Parser/MySQL.pm  view on Meta::CPAN

      }

      if ($fdata->{'is_unique'}) {
        $table->add_constraint(
          name   => '',
          type   => 'UNIQUE',
          fields => $fdata->{'name'},
        ) or die $table->error;
      }

      for my $cdata (@{ $fdata->{'constraints'} }) {
        next unless $cdata->{'type'} eq 'foreign_key';
        $cdata->{'fields'} ||= [ $field->name ];
        push @{ $tdata->{'constraints'} }, $cdata;
      }

    }

    for my $idata (@{ $tdata->{'indices'} || [] }) {
      my $index = $table->add_index(
        name   => $idata->{'name'},
        type   => uc $idata->{'type'},
        fields => $idata->{'fields'},
      ) or die $table->error;

lib/SQL/Translator/Parser/MySQL.pm  view on Meta::CPAN

          if (!exists $ignores->{$option_key}) {
            push @cleaned_options, $option;
          }
        }
      } else {
        @cleaned_options = @options;
      }
      $table->options(\@cleaned_options) or die $table->error;
    }

    for my $cdata (@{ $tdata->{'constraints'} || [] }) {
      my $constraint = $table->add_constraint(
        name             => $cdata->{'name'},
        type             => $cdata->{'type'},
        fields           => $cdata->{'fields'},
        expression       => $cdata->{'expression'},
        reference_table  => $cdata->{'reference_table'},
        reference_fields => $cdata->{'reference_fields'},
        match_type       => $cdata->{'match_type'} || '',
        on_delete        => $cdata->{'on_delete'}  || $cdata->{'on_delete_do'},
        on_update        => $cdata->{'on_update'}  || $cdata->{'on_update_do'},
      ) or die $table->error;
    }

    # After the constrains and PK/idxs have been created,
    # we normalize fields
    normalize_field($_) for $table->get_fields;
  }

  my @procedures = sort { $result->{procedures}->{$a}->{'order'} <=> $result->{procedures}->{$b}->{'order'} }
      keys %{ $result->{procedures} };

lib/SQL/Translator/Parser/Oracle.pm  view on Meta::CPAN

    push @{ $tdata->{'constraints'} }, @{ $constraints->{$table_name} || [] };

    for my $idata (@{ $tdata->{'indices'} || [] }) {
      my $index = $table->add_index(
        name   => $idata->{'name'},
        type   => uc $idata->{'type'},
        fields => $idata->{'fields'},
      ) or die $table->error;
    }

    for my $cdata (@{ $tdata->{'constraints'} || [] }) {
      my $constraint = $table->add_constraint(
        name             => $cdata->{'name'},
        type             => $cdata->{'type'},
        fields           => $cdata->{'fields'},
        expression       => $cdata->{'expression'},
        reference_table  => $cdata->{'reference_table'},
        reference_fields => $cdata->{'reference_fields'},
        match_type       => $cdata->{'match_type'} || '',
        on_delete        => $cdata->{'on_delete'}  || $cdata->{'on_delete_do'},
        on_update        => $cdata->{'on_update'}  || $cdata->{'on_update_do'},
      ) or die $table->error;
    }
  }

  my @procedures = sort { $result->{procedures}->{$a}->{'order'} <=> $result->{procedures}->{$b}->{'order'} }
      keys %{ $result->{procedures} };
  foreach my $proc_name (@procedures) {
    $schema->add_procedure(
      name  => $proc_name,
      owner => $result->{procedures}->{$proc_name}->{owner},

lib/SQL/Translator/Parser/PostgreSQL.pm  view on Meta::CPAN

        data_type         => $fdata->{'data_type'},
        size              => $fdata->{'size'},
        default_value     => $fdata->{'default'},
        is_auto_increment => $fdata->{'is_auto_increment'},
        is_nullable       => $fdata->{'is_nullable'},
        comments          => $fdata->{'comments'},
      ) or die $table->error;

      $table->primary_key($field->name) if $fdata->{'is_primary_key'};

      for my $cdata (@{ $fdata->{'constraints'} }) {
        next unless $cdata->{'type'} eq 'foreign_key';
        $cdata->{'fields'} ||= [ $field->name ];
        push @{ $tdata->{'constraints'} }, $cdata;
      }
    }

    for my $idata (@{ $tdata->{'indices'} || [] }) {
      my @options = ();
      push @options, { using   => $idata->{'method'} } if $idata->{method};
      push @options, { where   => $idata->{'where'} }  if $idata->{where};
      push @options, { include => $idata->{'include'} }
          if $idata->{include};
      my $index = $table->add_index(
        name    => $idata->{'name'},
        type    => uc $idata->{'type'},
        fields  => $idata->{'fields'},
        options => \@options
      ) or die $table->error . ' ' . $table->name;
    }

    for my $cdata (@{ $tdata->{'constraints'} || [] }) {
      my $options = [

        # load this up with the extras
        map +{ %$cdata{$_} }, grep $cdata->{$_},
        qw/include using where/
      ];
      my $constraint = $table->add_constraint(
        name             => $cdata->{'name'},
        type             => $cdata->{'type'},
        fields           => $cdata->{'fields'},
        reference_table  => $cdata->{'reference_table'},
        reference_fields => $cdata->{'reference_fields'},
        match_type       => $cdata->{'match_type'} || '',
        on_delete        => $cdata->{'on_delete'}  || $cdata->{'on_delete_do'},
        on_update        => $cdata->{'on_update'}  || $cdata->{'on_update_do'},
        expression       => $cdata->{'expression'},
        options          => $options
          )
          or die "Can't add constraint of type '"
          . $cdata->{'type'}
          . "' to table '"
          . $table->name . "': "
          . $table->error;
    }
  }

  for my $vinfo (@{ $result->{views} }) {
    my $sql = $vinfo->{sql};
    $sql =~ s/\A\s+|\s+\z//g;
    my $view = $schema->add_view(

lib/SQL/Translator/Parser/SQLServer.pm  view on Meta::CPAN

      if ($field->data_type =~ /(set|enum)/i && !$field->size) {
        my %extra   = $field->extra;
        my $longest = 0;
        for my $len (map {length} @{ $extra{'list'} || [] }) {
          $longest = $len if $len > $longest;
        }
        $field->size($longest) if $longest;
      }

      for my $cdata (@{ $fdata->{'constraints'} }) {
        next unless $cdata->{'type'} eq 'foreign_key';
        $cdata->{'fields'} ||= [ $field->name ];
        push @{ $tdata->{'constraints'} }, $cdata;
      }
    }

    for my $idata (@{ $tdata->{'indices'} || [] }) {
      my $index = $table->add_index(
        name   => $idata->{'name'},
        type   => uc $idata->{'type'},
        fields => $idata->{'fields'},
      ) or die $table->error;
    }

    for my $cdata (@{ $tdata->{'constraints'} || [] }) {
      my $constraint = $table->add_constraint(
        name             => $cdata->{'name'},
        type             => $cdata->{'type'},
        fields           => $cdata->{'fields'},
        reference_table  => $cdata->{'reference_table'},
        reference_fields => $cdata->{'reference_fields'},
        match_type       => $cdata->{'match_type'} || '',
        on_delete        => $cdata->{'on_delete'}  || $cdata->{'on_delete_do'},
        on_update        => $cdata->{'on_update'}  || $cdata->{'on_update_do'},
      ) or die $table->error;
    }
  }

  my @procedures = sort { $result->{procedures}->{$a}->{'order'} <=> $result->{procedures}->{$b}->{'order'} }
      keys %{ $result->{procedures} };
  for my $proc_name (@procedures) {
    $schema->add_procedure(
      name  => $proc_name,
      owner => $result->{procedures}->{$proc_name}->{owner},

lib/SQL/Translator/Parser/SQLite.pm  view on Meta::CPAN

          $fdata->{'is_auto_inc'}
          ? (extra => { auto_increment_type => 'monotonic' })
          : ()
        ),
        is_nullable => $fdata->{'is_nullable'},
        comments    => $fdata->{'comments'},
      ) or die $table->error;

      $table->primary_key($field->name) if $fdata->{'is_primary_key'};

      for my $cdata (@{ $fdata->{'constraints'} }) {
        next unless $cdata->{'type'} eq 'foreign_key';
        $cdata->{'fields'} ||= [ $field->name ];
        push @{ $tdata->{'constraints'} }, $cdata;
      }
    }

    for my $idata (@{ $tdata->{'indices'} || [] }) {
      my $index = $table->add_index(
        name   => $idata->{'name'},
        type   => uc($idata->{'type'} || ''),
        fields => $idata->{'fields'},
      ) or die $table->error;
    }

    for my $cdata (@{ $tdata->{'constraints'} || [] }) {
      my $constraint = $table->add_constraint(
        name             => $cdata->{'name'},
        type             => $cdata->{'type'},
        fields           => $cdata->{'fields'},
        reference_table  => $cdata->{'reference_table'},
        reference_fields => $cdata->{'reference_fields'},
        match_type       => $cdata->{'match_type'} || '',
        on_delete        => $cdata->{'on_delete'}  || $cdata->{'on_delete_do'},
        on_update        => $cdata->{'on_update'}  || $cdata->{'on_update_do'},
      ) or die $table->error;
    }
  }

  for my $def (@{ $result->{'views'} || [] }) {
    my $view = $schema->add_view(
      name => $def->{'name'},
      sql  => $def->{'sql'},
    );
  }

lib/SQL/Translator/Parser/Sybase.pm  view on Meta::CPAN

      if ($field->data_type =~ /(set|enum)/i && !$field->size) {
        my %extra   = $field->extra;
        my $longest = 0;
        for my $len (map {length} @{ $extra{'list'} || [] }) {
          $longest = $len if $len > $longest;
        }
        $field->size($longest) if $longest;
      }

      for my $cdata (@{ $fdata->{'constraints'} }) {
        next unless $cdata->{'type'} eq 'foreign_key';
        $cdata->{'fields'} ||= [ $field->name ];
        push @{ $tdata->{'constraints'} }, $cdata;
      }
    }

    for my $idata (@{ $tdata->{'indices'} || [] }) {
      my $index = $table->add_index(
        name   => $idata->{'name'},
        type   => uc $idata->{'type'},
        fields => $idata->{'fields'},
      ) or die $table->error;
    }

    for my $cdata (@{ $tdata->{'constraints'} || [] }) {
      my $constraint = $table->add_constraint(
        name             => $cdata->{'name'},
        type             => $cdata->{'type'},
        fields           => $cdata->{'fields'},
        reference_table  => $cdata->{'reference_table'},
        reference_fields => $cdata->{'reference_fields'},
        match_type       => $cdata->{'match_type'} || '',
        on_delete        => $cdata->{'on_delete'}  || $cdata->{'on_delete_do'},
        on_update        => $cdata->{'on_update'}  || $cdata->{'on_update_do'},
      ) or die $table->error;
    }
  }

  return 1;
}

1;

# -------------------------------------------------------------------

lib/SQL/Translator/Parser/YAML.pm  view on Meta::CPAN

    for my $fdata (@fields) {
      $table->add_field(%$fdata) or die $table->error;
      $table->primary_key($fdata->{'name'})
          if $fdata->{'is_primary_key'};
    }

    for my $idata (@{ $tdata->{'indices'} || [] }) {
      $table->add_index(%$idata) or die $table->error;
    }

    for my $cdata (@{ $tdata->{'constraints'} || [] }) {
      $table->add_constraint(%$cdata) or die $table->error;
    }

    $table->comments($tdata->{'comments'})
        if exists $tdata->{'comments'};
  }

  #
  # Views
  #
  my @views = map { $data->{'views'}{ $_->[1] } }