From: Ash Berlin <ash_github@firemirror.com>
Date: Tue, 3 Jun 2008 16:11:25 +0000 (+0000)
Subject: Remove the length limit on identifiers - it doesn't belong in DBIx::Class
X-Git-Tag: v0.08240~431
X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=a7e65bb51bb6dbdfdaf229a6d0dd1d8c25bef337;p=dbsrgits%2FDBIx-Class.git

Remove the length limit on identifiers - it doesn't belong in DBIx::Class
A few doc fixes
---

diff --git a/lib/DBIx/Class/ResultSet.pm b/lib/DBIx/Class/ResultSet.pm
index e113fdb..af97ebb 100644
--- a/lib/DBIx/Class/ResultSet.pm
+++ b/lib/DBIx/Class/ResultSet.pm
@@ -2435,13 +2435,27 @@ C<cd> or C<artist> relationships, which saves us two SQL statements in this
 case.
 
 Simple prefetches will be joined automatically, so there is no need
-for a C<join> attribute in the above search. If you're prefetching to
-depth (e.g. { cd => { artist => 'label' } or similar), you'll need to
-specify the join as well.
+for a C<join> attribute in the above search. 
 
 C<prefetch> can be used with the following relationship types: C<belongs_to>,
 C<has_one> (or if you're using C<add_relationship>, any relationship declared
-with an accessor type of 'single' or 'filter').
+with an accessor type of 'single' or 'filter'). A more complex example that
+prefetches an artists cds, the tracks on those cds, and the tags associted 
+with that artist is given below (assuming many-to-many from artists to tags):
+
+ my $rs = $schema->resultset('Artist')->search(
+   undef,
+   {
+     prefetch => [
+       { cds => 'tracks' },
+       { artist_tags => 'tags' }
+     ]
+   }
+ );
+ 
+
+B<NOTE:> If you specify a C<prefetch> attribute, the C<join> and C<select>
+attributes will be ignored.
 
 =head2 page
 
diff --git a/lib/SQL/Translator/Parser/DBIx/Class.pm b/lib/SQL/Translator/Parser/DBIx/Class.pm
index 80c166c..4610e20 100644
--- a/lib/SQL/Translator/Parser/DBIx/Class.pm
+++ b/lib/SQL/Translator/Parser/DBIx/Class.pm
@@ -101,7 +101,7 @@ sub parse {
             if (!$source->compare_relationship_keys($unique_constraints{$uniq}, \@primary)) {
                 $table->add_constraint(
                             type             => 'unique',
-                            name             => _create_unique_symbol($uniq),
+                            name             => $uniq,
                             fields           => $unique_constraints{$uniq}
                 );
             }
@@ -165,9 +165,7 @@ sub parse {
                 if (scalar(@keys)) {
                   $table->add_constraint(
                                     type             => 'foreign_key',
-                                    name             => _create_unique_symbol($table->name
-                                                                            . '_fk_'
-                                                                            . join('_', @keys)),
+                                    name             => join('_', $table->name, 'fk', @keys),
                                     fields           => \@keys,
                                     reference_fields => \@refkeys,
                                     reference_table  => $rel_table,
@@ -177,7 +175,7 @@ sub parse {
                   );
                     
                   my $index = $table->add_index(
-                                    name   => _create_unique_symbol(join('_', $table->name, 'idx', @keys)),
+                                    name   => join('_', $table->name, 'idx', @keys),
                                     fields => \@keys,
                                     type   => 'NORMAL',
                   );
@@ -197,31 +195,4 @@ sub parse {
     return 1;
 }
 
-# TODO - is there a reasonable way to pass configuration?
-# Default of 64 comes from mysql's limit.
-our $MAX_SYMBOL_LENGTH    ||= 64;
-our $COLLISION_TAG_LENGTH ||= 8;
-
-# -------------------------------------------------------------------
-# $resolved_name = _create_unique_symbol($desired_name)
-#
-# If desired_name is really long, it will be truncated in a way that
-# has a high probability of leaving it unique.
-# -------------------------------------------------------------------
-sub _create_unique_symbol {
-    my $desired_name = shift;
-    return $desired_name if length $desired_name <= $MAX_SYMBOL_LENGTH;
-
-    my $truncated_name = substr $desired_name, 0, $MAX_SYMBOL_LENGTH - $COLLISION_TAG_LENGTH - 1;
-
-    # Hex isn't the most space-efficient, but it skirts around allowed
-    # charset issues
-    my $digest = sha1_hex($desired_name);
-    my $collision_tag = substr $digest, 0, $COLLISION_TAG_LENGTH;
-
-    return $truncated_name
-         . '_'
-         . $collision_tag;
-}
-
 1;
diff --git a/t/71mysql.t b/t/71mysql.t
index 4aa48bd..90cbb0c 100644
--- a/t/71mysql.t
+++ b/t/71mysql.t
@@ -86,8 +86,9 @@ SKIP: {
 }
 
 ## Can we properly deal with the null search problem?
-
-use Data::Dump qw/dump/;
+##
+## Only way is to do a SET SQL_AUTO_IS_NULL = 0; on connect
+## But I'm not sure if we should do this or not (Ash, 2008/06/03)
 
 NULLINSEARCH: {
     
diff --git a/t/86sqlt.t b/t/86sqlt.t
index f16d29c..300ac37 100644
--- a/t/86sqlt.t
+++ b/t/86sqlt.t
@@ -10,7 +10,7 @@ plan skip_all => 'SQL::Translator required' if $@;
 
 my $schema = DBICTest->init_schema;
 
-plan tests => 160;
+plan tests => 131;
 
 my $translator = SQL::Translator->new( 
   parser_args => {
@@ -203,35 +203,6 @@ my %fk_constraints = (
     },
   ],
 
-  # LongColumns
-  long_columns => [
-    {
-      'display' => 'long_columns->owner',
-      'name' => 'long_columns_fk__64_character_column_aaaaaaaaaaaaaaaaaa_cfc8d5b0',
-      'index_name' => 'long_columns_idx__64_character_column_aaaaaaaaaaaaaaaaa_5050aa42',
-      'selftable' => 'long_columns', 'foreigntable' => 'long_columns',
-      'selfcols' => ['_64_character_column_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'],
-      'foreigncols' => ['lcid'],
-      on_delete => '', on_update => '', deferrable => 1,
-    },
-    {
-      'display' => 'long_columns->owner2',
-      'name' => 'long_columns_fk__32_character_column_aaaaaaaaaaa__32_ch_12bdb9cf',
-      'index_name' => 'long_columns_idx__32_character_column_aaaaaaaaaaa__32_c_18636e21',
-      'selftable' => 'long_columns', 'foreigntable' => 'long_columns',
-      'selfcols' => ['_32_character_column_bbbbbbbbbbb', '_32_character_column_aaaaaaaaaaa'],
-      'foreigncols' => ['_32_character_column_aaaaaaaaaaa', '_32_character_column_bbbbbbbbbbb'],
-      on_delete => '', on_update => '', deferrable => 1,
-    },
-    {
-      'display' => 'long_columns->owner3',
-      'name' => 'long_columns_fk__16_chars_column',
-      'index_name' => 'long_columns_idx__16_chars_column',
-      'selftable' => 'long_columns', 'foreigntable' => 'long_columns',
-      'selfcols' => ['_16_chars_column'], 'foreigncols' => ['_8_chr_c'],
-      on_delete => '', on_update => '', deferrable => 1,
-    },
-  ],
 );
 
 my %unique_constraints = (
@@ -253,29 +224,6 @@ my %unique_constraints = (
     },
   ],
 
-  long_columns => [
-    {
-      'display' => 'long but not quite truncated unique',
-      'name' => 'long_columns__16_chars_column__32_character_column_aaaaaaaaaaa',
-      'table' => 'long_columns', 'cols' => [qw( _32_character_column_aaaaaaaaaaa _16_chars_column )],
-    },
-    {
-      'display' => 'multi column truncated unique',
-      'name' => 'long_columns__8_chr_c__16_chars_column__32_character_co_004ce318',
-      'table' => 'long_columns', 'cols' => [qw( _32_character_column_aaaaaaaaaaa _16_chars_column _8_chr_c )],
-    },
-    {
-      'display' => 'different multi column truncated unique with same base',
-      'name' => 'long_columns__8_chr_c__16_chars_column__32_character_co_25773323',
-      'table' => 'long_columns', 'cols' => [qw( _32_character_column_bbbbbbbbbbb _16_chars_column _8_chr_c )],
-    },
-    {
-      'display' => 'single column truncated unique',
-      'name' => 'long_columns__64_character_column_aaaaaaaaaaaaaaaaaaaaa_0acf5172',
-      'table' => 'long_columns', 'cols' => ['_64_character_column_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'],
-    },
-  ],
-
   # TwoKeyTreeLike
   twokeytreelike => [
     {
@@ -364,6 +312,7 @@ sub get_constraint {
   my %fields = map { $_ => 1 } @$cols;
   my %f_fields = map { $_ => 1 } @$f_cols;
 
+  die "No $table_name" unless $table;
  CONSTRAINT:
   for my $constraint ( $table->get_constraints ) {
     next unless $constraint->type eq $type;
diff --git a/t/lib/DBICTest/Schema.pm b/t/lib/DBICTest/Schema.pm
index d1a86bd..22eddff 100644
--- a/t/lib/DBICTest/Schema.pm
+++ b/t/lib/DBICTest/Schema.pm
@@ -36,10 +36,8 @@ __PACKAGE__->load_classes(qw/
     'CD_to_Producer',
   ),
   qw/SelfRefAlias TreeLike TwoKeyTreeLike Event EventTZ NoPrimaryKey/,
-  qw/Collection CollectionObject TypedObject/,
-  qw/Owners BooksInLibrary/,
+  qw/Collection CollectionObject TypedObject Owners BooksInLibrary/,
   qw/ForceForeign/,
-  qw/LongColumns/,
 );
 
 sub sqlt_deploy_hook {
diff --git a/t/lib/DBICTest/Schema/LongColumns.pm b/t/lib/DBICTest/Schema/LongColumns.pm
deleted file mode 100644
index e0ab829..0000000
--- a/t/lib/DBICTest/Schema/LongColumns.pm
+++ /dev/null
@@ -1,64 +0,0 @@
-package # hide from PAUSE  
-    DBICTest::Schema::LongColumns;
-
-use base qw/DBIx::Class::Core/;
-
-__PACKAGE__->table('long_columns');
-__PACKAGE__->add_columns(
-    'lcid' => {
-        data_type => 'int',
-        is_auto_increment => 1,
-    },
-    '_64_character_column_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' => {
-        data_type => 'int',
-    },
-    '_32_character_column_aaaaaaaaaaa' => {
-        data_type => 'int',
-    },
-    '_32_character_column_bbbbbbbbbbb' => {
-        data_type => 'int',
-    },
-    '_16_chars_column' => {
-        data_type => 'int',
-    },
-    '_8_chr_c' => {
-        data_type => 'int',
-    },
-);
-
-__PACKAGE__->set_primary_key('lcid');
-
-__PACKAGE__->add_unique_constraint([qw( _16_chars_column _32_character_column_aaaaaaaaaaa )]);
-
-__PACKAGE__->add_unique_constraint([qw( _8_chr_c _16_chars_column _32_character_column_aaaaaaaaaaa )]);
-
-__PACKAGE__->add_unique_constraint([qw( _8_chr_c _16_chars_column _32_character_column_bbbbbbbbbbb )]);
-
-__PACKAGE__->add_unique_constraint([qw( _64_character_column_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa )]);
-
-__PACKAGE__->belongs_to(
-    'owner',
-    'DBICTest::Schema::LongColumns',
-    {
-        'foreign.lcid' => 'self._64_character_column_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-    },
-);
-
-__PACKAGE__->belongs_to(
-    'owner2',
-    'DBICTest::Schema::LongColumns',
-    {
-        'foreign._32_character_column_aaaaaaaaaaa' => 'self._32_character_column_bbbbbbbbbbb',
-        'foreign._32_character_column_bbbbbbbbbbb' => 'self._32_character_column_aaaaaaaaaaa',
-    },
-);
-
-__PACKAGE__->belongs_to(
-    'owner3',
-    'DBICTest::Schema::LongColumns',
-    {
-        'foreign._8_chr_c' => 'self._16_chars_column',
-    },
-);
-
-1;