package SQL::Translator::Schema::Table;
# ----------------------------------------------------------------------
-# $Id: Table.pm,v 1.12 2003-08-20 16:08:13 kycl4rk Exp $
+# $Id: Table.pm,v 1.27 2004-11-04 16:29:56 grommit Exp $
# ----------------------------------------------------------------------
-# Copyright (C) 2003 Ken Y. Clark <kclark@cpan.org>
+# Copyright (C) 2002-4 SQLFairy Authors
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
=cut
use strict;
-use Class::Base;
use SQL::Translator::Utils 'parse_list_arg';
use SQL::Translator::Schema::Constants;
use SQL::Translator::Schema::Constraint;
use SQL::Translator::Schema::Field;
use SQL::Translator::Schema::Index;
+use Data::Dumper;
+
+use base 'SQL::Translator::Schema::Object';
-use base 'Class::Base';
use vars qw( $VERSION $FIELD_ORDER );
-$VERSION = sprintf "%d.%02d", q$Revision: 1.12 $ =~ /(\d+)\.(\d+)/;
+$VERSION = sprintf "%d.%02d", q$Revision: 1.27 $ =~ /(\d+)\.(\d+)/;
+
+
+# Stringify to our name, being careful not to pass any args through so we don't
+# accidentally set it to undef. We also have to tweak bool so the object is
+# still true when it doesn't have a name (which shouldn't happen!).
+use overload
+ '""' => sub { shift->name },
+ 'bool' => sub { $_[0]->name || $_[0] },
+ fallback => 1,
+;
# ----------------------------------------------------------------------
sub init {
Add a constraint to the table. Returns the newly created
C<SQL::Translator::Schema::Constraint> object.
- my $c1 = $table->add_constraint(
- name => 'pk',
- type => PRIMARY_KEY,
- fields => [ 'foo_id' ],
+ my $c1 = $table->add_constraint(
+ name => 'pk',
+ type => PRIMARY_KEY,
+ fields => [ 'foo_id' ],
);
my $c2 = SQL::Translator::Schema::Constraint->new( name => 'uniq' );
# If we're trying to add a PK when one is already defined,
# then just add the fields to the existing definition.
#
- my $ok = 0;
+ my $ok = 1;
my $pk = $self->primary_key;
if ( $pk && $constraint->type eq PRIMARY_KEY ) {
$self->primary_key( $constraint->fields );
$constraint = $pk;
+ $ok = 0;
}
- else {
- my @field_names = $constraint->fields;
- $ok = 1;
-
- for my $c (
- grep { $_->type eq $constraint->type }
- $self->get_constraints
- ) {
- my %fields = map { $_, 1 } $c->fields;
- for my $field_name ( @field_names ) {
- if ( $fields{ $field_name } ) {
- $constraint = $c;
- $ok = 0;
- last;
- }
+ elsif ( $constraint->type eq PRIMARY_KEY ) {
+ for my $fname ( $constraint->fields ) {
+ if ( my $f = $self->get_field( $fname ) ) {
+ $f->is_primary_key( 1 );
}
- last unless $ok;
}
}
+ #
+ # See if another constraint of the same type
+ # covers the same fields. -- This doesn't work! ky
+ #
+# elsif ( $constraint->type ne CHECK_C ) {
+# my @field_names = $constraint->fields;
+# for my $c (
+# grep { $_->type eq $constraint->type }
+# $self->get_constraints
+# ) {
+# my %fields = map { $_, 1 } $c->fields;
+# for my $field_name ( @field_names ) {
+# if ( $fields{ $field_name } ) {
+# $constraint = $c;
+# $ok = 0;
+# last;
+# }
+# }
+# last unless $ok;
+# }
+# }
if ( $ok ) {
push @{ $self->{'constraints'} }, $constraint;
Add an index to the table. Returns the newly created
C<SQL::Translator::Schema::Index> object.
- my $i1 = $table->add_index(
+ my $i1 = $table->add_index(
name => 'name',
fields => [ 'name' ],
type => 'normal',
required. If you try to create a field with the same name as an
existing field, you will get an error and the field will not be created.
- my $f1 = $table->add_field(
+ my $f1 = $table->add_field(
name => 'foo_id',
data_type => 'integer',
size => 11,
);
- my $f2 = SQL::Translator::Schema::Field->new(
+ my $f2 = SQL::Translator::Schema::Field->new(
name => 'name',
table => $table,
);
- $f2 = $table->add_field( $field2 ) or die $table->error;
+ $f2 = $table->add_field( $field2 ) or die $table->error;
=cut
}
$field->order( ++$FIELD_ORDER );
- my $field_name = $field->name or return $self->error('No name');
+ # We know we have a name as the Field->new above errors if none given.
+ my $field_name = $field->name;
if ( exists $self->{'fields'}{ $field_name } ) {
return $self->error(qq[Can't create field: "$field_name" exists]);
}
# ----------------------------------------------------------------------
+sub is_trivial_link {
+
+=pod
+
+=head2 is_trivial_link
+
+True if table has no data (non-key) fields and only uses single key joins.
+
+=cut
+
+ my $self = shift;
+ return 0 if $self->is_data;
+ return $self->{'is_trivial_link'} if defined $self->{'is_trivial_link'};
+
+ $self->{'is_trivial_link'} = 1;
+
+ my %fk = ();
+
+ foreach my $field ( $self->get_fields ) {
+ next unless $field->is_foreign_key;
+ $fk{$field->foreign_key_reference->reference_table}++;
+ }
+
+ foreach my $referenced (keys %fk){
+ if($fk{$referenced} > 1){
+ $self->{'is_trivial_link'} = 0;
+ last;
+ }
+ }
+
+ return $self->{'is_trivial_link'};
+
+}
+
+sub is_data {
+
+=pod
+
+=head2 is_data
+
+Returns true if the table has some non-key fields.
+
+=cut
+
+ my $self = shift;
+ return $self->{'is_data'} if defined $self->{'is_data'};
+
+ $self->{'is_data'} = 0;
+
+ foreach my $field ( $self->get_fields ) {
+ if ( !$field->is_primary_key and !$field->is_foreign_key ) {
+ $self->{'is_data'} = 1;
+ return $self->{'is_data'};
+ }
+ }
+
+ return $self->{'is_data'};
+}
+
+# ----------------------------------------------------------------------
+sub can_link {
+
+=pod
+
+=head2 can_link
+
+Determine whether the table can link two arg tables via many-to-many.
+
+ my $ok = $table->can_link($table1,$table2);
+
+=cut
+
+ my ( $self, $table1, $table2 ) = @_;
+
+ return $self->{'can_link'}{ $table1->name }{ $table2->name }
+ if defined $self->{'can_link'}{ $table1->name }{ $table2->name };
+
+ if ( $self->is_data == 1 ) {
+ $self->{'can_link'}{ $table1->name }{ $table2->name } = [0];
+ $self->{'can_link'}{ $table2->name }{ $table1->name } = [0];
+ return $self->{'can_link'}{ $table1->name }{ $table2->name };
+ }
+
+ my %fk = ();
+
+ foreach my $field ( $self->get_fields ) {
+ if ( $field->is_foreign_key ) {
+ push @{ $fk{ $field->foreign_key_reference->reference_table } },
+ $field->foreign_key_reference;
+ }
+ }
+
+ if ( !defined( $fk{ $table1->name } ) or !defined( $fk{ $table2->name } ) )
+ {
+ $self->{'can_link'}{ $table1->name }{ $table2->name } = [0];
+ $self->{'can_link'}{ $table2->name }{ $table1->name } = [0];
+ return $self->{'can_link'}{ $table1->name }{ $table2->name };
+ }
+
+ # trivial traversal, only one way to link the two tables
+ if ( scalar( @{ $fk{ $table1->name } } == 1 )
+ and scalar( @{ $fk{ $table2->name } } == 1 ) )
+ {
+ $self->{'can_link'}{ $table1->name }{ $table2->name } =
+ [ 'one2one', $fk{ $table1->name }, $fk{ $table2->name } ];
+ $self->{'can_link'}{ $table1->name }{ $table2->name } =
+ [ 'one2one', $fk{ $table2->name }, $fk{ $table1->name } ];
+
+ # non-trivial traversal. one way to link table2,
+ # many ways to link table1
+ }
+ elsif ( scalar( @{ $fk{ $table1->name } } > 1 )
+ and scalar( @{ $fk{ $table2->name } } == 1 ) )
+ {
+ $self->{'can_link'}{ $table1->name }{ $table2->name } =
+ [ 'many2one', $fk{ $table1->name }, $fk{ $table2->name } ];
+ $self->{'can_link'}{ $table2->name }{ $table1->name } =
+ [ 'one2many', $fk{ $table2->name }, $fk{ $table1->name } ];
+
+ # non-trivial traversal. one way to link table1,
+ # many ways to link table2
+ }
+ elsif ( scalar( @{ $fk{ $table1->name } } == 1 )
+ and scalar( @{ $fk{ $table2->name } } > 1 ) )
+ {
+ $self->{'can_link'}{ $table1->name }{ $table2->name } =
+ [ 'one2many', $fk{ $table1->name }, $fk{ $table2->name } ];
+ $self->{'can_link'}{ $table2->name }{ $table1->name } =
+ [ 'many2one', $fk{ $table2->name }, $fk{ $table1->name } ];
+
+ # non-trivial traversal. many ways to link table1 and table2
+ }
+ elsif ( scalar( @{ $fk{ $table1->name } } > 1 )
+ and scalar( @{ $fk{ $table2->name } } > 1 ) )
+ {
+ $self->{'can_link'}{ $table1->name }{ $table2->name } =
+ [ 'many2many', $fk{ $table1->name }, $fk{ $table2->name } ];
+ $self->{'can_link'}{ $table2->name }{ $table1->name } =
+ [ 'many2many', $fk{ $table2->name }, $fk{ $table1->name } ];
+
+ # one of the tables didn't export a key
+ # to this table, no linking possible
+ }
+ else {
+ $self->{'can_link'}{ $table1->name }{ $table2->name } = [0];
+ $self->{'can_link'}{ $table2->name }{ $table1->name } = [0];
+ }
+
+ return $self->{'can_link'}{ $table1->name }{ $table2->name };
+}
+
+# ----------------------------------------------------------------------
sub name {
=pod
Get or set the table's name.
-If provided an argument, checks the schema object for a table of
-that name and disallows the change if one exists.
+Errors ("No table name") if you try to set a blank name.
+
+If provided an argument, checks the schema object for a table of
+that name and disallows the change if one exists (setting the error to
+"Can't use table name "%s": table exists").
my $table_name = $table->name('foo');
my $self = shift;
- if ( my $arg = shift ) {
+ if ( @_ ) {
+ my $arg = shift || return $self->error( "No table name" );
if ( my $schema = $self->schema ) {
return $self->error( qq[Can't use table name "$arg": table exists] )
if $schema->get_table( $arg );
=pod
-=head2 options
+=head2 primary_key
Gets or sets the table's primary key(s). Takes one or more field
names (as a string, list or array[ref]) as an argument. If the field
}
# ----------------------------------------------------------------------
+sub field_names {
+
+=head2 field_names
+
+Read-only method to return a list or array ref of the field names. Returns undef
+or an empty list if the table has no fields set. Usefull if you want to
+avoid the overload magic of the Field objects returned by the get_fields method.
+
+ my @names = $constraint->field_names;
+
+=cut
+
+ my $self = shift;
+ my @fields =
+ map { $_->name }
+ sort { $a->order <=> $b->order }
+ values %{ $self->{'fields'} || {} };
+
+ if ( @fields ) {
+ return wantarray ? @fields : \@fields;
+ }
+ else {
+ $self->error('No fields');
+ return wantarray ? () : undef;
+ }
+}
+
+# ----------------------------------------------------------------------
+
+=head1 LOOKUP METHODS
+
+The following are a set of shortcut methods for getting commonly used lists of
+fields and constraints. They all return lists or array refs of Field or
+Constraint objects.
+
+=over 4
+
+=item pkey_fields
+
+The primary key fields.
+
+=item fkey_fields
+
+All foreign key fields.
+
+=item nonpkey_fields
+
+All the fields except the primary key.
+
+=item data_fields
+
+All non key fields.
+
+=item unique_fields
+
+All fields with unique constraints.
+
+=item unique_constraints
+
+All this tables unique constraints.
+
+=item fkey_constraints
+
+All this tables foreign key constraints. (See primary_key method to get the
+primary key constraint)
+
+=back
+
+=cut
+
+sub pkey_fields {
+ my $me = shift;
+ my @fields = grep { $_->is_primary_key } $me->get_fields;
+ return wantarray ? @fields : \@fields;
+}
+
+# ----------------------------------------------------------------------
+sub fkey_fields {
+ my $me = shift;
+ my @fields;
+ push @fields, $_->fields foreach $me->fkey_constraints;
+ return wantarray ? @fields : \@fields;
+}
+
+# ----------------------------------------------------------------------
+sub nonpkey_fields {
+ my $me = shift;
+ my @fields = grep { !$_->is_primary_key } $me->get_fields;
+ return wantarray ? @fields : \@fields;
+}
+
+# ----------------------------------------------------------------------
+sub data_fields {
+ my $me = shift;
+ my @fields =
+ grep { !$_->is_foreign_key and !$_->is_primary_key } $me->get_fields;
+ return wantarray ? @fields : \@fields;
+}
+
+# ----------------------------------------------------------------------
+sub unique_fields {
+ my $me = shift;
+ my @fields;
+ push @fields, $_->fields foreach $me->unique_constraints;
+ return wantarray ? @fields : \@fields;
+}
+
+# ----------------------------------------------------------------------
+sub unique_constraints {
+ my $me = shift;
+ my @cons = grep { $_->type eq UNIQUE } $me->get_constraints;
+ return wantarray ? @cons : \@cons;
+}
+
+# ----------------------------------------------------------------------
+sub fkey_constraints {
+ my $me = shift;
+ my @cons = grep { $_->type eq FOREIGN_KEY } $me->get_constraints;
+ return wantarray ? @cons : \@cons;
+}
+
+# ----------------------------------------------------------------------
sub DESTROY {
my $self = shift;
undef $self->{'schema'}; # destroy cyclical reference
=pod
-=head1 AUTHOR
+=head1 AUTHORS
-Ken Y. Clark E<lt>kclark@cpan.orgE<gt>
+Ken Y. Clark E<lt>kclark@cpan.orgE<gt>,
+Allen Day E<lt>allenday@ucla.eduE<gt>.
=cut