← Index
NYTProf Performance Profile   « block view • line view • sub view »
For 05.Domain_and_Item.t
  Run on Tue May 4 17:21:41 2010
Reported on Tue May 4 17:22:20 2010

File /data/SimpleDB-Class/author.t/../lib/SimpleDB/Class/Item.pm
Statements Executed 2114
Statement Execution Time 7.52ms
Subroutines — ordered by exclusive time
Calls P F Exclusive
Time
Inclusive
Time
Subroutine
1112.62ms11.2msSimpleDB::Class::Item::::BEGIN@18SimpleDB::Class::Item::BEGIN@18
12222.14ms4.18sSimpleDB::Class::Item::::putSimpleDB::Class::Item::put
79111.66ms17.7msSimpleDB::Class::Item::::stringify_valuesSimpleDB::Class::Item::stringify_values
1844809µs6.33msSimpleDB::Class::Item::::to_hashrefSimpleDB::Class::Item::to_hashref
2231456µs4.37msSimpleDB::Class::Item::::stringify_valueSimpleDB::Class::Item::stringify_value
8922451µs963µsSimpleDB::Class::Item::::CORE:matchSimpleDB::Class::Item::CORE:match (opcode)
444345µs17.0msSimpleDB::Class::Item::::add_attributesSimpleDB::Class::Item::add_attributes
421109µs11.2msSimpleDB::Class::Item::::parse_valueSimpleDB::Class::Item::parse_value
11184µs320msSimpleDB::Class::Item::::copySimpleDB::Class::Item::copy
321183µs83µsSimpleDB::Class::Item::::_castor_attributeSimpleDB::Class::Item::_castor_attribute
22260µs4.04msSimpleDB::Class::Item::::belongs_toSimpleDB::Class::Item::belongs_to
33354µs92µsSimpleDB::Class::Item::::set_domain_nameSimpleDB::Class::Item::set_domain_name
104152µs68µsSimpleDB::Class::Item::::_install_subSimpleDB::Class::Item::_install_sub
91144µs1.63msSimpleDB::Class::Item::::generate_uuidSimpleDB::Class::Item::generate_uuid
11139µs500µsSimpleDB::Class::Item::::updateSimpleDB::Class::Item::update
51138µs2.91msSimpleDB::Class::Item::::__ANON__[../lib/SimpleDB/Class/Item.pm:87]SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:87]
22232µs42µsSimpleDB::Class::Item::::has_manySimpleDB::Class::Item::has_many
11131µs1.29msSimpleDB::Class::Item::::__ANON__[../lib/SimpleDB/Class/Item.pm:280]SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:280]
11129µs2.16msSimpleDB::Class::Item::::BEGIN@17SimpleDB::Class::Item::BEGIN@17
81122µs22µsSimpleDB::Class::Item::::__ANON__[../lib/SimpleDB/Class/Item.pm:90]SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:90]
11119µs3.60msSimpleDB::Class::Item::::BEGIN@19SimpleDB::Class::Item::BEGIN@19
41111µs11µsSimpleDB::Class::Item::::__ANON__[../lib/SimpleDB/Class/Item.pm:92]SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:92]
1119µs15µsSimpleDB::Class::Item::::recast_usingSimpleDB::Class::Item::recast_using
1118µs26µsSimpleDB::Class::Item::::BEGIN@25SimpleDB::Class::Item::BEGIN@25
3116µs6µsSimpleDB::Class::Item::::attributesSimpleDB::Class::Item::attributes
1115µs5µsSimpleDB::Class::Item::::BEGIN@20SimpleDB::Class::Item::BEGIN@20
0000s0sSimpleDB::Class::Item::::__ANON__[../lib/SimpleDB/Class/Item.pm:113]SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:113]
0000s0sSimpleDB::Class::Item::::__ANON__[../lib/SimpleDB/Class/Item.pm:208]SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:208]
0000s0sSimpleDB::Class::Item::::__ANON__[../lib/SimpleDB/Class/Item.pm:289]SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:289]
0000s0sSimpleDB::Class::Item::::__ANON__[../lib/SimpleDB/Class/Item.pm:316]SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:316]
0000s0sSimpleDB::Class::Item::::__ANON__[../lib/SimpleDB/Class/Item.pm:48]SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:48]
0000s0sSimpleDB::Class::Item::::__ANON__[../lib/SimpleDB/Class/Item.pm:89]SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:89]
0000s0sSimpleDB::Class::Item::::__ANON__[../lib/SimpleDB/Class/Item.pm:91]SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:91]
0000s0sSimpleDB::Class::Item::::deleteSimpleDB::Class::Item::delete
0000s0sSimpleDB::Class::Item::::delete_attributeSimpleDB::Class::Item::delete_attribute
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments
Time
on line
Calls Time
in subs
Code
1package SimpleDB::Class::Item;
2
3=head1 NAME
4
5SimpleDB::Class::Item - An object representation from an item in a SimpleDB domain.
6
7=head1 DESCRIPTION
8
9An object representation from an item in a SimpleDB domain.
10
11=head1 METHODS
12
13The following methods are available from this class.
14
15=cut
16
17331µs24.30ms
# spent 2.16ms (29µs+2.14) within SimpleDB::Class::Item::BEGIN@17 which was called # once (29µs+2.14ms) by Class::MOP::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm:103] at line 17
use Moose;
# spent 2.16ms making 1 call to SimpleDB::Class::Item::BEGIN@17 # spent 2.14ms making 1 call to Moose::Exporter::__ANON__[Moose/Exporter.pm:389]
183130µs211.3ms
# spent 11.2ms (2.62+8.59) within SimpleDB::Class::Item::BEGIN@18 which was called # once (2.62ms+8.59ms) by Class::MOP::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm:103] at line 18
use UUID::Tiny;
# spent 11.2ms making 1 call to SimpleDB::Class::Item::BEGIN@18 # spent 96µs making 1 call to Exporter::import
19372µs27.17ms
# spent 3.60ms (19µs+3.58) within SimpleDB::Class::Item::BEGIN@19 which was called # once (19µs+3.58ms) by Class::MOP::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm:103] at line 19
use SimpleDB::Class::Types ':all';
# spent 3.60ms making 1 call to SimpleDB::Class::Item::BEGIN@19 # spent 3.58ms making 1 call to MooseX::Types::Base::import
20336µs15µs
# spent 5µs within SimpleDB::Class::Item::BEGIN@20 which was called # once (5µs+0s) by Class::MOP::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm:103] at line 20
use Sub::Name ();
# spent 5µs making 1 call to SimpleDB::Class::Item::BEGIN@20
21
22#--------------------------------------------------------
23
# spent 68µs (52+17) within SimpleDB::Class::Item::_install_sub which was called 10 times, avg 7µs/call: # 4 times (23µs+7µs) by SimpleDB::Class::Item::add_attributes at line 113, avg 7µs/call # 3 times (17µs+5µs) by SimpleDB::Class::Item::set_domain_name at line 48, avg 7µs/call # 2 times (8µs+3µs) by SimpleDB::Class::Item::has_many at line 208, avg 5µs/call # once (5µs+2µs) by SimpleDB::Class::Item::recast_using at line 316
sub _install_sub {
242079µs my ($name, $sub) = @_;
2531.34ms245µs
# spent 26µs (8+18) within SimpleDB::Class::Item::BEGIN@25 which was called # once (8µs+18µs) by Class::MOP::__ANON__[/usr/local/lib/perl5/site_perl/5.10.1/darwin-2level/Class/MOP.pm:103] at line 25
no strict 'refs';
# spent 26µs making 1 call to SimpleDB::Class::Item::BEGIN@25 # spent 18µs making 1 call to strict::unimport
26 *{$name} = Sub::Name::subname($name, $sub);
# spent 16µs making 10 calls to Sub::Name::subname, avg 2µs/call
27}
28
29#--------------------------------------------------------
30
31=head2 set_domain_name ( name )
32
33Class method. Used to set the SimpleDB domain name associated with a sublcass.
34
35=head3 name
36
37The domain name to set.
38
39=head2 domain_name ( )
40
41Class method. After set_domain_name() has been called, there will be a domain_name method, that will return the value of the domain name.
42
43=cut
44
45
# spent 92µs (54+38) within SimpleDB::Class::Item::set_domain_name which was called 3 times, avg 31µs/call: # once (18µs+14µs) by Module::Find::useall at line 6 of lib/Foo/Child.pm # once (18µs+12µs) by Module::Find::useall at line 6 of lib/Foo/Domain.pm # once (18µs+12µs) by Module::Find::useall at line 6 of lib/Foo/Parent.pm
sub set_domain_name {
461543µs my ($class, $name) = @_;
47 # inject domain_name sub
4856214µs322µs _install_sub($class.'::domain_name', sub { return $name });
# spent 22µs making 3 calls to SimpleDB::Class::Item::_install_sub, avg 7µs/call
49 # register the name and class with the schema
50 my $names = SimpleDB::Class->domain_names;
# spent 11µs making 3 calls to SimpleDB::Class::domain_names, avg 4µs/call
51 $names->{$name} = $class;
52 SimpleDB::Class->domain_names($names);
# spent 5µs making 3 calls to SimpleDB::Class::domain_names, avg 2µs/call
53}
54
55#--------------------------------------------------------
56
57=head2 add_attributes ( list )
58
59Class method. Adds more attributes to this class. B<NOTE:> This will add a method to your class which can be used as an accessor/mutator. Therefore make sure to avoid method name conflicts with this class.
60
61=head3 list
62
63A hashref that holds a list of attributes and their properties (a hashref itself). Example: title => { isa => 'Str', default => 'Untitled' }
64
65=head4 attribute
66
67The attribute name is key in the hashref.
68
69=head4 isa
70
71The type of data represented by this attribute. See L<SimpleDB::Class::Types> for the available types.
72
73=head4 default
74
75The default value for this attribute. This should be specified even if it is 'None' or 'Undefined' or 'Null', because actuall null queries are slow in SimpleDB.
76
77=head4 trigger
78
79A sub reference that will be called like a method (has reference to $self), and is also passed the new and old values of this attribute. Behind the scenes is a L<Moose> trigger. See also L<Moose::Manual::Attributes/"Triggers">.
80
81=cut
82
83
# spent 17.0ms (345µs+16.7) within SimpleDB::Class::Item::add_attributes which was called 4 times, avg 4.25ms/call: # once (152µs+11.2ms) by Module::Find::useall at line 15 of lib/Foo/Domain.pm # once (81µs+2.75ms) by Module::Find::useall at line 7 of lib/Foo/Child.pm # once (62µs+1.40ms) by Module::Find::useall at line 7 of lib/Foo/Parent.pm # once (50µs+1.33ms) by Module::Find::useall at line 6 of lib/Foo/SubChild.pm
sub add_attributes {
8498299µs my ($class, %attributes) = @_;
85 my %defaults = (
86 Str => '',
87538µs52.87ms
# spent 2.91ms (38µs+2.87) within SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:87] which was called 5 times, avg 582µs/call: # 5 times (38µs+2.87ms) by Class::MOP::Mixin::AttributeCore::default at line 53 of Class/MOP/Mixin/AttributeCore.pm, avg 582µs/call
DateTime => sub { DateTime->now() },
# spent 2.87ms making 5 calls to DateTime::now, avg 575µs/call
88 Int => 0,
89 ArrayRefOfInt => sub { [] },
90825µs
# spent 22µs within SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:90] which was called 8 times, avg 3µs/call: # 8 times (22µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of Class/MOP/Mixin/AttributeCore.pm, avg 3µs/call
ArrayRefOfStr => sub { [] },
91 ArrayRefOfDateTime => sub { [] },
92412µs
# spent 11µs within SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:92] which was called 4 times, avg 3µs/call: # 4 times (11µs+0s) by Class::MOP::Mixin::AttributeCore::default at line 53 of Class/MOP/Mixin/AttributeCore.pm, avg 3µs/call
HashRef => sub { {} },
93 MediumStr => '',
94 );
95 foreach my $name (keys %attributes) {
96 my $type = $attributes{$name}{isa} || 'Str';
97 my $isa = 'SimpleDB::Class::Types::Sdb'.$type;
98 my %properties = (
99 is => 'rw',
100 isa => $isa,
101 coerce => 1,
102 default => $attributes{$name}{default} || $defaults{$type},
103 );
104 if ($type ne 'Str') { # don't do any work we don't have to
105 $properties{lazy} = 1;
106 }
107 if (defined $attributes{$name}{trigger}) {
108 $properties{trigger} = $attributes{$name}{trigger};
109 }
110 $class->meta->add_attribute($name, \%properties);
# spent 16.5ms making 13 calls to Moose::Meta::Class::add_attribute, avg 1.27ms/call # spent 77µs making 9 calls to Foo::Domain::meta, avg 9µs/call # spent 24µs making 2 calls to Foo::Child::meta, avg 12µs/call # spent 10µs making 1 call to Foo::Parent::meta # spent 9µs making 1 call to Foo::SubChild::meta
111 }
112 my %new = (%{$class->attributes}, %attributes);
# spent 6µs making 3 calls to SimpleDB::Class::Item::attributes, avg 2µs/call # spent 2µs making 1 call to Foo::Child::attributes
1132179µs429µs _install_sub($class.'::attributes', sub { return \%new; });
# spent 29µs making 4 calls to SimpleDB::Class::Item::_install_sub, avg 7µs/call
114}
115
116
117#--------------------------------------------------------
118
119=head2 has_many ( method, class, attribute )
120
121Class method. Sets up a 1:N relationship between this class and a child class.
122
123WARNING: With this method you need to be aware that SimpleDB is eventually consistent. See L<SimpleDB::Class/"Eventual Consistency"> for details.
124
125=head3 method
126
127The name of the method in this class you wish to use to access the relationship with the child class.
128
129=head3 class
130
131The class name of the class you're creating the child relationship with.
132
133=head3 attribute
134
135The attribute in the child class that represents this class' id.
136
137=head3 options
138
139A hash containing options that will modify the method created.
140
141=head4 mate
142
143The name of the attribute that will be created in C<class> to refer back to this object. If specified, a reference to this object will be set in C<class> when it is instantiated to avoid stale references.
144
145=head4 consistent
146
147A boolean which can enable SimpleDB's ConsistentRead option. Defaults to 0.
148
149=head2 I<has_many_generated_method> ( [ options ] )
150
151This is the documentation for the method generated by C<has_many>. It returns a L<SimpleDB::Class::ResultSet> object with a list of the related children to this class.
152
153=head3 options
154
155A hash of options to modify the result set at run time.
156
157=head4 where
158
159A where clause as defined by L<SimpleDB::Class::SQL>. This new clause will automatically be added to the relationship clause, so whatever you specify here is only to further limit the results returned.
160
161=head4 order_by
162
163An order_by clause as defined by L<SimpleDB::Class::SQL>. By default no order is specified.
164
165=head4 limit
166
167A limit clause as defined by L<SimpleDB::Class::SQL>. By default all items in the relationship will be returned.
168
169=head4 consistent
170
171A boolean that can enable SimpleDB's ConsistentRead option. Setting this will override whatever was set in C<has_many>, if anything.
172
173=head4 set
174
175A hash reference of attribute names and values that will be applied to each object returned from the result set. The C<mate> option in C<has_many> can already set one of these.
176
177=cut
178
179
# spent 42µs (32+11) within SimpleDB::Class::Item::has_many which was called 2 times, avg 21µs/call: # once (19µs+5µs) by Module::Find::useall at line 8 of lib/Foo/Parent.pm # once (13µs+5µs) by Module::Find::useall at line 23 of lib/Foo/Domain.pm
sub has_many {
180431µs my ($class, $name, $classname, $attribute, %options) = @_;
181 _install_sub($class.'::'.$name, sub {
18230101µs my ($self, %sub_options) = @_;
183 my %search_options = (
# spent 17µs making 3 calls to SimpleDB::Class::Item::id, avg 6µs/call
184 where => {$attribute => $self->id},
185 );
186 if (exists $sub_options{where}) {
187 $search_options{where}{'-and'} = $sub_options{where};
188 }
189 if ($sub_options{order_by}) {
190 $search_options{order_by} = $sub_options{order_by};
191 }
192 if ($sub_options{limit}) {
193 $search_options{limit} = $sub_options{limit};
194 }
195 if (exists $sub_options{set}) {
196 $search_options{set} = $sub_options{set};
197 }
198 if ($options{mate}) {
199 $search_options{set}{$options{mate}} = $self;
200 }
201 if (exists $options{consistent}) {
202 $search_options{consistent} = $options{consistent};
203 }
204 if (exists $sub_options{consistent}) {
205 $search_options{consistent} = $sub_options{consistent};
206 }
207 return $self->simpledb->domain($classname)->search(%search_options);
# spent 426µs making 3 calls to SimpleDB::Class::Domain::search, avg 142µs/call # spent 246µs making 3 calls to SimpleDB::Class::domain, avg 82µs/call # spent 11µs making 3 calls to SimpleDB::Class::Item::simpledb, avg 4µs/call
208 });
# spent 11µs making 2 calls to SimpleDB::Class::Item::_install_sub, avg 5µs/call
209}
210
211#--------------------------------------------------------
212
213=head2 belongs_to ( method, class, attribute )
214
215Class method. Adds a 1:N relationship between another class and this one.
216
217=head3 method
218
219The method name to create to represent this relationship in this class.
220
221=head3 class
222
223The class name of the parent class you're relating this class to.
224
225=head3 attribute
226
227The attribute in this class' attribute list that represents the id of the parent class.
228
229=head3 options
230
231A hash of options to modify the created method.
232
233=head4 mate
234
235The name of the attribute that will be created in C<class> to refer back to this object. If specified, a reference to this object will be set in C<class> when it is instantiated to avoid stale references. This would only be useful in the case of a 1:1 relationship.
236
237=head4 consistent
238
239A boolean indicating whether to enable the SimpleDB's ConsistentRead option.
240
241=head2 I<belongs_to_generated_method> ( [ item ] )
242
243This is the documentation for the method that C<belongs_to> generates. This method caches the item it retrieves for faster future retrievals.
244
245B<NOTE:> Will return C<undef> if the attribute specified has no value at the time it is called.
246
247=head3 item
248
249You can optionally precache the item that this method would produce, if you already have it by passing it to the method here. If you choose to use this option, make sure what you're setting here actually matches the id attribute that would normally be used to find the item in question.
250
251=head2 has_I<belongs_to_generated_method>
252
253Returns a boolean indicating whether the generated method is storing a cached result.
254
255=head2 clear_I<belongs_to_generated_method>
256
257Clears the cached result stored by the generated method. This method will be automatically called if a new value is set for the attribute.
258
259=cut
260
261
# spent 4.04ms (60µs+3.98) within SimpleDB::Class::Item::belongs_to which was called 2 times, avg 2.02ms/call: # once (33µs+2.11ms) by Module::Find::useall at line 11 of lib/Foo/Child.pm # once (27µs+1.87ms) by Module::Find::useall at line 24 of lib/Foo/Domain.pm
sub belongs_to {
2621049µs my ($class, $name, $classname, $attribute, %options) = @_;
263 my $clearer = 'clear_'.$name;
264 my $predicate = 'has_'.$name;
265 $class->meta->add_attribute($name, {
266 is => 'rw',
267 lazy => 1,
268
# spent 1.29ms (31µs+1.26) within SimpleDB::Class::Item::__ANON__[../lib/SimpleDB/Class/Item.pm:280] which was called # once (31µs+1.26ms) by Class::MOP::Mixin::AttributeCore::default at line 53 of Class/MOP/Mixin/AttributeCore.pm
default => sub {
269723µs my $self = shift;
270 my $id = $self->$attribute;
# spent 18µs making 1 call to Foo::Domain::parentId
271 return undef unless ($id ne '');
272 my %find_options;
273 if ($options{mate}) {
274 $find_options{set} = { $options{mate} => $self };
275 }
276 if (exists $options{consistent}) {
277 $find_options{consistent} = $options{consistent};
278 }
279 return $self->simpledb->domain($classname)->find($id, %find_options);
# spent 1.14ms making 1 call to SimpleDB::Class::Domain::find # spent 94µs making 1 call to SimpleDB::Class::domain # spent 4µs making 1 call to SimpleDB::Class::Item::simpledb
280 },
281 predicate => $predicate,
# spent 3.47ms making 2 calls to Moose::Meta::Class::add_attribute, avg 1.73ms/call # spent 8µs making 1 call to Foo::Child::meta # spent 8µs making 1 call to Foo::Domain::meta
282 clearer => $clearer,
283 });
284 $class->meta->add_after_method_modifier($attribute, sub {
28562140µs my ($self, $value) = @_;
286 if (defined $value) {
# spent 7µs making 2 calls to Foo::Domain::clear_parent, avg 3µs/call
287 $self->$clearer;
288 }
289 });
# spent 482µs making 2 calls to Class::MOP::Class::add_after_method_modifier, avg 241µs/call # spent 8µs making 1 call to Foo::Child::meta # spent 8µs making 1 call to Foo::Domain::meta
290}
291
292#--------------------------------------------------------
293
294=head2 attributes ( )
295
296Class method. Returns the hashref of attributes set by the add_attributes() method.
297
298=cut
299310µs
# spent 6µs within SimpleDB::Class::Item::attributes which was called 3 times, avg 2µs/call: # 3 times (6µs+0s) by SimpleDB::Class::Item::add_attributes at line 112, avg 2µs/call
sub attributes { return {} };
300
301
302#--------------------------------------------------------
303
304=head2 recast_using ( attribute_name )
305
306Class method. Sets an attribue name to use to recast this object as another class. This allows you to pull multiple object types from the same domain. If the attribute is defined when reading the information from SimpleDB, the object will be cast as the classname returned, rather than the classname associated with the domain. The new class must be a subclass of the class associated with the domain, because you cannot C<set_domain_name> for the same domain twice, or you will break SimpleDB::Class.
307
308=head3 attribute_name
309
310The name of an attribute defined by C<add_attributes>.
311
312=cut
313
314
# spent 15µs (9+6) within SimpleDB::Class::Item::recast_using which was called # once (9µs+6µs) by Module::Find::useall at line 12 of lib/Foo/Child.pm
sub recast_using {
31528µs my ($class, $attribute_name) = @_;
316317µs16µs _install_sub($class.'::_castor_attribute', sub { return $attribute_name });
# spent 6µs making 1 call to SimpleDB::Class::Item::_install_sub
317}
318
319
# spent 83µs within SimpleDB::Class::Item::_castor_attribute which was called 32 times, avg 3µs/call: # 32 times (83µs+0s) by SimpleDB::Class::Role::Itemized::determine_item_class at line 70 of ../lib/SimpleDB/Class/Role/Itemized.pm, avg 3µs/call
sub _castor_attribute {
32032103µs return undef;
321}
322
323#--------------------------------------------------------
324
325=head2 update ( attributes )
326
327Update a bunch of attributes all at once. Returns a reference to L<$self> so it can be chained into other methods.
328
329=head3 attributes
330
331A hash reference containing attribute names and values.
332
333=cut
334
335
# spent 500µs (39+461) within SimpleDB::Class::Item::update which was called # once (39µs+461µs) by SimpleDB::Class::Item::copy at line 415
sub update {
3361323µs my ($self, $attributes) = @_;
337 my $registered_attributes = $self->attributes;
# spent 800ns making 1 call to Foo::Domain::attributes
338 foreach my $attribute (keys %{$attributes}) {
339 $self->$attribute($attributes->{$attribute});
# spent 92µs making 1 call to Foo::Domain::size # spent 61µs making 1 call to Foo::Domain::parentId # spent 56µs making 1 call to Foo::Domain::quantity # spent 52µs making 1 call to Foo::Domain::components # spent 45µs making 1 call to Foo::Domain::start_date # spent 44µs making 1 call to Foo::Domain::notes # spent 42µs making 1 call to Foo::Domain::color # spent 37µs making 1 call to Foo::Domain::size_formatted # spent 31µs making 1 call to Foo::Domain::properties
340 }
341 return $self;
342}
343
344
345#--------------------------------------------------------
346
347=head2 new ( params )
348
349Constructor.
350
351=head3 params
352
353A hash.
354
355=head4 id
356
357The unique identifier (ItemName) of the item represented by this class. If you don't pass this in, an item ID will be generated for you automatically.
358
359=head4 simpledb
360
361Required. A L<SimpleDB::Class> object.
362
363=cut
364
365#--------------------------------------------------------
366
367=head2 simpledb ( )
368
369Returns the simpledb passed into the constructor.
370
371=cut
372
37313µs11.79mshas simpledb => (
# spent 1.79ms making 1 call to Moose::has
374 is => 'ro',
375 required => 1,
376);
377
378#--------------------------------------------------------
379
380=head2 id ( )
381
382Returns the unique id of this item. B<Note:> The primary key C<ItemName> (or C<id> as we call it) is a special property of an item that doesn't exist in it's own data. So if you want to search on the id, you have to use C<itemName()> in your queries as the attribute name.
383
384=cut
385
38614µs21.44mshas id => (
# spent 1.33ms making 1 call to Moose::has # spent 112µs making 1 call to __TYPE__::SimpleDB::Class::Types::SdbStr
387 is => 'ro',
388 isa => SdbStr,
389 builder => 'generate_uuid',
390 lazy => 1,
391);
392
393#--------------------------------------------------------
394
395=head2 copy ( [ id ] )
396
397Creates a duplicate of this object, inserts it into the database, and returns a reference to it.
398
399=head3 id
400
401If you want to assign a specific id to the copy, then you can do it with this parameter.
402
403=cut
404
405
# spent 320ms (84µs+320) within SimpleDB::Class::Item::copy which was called # once (84µs+320ms) by main::RUNTIME at line 65 of 05.Domain_and_Item.t
sub copy {
4061658µs my ($self, $id) = @_;
407 my %properties;
408 foreach my $name (keys %{$self->attributes}) {
# spent 3µs making 1 call to Foo::Domain::attributes
409 $properties{$name} = $self->$name;
# spent 30µs making 1 call to Foo::Domain::parentId # spent 5µs making 1 call to Foo::Domain::components # spent 5µs making 1 call to Foo::Domain::notes # spent 5µs making 1 call to Foo::Domain::start_date # spent 4µs making 1 call to Foo::Domain::quantity # spent 4µs making 1 call to Foo::Domain::properties # spent 4µs making 1 call to Foo::Domain::color # spent 2µs making 1 call to Foo::Domain::size_formatted # spent 1µs making 1 call to Foo::Domain::size
410 }
411 my %params = (simpledb => $self->simpledb);
# spent 4µs making 1 call to SimpleDB::Class::Item::simpledb
412 if (defined $id) {
413 $params{id} = $id;
414 }
415 my $new = $self->new(\%params)->update(\%properties)->put;
# spent 318ms making 1 call to SimpleDB::Class::Item::put # spent 814µs making 1 call to Moose::Object::new # spent 500µs making 1 call to SimpleDB::Class::Item::update
416 return $new;
417}
418
419#--------------------------------------------------------
420
421=head2 delete
422
423Removes this item from the database.
424
425=cut
426
427sub delete {
428 my ($self) = @_;
429 my $db = $self->simpledb;
430 my $domain_name = $db->add_domain_prefix($self->domain_name);
431 eval{$db->cache->delete($domain_name, $self->id)};
432 $db->http->send_request('DeleteAttributes', {ItemName => $self->id, DomainName=>$domain_name});
433}
434
435#--------------------------------------------------------
436
437=head2 delete_attribute
438
439Removes a specific attribute from this item in the database. Great in conjunction with add_attribute().
440
441=cut
442
443sub delete_attribute {
444 my ($self, $name) = @_;
445 my $attributes = $self->attributes;
446 delete $attributes->{$name};
447 $self->attributes($attributes);
448 my $db = $self->simpledb;
449 my $domain_name = $db->add_domain_prefix($self->domain_name);
450 eval{$db->cache->set($domain_name, $self->id, $attributes)};
451 $db->http->send_request('DeleteAttributes', { ItemName => $self->id, DomainName => $domain_name, 'Attribute.0.Name' => $name } );
452}
453
454#--------------------------------------------------------
455
456=head2 generate_uuid ( )
457
458Class method. Generates a unique UUID that can be used as a unique id for new items.
459
460=cut
461
462
# spent 1.63ms (44µs+1.58) within SimpleDB::Class::Item::generate_uuid which was called 9 times, avg 181µs/call: # 9 times (44µs+1.58ms) by SimpleDB::Class::Item::id at line 388 of accessor id defined at ../lib/SimpleDB/Class/Item.pm, avg 181µs/call
sub generate_uuid {
463949µs91.58ms return create_UUID_as_string(UUID_V4);
# spent 1.58ms making 9 calls to UUID::Tiny::create_uuid_as_string, avg 176µs/call
464}
465
466#--------------------------------------------------------
467
468=head2 put ( )
469
470Inserts/updates the current attributes of this Item object to the database. Returns a reference to L<$self> so it can be chained into other methods.
471
472=cut
473
474
# spent 4.18s (2.14ms+4.18) within SimpleDB::Class::Item::put which was called 12 times, avg 349ms/call: # 11 times (1.96ms+3.86s) by SimpleDB::Class::Domain::insert at line 218 of ../lib/SimpleDB/Class/Domain.pm, avg 351ms/call # once (179µs+318ms) by SimpleDB::Class::Item::copy at line 415
sub put {
4756651.76ms my ($self) = @_;
476 my $db = $self->simpledb;
# spent 46µs making 12 calls to SimpleDB::Class::Item::simpledb, avg 4µs/call
477 my $domain_name = $db->add_domain_prefix($self->domain_name);
# spent 130µs making 12 calls to SimpleDB::Class::add_domain_prefix, avg 11µs/call # spent 21µs making 8 calls to Foo::Domain::domain_name, avg 3µs/call # spent 7µs making 2 calls to Foo::Parent::domain_name, avg 3µs/call # spent 6µs making 2 calls to Foo::Child::domain_name, avg 3µs/call
478 my $i = 0;
479 my $attributes = $self->to_hashref;
# spent 5.37ms making 12 calls to SimpleDB::Class::Item::to_hashref, avg 448µs/call
480
481 # build the parameter list
482 my $params = {ItemName => $self->id, DomainName=>$domain_name};
# spent 2.04ms making 12 calls to SimpleDB::Class::Item::id, avg 170µs/call
483 foreach my $name (keys %{$attributes}) {
484 my $values = $self->stringify_values($name, $self->$name);
# spent 17.7ms making 79 calls to SimpleDB::Class::Item::stringify_values, avg 224µs/call # spent 140µs making 8 calls to Foo::Domain::parentId, avg 18µs/call # spent 36µs making 2 calls to Foo::Child::domainId, avg 18µs/call # spent 21µs making 8 calls to Foo::Domain::properties, avg 3µs/call # spent 21µs making 8 calls to Foo::Domain::notes, avg 3µs/call # spent 20µs making 8 calls to Foo::Domain::quantity, avg 3µs/call # spent 19µs making 8 calls to Foo::Domain::components, avg 2µs/call # spent 19µs making 8 calls to Foo::Domain::start_date, avg 2µs/call # spent 18µs making 8 calls to Foo::Domain::size, avg 2µs/call # spent 17µs making 8 calls to Foo::Domain::color, avg 2µs/call # spent 16µs making 8 calls to Foo::Domain::size_formatted, avg 2µs/call # spent 4µs making 2 calls to Foo::Child::class, avg 2µs/call # spent 4µs making 2 calls to Foo::Parent::title, avg 2µs/call # spent 2µs making 1 call to Foo::SubChild::tribe
485 unless (ref $values eq 'ARRAY') {
486 $values = [$values];
487 }
488 foreach my $value (@{$values}) {
489 $params->{'Attribute.'.$i.'.Name'} = $name;
490 $params->{'Attribute.'.$i.'.Value'} = $value;
491 $params->{'Attribute.'.$i.'.Replace'} = 'true';
492 $i++;
493 }
494 }
495
496 # push changes
497 eval{$db->cache->set($domain_name, $self->id, $attributes)};
# spent 6.66ms making 12 calls to SimpleDB::Class::Cache::set, avg 555µs/call # spent 63µs making 12 calls to SimpleDB::Class::cache, avg 5µs/call # spent 27µs making 12 calls to SimpleDB::Class::Item::id, avg 2µs/call
498 $db->http->send_request('PutAttributes', $params);
# spent 4.15s making 12 calls to SimpleDB::Client::send_request, avg 346ms/call # spent 98µs making 12 calls to SimpleDB::Class::http, avg 8µs/call
499 return $self;
500}
501
502#--------------------------------------------------------
503
504=head2 to_hashref ( )
505
506Returns a hash reference of the attributes asscoiated with this item.
507
508=cut
509
510
# spent 6.33ms (809µs+5.52) within SimpleDB::Class::Item::to_hashref which was called 18 times, avg 351µs/call: # 12 times (523µs+4.85ms) by SimpleDB::Class::Item::put at line 479, avg 448µs/call # 3 times (122µs+460µs) by SimpleDB::Class::ResultSet::next at line 470 of ../lib/SimpleDB/Class/ResultSet.pm, avg 194µs/call # 2 times (90µs+120µs) by SimpleDB::Class::Domain::find at line 168 of ../lib/SimpleDB/Class/Domain.pm, avg 105µs/call # once (74µs+85µs) by main::RUNTIME at line 43 of 05.Domain_and_Item.t
sub to_hashref {
511338633µs my ($self) = @_;
512 my %properties;
513 foreach my $attribute (keys %{$self->attributes}) {
# spent 36µs making 14 calls to Foo::Domain::attributes, avg 3µs/call # spent 6µs making 2 calls to Foo::Parent::attributes, avg 3µs/call # spent 3µs making 1 call to Foo::Child::attributes # spent 2µs making 1 call to Foo::SubChild::attributes
514 next if $attribute eq 'id';
515 $properties{$attribute} = $self->$attribute;
# spent 3.29ms making 14 calls to Foo::Domain::start_date, avg 235µs/call # spent 660µs making 14 calls to Foo::Domain::components, avg 47µs/call # spent 590µs making 14 calls to Foo::Domain::notes, avg 42µs/call # spent 408µs making 14 calls to Foo::Domain::parentId, avg 29µs/call # spent 254µs making 14 calls to Foo::Domain::properties, avg 18µs/call # spent 78µs making 2 calls to Foo::Child::domainId, avg 39µs/call # spent 66µs making 14 calls to Foo::Domain::quantity, avg 5µs/call # spent 50µs making 14 calls to Foo::Domain::color, avg 4µs/call # spent 26µs making 14 calls to Foo::Domain::size_formatted, avg 2µs/call # spent 25µs making 14 calls to Foo::Domain::size, avg 2µs/call # spent 9µs making 2 calls to Foo::Parent::title, avg 4µs/call # spent 8µs making 2 calls to Foo::Child::class, avg 4µs/call # spent 4µs making 1 call to Foo::SubChild::tribe
516 }
517 return \%properties;
518}
519
520#--------------------------------------------------------
521
522=head2 parse_value ( name, value )
523
524Class method. Returns the proper type for an attribute value in this class. So it could take a date string and turn it into a L<DateTime> object. See C<stringify_value> for the opposite.
525
526=head3 name
527
528The name of the attribute to parse.
529
530=head3 value
531
532The current stringified value to parse.
533
534=cut
535
536
# spent 11.2ms (109µs+11.1) within SimpleDB::Class::Item::parse_value which was called 4 times, avg 2.81ms/call: # 2 times (59µs+10.7ms) by SimpleDB::Class::Domain::max at line 357 of ../lib/SimpleDB/Class/Domain.pm, avg 5.39ms/call # 2 times (50µs+405µs) by SimpleDB::Class::Domain::min at line 408 of ../lib/SimpleDB/Class/Domain.pm, avg 227µs/call
sub parse_value {
5372496µs my ($class, $name, $value) = @_;
538 return $name if ($name eq 'itemName()');
539
540 # find type
541 my $attribute = $class->meta->find_attribute_by_name($name);
# spent 262µs making 4 calls to Class::MOP::Class::find_attribute_by_name, avg 66µs/call # spent 93µs making 4 calls to Foo::Domain::meta, avg 23µs/call
542 SimpleDB::Class::Exception::InvalidParam->throw(
543 name => 'name',
544 value => $name,
545 error => q{There is no attribute called '}.$name.q{'.},
546 ) unless defined $attribute;
547 my $isa = $attribute->type_constraint;
# spent 21µs making 4 calls to Moose::Meta::Mixin::AttributeCore::type_constraint, avg 5µs/call
548
549 # coerce
550 $isa->coerce($value);
# spent 10.8ms making 4 calls to Moose::Meta::TypeConstraint::coerce, avg 2.69ms/call
551}
552
553#--------------------------------------------------------
554
555=head2 stringify_value ( name, value )
556
557Class method. Formats an attribute as a string using one of the L<SimpleDB::Class::Types> to_* functions in this class. See C<parse_value>, as this is the reverse of that.
558
559=head3 name
560
561The name of the attribute to format.
562
563=head3 value
564
565The value to format.
566
567=cut
568
569
# spent 4.37ms (456µs+3.91) within SimpleDB::Class::Item::stringify_value which was called 22 times, avg 199µs/call: # 13 times (269µs+2.01ms) by SimpleDB::Class::SQL::recurse_where at line 337 of ../lib/SimpleDB/Class/SQL.pm, avg 175µs/call # 7 times (179µs+1.91ms) by SimpleDB::Class::SQL::recurse_where at line 294 of ../lib/SimpleDB/Class/SQL.pm, avg 298µs/call # 2 times (7µs+0s) by SimpleDB::Class::SQL::recurse_where at line 316 of ../lib/SimpleDB/Class/SQL.pm, avg 4µs/call
sub stringify_value {
570128385µs my ($class, $name, $value) = @_;
571 return $value if ($name eq 'itemName()');
572
573 # find type
574 my $attribute = $class->meta->find_attribute_by_name($name);
# spent 886µs making 18 calls to Class::MOP::Class::find_attribute_by_name, avg 49µs/call # spent 256µs making 17 calls to Foo::Domain::meta, avg 15µs/call # spent 15µs making 1 call to Foo::Child::meta
575 SimpleDB::Class::Exception::InvalidParam->throw(
576 name => 'name',
577 value => $name,
578 error => q{There is no attribute called '}.$name.q{'.},
579 ) unless defined $attribute;
580 my $isa = $attribute->type_constraint;
# spent 51µs making 18 calls to Moose::Meta::Mixin::AttributeCore::type_constraint, avg 3µs/call
581
582 # coerce
583 # special cases for int stuff because technically ints are already strings
5841101µs421.78ms if ($isa =~ /Int$/) {
# spent 1.25ms making 6 calls to MooseX::Types::__ANON__[MooseX/Types.pm:486], avg 209µs/call # spent 318µs making 18 calls to SimpleDB::Class::Item::CORE:match, avg 18µs/call # spent 209µs making 18 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:8], avg 12µs/call
585 return to_SdbIntAsStr($value);
586 }
587 else {
588 return to_SdbStr($value);
# spent 1.13ms making 12 calls to MooseX::Types::__ANON__[MooseX/Types.pm:486], avg 95µs/call
589 }
590}
591
592#--------------------------------------------------------
593
594=head2 stringify_values ( name, values )
595
596Class method. Same as C<stringify_value>, but takes into account array types in addition to scalars.
597
598=head3 name
599
600The name of the attribute to format.
601
602=head3 values
603
604The value to format.
605
606=cut
607
608
# spent 17.7ms (1.66+16.0) within SimpleDB::Class::Item::stringify_values which was called 79 times, avg 224µs/call: # 79 times (1.66ms+16.0ms) by SimpleDB::Class::Item::put at line 484, avg 224µs/call
sub stringify_values {
609521931µs my ($class, $name, $value) = @_;
610 return $name if ($name eq 'itemName()');
611
612 # find type
613 my $attribute = $class->meta->find_attribute_by_name($name);
# spent 2.81ms making 79 calls to Class::MOP::Class::find_attribute_by_name, avg 36µs/call # spent 638µs making 72 calls to Foo::Domain::meta, avg 9µs/call # spent 28µs making 2 calls to Foo::Parent::meta, avg 14µs/call # spent 26µs making 3 calls to Foo::SubChild::meta, avg 8µs/call # spent 25µs making 2 calls to Foo::Child::meta, avg 12µs/call
614 SimpleDB::Class::Exception::InvalidParam->throw(
615 name => 'name',
616 value => $name,
617 error => q{There is no attribute called '}.$name.q{'.},
618 ) unless defined $attribute;
619 my $isa = $attribute->type_constraint;
# spent 142µs making 79 calls to Moose::Meta::Mixin::AttributeCore::type_constraint, avg 2µs/call
620
621 # coerce
622 # special cases for int stuff because technically ints are already strings
6231581µs3326.91ms if ($isa eq 'SimpleDB::Class::Types::SdbArrayRefOfInt') {
# spent 5.09ms making 32 calls to MooseX::Types::__ANON__[MooseX/Types.pm:486], avg 159µs/call # spent 1.17ms making 229 calls to Moose::Meta::TypeConstraint::__ANON__[Moose/Meta/TypeConstraint.pm:8], avg 5µs/call # spent 645µs making 71 calls to SimpleDB::Class::Item::CORE:match, avg 9µs/call
624 return to_SdbArrayRefOfIntAsStr($value);
625 }
626 elsif ($isa eq 'SimpleDB::Class::Types::SdbInt') {
627 return to_SdbIntAsStr($value);
628 }
629 elsif ($isa =~ m/ArrayRefOf|HashRef|MediumStr/) {
630 return to_SdbArrayRefOfStr($value);
631 }
632 else {
633 return to_SdbStr($value);
# spent 5.73ms making 47 calls to MooseX::Types::__ANON__[MooseX/Types.pm:486], avg 122µs/call
634 }
635}
636
637=head1 LEGAL
638
639SimpleDB::Class is Copyright 2009-2010 Plain Black Corporation (L<http://www.plainblack.com/>) and is licensed under the same terms as Perl itself.
640
641=cut
642
643115µs1;
# spent 963µs (451+511) within SimpleDB::Class::Item::CORE:match which was called 89 times, avg 11µs/call: # 71 times (342µs+303µs) by SimpleDB::Class::Item::stringify_values at line 623 of ../lib/SimpleDB/Class/Item.pm, avg 9µs/call # 18 times (109µs+209µs) by SimpleDB::Class::Item::stringify_value at line 584 of ../lib/SimpleDB/Class/Item.pm, avg 18µs/call
sub SimpleDB::Class::Item::CORE:match; # xsub