DBIx/Class/Schema.pm

filter: Statementstmt 91.1% 330 / 362 Branchbran 71.7% 76 / 106 Conditioncond 61.2% 49 / 80 MC/DCmcdc 30.6% 15 / 49 Subroutinesub 85.7% 60 / 70 Podpod 97.0% 33 / 34 totaltotal 80.3% 563 / 701 CC 102 SCAR 20.1
CC
102
Cov
83%
load_namespaces
25.2
load_classes
13.3
_normalize_storage_type
12.0
CRAP 7.4
« DBIx/Class/Storage/DBI/Sybase/Microsoft_SQL_Server.pm ↑ Summary DBIx/Class/CDBICompat/ColumnsAsHash.pm »
1 package DBIx::Class::Schema;
2  
3 326 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
4 326 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
5  
6 326 ▶use base 'DBIx::Class';
Subroutine BEGIN: called CC=1 SCAR=0.0
7  
8 326 ▶use DBIx::Class::Carp;
Subroutine BEGIN: called CC=1 SCAR=0.0
9 326 ▶use Try::Tiny;
Subroutine BEGIN: called CC=1 SCAR=0.0
10 326 ▶use Scalar::Util qw/weaken blessed/;
Subroutine BEGIN: called CC=1 SCAR=0.0
11 326 ▶use DBIx::Class::_Util qw(refcount quote_sub is_exception scope_guard);
Subroutine BEGIN: called CC=1 SCAR=0.0
12 326 ▶use Devel::GlobalDestruction;
Subroutine BEGIN: called CC=1 SCAR=0.0
13 326 ▶use namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
14  
15 326 __PACKAGE__->mk_classdata('class_mappings' => {});
16 326 __PACKAGE__->mk_classdata('source_registrations' => {});
17 326 __PACKAGE__->mk_classdata('storage_type' => '::DBI');
18 326 __PACKAGE__->mk_classdata('storage');
19 326 __PACKAGE__->mk_classdata('exception_action');
20 326 ▶__PACKAGE__->mk_classdata('stacktrace' => $ENV{DBIC_TRACE} || 0);
Condition50%1/2
$ENV{'DBIC_TRACE'} || 0
l!l
0326
MC/DC0%0/1
$ENV{'DBIC_TRACE'} || 0
$ENV{'DBIC_TRACE'}
Truth table50%1/2
A
A= $ENV{'DBIC_TRACE'}
Aresult
11
00
21 326 __PACKAGE__->mk_classdata('default_resultset_attributes' => {});
22  
23 =head1 NAME
24  
25 DBIx::Class::Schema - composable schemas
26  
27 =head1 SYNOPSIS
28  
29 package Library::Schema;
30 use base qw/DBIx::Class::Schema/;
31  
32 # load all Result classes in Library/Schema/Result/
33 __PACKAGE__->load_namespaces();
34  
35 package Library::Schema::Result::CD;
36 use base qw/DBIx::Class::Core/;
37  
38 __PACKAGE__->load_components(qw/InflateColumn::DateTime/); # for example
39 __PACKAGE__->table('cd');
40  
41 # Elsewhere in your code:
42 my $schema1 = Library::Schema->connect(
43 $dsn,
44 $user,
45 $password,
46 { AutoCommit => 1 },
47 );
48  
49 my $schema2 = Library::Schema->connect($coderef_returning_dbh);
50  
51 # fetch objects using Library::Schema::Result::DVD
52 my $resultset = $schema1->resultset('DVD')->search( ... );
53 my @dvd_objects = $schema2->resultset('DVD')->search( ... );
54  
55 =head1 DESCRIPTION
56  
57 Creates database classes based on a schema. This is the recommended way to
58 use L<DBIx::Class> and allows you to use more than one concurrent connection
59 with your classes.
60  
61 NB: If you're used to L<Class::DBI> it's worth reading the L</SYNOPSIS>
62 carefully, as DBIx::Class does things a little differently. Note in
63 particular which module inherits off which.
64  
65 =head1 SETUP METHODS
66  
67 =head2 load_namespaces
68  
69 =over 4
70  
71 =item Arguments: %options?
72  
73 =back
74  
75 package MyApp::Schema;
76 __PACKAGE__->load_namespaces();
77  
78 __PACKAGE__->load_namespaces(
79 result_namespace => 'Res',
80 resultset_namespace => 'RSet',
81 default_resultset_class => '+MyApp::Othernamespace::RSet',
82 );
83  
84 With no arguments, this method uses L<Module::Find> to load all of the
85 Result and ResultSet classes under the namespace of the schema from
86 which it is called. For example, C<My::Schema> will by default find
87 and load Result classes named C<My::Schema::Result::*> and ResultSet
88 classes named C<My::Schema::ResultSet::*>.
89  
90 ResultSet classes are associated with Result class of the same name.
91 For example, C<My::Schema::Result::CD> will get the ResultSet class
92 C<My::Schema::ResultSet::CD> if it is present.
93  
94 Both Result and ResultSet namespaces are configurable via the
95 C<result_namespace> and C<resultset_namespace> options.
96  
97 Another option, C<default_resultset_class> specifies a custom default
98 ResultSet class for Result classes with no corresponding ResultSet.
99  
100 All of the namespace and classname options are by default relative to
101 the schema classname. To specify a fully-qualified name, prefix it
102 with a literal C<+>. For example, C<+Other::NameSpace::Result>.
103  
104 =head3 Warnings
105  
106 You will be warned if ResultSet classes are discovered for which there
107 are no matching Result classes like this:
108  
109 load_namespaces found ResultSet class $classname with no corresponding Result class
110  
111 If a ResultSource instance is found to already have a ResultSet class set
112 using L<resultset_class|DBIx::Class::ResultSource/resultset_class> to some
113 other class, you will be warned like this:
114  
115 We found ResultSet class '$rs_class' for '$result_class', but it seems
116 that you had already set '$result_class' to use '$rs_set' instead
117  
118 =head3 Examples
119  
120 # load My::Schema::Result::CD, My::Schema::Result::Artist,
121 # My::Schema::ResultSet::CD, etc...
122 My::Schema->load_namespaces;
123  
124 # Override everything to use ugly names.
125 # In this example, if there is a My::Schema::Res::Foo, but no matching
126 # My::Schema::RSets::Foo, then Foo will have its
127 # resultset_class set to My::Schema::RSetBase
128 My::Schema->load_namespaces(
129 result_namespace => 'Res',
130 resultset_namespace => 'RSets',
131 default_resultset_class => 'RSetBase',
132 );
133  
134 # Put things in other namespaces
135 My::Schema->load_namespaces(
136 result_namespace => '+Some::Place::Results',
137 resultset_namespace => '+Another::Place::RSets',
138 );
139  
140 To search multiple namespaces for either Result or ResultSet classes,
141 use an arrayref of namespaces for that option. In the case that the
142 same result (or resultset) class exists in multiple namespaces, later
143 entries in the list of namespaces will override earlier ones.
144  
145 My::Schema->load_namespaces(
146 # My::Schema::Results_C::Foo takes precedence over My::Schema::Results_B::Foo :
147 result_namespace => [ 'Results_A', 'Results_B', 'Results_C' ],
148 resultset_namespace => [ '+Some::Place::RSets', 'RSets' ],
149 );
150  
151 =cut
152  
153 # Pre-pends our classname to the given relative classname or
154 # class namespace, unless there is a '+' prefix, which will
155 # be stripped.
156 20 ▶sub _expand_relative_name {
Subroutine _expand_relative_name: called CC=2 SCAR=6.9
157 20 my ($class, $name) = @_;
158 20 ▶ $name =~ s/^\+// or $name = "${class}::${name}";
Branch: 1 branch
BranchTrueFalseTotal
$name =~ s/^\+// or $name = "${class}::$name" 3 17 20
159 20 return $name;
160 }
161  
162 # Finds all modules in the supplied namespace, or if omitted in the
163 # namespace of $class. Untaints all findings as they can be assumed
164 # to be safe
165 16 ▶sub _findallmod {
Subroutine _findallmod: called CC=3 SCAR=13.3
166 16 require Module::Find;
167 return map
168 16 ▶ { $_ =~ /(.+)/ } # untaint result
Condition33%2/6
$_[1] || ref $_[0] || $_[0]
l!l&&r!l&&!r
1600
$_[1] or ref $_[0]
l!l&&r!l&&!r
1600
MC/DC0%0/3
$_[1] || ref $_[0] || $_[0]
$_[1] ref $_[0] $_[0]
Truth table25%1/4
A or B || C
A= $_[1]B= ref $_[0]C= $_[0]
ABCresult
1XX1
01X1
0011
0000
169 Module::Find::findallmod( $_[1] || ref $_[0] || $_[0] )
170 ;
171 }
172  
173 # returns a hash of $shortname => $fullname for every package
174 # found in the given namespaces ($shortname is with the $fullname's
175 # namespace stripped off)
176 16 ▶sub _map_namespaces {
Subroutine _map_namespaces: called CC=3 SCAR=11.0
177 16 my ($me, $namespaces) = @_;
178  
179 16 my %res;
180 16 for my $ns (@$namespaces) {
181 $res{ substr($_, length "${ns}::") } = $_
182 17 for $me->_findallmod($ns);
183 }
184  
185 16 \%res;
186 }
187  
188 # returns the result_source_instance for the passed class/object,
189 # or dies with an informative message (used by load_namespaces)
190 240 ▶sub _ns_get_rsrc_instance {
Subroutine _ns_get_rsrc_instance: called CC=2 SCAR=7.2
191 240 my $me = shift;
192 240 ▶ my $rs_class = ref ($_[0]) || $_[0];
Condition33%1/3
ref $_[0] || $_[0]
l!l&&r!l&&!r
02400
MC/DC0%0/2
ref $_[0] || $_[0]
ref $_[0] $_[0]
Truth table33%1/3
A || B
A= ref $_[0]B= $_[0]
ABresult
1X1
011
000
193  
194 240 ▶ return try {
Subroutine __ANON__: called CC=1 SCAR=0.0
195 240 $rs_class->result_source_instance
196 1 ▶ } catch {
Subroutine __ANON__: called CC=1 SCAR=0.0
197 1 $me->throw_exception (
198 "Attempt to load_namespaces() class $rs_class failed - are you sure this is a real Result Class?: $_"
199 );
200 240 };
201 }
202  
203 8 ▶sub load_namespaces {
Subroutine load_namespaces: called CC=24 SCAR=32.3
Pod documented
204 8 my ($class, %args) = @_;
205  
206 8 ▶ my $result_namespace = delete $args{result_namespace} || 'Result';
Condition100%2/2
delete $args{'result_namespace'} || 'Result'
l!l
44
MC/DC100%1/1
delete $args{'result_namespace'} || 'Result'
delete $args{'result_namespace'}
Truth table100%2/2
A
A= delete $args{'result_namespace'}
Aresult
11
00
207 8 ▶ my $resultset_namespace = delete $args{resultset_namespace} || 'ResultSet';
Condition100%2/2
delete $args{'resultset_namespace'} || 'ResultSet'
l!l
44
MC/DC100%1/1
delete $args{'resultset_namespace'} || 'ResultSet'
delete $args{'resultset_namespace'}
Truth table100%2/2
A
A= delete $args{'resultset_namespace'}
Aresult
11
00
208  
209 8 my $default_resultset_class = delete $args{default_resultset_class};
210  
211 8 ▶ $default_resultset_class = $class->_expand_relative_name($default_resultset_class)
Branch: 1 branch
BranchTrueFalseTotal
if $default_resultset_class 3 5 8
212 if $default_resultset_class;
213  
214 $class->throw_exception('load_namespaces: unknown option(s): '
215 0 ▶ . join(q{,}, map { qq{'$_'} } keys %args))
Branch: 1 branch
BranchTrueFalseTotal
if scalar keys %args 0 8 8
216 if scalar keys %args;
217  
218 8 for my $arg ($result_namespace, $resultset_namespace) {
219 16 ▶ $arg = [ $arg ] if ( $arg and ! ref $arg );
Branch: 1 branch
BranchTrueFalseTotal
if $arg and not ref $arg 15 1 16
Condition66%2/3
$arg and not ref $arg
!ll&&!rl&&r
0115
MC/DC50%1/2
$arg and not ref $arg
$arg not ref $arg
Truth table66%2/3
A and not(B)
A= $argB= not ref $arg
ABresult
0X0
100
111
220  
221 16 ▶ $class->throw_exception('load_namespaces: namespace arguments must be '
Branch: 1 branch
BranchTrueFalseTotal
if ref $arg ne "ARRAY" 0 16 16
222 . 'a simple string or an arrayref')
223 if ref($arg) ne 'ARRAY';
224  
225 16 $_ = $class->_expand_relative_name($_) for (@$arg);
226 }
227  
228 8 my $results_by_source_name = $class->_map_namespaces($result_namespace);
229 8 my $resultsets_by_source_name = $class->_map_namespaces($resultset_namespace);
230  
231 8 my @to_register;
232 {
233 326 ▶ no warnings qw/redefine/;
Subroutine BEGIN: called CC=1 SCAR=0.0
234 8 ▶ local *Class::C3::reinitialize = sub { } if DBIx::Class::_ENV_::OLD_MRO;
Subroutine __ANON__: not called CC=1 SCAR=0.0
235 326 ▶ use warnings qw/redefine/;
Subroutine BEGIN: called CC=1 SCAR=0.0
236  
237 # ensure classes are loaded and attached in inheritance order
238 8 for my $result_class (values %$results_by_source_name) {
239 118 $class->ensure_class_loaded($result_class);
240 }
241 8 my %inh_idx;
242 my @source_names_by_subclass_last = sort {
243  
244 8 ($inh_idx{$a} ||=
245 57 ▶ scalar @{mro::get_linear_isa( $results_by_source_name->{$a} )}
Condition100%2/2
$inh_idx{$b} ||= scalar @{&mro::get_linear_isa($results_by_source_name->{$b});}
l!l
5361
MC/DC100%1/1
$inh_idx{$b} ||= scalar @{&mro::get_linear_isa($results_by_source_name->{$b});}
$inh_idx{$b}
Truth table100%2/2
A
A= $inh_idx{$b}
Aresult
11
00
246 )
247  
248 <=>
249  
250 ($inh_idx{$b} ||=
251 114 ▶ scalar @{mro::get_linear_isa( $results_by_source_name->{$b} )}
Condition100%2/2
$inh_idx{$a} ||= scalar @{&mro::get_linear_isa($results_by_source_name->{$a});}
l!l
5757
MC/DC100%1/1
$inh_idx{$a} ||= scalar @{&mro::get_linear_isa($results_by_source_name->{$a});}
$inh_idx{$a}
Truth table100%2/2
A
A= $inh_idx{$a}
Aresult
11
00
252 )
253  
254 } keys(%$results_by_source_name);
255  
256 8 foreach my $source_name (@source_names_by_subclass_last) {
257 116 my $result_class = $results_by_source_name->{$source_name};
258  
259 116 my $preset_resultset_class = $class->_ns_get_rsrc_instance ($result_class)->resultset_class;
260 115 my $found_resultset_class = delete $resultsets_by_source_name->{$source_name};
261  
262 115 ▶ if($preset_resultset_class && $preset_resultset_class ne 'DBIx::Class::ResultSet') {
Branch: 2 branches
BranchTrueFalseTotal
if ($preset_resultset_class and $preset_resultset_class ne 'DBIx::Class::ResultSet') { } 2 113 115
elsif ($found_resultset_class ||= $default_resultset_class) { } 9 104 113
Condition66%2/3
$preset_resultset_class and $preset_resultset_class ne "DBIx::Class::ResultSet"
!ll&&!rl&&r
01132
MC/DC50%1/2
$preset_resultset_class and $preset_resultset_class ne "DBIx::Class::ResultSet"
$preset_resultset_class $preset_resultset_class ne "DBIx::Class::ResultSet"
Truth table66%2/3
A and B
A= $preset_resultset_classB= $preset_resultset_class ne "DBIx::Class::ResultSet"
ABresult
0X0
100
111
263 2 ▶ if($found_resultset_class && $found_resultset_class ne $preset_resultset_class) {
Branch: 1 branch
BranchTrueFalseTotal
if ($found_resultset_class and $found_resultset_class ne $preset_resultset_class) 0 2 2
Condition33%1/3
$found_resultset_class and $found_resultset_class ne $preset_resultset_class
!ll&&!rl&&r
200
MC/DC0%0/2
$found_resultset_class and $found_resultset_class ne $preset_resultset_class
$found_resultset_class $found_resultset_class ne $preset_resultset_class
Truth table33%1/3
A and B
A= $found_resultset_classB= $found_resultset_class ne $preset_resultset_class
ABresult
0X0
100
111
264 0 carp "We found ResultSet class '$found_resultset_class' matching '$results_by_source_name->{$source_name}', but it seems "
265 . "that you had already set the '$results_by_source_name->{$source_name}' resultet to '$preset_resultset_class' instead";
266 }
267 }
268 # elsif - there may be *no* default_resultset_class, in which case we fallback to
269 # DBIx::Class::Resultset and there is nothing to check
270 ▶ elsif($found_resultset_class ||= $default_resultset_class) {
Condition100%3/3
$found_resultset_class ||= $default_resultset_class
l!l&&r!l&&!r
81104
MC/DC100%2/2
$found_resultset_class ||= $default_resultset_class
$found_resultset_class $default_resultset_class
Truth table100%3/3
A ||= B
A= $found_resultset_classB= $default_resultset_class
ABresult
1X1
011
000
271 9 $class->ensure_class_loaded($found_resultset_class);
272 9 ▶ if(!$found_resultset_class->isa("DBIx::Class::ResultSet")) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($found_resultset_class->isa("DBIx::Class::ResultSet")) 2 7 9
273 2 carp "load_namespaces found ResultSet class '$found_resultset_class' that does not subclass DBIx::Class::ResultSet";
274 }
275  
276 9 $class->_ns_get_rsrc_instance ($result_class)->resultset_class($found_resultset_class);
277 }
278  
279 115 ▶ my $source_name = $class->_ns_get_rsrc_instance ($result_class)->source_name || $source_name;
Condition33%1/3
$class->_ns_get_rsrc_instance($result_class)->source_name || $source_name
l!l&&r!l&&!r
01150
MC/DC0%0/2
$class->_ns_get_rsrc_instance($result_class)->source_name || $source_name
$class->_ns_get_rsrc_instance($result_class)->source_name $source_name
Truth table33%1/3
A || B
A= $class->_ns_get_rsrc_instance($result_class)->source_nameB= $source_name
ABresult
1X1
011
000
280  
281 115 push(@to_register, [ $source_name, $result_class ]);
282 }
283 }
284  
285 7 foreach (sort keys %$resultsets_by_source_name) {
286 4 carp "load_namespaces found ResultSet class '$resultsets_by_source_name->{$_}' "
287 .'with no corresponding Result class';
288 }
289  
290 7 Class::C3->reinitialize if DBIx::Class::_ENV_::OLD_MRO;
291  
292 7 $class->register_class(@$_) for (@to_register);
293  
294 7 return;
295 }
296  
297 =head2 load_classes
298  
299 =over 4
300  
301 =item Arguments: @classes?, { $namespace => [ @classes ] }+
302  
303 =back
304  
305 L</load_classes> is an alternative method to L</load_namespaces>, both of
306 which serve similar purposes, each with different advantages and disadvantages.
307 In the general case you should use L</load_namespaces>, unless you need to
308 be able to specify that only specific classes are loaded at runtime.
309  
310 With no arguments, this method uses L<Module::Find> to find all classes under
311 the schema's namespace. Otherwise, this method loads the classes you specify
312 (using L<use>), and registers them (using L</"register_class">).
313  
314 It is possible to comment out classes with a leading C<#>, but note that perl
315 will think it's a mistake (trying to use a comment in a qw list), so you'll
316 need to add C<no warnings 'qw';> before your load_classes call.
317  
318 If any classes found do not appear to be Result class files, you will
319 get the following warning:
320  
321 Failed to load $comp_class. Can't find source_name method. Is
322 $comp_class really a full DBIC result class? Fix it, move it elsewhere,
323 or make your load_classes call more specific.
324  
325 Example:
326  
327 My::Schema->load_classes(); # loads My::Schema::CD, My::Schema::Artist,
328 # etc. (anything under the My::Schema namespace)
329  
330 # loads My::Schema::CD, My::Schema::Artist, Other::Namespace::Producer but
331 # not Other::Namespace::LinerNotes nor My::Schema::Track
332 My::Schema->load_classes(qw/ CD Artist #Track /, {
333 Other::Namespace => [qw/ Producer #LinerNotes /],
334 });
335  
336 =cut
337  
338 330 ▶sub load_classes {
Subroutine load_classes: called CC=13 SCAR=25.9
Pod documented
339 330 my ($class, @params) = @_;
340  
341 330 my %comps_for;
342  
343 330 ▶ if (@params) {
Branch: 1 branch
BranchTrueFalseTotal
if (@params) { } 329 1 330
344 329 foreach my $param (@params) {
345 12965 ▶ if (ref $param eq 'ARRAY') {
Branch: 2 branches
BranchTrueFalseTotal
if (ref $param eq 'ARRAY') { } 0 12965 12965
elsif (ref $param eq 'HASH') { } 324 12641 12965
346 # filter out commented entries
347 0 my @modules = grep { $_ !~ /^#/ } @$param;
348  
349 0 push (@{$comps_for{$class}}, @modules);
350 }
351 elsif (ref $param eq 'HASH') {
352 # more than one namespace possible
353 324 for my $comp ( keys %$param ) {
354 # filter out commented entries
355 324 my @modules = grep { $_ !~ /^#/ } @{$param->{$comp}};
356  
357 324 push (@{$comps_for{$comp}}, @modules);
358 }
359 }
360 else {
361 # filter out commented entries
362 12641 ▶ push (@{$comps_for{$class}}, $param) if $param !~ /^#/;
Branch: 1 branch
BranchTrueFalseTotal
unless $param =~ /^#/ 11993 648 12641
363 }
364 }
365 } else {
366 1 my @comp = map { substr $_, length "${class}::" }
367 $class->_findallmod($class);
368 1 $comps_for{$class} = \@comp;
369 }
370  
371 330 my @to_register;
372 {
373 326 ▶ no warnings qw/redefine/;
Subroutine BEGIN: called CC=1 SCAR=0.0
374 330 ▶ local *Class::C3::reinitialize = sub { } if DBIx::Class::_ENV_::OLD_MRO;
Subroutine __ANON__: not called CC=1 SCAR=0.0
375 326 ▶ use warnings qw/redefine/;
Subroutine BEGIN: called CC=1 SCAR=0.0
376  
377 330 foreach my $prefix (keys %comps_for) {
378 330 ▶ foreach my $comp (@{$comps_for{$prefix}||[]}) {
Condition50%1/2
$comps_for{$prefix} || []
l!l
3300
MC/DC0%0/1
$comps_for{$prefix} || []
$comps_for{$prefix}
Truth table50%1/2
A
A= $comps_for{$prefix}
Aresult
11
00
379 14963 my $comp_class = "${prefix}::${comp}";
380 14963 $class->ensure_class_loaded($comp_class);
381  
382 14963 my $snsub = $comp_class->can('source_name');
383 14963 ▶ if(! $snsub ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($snsub) 1 14962 14963
384 1 carp "Failed to load $comp_class. Can't find source_name method. Is $comp_class really a full DBIC result class? Fix it, move it elsewhere, or make your load_classes call more specific.";
385 1 next;
386 }
387 14962 ▶ $comp = $snsub->($comp_class) || $comp;
Condition66%2/3
&$snsub($comp_class) || $comp
l!l&&r!l&&!r
325146370
MC/DC0%0/2
&$snsub($comp_class) || $comp
&$snsub($comp_class) $comp
Truth table66%2/3
A || B
A= &$snsub($comp_class)B= $comp
ABresult
1X1
011
000
388  
389 14962 push(@to_register, [ $comp, $comp_class ]);
390 }
391 }
392 }
393 330 Class::C3->reinitialize if DBIx::Class::_ENV_::OLD_MRO;
394  
395 330 foreach my $to (@to_register) {
396 14962 $class->register_class(@$to);
397 }
398 }
399  
400 =head2 storage_type
401  
402 =over 4
403  
404 =item Arguments: $storage_type|{$storage_type, \%args}
405  
406 =item Return Value: $storage_type|{$storage_type, \%args}
407  
408 =item Default value: DBIx::Class::Storage::DBI
409  
410 =back
411  
412 Set the storage class that will be instantiated when L</connect> is called.
413 If the classname starts with C<::>, the prefix C<DBIx::Class::Storage> is
414 assumed by L</connect>.
415  
416 You want to use this to set subclasses of L<DBIx::Class::Storage::DBI>
417 in cases where the appropriate subclass is not autodetected.
418  
419 If your storage type requires instantiation arguments, those are
420 defined as a second argument in the form of a hashref and the entire
421 value needs to be wrapped into an arrayref or a hashref. We support
422 both types of refs here in order to play nice with your
423 Config::[class] or your choice. See
424 L<DBIx::Class::Storage::DBI::Replicated> for an example of this.
425  
426 =head2 exception_action
427  
428 =over 4
429  
430 =item Arguments: $code_reference
431  
432 =item Return Value: $code_reference
433  
434 =item Default value: None
435  
436 =back
437  
438 When L</throw_exception> is invoked and L</exception_action> is set to a code
439 reference, this reference will be called instead of
440 L<DBIx::Class::Exception/throw>, with the exception message passed as the only
441 argument.
442  
443 Your custom throw code B<must> rethrow the exception, as L</throw_exception> is
444 an integral part of DBIC's internal execution control flow.
445  
446 Example:
447  
448 package My::Schema;
449 use base qw/DBIx::Class::Schema/;
450 use My::ExceptionClass;
451 __PACKAGE__->exception_action(sub { My::ExceptionClass->throw(@_) });
452 __PACKAGE__->load_classes;
453  
454 # or:
455 my $schema_obj = My::Schema->connect( .... );
456 $schema_obj->exception_action(sub { My::ExceptionClass->throw(@_) });
457  
458 =head2 stacktrace
459  
460 =over 4
461  
462 =item Arguments: boolean
463  
464 =back
465  
466 Whether L</throw_exception> should include stack trace information.
467 Defaults to false normally, but defaults to true if C<$ENV{DBIC_TRACE}>
468 is true.
469  
470 =head2 sqlt_deploy_hook
471  
472 =over
473  
474 =item Arguments: $sqlt_schema
475  
476 =back
477  
478 An optional sub which you can declare in your own Schema class that will get
479 passed the L<SQL::Translator::Schema> object when you deploy the schema via
480 L</create_ddl_dir> or L</deploy>.
481  
482 For an example of what you can do with this, see
483 L<DBIx::Class::Manual::Cookbook/Adding Indexes And Functions To Your SQL>.
484  
485 Note that sqlt_deploy_hook is called by L</deployment_statements>, which in turn
486 is called before L</deploy>. Therefore the hook can be used only to manipulate
487 the L<SQL::Translator::Schema> object before it is turned into SQL fed to the
488 database. If you want to execute post-deploy statements which can not be generated
489 by L<SQL::Translator>, the currently suggested method is to overload L</deploy>
490 and use L<dbh_do|DBIx::Class::Storage::DBI/dbh_do>.
491  
492 =head1 METHODS
493  
494 =head2 connect
495  
496 =over 4
497  
498 =item Arguments: @connectinfo
499  
500 =item Return Value: $new_schema
501  
502 =back
503  
504 Creates and returns a new Schema object. The connection info set on it
505 is used to create a new instance of the storage backend and set it on
506 the Schema object.
507  
508 See L<DBIx::Class::Storage::DBI/"connect_info"> for DBI-specific
509 syntax on the C<@connectinfo> argument, or L<DBIx::Class::Storage> in
510 general.
511  
512 Note that C<connect_info> expects an arrayref of arguments, but
513 C<connect> does not. C<connect> wraps its arguments in an arrayref
514 before passing them to C<connect_info>.
515  
516 =head3 Overloading
517  
518 C<connect> is a convenience method. It is equivalent to calling
519 $schema->clone->connection(@connectinfo). To write your own overloaded
520 version, overload L</connection> instead.
521  
522 =cut
523  
524 431 ▶sub connect { shift->clone->connection(@_) }
Subroutine connect: called CC=1 SCAR=0.0
Pod documented
525  
526 =head2 resultset
527  
528 =over 4
529  
530 =item Arguments: L<$source_name|DBIx::Class::ResultSource/source_name>
531  
532 =item Return Value: L<$resultset|DBIx::Class::ResultSet>
533  
534 =back
535  
536 my $rs = $schema->resultset('DVD');
537  
538 Returns the L<DBIx::Class::ResultSet> object for the registered source
539 name.
540  
541 =cut
542  
543 9060 ▶sub resultset {
Subroutine resultset: called CC=2 SCAR=6.9
Pod documented
544 9060 my ($self, $source_name) = @_;
545 9060 ▶ $self->throw_exception('resultset() expects a source name')
Branch: 1 branch
BranchTrueFalseTotal
unless defined $source_name 1 9059 9060
546 unless defined $source_name;
547 9059 return $self->source($source_name)->resultset;
548 }
549  
550 =head2 sources
551  
552 =over 4
553  
554 =item Return Value: L<@source_names|DBIx::Class::ResultSource/source_name>
555  
556 =back
557  
558 my @source_names = $schema->sources;
559  
560 Lists names of all the sources registered on this Schema object.
561  
562 =cut
563  
564 1252 ▶sub sources { keys %{shift->source_registrations} }
Subroutine sources: called CC=1 SCAR=0.0
Pod documented
565  
566 =head2 source
567  
568 =over 4
569  
570 =item Arguments: L<$source_name|DBIx::Class::ResultSource/source_name>
571  
572 =item Return Value: L<$result_source|DBIx::Class::ResultSource>
573  
574 =back
575  
576 my $source = $schema->source('Book');
577  
578 Returns the L<DBIx::Class::ResultSource> object for the registered
579 source name.
580  
581 =cut
582  
583 83087 ▶sub source {
Subroutine source: called CC=5 SCAR=16.1
Pod documented
584 83087 my $self = shift;
585  
586 83087 ▶ $self->throw_exception("source() expects a source name")
Branch: 1 branch
BranchTrueFalseTotal
unless @_ 1 83086 83087
587 unless @_;
588  
589 83086 my $source_name = shift;
590  
591 83086 my $sreg = $self->source_registrations;
592 83086 ▶ return $sreg->{$source_name} if exists $sreg->{$source_name};
Branch: 1 branch
BranchTrueFalseTotal
if exists $sreg->{$source_name} 66781 16305 83086
593  
594 # if we got here, they probably passed a full class name
595 16305 my $mapped = $self->class_mappings->{$source_name};
596 $self->throw_exception("Can't find source for ${source_name}")
597 16305 ▶ unless $mapped && exists $sreg->{$mapped};
Branch: 1 branch
BranchTrueFalseTotal
unless $mapped and exists $sreg->{$mapped} 9 16296 16305
Condition66%2/3
$mapped and exists $sreg->{$mapped}
!ll&&!rl&&r
0916296
MC/DC50%1/2
$mapped and exists $sreg->{$mapped}
$mapped exists $sreg->{$mapped}
Truth table66%2/3
A and B
A= $mappedB= exists $sreg->{$mapped}
ABresult
0X0
100
111
598 16296 return $sreg->{$mapped};
599 }
600  
601 =head2 class
602  
603 =over 4
604  
605 =item Arguments: L<$source_name|DBIx::Class::ResultSource/source_name>
606  
607 =item Return Value: $classname
608  
609 =back
610  
611 my $class = $schema->class('CD');
612  
613 Retrieves the Result class name for the given source name.
614  
615 =cut
616  
617 397 ▶sub class {
Subroutine class: called CC=1 SCAR=0.0
Pod documented
618 397 return shift->source(shift)->result_class;
619 }
620  
621 =head2 txn_do
622  
623 =over 4
624  
625 =item Arguments: C<$coderef>, @coderef_args?
626  
627 =item Return Value: The return value of $coderef
628  
629 =back
630  
631 Executes C<$coderef> with (optional) arguments C<@coderef_args> atomically,
632 returning its result (if any). Equivalent to calling $schema->storage->txn_do.
633 See L<DBIx::Class::Storage/"txn_do"> for more information.
634  
635 This interface is preferred over using the individual methods L</txn_begin>,
636 L</txn_commit>, and L</txn_rollback> below.
637  
638 WARNING: If you are connected with C<< AutoCommit => 0 >> the transaction is
639 considered nested, and you will still need to call L</txn_commit> to write your
640 changes when appropriate. You will also want to connect with C<< auto_savepoint =>
641 1 >> to get partial rollback to work, if the storage driver for your database
642 supports it.
643  
644 Connecting with C<< AutoCommit => 1 >> is recommended.
645  
646 =cut
647  
648 466 ▶sub txn_do {
Subroutine txn_do: called CC=2 SCAR=6.9
Pod documented
649 466 my $self = shift;
650  
651 466 ▶ $self->storage or $self->throw_exception
Branch: 1 branch
BranchTrueFalseTotal
$self->storage or $self->throw_exception("txn_do called on \$schema without storage") 442 24 466
652 ('txn_do called on $schema without storage');
653  
654 442 $self->storage->txn_do(@_);
655 }
656  
657 =head2 txn_scope_guard
658  
659 Runs C<txn_scope_guard> on the schema's storage. See
660 L<DBIx::Class::Storage/txn_scope_guard>.
661  
662 =cut
663  
664 1107 ▶sub txn_scope_guard {
Subroutine txn_scope_guard: called CC=2 SCAR=7.1
Pod documented
665 1107 my $self = shift;
666  
667 1107 ▶ $self->storage or $self->throw_exception
Branch: 1 branch
BranchTrueFalseTotal
$self->storage or $self->throw_exception("txn_scope_guard called on \$schema without storage") 1107 0 1107
668 ('txn_scope_guard called on $schema without storage');
669  
670 1107 $self->storage->txn_scope_guard(@_);
671 }
672  
673 =head2 txn_begin
674  
675 Begins a transaction (does nothing if AutoCommit is off). Equivalent to
676 calling $schema->storage->txn_begin. See
677 L<DBIx::Class::Storage/"txn_begin"> for more information.
678  
679 =cut
680  
681 12 ▶sub txn_begin {
Subroutine txn_begin: called CC=2 SCAR=7.1
Pod documented
682 12 my $self = shift;
683  
684 12 ▶ $self->storage or $self->throw_exception
Branch: 1 branch
BranchTrueFalseTotal
$self->storage or $self->throw_exception("txn_begin called on \$schema without storage") 12 0 12
685 ('txn_begin called on $schema without storage');
686  
687 12 $self->storage->txn_begin;
688 }
689  
690 =head2 txn_commit
691  
692 Commits the current transaction. Equivalent to calling
693 $schema->storage->txn_commit. See L<DBIx::Class::Storage/"txn_commit">
694 for more information.
695  
696 =cut
697  
698 5 ▶sub txn_commit {
Subroutine txn_commit: called CC=2 SCAR=7.1
Pod documented
699 5 my $self = shift;
700  
701 5 ▶ $self->storage or $self->throw_exception
Branch: 1 branch
BranchTrueFalseTotal
$self->storage or $self->throw_exception("txn_commit called on \$schema without storage") 5 0 5
702 ('txn_commit called on $schema without storage');
703  
704 5 $self->storage->txn_commit;
705 }
706  
707 =head2 txn_rollback
708  
709 Rolls back the current transaction. Equivalent to calling
710 $schema->storage->txn_rollback. See
711 L<DBIx::Class::Storage/"txn_rollback"> for more information.
712  
713 =cut
714  
715 6 ▶sub txn_rollback {
Subroutine txn_rollback: called CC=2 SCAR=7.1
Pod documented
716 6 my $self = shift;
717  
718 6 ▶ $self->storage or $self->throw_exception
Branch: 1 branch
BranchTrueFalseTotal
$self->storage or $self->throw_exception("txn_rollback called on \$schema without storage") 6 0 6
719 ('txn_rollback called on $schema without storage');
720  
721 6 $self->storage->txn_rollback;
722 }
723  
724 =head2 storage
725  
726 my $storage = $schema->storage;
727  
728 Returns the L<DBIx::Class::Storage> object for this Schema. Grab this
729 if you want to turn on SQL statement debugging at runtime, or set the
730 quote character. For the default storage, the documentation can be
731 found in L<DBIx::Class::Storage::DBI>.
732  
733 =head2 populate
734  
735 =over 4
736  
737 =item Arguments: L<$source_name|DBIx::Class::ResultSource/source_name>, [ \@column_list, \@row_values+ ] | [ \%col_data+ ]
738  
739 =item Return Value: L<\@result_objects|DBIx::Class::Manual::ResultClass> (scalar context) | L<@result_objects|DBIx::Class::Manual::ResultClass> (list context)
740  
741 =back
742  
743 A convenience shortcut to L<DBIx::Class::ResultSet/populate>. Equivalent to:
744  
745 $schema->resultset($source_name)->populate([...]);
746  
747 =over 4
748  
749 =item NOTE
750  
751 The context of this method call has an important effect on what is
752 submitted to storage. In void context data is fed directly to fastpath
753 insertion routines provided by the underlying storage (most often
754 L<DBI/execute_for_fetch>), bypassing the L<new|DBIx::Class::Row/new> and
755 L<insert|DBIx::Class::Row/insert> calls on the
756 L<Result|DBIx::Class::Manual::ResultClass> class, including any
757 augmentation of these methods provided by components. For example if you
758 are using something like L<DBIx::Class::UUIDColumns> to create primary
759 keys for you, you will find that your PKs are empty. In this case you
760 will have to explicitly force scalar or list context in order to create
761 those values.
762  
763 =back
764  
765 =cut
766  
767 7588 ▶sub populate {
Subroutine populate: called CC=2 SCAR=7.1
Pod documented
768 7588 my ($self, $name, $data) = @_;
769 7588 ▶ my $rs = $self->resultset($name)
Branch: 1 branch
BranchTrueFalseTotal
my $rs = $self->resultset($name) or $self->throw_exception("'${name}' is not a resultset") 7588 0 7588
770 or $self->throw_exception("'$name' is not a resultset");
771  
772 7588 return $rs->populate($data);
773 }
774  
775 =head2 connection
776  
777 =over 4
778  
779 =item Arguments: @args
780  
781 =item Return Value: $new_schema
782  
783 =back
784  
785 Similar to L</connect> except sets the storage object and connection
786 data in-place on the Schema class. You should probably be calling
787 L</connect> to get a proper Schema object instead.
788  
789 =head3 Overloading
790  
791 Overload C<connection> to change the behaviour of C<connect>.
792  
793 =cut
794  
795 443 ▶sub connection {
Subroutine connection: called CC=5 SCAR=16.8
Pod documented
796 443 my ($self, @info) = @_;
797 443 ▶ return $self if !@info && $self->storage;
Branch: 1 branch
BranchTrueFalseTotal
if not @info and $self->storage 0 443 443
Condition66%2/3
not @info and $self->storage
!ll&&!rl&&r
431120
MC/DC0%0/2
not @info and $self->storage
not @info $self->storage
Truth table66%2/3
not(A) and B
A= not @infoB= $self->storage
ABresult
0X0
100
111
798  
799 443 ▶ my ($storage_class, $args) = ref $self->storage_type
Branch: 1 branch
BranchTrueFalseTotal
ref $self->storage_type ? : 0 443 443
800 ? $self->_normalize_storage_type($self->storage_type)
801 : $self->storage_type
802 ;
803  
804 443 $storage_class =~ s/^::/DBIx::Class::Storage::/;
805  
806 443 ▶ try {
Subroutine __ANON__: called CC=1 SCAR=0.0
807 443 $self->ensure_class_loaded ($storage_class);
808 }
809 0 ▶ catch {
Subroutine __ANON__: not called CC=1 SCAR=6.9
810 0 $self->throw_exception(
811 "Unable to load storage class ${storage_class}: $_"
812 );
813 443 };
814  
815 443 ▶ my $storage = $storage_class->new( $self => $args||{} );
Condition50%1/2
$args || {}
l!l
0443
MC/DC0%0/1
$args || {}
$args
Truth table50%1/2
A
A= $args
Aresult
11
00
816 443 $storage->connect_info(\@info);
817 443 $self->storage($storage);
818 443 return $self;
819 }
820  
821 0 ▶sub _normalize_storage_type {
Subroutine _normalize_storage_type: not called CC=3 SCAR=24.8
822 0 my ($self, $storage_type) = @_;
823 0 ▶ if(ref $storage_type eq 'ARRAY') {
Branch: 2 branches
BranchTrueFalseTotal
if (ref $storage_type eq 'ARRAY') { } 0 0 0
elsif (ref $storage_type eq 'HASH') { } 0 0 0
824 0 return @$storage_type;
825 } elsif(ref $storage_type eq 'HASH') {
826 0 return %$storage_type;
827 } else {
828 0 $self->throw_exception('Unsupported REFTYPE given: '. ref $storage_type);
829 }
830 }
831  
832 =head2 compose_namespace
833  
834 =over 4
835  
836 =item Arguments: $target_namespace, $additional_base_class?
837  
838 =item Return Value: $new_schema
839  
840 =back
841  
842 For each L<DBIx::Class::ResultSource> in the schema, this method creates a
843 class in the target namespace (e.g. $target_namespace::CD,
844 $target_namespace::Artist) that inherits from the corresponding classes
845 attached to the current schema.
846  
847 It also attaches a corresponding L<DBIx::Class::ResultSource> object to the
848 new $schema object. If C<$additional_base_class> is given, the new composed
849 classes will inherit from first the corresponding class from the current
850 schema then the base class.
851  
852 For example, for a schema with My::Schema::CD and My::Schema::Artist classes,
853  
854 $schema->compose_namespace('My::DB', 'Base::Class');
855 print join (', ', @My::DB::CD::ISA) . "\n";
856 print join (', ', @My::DB::Artist::ISA) ."\n";
857  
858 will produce the output
859  
860 My::Schema::CD, Base::Class
861 My::Schema::Artist, Base::Class
862  
863 =cut
864  
865 # this might be oversimplified
866 # sub compose_namespace {
867 # my ($self, $target, $base) = @_;
868  
869 # my $schema = $self->clone;
870 # foreach my $source_name ($schema->sources) {
871 # my $source = $schema->source($source_name);
872 # my $target_class = "${target}::${source_name}";
873 # $self->inject_base(
874 # $target_class => $source->result_class, ($base ? $base : ())
875 # );
876 # $source->result_class($target_class);
877 # $target_class->result_source_instance($source)
878 # if $target_class->can('result_source_instance');
879 # $schema->register_source($source_name, $source);
880 # }
881 # return $schema;
882 # }
883  
884 402 ▶sub compose_namespace {
Subroutine compose_namespace: called CC=6 SCAR=18.1
Pod documented
885 402 my ($self, $target, $base) = @_;
886  
887 402 my $schema = $self->clone;
888  
889 402 $schema->source_registrations({});
890  
891 # the original class-mappings must remain - otherwise
892 # reverse_relationship_info will not work
893 #$schema->class_mappings({});
894  
895 {
896 326 ▶ no warnings qw/redefine/;
Subroutine BEGIN: called CC=1 SCAR=0.0
897 402 ▶ local *Class::C3::reinitialize = sub { } if DBIx::Class::_ENV_::OLD_MRO;
Subroutine __ANON__: not called CC=1 SCAR=0.0
898 326 ▶ use warnings qw/redefine/;
Subroutine BEGIN: called CC=1 SCAR=0.0
899  
900 402 foreach my $source_name ($self->sources) {
901 18449 my $orig_source = $self->source($source_name);
902  
903 18449 my $target_class = "${target}::${source_name}";
904 18449 ▶ $self->inject_base($target_class, $orig_source->result_class, ($base || ()) );
Condition66%2/3
$base || ()
l!l&&r!l&&!r
46184030
MC/DC0%0/2
$base || ()
$base ()
Truth table66%2/3
A || B
A= $baseB= ()
ABresult
1X1
011
000
905  
906 # register_source examines result_class, and then returns us a clone
907 18449 my $new_source = $schema->register_source($source_name, bless
908 { %$orig_source, result_class => $target_class },
909 ref $orig_source,
910 );
911  
912 18449 ▶ if ($target_class->can('result_source_instance')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($target_class->can("result_source_instance")) 18449 0 18449
913 # give the class a schema-less source copy
914 $target_class->result_source_instance( bless
915 { %$new_source, schema => ref $new_source->{schema} || $new_source->{schema} },
916 18449 ▶ ref $new_source,
Condition33%1/3
ref $new_source->{'schema'} || $new_source->{'schema'}
l!l&&r!l&&!r
1844900
MC/DC0%0/2
ref $new_source->{'schema'} || $new_source->{'schema'}
ref $new_source->{'schema'} $new_source->{'schema'}
Truth table33%1/3
A || B
A= ref $new_source->{'schema'}B= $new_source->{'schema'}
ABresult
1X1
011
000
917 );
918 }
919 }
920  
921 quote_sub "${target}::${_}" => "shift->schema->$_(\@_)"
922 402 for qw(class source resultset);
923 }
924  
925 402 Class::C3->reinitialize() if DBIx::Class::_ENV_::OLD_MRO;
926  
927 402 return $schema;
928 }
929  
930 0 ▶sub setup_connection_class {
Subroutine setup_connection_class: not called CC=1 SCAR=6.9
Pod undocumented
931 0 my ($class, $target, @info) = @_;
932 0 $class->inject_base($target => 'DBIx::Class::DB');
933 #$target->load_components('DB');
934 0 $target->connection(@info);
935 }
936  
937 =head2 svp_begin
938  
939 Creates a new savepoint (does nothing outside a transaction).
940 Equivalent to calling $schema->storage->svp_begin. See
941 L<DBIx::Class::Storage/"svp_begin"> for more information.
942  
943 =cut
944  
945 17 ▶sub svp_begin {
Subroutine svp_begin: called CC=2 SCAR=7.1
Pod documented
946 17 my ($self, $name) = @_;
947  
948 17 ▶ $self->storage or $self->throw_exception
Branch: 1 branch
BranchTrueFalseTotal
$self->storage or $self->throw_exception("svp_begin called on \$schema without storage") 17 0 17
949 ('svp_begin called on $schema without storage');
950  
951 17 $self->storage->svp_begin($name);
952 }
953  
954 =head2 svp_release
955  
956 Releases a savepoint (does nothing outside a transaction).
957 Equivalent to calling $schema->storage->svp_release. See
958 L<DBIx::Class::Storage/"svp_release"> for more information.
959  
960 =cut
961  
962 6 ▶sub svp_release {
Subroutine svp_release: called CC=2 SCAR=7.1
Pod documented
963 6 my ($self, $name) = @_;
964  
965 6 ▶ $self->storage or $self->throw_exception
Branch: 1 branch
BranchTrueFalseTotal
$self->storage or $self->throw_exception("svp_release called on \$schema without storage") 6 0 6
966 ('svp_release called on $schema without storage');
967  
968 6 $self->storage->svp_release($name);
969 }
970  
971 =head2 svp_rollback
972  
973 Rollback to a savepoint (does nothing outside a transaction).
974 Equivalent to calling $schema->storage->svp_rollback. See
975 L<DBIx::Class::Storage/"svp_rollback"> for more information.
976  
977 =cut
978  
979 12 ▶sub svp_rollback {
Subroutine svp_rollback: called CC=2 SCAR=7.1
Pod documented
980 12 my ($self, $name) = @_;
981  
982 12 ▶ $self->storage or $self->throw_exception
Branch: 1 branch
BranchTrueFalseTotal
$self->storage or $self->throw_exception("svp_rollback called on \$schema without storage") 12 0 12
983 ('svp_rollback called on $schema without storage');
984  
985 12 $self->storage->svp_rollback($name);
986 }
987  
988 =head2 clone
989  
990 =over 4
991  
992 =item Arguments: %attrs?
993  
994 =item Return Value: $new_schema
995  
996 =back
997  
998 Clones the schema and its associated result_source objects and returns the
999 copy. The resulting copy will have the same attributes as the source schema,
1000 except for those attributes explicitly overridden by the provided C<%attrs>.
1001  
1002 =cut
1003  
1004 841 ▶sub clone {
Subroutine clone: called CC=6 SCAR=18.0
Pod documented
1005 841 my $self = shift;
1006  
1007 my $clone = {
1008 (ref $self ? %$self : ()),
1009 841 ▶ (@_ == 1 && ref $_[0] eq 'HASH' ? %{ $_[0] } : @_),
Branch: 2 branches
BranchTrueFalseTotal
ref $self ? : 406 435 841
@_ == 1 && ref $_[0] eq 'HASH' ? : 1 840 841
Condition66%2/3
@_ == 1 and ref $_[0] eq "HASH"
!ll&&!rl&&r
84001
MC/DC50%1/2
@_ == 1 and ref $_[0] eq "HASH"
@_ == 1 ref $_[0] eq "HASH"
Truth table66%2/3
A and B
A= @_ == 1B= ref $_[0] eq "HASH"
ABresult
0X0
100
111
1010 };
1011 841 ▶ bless $clone, (ref $self || $self);
Condition66%2/3
ref $self || $self
l!l&&r!l&&!r
4064350
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table66%2/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
1012  
1013 841 $clone->$_(undef) for qw/class_mappings source_registrations storage/;
1014  
1015 841 $clone->_copy_state_from($self);
1016  
1017 841 return $clone;
1018 }
1019  
1020 # Needed in Schema::Loader - if you refactor, please make a compatibility shim
1021 # -- Caelum
1022 841 ▶sub _copy_state_from {
Subroutine _copy_state_from: called CC=3 SCAR=11.0
1023 841 my ($self, $from) = @_;
1024  
1025 841 $self->class_mappings({ %{$from->class_mappings} });
1026 841 $self->source_registrations({ %{$from->source_registrations} });
1027  
1028 841 foreach my $source_name ($from->sources) {
1029 38601 my $source = $from->source($source_name);
1030 38601 my $new = $source->new($source);
1031 # we use extra here as we want to leave the class_mappings as they are
1032 # but overwrite the source_registrations entry with the new source
1033 38601 $self->register_extra_source($source_name => $new);
1034 }
1035  
1036 841 ▶ if ($from->storage) {
Branch: 1 branch
BranchTrueFalseTotal
if ($from->storage) 7 834 841
1037 7 $self->storage($from->storage);
1038 7 $self->storage->set_schema($self);
1039 }
1040 }
1041  
1042 =head2 throw_exception
1043  
1044 =over 4
1045  
1046 =item Arguments: $message
1047  
1048 =back
1049  
1050 Throws an exception. Obeys the exemption rules of L<DBIx::Class::Carp> to report
1051 errors from outer-user's perspective. See L</exception_action> for details on overriding
1052 this method's behavior. If L</stacktrace> is turned on, C<throw_exception>'s
1053 default behavior will provide a detailed stack trace.
1054  
1055 =cut
1056  
1057 2740 ▶sub throw_exception {
Subroutine throw_exception: called CC=4 SCAR=13.9
Pod documented
1058 2740 my ($self, @args) = @_;
1059  
1060 2740 ▶ if (my $act = $self->exception_action) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $act = $self->exception_action) 7 2733 2740
1061  
1062 7 my $guard_disarmed;
1063  
1064 7 ▶ my $guard = scope_guard {
Subroutine __ANON__: called CC=2 SCAR=6.9
1065 7 ▶ return if $guard_disarmed;
Branch: 1 branch
BranchTrueFalseTotal
if $guard_disarmed 6 1 7
1066 1 local $SIG{__WARN__};
1067 1 Carp::cluck("
1068 !!! DBIx::Class INTERNAL PANIC !!!
1069  
1070 The exception_action() handler installed on '$self'
1071 aborted the stacktrace below via a longjmp (either via Return::Multilevel or
1072 plain goto, or Scope::Upper or something equally nefarious). There currently
1073 is nothing safe DBIx::Class can do, aside from displaying this error. A future
1074 version ( 0.082900, when available ) will reduce the cases in which the
1075 handler is invoked, but this is neither a complete solution, nor can it do
1076 anything for other software that might be affected by a similar problem.
1077  
1078 !!! FIX YOUR ERROR HANDLING !!!
1079  
1080 This guard was activated beginning"
1081 );
1082 7 };
1083  
1084 eval {
1085 # if it throws - good, we'll go down to the do{} below
1086 # if it doesn't - do different things depending on RV truthiness
1087 7 ▶ if( $act->(@args) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (&$act(@args)) { } 1 2 3
1088 1 $args[0] = (
1089 "Invocation of the exception_action handler installed on $self did *not*"
1090 .' result in an exception. DBIx::Class is unable to function without a reliable'
1091 .' exception mechanism, ensure that exception_action does not hide exceptions'
1092 ." (original error: $args[0])"
1093 );
1094 }
1095 else {
1096 2 carp_unique (
1097 "The exception_action handler installed on $self returned false instead"
1098 .' of throwing an exception. This behavior has been deprecated, adjust your'
1099 .' handler to always rethrow the supplied error'
1100 );
1101 }
1102  
1103 3 $guard_disarmed = 1;
1104 }
1105  
1106 or
1107  
1108 7 ▶ do {
Branch: 1 branch
BranchTrueFalseTotal
eval { do { if (&$act(@args)) { $args[0] = "Invocation of the exception_action handler installed on $self did *not*" . ' result in an exception. DBIx::Class is unable to function without a reliable' . " exception mechanism, ensure that exception_action does not hide exceptions" . " (original error: $args[0])"; } else { carp_unique("The exception_action handler installed on $self returned false instead" . ' of throwing an exception. This behavior has been deprecated, adjust your' . " handler to always rethrow the supplied error"); } ; $guard_disarmed = 1 } } or do { &is_exception($@); $guard_disarmed = 1; $args[0] = $@ } 3 3 6
1109 # We call this to get the necessary warnings emitted and disregard the RV
1110 # as it's definitely an exception if we got as far as this do{} block
1111 3 is_exception($@);
1112  
1113 3 $guard_disarmed = 1;
1114 3 $args[0] = $@;
1115 };
1116 }
1117  
1118 2739 DBIx::Class::Exception->throw($args[0], $self->stacktrace);
1119 }
1120  
1121 =head2 deploy
1122  
1123 =over 4
1124  
1125 =item Arguments: \%sqlt_args, $dir
1126  
1127 =back
1128  
1129 Attempts to deploy the schema to the current storage using L<SQL::Translator>.
1130  
1131 See L<SQL::Translator/METHODS> for a list of values for C<\%sqlt_args>.
1132 The most common value for this would be C<< { add_drop_table => 1 } >>
1133 to have the SQL produced include a C<DROP TABLE> statement for each table
1134 created. For quoting purposes supply C<quote_identifiers>.
1135  
1136 Additionally, the DBIx::Class parser accepts a C<sources> parameter as a hash
1137 ref or an array ref, containing a list of source to deploy. If present, then
1138 only the sources listed will get deployed. Furthermore, you can use the
1139 C<add_fk_index> parser parameter to prevent the parser from creating an index for each
1140 FK.
1141  
1142 =cut
1143  
1144 0 ▶sub deploy {
Subroutine deploy: not called CC=2 SCAR=17.9
Pod documented
1145 0 my ($self, $sqltargs, $dir) = @_;
1146 0 ▶ $self->throw_exception("Can't deploy without storage") unless $self->storage;
Branch: 1 branch
BranchTrueFalseTotal
unless $self->storage 0 0 0
1147 0 $self->storage->deploy($self, undef, $sqltargs, $dir);
1148 }
1149  
1150 =head2 deployment_statements
1151  
1152 =over 4
1153  
1154 =item Arguments: See L<DBIx::Class::Storage::DBI/deployment_statements>
1155  
1156 =item Return Value: $listofstatements
1157  
1158 =back
1159  
1160 A convenient shortcut to
1161 C<< $self->storage->deployment_statements($self, @args) >>.
1162 Returns the statements used by L</deploy> and
1163 L<DBIx::Class::Storage/deploy>.
1164  
1165 =cut
1166  
1167 1 ▶sub deployment_statements {
Subroutine deployment_statements: called CC=2 SCAR=7.1
Pod documented
1168 1 my $self = shift;
1169  
1170 1 ▶ $self->throw_exception("Can't generate deployment statements without a storage")
Branch: 1 branch
BranchTrueFalseTotal
unless $self->storage 0 1 1
1171 if not $self->storage;
1172  
1173 1 $self->storage->deployment_statements($self, @_);
1174 }
1175  
1176 =head2 create_ddl_dir
1177  
1178 =over 4
1179  
1180 =item Arguments: See L<DBIx::Class::Storage::DBI/create_ddl_dir>
1181  
1182 =back
1183  
1184 A convenient shortcut to
1185 C<< $self->storage->create_ddl_dir($self, @args) >>.
1186  
1187 Creates an SQL file based on the Schema, for each of the specified
1188 database types, in the given directory.
1189  
1190 =cut
1191  
1192 0 ▶sub create_ddl_dir {
Subroutine create_ddl_dir: not called CC=2 SCAR=17.9
Pod documented
1193 0 my $self = shift;
1194  
1195 0 ▶ $self->throw_exception("Can't create_ddl_dir without storage") unless $self->storage;
Branch: 1 branch
BranchTrueFalseTotal
unless $self->storage 0 0 0
1196 0 $self->storage->create_ddl_dir($self, @_);
1197 }
1198  
1199 =head2 ddl_filename
1200  
1201 =over 4
1202  
1203 =item Arguments: $database-type, $version, $directory, $preversion
1204  
1205 =item Return Value: $normalised_filename
1206  
1207 =back
1208  
1209 my $filename = $table->ddl_filename($type, $version, $dir, $preversion)
1210  
1211 This method is called by C<create_ddl_dir> to compose a file name out of
1212 the supplied directory, database type and version number. The default file
1213 name format is: C<$dir$schema-$version-$type.sql>.
1214  
1215 You may override this method in your schema if you wish to use a different
1216 format.
1217  
1218 WARNING
1219  
1220 Prior to DBIx::Class version 0.08100 this method had a different signature:
1221  
1222 my $filename = $table->ddl_filename($type, $dir, $version, $preversion)
1223  
1224 In recent versions variables $dir and $version were reversed in order to
1225 bring the signature in line with other Schema/Storage methods. If you
1226 really need to maintain backward compatibility, you can do the following
1227 in any overriding methods:
1228  
1229 ($dir, $version) = ($version, $dir) if ($DBIx::Class::VERSION < 0.08100);
1230  
1231 =cut
1232  
1233 1 ▶sub ddl_filename {
Subroutine ddl_filename: called CC=3 SCAR=11.6
Pod documented
1234 1 my ($self, $type, $version, $dir, $preversion) = @_;
1235  
1236 1 require File::Spec;
1237  
1238 1 ▶ $version = "$preversion-$version" if $preversion;
Branch: 1 branch
BranchTrueFalseTotal
if $preversion 0 1 1
1239  
1240 1 ▶ my $class = blessed($self) || $self;
Condition33%1/3
builtin::blessed($self) || $self
l!l&&r!l&&!r
100
MC/DC0%0/2
builtin::blessed($self) || $self
builtin::blessed($self) $self
Truth table33%1/3
A || B
A= builtin::blessed($self)B= $self
ABresult
1X1
011
000
1241 1 $class =~ s/::/-/g;
1242  
1243 1 return File::Spec->catfile($dir, "$class-$version-$type.sql");
1244 }
1245  
1246 =head2 thaw
1247  
1248 Provided as the recommended way of thawing schema objects. You can call
1249 C<Storable::thaw> directly if you wish, but the thawed objects will not have a
1250 reference to any schema, so are rather useless.
1251  
1252 =cut
1253  
1254 4 ▶sub thaw {
Subroutine thaw: called CC=1 SCAR=0.0
Pod documented
1255 4 my ($self, $obj) = @_;
1256 4 local $DBIx::Class::ResultSourceHandle::thaw_schema = $self;
1257 4 return Storable::thaw($obj);
1258 }
1259  
1260 =head2 freeze
1261  
1262 This doesn't actually do anything beyond calling L<nfreeze|Storable/SYNOPSIS>,
1263 it is just provided here for symmetry.
1264  
1265 =cut
1266  
1267 4 ▶sub freeze {
Subroutine freeze: called CC=1 SCAR=0.0
Pod documented
1268 4 return Storable::nfreeze($_[1]);
1269 }
1270  
1271 =head2 dclone
1272  
1273 =over 4
1274  
1275 =item Arguments: $object
1276  
1277 =item Return Value: dcloned $object
1278  
1279 =back
1280  
1281 Recommended way of dcloning L<DBIx::Class::Row> and L<DBIx::Class::ResultSet>
1282 objects so their references to the schema object
1283 (which itself is B<not> cloned) are properly maintained.
1284  
1285 =cut
1286  
1287 4 ▶sub dclone {
Subroutine dclone: called CC=1 SCAR=0.0
Pod documented
1288 4 my ($self, $obj) = @_;
1289 4 local $DBIx::Class::ResultSourceHandle::thaw_schema = $self;
1290 4 return Storable::dclone($obj);
1291 }
1292  
1293 =head2 schema_version
1294  
1295 Returns the current schema class' $VERSION in a normalised way.
1296  
1297 =cut
1298  
1299 1 ▶sub schema_version {
Subroutine schema_version: called CC=2 SCAR=7.0
Pod documented
1300 1 my ($self) = @_;
1301 1 ▶ my $class = ref($self)||$self;
Condition33%1/3
ref $self || $self
l!l&&r!l&&!r
100
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table33%1/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
1302  
1303 # does -not- use $schema->VERSION
1304 # since that varies in results depending on if version.pm is installed, and if
1305 # so the perl or XS versions. If you want this to change, bug the version.pm
1306 # author to make vpp and vxs behave the same.
1307  
1308 1 my $version;
1309 {
1310 326 ▶ no strict 'refs';
Subroutine BEGIN: called CC=1 SCAR=0.0
1311 1 $version = ${"${class}::VERSION"};
1312 }
1313 1 return $version;
1314 }
1315  
1316  
1317 =head2 register_class
1318  
1319 =over 4
1320  
1321 =item Arguments: $source_name, $component_class
1322  
1323 =back
1324  
1325 This method is called by L</load_namespaces> and L</load_classes> to install the found classes into your Schema. You should be using those instead of this one.
1326  
1327 You will only need this method if you have your Result classes in
1328 files which are not named after the packages (or all in the same
1329 file). You may also need it to register classes at runtime.
1330  
1331 Registers a class which isa DBIx::Class::ResultSourceProxy. Equivalent to
1332 calling:
1333  
1334 $schema->register_source($source_name, $component_class->result_source_instance);
1335  
1336 =cut
1337  
1338 15089 ▶sub register_class {
Subroutine register_class: called CC=1 SCAR=0.0
Pod documented
1339 15089 my ($self, $source_name, $to_register) = @_;
1340 15089 $self->register_source($source_name => $to_register->result_source_instance);
1341 }
1342  
1343 =head2 register_source
1344  
1345 =over 4
1346  
1347 =item Arguments: $source_name, L<$result_source|DBIx::Class::ResultSource>
1348  
1349 =back
1350  
1351 This method is called by L</register_class>.
1352  
1353 Registers the L<DBIx::Class::ResultSource> in the schema with the given
1354 source name.
1355  
1356 =cut
1357  
1358 33542 ▶sub register_source { shift->_register_source(@_) }
Subroutine register_source: called CC=1 SCAR=0.0
Pod documented
1359  
1360 =head2 unregister_source
1361  
1362 =over 4
1363  
1364 =item Arguments: $source_name
1365  
1366 =back
1367  
1368 Removes the L<DBIx::Class::ResultSource> from the schema for the given source name.
1369  
1370 =cut
1371  
1372 0 ▶sub unregister_source { shift->_unregister_source(@_) }
Subroutine unregister_source: not called CC=1 SCAR=6.9
Pod documented
1373  
1374 =head2 register_extra_source
1375  
1376 =over 4
1377  
1378 =item Arguments: $source_name, L<$result_source|DBIx::Class::ResultSource>
1379  
1380 =back
1381  
1382 As L</register_source> but should be used if the result class already
1383 has a source and you want to register an extra one.
1384  
1385 =cut
1386  
1387 38603 ▶sub register_extra_source { shift->_register_source(@_, { extra => 1 }) }
Subroutine register_extra_source: called CC=1 SCAR=0.0
Pod documented
1388  
1389 72145 ▶sub _register_source {
Subroutine _register_source: called CC=8 SCAR=20.8
1390 72145 my ($self, $source_name, $source, $params) = @_;
1391  
1392 72145 $source = $source->new({ %$source, source_name => $source_name });
1393  
1394 72145 $source->schema($self);
1395 72145 ▶ weaken $source->{schema} if ref($self);
Branch: 1 branch
BranchTrueFalseTotal
if ref $self 57059 15086 72145
1396  
1397 72145 my %reg = %{$self->source_registrations};
1398 72145 $reg{$source_name} = $source;
1399 72145 $self->source_registrations(\%reg);
1400  
1401 72145 ▶ return $source if $params->{extra};
Branch: 1 branch
BranchTrueFalseTotal
if $params->{"extra"} 38603 33542 72145
1402  
1403 33542 my $rs_class = $source->result_class;
1404 33542 ▶ if ($rs_class and my $rsrc = try { $rs_class->result_source_instance } ) {
Subroutine __ANON__: called CC=1 SCAR=0.0
Branch: 1 branch
BranchTrueFalseTotal
if ($rs_class and my $rsrc = &try(sub { $rs_class->result_source_instance; } )) 33540 2 33542
Condition66%2/3
$rs_class and my $rsrc = &try(sub { $rs_class->result_source_instance; } )
!ll&&!rl&&r
2033540
MC/DC50%1/2
$rs_class and my $rsrc = &try(sub { $rs_class->result_source_instance; } )
$rs_class my $rsrc = &try(sub { $rs_class->result_source_instance; } )
Truth table66%2/3
A and B
A= $rs_classB= my $rsrc = &try(sub { $rs_class->result_source_instance; } )
ABresult
0X0
100
111
1405 33540 my %map = %{$self->class_mappings};
1406 33540 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if (exists $map{$rs_class} and $map{$rs_class} ne $source_name and $rsrc ne $_[2]) 1 33539 33540
Condition100%6/6
exists $map{$rs_class} and $map{$rs_class} ne $source_name and $rsrc ne $_[2]
!ll&&!rl&&r
3353631
exists $map{$rs_class} and $map{$rs_class} ne $source_name
!ll&&!rl&&r
33489474
MC/DC100%3/3
exists $map{$rs_class} and $map{$rs_class} ne $source_name and $rsrc ne $_[2]
exists $map{$rs_class} $map{$rs_class} ne $source_name $rsrc ne $_[2]
Truth table100%4/4
A and B and C
A= exists $map{$rs_class}B= $map{$rs_class} ne $source_nameC= $rsrc ne $_[2]
ABCresult
0XX0
10X0
1100
1111
1407 exists $map{$rs_class}
1408 and
1409 $map{$rs_class} ne $source_name
1410 and
1411 $rsrc ne $_[2] # orig_source
1412 ) {
1413 1 carp
1414 "$rs_class already had a registered source which was replaced by this call. "
1415 . 'Perhaps you wanted register_extra_source(), though it is more likely you did '
1416 . 'something wrong.'
1417 ;
1418 }
1419  
1420 33540 $map{$rs_class} = $source_name;
1421 33540 $self->class_mappings(\%map);
1422 }
1423  
1424 33542 return $source;
1425 }
1426  
1427 326 my $global_phase_destroy;
1428 855 ▶sub DESTROY {
Subroutine DESTROY: called CC=7 SCAR=20.5
1429 ### NO detected_reinvoked_destructor check
1430 ### This code very much relies on being called multuple times
1431  
1432 855 ▶ return if $global_phase_destroy ||= in_global_destruction;
Branch: 1 branch
BranchTrueFalseTotal
if $global_phase_destroy ||= &in_global_destruction() 0 855 855
Condition33%1/3
$global_phase_destroy ||= &in_global_destruction()
l!l&&r!l&&!r
00855
MC/DC0%0/2
$global_phase_destroy ||= &in_global_destruction()
$global_phase_destroy &in_global_destruction()
Truth table33%1/3
A ||= B
A= $global_phase_destroyB= &in_global_destruction()
ABresult
1X1
011
000
1433  
1434 855 my $self = shift;
1435 855 my $srcs = $self->source_registrations;
1436  
1437 855 for my $source_name (keys %$srcs) {
1438 # find first source that is not about to be GCed (someone other than $self
1439 # holds a reference to it) and reattach to it, weakening our own link
1440 #
1441 # during global destruction (if we have not yet bailed out) this should throw
1442 # which will serve as a signal to not try doing anything else
1443 # however beware - on older perls the exception seems randomly untrappable
1444 # due to some weird race condition during thread joining :(((
1445 38940 ▶ if (length ref $srcs->{$source_name} and refcount($srcs->{$source_name}) > 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (length ref $srcs->{$source_name} and &refcount($srcs->{$source_name}) > 1) 15 38925 38940
Condition66%2/3
length ref $srcs->{$source_name} and &refcount($srcs->{$source_name}) > 1
!ll&&!rl&&r
03892515
MC/DC50%1/2
length ref $srcs->{$source_name} and &refcount($srcs->{$source_name}) > 1
length ref $srcs->{$source_name} &refcount($srcs->{$source_name}) > 1
Truth table66%2/3
A and B
A= length ref $srcs->{$source_name}B= &refcount($srcs->{$source_name}) > 1
ABresult
0X0
100
111
1446 15 local $@;
1447 eval {
1448 15 $srcs->{$source_name}->schema($self);
1449 15 weaken $srcs->{$source_name};
1450 15 1;
1451 15 ▶ } or do {
Branch: 1 branch
BranchTrueFalseTotal
eval { do { $srcs->{$source_name}->schema($self); builtin::weaken($srcs->{$source_name}); 1 } } or do { $global_phase_destroy = 1 } 15 0 15
1452 0 $global_phase_destroy = 1;
1453 };
1454  
1455 15 last;
1456 }
1457 }
1458 }
1459  
1460 2 ▶sub _unregister_source {
Subroutine _unregister_source: called CC=2 SCAR=6.9
1461 2 my ($self, $source_name) = @_;
1462 2 my %reg = %{$self->source_registrations};
1463  
1464 2 my $source = delete $reg{$source_name};
1465 2 $self->source_registrations(\%reg);
1466 2 ▶ if ($source->result_class) {
Branch: 1 branch
BranchTrueFalseTotal
if ($source->result_class) 2 0 2
1467 2 my %map = %{$self->class_mappings};
1468 2 delete $map{$source->result_class};
1469 2 $self->class_mappings(\%map);
1470 }
1471 }
1472  
1473  
1474 =head2 compose_connection (DEPRECATED)
1475  
1476 =over 4
1477  
1478 =item Arguments: $target_namespace, @db_info
1479  
1480 =item Return Value: $new_schema
1481  
1482 =back
1483  
1484 DEPRECATED. You probably wanted compose_namespace.
1485  
1486 Actually, you probably just wanted to call connect.
1487  
1488 =begin hidden
1489  
1490 (hidden due to deprecation)
1491  
1492 Calls L<DBIx::Class::Schema/"compose_namespace"> to the target namespace,
1493 calls L<DBIx::Class::Schema/connection> with @db_info on the new schema,
1494 then injects the L<DBix::Class::ResultSetProxy> component and a
1495 resultset_instance classdata entry on all the new classes, in order to support
1496 $target_namespaces::$class->search(...) method calls.
1497  
1498 This is primarily useful when you have a specific need for class method access
1499 to a connection. In normal usage it is preferred to call
1500 L<DBIx::Class::Schema/connect> and use the resulting schema object to operate
1501 on L<DBIx::Class::ResultSet> objects with L<DBIx::Class::Schema/resultset> for
1502 more information.
1503  
1504 =end hidden
1505  
1506 =cut
1507  
1508 1 ▶sub compose_connection {
Subroutine compose_connection: called CC=5 SCAR=18.5
Pod documented
1509 1 my ($self, $target, @info) = @_;
1510  
1511 carp_once "compose_connection deprecated as of 0.08000"
1512 1 ▶ unless $INC{"DBIx/Class/CDBICompat.pm"};
Branch: 1 branch
BranchTrueFalseTotal
unless $INC{"DBIx/Class/CDBICompat.pm"} 1 0 1
1513  
1514 1 my $base = 'DBIx::Class::ResultSetProxy';
1515 1 ▶ try {
Subroutine __ANON__: called CC=1 SCAR=0.0
1516 1 eval "require ${base};"
1517 }
1518 0 ▶ catch {
Subroutine __ANON__: not called CC=1 SCAR=6.9
1519 0 $self->throw_exception
1520 ("No arguments to load_classes and couldn't load ${base} ($_)")
1521 1 };
1522  
1523 1 ▶ if ($self eq $target) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self eq $target) 0 1 1
1524 # Pathological case, largely caused by the docs on early C::M::DBIC::Plain
1525 0 foreach my $source_name ($self->sources) {
1526 0 my $source = $self->source($source_name);
1527 0 my $class = $source->result_class;
1528 0 $self->inject_base($class, $base);
1529 0 $class->mk_classdata(resultset_instance => $source->resultset);
1530 0 $class->mk_classdata(class_resolver => $self);
1531 }
1532 0 $self->connection(@info);
1533 0 return $self;
1534 }
1535  
1536 1 my $schema = $self->compose_namespace($target, $base);
1537 1 quote_sub "${target}::schema", '$s', { '$s' => \$schema };
1538  
1539 1 $schema->connection(@info);
1540 1 foreach my $source_name ($schema->sources) {
1541 46 my $source = $schema->source($source_name);
1542 46 my $class = $source->result_class;
1543 #warn "$source_name $class $source ".$source->storage;
1544 46 $class->mk_classdata(result_source_instance => $source);
1545 46 $class->mk_classdata(resultset_instance => $source->resultset);
1546 46 $class->mk_classdata(class_resolver => $schema);
1547 }
1548 1 return $schema;
1549 }
1550  
1551 =head1 FURTHER QUESTIONS?
1552  
1553 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
1554  
1555 =head1 COPYRIGHT AND LICENSE
1556  
1557 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
1558 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
1559 redistribute it and/or modify it under the same terms as the
1560 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
1561  
1562 =cut
1563  
1564 326 1;
« DBIx/Class/Storage/DBI/Sybase/Microsoft_SQL_Server.pm ↑ Summary DBIx/Class/CDBICompat/ColumnsAsHash.pm »