[dbsrgits/SQL-Translator.git] / lib / SQL / Translator / Schema / Table.pm

package SQL::Translator::Schema::Table;

# ----------------------------------------------------------------------
# $Id: Table.pm,v 1.25 2004-03-23 21:05:20 grommit Exp $
# ----------------------------------------------------------------------
# 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
# 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
# -------------------------------------------------------------------

=pod

=head1 NAME

SQL::Translator::Schema::Table - SQL::Translator table object

=head1 SYNOPSIS

  use SQL::Translator::Schema::Table;
  my $table = SQL::Translator::Schema::Table->new( name => 'foo' );

=head1 DESCSIPTION

C<SQL::Translator::Schema::Table> is the table object.

=head1 METHODS

=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 'Class::Base';
use vars qw( $VERSION $FIELD_ORDER );

$VERSION = sprintf "%d.%02d", q$Revision: 1.25 $ =~ /(\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 {

=pod

=head2 new

Object constructor.

  my $table  =  SQL::Translator::Schema::Table->new( 
      schema => $schema,
      name   => 'foo',
  );

=cut

    my ( $self, $config ) = @_;
    
    for my $arg ( qw[ schema name comments ] ) {
        next unless defined $config->{ $arg };
        defined $self->$arg( $config->{ $arg } ) or return;
    }

    return $self;
}

# ----------------------------------------------------------------------
sub add_constraint {

=pod

=head2 add_constraint

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 $c2 = SQL::Translator::Schema::Constraint->new( name => 'uniq' );
  $c2    = $table->add_constraint( $constraint );

=cut

    my $self             = shift;
    my $constraint_class = 'SQL::Translator::Schema::Constraint';
    my $constraint;

    if ( UNIVERSAL::isa( $_[0], $constraint_class ) ) {
        $constraint = shift;
        $constraint->table( $self );
    }
    else {
        my %args = @_;
        $args{'table'} = $self;
        $constraint = $constraint_class->new( \%args ) or 
            return $self->error( $constraint_class->error );
    }

    #
    # If we're trying to add a PK when one is already defined,
    # then just add the fields to the existing definition.
    #
    my $ok = 1;
    my $pk = $self->primary_key;
    if ( $pk && $constraint->type eq PRIMARY_KEY ) {
        $self->primary_key( $constraint->fields );
        $constraint = $pk;
        $ok         = 0;
    }
    elsif ( $constraint->type eq PRIMARY_KEY ) {
        for my $fname ( $constraint->fields ) {
            if ( my $f = $self->get_field( $fname ) ) {
                $f->is_primary_key( 1 );
            }
        }
    }
    #
    # 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;
    }

    return $constraint;
}

# ----------------------------------------------------------------------
sub add_index {

=pod

=head2 add_index

Add an index to the table.  Returns the newly created
C<SQL::Translator::Schema::Index> object.

  my $i1     = $table->add_index(
      name   => 'name',
      fields => [ 'name' ],
      type   => 'normal',
  );

  my $i2 = SQL::Translator::Schema::Index->new( name => 'id' );
  $i2    = $table->add_index( $index );

=cut

    my $self        = shift;
    my $index_class = 'SQL::Translator::Schema::Index';
    my $index;

    if ( UNIVERSAL::isa( $_[0], $index_class ) ) {
        $index = shift;
        $index->table( $self );
    }
    else {
        my %args = @_;
        $args{'table'} = $self;
        $index = $index_class->new( \%args ) or return 
            $self->error( $index_class->error );
    }

    push @{ $self->{'indices'} }, $index;
    return $index;
}

# ----------------------------------------------------------------------
sub add_field {

=pod

=head2 add_field

Add an field to the table.  Returns the newly created
C<SQL::Translator::Schema::Field> object.  The "name" parameter is 
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(
      name      => 'foo_id',
      data_type => 'integer',
      size      => 11,
  );

  my $f2     =  SQL::Translator::Schema::Field->new( 
      name   => 'name', 
      table  => $table,
  );
  $f2 = $table->add_field( $field2 ) or die $table->error;

=cut

    my $self        = shift;
    my $field_class = 'SQL::Translator::Schema::Field';
    my $field;

    if ( UNIVERSAL::isa( $_[0], $field_class ) ) {
        $field = shift;
        $field->table( $self );
    }
    else {
        my %args = @_;
        $args{'table'} = $self;
        $field = $field_class->new( \%args ) or return 
            $self->error( $field_class->error );
    }

    $field->order( ++$FIELD_ORDER );
    # 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]);
    }
    else {
        $self->{'fields'}{ $field_name } = $field;
    }

    return $field;
}

# ----------------------------------------------------------------------
sub comments {

=pod

=head2 comments

Get or set the comments on a table.  May be called several times to 
set and it will accumulate the comments.  Called in an array context,
returns each comment individually; called in a scalar context, returns
all the comments joined on newlines.

  $table->comments('foo');
  $table->comments('bar');
  print join( ', ', $table->comments ); # prints "foo, bar"

=cut

    my $self     = shift;
    my @comments = ref $_[0] ? @{ $_[0] } : @_;

    for my $arg ( @comments ) {
        $arg = $arg->[0] if ref $arg;
        push @{ $self->{'comments'} }, $arg if defined $arg && $arg;
    }

    if ( @{ $self->{'comments'} || [] } ) {
        return wantarray 
            ? @{ $self->{'comments'} }
            : join( "\n", @{ $self->{'comments'} } )
        ;
    } 
    else {
        return wantarray ? () : undef;
    }
}

# ----------------------------------------------------------------------
sub get_constraints {

=pod

=head2 get_constraints

Returns all the constraint objects as an array or array reference.

  my @constraints = $table->get_constraints;

=cut

    my $self = shift;

    if ( ref $self->{'constraints'} ) {
        return wantarray 
            ? @{ $self->{'constraints'} } : $self->{'constraints'};
    }
    else {
        $self->error('No constraints');
        return wantarray ? () : undef;
    }
}

# ----------------------------------------------------------------------
sub get_indices {

=pod

=head2 get_indices

Returns all the index objects as an array or array reference.

  my @indices = $table->get_indices;

=cut

    my $self = shift;

    if ( ref $self->{'indices'} ) {
        return wantarray 
            ? @{ $self->{'indices'} } 
            : $self->{'indices'};
    }
    else {
        $self->error('No indices');
        return wantarray ? () : undef;
    }
}

# ----------------------------------------------------------------------
sub get_field {

=pod

=head2 get_field

Returns a field by the name provided.

  my $field = $table->get_field('foo');

=cut

    my $self       = shift;
    my $field_name = shift or return $self->error('No field name');
    return $self->error( qq[Field "$field_name" does not exist] ) unless
        exists $self->{'fields'}{ $field_name };
    return $self->{'fields'}{ $field_name };
}

# ----------------------------------------------------------------------
sub get_fields {

=pod

=head2 get_fields

Returns all the field objects as an array or array reference.

  my @fields = $table->get_fields;

=cut

    my $self = shift;
    my @fields = 
        map  { $_->[1] }
        sort { $a->[0] <=> $b->[0] }
        map  { [ $_->order, $_ ] }
        values %{ $self->{'fields'} || {} };

    if ( @fields ) {
        return wantarray ? @fields : \@fields;
    }
    else {
        $self->error('No fields');
        return wantarray ? () : undef;
    }
}

# ----------------------------------------------------------------------
sub is_valid {

=pod

=head2 is_valid

Determine whether the view is valid or not.

  my $ok = $view->is_valid;

=cut

    my $self = shift;
    return $self->error('No name')   unless $self->name;
    return $self->error('No fields') unless $self->get_fields;

    for my $object ( 
        $self->get_fields, $self->get_indices, $self->get_constraints 
    ) {
        return $object->error unless $object->is_valid;
    }

    return 1;
}

# ----------------------------------------------------------------------
sub is_trivial_link {

=pod

=head2 is_data

=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

=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

=head2 name

Get or set the table's name.

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');

=cut

    my $self = 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 );
        }
        $self->{'name'} = $arg;
    }

    return $self->{'name'} || '';
}

# ----------------------------------------------------------------------
sub schema {

=pod

=head2 schema

Get or set the table's schema object.

  my $schema = $table->schema;

=cut

    my $self = shift;
    if ( my $arg = shift ) {
        return $self->error('Not a schema object') unless
            UNIVERSAL::isa( $arg, 'SQL::Translator::Schema' );
        $self->{'schema'} = $arg;
    }

    return $self->{'schema'};
}

# ----------------------------------------------------------------------
sub primary_key {

=pod

=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
names are present, it will create a new PK if none exists, or it will
add to the fields of an existing PK (and will unique the field names).
Returns the C<SQL::Translator::Schema::Constraint> object representing
the primary key.

These are eqivalent:

  $table->primary_key('id');
  $table->primary_key(['name']);
  $table->primary_key('id','name']);
  $table->primary_key(['id','name']);
  $table->primary_key('id,name');
  $table->primary_key(qw[ id name ]);

  my $pk = $table->primary_key;

=cut

    my $self   = shift;
    my $fields = parse_list_arg( @_ );

    my $constraint;
    if ( @$fields ) {
        for my $f ( @$fields ) {
            return $self->error(qq[Invalid field "$f"]) unless 
                $self->get_field($f);
        }

        my $has_pk;
        for my $c ( $self->get_constraints ) {
            if ( $c->type eq PRIMARY_KEY ) {
                $has_pk = 1;
                $c->fields( @{ $c->fields }, @$fields );
                $constraint = $c;
            } 
        }

        unless ( $has_pk ) {
            $constraint = $self->add_constraint(
                type   => PRIMARY_KEY,
                fields => $fields,
            ) or return;
        }
    }

    if ( $constraint ) {
        return $constraint;
    }
    else {
        for my $c ( $self->get_constraints ) {
            return $c if $c->type eq PRIMARY_KEY;
        }
    }

    return;
}

# ----------------------------------------------------------------------
sub options {

=pod

=head2 options

Get or set the table's options (e.g., table types for MySQL).  Returns
an array or array reference.

  my @options = $table->options;

=cut

    my $self    = shift;
    my $options = parse_list_arg( @_ );

    push @{ $self->{'options'} }, @$options;

    if ( ref $self->{'options'} ) {
        return wantarray ? @{ $self->{'options'} || [] } : $self->{'options'};
    }
    else {
        return wantarray ? () : [];
    }
}

# ----------------------------------------------------------------------
sub order {

=pod

=head2 order

Get or set the table's order.

  my $order = $table->order(3);

=cut

    my ( $self, $arg ) = @_;

    if ( defined $arg && $arg =~ /^\d+$/ ) {
        $self->{'order'} = $arg;
    }

    return $self->{'order'} || 0;
}

# ----------------------------------------------------------------------
sub DESTROY {
    my $self = shift;
    undef $self->{'schema'}; # destroy cyclical reference
    undef $_ for @{ $self->{'constraints'} };
    undef $_ for @{ $self->{'indices'} };
    undef $_ for values %{ $self->{'fields'} };
}

1;

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

=pod

=head1 AUTHORS

Ken Y. Clark E<lt>kclark@cpan.orgE<gt>,
Allen Day E<lt>allenday@ucla.eduE<gt>.

=cut
Commit	Line	Data
3c5de62a	1	package SQL::Translator::Schema::Table;
	2
	3	# ----------------------------------------------------------------------
65dd38c0	4	# $Id: Table.pm,v 1.25 2004-03-23 21:05:20 grommit Exp $
3c5de62a	5	# ----------------------------------------------------------------------
6606c4c6	6	# Copyright (C) 2002-4 SQLFairy Authors
3c5de62a	7	#
	8	# This program is free software; you can redistribute it and/or
	9	# modify it under the terms of the GNU General Public License as
	10	# published by the Free Software Foundation; version 2.
	11	#
	12	# This program is distributed in the hope that it will be useful, but
	13	# WITHOUT ANY WARRANTY; without even the implied warranty of
	14	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	# General Public License for more details.
	16	#
	17	# You should have received a copy of the GNU General Public License
	18	# along with this program; if not, write to the Free Software
	19	# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
	20	# 02111-1307 USA
	21	# -------------------------------------------------------------------
	22
	23	=pod
	24
	25	=head1 NAME
	26
	27	SQL::Translator::Schema::Table - SQL::Translator table object
	28
	29	=head1 SYNOPSIS
	30
	31	use SQL::Translator::Schema::Table;
0f3cc5c0	32	my $table = SQL::Translator::Schema::Table->new( name => 'foo' );
3c5de62a	33
	34	=head1 DESCSIPTION
	35
	36	C<SQL::Translator::Schema::Table> is the table object.
	37
	38	=head1 METHODS
	39
	40	=cut
	41
	42	use strict;
	43	use Class::Base;
30f4ec44	44	use SQL::Translator::Utils 'parse_list_arg';
0f3cc5c0	45	use SQL::Translator::Schema::Constants;
3c5de62a	46	use SQL::Translator::Schema::Constraint;
	47	use SQL::Translator::Schema::Field;
	48	use SQL::Translator::Schema::Index;
c8515c9f	49	use Data::Dumper;
3c5de62a	50
3c5de62a	51	use base 'Class::Base';
0f3cc5c0	52	use vars qw( $VERSION $FIELD_ORDER );
3c5de62a	53
65dd38c0	54	$VERSION = sprintf "%d.%02d", q$Revision: 1.25 $ =~ /(\d+)\.(\d+)/;
	55
	56
	57	# Stringify to our name, being careful not to pass any args through so we don't
	58	# accidentally set it to undef. We also have to tweak bool so the object is
	59	# still true when it doesn't have a name (which shouldn't happen!).
	60	use overload
	61	'""' => sub { shift->name },
	62	'bool' => sub { $_[0]->name \|\| $_[0] },
	63	fallback => 1,
	64	;
3c5de62a	65
	66	# ----------------------------------------------------------------------
	67	sub init {
	68
	69	=pod
	70
	71	=head2 new
	72
	73	Object constructor.
	74
43b9dc7a	75	my $table = SQL::Translator::Schema::Table->new(
	76	schema => $schema,
	77	name => 'foo',
	78	);
3c5de62a	79
	80	=cut
	81
	82	my ( $self, $config ) = @_;
43b9dc7a	83
88b8377e	84	for my $arg ( qw[ schema name comments ] ) {
43b9dc7a	85	next unless defined $config->{ $arg };
88b8377e	86	defined $self->$arg( $config->{ $arg } ) or return;
43b9dc7a	87	}
43b9dc7a	88
3c5de62a	89	return $self;
	90	}
	91
	92	# ----------------------------------------------------------------------
3c5de62a	93	sub add_constraint {
	94
	95	=pod
	96
	97	=head2 add_constraint
	98
0f3cc5c0	99	Add a constraint to the table. Returns the newly created
0f3cc5c0	100	C<SQL::Translator::Schema::Constraint> object.
3c5de62a	101
870024f3	102	my $c1 = $table->add_constraint(
	103	name => 'pk',
	104	type => PRIMARY_KEY,
	105	fields => [ 'foo_id' ],
3c5de62a	106	);
3c5de62a	107
dfdb0568	108	my $c2 = SQL::Translator::Schema::Constraint->new( name => 'uniq' );
dfdb0568	109	$c2 = $table->add_constraint( $constraint );
43b9dc7a	110
3c5de62a	111	=cut
3c5de62a	112
43b9dc7a	113	my $self = shift;
	114	my $constraint_class = 'SQL::Translator::Schema::Constraint';
	115	my $constraint;
	116
	117	if ( UNIVERSAL::isa( $_[0], $constraint_class ) ) {
	118	$constraint = shift;
	119	$constraint->table( $self );
	120	}
	121	else {
	122	my %args = @_;
	123	$args{'table'} = $self;
	124	$constraint = $constraint_class->new( \%args ) or
	125	return $self->error( $constraint_class->error );
	126	}
	127
dfdb0568	128	#
	129	# If we're trying to add a PK when one is already defined,
	130	# then just add the fields to the existing definition.
	131	#
3dd9026c	132	my $ok = 1;
dfdb0568	133	my $pk = $self->primary_key;
	134	if ( $pk && $constraint->type eq PRIMARY_KEY ) {
	135	$self->primary_key( $constraint->fields );
	136	$constraint = $pk;
3dd9026c	137	$ok = 0;
dfdb0568	138	}
2ccf2299	139	elsif ( $constraint->type eq PRIMARY_KEY ) {
	140	for my $fname ( $constraint->fields ) {
	141	if ( my $f = $self->get_field( $fname ) ) {
	142	$f->is_primary_key( 1 );
	143	}
	144	}
	145	}
3dd9026c	146	#
3dd9026c	147	# See if another constraint of the same type
be53b4c8	148	# covers the same fields. -- This doesn't work! ky
3dd9026c	149	#
be53b4c8	150	# elsif ( $constraint->type ne CHECK_C ) {
	151	# my @field_names = $constraint->fields;
	152	# for my $c (
	153	# grep { $_->type eq $constraint->type }
	154	# $self->get_constraints
	155	# ) {
	156	# my %fields = map { $_, 1 } $c->fields;
	157	# for my $field_name ( @field_names ) {
	158	# if ( $fields{ $field_name } ) {
	159	# $constraint = $c;
	160	# $ok = 0;
	161	# last;
	162	# }
	163	# }
	164	# last unless $ok;
	165	# }
	166	# }
dfdb0568	167
	168	if ( $ok ) {
	169	push @{ $self->{'constraints'} }, $constraint;
	170	}
	171
3c5de62a	172	return $constraint;
	173	}
	174
	175	# ----------------------------------------------------------------------
	176	sub add_index {
	177
	178	=pod
	179
	180	=head2 add_index
	181
0f3cc5c0	182	Add an index to the table. Returns the newly created
0f3cc5c0	183	C<SQL::Translator::Schema::Index> object.
3c5de62a	184
870024f3	185	my $i1 = $table->add_index(
3c5de62a	186	name => 'name',
	187	fields => [ 'name' ],
	188	type => 'normal',
	189	);
	190
dfdb0568	191	my $i2 = SQL::Translator::Schema::Index->new( name => 'id' );
dfdb0568	192	$i2 = $table->add_index( $index );
43b9dc7a	193
3c5de62a	194	=cut
3c5de62a	195
43b9dc7a	196	my $self = shift;
	197	my $index_class = 'SQL::Translator::Schema::Index';
	198	my $index;
	199
	200	if ( UNIVERSAL::isa( $_[0], $index_class ) ) {
	201	$index = shift;
	202	$index->table( $self );
	203	}
	204	else {
	205	my %args = @_;
	206	$args{'table'} = $self;
	207	$index = $index_class->new( \%args ) or return
	208	$self->error( $index_class->error );
	209	}
	210
3c5de62a	211	push @{ $self->{'indices'} }, $index;
	212	return $index;
	213	}
	214
	215	# ----------------------------------------------------------------------
	216	sub add_field {
	217
	218	=pod
	219
	220	=head2 add_field
	221
43b9dc7a	222	Add an field to the table. Returns the newly created
	223	C<SQL::Translator::Schema::Field> object. The "name" parameter is
	224	required. If you try to create a field with the same name as an
	225	existing field, you will get an error and the field will not be created.
3c5de62a	226
870024f3	227	my $f1 = $table->add_field(
0f3cc5c0	228	name => 'foo_id',
	229	data_type => 'integer',
	230	size => 11,
3c5de62a	231	);
3c5de62a	232
870024f3	233	my $f2 = SQL::Translator::Schema::Field->new(
43b9dc7a	234	name => 'name',
	235	table => $table,
	236	);
870024f3	237	$f2 = $table->add_field( $field2 ) or die $table->error;
43b9dc7a	238
3c5de62a	239	=cut
3c5de62a	240
dfdb0568	241	my $self = shift;
43b9dc7a	242	my $field_class = 'SQL::Translator::Schema::Field';
	243	my $field;
	244
	245	if ( UNIVERSAL::isa( $_[0], $field_class ) ) {
	246	$field = shift;
	247	$field->table( $self );
	248	}
	249	else {
	250	my %args = @_;
	251	$args{'table'} = $self;
	252	$field = $field_class->new( \%args ) or return
	253	$self->error( $field_class->error );
	254	}
	255
30f4ec44	256	$field->order( ++$FIELD_ORDER );
65dd38c0	257	# We know we have a name as the Field->new above errors if none given.
65dd38c0	258	my $field_name = $field->name;
43b9dc7a	259
43b9dc7a	260	if ( exists $self->{'fields'}{ $field_name } ) {
870024f3	261	return $self->error(qq[Can't create field: "$field_name" exists]);
43b9dc7a	262	}
	263	else {
	264	$self->{'fields'}{ $field_name } = $field;
43b9dc7a	265	}
43b9dc7a	266
3c5de62a	267	return $field;
	268	}
	269
	270	# ----------------------------------------------------------------------
88b8377e	271	sub comments {
	272
	273	=pod
	274
	275	=head2 comments
	276
	277	Get or set the comments on a table. May be called several times to
	278	set and it will accumulate the comments. Called in an array context,
	279	returns each comment individually; called in a scalar context, returns
	280	all the comments joined on newlines.
	281
	282	$table->comments('foo');
	283	$table->comments('bar');
	284	print join( ', ', $table->comments ); # prints "foo, bar"
	285
	286	=cut
	287
eb3b8ae4	288	my $self = shift;
eb3b8ae4	289	my @comments = ref $_[0] ? @{ $_[0] } : @_;
b891fb49	290
eb3b8ae4	291	for my $arg ( @comments ) {
b891fb49	292	$arg = $arg->[0] if ref $arg;
eb3b8ae4	293	push @{ $self->{'comments'} }, $arg if defined $arg && $arg;
b891fb49	294	}
88b8377e	295
eb3b8ae4	296	if ( @{ $self->{'comments'} \|\| [] } ) {
	297	return wantarray
	298	? @{ $self->{'comments'} }
	299	: join( "\n", @{ $self->{'comments'} } )
	300	;
	301	}
	302	else {
	303	return wantarray ? () : undef;
	304	}
88b8377e	305	}
	306
	307	# ----------------------------------------------------------------------
0f3cc5c0	308	sub get_constraints {
	309
	310	=pod
	311
	312	=head2 get_constraints
	313
	314	Returns all the constraint objects as an array or array reference.
	315
	316	my @constraints = $table->get_constraints;
	317
	318	=cut
	319
	320	my $self = shift;
	321
	322	if ( ref $self->{'constraints'} ) {
	323	return wantarray
	324	? @{ $self->{'constraints'} } : $self->{'constraints'};
	325	}
	326	else {
	327	$self->error('No constraints');
	328	return wantarray ? () : undef;
	329	}
	330	}
	331
	332	# ----------------------------------------------------------------------
	333	sub get_indices {
3c5de62a	334
	335	=pod
	336
0f3cc5c0	337	=head2 get_indices
3c5de62a	338
0f3cc5c0	339	Returns all the index objects as an array or array reference.
3c5de62a	340
0f3cc5c0	341	my @indices = $table->get_indices;
3c5de62a	342
	343	=cut
	344
	345	my $self = shift;
0f3cc5c0	346
	347	if ( ref $self->{'indices'} ) {
	348	return wantarray
	349	? @{ $self->{'indices'} }
	350	: $self->{'indices'};
	351	}
	352	else {
	353	$self->error('No indices');
	354	return wantarray ? () : undef;
	355	}
	356	}
	357
	358	# ----------------------------------------------------------------------
43b9dc7a	359	sub get_field {
	360
	361	=pod
	362
	363	=head2 get_field
	364
	365	Returns a field by the name provided.
	366
	367	my $field = $table->get_field('foo');
	368
	369	=cut
	370
	371	my $self = shift;
	372	my $field_name = shift or return $self->error('No field name');
	373	return $self->error( qq[Field "$field_name" does not exist] ) unless
	374	exists $self->{'fields'}{ $field_name };
	375	return $self->{'fields'}{ $field_name };
	376	}
	377
	378	# ----------------------------------------------------------------------
0f3cc5c0	379	sub get_fields {
	380
	381	=pod
	382
	383	=head2 get_fields
	384
	385	Returns all the field objects as an array or array reference.
	386
	387	my @fields = $table->get_fields;
	388
	389	=cut
	390
	391	my $self = shift;
	392	my @fields =
30f4ec44	393	map { $_->[1] }
	394	sort { $a->[0] <=> $b->[0] }
	395	map { [ $_->order, $_ ] }
0f3cc5c0	396	values %{ $self->{'fields'} \|\| {} };
	397
	398	if ( @fields ) {
	399	return wantarray ? @fields : \@fields;
	400	}
	401	else {
	402	$self->error('No fields');
	403	return wantarray ? () : undef;
	404	}
3c5de62a	405	}
	406
	407	# ----------------------------------------------------------------------
	408	sub is_valid {
	409
	410	=pod
	411
	412	=head2 is_valid
	413
	414	Determine whether the view is valid or not.
	415
	416	my $ok = $view->is_valid;
	417
	418	=cut
	419
	420	my $self = shift;
43b9dc7a	421	return $self->error('No name') unless $self->name;
0f3cc5c0	422	return $self->error('No fields') unless $self->get_fields;
	423
	424	for my $object (
	425	$self->get_fields, $self->get_indices, $self->get_constraints
	426	) {
	427	return $object->error unless $object->is_valid;
	428	}
	429
	430	return 1;
3c5de62a	431	}
3c5de62a	432
870024f3	433	# ----------------------------------------------------------------------
65157eda	434	sub is_trivial_link {
	435
	436	=pod
	437
	438	=head2 is_data
	439
	440	=cut
	441
	442	my $self = shift;
	443	return 0 if $self->is_data;
	444	return $self->{'is_trivial_link'} if defined $self->{'is_trivial_link'};
	445
	446	$self->{'is_trivial_link'} = 1;
	447
	448	my %fk = ();
	449
	450	foreach my $field ( $self->get_fields ) {
	451	next unless $field->is_foreign_key;
	452	$fk{$field->foreign_key_reference->reference_table}++;
	453	}
	454
	455	foreach my $referenced (keys %fk){
f9c5e794	456	if($fk{$referenced} > 1){
	457	$self->{'is_trivial_link'} = 0;
	458	last;
65157eda	459	}
3d6c9056	460	}
65157eda	461
	462	return $self->{'is_trivial_link'};
	463
	464	}
	465
69c7a62f	466	sub is_data {
69c7a62f	467
870024f3	468	=pod
	469
	470	=head2 is_data
	471
	472	=cut
	473
	474	my $self = shift;
	475	return $self->{'is_data'} if defined $self->{'is_data'};
69c7a62f	476
870024f3	477	$self->{'is_data'} = 0;
69c7a62f	478
870024f3	479	foreach my $field ( $self->get_fields ) {
	480	if ( !$field->is_primary_key and !$field->is_foreign_key ) {
	481	$self->{'is_data'} = 1;
	482	return $self->{'is_data'};
	483	}
	484	}
	485
	486	return $self->{'is_data'};
69c7a62f	487	}
69c7a62f	488
870024f3	489	# ----------------------------------------------------------------------
69c7a62f	490	sub can_link {
	491
	492	=pod
	493
	494	=head2 can_link
	495
	496	Determine whether the table can link two arg tables via many-to-many.
	497
	498	my $ok = $table->can_link($table1,$table2);
	499
	500	=cut
	501
870024f3	502	my ( $self, $table1, $table2 ) = @_;
	503
	504	return $self->{'can_link'}{ $table1->name }{ $table2->name }
	505	if defined $self->{'can_link'}{ $table1->name }{ $table2->name };
	506
	507	if ( $self->is_data == 1 ) {
	508	$self->{'can_link'}{ $table1->name }{ $table2->name } = [0];
	509	$self->{'can_link'}{ $table2->name }{ $table1->name } = [0];
	510	return $self->{'can_link'}{ $table1->name }{ $table2->name };
	511	}
	512
	513	my %fk = ();
	514
	515	foreach my $field ( $self->get_fields ) {
	516	if ( $field->is_foreign_key ) {
	517	push @{ $fk{ $field->foreign_key_reference->reference_table } },
	518	$field->foreign_key_reference;
	519	}
	520	}
	521
	522	if ( !defined( $fk{ $table1->name } ) or !defined( $fk{ $table2->name } ) )
	523	{
	524	$self->{'can_link'}{ $table1->name }{ $table2->name } = [0];
	525	$self->{'can_link'}{ $table2->name }{ $table1->name } = [0];
	526	return $self->{'can_link'}{ $table1->name }{ $table2->name };
	527	}
	528
	529	# trivial traversal, only one way to link the two tables
	530	if ( scalar( @{ $fk{ $table1->name } } == 1 )
	531	and scalar( @{ $fk{ $table2->name } } == 1 ) )
	532	{
	533	$self->{'can_link'}{ $table1->name }{ $table2->name } =
	534	[ 'one2one', $fk{ $table1->name }, $fk{ $table2->name } ];
	535	$self->{'can_link'}{ $table1->name }{ $table2->name } =
	536	[ 'one2one', $fk{ $table2->name }, $fk{ $table1->name } ];
	537
	538	# non-trivial traversal. one way to link table2,
	539	# many ways to link table1
	540	}
	541	elsif ( scalar( @{ $fk{ $table1->name } } > 1 )
	542	and scalar( @{ $fk{ $table2->name } } == 1 ) )
	543	{
	544	$self->{'can_link'}{ $table1->name }{ $table2->name } =
	545	[ 'many2one', $fk{ $table1->name }, $fk{ $table2->name } ];
	546	$self->{'can_link'}{ $table2->name }{ $table1->name } =
	547	[ 'one2many', $fk{ $table2->name }, $fk{ $table1->name } ];
	548
	549	# non-trivial traversal. one way to link table1,
	550	# many ways to link table2
	551	}
	552	elsif ( scalar( @{ $fk{ $table1->name } } == 1 )
	553	and scalar( @{ $fk{ $table2->name } } > 1 ) )
	554	{
	555	$self->{'can_link'}{ $table1->name }{ $table2->name } =
	556	[ 'one2many', $fk{ $table1->name }, $fk{ $table2->name } ];
	557	$self->{'can_link'}{ $table2->name }{ $table1->name } =
	558	[ 'many2one', $fk{ $table2->name }, $fk{ $table1->name } ];
	559
	560	# non-trivial traversal. many ways to link table1 and table2
	561	}
	562	elsif ( scalar( @{ $fk{ $table1->name } } > 1 )
	563	and scalar( @{ $fk{ $table2->name } } > 1 ) )
	564	{
	565	$self->{'can_link'}{ $table1->name }{ $table2->name } =
566	[ 'many2many', $fk{ $table1->name }, $fk{ $table2->name } ];
567	$self->{'can_link'}{ $table2->name }{ $table1->name } =
568	[ 'many2many', $fk{ $table2->name }, $fk{ $table1->name } ];
569
570	# one of the tables didn't export a key
571	# to this table, no linking possible
572	}
573	else {
574	$self->{'can_link'}{ $table1->name }{ $table2->name } = [0];
575	$self->{'can_link'}{ $table2->name }{ $table1->name } = [0];
576	}
577
578	return $self->{'can_link'}{ $table1->name }{ $table2->name };
69c7a62f	579	}
69c7a62f	580
43b9dc7a	581	# ----------------------------------------------------------------------
dfdb0568	582	sub name {
	583
	584	=pod
	585
	586	=head2 name
	587
870024f3	588	Get or set the table's name.
dfdb0568	589
65dd38c0	590	Errors ("No table name") if you try to set a blank name.
	591
	592	If provided an argument, checks the schema object for a table of
	593	that name and disallows the change if one exists (setting the error to
	594	"Can't use table name "%s": table exists").
dfdb0568	595
	596	my $table_name = $table->name('foo');
	597
	598	=cut
	599
	600	my $self = shift;
	601
65dd38c0	602	if ( @_ ) {
65dd38c0	603	my $arg = shift \|\| return $self->error( "No table name" );
dfdb0568	604	if ( my $schema = $self->schema ) {
870024f3	605	return $self->error( qq[Can't use table name "$arg": table exists] )
dfdb0568	606	if $schema->get_table( $arg );
	607	}
	608	$self->{'name'} = $arg;
	609	}
	610
	611	return $self->{'name'} \|\| '';
	612	}
	613
	614	# ----------------------------------------------------------------------
43b9dc7a	615	sub schema {
	616
	617	=pod
	618
	619	=head2 schema
	620
870024f3	621	Get or set the table's schema object.
43b9dc7a	622
	623	my $schema = $table->schema;
	624
	625	=cut
	626
	627	my $self = shift;
	628	if ( my $arg = shift ) {
	629	return $self->error('Not a schema object') unless
	630	UNIVERSAL::isa( $arg, 'SQL::Translator::Schema' );
	631	$self->{'schema'} = $arg;
	632	}
	633
	634	return $self->{'schema'};
	635	}
	636
	637	# ----------------------------------------------------------------------
	638	sub primary_key {
	639
	640	=pod
	641
870024f3	642	=head2 primary_key
43b9dc7a	643
870024f3	644	Gets or sets the table's primary key(s). Takes one or more field
5e84ac85	645	names (as a string, list or array[ref]) as an argument. If the field
	646	names are present, it will create a new PK if none exists, or it will
	647	add to the fields of an existing PK (and will unique the field names).
	648	Returns the C<SQL::Translator::Schema::Constraint> object representing
	649	the primary key.
	650
	651	These are eqivalent:
43b9dc7a	652
43b9dc7a	653	$table->primary_key('id');
5e84ac85	654	$table->primary_key(['name']);
5e84ac85	655	$table->primary_key('id','name']);
43b9dc7a	656	$table->primary_key(['id','name']);
	657	$table->primary_key('id,name');
	658	$table->primary_key(qw[ id name ]);
	659
	660	my $pk = $table->primary_key;
	661
	662	=cut
	663
30f4ec44	664	my $self = shift;
30f4ec44	665	my $fields = parse_list_arg( @_ );
43b9dc7a	666
5e84ac85	667	my $constraint;
43b9dc7a	668	if ( @$fields ) {
	669	for my $f ( @$fields ) {
	670	return $self->error(qq[Invalid field "$f"]) unless
	671	$self->get_field($f);
	672	}
	673
	674	my $has_pk;
	675	for my $c ( $self->get_constraints ) {
	676	if ( $c->type eq PRIMARY_KEY ) {
	677	$has_pk = 1;
	678	$c->fields( @{ $c->fields }, @$fields );
5e84ac85	679	$constraint = $c;
43b9dc7a	680	}
	681	}
	682
	683	unless ( $has_pk ) {
5e84ac85	684	$constraint = $self->add_constraint(
43b9dc7a	685	type => PRIMARY_KEY,
43b9dc7a	686	fields => $fields,
88b8377e	687	) or return;
43b9dc7a	688	}
	689	}
	690
5e84ac85	691	if ( $constraint ) {
	692	return $constraint;
	693	}
	694	else {
	695	for my $c ( $self->get_constraints ) {
	696	return $c if $c->type eq PRIMARY_KEY;
	697	}
43b9dc7a	698	}
43b9dc7a	699
dfdb0568	700	return;
43b9dc7a	701	}
	702
	703	# ----------------------------------------------------------------------
	704	sub options {
	705
	706	=pod
	707
	708	=head2 options
	709
870024f3	710	Get or set the table's options (e.g., table types for MySQL). Returns
43b9dc7a	711	an array or array reference.
	712
	713	my @options = $table->options;
	714
	715	=cut
	716
	717	my $self = shift;
30f4ec44	718	my $options = parse_list_arg( @_ );
43b9dc7a	719
	720	push @{ $self->{'options'} }, @$options;
	721
	722	if ( ref $self->{'options'} ) {
	723	return wantarray ? @{ $self->{'options'} \|\| [] } : $self->{'options'};
	724	}
	725	else {
	726	return wantarray ? () : [];
	727	}
	728	}
	729
30f4ec44	730	# ----------------------------------------------------------------------
	731	sub order {
	732
	733	=pod
	734
	735	=head2 order
	736
870024f3	737	Get or set the table's order.
30f4ec44	738
	739	my $order = $table->order(3);
	740
	741	=cut
	742
	743	my ( $self, $arg ) = @_;
	744
	745	if ( defined $arg && $arg =~ /^\d+$/ ) {
	746	$self->{'order'} = $arg;
	747	}
	748
	749	return $self->{'order'} \|\| 0;
	750	}
	751
	752	# ----------------------------------------------------------------------
	753	sub DESTROY {
	754	my $self = shift;
	755	undef $self->{'schema'}; # destroy cyclical reference
	756	undef $_ for @{ $self->{'constraints'} };
	757	undef $_ for @{ $self->{'indices'} };
	758	undef $_ for values %{ $self->{'fields'} };
	759	}
	760
3c5de62a	761	1;
	762
	763	# ----------------------------------------------------------------------
	764
	765	=pod
	766
870024f3	767	=head1 AUTHORS
3c5de62a	768
870024f3	769	Ken Y. Clark E<lt>kclark@cpan.orgE<gt>,
870024f3	770	Allen Day E<lt>allenday@ucla.eduE<gt>.
3c5de62a	771
3c5de62a	772	=cut