[dbsrgits/SQL-Translator.git] / lib / SQL / Translator / Producer / ClassDBI.pm

package SQL::Translator::Producer::ClassDBI;

# -------------------------------------------------------------------
# $Id: ClassDBI.pm,v 1.10 2003-06-09 03:38:38 allenday Exp $
# -------------------------------------------------------------------
# Copyright (C) 2003 Ying Zhang <zyolive@yahoo.com>,
#                    Allen Day <allenday@ucla.edu>,
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; version 2.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
# 02111-1307  USA
# -------------------------------------------------------------------

use strict;
use vars qw[ $VERSION $DEBUG ];
$VERSION = sprintf "%d.%02d", q$Revision: 1.10 $ =~ /(\d+)\.(\d+)/;
$DEBUG   = 1 unless defined $DEBUG;

use SQL::Translator::Schema::Constants;
use SQL::Translator::Utils qw(header_comment);
use Data::Dumper;

sub produce {
    my ($translator, $data) = @_;
    local $DEBUG            = $translator->debug;
    my $no_comments         = $translator->no_comments;
    my $schema              = $translator->schema;
	
    my $create; 
    $create .= header_comment(__PACKAGE__, "# ") unless ($no_comments);
	
    $create .= "package " . $translator->format_package_name('DBI'). ";\n\n";
	
    $create .= "my \$USER = '';\n";
    $create .= "my \$PASS = '';\n\n";
	
    my $from = _from($translator->parser_type());
	
    $create .= "use base 'Class::DBI::$from';\n\n" .
        $translator->format_package_name('DBI') . 
        "->set_db('Main', 'dbi:$from:_', \$USER, \$PASS);\n\n";
	

	#
	# Identify link tables, defined as tables that have only PK and FK
	# fields
	#
	my %linkable;
	foreach my $table ($schema->get_tables) {
	  my $is_link = 1;
	  foreach my $field ($table->get_fields){
		$is_link = 0 and last unless $field->is_primary_key or $field->is_foreign_key;
	  }

	  if($is_link){
		foreach my $left ($table->get_fields){
		  next unless $left->is_foreign_key;
		  foreach my $right ($table->get_fields){
			next unless $right->is_foreign_key;

			$linkable{$left->foreign_key_reference->reference_table}
			  {$right->foreign_key_reference->reference_table} = $table;
			$linkable{$right->foreign_key_reference->reference_table}
			  {$left->foreign_key_reference->reference_table} = $table;
		  }
		}
	  }

	}

    #
    # Iterate over all tables
    #
    for my $table ( $schema->get_tables ) {
        my $table_name = $table->name or next;
        my %pk;

        unless ( $no_comments ) {
            $create .=
                "#\n# Package: " .
                $translator->format_package_name($table_name).
                "\n#\n"
        }

        $create .= "package ".$translator->format_package_name($table_name).";\n";
		$create .= "use base ".$translator->format_package_name('DBI').";\n";
        $create .= "use mixin 'Class::DBI::Join';\n";
        $create .= "use Class::DBI::Pager;\n\n";
		
        $create .= $translator->format_package_name($table_name)."->set_up_table('$table_name');\n\n";
		
        #
        # Primary key?
        #
        foreach my $constraint ( $table->get_constraints ) {
            next unless $constraint->type eq PRIMARY_KEY;
            my $field = ($constraint->fields)[0];
			
            $pk{ $table_name } = $field;
            $create .= "sub " .$translator->format_pk_name(
                $translator->format_package_name( $table_name ),
                $field
            ) . " { shift->".$field." }\n\n";
        }
		
        #
        # Find foreign keys
        #
        foreach my $field ( $table->get_fields ) {
            if ( $field->is_foreign_key ) {
                my $field_name = $field->name;
                my $fk         = $field->foreign_key_reference;
                my $ref_table  = $fk->reference_table;
                my @ref_fields = $fk->reference_fields;
                my @fields     = $fk->fields;

              $create .= $translator->format_package_name($table_name). 
                    "->has_a(\n    " .
                    $translator->format_package_name($ref_table). 
                    " => '$field_name'\n);\n\n";
              $create .= "sub " .
                    $translator->format_fk_name($ref_table, $field_name).
                    " {\n    return shift->$field_name\n}\n\n";
            }
        }

		my $is_data = 0;
		map {(!$_->is_foreign_key and !$_->is_primary_key) ? $is_data++ : 0} $table->get_fields;
		if($is_data){
		  my %linked;
		  foreach my $field ( $table->get_fields ) {
			if($field->is_foreign_key){
			  my $fk = $field->foreign_key_reference;

#			  next if $linked{($fk->reference_fields)[0]};
			  next unless $linkable{$fk->reference_table};

			  foreach my $link (keys %{$linkable{$fk->reference_table}}){
				my $linkmethodname = "_".$translator->format_fk_name($fk->reference_table,$field->name)."_refs";

				next if $linked{$linkmethodname};

				$create .= $translator->format_package_name($table_name).
				  "->has_many('$linkmethodname','".
				  $translator->format_package_name($linkable{$fk->reference_table}{$link}->name)."','".
				  ($fk->reference_fields)[0]."');\n";
				$create .= "sub ". $translator->format_fk_name($fk->reference_table,$field->name).
####HARDCODED S HERE.  ADD CALLBACK FOR PLURALIZATION MANGLING
				  "s {\n    my \$self = shift; return map \$_->".($fk->reference_fields)[0].", \$self->".$linkmethodname.";\n}\n\n";

				$linked{$linkmethodname}++;
			  }
			}
		  }
		}

    }

    $create .= '1;';

#    for my $table (keys %{$data}) {
#        my $table_data = $data->{$table};
#        my @fields =  keys %{$table_data->{'fields'}};
#        my %pk;
#
#        $create .= "##\n## Package: " .$translator->format_package_name($table). "\n##\n" unless $no_comments;
#        $create .= "package ". $translator->format_package_name($table). ";\n";
#
#        $create .= "use base \'Chado::DBI\';\n";
#        $create .= "use mixin \'Class::DBI::Join\';\n";
#        $create .= "use Class::DBI::Pager;\n\n";
#
#        $create .= $translator->format_package_name($table). "->set_up_table('$table');\n\n";
#
#        #
#        # Primary key?
#        #
#        foreach my $constraint ( @{ $table_data->{'constraints'} } ) {
#          my $name       = $constraint->{'name'} || '';
#          my $type       = $constraint->{'type'};
#          my $ref_table  = $constraint->{'reference_table'};
#          my $ref_fields = $constraint->{'reference_fields'};
#
#          if ( $type eq 'primary_key') {
#            $pk{$table} = $constraint->{'fields'}->[0];
#            $create .= "sub " .$translator->format_pk_name(
#                                                           $translator->format_package_name($table),
#                                                           $constraint->{'fields'}->[0]
#                                                          ) . " { shift->".$constraint->{'fields'}->[0]." }\n\n";
#          }
#        }
#
#        #
#        # Foreign key?
#        #
#        foreach my $field (@fields){
#          my $field_data = $table_data->{'fields'}->{$field}->{'constraints'};
#          my $type = $field_data->[1]->{'type'} || '';
#          my $ref_table = $field_data->[1]->{'reference_table'};
#          my $ref_field = $field_data->[1]->{'reference_fields'}->[0];
#          my $field = $field_data->[1]->{'fields'}->[0];
#
#          if ($type eq 'foreign_key') {
#
#    #THIS IS IMPOSSIBLE UNTIL WE HAVE A BETTER DATA MODEL.  THIS GIANT HASH SUCKS !!!
#    #         my $r_link     = 0; #not a link table (yet)
#    #         my $r_linkthis = 0;
#    #         my $r_linkthat = 0;
#    #         my $r_linkdata = 0;
#    #         my $r_table = $data->{$ref_table};
#    #         my @r_fields = keys %{$r_table->{'fields'}};
#    #         foreach my $r_field ( keys %{$r_table->{'fields'}} ){
#    #           $r_linkthis++ and next if $r_field eq $ref_field; #remote table links to local table
#    #           if($r_table->{'fields'}->{$r_field}->{'constraints'}){
#
#    #             foreach my $r_constraint ($r_table->{'fields'}->{$r_field}->{'constraints'}){
#    #               $create .= Dumper($r_constraint);
#    #             }
#
#    #           } else {
#    #             $r_linkdata++; #if not constraints, assume it's data (safe?)
#    #           }
#    #           foreach my $r_constraint ( @{ $r_table->{'fields'}->{$r_field}->{'constraints'} } ) {
#    #             next unless $r_constraint->{'constraint_type'} eq 'foreign_key';
#
#    #             $r_linkthat++ unless $r_constraint->{'reference_table'} eq $table; #remote table links to non-local table
#    #           }
#    #         }
#
#    #        my $link = $r_linkthis && $r_linkthat && !$r_linkdata ? '_link' : '';
#            $create .= $translator->format_package_name($table). "->has_a(" .$translator->format_package_name($ref_table). " => \'$field\');\n";
#            $create .= "sub " .$translator->format_fk_name($ref_table, $field)." { return shift->$field }\n\n";
#          }
#        }
#
#    #THIS IS IMPOSSIBLE UNTIL WE HAVE A BETTER DATA MODEL.  THIS GIANT HASH SUCKS !!!
#    #     #
#    #     # Remote foreign key?
#    #     #
#    #     print "****$table\n";
#    #     # find tables that refer to this table
#    #     my %refers = ();
#    #     for my $remote_table (keys %{$data}){
#    #       next if $remote_table eq $table;
#    # #      print "********".$remote_table."\n";
#    #       my $remote_table_data = $data->{$remote_table};
#
#    #       foreach my $remote_field ( keys %{$remote_table_data->{'fields'}} ){
#    #         foreach my $remote_constraint ( @{ $remote_table_data->{'fields'}->{$remote_field}->{'constraints'} } ) {
#    #           next unless $remote_constraint->{'constraint_type'} eq 'foreign_key'; #only interested in foreign keys...
#
#    #           $refers{$remote_table} = 1 if $pk{$remote_constraint->{'reference_table'}} ;#eq $remote_constraint->{'reference_fields'}->[0];
#    #            }
#    #       }
#    #     }
#
#    #     foreach my $refer (keys %refers){
#    #       foreach my $refer_field ( keys %{$data->{$refer}->{'fields'}} ){
#    #         foreach my $refer_constraint ( @{ $data->{$refer}->{'fields'}->{$refer_field}->{'constraints'} } ) {
#    #           next unless $refer_constraint->{'constraint_type'} eq 'foreign_key'; #only interested in foreign keys...
#    #           next if $refer_constraint->{'reference_table'} eq $table; #don't want to consider the current table vs itself
#    #           print "********".$refer."\t".$refer_field."\t****\t".$refer_constraint->{'reference_table'}."\t".$refer_constraint->{'reference_fields'}->[0]."\n";
#
#    #           $create .= "****sub " .$translator->format_fk_name($refer_constraint->{'reference_table'}, $refer_constraint->{'reference_fields'}->[0]). " { return shift->".$refer_constraint->{'reference_fields'}->[0]." }\n\n";
#    #         }
#    #       }
#    #     }
#
#        $create .= "1;\n\n\n";
#    }

    return $create;
}


sub _from {
    my $from = shift;
    my @temp = split(/::/, $from);
    $from    = $temp[$#temp];

    if ( $from eq 'MySQL') {
        $from = lc($from);
    } elsif ( $from eq 'PostgreSQL') {
        $from = 'Pg';
    } elsif ( $from eq 'Oracle') {
        $from = 'Oracle';
    } else {
        die "__PACKAGE__ can't handle vendor $from";
    }

    return $from;
}

1;

__END__

=head1 NAME

SQL::Translator::Producer::ClassDBI - 
    Translate SQL schemata into Class::DBI classes

=head1 SYNOPSIS

Use this producer as you would any other from SQL::Translator.  See
L<SQL::Translator> for details.

This package utilizes SQL::Translator's formatting methods
format_package_name(), format_pk_name(), format_fk_name(), and
format_table_name() as it creates classes, one per table in the schema
provided.  An additional base class is also created for database connectivity
configuration.  See L<Class::DBI> for details on how this works.

=head1 AUTHORS

Ying Zhang E<lt>zyolive@yahoo.comE<gt>, 
Allen Day E<lt>allenday@ucla.eduE<gt>
Ken Y. Clark E<lt>kclark@cpan.org<gt>.
Commit	Line	Data
f42e7027	1	package SQL::Translator::Producer::ClassDBI;
	2
	3	# -------------------------------------------------------------------
226d3a81	4	# $Id: ClassDBI.pm,v 1.10 2003-06-09 03:38:38 allenday Exp $
f42e7027	5	# -------------------------------------------------------------------
	6	# Copyright (C) 2003 Ying Zhang <zyolive@yahoo.com>,
	7	# Allen Day <allenday@ucla.edu>,
	8	#
	9	# This program is free software; you can redistribute it and/or
	10	# modify it under the terms of the GNU General Public License as
	11	# published by the Free Software Foundation; version 2.
	12	#
	13	# This program is distributed in the hope that it will be useful, but
	14	# WITHOUT ANY WARRANTY; without even the implied warranty of
	15	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	# General Public License for more details.
	17	#
	18	# You should have received a copy of the GNU General Public License
	19	# along with this program; if not, write to the Free Software
	20	# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
	21	# 02111-1307 USA
	22	# -------------------------------------------------------------------
	23
	24	use strict;
	25	use vars qw[ $VERSION $DEBUG ];
226d3a81	26	$VERSION = sprintf "%d.%02d", q$Revision: 1.10 $ =~ /(\d+)\.(\d+)/;
f42e7027	27	$DEBUG = 1 unless defined $DEBUG;
f42e7027	28
6c45056f	29	use SQL::Translator::Schema::Constants;
5ee19df8	30	use SQL::Translator::Utils qw(header_comment);
f42e7027	31	use Data::Dumper;
	32
	33	sub produce {
6c45056f	34	my ($translator, $data) = @_;
	35	local $DEBUG = $translator->debug;
	36	my $no_comments = $translator->no_comments;
	37	my $schema = $translator->schema;
df602cfb	38
6c45056f	39	my $create;
6c45056f	40	$create .= header_comment(__PACKAGE__, "# ") unless ($no_comments);
df602cfb	41
6c45056f	42	$create .= "package " . $translator->format_package_name('DBI'). ";\n\n";
df602cfb	43
6c45056f	44	$create .= "my \$USER = '';\n";
6c45056f	45	$create .= "my \$PASS = '';\n\n";
df602cfb	46
6c45056f	47	my $from = _from($translator->parser_type());
df602cfb	48
6c45056f	49	$create .= "use base 'Class::DBI::$from';\n\n" .
	50	$translator->format_package_name('DBI') .
	51	"->set_db('Main', 'dbi:$from:_', \$USER, \$PASS);\n\n";
df602cfb	52
	53
	54	#
	55	# Identify link tables, defined as tables that have only PK and FK
	56	# fields
	57	#
	58	my %linkable;
	59	foreach my $table ($schema->get_tables) {
	60	my $is_link = 1;
	61	foreach my $field ($table->get_fields){
	62	$is_link = 0 and last unless $field->is_primary_key or $field->is_foreign_key;
	63	}
	64
	65	if($is_link){
	66	foreach my $left ($table->get_fields){
	67	next unless $left->is_foreign_key;
	68	foreach my $right ($table->get_fields){
	69	next unless $right->is_foreign_key;
	70
	71	$linkable{$left->foreign_key_reference->reference_table}
	72	{$right->foreign_key_reference->reference_table} = $table;
	73	$linkable{$right->foreign_key_reference->reference_table}
	74	{$left->foreign_key_reference->reference_table} = $table;
	75	}
	76	}
	77	}
	78
	79	}
	80
6c45056f	81	#
	82	# Iterate over all tables
	83	#
	84	for my $table ( $schema->get_tables ) {
	85	my $table_name = $table->name or next;
	86	my %pk;
	87
	88	unless ( $no_comments ) {
df602cfb	89	$create .=
6c45056f	90	"#\n# Package: " .
df602cfb	91	$translator->format_package_name($table_name).
df602cfb	92	"\n#\n"
6c45056f	93	}
6c45056f	94
df602cfb	95	$create .= "package ".$translator->format_package_name($table_name).";\n";
df602cfb	96	$create .= "use base ".$translator->format_package_name('DBI').";\n";
6c45056f	97	$create .= "use mixin 'Class::DBI::Join';\n";
6c45056f	98	$create .= "use Class::DBI::Pager;\n\n";
df602cfb	99
	100	$create .= $translator->format_package_name($table_name)."->set_up_table('$table_name');\n\n";
	101
6c45056f	102	#
	103	# Primary key?
	104	#
	105	foreach my $constraint ( $table->get_constraints ) {
	106	next unless $constraint->type eq PRIMARY_KEY;
	107	my $field = ($constraint->fields)[0];
df602cfb	108
6c45056f	109	$pk{ $table_name } = $field;
	110	$create .= "sub " .$translator->format_pk_name(
	111	$translator->format_package_name( $table_name ),
	112	$field
	113	) . " { shift->".$field." }\n\n";
	114	}
df602cfb	115
6c45056f	116	#
	117	# Find foreign keys
	118	#
	119	foreach my $field ( $table->get_fields ) {
	120	if ( $field->is_foreign_key ) {
	121	my $field_name = $field->name;
	122	my $fk = $field->foreign_key_reference;
	123	my $ref_table = $fk->reference_table;
	124	my @ref_fields = $fk->reference_fields;
	125	my @fields = $fk->fields;
	126
	127	$create .= $translator->format_package_name($table_name).
226d3a81	128	"->has_a(\n " .
6c45056f	129	$translator->format_package_name($ref_table).
	130	" => '$field_name'\n);\n\n";
	131	$create .= "sub " .
	132	$translator->format_fk_name($ref_table, $field_name).
	133	" {\n return shift->$field_name\n}\n\n";
	134	}
	135	}
df602cfb	136
	137	my $is_data = 0;
	138	map {(!$_->is_foreign_key and !$_->is_primary_key) ? $is_data++ : 0} $table->get_fields;
	139	if($is_data){
	140	my %linked;
	141	foreach my $field ( $table->get_fields ) {
	142	if($field->is_foreign_key){
	143	my $fk = $field->foreign_key_reference;
	144
	145	# next if $linked{($fk->reference_fields)[0]};
	146	next unless $linkable{$fk->reference_table};
	147
	148	foreach my $link (keys %{$linkable{$fk->reference_table}}){
	149	my $linkmethodname = "_".$translator->format_fk_name($fk->reference_table,$field->name)."_refs";
	150
	151	next if $linked{$linkmethodname};
	152
	153	$create .= $translator->format_package_name($table_name).
	154	"->has_many('$linkmethodname','".
	155	$translator->format_package_name($linkable{$fk->reference_table}{$link}->name)."','".
	156	($fk->reference_fields)[0]."');\n";
	157	$create .= "sub ". $translator->format_fk_name($fk->reference_table,$field->name).
	158	####HARDCODED S HERE. ADD CALLBACK FOR PLURALIZATION MANGLING
	159	"s {\n my \$self = shift; return map \$_->".($fk->reference_fields)[0].", \$self->".$linkmethodname.";\n}\n\n";
	160
	161	$linked{$linkmethodname}++;
	162	}
	163	}
	164	}
	165	}
	166
6c45056f	167	}
	168
	169	$create .= '1;';
	170
	171	# for my $table (keys %{$data}) {
	172	# my $table_data = $data->{$table};
	173	# my @fields = keys %{$table_data->{'fields'}};
	174	# my %pk;
df602cfb	175	#
6c45056f	176	# $create .= "##\n## Package: " .$translator->format_package_name($table). "\n##\n" unless $no_comments;
6c45056f	177	# $create .= "package ". $translator->format_package_name($table). ";\n";
df602cfb	178	#
6c45056f	179	# $create .= "use base \'Chado::DBI\';\n";
	180	# $create .= "use mixin \'Class::DBI::Join\';\n";
	181	# $create .= "use Class::DBI::Pager;\n\n";
df602cfb	182	#
6c45056f	183	# $create .= $translator->format_package_name($table). "->set_up_table('$table');\n\n";
df602cfb	184	#
6c45056f	185	# #
	186	# # Primary key?
	187	# #
	188	# foreach my $constraint ( @{ $table_data->{'constraints'} } ) {
	189	# my $name = $constraint->{'name'} \|\| '';
	190	# my $type = $constraint->{'type'};
	191	# my $ref_table = $constraint->{'reference_table'};
	192	# my $ref_fields = $constraint->{'reference_fields'};
df602cfb	193	#
6c45056f	194	# if ( $type eq 'primary_key') {
	195	# $pk{$table} = $constraint->{'fields'}->[0];
	196	# $create .= "sub " .$translator->format_pk_name(
	197	# $translator->format_package_name($table),
	198	# $constraint->{'fields'}->[0]
	199	# ) . " { shift->".$constraint->{'fields'}->[0]." }\n\n";
	200	# }
	201	# }
df602cfb	202	#
6c45056f	203	# #
	204	# # Foreign key?
	205	# #
	206	# foreach my $field (@fields){
	207	# my $field_data = $table_data->{'fields'}->{$field}->{'constraints'};
	208	# my $type = $field_data->[1]->{'type'} \|\| '';
	209	# my $ref_table = $field_data->[1]->{'reference_table'};
	210	# my $ref_field = $field_data->[1]->{'reference_fields'}->[0];
	211	# my $field = $field_data->[1]->{'fields'}->[0];
df602cfb	212	#
6c45056f	213	# if ($type eq 'foreign_key') {
df602cfb	214	#
6c45056f	215	# #THIS IS IMPOSSIBLE UNTIL WE HAVE A BETTER DATA MODEL. THIS GIANT HASH SUCKS !!!
	216	# # my $r_link = 0; #not a link table (yet)
	217	# # my $r_linkthis = 0;
	218	# # my $r_linkthat = 0;
	219	# # my $r_linkdata = 0;
	220	# # my $r_table = $data->{$ref_table};
	221	# # my @r_fields = keys %{$r_table->{'fields'}};
	222	# # foreach my $r_field ( keys %{$r_table->{'fields'}} ){
	223	# # $r_linkthis++ and next if $r_field eq $ref_field; #remote table links to local table
	224	# # if($r_table->{'fields'}->{$r_field}->{'constraints'}){
df602cfb	225	#
6c45056f	226	# # foreach my $r_constraint ($r_table->{'fields'}->{$r_field}->{'constraints'}){
	227	# # $create .= Dumper($r_constraint);
	228	# # }
df602cfb	229	#
6c45056f	230	# # } else {
	231	# # $r_linkdata++; #if not constraints, assume it's data (safe?)
	232	# # }
	233	# # foreach my $r_constraint ( @{ $r_table->{'fields'}->{$r_field}->{'constraints'} } ) {
	234	# # next unless $r_constraint->{'constraint_type'} eq 'foreign_key';
df602cfb	235	#
6c45056f	236	# # $r_linkthat++ unless $r_constraint->{'reference_table'} eq $table; #remote table links to non-local table
	237	# # }
	238	# # }
df602cfb	239	#
6c45056f	240	# # my $link = $r_linkthis && $r_linkthat && !$r_linkdata ? '_link' : '';
226d3a81	241	# $create .= $translator->format_package_name($table). "->has_a(" .$translator->format_package_name($ref_table). " => \'$field\');\n";
6c45056f	242	# $create .= "sub " .$translator->format_fk_name($ref_table, $field)." { return shift->$field }\n\n";
	243	# }
	244	# }
df602cfb	245	#
6c45056f	246	# #THIS IS IMPOSSIBLE UNTIL WE HAVE A BETTER DATA MODEL. THIS GIANT HASH SUCKS !!!
	247	# # #
	248	# # # Remote foreign key?
	249	# # #
	250	# # print "****$table\n";
	251	# # # find tables that refer to this table
	252	# # my %refers = ();
	253	# # for my $remote_table (keys %{$data}){
	254	# # next if $remote_table eq $table;
	255	# # # print "********".$remote_table."\n";
	256	# # my $remote_table_data = $data->{$remote_table};
df602cfb	257	#
6c45056f	258	# # foreach my $remote_field ( keys %{$remote_table_data->{'fields'}} ){
	259	# # foreach my $remote_constraint ( @{ $remote_table_data->{'fields'}->{$remote_field}->{'constraints'} } ) {
	260	# # next unless $remote_constraint->{'constraint_type'} eq 'foreign_key'; #only interested in foreign keys...
df602cfb	261	#
6c45056f	262	# # $refers{$remote_table} = 1 if $pk{$remote_constraint->{'reference_table'}} ;#eq $remote_constraint->{'reference_fields'}->[0];
	263	# # }
	264	# # }
	265	# # }
df602cfb	266	#
6c45056f	267	# # foreach my $refer (keys %refers){
	268	# # foreach my $refer_field ( keys %{$data->{$refer}->{'fields'}} ){
	269	# # foreach my $refer_constraint ( @{ $data->{$refer}->{'fields'}->{$refer_field}->{'constraints'} } ) {
	270	# # next unless $refer_constraint->{'constraint_type'} eq 'foreign_key'; #only interested in foreign keys...
	271	# # next if $refer_constraint->{'reference_table'} eq $table; #don't want to consider the current table vs itself
	272	# # print "******".$refer."\t".$refer_field."\t**\t".$refer_constraint->{'reference_table'}."\t".$refer_constraint->{'reference_fields'}->[0]."\n";
df602cfb	273	#
6c45056f	274	# # $create .= "****sub " .$translator->format_fk_name($refer_constraint->{'reference_table'}, $refer_constraint->{'reference_fields'}->[0]). " { return shift->".$refer_constraint->{'reference_fields'}->[0]." }\n\n";
	275	# # }
	276	# # }
	277	# # }
df602cfb	278	#
6c45056f	279	# $create .= "1;\n\n\n";
6c45056f	280	# }
df602cfb	281
6c45056f	282	return $create;
f42e7027	283	}
	284
	285
	286	sub _from {
6c45056f	287	my $from = shift;
	288	my @temp = split(/::/, $from);
	289	$from = $temp[$#temp];
df602cfb	290
6c45056f	291	if ( $from eq 'MySQL') {
	292	$from = lc($from);
	293	} elsif ( $from eq 'PostgreSQL') {
	294	$from = 'Pg';
	295	} elsif ( $from eq 'Oracle') {
	296	$from = 'Oracle';
	297	} else {
	298	die "__PACKAGE__ can't handle vendor $from";
	299	}
df602cfb	300
6c45056f	301	return $from;
f42e7027	302	}
	303
	304	1;
	305
	306	__END__
	307
	308	=head1 NAME
	309
6c45056f	310	SQL::Translator::Producer::ClassDBI -
6c45056f	311	Translate SQL schemata into Class::DBI classes
f42e7027	312
	313	=head1 SYNOPSIS
	314
1eee27d3	315	Use this producer as you would any other from SQL::Translator. See
1eee27d3	316	L<SQL::Translator> for details.
f42e7027	317
1eee27d3	318	This package utilizes SQL::Translator's formatting methods
	319	format_package_name(), format_pk_name(), format_fk_name(), and
	320	format_table_name() as it creates classes, one per table in the schema
	321	provided. An additional base class is also created for database connectivity
	322	configuration. See L<Class::DBI> for details on how this works.
f42e7027	323
6c45056f	324	=head1 AUTHORS
f42e7027	325
6c45056f	326	Ying Zhang E<lt>zyolive@yahoo.comE<gt>,
	327	Allen Day E<lt>allenday@ucla.eduE<gt>
	328	Ken Y. Clark E<lt>kclark@cpan.org<gt>.