1040

pending completion

Build # 1040

Build Type

Pull #266

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/nextras/orm/commit/<a class=hub.com/nextras/orm/commit/dbcf1bf2751550cffaaa861db859f8a4e602b2fb">dbcf1bf27<a href="https://github.com/nextras/orm/commit/dbcf1bf2751550cffaaa861db859f8a4e602b2fb">&quot;&gt;Revert &amp;quot;update onLoad entity allowing set virtual property if isset in data from query result&quot;

This reverts commit </a><a class="double-link" href="https://github.com/nextras/orm/commit/<a class="double-link" href="https://github.com/nextras/orm/commit/cbc5c28d1e13da3293054bda0c593a5ef0fd7918">cbc5c28d1</a>">cbc5c28d1</a><a href="https://github.com/nextras/orm/commit/dbcf1bf2751550cffaaa861db859f8a4e602b2fb">.

Pull Request Pull Request #266: update adding select into query builder instead of replacing existing

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

3213 of 3460 relevant lines covered (92.86%)

0.93 hits per line

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

91.54

/src/Mapper/Dbal/StorageReflection/StorageReflection.php

<?php declare(strict_types = 1);

/**
 * This file is part of the Nextras\Orm library.
 * @license    MIT
 * @link       https://github.com/nextras/orm
 */

namespace Nextras\Orm\Mapper\Dbal\StorageReflection;

use Nette\Caching\Cache;
use Nette\SmartObject;
use Nextras\Dbal\IConnection;
use Nextras\Dbal\Platforms\CachedPlatform;
use Nextras\Dbal\Platforms\IPlatform;
use Nextras\Orm;
use Nextras\Orm\InvalidArgumentException;
use Nextras\Orm\InvalidStateException;
use Nextras\Orm\NotSupportedException;


abstract class StorageReflection implements IStorageReflection
{
        use SmartObject;


        /** @const keys for mapping cache */
        const TO_STORAGE = 0;
        const TO_ENTITY = 1;

        /** @var string */
        public $manyHasManyStorageNamePattern = '%s_x_%s';

        /** @var string */
        protected $storageName;

        /** @var array */
        protected $mappings;

        /** @var array */
        protected $modifiers;

        /** @var array */
        protected $entityPrimaryKey = [];

        /** @var array */
        protected $storagePrimaryKey = [];

        /** @var IPlatform */
        protected $platform;


        public function __construct(IConnection $connection, $storageName, array $entityPrimaryKey, Cache $cache)
        {
                $this->platform = new CachedPlatform($connection->getPlatform(), $cache->derive('db_reflection'));
                $this->storageName = $storageName;
                $this->entityPrimaryKey = $entityPrimaryKey;

                $cache = $cache->derive('storage_reflection');
                $this->mappings = $cache->load('nextras.orm.storage_reflection.' . md5($this->storageName) . '.mappings', function () {
                        return $this->getDefaultMappings();
                });
                $this->modifiers = $cache->load('nextras.orm.storage_reflection.' . md5($this->storageName) . '.modifiers', function () {
                        return $this->getDefaultModifiers();
                });
        }


        public function getStorageName(): string
        {
                return $this->storageName;
        }


        public function getStoragePrimaryKey(): array
        {
                if (!$this->storagePrimaryKey) {
                        $primaryKeys = [];
                        foreach ($this->platform->getColumns($this->storageName) as $column => $meta) {
                                if ($meta['is_primary']) {
                                        $primaryKeys[] = $column;
                                }
                        }
                        if (count($primaryKeys) === 0) {
                                throw new InvalidArgumentException("Storage '$this->storageName' has not defined any primary key.");
                        }
                        $this->storagePrimaryKey = $primaryKeys;
                }

                return $this->storagePrimaryKey;
        }


        public function convertEntityToStorage(array $in): array
        {
                $out = [];
                foreach ($in as $key => $val) {
                        if (isset($this->mappings[self::TO_STORAGE][$key][0])) {
                                $newKey = $this->mappings[self::TO_STORAGE][$key][0];
                        } else {
                                $newKey = $this->convertEntityToStorageKey($key);
                        }
                        if (isset($this->modifiers[$newKey])) {
                                $newKey .= $this->modifiers[$newKey];
                        }
                        if (isset($this->mappings[self::TO_STORAGE][$key][1])) {
                                $converter = $this->mappings[self::TO_STORAGE][$key][1];
                                $out[$newKey] = $converter($val, $newKey);
                        } else {
                                $out[$newKey] = $val;
                        }
                }

                return $out;
        }


        public function convertStorageToEntity(array $in): array
        {
                $out = [];
                foreach ($in as $key => $val) {
                        if (isset($this->mappings[self::TO_ENTITY][$key][0])) {
                                $newKey = $this->mappings[self::TO_ENTITY][$key][0];
                        } else {
                                $newKey = $this->convertStorageToEntityKey($key);
                        }
                        if (isset($this->mappings[self::TO_ENTITY][$key][1])) {
                                $converter = $this->mappings[self::TO_ENTITY][$key][1];
                                $out[$newKey] = $converter($val, $newKey);
                        } else {
                                $out[$newKey] = $val;
                        }
                }

                return $out;
        }


        public function convertStorageToEntityKey(string $key): string
        {
                if (!isset($this->mappings[self::TO_ENTITY][$key][0])) {
                        $this->mappings[self::TO_ENTITY][$key] = [$this->formatEntityKey($key)];
                }

                return $this->mappings[self::TO_ENTITY][$key][0];
        }


        public function convertEntityToStorageKey(string $key): string
        {
                if (!isset($this->mappings[self::TO_STORAGE][$key][0])) {
                        $this->mappings[self::TO_STORAGE][$key] = [$this->formatStorageKey($key)];
                }

                return $this->mappings[self::TO_STORAGE][$key][0];
        }


        /**
         * @return string|null
         */
        public function getPrimarySequenceName()
        {
                return $this->platform->getPrimarySequenceName($this->storageName);
        }


        public function getManyHasManyStorageName(Orm\StorageReflection\IStorageReflection $targetStorageReflection): string
        {
                return sprintf(
                        $this->manyHasManyStorageNamePattern,
                        $this->storageName,
                        preg_replace('#^(.*\.)?(.*)$#', '$2', $targetStorageReflection->getStorageName())
                );
        }


        public function getManyHasManyStoragePrimaryKeys(Orm\StorageReflection\IStorageReflection $targetStorageReflection): array
        {

                $one = $this->getStoragePrimaryKey()[0];
                $two = $targetStorageReflection->getStoragePrimaryKey()[0];
                if ($one !== $two) {
                        return [$one, $two];
                }

                return $this->findManyHasManyPrimaryColumns(
                        $this->getManyHasManyStorageName($targetStorageReflection),
                        $this->storageName,
                        $targetStorageReflection->getStorageName()
                );
        }


        /**
         * Adds mapping.
         * @throws InvalidStateException Throws exception if mapping was already defined.
         */
        public function addMapping(string $entity, string $storage, callable $toEntityCb = null, callable $toStorageCb = null): StorageReflection
        {
                if (isset($this->mappings[self::TO_ENTITY][$storage])) {
                        throw new InvalidStateException("Mapping for $storage column is already defined.");
                } elseif (isset($this->mappings[self::TO_STORAGE][$entity])) {
                        throw new InvalidStateException("Mapping for $entity property is already defined.");
                }

                $this->mappings[self::TO_ENTITY][$storage] = [$entity, $toEntityCb];
                $this->mappings[self::TO_STORAGE][$entity] = [$storage, $toStorageCb];
                return $this;
        }


        /**
         * Sets mapping.
         */
        public function setMapping(string $entity, string $storage, callable $toEntityCb = null, callable $toStorageCb = null): StorageReflection
        {
                unset($this->mappings[self::TO_ENTITY][$storage], $this->mappings[self::TO_STORAGE][$entity]);
                return $this->addMapping($entity, $storage, $toEntityCb, $toStorageCb);
        }


        /**
         * Adds parameter modifier for data-trasform to Nextras Dbal layer.
         */
        public function addModifier(string $storageKey, string $saveModifier): StorageReflection
        {
                $this->modifiers[$storageKey] = $saveModifier;
                return $this;
        }


        protected function findManyHasManyPrimaryColumns($joinTable, $sourceTable, $targetTable): array
        {
                $useFQN = strpos($sourceTable, '.') !== false;
                $keys = $this->platform->getForeignKeys($joinTable);
                foreach ($keys as $column => $meta) {
                        $table = $useFQN
                                ? $meta['ref_table']
                                : preg_replace('#^(.*\.)?(.*)$#', '$2', $meta['ref_table']);

                        if ($table === $sourceTable && !isset($sourceId)) {
                                $sourceId = $column;
                        } elseif ($table === $targetTable) {
                                $targetId = $column;
                        }
                }

                if (!isset($sourceId, $targetId)) {
                        throw new InvalidStateException("No primary keys detected for many has many '{$joinTable}' join table.");
                }

                return [$sourceId, $targetId];
        }


        protected function getDefaultMappings(): array
        {
                $mappings = [self::TO_STORAGE => [], self::TO_ENTITY => []];

                $columns = array_keys($this->platform->getForeignKeys($this->storageName));
                foreach ($columns as $storageKey) {
                        $entityKey = $this->formatEntityForeignKey($storageKey);
                        $mappings[self::TO_ENTITY][$storageKey] = [$entityKey, null];
                        $mappings[self::TO_STORAGE][$entityKey] = [$storageKey, null];
                }

                $storagePrimaryKey = $this->getStoragePrimaryKey();
                if (count($this->entityPrimaryKey) !== count($storagePrimaryKey)) {
                        throw new InvalidStateException(
                                'Mismatch count of entity primary key (' . implode(', ', $this->entityPrimaryKey)
                                . ') with storage primary key (' . implode(', ', $storagePrimaryKey) . ').'
                        );
                }

                if (count($storagePrimaryKey) === 1) {
                        $entityKey = $this->entityPrimaryKey[0];
                        $storageKey = $storagePrimaryKey[0];
                        $mappings[self::TO_ENTITY][$storageKey] = [$entityKey, null];
                        $mappings[self::TO_STORAGE][$entityKey] = [$storageKey, null];
                }

                return $mappings;
        }


        protected function getDefaultModifiers(): array
        {
                $modifiers = [];

                switch ($this->platform->getName()) {
                        case 'pgsql':
                                $types = ['TIMESTAMP' => true];
                                break;

                        case 'mysql':
                                $types = ['DATETIME' => true];
                                break;

                        case 'mssql':
                                $types = ['TIMESTAMP' => true];
                                break;

                        default:
                                throw new NotSupportedException();
                }

                foreach ($this->platform->getColumns($this->storageName) as $column) {
                        if (isset($types[$column['type']])) {
                                $modifiers[$column['name']] = $column['is_nullable'] ? '%?dts' : '%dts';
                        }
                }

                return $modifiers;
        }


        abstract protected function formatStorageKey(string $key): string;


        abstract protected function formatEntityKey(string $key): string;


        abstract protected function formatEntityForeignKey(string $key): string;
}

1	<?php declare(strict_types = 1);
2
3	/**
4	* This file is part of the Nextras\Orm library.
5	* @license MIT
6	* @link https://github.com/nextras/orm
7	*/
8
9	namespace Nextras\Orm\Mapper\Dbal\StorageReflection;
10
11	use Nette\Caching\Cache;
12	use Nette\SmartObject;
13	use Nextras\Dbal\IConnection;
14	use Nextras\Dbal\Platforms\CachedPlatform;
15	use Nextras\Dbal\Platforms\IPlatform;
16	use Nextras\Orm;
17	use Nextras\Orm\InvalidArgumentException;
18	use Nextras\Orm\InvalidStateException;
19	use Nextras\Orm\NotSupportedException;
20
21
22	abstract class StorageReflection implements IStorageReflection	1✔
23	{
24	use SmartObject;
25
26
27	/** @const keys for mapping cache */
28	const TO_STORAGE = 0;
29	const TO_ENTITY = 1;
30
31	/** @var string */
32	public $manyHasManyStorageNamePattern = '%s_x_%s';
33
34	/** @var string */
35	protected $storageName;
36
37	/** @var array */
38	protected $mappings;
39
40	/** @var array */
41	protected $modifiers;
42
43	/** @var array */
44	protected $entityPrimaryKey = [];
45
46	/** @var array */
47	protected $storagePrimaryKey = [];
48
49	/** @var IPlatform */
50	protected $platform;
51
52
53	public function __construct(IConnection $connection, $storageName, array $entityPrimaryKey, Cache $cache)	1✔
54	{
55	$this->platform = new CachedPlatform($connection->getPlatform(), $cache->derive('db_reflection'));	1✔
56	$this->storageName = $storageName;	1✔
57	$this->entityPrimaryKey = $entityPrimaryKey;	1✔
58
59	$cache = $cache->derive('storage_reflection');	1✔
60	$this->mappings = $cache->load('nextras.orm.storage_reflection.' . md5($this->storageName) . '.mappings', function () {	1✔
61	return $this->getDefaultMappings();	1✔
62	});	1✔
63	$this->modifiers = $cache->load('nextras.orm.storage_reflection.' . md5($this->storageName) . '.modifiers', function () {	1✔
64	return $this->getDefaultModifiers();	1✔
65	});	1✔
66	}	1✔
67
68
69	public function getStorageName(): string
70	{
71	return $this->storageName;	1✔
72	}
73
74
75	public function getStoragePrimaryKey(): array
76	{
77	if (!$this->storagePrimaryKey) {	1✔
78	$primaryKeys = [];	1✔
79	foreach ($this->platform->getColumns($this->storageName) as $column => $meta) {	1✔
80	if ($meta['is_primary']) {	1✔
81	$primaryKeys[] = $column;	1✔
82	}
83	}
84	if (count($primaryKeys) === 0) {	1✔
85	throw new InvalidArgumentException("Storage '$this->storageName' has not defined any primary key.");	×
86	}
87	$this->storagePrimaryKey = $primaryKeys;	1✔
88	}
89
90	return $this->storagePrimaryKey;	1✔
91	}
92
93
94	public function convertEntityToStorage(array $in): array	1✔
95	{
96	$out = [];	1✔
97	foreach ($in as $key => $val) {	1✔
98	if (isset($this->mappings[self::TO_STORAGE][$key][0])) {	1✔
99	$newKey = $this->mappings[self::TO_STORAGE][$key][0];	1✔
100	} else {
101	$newKey = $this->convertEntityToStorageKey($key);	1✔
102	}
103	if (isset($this->modifiers[$newKey])) {	1✔
104	$newKey .= $this->modifiers[$newKey];	1✔
105	}
106	if (isset($this->mappings[self::TO_STORAGE][$key][1])) {	1✔
107	$converter = $this->mappings[self::TO_STORAGE][$key][1];	1✔
108	$out[$newKey] = $converter($val, $newKey);	1✔
109	} else {
110	$out[$newKey] = $val;	1✔
111	}
112	}
113
114	return $out;	1✔
115	}
116
117
118	public function convertStorageToEntity(array $in): array	1✔
119	{
120	$out = [];	1✔
121	foreach ($in as $key => $val) {	1✔
122	if (isset($this->mappings[self::TO_ENTITY][$key][0])) {	1✔
123	$newKey = $this->mappings[self::TO_ENTITY][$key][0];	1✔
124	} else {
125	$newKey = $this->convertStorageToEntityKey($key);	1✔
126	}
127	if (isset($this->mappings[self::TO_ENTITY][$key][1])) {	1✔
128	$converter = $this->mappings[self::TO_ENTITY][$key][1];	1✔
129	$out[$newKey] = $converter($val, $newKey);	1✔
130	} else {
131	$out[$newKey] = $val;	1✔
132	}
133	}
134
135	return $out;	1✔
136	}
137
138
139	public function convertStorageToEntityKey(string $key): string	1✔
140	{
141	if (!isset($this->mappings[self::TO_ENTITY][$key][0])) {	1✔
142	$this->mappings[self::TO_ENTITY][$key] = [$this->formatEntityKey($key)];	1✔
143	}
144
145	return $this->mappings[self::TO_ENTITY][$key][0];	1✔
146	}
147
148
149	public function convertEntityToStorageKey(string $key): string	1✔
150	{
151	if (!isset($this->mappings[self::TO_STORAGE][$key][0])) {	1✔
152	$this->mappings[self::TO_STORAGE][$key] = [$this->formatStorageKey($key)];	1✔
153	}
154
155	return $this->mappings[self::TO_STORAGE][$key][0];	1✔
156	}
157
158
159	/**
160	* @return string\|null
161	*/
162	public function getPrimarySequenceName()
163	{
164	return $this->platform->getPrimarySequenceName($this->storageName);	1✔
165	}
166
167
168	public function getManyHasManyStorageName(Orm\StorageReflection\IStorageReflection $targetStorageReflection): string	1✔
169	{
170	return sprintf(	1✔
171	$this->manyHasManyStorageNamePattern,	1✔
172	$this->storageName,	1✔
173	preg_replace('#^(.\.)?(.)$#', '$2', $targetStorageReflection->getStorageName())	1✔
174	);
175	}
176
177
178	public function getManyHasManyStoragePrimaryKeys(Orm\StorageReflection\IStorageReflection $targetStorageReflection): array	1✔
179	{
180
181	$one = $this->getStoragePrimaryKey()[0];	1✔
182	$two = $targetStorageReflection->getStoragePrimaryKey()[0];	1✔
183	if ($one !== $two) {	1✔
184	return [$one, $two];	×
185	}
186
187	return $this->findManyHasManyPrimaryColumns(	1✔
188	$this->getManyHasManyStorageName($targetStorageReflection),	1✔
189	$this->storageName,	1✔
190	$targetStorageReflection->getStorageName()	1✔
191	);
192	}
193
194
195	/**
196	* Adds mapping.
197	* @throws InvalidStateException Throws exception if mapping was already defined.
198	*/
199	public function addMapping(string $entity, string $storage, callable $toEntityCb = null, callable $toStorageCb = null): StorageReflection	1✔
200	{
201	if (isset($this->mappings[self::TO_ENTITY][$storage])) {	1✔
202	throw new InvalidStateException("Mapping for $storage column is already defined.");	×
203	} elseif (isset($this->mappings[self::TO_STORAGE][$entity])) {	1✔
204	throw new InvalidStateException("Mapping for $entity property is already defined.");	1✔
205	}
206
207	$this->mappings[self::TO_ENTITY][$storage] = [$entity, $toEntityCb];	1✔
208	$this->mappings[self::TO_STORAGE][$entity] = [$storage, $toStorageCb];	1✔
209	return $this;	1✔
210	}
211
212
213	/**
214	* Sets mapping.
215	*/
216	public function setMapping(string $entity, string $storage, callable $toEntityCb = null, callable $toStorageCb = null): StorageReflection	1✔
217	{
218	unset($this->mappings[self::TO_ENTITY][$storage], $this->mappings[self::TO_STORAGE][$entity]);	1✔
219	return $this->addMapping($entity, $storage, $toEntityCb, $toStorageCb);	1✔
220	}
221
222
223	/**
224	* Adds parameter modifier for data-trasform to Nextras Dbal layer.
225	*/
226	public function addModifier(string $storageKey, string $saveModifier): StorageReflection	1✔
227	{
228	$this->modifiers[$storageKey] = $saveModifier;	1✔
229	return $this;	1✔
230	}
231
232
233	protected function findManyHasManyPrimaryColumns($joinTable, $sourceTable, $targetTable): array
234	{
235	$useFQN = strpos($sourceTable, '.') !== false;	1✔
236	$keys = $this->platform->getForeignKeys($joinTable);	1✔
237	foreach ($keys as $column => $meta) {	1✔
238	$table = $useFQN	1✔
239	? $meta['ref_table']	×
240	: preg_replace('#^(.\.)?(.)$#', '$2', $meta['ref_table']);	1✔
241
242	if ($table === $sourceTable && !isset($sourceId)) {	1✔
243	$sourceId = $column;	1✔
244	} elseif ($table === $targetTable) {	1✔
245	$targetId = $column;	1✔
246	}
247	}
248
249	if (!isset($sourceId, $targetId)) {	1✔
250	throw new InvalidStateException("No primary keys detected for many has many '{$joinTable}' join table.");	×
251	}
252
253	return [$sourceId, $targetId];	1✔
254	}
255
256
257	protected function getDefaultMappings(): array
258	{
259	$mappings = [self::TO_STORAGE => [], self::TO_ENTITY => []];	1✔
260
261	$columns = array_keys($this->platform->getForeignKeys($this->storageName));	1✔
262	foreach ($columns as $storageKey) {	1✔
263	$entityKey = $this->formatEntityForeignKey($storageKey);	1✔
264	$mappings[self::TO_ENTITY][$storageKey] = [$entityKey, null];	1✔
265	$mappings[self::TO_STORAGE][$entityKey] = [$storageKey, null];	1✔
266	}
267
268	$storagePrimaryKey = $this->getStoragePrimaryKey();	1✔
269	if (count($this->entityPrimaryKey) !== count($storagePrimaryKey)) {	1✔
270	throw new InvalidStateException(	1✔
271	'Mismatch count of entity primary key (' . implode(', ', $this->entityPrimaryKey)	1✔
272	. ') with storage primary key (' . implode(', ', $storagePrimaryKey) . ').'	1✔
273	);
274	}
275
276	if (count($storagePrimaryKey) === 1) {	1✔
277	$entityKey = $this->entityPrimaryKey[0];	1✔
278	$storageKey = $storagePrimaryKey[0];	1✔
279	$mappings[self::TO_ENTITY][$storageKey] = [$entityKey, null];	1✔
280	$mappings[self::TO_STORAGE][$entityKey] = [$storageKey, null];	1✔
281	}
282
283	return $mappings;	1✔
284	}
285
286
287	protected function getDefaultModifiers(): array
288	{
289	$modifiers = [];	1✔
290
291	switch ($this->platform->getName()) {	1✔
292	case 'pgsql':	×
293	$types = ['TIMESTAMP' => true];	1✔
294	break;	1✔
295
296	case 'mysql':	×
297	$types = ['DATETIME' => true];	1✔
298	break;	1✔
299
300	case 'mssql':	×
301	$types = ['TIMESTAMP' => true];	×
302	break;	×
303
304	default:
305	throw new NotSupportedException();	×
306	}
307
308	foreach ($this->platform->getColumns($this->storageName) as $column) {	1✔
309	if (isset($types[$column['type']])) {	1✔
310	$modifiers[$column['name']] = $column['is_nullable'] ? '%?dts' : '%dts';	1✔
311	}
312	}
313
314	return $modifiers;	1✔
315	}
316
317
318	abstract protected function formatStorageKey(string $key): string;
319
320
321	abstract protected function formatEntityKey(string $key): string;
322
323
324	abstract protected function formatEntityForeignKey(string $key): string;
325	}

nextras / orm / 1040

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