22226743054

Committed 20 Feb 2026 01:53PM UTC coverage: 88.227% (+1.0%) from 87.202%

Build # 22226743054

Build Type

Pull #85

github

Committed by

web-flow

Commit Message

Merge c3f6b576c into f6698ea58

Pull Request Pull Request #85: Extend MemoryStorage with Tags, Priority, Expire and Sliding modifiers

Coverage Stats

35 of 36 new or added lines in 1 file covered. (97.22%)

57 existing lines in 7 files now uncovered.

622 of 705 relevant lines covered (88.23%)

0.88 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.34

/src/Caching/Storages/SQLiteJournal.php

<?php

/**
 * This file is part of the Nette Framework (https://nette.org)
 * Copyright (c) 2004 David Grudl (https://davidgrudl.com)
 */

declare(strict_types=1);

namespace Nette\Caching\Storages;

use Nette;
use Nette\Caching\Cache;
use function count, extension_loaded, implode, is_file, str_repeat, touch;


/**
 * SQLite based journal.
 */
class SQLiteJournal implements Journal
{
        private \PDO $pdo;


        public function __construct(
                private readonly string $path,
        ) {
                if (!extension_loaded('pdo_sqlite')) {
                        throw new Nette\NotSupportedException('SQLiteJournal requires PHP extension pdo_sqlite which is not loaded.');
                }
        }


        private function open(): void
        {
                if ($this->path !== ':memory:' && !is_file($this->path)) {
                        touch($this->path); // ensures ordinary file permissions
                }

                $this->pdo = new \PDO('sqlite:' . $this->path);
                $this->pdo->exec('
                        PRAGMA foreign_keys = OFF;
                        PRAGMA journal_mode = WAL;
                        CREATE TABLE IF NOT EXISTS tags (
                                key BLOB NOT NULL,
                                tag BLOB NOT NULL
                        );
                        CREATE TABLE IF NOT EXISTS priorities (
                                key BLOB NOT NULL,
                                priority INT NOT NULL
                        );
                        CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag);
                        CREATE UNIQUE INDEX IF NOT EXISTS idx_tags_key_tag ON tags(key, tag);
                        CREATE UNIQUE INDEX IF NOT EXISTS idx_priorities_key ON priorities(key);
                        CREATE INDEX IF NOT EXISTS idx_priorities_priority ON priorities(priority);
                        PRAGMA synchronous = NORMAL;
                ');
        }


        public function write(string $key, array $dependencies): void
        {
                if (!isset($this->pdo)) {
                        $this->open();
                }

                $this->pdo->exec('BEGIN');

                if (!empty($dependencies[Cache::Tags])) {
                        $this->pdo->prepare('DELETE FROM tags WHERE key = ?')->execute([$key]);

                        foreach ($dependencies[Cache::Tags] as $tag) {
                                $arr[] = $key;
                                $arr[] = $tag;
                        }

                        $this->pdo->prepare('INSERT INTO tags (key, tag) SELECT ?, ?' . str_repeat('UNION SELECT ?, ?', count($arr) / 2 - 1))
                                ->execute($arr);
                }

                if (!empty($dependencies[Cache::Priority])) {
                        $this->pdo->prepare('REPLACE INTO priorities (key, priority) VALUES (?, ?)')
                                ->execute([$key, (int) $dependencies[Cache::Priority]]);
                }

                $this->pdo->exec('COMMIT');
        }


        public function clean(array $conditions): ?array
        {
                if (!isset($this->pdo)) {
                        $this->open();
                }

                if (!empty($conditions[Cache::All])) {
                        $this->pdo->exec('
                                BEGIN;
                                DELETE FROM tags;
                                DELETE FROM priorities;
                                COMMIT;
                        ');

                        return null;
                }

                $unions = $args = [];
                if (!empty($conditions[Cache::Tags])) {
                        $tags = (array) $conditions[Cache::Tags];
                        $unions[] = 'SELECT DISTINCT key FROM tags WHERE tag IN (?' . str_repeat(', ?', count($tags) - 1) . ')';
                        $args = $tags;
                }

                if (!empty($conditions[Cache::Priority])) {
                        $unions[] = 'SELECT DISTINCT key FROM priorities WHERE priority <= ?';
                        $args[] = (int) $conditions[Cache::Priority];
                }

                if (empty($unions)) {
                        return [];
                }

                $unionSql = implode(' UNION ', $unions);

                $this->pdo->exec('BEGIN IMMEDIATE');

                $stmt = $this->pdo->prepare($unionSql);
                $stmt->execute($args);
                $keys = $stmt->fetchAll(\PDO::FETCH_COLUMN, 0);

                if (empty($keys)) {
                        $this->pdo->exec('COMMIT');
                        return [];
                }

                $this->pdo->prepare("DELETE FROM tags WHERE key IN ($unionSql)")->execute($args);
                $this->pdo->prepare("DELETE FROM priorities WHERE key IN ($unionSql)")->execute($args);
                $this->pdo->exec('COMMIT');

                return $keys;
        }
}

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\Storages;
11
12	use Nette;
13	use Nette\Caching\Cache;
14	use function count, extension_loaded, implode, is_file, str_repeat, touch;
15
16
17	/**
18	* SQLite based journal.
19	*/
20	class SQLiteJournal implements Journal
21	{
22	private \PDO $pdo;
23
24
25	public function __construct(	1✔
26	private readonly string $path,
27	) {
28	if (!extension_loaded('pdo_sqlite')) {	1✔
UNCOV 29	throw new Nette\NotSupportedException('SQLiteJournal requires PHP extension pdo_sqlite which is not loaded.');	×
30	}
31	}	1✔
32
33
34	private function open(): void
35	{
36	if ($this->path !== ':memory:' && !is_file($this->path)) {	1✔
37	touch($this->path); // ensures ordinary file permissions	1✔
38	}
39
40	$this->pdo = new \PDO('sqlite:' . $this->path);	1✔
41	$this->pdo->exec('	1✔
42	PRAGMA foreign_keys = OFF;
43	PRAGMA journal_mode = WAL;
44	CREATE TABLE IF NOT EXISTS tags (
45	key BLOB NOT NULL,
46	tag BLOB NOT NULL
47	);
48	CREATE TABLE IF NOT EXISTS priorities (
49	key BLOB NOT NULL,
50	priority INT NOT NULL
51	);
52	CREATE INDEX IF NOT EXISTS idx_tags_tag ON tags(tag);
53	CREATE UNIQUE INDEX IF NOT EXISTS idx_tags_key_tag ON tags(key, tag);
54	CREATE UNIQUE INDEX IF NOT EXISTS idx_priorities_key ON priorities(key);
55	CREATE INDEX IF NOT EXISTS idx_priorities_priority ON priorities(priority);
56	PRAGMA synchronous = NORMAL;
57	');
58	}	1✔
59
60
61	public function write(string $key, array $dependencies): void	1✔
62	{
63	if (!isset($this->pdo)) {	1✔
64	$this->open();	1✔
65	}
66
67	$this->pdo->exec('BEGIN');	1✔
68
69	if (!empty($dependencies[Cache::Tags])) {	1✔
70	$this->pdo->prepare('DELETE FROM tags WHERE key = ?')->execute([$key]);	1✔
71
72	foreach ($dependencies[Cache::Tags] as $tag) {	1✔
73	$arr[] = $key;	1✔
74	$arr[] = $tag;	1✔
75	}
76
77	$this->pdo->prepare('INSERT INTO tags (key, tag) SELECT ?, ?' . str_repeat('UNION SELECT ?, ?', count($arr) / 2 - 1))	1✔
78	->execute($arr);	1✔
79	}
80
81	if (!empty($dependencies[Cache::Priority])) {	1✔
82	$this->pdo->prepare('REPLACE INTO priorities (key, priority) VALUES (?, ?)')	1✔
83	->execute([$key, (int) $dependencies[Cache::Priority]]);	1✔
84	}
85
86	$this->pdo->exec('COMMIT');	1✔
87	}	1✔
88
89
90	public function clean(array $conditions): ?array	1✔
91	{
92	if (!isset($this->pdo)) {	1✔
UNCOV 93	$this->open();	×
94	}
95
96	if (!empty($conditions[Cache::All])) {	1✔
97	$this->pdo->exec('	1✔
98	BEGIN;
99	DELETE FROM tags;
100	DELETE FROM priorities;
101	COMMIT;
102	');
103
104	return null;	1✔
105	}
106
107	$unions = $args = [];	1✔
108	if (!empty($conditions[Cache::Tags])) {	1✔
109	$tags = (array) $conditions[Cache::Tags];	1✔
110	$unions[] = 'SELECT DISTINCT key FROM tags WHERE tag IN (?' . str_repeat(', ?', count($tags) - 1) . ')';	1✔
111	$args = $tags;	1✔
112	}
113
114	if (!empty($conditions[Cache::Priority])) {	1✔
115	$unions[] = 'SELECT DISTINCT key FROM priorities WHERE priority <= ?';	1✔
116	$args[] = (int) $conditions[Cache::Priority];	1✔
117	}
118
119	if (empty($unions)) {	1✔
UNCOV 120	return [];	×
121	}
122
123	$unionSql = implode(' UNION ', $unions);	1✔
124
125	$this->pdo->exec('BEGIN IMMEDIATE');	1✔
126
127	$stmt = $this->pdo->prepare($unionSql);	1✔
128	$stmt->execute($args);	1✔
129	$keys = $stmt->fetchAll(\PDO::FETCH_COLUMN, 0);	1✔
130
131	if (empty($keys)) {	1✔
132	$this->pdo->exec('COMMIT');	1✔
133	return [];	1✔
134	}
135
136	$this->pdo->prepare("DELETE FROM tags WHERE key IN ($unionSql)")->execute($args);	1✔
137	$this->pdo->prepare("DELETE FROM priorities WHERE key IN ($unionSql)")->execute($args);	1✔
138	$this->pdo->exec('COMMIT');	1✔
139
140	return $keys;	1✔
141	}
142	}

nette / caching / 22226743054

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous