SQLite3Cache::isExpired() - Code Metrics - Inspection of "#172 synax error hotfix" - doctrine/cache - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8f6a24...fe68e4 )

by Marco

created 2016-07-15 15:57 UTC

SQLite3Cache::isExpired() A

↳ Parent: SQLite3Cache

Complexity

Conditions	3
Paths	3

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	12

Importance

Changes

Metric	Value
dl	0
loc	6
c	0
b	0
f	0
ccs	0
cts	6
cp	0
rs	9.4285
cc	3
eloc	4
nc	3
nop	1
crap	12

<?php
/*
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * This software consists of voluntary contributions made by many individuals
 * and is licensed under the MIT license. For more information, see
 * <http://www.doctrine-project.org>.
 */

namespace Doctrine\Common\Cache;

use SQLite3;
use SQLite3Result;

/**
 * SQLite3 cache provider.
 *
 * @since  1.4
 * @author Jake Bell <[email protected]>
 */
class SQLite3Cache extends CacheProvider
{
    /**
     * The ID field will store the cache key.
     */
    const ID_FIELD = 'k';

    /**
     * The data field will store the serialized PHP value.
     */
    const DATA_FIELD = 'd';

    /**
     * The expiration field will store a date value indicating when the
     * cache entry should expire.
     */
    const EXPIRATION_FIELD = 'e';

    /**
     * @var SQLite3
     */
    private $sqlite;

    /**
     * @var string
     */
    private $table;

    /**
     * Constructor.
     *
     * Calling the constructor will ensure that the database file and table 
     * exist and will create both if they don't.
     *
     * @param SQLite3 $sqlite
     * @param string $table
     */
    public function __construct(SQLite3 $sqlite, $table)
    {
        $this->sqlite = $sqlite;
        $this->table  = (string) $table;

        list($id, $data, $exp) = $this->getFields();

        return $this->sqlite->exec(sprintf(

            'CREATE TABLE IF NOT EXISTS %s(%s TEXT PRIMARY KEY NOT NULL, %s BLOB, %s INTEGER)',
            $table,
            $id,
            $data,
            $exp
        ));
    }

    /**
     * {@inheritdoc}
     */
    protected function doFetch($id)
    {
        $item = $this->findById($id);

        if (!$item) {
            return false;
        }

        return unserialize($item[self::DATA_FIELD]);
    }

    /**
     * {@inheritdoc}
     */
    protected function doContains($id)
    {
        return null !== $this->findById($id, false);
    }

    /**
     * {@inheritdoc}
     */
    protected function doSave($id, $data, $lifeTime = 0)
    {
        $statement = $this->sqlite->prepare(sprintf(
            'INSERT OR REPLACE INTO %s (%s) VALUES (:id, :data, :expire)',
            $this->table,
            implode(',', $this->getFields())
        ));

        $statement->bindValue(':id', $id);
        $statement->bindValue(':data', serialize($data), SQLITE3_BLOB);
        $statement->bindValue(':expire', $lifeTime > 0 ? time() + $lifeTime : null);

        return $statement->execute() instanceof SQLite3Result;
    }

    /**
     * {@inheritdoc}
     */
    protected function doDelete($id)
    {
        list($idField) = $this->getFields();

        $statement = $this->sqlite->prepare(sprintf(
            'DELETE FROM %s WHERE %s = :id',
            $this->table,
            $idField
        ));

        $statement->bindValue(':id', $id);

        return $statement->execute() instanceof SQLite3Result;
    }

    /**
     * {@inheritdoc}
     */
    protected function doFlush()
    {
        return $this->sqlite->exec(sprintf('DELETE FROM %s', $this->table));
    }

    /**
     * {@inheritdoc}
     */
    protected function doGetStats()
    {
        // no-op.
    }

    /**
     * Find a single row by ID.
     *
     * @param mixed $id
     * @param bool $includeData
     *
     * @return array|null
     */
    private function findById($id, $includeData = true)
    {
        list($idField) = $fields = $this->getFields();

        if (!$includeData) {
            $key = array_search(static::DATA_FIELD, $fields);
            unset($fields[$key]);
        }

        $statement = $this->sqlite->prepare(sprintf(
            'SELECT %s FROM %s WHERE %s = :id LIMIT 1',
            implode(',', $fields),
            $this->table,
            $idField
        ));

        $statement->bindValue(':id', $id, SQLITE3_TEXT);

        $item = $statement->execute()->fetchArray(SQLITE3_ASSOC);

        if ($item === false) {
            return null;
        }

        if ($this->isExpired($item)) {
            $this->doDelete($id);

            return null;
        }

        return $item;
    }

    /**
     * Gets an array of the fields in our table.
     *
     * @return array
     */
    private function getFields()
    {
        return [static::ID_FIELD, static::DATA_FIELD, static::EXPIRATION_FIELD];
    }

    /**
     * Check if the item is expired.
     *
     * @param array $item
     *
     * @return bool
     */
    private function isExpired(array $item)
    {
        return isset($item[static::EXPIRATION_FIELD]) &&
            $item[self::EXPIRATION_FIELD] !== null &&
            $item[self::EXPIRATION_FIELD] < time();
    }
}


1			<?php
2			/*
3			* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
4			* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
5			* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
6			* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
7			* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
8			* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
9			* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
10			* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
11			* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
12			* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
13			* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
14			*
15			* This software consists of voluntary contributions made by many individuals
16			* and is licensed under the MIT license. For more information, see
17			* <http://www.doctrine-project.org>.
18			*/
19
20			namespace Doctrine\Common\Cache;
21
22			use SQLite3;
23			use SQLite3Result;
24
25			/**
26			* SQLite3 cache provider.
27			*
28			* @since 1.4
29			* @author Jake Bell <[email protected]>
30			*/
31			class SQLite3Cache extends CacheProvider
32			{
33			/**
34			* The ID field will store the cache key.
35			*/
36			const ID_FIELD = 'k';
37
38			/**
39			* The data field will store the serialized PHP value.
40			*/
41			const DATA_FIELD = 'd';
42
43			/**
44			* The expiration field will store a date value indicating when the
45			* cache entry should expire.
46			*/
47			const EXPIRATION_FIELD = 'e';
48
49			/**
50			* @var SQLite3
51			*/
52			private $sqlite;
53
54			/**
55			* @var string
56			*/
57			private $table;
58
59			/**
60			* Constructor.
61			*
62			* Calling the constructor will ensure that the database file and table
63			* exist and will create both if they don't.
64			*
65			* @param SQLite3 $sqlite
66			* @param string $table
67			*/
68			public function __construct(SQLite3 $sqlite, $table)
69			{
70			$this->sqlite = $sqlite;
71			$this->table = (string) $table;
72
73			list($id, $data, $exp) = $this->getFields();
74
75			return $this->sqlite->exec(sprintf(
			0 ignored issues – show Bug introduced 2015-12-31 16:02 UTC by Report Bug Copy Issue Report Constructors do not have meaningful return values, anything that is returned from here is discarded. Are you sure this is correct? Loading history...
76			'CREATE TABLE IF NOT EXISTS %s(%s TEXT PRIMARY KEY NOT NULL, %s BLOB, %s INTEGER)',
77			$table,
78			$id,
79			$data,
80			$exp
81			));
82			}
83
84			/**
85			* {@inheritdoc}
86			*/
87			protected function doFetch($id)
88			{
89			$item = $this->findById($id);
90
91			if (!$item) {
92			return false;
93			}
94
95			return unserialize($item[self::DATA_FIELD]);
96			}
97
98			/**
99			* {@inheritdoc}
100			*/
101			protected function doContains($id)
102			{
103			return null !== $this->findById($id, false);
104			}
105
106			/**
107			* {@inheritdoc}
108			*/
109			protected function doSave($id, $data, $lifeTime = 0)
110			{
111			$statement = $this->sqlite->prepare(sprintf(
112			'INSERT OR REPLACE INTO %s (%s) VALUES (:id, :data, :expire)',
113			$this->table,
114			implode(',', $this->getFields())
115			));
116
117			$statement->bindValue(':id', $id);
118			$statement->bindValue(':data', serialize($data), SQLITE3_BLOB);
119			$statement->bindValue(':expire', $lifeTime > 0 ? time() + $lifeTime : null);
120
121			return $statement->execute() instanceof SQLite3Result;
122			}
123
124			/**
125			* {@inheritdoc}
126			*/
127			protected function doDelete($id)
128			{
129			list($idField) = $this->getFields();
130
131			$statement = $this->sqlite->prepare(sprintf(
132			'DELETE FROM %s WHERE %s = :id',
133			$this->table,
134			$idField
135			));
136
137			$statement->bindValue(':id', $id);
138
139			return $statement->execute() instanceof SQLite3Result;
140			}
141
142			/**
143			* {@inheritdoc}
144			*/
145			protected function doFlush()
146			{
147			return $this->sqlite->exec(sprintf('DELETE FROM %s', $this->table));
148			}
149
150			/**
151			* {@inheritdoc}
152			*/
153			protected function doGetStats()
154			{
155			// no-op.
156			}
157
158			/**
159			* Find a single row by ID.
160			*
161			* @param mixed $id
162			* @param bool $includeData
163			*
164			* @return array\|null
165			*/
166			private function findById($id, $includeData = true)
167			{
168			list($idField) = $fields = $this->getFields();
169
170			if (!$includeData) {
171			$key = array_search(static::DATA_FIELD, $fields);
172			unset($fields[$key]);
173			}
174
175			$statement = $this->sqlite->prepare(sprintf(
176			'SELECT %s FROM %s WHERE %s = :id LIMIT 1',
177			implode(',', $fields),
178			$this->table,
179			$idField
180			));
181
182			$statement->bindValue(':id', $id, SQLITE3_TEXT);
183
184			$item = $statement->execute()->fetchArray(SQLITE3_ASSOC);
185
186			if ($item === false) {
187			return null;
188			}
189
190			if ($this->isExpired($item)) {
191			$this->doDelete($id);
192
193			return null;
194			}
195
196			return $item;
197			}
198
199			/**
200			* Gets an array of the fields in our table.
201			*
202			* @return array
203			*/
204			private function getFields()
205			{
206			return [static::ID_FIELD, static::DATA_FIELD, static::EXPIRATION_FIELD];
207			}
208
209			/**
210			* Check if the item is expired.
211			*
212			* @param array $item
213			*
214			* @return bool
215			*/
216			private function isExpired(array $item)
217			{
218			return isset($item[static::EXPIRATION_FIELD]) &&
219			$item[self::EXPIRATION_FIELD] !== null &&
220			$item[self::EXPIRATION_FIELD] < time();
221			}
222			}
223

doctrine / cache

Push — master ( 8f6a24...fe68e4 )

SQLite3Cache::isExpired() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like