Dbal::escapeValue() - Code Metrics - Inspection of "Feature dbal" - tflori/orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#36)

by Thomas

created 2017-05-18 07:14 UTC

Dbal::escapeValue() C

↳ Parent: Dbal

Complexity

Conditions	7
Paths	7

Size

Total Lines	22
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	13
CRAP Score	7

Importance

Changes

Metric	Value
dl	0
loc	22
ccs	13
cts	13
cp	1
rs	6.9811
c	0
b	0
f	0
cc	7
eloc	14
nc	7
nop	1
crap	7

<?php

namespace ORM\Dbal;

use ORM\Entity;
use ORM\EntityManager;
use ORM\Exceptions\NotScalar;
use ORM\Exceptions\UnsupportedDriver;

/**
 * Base class for database abstraction
 *
 * @package ORM
 * @author  Thomas Flori <[email protected]>
 */
abstract class Dbal
{
    /** @var EntityManager */
    protected $em;
    /** @var string[] */
    protected static $registeredTypes = [];

    /** @var string */
    protected static $quotingCharacter = '"';
    /** @var string */
    protected static $identifierDivider = '.';
    /** @var string */
    protected static $booleanTrue = '1';
    /** @var string */
    protected static $booleanFalse = '0';

    /**
     * Dbal constructor.
     *
     * @param EntityManager $entityManager
     */
    public function __construct(EntityManager $entityManager)
    {
        $this->em = $entityManager;
    }

    /**
     * Returns $identifier quoted for use in a sql statement
     *
     * @param string $identifier Identifier to quote
     * @return string
     */
    public function escapeIdentifier($identifier)
    {
        $q = static::$quotingCharacter;
        $d = static::$identifierDivider;
        return $q . str_replace($d, $q . $d . $q, $identifier) . $q;
    }

    /**
     * Returns $value formatted to use in a sql statement.
     *
     * @param  mixed  $value The variable that should be returned in SQL syntax
     * @return string
     * @throws NotScalar
     */
    public function escapeValue($value)
    {
        switch (strtolower(gettype($value))) {
            case 'string':
                return $this->em->getConnection()->quote($value);

            case 'integer':
                return (string) $value;

            case 'double':
                return (string) $value;

            case 'null':
                return 'NULL';

            case 'boolean':
                return ($value) ? static::$booleanTrue : static::$booleanFalse;

            default:
                throw new NotScalar('$value has to be scalar data type. ' . gettype($value) . ' given');
        }
    }

    /**
     * Describe a table
     *
     * @param string $table
     * @return Column[]
     * @throws UnsupportedDriver
     */
    public function describe($table)
    {
        throw new UnsupportedDriver('Not supported for this driver');
    }

    /**
     * Inserts $entity and returns the new ID for autoincrement or true
     *
     * @param Entity $entity
     * @param bool   $useAutoIncrement
     * @return mixed
     * @throws UnsupportedDriver
     */
    public function insert($entity, $useAutoIncrement = true)
    {
        $statement = $this->buildInsertStatement($entity);

        if ($useAutoIncrement && $entity::isAutoIncremented()) {
            throw new UnsupportedDriver('Auto incremented column for this driver is not supported');
        }

        $this->em->getConnection()->query($statement);
        $this->em->sync($entity, true);
        return true;
    }

    /**
     * Update $entity in database
     *
     * @param Entity $entity
     * @return bool
     * @internal
     */
    public function update(Entity $entity)
    {
        $data = $entity->getData();
        $primaryKey = $entity->getPrimaryKey();

        $where = [];
        foreach ($primaryKey as $var => $value) {
            $col = $entity::getColumnName($var);
            $where[] = $this->escapeIdentifier($col) . ' = ' . $this->escapeValue($value);
            if (isset($data[$col])) {
                unset($data[$col]);
            }
        }

        $set = [];
        foreach ($data as $col => $value) {
            $set[] = $this->escapeIdentifier($col) . ' = ' . $this->escapeValue($value);
        }

        $statement = 'UPDATE ' . $this->escapeIdentifier($entity::getTableName()) . ' ' .
                     'SET ' . implode(',', $set) . ' ' .
                     'WHERE ' . implode(' AND ', $where);
        $this->em->getConnection()->query($statement);

        return true;
    }

    /**
     * Delete $entity from database
     *
     * This method does not delete from the map - you can still receive the entity via fetch.
     *
     * @param Entity $entity
     * @return bool
     */
    public function delete(Entity $entity)
    {
        $primaryKey = $entity->getPrimaryKey();
        $where = [];
        foreach ($primaryKey as $var => $value) {
            $col = $entity::getColumnName($var);
            $where[] = $this->escapeIdentifier($col) . ' = ' . $this->escapeValue($value);
        }

        $statement = 'DELETE FROM ' . $this->escapeIdentifier($entity::getTableName()) . ' ' .
                     'WHERE ' . implode(' AND ', $where);
        $this->em->getConnection()->query($statement);

        return true;
    }

    /**
     * Register $type for describe
     *
     * @param string $type The full qualified class name
     */
    public static function registerType($type)
    {
        if (!in_array($type, static::$registeredTypes)) {
            array_unshift(static::$registeredTypes, $type);
        }
    }

    /**
     * @param string $char
     */
    public static function setQuotingCharacter($char)
    {
        static::$quotingCharacter = $char;
    }

    /**
     * @param string $divider
     */
    public static function setIdentifierDivider($divider)
    {
        static::$identifierDivider = $divider;
    }

    /**
     * @param string $true
     */
    public static function setBooleanTrue($true)
    {
        static::$booleanTrue = $true;
    }

    /**
     * @param string $false
     */
    public static function setBooleanFalse($false)
    {
        static::$booleanFalse = $false;
    }

    /**
     * @return string
     */
    public static function getQuotingCharacter()
    {
        return static::$quotingCharacter;
    }

    /**
     * @return string
     */
    public static function getIdentifierDivider()
    {
        return static::$identifierDivider;
    }

    /**
     * @return string
     */
    public static function getBooleanTrue()
    {
        return static::$booleanTrue;
    }

    /**
     * @return string
     */
    public static function getBooleanFalse()
    {
        return static::$booleanFalse;
    }

    /**
     * Build the insert statement for $entity
     *
     * @param Entity $entity
     * @return string
     */
    protected function buildInsertStatement($entity)
    {
        $data = $entity->getData();

        $cols = array_map(function ($key) {
            return $this->escapeIdentifier($key);
        }, array_keys($data));

        $values = array_map(function ($value) use ($entity) {
            return $this->escapeValue($value);
        }, array_values($data));

        $statement = 'INSERT INTO ' . $this->escapeIdentifier($entity::getTableName()) . ' ' .
                     '(' . implode(',', $cols) . ') VALUES (' . implode(',', $values) . ')';

        return $statement;
    }

    /**
     * Normalize $type
     *
     * The type returned by mysql is for example VARCHAR(20) - this function converts it to varchar
     *
     * @param string $type
     * @return string
     */
    protected function normalizeType($type)
    {
        $type = strtolower($type);

        if (($p = strpos($type, '(')) !== false && $p > 0) {
            $type = substr($type, 0, $p);
        }

        return $type;
    }

    /**
     * Extract content from parenthesis in $type
     *
     * @param string $type
     * @return string
     */
    protected function extractParenthesis($type)
    {
        if (preg_match('/\(([\d,]+)\)/', $type, $match)) {
            return $match[1];
        }

        return null;
    }

    /**
     * Get the type for $columnDefinition
     *
     * Executes fromDefinition of each registered Type
     *
     * @param array $columnDefinition
     * @return TypeInterface
     */
    protected function getType($columnDefinition)
    {
        foreach (self::$registeredTypes as $class) {
            if ($type = $class::fromDefinition($columnDefinition)) {
                return $type;
            }
        }

        return new Type\Text();
    }
}


1		<?php
2
3		namespace ORM\Dbal;
4
5		use ORM\Entity;
6		use ORM\EntityManager;
7		use ORM\Exceptions\NotScalar;
8		use ORM\Exceptions\UnsupportedDriver;
9
10		/**
11		* Base class for database abstraction
12		*
13		* @package ORM
14		* @author Thomas Flori <[email protected]>
15		*/
16		abstract class Dbal
17		{
18		/** @var EntityManager */
19		protected $em;
20		/** @var string[] */
21		protected static $registeredTypes = [];
22
23		/** @var string */
24		protected static $quotingCharacter = '"';
25		/** @var string */
26		protected static $identifierDivider = '.';
27		/** @var string */
28		protected static $booleanTrue = '1';
29		/** @var string */
30		protected static $booleanFalse = '0';
31
32		/**
33		* Dbal constructor.
34		*
35		* @param EntityManager $entityManager
36		*/
37	603	public function __construct(EntityManager $entityManager)
38		{
39	603	$this->em = $entityManager;
40	603	}
41
42		/**
43		* Returns $identifier quoted for use in a sql statement
44		*
45		* @param string $identifier Identifier to quote
46		* @return string
47		*/
48	167	public function escapeIdentifier($identifier)
49		{
50	167	$q = static::$quotingCharacter;
51	167	$d = static::$identifierDivider;
52	167	return $q . str_replace($d, $q . $d . $q, $identifier) . $q;
53		}
54
55		/**
56		* Returns $value formatted to use in a sql statement.
57		*
58		* @param mixed $value The variable that should be returned in SQL syntax
59		* @return string
60		* @throws NotScalar
61		*/
62	162	public function escapeValue($value)
63		{
64	162	switch (strtolower(gettype($value))) {
65	162	case 'string':
66	119	return $this->em->getConnection()->quote($value);
67
68	57	case 'integer':
69	49	return (string) $value;
70
71	8	case 'double':
72	4	return (string) $value;
73
74	4	case 'null':
75	1	return 'NULL';
76
77	3	case 'boolean':
78	2	return ($value) ? static::$booleanTrue : static::$booleanFalse;
79
80		default:
81	1	throw new NotScalar('$value has to be scalar data type. ' . gettype($value) . ' given');
82		}
83		}
84
85		/**
86		* Describe a table
87		*
88		* @param string $table
89		* @return Column[]
90		* @throws UnsupportedDriver
91		*/
92	1	public function describe($table)
93		{
94	1	throw new UnsupportedDriver('Not supported for this driver');
95		}
96
97		/**
98		* Inserts $entity and returns the new ID for autoincrement or true
99		*
100		* @param Entity $entity
101		* @param bool $useAutoIncrement
102		* @return mixed
103		* @throws UnsupportedDriver
104		*/
105	2	public function insert($entity, $useAutoIncrement = true)
106		{
107	2	$statement = $this->buildInsertStatement($entity);
108
109	2	if ($useAutoIncrement && $entity::isAutoIncremented()) {
110	1	throw new UnsupportedDriver('Auto incremented column for this driver is not supported');
111		}
112
113	1	$this->em->getConnection()->query($statement);
114	1	$this->em->sync($entity, true);
115	1	return true;
116		}
117
118		/**
119		* Update $entity in database
120		*
121		* @param Entity $entity
122		* @return bool
123		* @internal
124		*/
125	6	public function update(Entity $entity)
126		{
127	6	$data = $entity->getData();
128	6	$primaryKey = $entity->getPrimaryKey();
129
130	6	$where = [];
131	6	foreach ($primaryKey as $var => $value) {
132	6	$col = $entity::getColumnName($var);
133	6	$where[] = $this->escapeIdentifier($col) . ' = ' . $this->escapeValue($value);
134	6	if (isset($data[$col])) {
135	6	unset($data[$col]);
136		}
137		}
138
139	6	$set = [];
140	6	foreach ($data as $col => $value) {
141	6	$set[] = $this->escapeIdentifier($col) . ' = ' . $this->escapeValue($value);
142		}
143
144	6	$statement = 'UPDATE ' . $this->escapeIdentifier($entity::getTableName()) . ' ' .
145	6	'SET ' . implode(',', $set) . ' ' .
146	6	'WHERE ' . implode(' AND ', $where);
147	6	$this->em->getConnection()->query($statement);
148
149	3	return true;
150		}
151
152		/**
153		* Delete $entity from database
154		*
155		* This method does not delete from the map - you can still receive the entity via fetch.
156		*
157		* @param Entity $entity
158		* @return bool
159		*/
160	6	public function delete(Entity $entity)
161		{
162	6	$primaryKey = $entity->getPrimaryKey();
163	6	$where = [];
164	6	foreach ($primaryKey as $var => $value) {
165	6	$col = $entity::getColumnName($var);
166	6	$where[] = $this->escapeIdentifier($col) . ' = ' . $this->escapeValue($value);
167		}
168
169	6	$statement = 'DELETE FROM ' . $this->escapeIdentifier($entity::getTableName()) . ' ' .
170	6	'WHERE ' . implode(' AND ', $where);
171	6	$this->em->getConnection()->query($statement);
172
173	4	return true;
174		}
175
176		/**
177		* Register $type for describe
178		*
179		* @param string $type The full qualified class name
180		*/
181	7	public static function registerType($type)
182		{
183	7	if (!in_array($type, static::$registeredTypes)) {
184	7	array_unshift(static::$registeredTypes, $type);
185		}
186	7	}
187
188		/**
189		* @param string $char
190		*/
191	17	public static function setQuotingCharacter($char)
192		{
193	17	static::$quotingCharacter = $char;
194	17	}
195
196		/**
197		* @param string $divider
198		*/
199	17	public static function setIdentifierDivider($divider)
200		{
201	17	static::$identifierDivider = $divider;
202	17	}
203
204		/**
205		* @param string $true
206		*/
207	17	public static function setBooleanTrue($true)
208		{
209	17	static::$booleanTrue = $true;
210	17	}
211
212		/**
213		* @param string $false
214		*/
215	17	public static function setBooleanFalse($false)
216		{
217	17	static::$booleanFalse = $false;
218	17	}
219
220		/**
221		* @return string
222		*/
223	1	public static function getQuotingCharacter()
224		{
225	1	return static::$quotingCharacter;
226		}
227
228		/**
229		* @return string
230		*/
231	1	public static function getIdentifierDivider()
232		{
233	1	return static::$identifierDivider;
234		}
235
236		/**
237		* @return string
238		*/
239	1	public static function getBooleanTrue()
240		{
241	1	return static::$booleanTrue;
242		}
243
244		/**
245		* @return string
246		*/
247	1	public static function getBooleanFalse()
248		{
249	1	return static::$booleanFalse;
250		}
251
252		/**
253		* Build the insert statement for $entity
254		*
255		* @param Entity $entity
256		* @return string
257		*/
258	11	protected function buildInsertStatement($entity)
259		{
260	11	$data = $entity->getData();
261
262		$cols = array_map(function ($key) {
263	11	return $this->escapeIdentifier($key);
264	11	}, array_keys($data));
265
266	11	$values = array_map(function ($value) use ($entity) {
267	11	return $this->escapeValue($value);
268	11	}, array_values($data));
269
270	11	$statement = 'INSERT INTO ' . $this->escapeIdentifier($entity::getTableName()) . ' ' .
271	11	'(' . implode(',', $cols) . ') VALUES (' . implode(',', $values) . ')';
272
273	11	return $statement;
274		}
275
276		/**
277		* Normalize $type
278		*
279		* The type returned by mysql is for example VARCHAR(20) - this function converts it to varchar
280		*
281		* @param string $type
282		* @return string
283		*/
284	65	protected function normalizeType($type)
285		{
286	65	$type = strtolower($type);
287
288	65	if (($p = strpos($type, '(')) !== false && $p > 0) {
289	23	$type = substr($type, 0, $p);
290		}
291
292	65	return $type;
293		}
294
295		/**
296		* Extract content from parenthesis in $type
297		*
298		* @param string $type
299		* @return string
300		*/
301	9	protected function extractParenthesis($type)
302		{
303	9	if (preg_match('/\(([\d,]+)\)/', $type, $match)) {
304	4	return $match[1];
305		}
306
307	5	return null;
308		}
309
310		/**
311		* Get the type for $columnDefinition
312		*
313		* Executes fromDefinition of each registered Type
314		*
315		* @param array $columnDefinition
316		* @return TypeInterface
317		*/
318	13	protected function getType($columnDefinition)
319		{
320	13	foreach (self::$registeredTypes as $class) {
321	4	if ($type = $class::fromDefinition($columnDefinition)) {
322	4	return $type;
323		}
324		}
325
326	12	return new Type\Text();
327		}
328		}
329

tflori / orm

Pull Request — master (#36)

Dbal::escapeValue() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like