Data-ObjectDriver

 view release on metacpan or  search on metacpan

lib/Data/ObjectDriver/BaseObject.pm  view on Meta::CPAN

518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
                return;
            }
            $driver->cache_object($o);
            return $o;
        };
        return Data::ObjectDriver::Iterator->new($caching_iter, sub { $iter->end });
    }
}
 
sub remove         { shift->_proxy( 'remove',         @_ ) }
sub update         { shift->_proxy( 'update',         @_ ) }
sub insert         { shift->_proxy( 'insert',         @_ ) }
sub replace        { shift->_proxy( 'replace',        @_ ) }
sub fetch_data     { shift->_proxy( 'fetch_data',     @_ ) }
sub uncache_object { shift->_proxy( 'uncache_object', @_ ) }
 
sub refresh {
    my $obj = shift;
    return unless $obj->has_primary_key;
    my $fields = $obj->fetch_data;
    $obj->set_values_internal($fields);

lib/Data/ObjectDriver/Driver/BaseCache.pm  view on Meta::CPAN

10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
use Carp ();
 
__PACKAGE__->mk_accessors(qw( cache fallback txn_buffer));
__PACKAGE__->mk_classdata(qw( Disabled ));
 
sub deflate { $_[1] }
sub inflate { $_[2] }
 
# subclasses must override these:
sub add_to_cache            { Carp::croak("NOT IMPLEMENTED") }
sub update_cache            { Carp::croak("NOT IMPLEMENTED") }
sub remove_from_cache       { Carp::croak("NOT IMPLEMENTED") }
sub get_from_cache          { Carp::croak("NOT IMPLEMENTED") }
 
sub init {
    my $driver = shift;
    $driver->SUPER::init(@_);
    my %param = @_;
    $driver->cache($param{cache})
        or Carp::croak("cache is required");
    $driver->fallback($param{fallback})

lib/Data/ObjectDriver/Driver/BaseCache.pm  view on Meta::CPAN

200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
        };
        return Data::ObjectDriver::Iterator->new($iter, sub { @objs = (); @window = () });
    } else {
        ## Load all of the objects using a lookup_multi, which is fast from
        ## cache.
        my $objs = $driver->lookup_multi($class, [ map { $_->primary_key } @objs ]);
        return $driver->list_or_iterator($objs);
    }
}
 
sub update {
    my $driver = shift;
    my($obj) = @_;
    return $driver->fallback->update($obj)
        if $driver->Disabled;
    my $ret = $driver->fallback->update(@_);
    my $key = $driver->cache_key(ref($obj), $obj->primary_key);
    $driver->modify_cache(sub {
        $driver->uncache_object($obj);
    });
    return $ret;

lib/Data/ObjectDriver/Driver/Cache/Apache.pm  view on Meta::CPAN

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
    my $r = $driver->r or return;
 
    $driver->start_query('APACHECACHE_ADD ?,?', \@_);
    my $ret = $r->pnotes($_[0], $_[1]);
    $driver->end_query(undef);
 
    return if !defined $ret;
    return $ret;
}
 
sub update_cache {
    my $driver = shift;
    my $r = $driver->r or return;
 
    $driver->start_query('APACHECACHE_SET ?,?', \@_);
    my $ret = $r->pnotes($_[0], $_[1]);
    $driver->end_query(undef);
 
    return if !defined $ret;
    return $ret;
}

lib/Data/ObjectDriver/Driver/Cache/Cache.pm  view on Meta::CPAN

13
14
15
16
17
18
19
20
21
22
23
24
25
26
}
 
sub inflate {
    my $driver = shift;
    my($class, $data) = @_;
    $class->inflate($data);
}
 
sub get_from_cache    { shift->cache->thaw(@_)   }
sub add_to_cache      { shift->cache->freeze(@_) }
sub update_cache      { shift->cache->freeze(@_) }
sub remove_from_cache { shift->cache->remove(@_) }
 
1;

lib/Data/ObjectDriver/Driver/Cache/RAM.pm  view on Meta::CPAN

30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
    my $driver = shift;
 
    $driver->start_query('RAMCACHE_ADD ?', \@_);
    my $ret = $Cache{$_[0]} = $_[1];
    $driver->end_query(undef);
 
    return if !defined $ret;
    return $ret;
}
 
sub update_cache {
    my $driver = shift;
 
    $driver->start_query('RAMCACHE_SET ?', \@_);
    my $ret = $Cache{$_[0]} = $_[1];
    $driver->end_query(undef);
 
    return if !defined $ret;
    return $ret;
}

lib/Data/ObjectDriver/Driver/DBI.pm  view on Meta::CPAN

446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
    $driver->end_query($sth);
 
    $obj->call_trigger('post_save', $orig_obj);
    $obj->call_trigger('post_insert', $orig_obj);
 
    $orig_obj->{__is_stored} = 1;
    $orig_obj->{changed_cols} = {};
    1;
}
 
sub update {
    my $driver = shift;
 
    my($orig_obj, $terms) = @_;
 
    if ($Data::ObjectDriver::RESTRICT_IO) {
        use Data::Dumper;
        die "Attempted DBI I/O while in restricted mode: _update() " . Dumper($terms);
    }
 
    ## Use a duplicate so the pre_save trigger can modify it.

lib/Data/ObjectDriver/Driver/GearmanDBI.pm  view on Meta::CPAN

101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
    return Digest::MD5::md5_hex(join "", $sql, @$bind);
}
 
## every single data access methods are delegated to dbi
## except for search
sub lookup       { shift->dbi->lookup       (@_) }
sub lookup_multi { shift->dbi->lookup_multi (@_) }
sub exists       { shift->dbi->exists       (@_) }
sub insert       { shift->dbi->insert       (@_) }
sub replace      { shift->dbi->replace      (@_) }
sub update       { shift->dbi->update       (@_) }
sub remove       { shift->dbi->remove       (@_) }
sub fetch_data   { shift->dbi->fetch_data   (@_) }
 
## transactions are passed to dbi
sub add_working_driver { shift->dbi->add_working_driver (@_) }
sub commit             { shift->dbi->commit             (@_) }
sub rollback           { shift->dbi->rollback           (@_) }
sub rw_handle          { shift->dbi->rw_handle          (@_) }
sub r_handle           { shift->dbi->r_handle           (@_) }

lib/Data/ObjectDriver/Driver/Multiplexer.pm  view on Meta::CPAN

57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
sub search {
    my $driver = shift;
    my($class, $terms, $args) = @_;
    my $sub_driver = $driver->_find_sub_driver($terms)
        or croak "No matching sub-driver found";
    return $sub_driver->search(@_);
}
 
sub replace { shift->_exec_multiplexed('replace', @_) }
sub insert  { shift->_exec_multiplexed('insert',  @_) }
sub update  { shift->_exec_multiplexed('update',  @_) }
 
sub remove {
    my $driver = shift;
    my $removed = 0;
    for my $sub_driver (@{ $driver->drivers }) {
        $removed += $sub_driver->remove(@_);
    }
    if ($removed % 2) {
        warn "remove count looks incorrect, we might miss one object";
    }

lib/Data/ObjectDriver/Driver/Partition.pm  view on Meta::CPAN

28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
sub lookup_multi {
    my $driver = shift;
    my($class, $ids) = @_;
    return [] unless @$ids;
    $driver->get_driver->($ids->[0])->lookup_multi($class, $ids);
}
 
sub exists     { shift->_exec_partitioned('exists',     @_) }
sub insert     { shift->_exec_partitioned('insert',     @_) }
sub replace    { shift->_exec_partitioned('replace',    @_) }
sub update     { shift->_exec_partitioned('update',     @_) }
sub remove     { shift->_exec_partitioned('remove',     @_) }
sub fetch_data { shift->_exec_partitioned('fetch_data', @_) }
 
sub search {
    my $driver = shift;
    my($class, $terms, $args) = @_;
    $driver->get_driver->($terms, $args)->search($class, $terms, $args);
}
 
sub _exec_partitioned {