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

   1 use MooseX::Declare;
   2 role SQL::Translator::Parser::DDL::YAML {
   3     use MooseX::Types::Moose qw(Any Str);
   4     use SQL::Translator::Types qw(Schema);
   5     use aliased 'SQL::Translator::Object::Column';
   6     use aliased 'SQL::Translator::Object::Constraint';
   7     use aliased 'SQL::Translator::Object::Index';
   8     use aliased 'SQL::Translator::Object::Table';
   9     use aliased 'SQL::Translator::Object::Schema' => 'SchemaObj';
  10     use YAML qw(Load);
  11     use MooseX::MultiMethods;
  12
  13 #    multi method parse(Any $data) { use Data::Dumper; die Dumper($data); }
  14     multi method parse(Schema $data) { return $data }
  15
  16     multi method parse(Str $data) {
  17         return $data if blessed $data && $data->isa('SQL::Translator::Object::Schema');
  18         $data = Load($data);
  19         $data = $data->{schema};
  20
  21 #        warn "YAML data:",Dumper( $data ) if $self->debug;
  22
  23         my $schema = SchemaObj->new; #$self->schema;
  24
  25         #
  26         # Tables
  27         #
  28         my @tables =
  29             map   { $data->{'tables'}{ $_->[1] } }
  30 #            sort  { $a->[0] <=> $b->[0] }
  31             map   { [ $data->{'tables'}{ $_ }{'order'} || 0, $_ ] }
  32             keys %{ $data->{'tables'} } ;
  33
  34         for my $tdata ( @tables ) {
  35             my $table = Table->new({ map { $tdata->{$_} ? ($_ => $tdata->{$_}) : () } qw/name extra options/ });
  36             $schema->add_table($table);
  37 #            my $table = $schema->add_table(
  38 #                map {
  39 #                  $tdata->{$_} ? ($_ => $tdata->{$_}) : ()
  40 #                } (qw/name extra options/)
  41 #            ) or die $schema->error;
  42
  43             my @fields =
  44                 map   { $tdata->{'fields'}{ $_->[1] } }
  45 #                sort  { $a->[0] <=> $b->[0] }
  46                 map   { [ $tdata->{'fields'}{ $_ }{'order'}, $_ ] }
  47                 keys %{ $tdata->{'fields'} } ;
  48
  49             for my $fdata ( @fields ) {
  50 #                $table->add_field( %$fdata ) or die $table->error;
  51                 $fdata->{sql_data_type} = $self->data_type_mapping->{$fdata->{data_type}} || -99999;
  52                 my $column = Column->new($fdata);
  53                 $table->add_column($column);
  54                 $table->primary_key($column->name) if $fdata->{is_primary_key};
  55             }
  56
  57             for my $idata ( @{ $tdata->{'indices'} || [] } ) {
  58 #                $table->add_index( %$idata ) or die $table->error;
  59                  my $index = Index->new($idata);
  60                  $table->add_index($index);
  61             }
  62
  63             for my $cdata ( @{ $tdata->{'constraints'} || [] } ) {
  64 #                $table->add_constraint( %$cdata ) or die $table->error;
  65                  my $constraint = Constraint->new($cdata);
  66                  $table->add_constraint($constraint);
  67             }
  68         }
  69
  70         #
  71         # Views
  72         #
  73         my @views =
  74             map   { $data->{'views'}{ $_->[1] } }
  75             sort  { $a->[0] <=> $b->[0] }
  76             map   { [ $data->{'views'}{ $_ }{'order'}, $_ ] }
  77             keys %{ $data->{'views'} } ;
  78
  79         for my $vdata ( @views ) {
  80 #            $schema->add_view( %$vdata ) or die $schema->error;
  81         }
  82
  83         #
  84         # Triggers
  85         #
  86         my @triggers =
  87             map   { $data->{'triggers'}{ $_->[1] } }
  88             sort  { $a->[0] <=> $b->[0] }
  89             map   { [ $data->{'triggers'}{ $_ }{'order'}, $_ ] }
  90             keys %{ $data->{'triggers'} }
  91         ;
  92
  93         for my $tdata ( @triggers ) {
  94 #            $schema->add_trigger( %$tdata ) or die $schema->error;
  95         }
  96
  97         #
  98         # Procedures
  99         #
 100         my @procedures =
 101             map   { $data->{'procedures'}{ $_->[1] } }
 102             sort  { $a->[0] <=> $b->[0] }
 103             map   { [ $data->{'procedures'}{ $_ }{'order'}, $_ ] }
 104             keys %{ $data->{'procedures'} }
 105         ;
 106
 107         for my $tdata ( @procedures ) {
 108 #            $schema->add_procedure( %$tdata ) or die $schema->error;
 109         }
 110
 111         if ( my $tr_data = $data->{'translator'} ) {
 112             $self->add_drop_table( $tr_data->{'add_drop_table'} );
 113             $self->filename( $tr_data->{'filename'} );
 114             $self->no_comments( $tr_data->{'no_comments'} );
 115             $self->parser_args( $tr_data->{'parser_args'} );
 116             $self->producer_args( $tr_data->{'producer_args'} );
 117             $self->parser_type( $tr_data->{'parser_type'} );
 118             $self->producer_type( $tr_data->{'producer_type'} );
 119             $self->show_warnings( $tr_data->{'show_warnings'} );
 120             $self->trace( $tr_data->{'trace'} );
 121         }
 122
 123         return $schema;
 124     }
 125 }