lib/DB/Object/Query/Elements.pm

filter: Statementstmt 19.6% 38 / 193 Branchbran 1.4% 1 / 68 Conditioncond 0.0% 0 / 73 MC/DCmcdc 0.0% 0 / 34 Subroutinesub 25.0% 10 / 40 Podpod 78.2% 18 / 23 totaltotal 15.5% 67 / 431 CC 69 SCAR 35.0
CC
69
Cov
12%
THAW
110.0
push
72.0
FREEZE
72.0
CRAP 33.1
« lib/DB/Object/Fields/Unknown.pm ↑ Summary blib/lib/DB/Object/Mysql.pm »
1 ##----------------------------------------------------------------------------
2 ## Database Object Interface - ~/lib/DB/Object/Query/Elements.pm
3 ## Version v0.2.1
4 ## Copyright(c) 2026 DEGUEST Pte. Ltd.
5 ## Author: Jacques Deguest <jack@deguest.jp>
6 ## Created 2023/07/08
7 ## Modified 2026/08/05
8 ## All rights reserved
9 ##
10 ## This program is free software; you can redistribute it and/or modify it
11 ## under the same terms as Perl itself.##
12 ##----------------------------------------------------------------------------##
13 package DB::Object::Query::Elements;
14 BEGIN
15 4 ▶{
Subroutine BEGIN: called CC=1 SCAR=0.0
16 4 ▶ use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
17 4 ▶ use common::sense;
Subroutine BEGIN: called CC=1 SCAR=0.0
18 4 warnings::register_categories( 'DB::Object' );
19 4 ▶ use parent qw( Module::Generic );
Subroutine BEGIN: called CC=1 SCAR=0.0
20 4 ▶ use vars qw( $VERSION $EXCEPTION_CLASS );
Subroutine BEGIN: called CC=1 SCAR=0.0
21 4 our $EXCEPTION_CLASS = $DB::Object::EXCEPTION_CLASS;
22 4 our $VERSION = 'v0.2.1';
23 };
24  
25 4 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
26 4 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
27  
28 sub init
29 1 ▶{
Subroutine init: called CC=2 SCAR=6.9
Pod documented
30 1 my $self = shift( @_ );
31 1 $self->{elements} = [];
32 1 $self->{query_object} = undef;
33 1 $self->{_init_strict_use_sub} = 1;
34 1 $self->{_exception_class} = $EXCEPTION_CLASS;
35 1 ▶ $self->SUPER::init( @_ ) || return( $self->pass_error );
Branch: 1 branch
BranchTrueFalseTotal
$self->SUPER::init(@_) or return $self->pass_error 1 0 1
36 1 $self->{_fields} = [qw( elements )];
37 1 $self->{_cache_fields} = '';
38 1 $self->{_cache_formats} = '';
39 1 $self->{_cache_types} = '';
40 1 $self->{_cache_values} = '';
41 1 return( $self );
42 }
43  
44 # We attach this elements collection to its query object
45 sub attach
46 0 ▶{
Subroutine attach: not called CC=6 SCAR=37.4
Pod documented
47 0 my $self = shift( @_ );
48 # Query object
49 0 ▶ my $qo = shift( @_ ) ||
Condition0%0/2
shift @_ || (return $self->error('No DB::Object::Query object was provided.'))
l!l
00
MC/DC0%0/1
shift @_ || (return $self->error('No DB::Object::Query object was provided.'))
shift @_
Truth table0%0/2
A
A= shift @_
Aresult
11
00
50 return( $self->error( "No DB::Object::Query object was provided." ) );
51 0 ▶ unless( $self->_is_a( $qo => 'DB::Object::Query' ) )
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->_is_a($qo, "DB::Object::Query")) 0 0 0
52 {
53 0 return( $self->error( "Value provided is not a DB::Object::Query object." ) );
54 }
55 0 ▶ $self->query_object( $qo ) || return( $self->pass_error );
Branch: 1 branch
BranchTrueFalseTotal
$self->query_object($qo) or return $self->pass_error 0 0 0
56 0 $self->debug( $qo->debug );
57 # We propagate ourself to all the elements in the collection.
58 0 ▶ if( my $elems = $self->elements )
Branch: 1 branch
BranchTrueFalseTotal
if (my $elems = $self->elements) 0 0 0
59 {
60 0 foreach my $elem ( @$elems )
61 {
62 0 $elem->attach( $self );
63 }
64 }
65 0 return( $self );
66 }
67  
68 # This is used to forward unknown method to Module::Generic::Array
69 sub autoload
70 0 ▶{
Subroutine autoload: not called CC=5 SCAR=30.7
Pod undocumented
71 0 my $self = shift( @_ );
72 0 ▶ my $meth = shift( @_ ) || return;
Condition0%0/2
shift @_ || (return)
l!l
00
MC/DC0%0/1
shift @_ || (return)
shift @_
Truth table0%0/2
A
A= shift @_
Aresult
11
00
73 0 ▶ my $elems = $self->elements || return;
Condition0%0/2
$self->elements || (return)
l!l
00
MC/DC0%0/1
$self->elements || (return)
$self->elements
Truth table0%0/2
A
A= $self->elements
Aresult
11
00
74 0 my $code;
75 0 ▶ if( $code = $elems->can( $meth ) )
Branch: 1 branch
BranchTrueFalseTotal
if ($code = $elems->can($meth)) 0 0 0
76 {
77 4 ▶ no strict 'refs';
Subroutine BEGIN: called CC=1 SCAR=0.0
78 my $sub = sub
79 0 ▶ {
Subroutine __ANON__: not called CC=1 SCAR=6.9
80 0 my $this = shift( @_ );
81 0 return( $code->( $this->elements, @_ ) );
82 0 };
83 0 *$meth = $sub;
84 0 return( $sub );
85 }
86 0 ▶ warn( "No method '$meth' supported by this class ", ref( $self ), " or by ", ref( $elems ) ) if( $self->_is_warnings_enabled( 'DB::Object' ) );
Branch: 1 branch
BranchTrueFalseTotal
if $self->_is_warnings_enabled("DB::Object") 0 0 0
87 0 return;
88 }
89  
90 # NOTE: sub clone is inherited from Module::Generic
91  
92 0 ▶sub elements { return( shift->reset(@_)->_set_get_object_array_object( 'elements', 'DB::Object::Query::Element', @_ ) ); }
Subroutine elements: not called CC=1 SCAR=6.9
Pod documented
93  
94 sub fields
95 0 ▶{
Subroutine fields: not called CC=4 SCAR=30.0
Pod documented
96 0 my $self = shift( @_ );
97 0 ▶ return( $self->{_cache_fields} ) if( $self->{_cache_fields} && !CORE::length( $self->{_reset} // '' ) );
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"_cache_fields"} and not CORE::length($self->{"_reset"} // "") 0 0 0
Condition0%0/5
$self->{"_cache_fields"} and not CORE::length($self->{"_reset"} // "")
!ll&&!rl&&r
000
$self->{"_reset"} // ""
l!l
00
MC/DC0%0/2
$self->{"_cache_fields"} and not CORE::length($self->{"_reset"} // "")
$self->{"_cache_fields"} $self->{"_reset"}
Truth table0%0/3
A and not(B)
A= $self->{"_cache_fields"}B= $self->{"_reset"}
ABresult
0X0
110
101
98 0 my $arr = $self->new_array;
99 0 my $e = $self->elements;
100 $e->foreach(sub
101 0 ▶ {
Subroutine __ANON__: not called CC=2 SCAR=17.9
102 0 my $o = shift( @_ );
103 0 ▶ $arr->push( defined( $o ) ? $o->field : undef );
Branch: 1 branch
BranchTrueFalseTotal
defined $o ? : 0 0 0
104 0 });
105 0 $self->{_cache_fields} = $arr;
106 0 CORE::delete( $self->{_reset} );
107 0 return( $arr );
108 }
109  
110 0 ▶sub for { return( shift->elements->for( @_ ) ); }
Subroutine for: not called CC=1 SCAR=6.9
Pod documented
111  
112 0 ▶sub foreach { return( shift->elements->foreach( @_ ) ); }
Subroutine foreach: not called CC=1 SCAR=6.9
Pod documented
113  
114 sub formats
115 0 ▶{
Subroutine formats: not called CC=4 SCAR=30.0
Pod documented
116 0 my $self = shift( @_ );
117 0 ▶ return( $self->{_cache_formats} ) if( $self->{_cache_formats} && !CORE::length( $self->{_reset} // '' ) );
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"_cache_formats"} and not CORE::length($self->{"_reset"} // "") 0 0 0
Condition0%0/5
$self->{"_cache_formats"} and not CORE::length($self->{"_reset"} // "")
!ll&&!rl&&r
000
$self->{"_reset"} // ""
l!l
00
MC/DC0%0/2
$self->{"_cache_formats"} and not CORE::length($self->{"_reset"} // "")
$self->{"_cache_formats"} $self->{"_reset"}
Truth table0%0/3
A and not(B)
A= $self->{"_cache_formats"}B= $self->{"_reset"}
ABresult
0X0
110
101
118 0 my $arr = $self->new_array;
119 0 my $e = $self->elements;
120 $e->foreach(sub
121 0 ▶ {
Subroutine __ANON__: not called CC=2 SCAR=17.9
122 0 my $o = shift( @_ );
123 0 ▶ $arr->push( defined( $o ) ? $o->format : undef );
Branch: 1 branch
BranchTrueFalseTotal
defined $o ? : 0 0 0
124 0 });
125 0 $self->{_cache_formats} = $arr;
126 0 CORE::delete( $self->{_reset} );
127 0 return( $arr );
128 }
129  
130 sub generics
131 0 ▶{
Subroutine generics: not called CC=4 SCAR=30.0
Pod documented
132 0 my $self = shift( @_ );
133 0 ▶ return( $self->{_cache_generics} ) if( $self->{_cache_generics} && !CORE::length( $self->{_reset} // '' ) );
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"_cache_generics"} and not CORE::length($self->{"_reset"} // "") 0 0 0
Condition0%0/5
$self->{"_cache_generics"} and not CORE::length($self->{"_reset"} // "")
!ll&&!rl&&r
000
$self->{"_reset"} // ""
l!l
00
MC/DC0%0/2
$self->{"_cache_generics"} and not CORE::length($self->{"_reset"} // "")
$self->{"_cache_generics"} $self->{"_reset"}
Truth table0%0/3
A and not(B)
A= $self->{"_cache_generics"}B= $self->{"_reset"}
ABresult
0X0
110
101
134 0 my $arr = $self->new_array;
135 0 my $e = $self->elements;
136 $e->foreach(sub
137 0 ▶ {
Subroutine __ANON__: not called CC=2 SCAR=17.9
138 0 my $o = shift( @_ );
139 0 ▶ $arr->push( defined( $o ) ? $o->generic : '?' );
Branch: 1 branch
BranchTrueFalseTotal
defined $o ? : 0 0 0
140 0 });
141 0 $self->{_cache_generics} = $arr;
142 0 CORE::delete( $self->{_reset} );
143 0 return( $arr );
144 }
145  
146 0 ▶sub is_empty { return( shift->elements->is_empty ); }
Subroutine is_empty: not called CC=1 SCAR=6.9
Pod documented
147  
148 0 ▶sub length { return( shift->elements->length ); }
Subroutine length: not called CC=1 SCAR=6.9
Pod documented
149  
150 # This merge one or more objects of the same class into this one
151 sub merge
152 0 ▶{
Subroutine merge: not called CC=5 SCAR=34.0
Pod documented
153 0 my $self = shift( @_ );
154 0 my $elems = $self->elements;
155 0 CORE::foreach my $this ( @_ )
156 {
157 0 ▶ if( !$self->_is_a( $this => 'DB::Object::Query::Elements' ) )
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->_is_a($this, "DB::Object::Query::Elements")) 0 0 0
158 {
159 0 ▶ warn( "Element provided '", overload::StrVal( $this ), "' is not an DB::Object::Query::Elements or DB::Object::Query::Clause object" ) if( $self->_is_warnings_enabled( 'DB::Object' ) );
Branch: 1 branch
BranchTrueFalseTotal
if $self->_is_warnings_enabled("DB::Object") 0 0 0
160 0 next;
161 }
162  
163 0 $elems->push( $this->elements->list );
164 }
165 # Make sure our elements are in the right order
166 0 $self->_sort;
167 0 ▶ $self->reset(1) if( scalar( @_ ) );
Branch: 1 branch
BranchTrueFalseTotal
if scalar @_ 0 0 0
168 0 return( $self );
169 }
170  
171 sub new_element
172 0 ▶{
Subroutine new_element: not called CC=2 SCAR=17.9
Pod documented
173 0 my $self = shift( @_ );
174 0 ▶ my $el = $self->query_object->new_element( @_ ) ||
Condition0%0/2
$self->query_object->new_element(@_) || (return $self->pass_error($self->query_object->error))
l!l
00
MC/DC0%0/1
$self->query_object->new_element(@_) || (return $self->pass_error($self->query_object->error))
$self->query_object->new_element(@_)
Truth table0%0/2
A
A= $self->query_object->new_element(@_)
Aresult
11
00
175 return( $self->pass_error( $self->query_object->error ) );
176 0 return( $el );
177 }
178  
179 sub push
180 0 ▶{
Subroutine push: not called CC=8 SCAR=42.8
Pod documented
181 0 my $self = shift( @_ );
182 0 my $e = $self->elements;
183 0 CORE::foreach my $elem ( @_ )
184 {
185 0 my( $o );
186 # This works also for DB::Object::Query::Clause that inherits from DB::Object::Query::Elements
187 0 ▶ if( $self->_is_a( $elem => 'DB::Object::Query::Elements' ) )
Branch: 3 branches
BranchTrueFalseTotal
if ($self->_is_a($elem, 'DB::Object::Query::Elements')) { } 0 0 0
elsif ($self->_is_a($elem, 'DB::Object::Query::Element')) { } 0 0 0
elsif (ref $elem eq 'HASH') { } 0 0 0
188 {
189 0 $self->push( $elem->elements->list );
190 0 next;
191 }
192 elsif( $self->_is_a( $elem => 'DB::Object::Query::Element' ) )
193 {
194 0 $o = $elem;
195 }
196 elsif( ref( $elem ) eq 'HASH' )
197 {
198 0 ▶ $o = $self->new_element( %$elem ) || return( $self->pass_error );
Condition0%0/2
$self->new_element(%$elem) || (return $self->pass_error)
l!l
00
MC/DC0%0/1
$self->new_element(%$elem) || (return $self->pass_error)
$self->new_element(%$elem)
Truth table0%0/2
A
A= $self->new_element(%$elem)
Aresult
11
00
199 }
200 else
201 {
202 0 ▶ return( $self->error( "Unknown value '", ( $elem // 'undef' ), "' to add as element to our clause elements stack." ) );
Condition0%0/2
$elem // "undef"
l!l
00
MC/DC0%0/1
$elem // "undef"
$elem
Truth table0%0/2
A
A= $elem
Aresult
11
00
203 }
204  
205 # Order does not really matter, we just stack them, and after we will sort them by their object property 'index' value, if necessary
206 0 $e->push( $o );
207 }
208 # Make sure our elements are in the right order
209 0 $self->_sort;
210 0 ▶ $self->reset(1) if( scalar( @_ ) );
Branch: 1 branch
BranchTrueFalseTotal
if scalar @_ 0 0 0
211 0 return( $self );
212 }
213  
214 1 ▶sub query_object { return( shift->_set_get_object( 'query_object', 'DB::Object::Query', @_ ) ); }
Subroutine query_object: called CC=1 SCAR=0.0
Pod documented
215  
216 sub reset
217 0 ▶{
Subroutine reset: not called CC=4 SCAR=30.0
Pod documented
218 0 my $self = shift( @_ );
219 0 ▶ if( !CORE::length( $self->{_reset} // '' ) && scalar( @_ ) )
Branch: 1 branch
BranchTrueFalseTotal
if (not CORE::length($self->{"_reset"} // "") and scalar @_) 0 0 0
Condition0%0/4
not CORE::length($self->{"_reset"} // "") and scalar @_
!ll
00
$self->{"_reset"} // ""
l!l
00
MC/DC0%0/1
not CORE::length($self->{"_reset"} // "") and scalar @_
$self->{"_reset"}
Truth table0%0/2
not(A)
A= $self->{"_reset"}
Aresult
10
01
220 {
221 0 $self->{_reset} = scalar( @_ );
222 }
223 0 return( $self );
224 }
225  
226 sub sort
227 0 ▶{
Subroutine sort: not called CC=1 SCAR=6.9
Pod documented
228 0 my $self = shift( @_ );
229 my $elems = $self->elements->sort(sub
230 0 ▶ {
Subroutine __ANON__: not called CC=1 SCAR=6.9
231 0 my( $a, $b ) = @_;
232 0 return( $a->index <=> $b->index );
233 0 });
234 0 my $clone = $self->clone;
235 0 $clone->elements( $elems );
236 0 return( $clone );
237 }
238  
239 sub types
240 0 ▶{
Subroutine types: not called CC=4 SCAR=30.0
Pod documented
241 0 my $self = shift( @_ );
242 0 ▶ return( $self->{_cache_types} ) if( $self->{_cache_types} && !CORE::length( $self->{_reset} // '' ) );
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"_cache_types"} and not CORE::length($self->{"_reset"} // "") 0 0 0
Condition0%0/5
$self->{"_cache_types"} and not CORE::length($self->{"_reset"} // "")
!ll&&!rl&&r
000
$self->{"_reset"} // ""
l!l
00
MC/DC0%0/2
$self->{"_cache_types"} and not CORE::length($self->{"_reset"} // "")
$self->{"_cache_types"} $self->{"_reset"}
Truth table0%0/3
A and not(B)
A= $self->{"_cache_types"}B= $self->{"_reset"}
ABresult
0X0
110
101
243 0 my $arr = $self->new_array;
244 0 my $e = $self->elements;
245 $e->foreach(sub
246 0 ▶ {
Subroutine __ANON__: not called CC=2 SCAR=17.9
247 0 my $o = shift( @_ );
248 0 ▶ $arr->push( defined( $o->type ) ? $o : undef );
Branch: 1 branch
BranchTrueFalseTotal
defined $o->type ? : 0 0 0
249 0 });
250 0 $self->{_cache_types} = $arr;
251 0 CORE::delete( $self->{_reset} );
252 0 return( $arr );
253 }
254  
255 sub values
256 0 ▶{
Subroutine values: not called CC=4 SCAR=30.0
Pod documented
257 0 my $self = shift( @_ );
258 0 ▶ return( $self->{_cache_values} ) if( $self->{_cache_values} && !CORE::length( $self->{_reset} // '' ) );
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"_cache_values"} and not CORE::length($self->{"_reset"} // "") 0 0 0
Condition0%0/5
$self->{"_cache_values"} and not CORE::length($self->{"_reset"} // "")
!ll&&!rl&&r
000
$self->{"_reset"} // ""
l!l
00
MC/DC0%0/2
$self->{"_cache_values"} and not CORE::length($self->{"_reset"} // "")
$self->{"_cache_values"} $self->{"_reset"}
Truth table0%0/3
A and not(B)
A= $self->{"_cache_values"}B= $self->{"_reset"}
ABresult
0X0
110
101
259 0 my $arr = $self->new_array;
260 0 my $e = $self->elements;
261 $e->foreach(sub
262 0 ▶ {
Subroutine __ANON__: not called CC=2 SCAR=17.9
263 0 my $o = shift( @_ );
264 0 ▶ $arr->push( defined( $o ) ? $o->value : undef );
Branch: 1 branch
BranchTrueFalseTotal
defined $o ? : 0 0 0
265 0 });
266 0 $self->{_cache_values} = $arr;
267 0 CORE::delete( $self->{_reset} );
268 0 return( $arr );
269 }
270  
271 sub _sort
272 0 ▶{
Subroutine _sort: not called CC=5 SCAR=34.0
273 0 my $self = shift( @_ );
274 0 my $e = $self->elements;
275 0 my $el;
276 # We check the first element to decide whether the placeholders, if any, are numbered or not.
277 $e->foreach(sub
278 0 ▶ {
Subroutine __ANON__: not called CC=4 SCAR=30.0
279 0 my $this = shift( @_ );
280 0 ▶ if( $self->_is_object( $this ) &&
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_is_object($this) and $self->_can($this, "is_numbered") and $this->is_numbered) 0 0 0
Condition0%0/6
$self->_is_object($this) and $self->_can($this, "is_numbered") and $this->is_numbered
!ll&&!rl&&r
000
$self->_is_object($this) and $self->_can($this, "is_numbered")
!ll&&!rl&&r
000
MC/DC0%0/3
$self->_is_object($this) and $self->_can($this, "is_numbered") and $this->is_numbered
$self->_is_object($this) $self->_can($this, "is_numbered") $this->is_numbered
Truth table0%0/4
A and B and C
A= $self->_is_object($this)B= $self->_can($this, "is_numbered")C= $this->is_numbered
ABCresult
0XX0
10X0
1100
1111
281 $self->_can( $this => 'is_numbered' ) &&
282 $this->is_numbered )
283 {
284 0 $el = $this;
285 0 return(0);
286 }
287 0 });
288 0 ▶ if( $el && $el->placeholder && $el->is_numbered )
Branch: 1 branch
BranchTrueFalseTotal
if ($el and $el->placeholder and $el->is_numbered) 0 0 0
Condition0%0/6
$el and $el->placeholder and $el->is_numbered
!ll&&!rl&&r
000
$el and $el->placeholder
!ll&&!rl&&r
000
MC/DC0%0/3
$el and $el->placeholder and $el->is_numbered
$el $el->placeholder $el->is_numbered
Truth table0%0/4
A and B and C
A= $elB= $el->placeholderC= $el->is_numbered
ABCresult
0XX0
10X0
1100
1111
289 {
290 0 my $sorted = $self->sort->elements;
291 0 ▶ $self->elements( $sorted ) if( $sorted );
Branch: 1 branch
BranchTrueFalseTotal
if $sorted 0 0 0
292 }
293 0 return( $self );
294 }
295  
296 sub FREEZE
297 0 ▶{
Subroutine FREEZE: not called CC=8 SCAR=42.8
Pod undocumented
298 0 my $self = CORE::shift( @_ );
299 0 ▶ my $serialiser = CORE::shift( @_ ) // '';
Condition0%0/2
shift @_ // ""
l!l
00
MC/DC0%0/1
shift @_ // ""
shift @_
Truth table0%0/2
A
A= shift @_
Aresult
11
00
300 0 my $class = CORE::ref( $self );
301  
302 # We keep a strict allow-list to avoid accidentally freezing DBI handles or other
303 # process-local state.
304 0 my @props = @{$self->{_fields}};
305  
306 0 my $hash = {};
307 0 foreach my $prop ( @props )
308 {
309 0 ▶ if( CORE::exists( $self->{ $prop } ) &&
Branch: 1 branch
BranchTrueFalseTotal
if (exists $self->{$prop} and defined $self->{$prop} and ref $self->{$prop} ne "CODE") 0 0 0
Condition0%0/6
exists $self->{$prop} and defined $self->{$prop} and ref $self->{$prop} ne "CODE"
!ll&&!rl&&r
000
exists $self->{$prop} and defined $self->{$prop}
!ll&&!rl&&r
000
MC/DC0%0/3
exists $self->{$prop} and defined $self->{$prop} and ref $self->{$prop} ne "CODE"
exists $self->{$prop} defined $self->{$prop} ref $self->{$prop} ne "CODE"
Truth table0%0/4
A and B and C
A= exists $self->{$prop}B= defined $self->{$prop}C= ref $self->{$prop} ne "CODE"
ABCresult
0XX0
10X0
1100
1111
310 defined( $self->{ $prop } ) &&
311 CORE::ref( $self->{ $prop } ) ne 'CODE' )
312 {
313 0 $hash->{ $prop } = $self->{ $prop };
314 }
315 }
316  
317 # Return an array reference rather than a list so this works with Sereal and CBOR.
318 # Before Sereal version 4.023, Sereal did not support multiple values returned.
319 0 ▶ if( $serialiser eq 'Sereal' )
Branch: 1 branch
BranchTrueFalseTotal
if ($serialiser eq "Sereal") 0 0 0
320 {
321 0 require Sereal::Encoder;
322 0 require version;
323  
324 0 ▶ if( version->parse( Sereal::Encoder->VERSION ) < version->parse( '4.023' ) )
Branch: 1 branch
BranchTrueFalseTotal
if ("version"->parse("Sereal::Encoder"->VERSION) < "version"->parse("4.023")) 0 0 0
325 {
326 0 CORE::return( [$class, $hash] );
327 }
328 }
329  
330 # But Storable wants a list with the first element being the serialised element
331 0 CORE::return( $class, $hash );
332 }
333  
334 0 ▶sub STORABLE_freeze { return( shift->FREEZE( @_ ) ); }
Subroutine STORABLE_freeze: not called CC=1 SCAR=6.9
Pod undocumented
335  
336 0 ▶sub STORABLE_thaw { return( shift->THAW( @_ ) ); }
Subroutine STORABLE_thaw: not called CC=1 SCAR=6.9
Pod undocumented
337  
338 sub THAW
339 0 ▶{
Subroutine THAW: not called CC=10 SCAR=47.0
Pod undocumented
340 # STORABLE_thaw would issue $cloning as the 2nd argument, while CBOR would issue
341 # 'CBOR' as the second value.
342 0 my( $self, undef, @args ) = @_;
343 0 ▶ my $ref = ( CORE::scalar( @args ) == 1 && CORE::ref( $args[0] ) eq 'ARRAY' ) ? CORE::shift( @args ) : \@args;
Branch: 1 branch
BranchTrueFalseTotal
scalar @args == 1 && ref $args[0] eq 'ARRAY' ? : 0 0 0
Condition0%0/3
scalar @args == 1 and ref $args[0] eq "ARRAY"
!ll&&!rl&&r
000
MC/DC0%0/2
scalar @args == 1 and ref $args[0] eq "ARRAY"
scalar @args == 1 ref $args[0] eq "ARRAY"
Truth table0%0/3
A and B
A= scalar @args == 1B= ref $args[0] eq "ARRAY"
ABresult
0X0
100
111
344 0 ▶ my $class = ( CORE::defined( $ref ) && CORE::ref( $ref ) eq 'ARRAY' && CORE::scalar( @$ref ) > 1 ) ? CORE::shift( @$ref ) : ( CORE::ref( $self ) || $self );
Branch: 1 branch
BranchTrueFalseTotal
defined $ref && ref $ref eq 'ARRAY' && scalar @$ref > 1 ? : 0 0 0
Condition0%0/9
defined $ref and ref $ref eq "ARRAY" and scalar @$ref > 1
!ll&&!rl&&r
000
defined $ref and ref $ref eq "ARRAY"
!ll&&!rl&&r
000
ref $self or $self
l!l&&r!l&&!r
000
MC/DC0%0/3
defined $ref and ref $ref eq "ARRAY" and scalar @$ref > 1
defined $ref ref $ref eq "ARRAY" scalar @$ref > 1
MC/DC0%0/2
ref $self or $self
ref $self $self
Truth table0%0/4
A and B and C
A= defined $refB= ref $ref eq "ARRAY"C= scalar @$ref > 1
ABCresult
0XX0
10X0
1100
1111
Truth table0%0/3
A or B
A= ref $selfB= $self
ABresult
1X1
011
000
345 0 ▶ my $hash = CORE::ref( $ref ) eq 'ARRAY' ? CORE::shift( @$ref ) : {};
Branch: 1 branch
BranchTrueFalseTotal
ref $ref eq 'ARRAY' ? : 0 0 0
346 0 my $new;
347 # Storable pattern requires to modify the object it created rather than returning a new one
348 0 ▶ if( CORE::ref( $self ) )
Branch: 1 branch
BranchTrueFalseTotal
if (ref $self) { } 0 0 0
349 {
350 0 foreach( CORE::keys( %$hash ) )
351 {
352 0 $self->{ $_ } = CORE::delete( $hash->{ $_ } );
353 }
354 0 $new = $self;
355 }
356 else
357 {
358 0 $new = CORE::bless( $hash => $class );
359 }
360 0 CORE::return( $new );
361 }
362  
363 4 1;
364 # NOTE: POD
365 __END__
« lib/DB/Object/Fields/Unknown.pm ↑ Summary blib/lib/DB/Object/Mysql.pm »