1 package DBIx::Class::Schema::Loader::Base;
5 use base qw/Class::Accessor::Grouped Class::C3::Componentised/;
7 use Carp::Clan qw/^DBIx::Class/;
8 use DBIx::Class::Schema::Loader::RelBuilder;
9 use Data::Dump qw/ dump /;
14 use Lingua::EN::Inflect::Number qw//;
19 our $VERSION = '0.04999_13';
21 __PACKAGE__->mk_group_ro_accessors('simple', qw/
28 additional_base_classes
44 default_resultset_class
47 overwrite_modifications
61 __PACKAGE__->mk_group_accessors('simple', qw/
63 schema_version_to_dump
69 DBIx::Class::Schema::Loader::Base - Base DBIx::Class::Schema::Loader Implementation.
73 See L<DBIx::Class::Schema::Loader>
77 This is the base class for the storage-specific C<DBIx::Class::Schema::*>
78 classes, and implements the common functionality between them.
80 =head1 CONSTRUCTOR OPTIONS
82 These constructor options are the base options for
83 L<DBIx::Class::Schema::Loader/loader_options>. Available constructor options are:
85 =head2 skip_relationships
87 Skip setting up relationships. The default is to attempt the loading
90 =head2 skip_load_external
92 Skip loading of other classes in @INC. The default is to merge all other classes
93 with the same name found in @INC into the schema file we are creating.
97 Static schemas (ones dumped to disk) will, by default, use the new-style 0.05XXX
98 relationship names and singularized Results, unless you're overwriting an
99 existing dump made by a 0.04XXX version of L<DBIx::Class::Schema::Loader>, in
100 which case the backward compatible RelBuilder will be activated, and
101 singularization will be turned off.
107 will disable the backward-compatible RelBuilder and use
108 the new-style relationship names along with singularized Results, even when
109 overwriting a dump made with an earlier version.
111 The option also takes a hashref:
113 naming => { relationships => 'v5', monikers => 'v4' }
121 How to name relationship accessors.
125 How to name Result classes.
135 Latest default style, whatever that happens to be.
139 Version 0.05XXX style.
143 Version 0.04XXX style.
147 Dynamic schemas will always default to the 0.04XXX relationship names and won't
148 singularize Results for backward compatibility, to activate the new RelBuilder
149 and singularization put this in your C<Schema.pm> file:
151 __PACKAGE__->naming('current');
153 Or if you prefer to use 0.05XXX features but insure that nothing breaks in the
154 next major version upgrade:
156 __PACKAGE__->naming('v5');
158 =head2 relationship_attrs
160 Hashref of attributes to pass to each generated relationship, listed
161 by type. Also supports relationship type 'all', containing options to
162 pass to all generated relationships. Attributes set for more specific
163 relationship types override those set in 'all'.
167 relationship_attrs => {
168 all => { cascade_delete => 0 },
169 has_many => { cascade_delete => 1 },
172 will set the C<cascade_delete> option to 0 for all generated relationships,
173 except for C<has_many>, which will have cascade_delete as 1.
175 NOTE: this option is not supported if v4 backward-compatible naming is
176 set either globally (naming => 'v4') or just for relationships.
180 If set to true, each constructive L<DBIx::Class> statement the loader
181 decides to execute will be C<warn>-ed before execution.
185 Set the name of the schema to load (schema in the sense that your database
186 vendor means it). Does not currently support loading more than one schema
191 Only load tables matching regex. Best specified as a qr// regex.
195 Exclude tables matching regex. Best specified as a qr// regex.
199 Overrides the default table name to moniker translation. Can be either
200 a hashref of table keys and moniker values, or a coderef for a translator
201 function taking a single scalar table name argument and returning
202 a scalar moniker. If the hash entry does not exist, or the function
203 returns a false value, the code falls back to default behavior
206 The default behavior is to singularize the table name, and: C<join '', map
207 ucfirst, split /[\W_]+/, lc $table>, which is to say: lowercase everything,
208 split up the table name into chunks anywhere a non-alpha-numeric character
209 occurs, change the case of first letter of each chunk to upper case, and put
210 the chunks back together. Examples:
212 Table Name | Moniker Name
213 ---------------------------
215 luser_group | LuserGroup
216 luser-opts | LuserOpts
218 =head2 inflect_plural
220 Just like L</moniker_map> above (can be hash/code-ref, falls back to default
221 if hash key does not exist or coderef returns false), but acts as a map
222 for pluralizing relationship names. The default behavior is to utilize
223 L<Lingua::EN::Inflect::Number/to_PL>.
225 =head2 inflect_singular
227 As L</inflect_plural> above, but for singularizing relationship names.
228 Default behavior is to utilize L<Lingua::EN::Inflect::Number/to_S>.
230 =head2 schema_base_class
232 Base class for your schema classes. Defaults to 'DBIx::Class::Schema'.
234 =head2 result_base_class
236 Base class for your table classes (aka result classes). Defaults to
239 =head2 additional_base_classes
241 List of additional base classes all of your table classes will use.
243 =head2 left_base_classes
245 List of additional base classes all of your table classes will use
246 that need to be leftmost.
248 =head2 additional_classes
250 List of additional classes which all of your table classes will use.
254 List of additional components to be loaded into all of your table
255 classes. A good example would be C<ResultSetManager>.
257 =head2 resultset_components
259 List of additional ResultSet components to be loaded into your table
260 classes. A good example would be C<AlwaysRS>. Component
261 C<ResultSetManager> will be automatically added to the above
262 C<components> list if this option is set.
264 =head2 use_namespaces
266 Generate result class names suitable for
267 L<DBIx::Class::Schema/load_namespaces> and call that instead of
268 L<DBIx::Class::Schema/load_classes>. When using this option you can also
269 specify any of the options for C<load_namespaces> (i.e. C<result_namespace>,
270 C<resultset_namespace>, C<default_resultset_class>), and they will be added
271 to the call (and the generated result class names adjusted appropriately).
273 =head2 dump_directory
275 This option is designed to be a tool to help you transition from this
276 loader to a manually-defined schema when you decide it's time to do so.
278 The value of this option is a perl libdir pathname. Within
279 that directory this module will create a baseline manual
280 L<DBIx::Class::Schema> module set, based on what it creates at runtime
283 The created schema class will have the same classname as the one on
284 which you are setting this option (and the ResultSource classes will be
285 based on this name as well).
287 Normally you wouldn't hard-code this setting in your schema class, as it
288 is meant for one-time manual usage.
290 See L<DBIx::Class::Schema::Loader/dump_to_dir> for examples of the
291 recommended way to access this functionality.
293 =head2 dump_overwrite
295 Deprecated. See L</really_erase_my_files> below, which does *not* mean
296 the same thing as the old C<dump_overwrite> setting from previous releases.
298 =head2 really_erase_my_files
300 Default false. If true, Loader will unconditionally delete any existing
301 files before creating the new ones from scratch when dumping a schema to disk.
303 The default behavior is instead to only replace the top portion of the
304 file, up to and including the final stanza which contains
305 C<# DO NOT MODIFY THIS OR ANYTHING ABOVE!>
306 leaving any customizations you placed after that as they were.
308 When C<really_erase_my_files> is not set, if the output file already exists,
309 but the aforementioned final stanza is not found, or the checksum
310 contained there does not match the generated contents, Loader will
311 croak and not touch the file.
313 You should really be using version control on your schema classes (and all
314 of the rest of your code for that matter). Don't blame me if a bug in this
315 code wipes something out when it shouldn't have, you've been warned.
317 =head2 overwrite_modifications
319 Default false. If false, when updating existing files, Loader will
320 refuse to modify any Loader-generated code that has been modified
321 since its last run (as determined by the checksum Loader put in its
324 If true, Loader will discard any manual modifications that have been
325 made to Loader-generated code.
327 Again, you should be using version control on your schema classes. Be
328 careful with this option.
332 None of these methods are intended for direct invocation by regular
333 users of L<DBIx::Class::Schema::Loader>. Anything you can find here
334 can also be found via standard L<DBIx::Class::Schema> methods somehow.
338 use constant CURRENT_V => 'v5';
340 # ensure that a peice of object data is a valid arrayref, creating
341 # an empty one or encapsulating whatever's there.
342 sub _ensure_arrayref {
347 $self->{$_} = [ $self->{$_} ]
348 unless ref $self->{$_} eq 'ARRAY';
354 Constructor for L<DBIx::Class::Schema::Loader::Base>, used internally
355 by L<DBIx::Class::Schema::Loader>.
360 my ( $class, %args ) = @_;
362 my $self = { %args };
364 bless $self => $class;
366 $self->_ensure_arrayref(qw/additional_classes
367 additional_base_classes
373 push(@{$self->{components}}, 'ResultSetManager')
374 if @{$self->{resultset_components}};
376 $self->{monikers} = {};
377 $self->{classes} = {};
378 $self->{_upgrading_classes} = {};
380 $self->{schema_class} ||= ( ref $self->{schema} || $self->{schema} );
381 $self->{schema} ||= $self->{schema_class};
383 croak "dump_overwrite is deprecated. Please read the"
384 . " DBIx::Class::Schema::Loader::Base documentation"
385 if $self->{dump_overwrite};
387 $self->{dynamic} = ! $self->{dump_directory};
388 $self->{temp_directory} ||= File::Temp::tempdir( 'dbicXXXX',
393 $self->{dump_directory} ||= $self->{temp_directory};
395 $self->version_to_dump($DBIx::Class::Schema::Loader::VERSION);
396 $self->schema_version_to_dump($DBIx::Class::Schema::Loader::VERSION);
398 if ((not ref $self->naming) && defined $self->naming) {
399 my $naming_ver = $self->naming;
401 relationships => $naming_ver,
402 monikers => $naming_ver,
407 for (values %{ $self->naming }) {
408 $_ = CURRENT_V if $_ eq 'current';
411 $self->{naming} ||= {};
413 $self->_check_back_compat;
418 sub _check_back_compat {
421 # dynamic schemas will always be in 0.04006 mode, unless overridden
422 if ($self->dynamic) {
423 # just in case, though no one is likely to dump a dynamic schema
424 $self->schema_version_to_dump('0.04006');
426 if (not %{ $self->naming }) {
427 warn <<EOF unless $ENV{SCHEMA_LOADER_BACKCOMPAT};
429 Dynamic schema detected, will run in 0.04006 mode.
431 Set the 'naming' attribute or the SCHEMA_LOADER_BACKCOMPAT environment variable
432 to disable this warning.
434 See perldoc DBIx::Class::Schema::Loader::Manual::UpgradingFromV4 for more
439 $self->_upgrading_from('v4');
442 $self->naming->{relationships} ||= 'v4';
443 $self->naming->{monikers} ||= 'v4';
448 # otherwise check if we need backcompat mode for a static schema
449 my $filename = $self->_get_dump_filename($self->schema_class);
450 return unless -e $filename;
452 open(my $fh, '<', $filename)
453 or croak "Cannot open '$filename' for reading: $!";
456 if (/^# Created by DBIx::Class::Schema::Loader v((\d+)\.(\d+))/) {
459 # XXX when we go past .0 this will need fixing
460 my ($v) = $real_ver =~ /([1-9])/;
463 last if $v eq CURRENT_V || $real_ver =~ /^0\.\d\d999/;
465 if (not %{ $self->naming }) {
466 warn <<"EOF" unless $ENV{SCHEMA_LOADER_BACKCOMPAT};
468 Version $real_ver static schema detected, turning on backcompat mode.
470 Set the 'naming' attribute or the SCHEMA_LOADER_BACKCOMPAT environment variable
471 to disable this warning.
473 See perldoc DBIx::Class::Schema::Loader::Manual::UpgradingFromV4 for more
478 $self->_upgrading_from($v);
482 $self->naming->{relationships} ||= $v;
483 $self->naming->{monikers} ||= $v;
485 $self->schema_version_to_dump($real_ver);
493 sub _find_file_in_inc {
494 my ($self, $file) = @_;
496 foreach my $prefix (@INC) {
497 my $fullpath = File::Spec->catfile($prefix, $file);
498 return $fullpath if -f $fullpath
499 and Cwd::abs_path($fullpath) ne
500 (Cwd::abs_path(File::Spec->catfile($self->dump_directory, $file)) || '');
507 my ($self, $class) = @_;
509 my $class_path = $class;
510 $class_path =~ s{::}{/}g;
511 $class_path .= '.pm';
516 sub _find_class_in_inc {
517 my ($self, $class) = @_;
519 return $self->_find_file_in_inc($self->_class_path($class));
522 sub _rewrite_old_classnames {
523 my ($self, $code) = @_;
525 return $code unless $self->_upgrading_from;
527 my %old_classes = reverse %{ $self->_upgrading_classes };
529 my $re = join '|', keys %old_classes;
532 $code =~ s/$re/$old_classes{$1} || $1/eg;
538 my ($self, $class) = @_;
540 return if $self->{skip_load_external};
542 # so that we don't load our own classes, under any circumstances
543 local *INC = [ grep $_ ne $self->dump_directory, @INC ];
545 my $real_inc_path = $self->_find_class_in_inc($class);
547 my $old_class = $self->_upgrading_classes->{$class}
548 if $self->_upgrading_from;
550 my $old_real_inc_path = $self->_find_class_in_inc($old_class)
551 if $old_class && $old_class ne $class;
553 return unless $real_inc_path || $old_real_inc_path;
555 if ($real_inc_path) {
556 # If we make it to here, we loaded an external definition
557 warn qq/# Loaded external class definition for '$class'\n/
560 open(my $fh, '<', $real_inc_path)
561 or croak "Failed to open '$real_inc_path' for reading: $!";
562 my $code = do { local $/; <$fh> };
564 or croak "Failed to close $real_inc_path: $!";
565 $code = $self->_rewrite_old_classnames($code);
567 if ($self->dynamic) { # load the class too
568 # kill redefined warnings
569 my $warn_handler = $SIG{__WARN__} || sub { warn @_ };
570 local $SIG{__WARN__} = sub {
572 unless $_[0] =~ /^Subroutine \S+ redefined/;
578 $self->_ext_stmt($class,
579 qq|# These lines were loaded from '$real_inc_path' found in \@INC.\n|
580 .qq|# They are now part of the custom portion of this file\n|
581 .qq|# for you to hand-edit. If you do not either delete\n|
582 .qq|# this section or remove that file from \@INC, this section\n|
583 .qq|# will be repeated redundantly when you re-create this\n|
584 .qq|# file again via Loader!\n|
587 $self->_ext_stmt($class, $code);
588 $self->_ext_stmt($class,
589 qq|# End of lines loaded from '$real_inc_path' |
593 if ($old_real_inc_path) {
594 open(my $fh, '<', $old_real_inc_path)
595 or croak "Failed to open '$old_real_inc_path' for reading: $!";
596 $self->_ext_stmt($class, <<"EOF");
598 # These lines were loaded from '$old_real_inc_path',
599 # based on the Result class name that would have been created by an 0.04006
600 # version of the Loader. For a static schema, this happens only once during
605 local ($/, @ARGV) = (undef, $old_real_inc_path); <>
607 $code = $self->_rewrite_old_classnames($code);
609 if ($self->dynamic) {
612 Detected external content in '$old_real_inc_path', a class name that would have
613 been used by an 0.04006 version of the Loader.
615 * PLEASE RENAME THIS CLASS: from '$old_class' to '$class', as that is the
616 new name of the Result.
618 # kill redefined warnings
619 my $warn_handler = $SIG{__WARN__} || sub { warn @_ };
620 local $SIG{__WARN__} = sub {
622 unless $_[0] =~ /^Subroutine \S+ redefined/;
629 $self->_ext_stmt($class, $code);
630 $self->_ext_stmt($class,
631 qq|# End of lines loaded from '$old_real_inc_path' |
638 Does the actual schema-construction work.
645 $self->_load_tables($self->_tables_list);
652 Rescan the database for newly added tables. Does
653 not process drops or changes. Returns a list of
654 the newly added table monikers.
656 The schema argument should be the schema class
657 or object to be affected. It should probably
658 be derived from the original schema_class used
664 my ($self, $schema) = @_;
666 $self->{schema} = $schema;
667 $self->_relbuilder->{schema} = $schema;
670 my @current = $self->_tables_list;
671 foreach my $table ($self->_tables_list) {
672 if(!exists $self->{_tables}->{$table}) {
673 push(@created, $table);
677 my $loaded = $self->_load_tables(@created);
679 return map { $self->monikers->{$_} } @$loaded;
683 no warnings 'uninitialized';
686 return if $self->{skip_relationships};
688 if ($self->naming->{relationships} eq 'v4') {
689 require DBIx::Class::Schema::Loader::RelBuilder::Compat::v0_040;
690 return $self->{relbuilder} ||=
691 DBIx::Class::Schema::Loader::RelBuilder::Compat::v0_040->new(
692 $self->schema, $self->inflect_plural, $self->inflect_singular
696 $self->{relbuilder} ||= DBIx::Class::Schema::Loader::RelBuilder->new (
698 $self->inflect_plural,
699 $self->inflect_singular,
700 $self->relationship_attrs,
705 my ($self, @tables) = @_;
707 # First, use _tables_list with constraint and exclude
708 # to get a list of tables to operate on
710 my $constraint = $self->constraint;
711 my $exclude = $self->exclude;
713 @tables = grep { /$constraint/ } @tables if $constraint;
714 @tables = grep { ! /$exclude/ } @tables if $exclude;
716 # Save the new tables to the tables list
718 $self->{_tables}->{$_} = 1;
721 $self->_make_src_class($_) for @tables;
722 $self->_setup_src_meta($_) for @tables;
724 if(!$self->skip_relationships) {
725 # The relationship loader needs a working schema
727 local $self->{dump_directory} = $self->{temp_directory};
728 $self->_reload_classes(\@tables);
729 $self->_load_relationships($_) for @tables;
732 # Remove that temp dir from INC so it doesn't get reloaded
733 @INC = grep $_ ne $self->dump_directory, @INC;
736 $self->_load_external($_)
737 for map { $self->classes->{$_} } @tables;
739 # Reload without unloading first to preserve any symbols from external
741 $self->_reload_classes(\@tables, 0);
743 # Drop temporary cache
744 delete $self->{_cache};
749 sub _reload_classes {
750 my ($self, $tables, $unload) = @_;
752 my @tables = @$tables;
753 $unload = 1 unless defined $unload;
755 # so that we don't repeat custom sections
756 @INC = grep $_ ne $self->dump_directory, @INC;
758 $self->_dump_to_dir(map { $self->classes->{$_} } @tables);
760 unshift @INC, $self->dump_directory;
763 my %have_source = map { $_ => $self->schema->source($_) }
764 $self->schema->sources;
766 for my $table (@tables) {
767 my $moniker = $self->monikers->{$table};
768 my $class = $self->classes->{$table};
771 no warnings 'redefine';
772 local *Class::C3::reinitialize = sub {};
775 Class::Unload->unload($class) if $unload;
776 my ($source, $resultset_class);
778 ($source = $have_source{$moniker})
779 && ($resultset_class = $source->resultset_class)
780 && ($resultset_class ne 'DBIx::Class::ResultSet')
782 my $has_file = Class::Inspector->loaded_filename($resultset_class);
783 Class::Unload->unload($resultset_class) if $unload;
784 $self->_reload_class($resultset_class) if $has_file;
786 $self->_reload_class($class);
788 push @to_register, [$moniker, $class];
791 Class::C3->reinitialize;
793 $self->schema->register_class(@$_);
797 # We use this instead of ensure_class_loaded when there are package symbols we
800 my ($self, $class) = @_;
802 my $class_path = $self->_class_path($class);
803 delete $INC{ $class_path };
805 # kill redefined warnings
806 my $warn_handler = $SIG{__WARN__} || sub { warn @_ };
807 local $SIG{__WARN__} = sub {
809 unless $_[0] =~ /^Subroutine \S+ redefined/;
811 eval "require $class;";
814 sub _get_dump_filename {
815 my ($self, $class) = (@_);
818 return $self->dump_directory . q{/} . $class . q{.pm};
821 sub _ensure_dump_subdirs {
822 my ($self, $class) = (@_);
824 my @name_parts = split(/::/, $class);
825 pop @name_parts; # we don't care about the very last element,
826 # which is a filename
828 my $dir = $self->dump_directory;
831 mkdir($dir) or croak "mkdir('$dir') failed: $!";
833 last if !@name_parts;
834 $dir = File::Spec->catdir($dir, shift @name_parts);
839 my ($self, @classes) = @_;
841 my $schema_class = $self->schema_class;
842 my $schema_base_class = $self->schema_base_class || 'DBIx::Class::Schema';
844 my $target_dir = $self->dump_directory;
845 warn "Dumping manual schema for $schema_class to directory $target_dir ...\n"
846 unless $self->{dynamic} or $self->{quiet};
849 qq|package $schema_class;\n\n|
850 . qq|# Created by DBIx::Class::Schema::Loader\n|
851 . qq|# DO NOT MODIFY THE FIRST PART OF THIS FILE\n\n|
852 . qq|use strict;\nuse warnings;\n\n|
853 . qq|use base '$schema_base_class';\n\n|;
855 if ($self->use_namespaces) {
856 $schema_text .= qq|__PACKAGE__->load_namespaces|;
857 my $namespace_options;
858 for my $attr (qw(result_namespace
860 default_resultset_class)) {
862 $namespace_options .= qq| $attr => '| . $self->$attr . qq|',\n|
865 $schema_text .= qq|(\n$namespace_options)| if $namespace_options;
866 $schema_text .= qq|;\n|;
869 $schema_text .= qq|__PACKAGE__->load_classes;\n|;
873 local $self->{version_to_dump} = $self->schema_version_to_dump;
874 $self->_write_classfile($schema_class, $schema_text, 1);
877 my $result_base_class = $self->result_base_class || 'DBIx::Class::Core';
879 foreach my $src_class (@classes) {
881 qq|package $src_class;\n\n|
882 . qq|# Created by DBIx::Class::Schema::Loader\n|
883 . qq|# DO NOT MODIFY THE FIRST PART OF THIS FILE\n\n|
884 . qq|use strict;\nuse warnings;\n\n|
885 . qq|use base '$result_base_class';\n\n|;
887 $self->_write_classfile($src_class, $src_text);
890 warn "Schema dump completed.\n" unless $self->{dynamic} or $self->{quiet};
895 my ($self, $version, $ts) = @_;
896 return qq|\n\n# Created by DBIx::Class::Schema::Loader|
899 . qq|\n# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:|;
902 sub _write_classfile {
903 my ($self, $class, $text, $is_schema) = @_;
905 my $filename = $self->_get_dump_filename($class);
906 $self->_ensure_dump_subdirs($class);
908 if (-f $filename && $self->really_erase_my_files) {
909 warn "Deleting existing file '$filename' due to "
910 . "'really_erase_my_files' setting\n" unless $self->{quiet};
914 my ($custom_content, $old_md5, $old_ver, $old_ts) = $self->_get_custom_content($class, $filename);
916 if (my $old_class = $self->_upgrading_classes->{$class}) {
917 my $old_filename = $self->_get_dump_filename($old_class);
919 my ($old_custom_content) = $self->_get_custom_content(
920 $old_class, $old_filename, 0 # do not add default comment
923 $old_custom_content =~ s/\n\n# You can replace.*\n1;\n//;
925 if ($old_custom_content) {
927 "\n" . $old_custom_content . "\n" . $custom_content;
930 unlink $old_filename;
933 $custom_content = $self->_rewrite_old_classnames($custom_content);
936 for @{$self->{_dump_storage}->{$class} || []};
938 # Check and see if the dump is infact differnt
942 $compare_to = $text . $self->_sig_comment($old_ver, $old_ts);
945 if (Digest::MD5::md5_base64($compare_to) eq $old_md5) {
946 return unless $self->_upgrading_from && $is_schema;
950 $text .= $self->_sig_comment(
951 $self->version_to_dump,
952 POSIX::strftime('%Y-%m-%d %H:%M:%S', localtime)
955 open(my $fh, '>', $filename)
956 or croak "Cannot open '$filename' for writing: $!";
958 # Write the top half and its MD5 sum
959 print $fh $text . Digest::MD5::md5_base64($text) . "\n";
961 # Write out anything loaded via external partial class file in @INC
963 for @{$self->{_ext_storage}->{$class} || []};
965 # Write out any custom content the user has added
966 print $fh $custom_content;
969 or croak "Error closing '$filename': $!";
972 sub _default_custom_content {
973 return qq|\n\n# You can replace this text with custom|
974 . qq| content, and it will be preserved on regeneration|
978 sub _get_custom_content {
979 my ($self, $class, $filename, $add_default) = @_;
981 $add_default = 1 unless defined $add_default;
983 return ($self->_default_custom_content) if ! -f $filename;
985 open(my $fh, '<', $filename)
986 or croak "Cannot open '$filename' for reading: $!";
989 qr{^(# DO NOT MODIFY THIS OR ANYTHING ABOVE! md5sum:)([A-Za-z0-9/+]{22})\n};
992 my ($md5, $ts, $ver);
994 if(!$md5 && /$mark_re/) {
998 # Pull out the previous version and timestamp
999 ($ver, $ts) = $buffer =~ m/# Created by DBIx::Class::Schema::Loader v(.*?) @ (.*?)$/s;
1002 croak "Checksum mismatch in '$filename', the auto-generated part of the file has been modified outside of this loader. Aborting.\nIf you want to overwrite these modifications, set the 'overwrite_modifications' loader option.\n"
1003 if !$self->overwrite_modifications && Digest::MD5::md5_base64($buffer) ne $md5;
1012 croak "Cannot not overwrite '$filename' without 'really_erase_my_files',"
1013 . " it does not appear to have been generated by Loader"
1016 # Default custom content:
1017 $buffer ||= $self->_default_custom_content if $add_default;
1019 return ($buffer, $md5, $ver, $ts);
1027 warn "$target: use $_;" if $self->debug;
1028 $self->_raw_stmt($target, "use $_;");
1035 my $schema_class = $self->schema_class;
1037 my $blist = join(q{ }, @_);
1038 warn "$target: use base qw/ $blist /;" if $self->debug && @_;
1039 $self->_raw_stmt($target, "use base qw/ $blist /;") if @_;
1042 # Create class with applicable bases, setup monikers, etc
1043 sub _make_src_class {
1044 my ($self, $table) = @_;
1046 my $schema = $self->schema;
1047 my $schema_class = $self->schema_class;
1049 my $table_moniker = $self->_table2moniker($table);
1050 my @result_namespace = ($schema_class);
1051 if ($self->use_namespaces) {
1052 my $result_namespace = $self->result_namespace || 'Result';
1053 if ($result_namespace =~ /^\+(.*)/) {
1054 # Fully qualified namespace
1055 @result_namespace = ($1)
1058 # Relative namespace
1059 push @result_namespace, $result_namespace;
1062 my $table_class = join(q{::}, @result_namespace, $table_moniker);
1064 if (my $upgrading_v = $self->_upgrading_from) {
1065 local $self->naming->{monikers} = $upgrading_v;
1067 my $old_class = join(q{::}, @result_namespace,
1068 $self->_table2moniker($table));
1070 $self->_upgrading_classes->{$table_class} = $old_class
1071 unless $table_class eq $old_class;
1074 my $table_normalized = lc $table;
1075 $self->classes->{$table} = $table_class;
1076 $self->classes->{$table_normalized} = $table_class;
1077 $self->monikers->{$table} = $table_moniker;
1078 $self->monikers->{$table_normalized} = $table_moniker;
1080 $self->_use ($table_class, @{$self->additional_classes});
1081 $self->_inject($table_class, @{$self->left_base_classes});
1083 if (my @components = @{ $self->components }) {
1084 $self->_dbic_stmt($table_class, 'load_components', @components);
1087 $self->_dbic_stmt($table_class, 'load_resultset_components', @{$self->resultset_components})
1088 if @{$self->resultset_components};
1089 $self->_inject($table_class, @{$self->additional_base_classes});
1092 # Set up metadata (cols, pks, etc)
1093 sub _setup_src_meta {
1094 my ($self, $table) = @_;
1096 my $schema = $self->schema;
1097 my $schema_class = $self->schema_class;
1099 my $table_class = $self->classes->{$table};
1100 my $table_moniker = $self->monikers->{$table};
1102 my $table_name = $table;
1103 my $name_sep = $self->schema->storage->sql_maker->name_sep;
1105 if ($name_sep && $table_name =~ /\Q$name_sep\E/) {
1106 $table_name = \ $self->_quote_table_name($table_name);
1109 $self->_dbic_stmt($table_class,'table',$table_name);
1111 my $cols = $self->_table_columns($table);
1113 eval { $col_info = $self->_columns_info_for($table) };
1115 $self->_dbic_stmt($table_class,'add_columns',@$cols);
1118 if ($self->_is_case_sensitive) {
1119 for my $col (keys %$col_info) {
1120 $col_info->{$col}{accessor} = lc $col
1121 if $col ne lc($col);
1124 $col_info = { map { lc($_), $col_info->{$_} } keys %$col_info };
1127 my $fks = $self->_table_fk_info($table);
1129 for my $fkdef (@$fks) {
1130 for my $col (@{ $fkdef->{local_columns} }) {
1131 $col_info->{$col}{is_foreign_key} = 1;
1137 map { $_, ($col_info->{$_}||{}) } @$cols
1141 my %uniq_tag; # used to eliminate duplicate uniqs
1143 my $pks = $self->_table_pk_info($table) || [];
1144 @$pks ? $self->_dbic_stmt($table_class,'set_primary_key',@$pks)
1145 : carp("$table has no primary key");
1146 $uniq_tag{ join("\0", @$pks) }++ if @$pks; # pk is a uniq
1148 my $uniqs = $self->_table_uniq_info($table) || [];
1150 my ($name, $cols) = @$_;
1151 next if $uniq_tag{ join("\0", @$cols) }++; # skip duplicates
1152 $self->_dbic_stmt($table_class,'add_unique_constraint', $name, $cols);
1159 Returns a sorted list of loaded tables, using the original database table
1167 return keys %{$self->_tables};
1170 # Make a moniker from a table
1171 sub _default_table2moniker {
1172 no warnings 'uninitialized';
1173 my ($self, $table) = @_;
1175 if ($self->naming->{monikers} eq 'v4') {
1176 return join '', map ucfirst, split /[\W_]+/, lc $table;
1179 return join '', map ucfirst, split /[\W_]+/,
1180 Lingua::EN::Inflect::Number::to_S(lc $table);
1183 sub _table2moniker {
1184 my ( $self, $table ) = @_;
1188 if( ref $self->moniker_map eq 'HASH' ) {
1189 $moniker = $self->moniker_map->{$table};
1191 elsif( ref $self->moniker_map eq 'CODE' ) {
1192 $moniker = $self->moniker_map->($table);
1195 $moniker ||= $self->_default_table2moniker($table);
1200 sub _load_relationships {
1201 my ($self, $table) = @_;
1203 my $tbl_fk_info = $self->_table_fk_info($table);
1204 foreach my $fkdef (@$tbl_fk_info) {
1205 $fkdef->{remote_source} =
1206 $self->monikers->{delete $fkdef->{remote_table}};
1208 my $tbl_uniq_info = $self->_table_uniq_info($table);
1210 my $local_moniker = $self->monikers->{$table};
1211 my $rel_stmts = $self->_relbuilder->generate_code($local_moniker, $tbl_fk_info, $tbl_uniq_info);
1213 foreach my $src_class (sort keys %$rel_stmts) {
1214 my $src_stmts = $rel_stmts->{$src_class};
1215 foreach my $stmt (@$src_stmts) {
1216 $self->_dbic_stmt($src_class,$stmt->{method},@{$stmt->{args}});
1221 # Overload these in driver class:
1223 # Returns an arrayref of column names
1224 sub _table_columns { croak "ABSTRACT METHOD" }
1226 # Returns arrayref of pk col names
1227 sub _table_pk_info { croak "ABSTRACT METHOD" }
1229 # Returns an arrayref of uniqs [ [ foo => [ col1, col2 ] ], [ bar => [ ... ] ] ]
1230 sub _table_uniq_info { croak "ABSTRACT METHOD" }
1232 # Returns an arrayref of foreign key constraints, each
1233 # being a hashref with 3 keys:
1234 # local_columns (arrayref), remote_columns (arrayref), remote_table
1235 sub _table_fk_info { croak "ABSTRACT METHOD" }
1237 # Returns an array of lower case table names
1238 sub _tables_list { croak "ABSTRACT METHOD" }
1240 # Execute a constructive DBIC class method, with debug/dump_to_dir hooks.
1246 # generate the pod for this statement, storing it with $self->_pod
1247 $self->_make_pod( $class, $method, @_ );
1249 my $args = dump(@_);
1250 $args = '(' . $args . ')' if @_ < 2;
1251 my $stmt = $method . $args . q{;};
1253 warn qq|$class\->$stmt\n| if $self->debug;
1254 $self->_raw_stmt($class, '__PACKAGE__->' . $stmt);
1258 # generates the accompanying pod for a DBIC class method statement,
1259 # storing it with $self->_pod
1265 if ( $method eq 'table' ) {
1267 $self->_pod( $class, "=head1 NAME" );
1268 my $table_descr = $class;
1269 if ( $self->can('_table_comment') ) {
1270 my $comment = $self->_table_comment($table);
1271 $table_descr .= " - " . $comment if $comment;
1273 $self->{_class2table}{ $class } = $table;
1274 $self->_pod( $class, $table_descr );
1275 $self->_pod_cut( $class );
1276 } elsif ( $method eq 'add_columns' ) {
1277 $self->_pod( $class, "=head1 ACCESSORS" );
1278 my $col_counter = 0;
1280 while( my ($name,$attrs) = splice @cols,0,2 ) {
1282 $self->_pod( $class, '=head2 ' . $name );
1283 $self->_pod( $class,
1285 my $s = $attrs->{$_};
1286 $s = !defined $s ? 'undef' :
1287 length($s) == 0 ? '(empty string)' :
1291 } sort keys %$attrs,
1294 if( $self->can('_column_comment')
1295 and my $comment = $self->_column_comment( $self->{_class2table}{$class}, $col_counter)
1297 $self->_pod( $class, $comment );
1300 $self->_pod_cut( $class );
1301 } elsif ( $method =~ /^(belongs_to|has_many|might_have)$/ ) {
1302 $self->_pod( $class, "=head1 RELATIONS" ) unless $self->{_relations_started} { $class } ;
1303 my ( $accessor, $rel_class ) = @_;
1304 $self->_pod( $class, "=head2 $accessor" );
1305 $self->_pod( $class, 'Type: ' . $method );
1306 $self->_pod( $class, "Related object: L<$rel_class>" );
1307 $self->_pod_cut( $class );
1308 $self->{_relations_started} { $class } = 1;
1312 # Stores a POD documentation
1314 my ($self, $class, $stmt) = @_;
1315 $self->_raw_stmt( $class, "\n" . $stmt );
1319 my ($self, $class ) = @_;
1320 $self->_raw_stmt( $class, "\n=cut\n" );
1324 # Store a raw source line for a class (for dumping purposes)
1326 my ($self, $class, $stmt) = @_;
1327 push(@{$self->{_dump_storage}->{$class}}, $stmt);
1330 # Like above, but separately for the externally loaded stuff
1332 my ($self, $class, $stmt) = @_;
1333 push(@{$self->{_ext_storage}->{$class}}, $stmt);
1336 sub _quote_table_name {
1337 my ($self, $table) = @_;
1339 my $qt = $self->schema->storage->sql_maker->quote_char;
1341 return $table unless $qt;
1344 return $qt->[0] . $table . $qt->[1];
1347 return $qt . $table . $qt;
1350 sub _is_case_sensitive { 0 }
1352 # remove the dump dir from @INC on destruction
1356 @INC = grep $_ ne $self->dump_directory, @INC;
1361 Returns a hashref of loaded table to moniker mappings. There will
1362 be two entries for each table, the original name and the "normalized"
1363 name, in the case that the two are different (such as databases
1364 that like uppercase table names, or preserve your original mixed-case
1365 definitions, or what-have-you).
1369 Returns a hashref of table to class mappings. In some cases it will
1370 contain multiple entries per table for the original and normalized table
1371 names, as above in L</monikers>.
1375 L<DBIx::Class::Schema::Loader>
1379 See L<DBIx::Class::Schema::Loader/AUTHOR> and L<DBIx::Class::Schema::Loader/CONTRIBUTORS>.
1383 This library is free software; you can redistribute it and/or modify it under
1384 the same terms as Perl itself.