Skip to content

Commit 40be743

Browse files
KminekMatejKminekMatej
authored
Bulk write implementation (#73)
1 parent 31a50f4 commit 40be743

File tree

6 files changed

+279
-8
lines changed

6 files changed

+279
-8
lines changed

‎src/Caching/BulkWriter.php‎

Lines changed: 36 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
<?php
2+
3+
/**
4+
* This file is part of the Nette Framework (https://nette.org)
5+
* Copyright (c) 2004 David Grudl (https://davidgrudl.com)
6+
*/
7+
8+
declare(strict_types=1);
9+
10+
namespace Nette\Caching;
11+
use Nette\InvalidStateException;
12+
use Nette\NotSupportedException;
13+
14+
15+
/**
16+
* Cache storage with a bulk write support.
17+
*/
18+
interface BulkWriter
19+
{
20+
/**
21+
* Writes to cache in bulk.
22+
* <p>Similar to <code>write()</code>, but instead of a single key/value item, it works on multiple items specified in <code>items</code></p>
23+
*
24+
* @param array{string, mixed} $items <p>An array of key/data pairs to store on the server</p>
25+
* @param array $dp Global dependencies of each stored value
26+
* @return bool <p>Returns <b><code>true</code></b> on success or <b><code>false</code></b> on failure</p>
27+
* @throws NotSupportedException
28+
* @throws InvalidStateException
29+
*/
30+
function bulkWrite(array $items, array $dp): bool;
31+
32+
/**
33+
* Removes multiple items from cache
34+
*/
35+
function bulkRemove(array $keys): void;
36+
}

‎src/Caching/Cache.php‎

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -173,6 +173,56 @@ public function bulkLoad(array $keys, ?callable $generator = null): array
173173
}
174174

175175

176+
/**
177+
* Writes multiple items into cache
178+
*
179+
* @param array $items
180+
* @param array|null $dependencies
181+
* @return array Stored items
182+
*
183+
* @throws InvalidArgumentException
184+
*/
185+
public function bulkSave(array $items, ?array $dependencies = null): array
186+
{
187+
$storedItems = [];
188+
189+
if (!$this->storage instanceof BulkWriter) {
190+
191+
foreach ($items as $key => $data) {
192+
$storedItems[$key] = $this->save($key, $data, $dependencies);
193+
}
194+
return $storedItems;
195+
}
196+
197+
$dependencies = $this->completeDependencies($dependencies);
198+
199+
if (isset($dependencies[self::Expire]) && $dependencies[self::Expire] <= 0) {
200+
$this->storage->bulkRemove(array_map(fn($key): string => $this->generateKey($key), array_keys($items)));
201+
return [];
202+
}
203+
204+
$removals = [];
205+
$toCache = [];
206+
foreach ($items as $key => $data) {
207+
$cKey = $this->generateKey($key);
208+
209+
if ($data === null) {
210+
$removals[] = $cKey;
211+
} else {
212+
$storedItems[$key] = $toCache[$cKey] = $data;
213+
}
214+
}
215+
216+
if (!empty($removals)) {
217+
$this->storage->bulkRemove($removals);
218+
}
219+
220+
$this->storage->bulkWrite($toCache, $dependencies);
221+
222+
return $storedItems;
223+
}
224+
225+
176226
/**
177227
* Writes item into the cache.
178228
* Dependencies are:

‎src/Caching/Storages/MemcachedStorage.php‎

Lines changed: 51 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@
1616
/**
1717
* Memcached storage using memcached extension.
1818
*/
19-
class MemcachedStorage implements Nette\Caching\Storage, Nette\Caching\BulkReader
19+
class MemcachedStorage implements Nette\Caching\Storage, Nette\Caching\BulkReader, Nette\Caching\BulkWriter
2020
{
2121
/** @internal cache structure */
2222
private const
@@ -25,8 +25,6 @@ class MemcachedStorage implements Nette\Caching\Storage, Nette\Caching\BulkReade
2525
MetaDelta = 'delta';
2626

2727
private \Memcached $memcached;
28-
private string $prefix;
29-
private ?Journal $journal;
3028

3129

3230
/**
@@ -41,15 +39,12 @@ public static function isAvailable(): bool
4139
public function __construct(
4240
string $host = 'localhost',
4341
int $port = 11211,
44-
string $prefix = '',
45-
?Journal $journal = null,
42+
private string $prefix = '',
43+
private ?Journal $journal = null,
4644
) {
4745
if (!static::isAvailable()) {
4846
throw new Nette\NotSupportedException("PHP extension 'memcached' is not loaded.");
4947
}
50-
51-
$this->prefix = $prefix;
52-
$this->journal = $journal;
5348
$this->memcached = new \Memcached;
5449
if ($host) {
5550
$this->addServer($host, $port);
@@ -168,12 +163,60 @@ public function write(string $key, $data, array $dp): void
168163
}
169164

170165

166+
public function bulkWrite(array $items, array $dp): bool
167+
{
168+
if (isset($dp[Cache::Items])) {
169+
throw new Nette\NotSupportedException('Dependent items are not supported by MemcachedStorage.');
170+
}
171+
172+
$records = [];
173+
174+
$expire = 0;
175+
if (isset($dp[Cache::Expire])) {
176+
$expire = (int) $dp[Cache::Expire];
177+
}
178+
179+
foreach ($items as $key => $data) {
180+
$key = urlencode($this->prefix . $key);
181+
$meta = [
182+
self::MetaData => $data,
183+
];
184+
185+
if (!empty($dp[Cache::Sliding])) {
186+
$meta[self::MetaDelta] = $expire; // sliding time
187+
}
188+
189+
if (isset($dp[Cache::Callbacks])) {
190+
$meta[self::MetaCallbacks] = $dp[Cache::Callbacks];
191+
}
192+
193+
if (isset($dp[Cache::Tags]) || isset($dp[Cache::Priority])) {
194+
if (!$this->journal) {
195+
throw new Nette\InvalidStateException('CacheJournal has not been provided.');
196+
}
197+
198+
$this->journal->write($key, $dp);
199+
}
200+
201+
$records[$key] = $meta;
202+
}
203+
204+
return $this->memcached->setMulti($records, $expire);
205+
}
206+
207+
171208
public function remove(string $key): void
172209
{
173210
$this->memcached->delete(urlencode($this->prefix . $key), 0);
174211
}
175212

176213

214+
public function bulkRemove(array $keys): void
215+
{
216+
$this->memcached->deleteMulti(array_map(fn($key) => urlencode($this->prefix . $key), $keys), 0);
217+
}
218+
219+
177220
public function clean(array $conditions): void
178221
{
179222
if (!empty($conditions[Cache::All])) {

‎tests/Caching/Cache.bulkSave.phpt‎

Lines changed: 53 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,53 @@
1+
<?php
2+
3+
/**
4+
* Test: Nette\Caching\Cache save().
5+
*/
6+
7+
declare(strict_types=1);
8+
9+
use Nette\Caching\Cache;
10+
use Tester\Assert;
11+
12+
13+
require __DIR__ . '/../bootstrap.php';
14+
15+
require __DIR__ . '/Cache.php';
16+
17+
18+
test('storage without bulk write support', function () {
19+
$storage = new TestStorage;
20+
$cache = new Cache($storage, 'ns');
21+
Assert::same([1, 2], $cache->bulkSave([1, 2]), 'data');
22+
Assert::same([1 => 'value1', 2 => 'value2'], $cache->bulkSave([1 => 'value1', 2 => 'value2']), 'data');
23+
24+
$data = $cache->bulkLoad([1, 2]);
25+
Assert::same('value1', $data[1]['data']);
26+
Assert::same('value2', $data[2]['data']);
27+
});
28+
29+
test('storage with bulk write support', function () {
30+
$storage = new BulkWriteTestStorage;
31+
$cache = new Cache($storage, 'ns');
32+
Assert::same([1, 2], $cache->bulkSave([1, 2]), 'data');
33+
Assert::same([1 => 'value1', 2 => 'value2'], $cache->bulkSave([1 => 'value1', 2 => 'value2']), 'data');
34+
35+
$data = $cache->bulkLoad([1, 2]);
36+
Assert::same('value1', $data[1]['data']);
37+
Assert::same('value2', $data[2]['data']);
38+
});
39+
40+
test('dependencies', function () {
41+
$storage = new BulkWriteTestStorage;
42+
$cache = new Cache($storage, 'ns');
43+
$dependencies = [Cache::Tags => ['tag']];
44+
$cache->bulkSave([1 => 'value1', 2 => 'value2'], $dependencies);
45+
46+
$data = $cache->bulkLoad([1, 2]);
47+
Assert::same($dependencies, $data[1]['dependencies']);
48+
Assert::same($dependencies, $data[2]['dependencies']);
49+
50+
$cache->clean($dependencies);
51+
52+
Assert::same([1 => null, 2 => null], $cache->bulkLoad([1, 2]));
53+
});

‎tests/Caching/Cache.php‎

Lines changed: 52 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22

33
declare(strict_types=1);
44

5+
use Nette\Caching\BulkWriter;
56
use Nette\Caching\IBulkReader;
67
use Nette\Caching\IStorage;
78

@@ -37,6 +38,25 @@ public function remove(string $key): void
3738

3839
public function clean(array $conditions): void
3940
{
41+
if (!empty($conditions[Nette\Caching\Cache::All])) {
42+
$this->data = [];
43+
return;
44+
}
45+
46+
//unset based by tags
47+
if (!empty($conditions[Nette\Caching\Cache::Tags])) {
48+
$unsets = [];
49+
foreach ($this->data as $key => $data) {
50+
$tags = $data['dependencies'][Nette\Caching\Cache::Tags] ?? null;
51+
if (array_intersect($conditions[Nette\Caching\Cache::Tags], $tags)) {
52+
$unsets[$key] = $key;
53+
}
54+
}
55+
56+
foreach ($unsets as $unsetKey) {
57+
unset($this->data[$unsetKey]);
58+
}
59+
}
4060
}
4161
}
4262

@@ -55,3 +75,35 @@ public function bulkRead(array $keys): array
5575
return $result;
5676
}
5777
}
78+
79+
class BulkWriteTestStorage extends TestStorage implements BulkWriter
80+
{
81+
public function bulkRead(array $keys): array
82+
{
83+
$result = [];
84+
foreach ($keys as $key) {
85+
$data = $this->read($key);
86+
if ($data !== null) {
87+
$result[$key] = $data;
88+
}
89+
}
90+
91+
return $result;
92+
}
93+
94+
95+
public function bulkRemove(array $keys): void
96+
{
97+
98+
}
99+
100+
101+
public function bulkWrite($items, array $dp): bool
102+
{
103+
foreach ($items as $key => $data) {
104+
$this->write($key, $data, $dp);
105+
}
106+
107+
return true;
108+
}
109+
}

‎tests/Storages/Memcached.bulkWrite.phpt‎

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
<?php
2+
3+
/**
4+
* Test: Nette\Caching\Storages\MemcachedStorage and bulkWrite
5+
*/
6+
7+
declare(strict_types=1);
8+
9+
use Nette\Caching\Cache;
10+
use Nette\Caching\Storages\MemcachedStorage;
11+
use Nette\Caching\Storages\SQLiteJournal;
12+
use Tester\Assert;
13+
14+
15+
require __DIR__ . '/../bootstrap.php';
16+
17+
18+
if (!MemcachedStorage::isAvailable()) {
19+
Tester\Environment::skip('Requires PHP extension Memcached.');
20+
}
21+
22+
Tester\Environment::lock('memcached-files', getTempDir());
23+
24+
25+
$storage = new MemcachedStorage('localhost', 11211, '', new SQLiteJournal(getTempDir() . '/journal-memcached.s3db'));
26+
$cache = new Cache($storage);
27+
28+
//standard
29+
$cache->bulkSave(["foo" => "bar"]);
30+
Assert::same(['foo' => 'bar', 'lorem' => null], $cache->bulkLoad(['foo', 'lorem']));
31+
32+
//tags
33+
$dependencies = [Cache::Tags => ['tag']];
34+
$cache->bulkSave(["foo" => "bar"], $dependencies);
35+
Assert::same(['foo' => 'bar'], $cache->bulkLoad(['foo']));
36+
$cache->clean($dependencies);
37+
Assert::same(['foo' => null], $cache->bulkLoad(['foo']));

0 commit comments

Comments
 (0)