while (my ($raw) = $stream->next) {
my $obj = do {
if (my ($obj) = $self->_key_cache_get_raw($raw)) {
- $self->_merge($obj, $raw)
+ $obj # can't $self->_merge($obj, $raw) since $obj might have changed
} else {
$self->_add_to_key_cache($self->_inflate($raw))
}
}
method _add_to_member_cache ($to_add) {
- return unless $self->_member_cache_built;
+ return $to_add unless $self->_member_cache_built;
push @{$self->_member_cache}, $to_add;
$to_add
}
+method _remove_from_member_cache ($to_remove) {
+ return $to_remove unless $self->_member_cache_built;
+ @{$self->_member_cache} = grep $_ ne $to_remove, @{$self->_member_cache};
+ $to_remove
+}
+
## key cache - by primary/unique key
has _key_cache => (is => 'ro', default => sub { {} });
$to_add
}
+method _remove_from_key_cache ($to_remove) {
+ # should return $to_remove
+ delete $self->_key_cache->{$self->_object_to_id($to_remove)}
+}
+
method _key_cache_has_raw ($raw) {
exists $self->_key_cache->{$self->_raw_to_id($raw)}
}
}
method _key_cache_get_raw ($raw) {
- my $id = $self->_raw_to_id($raw);
- exists $self->_key_cache->{$id}
- ? ($self->_key_cache->{$id})
- : ()
+ $self->_key_cache_get_id($self->_raw_to_id($raw))
}
method _key_cache_get_object ($obj) {
- $self->_key_cache_get_raw($self->_deflate($obj))
+ $self->_key_cache_get_id($self->_object_to_id($obj))
}
-## loading data
+method _key_cache_get_object_spec ($spec) {
+ # see _object_spec_to_id for doc of what the difference is
+ $self->_key_cache_get_id($self->_object_spec_to_id($spec))
+}
-method _new_raw_stream {
- $self->_store->new_select_command([])->execute;
+method _key_cache_get_id ($id) {
+ exists $self->_key_cache->{$id}
+ ? ($self->_key_cache->{$id})
+ : ()
}
## thunking between the store representation and the set representation
# _deflate is final repr -> raw data
# _merge takes final repr + raw data and updates the repr
# (this is used for pk-generated values and later lazy loading)
+#
+# _deflate_spec is attributes of final repr -> raw data
method _inflate ($raw) {
bless($raw, $self->_class) if $self->_has_class;
- $raw;
+ $raw
}
method _deflate ($obj) {
method _merge ($obj, $raw) {
@{$obj}{keys %$raw} = values %$raw;
- $obj;
+ $obj
+}
+
+method _deflate_spec ($spec) {
+ $spec
}
## methods to get ids
}
method _object_to_id ($obj) {
- $self->_raw_to_id($self->_deflate($obj));
+ $self->_raw_to_id($self->_deflate($obj))
+}
+
+method _object_spec_to_id ($spec) {
+ # intentionally C&P from _raw_to - this is not the same thing. If a column
+ # were mapped to an attribute of a different name, the raw would have the
+ # column name as a key but an object spec would have the attribute name
+ join ';', map $spec->{$_}, @{$self->_set_over}
+}
+
+## array-ish operations - i.e. get all members
+
+method _new_raw_stream {
+ $self->_store->new_select_command([])->execute
}
method flatten {
Data::Perl::Stream::Array->new(array => $self->_member_cache);
}
+## load single row
+
+method get ($spec) {
+ if (my ($got) = $self->_key_cache_get_object_spec($spec)) {
+ return $got
+ }
+ if (my ($raw) = $self->_get_from_store($self->_deflate_spec($spec))) {
+ return $self->_add_to_key_cache($self->_inflate($raw))
+ }
+ return undef # we aren't handling cache misses here yet
+}
+
+method _get_from_store ($raw) {
+ $self->_store->new_select_single_command($raw)->execute
+}
+
+## add to set
+
method add ($new) {
$self->_add_to_store($new);
$self->_add_to_caches($new);
- $new;
+ $new
}
method _add_to_store ($new) {
my $new_raw = $self->_deflate($new);
$self->_merge($new, $self->_store->new_insert_command($new_raw)->execute);
- $new;
+ $new
}
method _add_to_caches ($new) {
$new
}
+## remove from set
+
+method remove ($old) {
+ $self->_remove_from_store($old);
+ $self->_remove_from_caches($old);
+ $old
+}
+
+method _remove_from_store ($old) {
+ $self->_store->new_delete_command($self->_deflate($old))->execute
+}
+
+method _remove_from_caches ($old) {
+ $self->_remove_from_member_cache($old);
+ $self->_remove_from_key_cache($old);
+ $old
+}
+
+## update
+
+method _update_in_store ($obj) {
+ # this is currently a call command but we should think about it
+ # being a row command so that we can have RETURNING or other
+ # mechanisms handle things like set-on-update datetime values
+ $self->_store->new_update_command($self->_deflate($obj))->execute
+}
+
1;